深入理解[代理模式]原理与技术

栏目: 后端 · 发布时间: 6年前

内容简介:思考抽象问题最好的办法就是具体化!比如我们需要为一个业务方法在执行前后记录日志,为了达到解耦的目的,我们可以再新建一个类并定义一个新的业务方法,该方法既可以调用原业务方法,又可以在调用前后进行日志处理,例如:代理模式的应用很多,比如Spring容器的延迟加载,AOP增强处理等。

如何理解代理模式?

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

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

CarProxy.class

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

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

一、静态代理

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

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

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

基于继承的静态代理

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

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

二、动态代理

动态代理是在实现阶段不用关心代理类,而在运行阶段才指定哪一个对象。动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成 。

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

1、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()方法,该方法用于对目标方法的增强处理,比如记录日志等。该方法的返回值就是代理对象执行目标方法的返回值。

具体参数:

  1. proxy 动态生成的代理对象

  2. method 目标方法的实例

  3. 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的动态代理只能代理实现了接口的类, 没有实现接口的类不能实现动态代理。

2、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类无法使用。

三、手写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在所难免啦~~~!


以上所述就是小编给大家介绍的《深入理解[代理模式]原理与技术》,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对 码农网 的支持!

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

Learn Python the Hard Way

Learn Python the Hard Way

Zed A. Shaw / Addison-Wesley Professional / 2013-10-11 / USD 39.99

Master Python and become a programmer-even if you never thought you could! This breakthrough book and CD can help practically anyone get started in programming. It's called "The Hard Way," but it's re......一起来看看 《Learn Python the Hard Way》 这本书的介绍吧!

HTML 压缩/解压工具
HTML 压缩/解压工具

在线压缩/解压 HTML 代码

RGB转16进制工具
RGB转16进制工具

RGB HEX 互转工具

URL 编码/解码
URL 编码/解码

URL 编码/解码