动态代理

主要用来做方法的增强，让你可以在不修改源码的情况下，增强一些方法，在方法执行前后做任何你想做的事情 
代理对象UserServiceProxy 
import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

public class UserServiceProxy implements InvocationHandler{

//继承接口

private Object object;//声明一个对象
 
public UserServiceProxy(Object object) { 

//创建对象构造函数，方便赋值

this.object = object; 

} 

@Override 
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //实现接口对象方法

System.out.println("开始登录"); //添加事件

Object o = method.invoke(object, args); //利用反射执行原始方法

System.out.println("结束登录"); //添加事件

return o; //返回原始对象结果

}
}


测试

public class Test {

public static void main(String[] args) { 

//真实调用的方法 

UserServiceImpl serviceImpl = new UserServiceImpl(); 

//创建代理对象 

UserServiceProxy proxy = new UserServiceProxy(serviceImpl); 

//返回真实的代理对象 

UserService service = (UserService) Proxy.newProxyInstance(serviceImpl.getClass().getClassLoader(), serviceImpl.getClass().getInterfaces(), proxy); 

service.a(); //执行方法

}

}
原始对象

public class UserController {

 UserService userService; 

 public String loginDo() { 

 userService.login("", "");

 return null; 
 }
}
面向切面编程：事物 Spring的核心，是对面向对象思维的有力补充 
web.xml

 xmlns:aop="http://www.springframework.org/schema/aop"

 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop.xsd"

 <aop:aspectj-autoproxy/>
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect//织入
public class PointCut {

//切入点 

@Pointcut("execution (public !void com.UserServiceImpl.*(..))") 
public void userssss() { } 

//之前执行 

@Before("userssss()")


public void before() {
 
System.out.println("开始执行"); 

} 

//* finally的时候执行  
  
@After("userssss()") 
public void after() { 

System.out.println("after"); 

} 

//* 返回的时候执行    
@AfterReturning("userssss()") 
public void afterReturning() { 

System.out.println("afterReturning"); 

} 

//* 抛异常的时候执行 

@AfterThrowing("userssss()") 
public void afterThrowing() { 

System.out.println("afterThrowing"); 

} 

//* 之前之后都执行 

@Around("userssss()") 
public void around(ProceedingJoinPoint pjp) throws Throwable { 

System.out.println("around-之前"); 

pjp.proceed(); 

System.out.println("around-之后"); 

  } 
}