Java | 动态代理及作用

Bertha 。 2023-09-25 20:44 47阅读 0赞

## 什么是代理 ##

代理实际上是一种处理问题的方式。在现实世界中，你登录不同的社交app去撩漂亮小姐姐，经过长时间的努力和你撩力值的提升，最终有一位小姐姐的心被你捕获，也终于有天，你们决定线下见面完成线下\#\#\#活动。于是，你俩一次又一次的完成线下\#\#\#活动。久而久之，你和小姐姐产生了深厚的情感，你俩觉得很舒服很开心，应该持续下去，于是她决定成为你的女友，一起奋(tong)斗(ju)。既然要奋(tong)斗(ju)了，那你俩得有住处，于是你积极的找房，终于在跑断双腿之前看中了倒数第二套房，房子的隔音效果比较好啊，也正是你俩想要的，可没想到有几个和你相同经历的朋友和你抢着看房：

![format_png][]

原来他们也是和你一样撩到妹之后，决定和妹子共同奋(tong)斗(ju)。但可惜，你们反复过去看房，搞得房东接待不过来，最后房东决定不租了！你只好重新去找房子，这次你学聪明了，不再去满大街跑，你把自己的租房要求告诉给了房屋中介，毕竟中介也是过来人，了解了你的需求，为了满足你和女友打(tong)拼(ju)生活，中介给你提供了隔音效果好的房子，正好这套房的房东年迈已高，就想躺着收租、和自己老婆看着小电影，于是，中介带着你去看房，房子隔音果然好啊，还有24小时热水，完全满足你的实际需求。中介带着你看房，还给你各种推销吹嘘，你看完之后，你和中介加了好友，中介告诉你其他租客也要找他看：

![format_png 1][]

最后，你为了和你爱的女友的未来，你果断决定租下了这套房子！房东也很开心，总算实现了躺床上和老婆看着小电影，手机每个月收到房租到账短信的理想生活。

由此可见，代理是日常生活中常见的模式，故事中的中介就是一个代理，他代理房东和租客之间的需求。

在软件开发中，代理模式是常用的结构型设计模式中的一种，特征是代理类与委托类有同样的接口，代理类主要负责提交请求给委托类的前后进行事件处理，比如：预处理消息、过滤消息，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并没有真正实现，而是通过调用委托类的对象的相关方法，来提供特定的服务。

## 代理模式结构 ##

以上故事在软件开发中结构如下：

![format_png 2][]

你带着女友，把上面结构用编码语言重新记录了下来，首先你创建了一个房东接口LandlordInterface，房东可以出租，也可以接待：

package com.mars;
    
    /**
     * Created by Mars酱
     */
    public interface LandlordInterface {
    	/** 出租房屋 */
        void rentHouse();
    
        /** 接待看房 */
        void reception();
    
    }
    复制代码

然后创建了一个房东的具体实现类 LandlordImpl，同时实现 LandlordInterface 接口：

package com.mars;
    
    /**
     * Created by Mars酱
     */
    public class LandlordImpl implements LandlordInterface {
    
    	/** 出租房屋 */
        @Override
        public void rentHouse(){
            System.out.println("出租：房子已租出。");
        }
            
    
        /** 接待看房 */
        @Override
        public void reception(){
            System.out.println("接待：欢迎参观");
        }
    }
    复制代码

你租下的那套房，房东是给中介代理了接待和出租，所以，在接待和出租前后都加上中介的服务，如下：

package com.mars;
    
    /**
     * Created by Mars酱
     */
    public class LandlordProxy implements LandlordInterface {
    
        private LandlordInterface impl;
    
        public LandlordProxy(LandlordInterface impl) {
            this.impl = impl;
        }
    
    	/** 出租房屋 */
        @Override
        public void rentHouse(){
            System.out.println("出租前：这是房子钥匙，请您拿好！");
            impl.rentHouse();
            System.out.println("出租后：祝您和女友过上自己想要的生活！");
        }
            
    
        /** 接待看房 */
        @Override
        public void reception(){
            System.out.println("接待前：您好，我是中介。我会带你去房子里面看看。");
            impl.reception();
            System.out.println("接待后：希望这套房子您能满意，毕竟隔音效果好。");
        }
    }
    复制代码

