设计模式之代理模式

偏执的太偏执、 2022-05-30 12:06 140阅读 0赞

### 设计模式 ###

为其他对象**提供一种代理以控制这个对象的访问**。简单来说就是在一些情况下客户不想或者不能直接饮用一个对象，而代理对象可以在客户和目标对象之间起到中间作用，**去掉客户不能看到的内容和服务或增添客户需要的额外服务**。（当你想为某个对象方法拓展、增加前置后置事务时不要修改源码，而是通过代理的方式来拓展功能）

### 静态代理 ###

#### 描述：需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类 ####

#### 例子：房客在中介租用房东的房子；工作人员通过经纪人来决定明星的行程。 ####

#### 角色组成： ####

抽象主题角色：指代理角色（中介）和真实角色（房东）对外提供的公共方法，一般为一个接口。
    
    代理主题角色：需要实现抽象角色接口，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制都放到代理角色中处理！（中介对房东的出租房屋的拓展动作）
    
    真实主题角色：需要实现抽象角色接口，定义了真实角色所要实现的业务逻辑，以便供代理角色调用。也就是真正的业务逻辑在此。（房东出租房屋的动作）

抽象主题接口：（房东）  
![这里写图片描述][SouthEast]

真实主题类：（真实房东）  
![这里写图片描述][SouthEast 1]

代理主题类：（中介）  
![这里写图片描述][SouthEast 2]

测试：  
![这里写图片描述][SouthEast 3]

*  优点：可以做到在不修改目标对象的功能前提下,对目标功能扩展。
 *  缺点：因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护。

### 动态代理 ###

一般来说，对代理模式而言，一个主题类与一个代理类一一对应，这也是静态代理模式的特点。

但是，也存在这样的情况，有n各主题类，但是代理类中的“前处理、后处理”都是一样的，仅调用主题不同。也就是说，多个主题类对应一个代理类，共享“前处理，后处理”功能，动态调用所需主题，大大减小了程序规模，这就是动态代理模式的特点。

实现：  
抽象主题 和 真是主题与前面一样

事务处理器：

package DynamicProxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /** * 事务处理器 */
    public class LandlordHandler implements InvocationHandler { 
    
        //目标对象
        private Object target;
    
        //构造函数
        public LandlordHandler(Object target) {
            this.target = target;
        }
    
        /** * 执行目标对象的方法 * @param proxy * @param method * @param args * @return * @throws Throwable */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("带房东看房子(前置事件)");
            //执行目标对象的方法
            method.invoke(target,args);
            System.out.println("签订合同（后置事件）");
            return null;
        }
    
        /** * 获取代理类 * 类加载器（要进行代理的类）、被代理类实现的接口，事务处理器 * @return */
        public Object getProxy(){
            return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
        }
    }

测试：  
![这里写图片描述][SouthEast 4]

这里基本上就是AOP的一个简单实现了，在目标对象的方法执行之前和执行之后进行了增强。Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。

JDK动态代理步骤  
1. 创建一个实现InvocationHandler接口的类，它必须实现invoke()方法  
2. 创建被代理的类及接口  
3. 调用Proxy的静态方法，创建一个代理类  
4. 通过代理调用方法

注意：代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理。  
JDK动态代理不能实现继承式动态代理，原因是Java不允许多继承，而生成的代理类本身就已经继承了Proxy类。

### Cglib代理 ###

#### CGLIB是一个强大的高性能的代码生成包。 ####

1>它广泛的被许多AOP的框架使用，例如：Spring AOP和dynaop，为他们提供方法的interception（拦截）；
    
       2>hibernate使用CGLIB来代理单端single-ended(多对一和一对一)关联（对集合的延迟抓取，是采用其他机制实现的）；
    
       3>EasyMock和jMock是通过使用模仿（moke）对象来测试java代码的包。
    
     它们都通过使用CGLIB来为那些没有接口的类创建模仿（moke）对象。

#### Cglib代理 ####

上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象,但是有时候**目标对象只是一个单独的对象,并没有实现任何的接口**,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理

Cglib代理,也叫作**子类代理**,它是在内存中**构建一个子类对象**从而实现对目标对象功能的扩展.

JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.  
Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.

#### 实现方式 ####

1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入spring-core-3.2.5.jar即可.  
2.引入功能包后,就可以在内存中**动态构建子类**  
3.代理的类**不能为final**,否则报错(final不能被继承)  
4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

目标对象

package cglib;
    
    import DynamicProxy.Landlord;
    
    /** * 真实房东 */
    public class RealLandlord implements Landlord { 
    
        @Override
        public void rent() {
            System.out.println("把房屋出租给房客");
        }
    }

CGLIB代理

package cglib;
    
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    /** * cglib代理工厂 * 对RealLandlord动态创建子类对象 */
    public class CglibProxy implements MethodInterceptor { 
    
        private Object target;//目标对象
    
        public CglibProxy(Object target) {
            this.target = target;
        }
    
        /** * 创建代理对象 */
        public Object getProxyInstance(){
            Enhancer enhancer = new Enhancer();//工具类
            enhancer.setSuperclass(target.getClass());//设置父类
            enhancer.setCallback(this);//设置回调函数
            return enhancer.create();//创建代理对象
        }
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("开始事务。。。");
            method.invoke(target,objects);//执行目标对象函数
            System.out.println("提交事务。。。");
            return null;
        }
    }

测试  
![这里写图片描述][SouthEast 5]

### 总结 ###

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用**处理器一个集中的方法**中处理。在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样对每一个方法或方法组合进行处理。**Proxy 很美很强大，但是仅支持 interface 代理**。Java 的单继承机制注定了这些动态代理类们无法实现对 class 的动态代理。好在有cglib为Proxy提供了弥补。class与interface的区别本来就模糊，在java8中更是增加了一些新特性，使得interface越来越接近class，当有一日，java突破了单继承的限制，动态代理将会更加强大。

参考：

*  作者：岑宇 出处：[http://www.cnblogs.com/cenyu/][http_www.cnblogs.com_cenyu]
 *  [http://blog.csdn.net/Goskalrie/article/details/52458773][http_blog.csdn.net_Goskalrie_article_details_52458773]
 *  [http://blog.csdn.net/xiaohai0504/article/details/6832990][http_blog.csdn.net_xiaohai0504_article_details_6832990]

[SouthEast]: /images/20220530/1e976921521d49479887ecb39f25c89c.png
[SouthEast 1]: /images/20220530/b3c47b6d2db6495dbd51dd71566d8607.png
[SouthEast 2]: /images/20220530/4a11f49e5a7d4786865377749c0f1e61.png
[SouthEast 3]: /images/20220530/df071d9353c549a58a88017b7eda2b5b.png
[SouthEast 4]: /images/20220530/12ac299b1ede472f942784855b5affd1.png
[SouthEast 5]: /images/20220530/19bbd3c218ab4cee9f57244d54280af2.png
[http_www.cnblogs.com_cenyu]: http://www.cnblogs.com/cenyu/
[http_blog.csdn.net_Goskalrie_article_details_52458773]: http://blog.csdn.net/Goskalrie/article/details/52458773
[http_blog.csdn.net_xiaohai0504_article_details_6832990]: http://blog.csdn.net/xiaohai0504/article/details/6832990