海创软件组-20200420-AOP-动态代理

AOP

…AOP（Aspect Oriented Programming)，面向切面编程，是面向对象编程OOP的一种补充.面向对象编程是从静态角度考虑程序的结构,而面向切面编程是从动态角度考虑程序运行过程，AOP 底层，就是采用动态代理模式实现的。采用了两种代理：JDK 的动态代理，与 CGLIB的动态代理。
…动态代理的意义在于生成一个占位（又称代理对象， 来代理真实对象，从而控制真实对象的访问。

代理模式

…假设这样一个个场景,你的公司是家软件公司，你是软件工程师。客户带着需求去找公司显然不会直接和你谈，而是去找商务谈，此时客户会认为商务就代表公司。显然客户是通过商务去访问软件工程师的，那么商务（代理对象）的意义在于什么呢?商务可以进行谈判，比如项目启动前的商务谈判 软件的价格、交付、进度的时间节点等，或者项目完成后的商务追讨应收账款等。商务也有可能在开发软件之前谈判失败，此时商务就会根据公司规 去结束和客户的合作关系，这些都不用软件工程师来处理。
…因此，代理的作用就是，在真实对象访问之前或者之后加入对应的逻辑，或者根据其规则控制是否使用真实对象，显然在这个例子里商务控制了客户对软件工程师的访问。
…经过上面的论述，我知道商务和软件工程师是代理和被代理的关系 客户是经过商务去访问软件工程师的。此时客户就是程序中的调用者，商务就是代理对象 软件工程师就是真实对象。我 需要在调用者调用对象之前产生 个代理对象，而这个代理对象需要和真实对象建立代理关系，所以代理必须分为两个步骤代理：1）对象和真实对象建立代理关系；2）实现代理对象的代理逻辑方法
…Java 中有多种动态代理技术，目前 Spring 常用 JDK、CGLIB 。

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP

public interface ISomeService {
  void doFirst();
  void doSecond();
}

​public class SomeServiceImpl implements ISomeService{  
  public void doFirst(){
        System.out.println("执行dofirst");
}
    public void doSecond(){
        System.out.println("执行doSecond");

}
}
​​​

​//切面
public class MyAspect {
	public void before( ) {

	System.out.println("执行before");
	}

	public void log( ) {
		System.out.println("执行后log");
	}

	void after(){
		System.out.println("执行after " );
	}
	}
	

​​
创建代理对象

​public class JDKProxy implements InvocationHandler {

	// 声明目标类接口对象（真实对象）
	private ISomeService someService;
	//创建代理的方法，建立代理对象和真实对象的代理关系，并返回代理对象
	public Object creatProxy(ISomeService someService) {
		this.someService=someService;
		//类加载器
		ClassLoader cld=JDKProxy.class.getClassLoader();
		//被代理对象实现的所有接口
		Class[] claz=someService.getClass().getInterfaces();
		//使用代理类进行增强，返回代理后的对象
		return Proxy.newProxyInstance(cld, claz, this);
		}
		/**
		*​代理的逻辑方法，所有动态代理类的方法调用都交给该方法处理
                *proxy 是被代理的对象
                *method 是将要被执行的方法
                *args是执行方法时需要的参数
                *re​turn指返回代理对象
		*/
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         //创建一个切面
		MyAspect myAspect =new MyAspect();
		myAspect.before();
		//在目标类上调用方法并传入参数，相当于调用someService中的方法
		Object obj=method.invoke(someService, args);
		myAspect.after();
		myAspect.log();
		return obj;
		
		
	}

}


​​​

        @Test
	public void test01() {
		//创建代理对象
	JDKProxy jdkp=new JDKProxy();
	//创建目标对象
	ISomeService someService=new SomeServiceImpl();
	//从代理对象中获取增强后的目标对象，该对象是一个被代理的对象，它会进入代理的逻辑方法invoke中
	ISomeService text=(ISomeService)jdkp.creatProxy(someService);
	//执行方法
        text.doFirst();
        System.out.println("--------------------");
       text.doSecond();
       System.out.println("--------------------");
   
   }
	​

   

结果：

而这个时候因为是接口，Spring默认动态代理是JDK

2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

JDK 动态代理必须提供接口才能使用，有些不能提供接口的环境中，只能采用其他方技术， 比如 CGLIB 动态代理。 而有接口的时候也可以使用CGLIB动态代理。

​public class Cglib implements MethodInterceptor {

	
		// 声明目标类接口对象
		private ISomeService someService;
		//创建代理的方法，建立代理对象和真实对象的代理关系，并返回代理对象
		public Object creatProxy(ISomeService someService) {
			this.someService=someService;
		//创建一个动态类对象，即增强类对象
		Enhancer enhancer=new Enhancer();
		//确定需要增强的类，设置其父类
		enhancer.setSuperclass(someService.getClass());
		//确定代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor的方法
		enhancer.setCallback(this);
		//返回创建的代理对象
		return enhancer.create();
	}
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //创建一个切面
		MyAspect myAspect=new MyAspect();
		myAspect.before();
		//目标方法执行，返回代理结果
		Object obj=methodProxy.invokeSuper(proxy,args);
		myAspect.after();
		myAspect.log();
		return obj;
	}

}
​

​	@Test
	public void test01() {
		//创建代理对象
	Cglib cglib=new Cglib();
	//创建目标对象
	ISomeService someService=new SomeServiceImpl();
	//从代理对象中获取增强后的目标对象，该对象是一个被代理的对象，它会进入代理的逻辑方法invoke中
	ISomeService text=(ISomeService)cglib.creatProxy(someService);
	//执行方法
    text.doFirst();
    System.out.println("--------------------");
    text.doSecond();
    System.out.println("--------------------");
   	}}

运行的结果一样，但代理不一样了

3、如果目标对象没有实现了接口，则必须采用CGLIB

​public class SomeService {

	public void doFirst(){
		System.out.println("执行dofirst");
}
	public void doSecond(){
		System.out.println("执行doSecond");
	}
}​

​//切面
public class MyAspect {
 
 	public void before( ) {
		
		System.out.println("执行before");
	}
	public void log( ) {
		System.out.println("执行后log");
	}

	void after(){
		System.out.println("执行after " );
	}	
}

​public class Cglib implements MethodInterceptor {

	public Object creatProxy(Object target) {
		//创建一个动态类对象，即增强类对象
		Enhancer enhancer=new Enhancer();
		//确定需要增强的类，设置其父类
		enhancer.setSuperclass(target.getClass());
		//确定代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor的方法
		enhancer.setCallback(this);
		//返回创建的代理对象
		return enhancer.create();
	}
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //创建一个切面
		MyAspect myAspect=new MyAspect();
		myAspect.before();
		//目标方法执行，返回代理结果
		Object obj=methodProxy.invokeSuper(proxy,args);
		myAspect.after();
		myAspect.log();
		return obj;
	}

}
​

​	@Test
	public void test01() {
		//创建代理对象
	Cglib cglib=new Cglib();
	//创建目标对象
	SomeService someService=new SomeService();
	//从代理对象中获取增强后的目标对象，该对象是一个被代理的对象，它会进入代理的逻辑方法invoke中
	SomeService text=(SomeService)cglib.creatProxy(someService);
	//执行方法
    text.doFirst();
    System.out.println("--------------------");
    text.doSecond();
    System.out.println("--------------------");
   	}}