深入理解设计模式之 [ 代理模式 ]

来自:程序员柯南(微信号:codekn),作者:像风一样



计划写一个 [ 设计模式 ] 专栏,这一次先更新两篇。觉得不错,底部赞赏!


01
理解代理模式



代理模式的定义:为其他对象提供一种代理以控制对这个对象的访问。

代理模式是23种常用的面向对象软件的设计模式之一,具体又分为静态代理、动态代理。

如何理解代理模式?

思考抽象问题最好的办法就是具体化!

比如我们需要为一个业务方法在执行前后记录日志,为了达到解耦的目的,我们可以再新建一个类并定义一个新的业务方法,该方法既可以调用原业务方法,又可以在调用前后进行日志处理,例如:

    CarProxy.class

   public void move() {
       System.out.println("日志开始记录....");
       new Car().move();
       System.out.println("日志记录完成....");
   }

代理模式的应用很多,比如Spring容器的延迟加载,AOP增强处理等。


02
静态代理



静态代理是由程序员创建或工具生成代理类的源码,再编译代理类。

所谓静态也就是在程序运行前就已经存在代理类的字节码文件,代理类和委托类的关系在运行前就确定了。

一句话,自己手写代理类就是静态代理。

基于继承的静态代理

目标对象:定义一个普通方法

public class Car {

   public void move() {
       System.out.println("1.汽车开始跑步");
       System.out.println("2.汽车跑到了终点");
   }

}

代理对象:主要作用是继承目标对象,进行增强处理,并使用关键字super调用父类方法。

public class CarProxy extends Car {

   @Override
   public void move() {
       System.out.println("日志开始记录....");
       super.move();
       System.out.println("日志记录完成....");
   }

}

测试方法:实际上是调用代理对象的move()方法。

    public static void main(String[] args) {
       Car car = new CarProxy();
       car.move();
   }

基于接口的静态代理

共同接口:定义一个普通的接口方法

public interface Moveable {
   void move();
}

目标对象:实现该接口方法。

public class Car implements Moveable {

   @Override
   public void move() {
       System.out.println("汽车行驶中....");
   }

}

代理对象:调用目标对象的方法,并在调用前后进行增强处理。

public class CarProxy implements Moveable{
   private Moveable move;
   
   @Override
   public void move() {
       if(move==null){
           move = new Car();
       }
       System.out.println("开始记录日志:");
       move.move();
       System.out.println("记录日志结束!");
       
   }
}

测试方法:实际上是调用代理对象的move()方法。

    public static void main(String[] args) throws Exception {
       Moveable m =new CarProxy();
       m.move();
   }

静态代理的优缺点

优点

业务类只需要关注业务逻辑本身,保证了业务类的重用性。这是代理模式的共有优点。

缺点

1)代理对象的一个接口只服务于一种类型的对象,如果要代理的类型很多,势必要为每一种类型的方法都进行代理,静态代理在程序规模稍大时就无法胜任了。

比如Car类的move()方法需要记录日志,如果还有汽车,火车,自行车类的move()方法也需要记录日志,我们都要一个个的去为它们生成代理类,太麻烦了。

2)如果接口增加一个方法,除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。显而易见,增加了代码维护的复杂度。 


03
动态代理



动态代理是在实现阶段不用关心代理类,而在运行阶段才指定哪一个对象。

动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成 。

简单来说,动态代理就是交给程序去自动生成代理类。

JDK的动态代理

JDK动态代理实现步骤:

  1. 创建被代理的类以及实现的接口;

  2. 创建一个实现接口InvocationHandler的类,它必须实现invoke方法;

  3. 调用Proxy的newProxyInstance静态方法,创建一个代理类。

  4. 通过代理对象调用目标方法。

代码示例

共同接口

public interface Moveable {
   String move();
}

目标对象:正常实现接口方法

public class Car implements Moveable {

   @Override
   public String move() {
       return "汽车行驶中";
   }

}

对目标对象的增强处理:

public class LogHandler implements InvocationHandler{
   private Object target;
   
   public LogHandler(Object object){
       super();
       this.target =  object;
   }

   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       //增强处理
       Object o = method.invoke(target,args);
       //增强处理
       return o;
   }

}

实现InvocationHandler接口步骤:

