最新公告
  • 欢迎您光临极客文库,本站秉承服务宗旨 履行“站长”责任,销售只是起点 服务永无止境!立即加入我们
  • 如何理解代理模式?

    思考抽象问题最好的办法就是具体化!
    比如我们需要为一个业务方法在执行前后记录日志,为了达到解耦的目的,我们可以再新建一个类并定义一个新的业务方法,该方法既可以调用原业务方法,又可以在调用前后进行日志处理,例如:
    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 = “rn”;
           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
    本站所有文章均由网友分享,仅用于参考学习用,请勿直接转载,如有侵权,请联系网站客服删除相关文章。若由于商用引起版权纠纷,一切责任均由使用者承担
    极客文库 » 深入理解[代理模式]原理与技术

    常见问题FAQ

    免费下载或者VIP会员专享资源能否直接商用?
    本站所有资源版权均属于原作者所有,这里所提供资源均只能用于参考学习用,请勿直接商用。若由于商用引起版权纠纷,一切责任均由使用者承担。更多说明请参考 VIP介绍。
    提示下载完但解压或打开不了?
    最常见的情况是下载不完整: 可对比下载完压缩包的与网盘上的容量,若小于网盘提示的容量则是这个原因。这是浏览器下载的bug,建议用百度网盘软件或迅雷下载。若排除这种情况,可在对应资源底部留言,或 联络我们.。
    找不到素材资源介绍文章里的示例图片?
    对于PPT,KEY,Mockups,APP,网页模版等类型的素材,文章内用于介绍的图片通常并不包含在对应可供下载素材包内。这些相关商业图片需另外购买,且本站不负责(也没有办法)找到出处。 同样地一些字体文件也是这种情况,但部分素材会在素材包内有一份字体下载链接清单。
    极客文库
    程序员的加油站

    Leave a Reply

    Hi, 如果你对这款模板有疑问,可以跟我联系哦!

    联系发布者

    Leave a Reply

    Hi, 如果你对这款模板有疑问,可以跟我联系哦!

    联系发布者
    • 99会员总数(位)
    • 3629资源总数(个)
    • 44本周发布(个)
    • 0 今日发布(个)
    • 105稳定运行(天)

    欢迎加入「极客文库」,成为原创作者从这里开始!

    立即加入 了解更多