Java设计模式之代理模式_代理模式是最常用的java设计模式特征是代理类和委托类有相同的接口-优快云博客

本文链接：https://blog.youkuaiyun.com/Codefarmer_uzi/article/details/117287231

概述

代理模式是常用的java设计模式
他的特征是代理类与委托类有同样的接口
代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等
代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途

静态代理

静态代理：由程序员创建或特定工具自动生成源代码，也就是在编译时就已经将接口，被代理类，代理类等确定下来
在程序运行之前，代理类的.class文件就已经生成

动态代理

动态代理：代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的
相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法

JDK动态代理

在java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象
缺点：被代理的类必须是接口的实现类（依赖于接口），如果某些类没有实现接口则不能用jdk代理
通过反射的机制来调用被拦截方法的，反射的效率比较低
为什么Java动态代理必须是接口
反射生成的代理类，默认会继承 Proxy类，由于java是单继承，多实现
因此要实现对象的方法，只能实现对象的接口，而不能继承

实现

/**
	在运行期动态创建一个 interface 实例的方法如下
 		定义一个 InvocationHandler 实例，它负责实现接口的方法调用
 		通过 Proxy.newProxyInstance() 创建 interface 实例，它需要3个参数
	 	将返回的 Object 强制转型为接口
*/
public class ProxyHandler implements InvocationHandler {

    private Object tar;

    public Object bind(Object tar) {
        this.tar = tar;
        /**
        	参数
        		1.使用的 ClassLoader ，通常就是接口类的 ClassLoader 
   				2.需要实现的接口数组，至少需要传入一个接口进去
  				3.用来处理接口方法调用的 InvocationHandler 实例
        */
        return Proxy.newProxyInstance(tar.getClass().getClassLoader(),
                                      tar.getClass().getInterfaces(),
                                       this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;

        result = method.invoke(tar,args);

        return result;
    }
}

public class TestProxy {
    public static void main(String[] args) {
        ProxyHandler proxy = new ProxyHandler();

        Subject sub = (Subject) proxy.bind(new RealSubject());
        sub.doSomething();
    }
}

cglib动态代理

原理是针对target类，生成一个子类，继承父类所有的公开方法，重写这些方法，在重写时对这些方法增强
CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类
采用了FastClass的机制来实现对被拦截方法的调用
FastClass机制就是对一个类的方法建立索引，通过索引来直接调用相应的方法
示例

/**
	Test2是Test的Fastclass，在Test2中有两个方法getIndex和invoke
	在getIndex方法中对Test的每个方法建立索引，并根据入参（方法名+方法的描述符）来返回相应的索引
	Invoke根据指定的索引，以ol为入参调用对象O的方法。这样就避免了反射调用，提高了效率
*/
public class test10 {
    public static void main(String[] args){
        Test tt = new Test();
        Test2 fc = new Test2();
        int index = fc.getIndex("f()V");
        fc.invoke(index, tt, null);
    }
}

class Test{
    public void f(){
        System.out.println("f method");
    }
    
    public void g(){
        System.out.println("g method");
    }
}
class Test2{
    public Object invoke(int index, Object o, Object[] ol){
        Test t = (Test) o;
        switch(index){
        case 1:
            t.f();
            return null;
        case 2:
            t.g();
            return null;
        }
        return null;
    }
    
    public int getIndex(String signature){
        switch(signature.hashCode()){
        case 3078479:
            return 1;
        case 3108270:
            return 2;
        }
        return -1;
    }
}

缺点：基于继承，无法代理final类(final类无法被继承，如String)
实现

/**
	生成目标类Target的代理类的方法如下
		创建Enhancer实例
 		通过setSuperclass方法来设置目标类
 		通过setCallback 方法来设置拦截对象
 		create方法生成Target的代理类，并返回代理类的实例
*/
public class Client {
  public static void main(String[] args) {
	//设置cglib生成的源码目录
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\");
	// 创建Enhancer实例
    Enhancer enhancer = new Enhancer();
	//设置父类
    enhancer.setSuperclass(Singer.class);
	//设置方法拦截处理器
    enhancer.setCallback(new SingerMethodInterceptor());
	//创建代理对象
    Singable singable = (Singable) enhancer.create();
    singable.sing();
  }

  public static class SingerMethodInterceptor implements MethodInterceptor {

    /**
    	参数：
    		1.obj表示增强的对象，即实现这个接口类的一个对象
    		2.method表示要被拦截的方法
    		3.args表示要被拦截方法的参数
    		4.proxy表示要触发父类的方法对象
    */
    @Override
    public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
      System.out.println("cglib before");
      Object result = methodProxy.invokeSuper(obj, objects);
      System.out.println("cglib after");
      return result;
    }
  }
}

SpringAOP 动态代理的实现

假设目标对象的实现类实现了接口，则使用JDK 动态代理来生成 AOP 代理类
假设目标对象的实现类没有实现接口，则使用 CGLIB 来生成 AOP 代理类

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
            return new JdkDynamicAopProxy(config);
        } else {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
            } else {
                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
            }
        }
    }
}