最后 ，你去看房，而且决定租下来了。

/**
     * Created by Mars酱
     */
    public class Renter {
    
        LandlordInterface landlordProxy = new LandlordProxy(new LandlordImpl());
        
        public void seeHouse(){
            // 中介接待你
            landlordProxy.reception();
        }
    
        public void iRentThisHouse(){
        	// 房子出租
            landlordProxy.rentHouse();
        }
    } 
    复制代码

写上main函数：

/**
     * Created by Mars酱
     */
    public static void main(String[] args) {
    	Renter you = new Renter();
    	you.seeHouse();
    	System.out.println(">> 看完房子，回去和女友商量了一番，如是决定了！");
    	you.iRentThisHouse();
    }
    复制代码

运行结果：

![format_png 3][]

## 静态代理 ##

以上故事的代码实现，其实就是静态代理的实现过程，中介持有房东需求，然后通过房东的基本需求，在接待和出租前后加上自己的服务实现静态代理。 但这个代理方式存在着问题：

*  当房东接口增加了需求，那么房东实现都要增加这个需求的实现。与此同时，中介代理也必须实现新增的房东接口的需求代理，这样对于房东和中介都不是很友好。
 *  中介代理目前只是对1个房东出租代理，假设添加一个厂房房东的实现，那么就要再增加对应的厂房中介代理，这样对代理类的维护也变得非常繁琐。

上面的问题在动态代理中就得到了比较好的解决。

## 动态代理 ##

先看下网上搜索出来的定义：

> 动态代理类与静态代理类最主要不同的是，代理类的字节码不是在程序运行前生成的，而是在程序运行时在虚拟机中程序自动创建的。
> 
> 其实动态代理与静态代理的本质一样，最终程序运行时都需要生成一个代理对象实例，通过它来完成相关增强以及业务逻辑，只不过静态代理需要硬编码的方式指定，而动态代理则是以动态方式生成代理(有编译时操作字节码生成的方式、运行时通过反射、字节码生成的式)。

由此可见，动态的好处很明显，代理逻辑与业务逻辑是互相独立的，没有耦合，代理1个类或100个类要做的事情没有任何区别。

在java中，常见的动态代理有两种：一种是JDK自带的动态代理，一种是CGLib的动态代理。

### JDK动态代理 ###

JDK动态代理是由JDK官方提供的代理方式，主要有`java.lang.reflect.Proxy`和`java.lang.reflect.InvocationHandler`两个类完成。

`java.lang.reflect.Proxy`：通过java反射，创建出代理类； `java.lang.reflect.InvocationHandler`：负责接口方法的调用；

LandlordInterface、LandlordImpl都不用变，动态代理是改变中介和租客部分的逻辑，上面故事使用JDK动态代理的代码实现：

/** Created by Mars酱 */
    /**
     * 代理服务
     *
     * @param landlordInterface LandlordInterface接口
     * @return InvocationHandler对象
     */
    private InvocationHandler proxyService(LandlordInterface landlordInterface) {
        return (proxy, method, args1) -> {
                // 如果是接待服务
            if (method.getName().equalsIgnoreCase("reception")) {
                System.out.println("接待前：您好，我是中介。我会带你去房子里面看看。");
                method.invoke(landlordInterface, args1);
                System.out.println("接待后：希望这套房子您能满意，毕竟隔音效果好。");
            }
            return null;
        };
    }
    
    /**
     * 动态创建对象
     *
     * @param invocationHandler InvocationHandler对象
     * @return	LandlordInterface对象	
     */
    private LandlordInterface getLandlord(InvocationHandler invocationHandler) {
        return (LandlordInterface) Proxy.newProxyInstance(LandlordInterface.class.getClassLoader(), new Class[]{LandlordInterface.class}, invocationHandler);
    }
    复制代码