1.定义含参构造方法,该参数为要代理的实例对象,目的是用于执行method.invoke()方法(也就是执行目标方法)

2.实现接口的invoke()方法,该方法用于对目标方法的增强处理,比如记录日志等。该方法的返回值就是代理对象执行目标方法的返回值。具体参数:

    proxy 动态生成的代理对象

    method 目标方法的实例

    args 目标方法的参数

测试方法:

public static void main(String[] args) {
   Moveable move =  (Moveable) Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(), new LogHandler(new Car()));
   
   System.out.println("代理对象:"+move.getClass().getName());
   System.out.println("执行方法:"+move.move());
}

通过调用Proxy.newProxyInstance方法生成代理对象,具体参数有:

  1. loader 目标类的类加载器

  2. interfaces 目标类实现的接口

  3. InvocationHandler 调用处理程序的实现对象

打印结果

代理对象:com.sun.proxy.$Proxy0
执行方法:汽车行驶中

值得一提的是,JDK动态代理针对每个代理对象都会有一个关联的调用处理程序,即实现InvocationHandler接口。当在代理对象上调用目标方法时,将对方法调用进行编码并将其分配给其实现 InvocationHandler 接口的 invoke 方法。

特点

JDK的动态代理只能代理实现了接口的类, 没有实现接口的类不能实现动态代理。



cglib的动态代理

引用cglib的依赖包

<dependency>
   <groupId>cglib</groupId>
   <artifactId>cglib-nodep</artifactId>
   <version>2.2</version>
</dependency>

为了方便思考它的原理,我把执行步骤按顺序写下

    public static void main(String[] args) {
       Enhancer enhancer = new Enhancer();
       //设置父类,被代理类(这里是Car.class)
       enhancer.setSuperclass(Car.class);
       //设置回调函数
       enhancer.setCallback(new MethodInterceptor() {
           @Override
           public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
               //增强处理...
               Object o= proxy.invokeSuper(obj, args);//代理类调用父类的方法
               //增强处理...
               return o;
           }
       });
       //创建代理类并使用回调(用父类Car去引用)
       Car car = (Car) enhancer.create();
       //执行目标方法
       System.out.println(car.move());
   }

方法拦截器

实现MethodInterceptor接口的intercept方法后,所有生成的代理方法都调用这个方法。

intercept方法的具体参数有

  1. obj 目标类的实例

  2. method 目标方法实例(通过反射获取的目标方法实例)

  3. args 目标方法的参数

  4. proxy 代理类的实例

该方法的返回值就是目标方法的返回值。

特点

  1. cglib的动态代理是针对类来实现代理。

  2. 对指定目标类产生一个子类,通过方法拦截技术拦截所有父类方法的调用。

  3. 因为是通过继承实现,final类无法使用。


04
手写JDK动态代理源码



从上面可以看到JDK动态代理的核心代码在于Proxy.newProxyInstance方法。

Moveable m = (Moveable)Proxy.newProxyInstance(Car.class,new InvocationHandler());

实现原理

  1. 声明一段源码,源码动态产生动态代理

  2. 源码产生java文件,对java文件进行编译

  3. 得到编译生成后的class文件

  4. 把class文件load到内存之中,产生代理类对象返回即可。

下面附我手写的源码!

生产代理对象类,核心类!难点,思路都在这里~

public class Proxy {

   /**
    * 生产代理对象
    * @param clazz
    * @param h
    * @return
    * @throws Exception
    */

   public static Object newProxyInstance(Class clazz,InvocationHandler h) throws Exception{
       //代理类类名
       String cname = clazz.getName().substring(clazz.getName().lastIndexOf(".")+1) + "$Proxy0";
       //手写代理类源码
       StringBuilder source = getSource(clazz, h, cname);
       //产生代理类的java文件
       String filename = Thread.currentThread().getContextClassLoader().getResource("").getPath()
               + clazz.getPackage().getName().replaceAll("\\.", "/") +"/"+cname+".java";
       System.out.println(filename);
       //把源码写入到文件中
       File file = new File(filename);
       FileUtil.writeStringToFile(file, source.toString());
       //编译
       //拿到编译器
       JavaCompiler complier = ToolProvider.getSystemJavaCompiler();
       //文件管理者
       StandardJavaFileManager fileMgr =
               complier.getStandardFileManager(null, null, null);
       //获取文件
       Iterable units = fileMgr.getJavaFileObjects(filename);
       //编译任务
       CompilationTask t = complier.getTask(null, fileMgr, null, null, null, units);
       //进行编译
       t.call();
       fileMgr.close();
       //load 到内存
       ClassLoader cl = ClassLoader.getSystemClassLoader();
       Class<?> c = cl.loadClass(clazz.getPackage().getName() + "."+cname);
       //获取构造函数Constructor
       Constructor<?> ctr = c.getConstructor(h.getClass());
       return ctr.newInstance(h);
   }

