04_Spring AOP两种代理方法

什么是AOP?

          AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

应用场合：事务管理、性能监视、安全检查、缓存 、日志等。

Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码。

AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码。

纵向继承：

横向抽取：

AOP底层将采用代理机制实现

1.接口 + 实现类 ：spring采用 jdk 的动态代理Proxy。

2.实现类：spring 采用 cglib字节码增强代理。

代码实现：在增删改方法之前，增加事务处理（开启事物，提交事物），前提不修改当前类。

userService.java

public interface userService {
    void save();
    void delete();
    void update();
    void find();
}

userServiceImpl.java

@Component("userService")
public class userServiceImpl implements userService{
    //增强

    public void save() {
       
        System.out.println("保存用户");
        
    }


    public void delete() {
        //
        System.out.println("删除用户");
        //
    }


    public void update() {
        
        System.out.println("修改用户");
    }


    public void find() {
        System.out.println("查找用户");
    }

}

1)JDK 动态代理

jdk动态代理实现主要靠Proxy类和InvocationHandler接口来实现。

userServiceProxyFactory.java 

public class userServiceProxyFactory implements InvocationHandler{
	//代理对象
	private userService us;
	
	public userServiceProxyFactory(userService us){
		super();
		this.us=us;
	}
	//返回代的对象   
	//参数1，类加载器  参数2，代理类的接口 参数3.实现增强的代码(对原方法增强的一个方法)
	public userService getUserServiceProxy(){
		return (UserService)Proxy.newProxyInstance(userServiceProxyFactory.class.getClassLoader(),
				UuerServiceImpl.class.getInterfaces(),this);
		
	}
	@Override
	//参数1，代理对象    参数2，原代理对象的方法  参数3，代理方法的参数
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//增强
		System.out.println("开启事务");   //前置通知 
		Object invoke = method.invoke(us, args);   //调用原方法（切入点）  + (通知) = 切面
		System.out.println("提交事务");  //后置通知
		return invoke;
	}

}

测试代码:

public class Mytest {

    @Test//动态代理
    public void test(){
        userService us = new userServiceImpl();
        userServiceProxyFactory factory = new userServiceProxyFactory(us);
        userService userServiceProxy = factory.getUserServiceProxy();//返回代理后的对象
        //未使用jdk动态代理
        us.save();
        System.out.println("--------------------------");
        //使用动态代理对象
        userServiceProxy.save();
    }
}

2)CGLIB代理

public class UserServiceProxyFactory2 {
	//代理对象
	/*private UserService us;
	
	public UserServiceProxyFactory2(UserService us){
		super();
		this.us=us;
	}*/
	//返回代理对象
	public UserService getUserServiceProxy(){
		Enhancer en  = new Enhancer();  //帮我们生成代理对象
		en.setSuperclass(UserServiceImpl.class);
		en.setCallback(new MethodInterceptor() {
			@Override
			//参数1，目标对象  参数2，目标对象的方法  参数3，方法中参数  参数4 代理方法
			public Object intercept(Object proxyObj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
				System.out.println("开启事务");
				//目标方法调用
				//Ojbect invoke = method.invoke(us, args)
				Object invokeSuper = methodProxy.invokeSuper(proxyObj, args);
				System.out.println("提交事务");
				
				return invokeSuper;
			}
		});
		UserService us = (UserService) en.create();  //创建代理对象
		return us;
	}
}

测试代码

public class Mytest {

 
    @Test
    public void test2(){
        UserServiceProxyFactory2 factory = new UserServiceProxyFactory2();
        UserService userServiceProxy = factory.getUserServiceProxy();
        UserServiceProxy.save();
    }
    
}