再创建一个只有单间的房东对象：

/**
     * Created by Mars酱
     */
    public class LandlordSingleRoomImpl implements LandlordInterface {
        @Override
        public void rentHouse() {
            System.out.println("出租：单间房子已租出。");
        }
    
        @Override
        public void reception() {
            System.out.println("接待：欢迎参观，我们这里是单间，隔音效果很好");
        }
    }
    复制代码

写上main函数：

/**
     * Created by Mars酱
     */
    public static void main(String[] args) {
        RenterUseJDKProxy renterJDKProxy = new RenterUseJDKProxy();
        // 1. 代理看普通房东
        LandlordInterface normalLandlord = renterJDKProxy.getLandlord(renterJDKProxy.proxyService(new LandlordImpl()));
        normalLandlord.reception();
        System.out.println(">> 看完房子: 房子不太好，换一家");
        System.out.println();
        // 2. 代理看单间房东，听说隔音不错
        LandlordInterface singleRoomLandlord = renterJDKProxy.getLandlord(renterJDKProxy.proxyService(new LandlordSingleRoomImpl()));
        singleRoomLandlord.reception();
        System.out.println(">> 看完房子: 这房子不错，回去和女友商量下");
    
    }
    复制代码

执行结果：

![format_png 4][]

由此，用到JDK动态代理，需要实现的是InvocationHandler接口。那么，如果去实现InvocationHandler接口，是不是可以代理成功呢？试试看，我们创建一个不需要实现接口的房东类：

/**
     * Created by Mars酱
     */
    public class LandlordImpl2 {
    
        public void rentHouse() {
            System.out.println("出租2：房子已租出。");
        }
    
        public void reception() {
            System.out.println("接待2：欢迎参观");
        }
    }
    复制代码

再创建一个租客，再通过Proxy去调用：

/**
     * Created by Mars酱
     */
    public class Renter2UseJDKProxy {
    
        /**
         * 代理服务
         *
         * @param landlordInterface LandlordInterface接口
         * @return 调用程序
         */
        private InvocationHandler proxyService(LandlordImpl2 landlordInterface) {
            return (proxy, method, args1) -> {
                // 如果是接待服务
                if (method.getName().equalsIgnoreCase("reception")) {
                    System.out.println("接待前：您好，我是中介。我会带你去房子里面看看。");
                    method.invoke(landlordInterface, args1);
                    System.out.println("接待后：希望这套房子您能满意，毕竟隔音效果好。");
                }
                return null;
            };
        }
    
        /**
         * 动态创建中介对象
         *
         * @param invocationHandler
         * @return
         */
        private LandlordImpl2 getLandlord(InvocationHandler invocationHandler) {
            return (LandlordImpl2) Proxy.newProxyInstance(LandlordImpl2.class.getClassLoader(),
                    new Class[]{LandlordImpl2.class},
                    invocationHandler);
        }
    
    
        public static void main(String[] args) {
            Renter2UseJDKProxy renterJDKProxy = new Renter2UseJDKProxy();
            // 1. 代理看普通房东
            LandlordImpl2 landlord2 = renterJDKProxy.getLandlord(renterJDKProxy.proxyService(new LandlordImpl2()));
            landlord2.reception();
            System.out.println(">> 看完房子: 这房子不错，回去和女友商量下");
        }
    }
    复制代码

运行main函数：

![format_png 5][]

错误提示说我们的这个房东不是一个接口，那么看来使用JDK动态代理是必须要实现业务接口的。这样看来就不是太灵活了，有些房东想着轻松，会把房子代理给中介出租，有些人就想自己出租不喜欢中介，JDK动态代理就无法满足这种情况了。

### CGLib动态代理 ###