   /**
    * 手写代理类源码
    * @param clazz
    * @param h
    * @param cname
    * @return
    */

   private static StringBuilder getSource(Class clazz, InvocationHandler h, String cname) {
       //调用处理接口
       String handler = h.getClass().getName();
       //换行符号
       String line = "\r\n";
       String space = " ";
       //代理类源码
       StringBuilder source = new StringBuilder();
       //包声明
       source.append("package" + space + clazz.getPackage().getName() + ";").append(line);
       //获取类的名称
       source.append(Modifier.toString(clazz.getModifiers()) + space + "class" + space + cname + space);
       //继承接口
       source.append("implements" + space);
       Class[] interfaces = clazz.getInterfaces();
       for (int i = 0; i < interfaces.length; i++) {
           source.append(interfaces[i].getName());
           if (i != interfaces.length - 1) {
               source.append(",");
           }
       }
       source.append("{").append(line);
       //声明变量
       source.append("private " + handler + " h;").append(line);
       //构造方法
       source.append("public " + cname + "(" + handler + " h){").append(line);
       source.append("this.h=h;").append(line).append("}").append(line);
       //实现所有方法
       Method[] methods = clazz.getDeclaredMethods();
       for (Method method : methods) {
           //获取方法返回类型
           Class returnType = method.getReturnType();
           //获取方法上的所有注释
           Annotation[] annotations = method.getDeclaredAnnotations();
           for (Annotation annotation : annotations) {
               //打印注释类型
               source.append("@" + annotation.annotationType().getName()).append(line);
           }
           //打印方法声明
           source.append(Modifier.toString(method.getModifiers()) + " " + returnType.getName() + " " + method.getName() + "(");
           //获取方法的所有参数
           Parameter[] parameters = method.getParameters();
           //参数字符串
           StringBuilder args = new StringBuilder();
           for (int i = 0; i < parameters.length; i++) {
               //参数的类型,形参(全是arg123..)
               source.append(parameters[i].getType().getName() + " " + parameters[i].getName());
               args.append(parameters[i].getName());
               if (i != parameters.length - 1) {
                   source.append(",");
                   args.append(",");
               }
           }
           source.append("){").append(line);
           //方法逻辑
           source.append("Object obj=null; \n try {").append(line);
           source.append("Class[] args = new Class[]{" + args + "};").append(line);
           source.append(Method.class.getName()+" method = " + clazz.getName() + ".class.getMethod(\"" + method.getName() + "\",args);").append(line);
           source.append("obj = h.invoke(this,method,args);").append(line);
           source.append("} catch (Exception e) {\n" + "e.printStackTrace();\n" + "}catch (Throwable throwable) {\n" +
                   "throwable.printStackTrace();\n" + "}").append(line);
           //方法结束
           source.append("return (obj!=null)?("+returnType.getName()+")obj:null;\n}").append(line);
       }
       //类结束
       source.append("}");
       return source;
   }


}

单元测试

    public static void main(String[] args) throws Exception {
       Moveable m = (Moveable) Proxy.newProxyInstance(Car.class, new TimeHandler(new Car()));
       String s = m.move();
       System.out.println(s);
   }

测试结果

/D:/IDEA/workSpace/myJdkProxy/target/classes/cn/zyzpp/client/Car$Proxy0.java
开始记录时间
汽车行驶中....
耗时:481毫秒!
success

我只测试了部分,有bug在所难免啦~~~!项目地址:

https://gitee.com/zyzpp/myJdkProxy

推荐↓↓↓
Java编程
上一篇:你知道Java的四种引用类型吗? 下一篇:深入理解设计模式之[Future模式]