CGLib的定义，先看网上搜到的说明：

> CGLib (Code Generation Library) 是一个开源项目。是一个强大的、高性能、高质量的 Code 生成类库。它可以在运行期扩展 Java 类与实现 Java 接口。CGLib 比 Java 的 java.lang.reflect.Proxy 类更强的在于它**不仅可以接管接口类的方法**，**还可以接管普通类的方法**。
> 
> CGLib 的底层是 Java 字节码操作框架：ASM

CGLib的优势它自己写了，根据官方说明，只需要用到两个类：`net.sf.cglib.proxy.MethodInterceptor`和 `net.sf.cglib.proxy.Enhancer`，前者用来在被代理业务的前后添加自己的逻辑，后者负责生成动态代理类。那么我们来试下吧！兄弟们，上车~

/**
     * Created by Mars酱
     */
    public class RenterUseCglibProxy {
    
        public static void main(String[] args) {
            LandlordInterface normalLandlord = (LandlordInterface) cglibProxy(new LandlordImpl()).create();
            normalLandlord.reception();
            System.out.println(">>> 房子一般，我再看看!");
            System.out.println();
            LandlordInterface singleLandlord = (LandlordInterface) cglibProxy(new LandlordSingleRoomImpl()).create();
            singleLandlord.reception();
        }
    
        private static Enhancer cglibProxy(LandlordInterface landlordInterface) {
            Enhancer enhancer = new Enhancer();
            // 1.设置类加载
            enhancer.setClassLoader(landlordInterface.getClass().getClassLoader());
            // 2.设置被代理的类
            enhancer.setSuperclass(landlordInterface.getClass());
            // 3.设置好回调
            enhancer.setCallback((MethodInterceptor) (obj, method, params, methodProxy) -> {
                System.out.println("接待前：您好，我是中介。我会带你去房子里面看看。");
                Object result = methodProxy.invokeSuper(obj, params);
                System.out.println("接待后：希望这套房子您能满意。");
                return result;
            });
            // 4.创建代理类
            return enhancer;
        }
    }
    复制代码

运行之后的结果：

![format_png 6][]

效果符合。但是这里cglibProxy()传递的是LandlordInterface接口，那么cglib不是说好的可以代理普通类吗？前面的LandlordImpl2怎么处理呢？我们把cglib这里改造下吧

/**
     * Created by Mars酱
     */
    public class RenterUseCglibProxy {
    
        public static void main(String[] args) {
            LandlordInterface normalLandlord = (LandlordInterface) cglibProxy(LandlordImpl.class).create();
            normalLandlord.reception();
            System.out.println(">>> 房子一般，我再看看!");
            System.out.println();
            LandlordInterface singleLandlord = (LandlordInterface) cglibProxy(LandlordSingleRoomImpl.class).create();
            singleLandlord.reception();
            System.out.println(">>> 房子不错，但是我想再看看!");
            System.out.println();
            // 自己房子的房东返回的就是自己
            LandlordImpl2 singleLandlordSelf = (LandlordImpl2) cglibProxy(LandlordImpl2.class).create();
            // 然后自己做接待
            singleLandlordSelf.reception();
            System.out.println(">>> 房子不错，我想想再决定!");
        }
    
        /**
         * cglibProxy函数接受Class对象
         */
        private static Enhancer cglibProxy(Class clazz) {
            Enhancer enhancer = new Enhancer();
            enhancer.setClassLoader(clazz.getClassLoader());
            enhancer.setSuperclass(clazz);
            enhancer.setCallback((MethodInterceptor) (obj, method, params, methodProxy) -> {
                System.out.println("接待前：您好，我是中介。我会带你去房子里面看看。");
                Object result = methodProxy.invokeSuper(obj, params);
                System.out.println("接待后：希望这套房子您能满意。");
                return result;
            });
            return enhancer;
        }
    }
    复制代码

运行之后的结果：

![format_png 7][]

细心的朋友发现，最后那个接待语怎么还是用的中介的呢？那是因为自住房房东的接待方法和中介的一致，为了区别，我们可以再改造一下，cglib中有个回调过滤器`net.sf.cglib.proxy.CallbackFilter`，我们用这个过滤器处理一下自住房的房东接待语

/**
     * Created by Mars酱
     */
    private static Enhancer cglibProxy(Class clazz) {
    	Enhancer enhancer = new Enhancer();
    	enhancer.setClassLoader(clazz.getClassLoader());
    	enhancer.setSuperclass(clazz);
    	// 1. 创建两个回调，一个用来适用于中介，一个适用于自住房，数组索引从0开始
    	enhancer.setCallbacks(new Callback[]{(MethodInterceptor) (obj, method, params, methodProxy) -> {
                System.out.println("接待前：您好，我是中介。我会带你去房子里面看看。");
                Object result = methodProxy.invokeSuper(obj, params);
                System.out.println("接待后：希望这套房子您能满意。");
    	    return result;
    	}, (MethodInterceptor) (obj, method, params, methodProxy) -> {
                System.out.println("接待前：您好，我不是中介。今天我带你去我自己房子里面看看。");
                Object result = methodProxy.invokeSuper(obj, params);
                System.out.println("接待后：你什么时候有空就给我个答复。");
                return result;
        }});
    	// 2. 创建函数过滤器，如果是自己房子的函数，使用第二个回调函数，回调数组中索引为1
    	enhancer.setCallbackFilter(new CallbackFilter() {
                @Override
                public int accept(Method method) {
    		return (method.getName().equalsIgnoreCase("selfReception")) ? 1 : 0;
                }
    
                @Override
                public boolean equals(Object o) {
    		return false;
                }
        });
        return enhancer;
    }
    复制代码

同样的，自住房的房东接待函数名也改个名为:

/**
     * Created by Mars酱
     */
    // 原函数名为：reception()
    public void selfReception() {
        System.out.println("接待2：欢迎参观，这是我自己的房子，没有中介。");
    }
    复制代码

执行之后的结果：

![format_png 8][]

好了，cglib确实可以代理接口对象和普通对象。

## 总结 ##

Java动态代理，介绍了两种方式：JDK动态代理和开源Cglib动态代理，它们的实现机制不同：

1.  JDK 动态代理是通过实现目标类的接口，然后将目标类在构造动态代理时作为参数传入，使代理对象持有目标对象，再通过代理对象的 InvocationHandler 实现动态代理的操作。
2.  CGLIB 动态代理是通过配置目标类信息，然后利用 ASM 字节码框架进行生成目标类的子类。当调用代理方法时，通过拦截方法的方式实现代理的操作。

共同的部分，底层其实都是用到了通过反射完成，

总的来说，JDK 动态代理利用接口实现代理，Cglib 动态代理利用继承的方式实现代理。

而动态代理的作用就在于：

> 做方法的增强，在不改变源代码的情况下给原来的方法前后增加一些其他方法。比如：日志记录，事务管理等等

动态代理在 Java 开发中是非常常见的，在日志，监控，事务，技术框架中都有着广泛使用。动态代理的底层原理下次再讲。

作者：Mars酱  
链接：https://juejin.cn/post/7215963267490627644

[format_png]: https://img-blog.csdnimg.cn/img_convert/e98b72b992bb20780c5914e8fb4290db.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/fe72096f2a5b21b81113195219052db6.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/799a681341a888fcbd84acafd41e050e.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/73c528f837c51e5c6dbbcfdaa1bae87d.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/6270d5c53ea2c235696a47c22d9a05f8.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/eb256438d11870621f87cee5aa853479.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/a61a6861178b5bce2a5a05d0e829a831.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/e44302d46db887ff90b5dfa42c6f3884.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/30fe04892284a7237419cb100b1e3415.webp?x-oss-process=image/format,png