代理模式（静态代理、jdk动态代理、CGLib动态代理）

深藏阁楼爱情的钟 2023-09-29 12:57 78阅读 0赞

#### 目录 ####

*  1.什么是代理模式？
 *  2.静态代理
 *   *  1.案例
     *  2.优化案例
     *  3.静态代理瓶颈
 *  3.动态代理
 *   *  1.什么是动态代理？
     *  2.jdk动态代理
     *   *  1.动态代理的工具类
         *   *  匿名内部类简介
         *  2.jdk动态代理实现
         *  3.动态代理新增业务方法
         *   *  动态代理获取到的代理对象是什么类型的呢？
     *  3.CGLib动态代理
     *   *  1.简化版
         *  2.真正的CGLib
         *   *  代码实现
 *  4.小结

## 1.什么是代理模式？ ##

**代理模式：** 目标对象不可访问，通过代理对象增强访问。

案例：客户A想要租房，都是通过与中介去租房，而不是直接去找房东租房。这就是代理模式。

*  房东就是目标对象
 *  客户A是客户端对象
 *  房屋中介就是代理对象  
    ![e5d668e58f16464c89cc4217577374f1.png][]

**代理模式的作用：**

*  控制目标对象的访问（不让租户直接与房东联系租房）
 *  增强功能（中介去进一步装修房子）

**代理模式的分类：**

*  静态代理（代理类）
 *  动态代理（代理接口）  
    jdk动态代理  
    CGLib动态代理

## 2.静态代理 ##

**静态代理的特点：**

*  目标对象和代理对象实现同一个业务接口
 *  目标对象必须实现接口
 *  代理对象在程序运行前就已经存在
 *  能够灵活地进行目标对象的切换，却不能进行功能的灵活处理（就因为这点问题，而出现了动态代理）

### 1.案例 ###

**案例：** 张三现在找到了一份工作，需要去公司附近租一套房子，且已经看中了一套离公司很近的loft公寓，现在需要去联系中介租这一套房。

*  业务功能：租房
 *  目标对象：房东
 *  代理对象：中介  
    ![8e0cc87dd7334bf28219390091abb6f1.png][]  
    完成租出去一套房子这一业务的实际上还是房东，中介实际上是完成其他业务的（如添置家具、商谈资金…）。

上代码：

Service

public interface Service {
        
        void rent();
    }

Landlord

public class Landlord implements Service{
        
        //只有房东才有房子
        private House house;
    
        @Override
        public void rent() {
        
            house = new House();
            System.out.println("把房子租出去");
        }
    
        private class House{
        
            public House() {
        
            }
        }
    }

Agency

public class Agency implements Service{
        
        @Override
        public void rent() {
        
            System.out.println("添置家具");
            System.out.println("商谈租金");
    
            Landlord landlord = new Landlord();
            landlord.rent();
    
            System.out.println("签合同，收租金");
        }
    }

Zhang

public class Zhang {
        
        @Test
        public void testRent(){
        
            Service agency = new Agency();
            agency.rent();
        }
    }

输出：  
![12c2cef4f8bd41c4bd031efc6e5b823b.png][]

**分析一下：**

代理过程：

*  整个过程，真正的业务功能——把房子租出去
 *  代理的附加功能——其他三个

### 2.优化案例 ###

Java多态的展现：子类可以根据自身情况对父类/接口的方法进行重写（扩展）  
![c36219601213428e99127d17b0fddc01.png][]  
当我们需要新增一个目标对象交由中介代理的时候，如何让中介根据客户需求去实现准确的代理（租户要租别墅就给他别墅，要房子就给他房子）？  
这就涉及到面向接口编程了。

面向接口编程：将类中的成员变量设计为接口，方法的形参设计为接口，方法的返回值设计为接口，调用时，接口只想实现类。

--------------------

以下便是上述案例关于面向接口编程的一个优化：

首先，我们新增一个房东Pro，他想租出去一套别墅。  
LandlordPro

public class LandlordPro implements Service{
        
        private Villa villa;
        @Override
        public void rent() {
        
            villa = new Villa();
            System.out.println("出租一套别墅");
        }
    
        private class Villa{
        
            public Villa() {
        
            }
        }
    }

因为新增了一个目标对象（现在有两个了），那么相应的代理对象也需要根据客户需求进行判断（该把谁的租借出去），所以我们在类中新增一个接口对象作为传输参数，判断该先执行哪个目标对象的业务。

public class Agency implements Service{
        
        //类中的成员变量设计为接口
        public Service target; //目标对象
    
        public Agency() {
        
        }
    
        //传入目标对象,方法的参数设计为接口
        public Agency(Service target){
        
            this.target = target;
        }
    
        @Override
        public void rent() {
        
            System.out.println("添置家具");
            System.out.println("商谈租金");
    
            //面向接口编程：调用时，接口指向实现类
            target.rent();
    
            System.out.println("签合同，收租金");
        }
    }

现在来看看客户代码：

public class Zhang {
        
        @Test
        public void testRent(){
        
        	//需要将参数传入构造器，从而调用相应的目标对象的相应业务
            Service agency = new Agency(new LandlordPro());
            agency.rent();
        }
    }

输出：  
![e93fa552c0b84558b217c6a041884fa7.png][]

### 3.静态代理瓶颈 ###

通过上述的案例我们可以预料到一种情况——当我们需要向接口中新增业务方法的时候，我们的两个目标对象都必须改写代码（实现新增的业务方法），代理对象也需要进行改变，如图：

我们在业务接口中新增一个 违约的方法 default()，那么整个模块都需要进行改动，巨麻烦。  
![d1c90ad2e7ac4376962c99c80cf73a70.png][]

**因此，静态代理只适合——业务功能固定，最多目标对象需要改变的情况**，因此我们需要动态代理。

## 3.动态代理 ##

### 1.什么是动态代理？ ###

**动态代理：** 代理对象在程序运行的过程中动态在内存构建，可以灵活的进行业务逻辑功能的切换。

简而言之，就是基于静态代理，突破其业务功能必须固定这一瓶颈。

**jdk动态代理：**

*  目标对象必须实现业务接口（同静态代理）
 *  代理对象不需要实现业务接口（一项巨大的优化）
 *  动态代理的对象在程序运行前不存在，在程序运行时动态的在内存创建（优化）
 *  能灵活地进行业务功能的切换（突破瓶颈）

### 2.jdk动态代理 ###

#### 1.动态代理的工具类 ####

jdk动态代理是需要使用工具类来完成jdk动态实现的：

**java.lang.reflect.proxy** 类

*  `public static Object newProxyInstance(...)` 专门用来生成动态代理对象

@CallerSensitive
        public static Object newProxyInstance(ClassLoader loader,//类加载器，完成目标对象的加载
                                              Class<?>[] interfaces,//目标对象实现的所有接口
                                              InvocationHandler h)//代理的功能和目标对象的业务功能的调用
            throws IllegalArgumentException
        {
        
        ...

**java.lang.reflect.Method** 类  
进行目标对象的方法的反射调用，method对象接收我们要调用的方法（如上述案例的 rent()）

*  `public Object invoke(Object obj, Object... args)`  
    obj：调用底层方法的对象  
    args：用于方法调用的参数

**InvocationHandler** 接口  
用来实现代理和业务功能的，在调用时使用 匿名内部类 实现

##### 匿名内部类简介 #####

啥是匿名内部类？一般情况，接口或者抽象类是不能直接实例化的（new 一个接口对象），而使用匿名内部类就可以实现接口或者抽象类的实例化。

比如，我们非常熟悉的 Runnable 接口：这就是一个匿名内部类的实现。

public class Test {
        
        public static void main(String[] args) {
        
            Runnable runnable = new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("一个线程在运行...");
                }
            };
            Thread thread = new Thread(runnable);
            }
    }

而因为Runnable接口只有一个方法，故而这是一个 函数式接口 ，可以使用Lambda表达式简化代码：

public class Test {
        
        public static void main(String[] args) {
        
            Runnable runnable = () -> System.out.println("一个线程在运行...");
            Thread thread = new Thread(runnable);
            }
    }

#### 2.jdk动态代理实现 ####

![8c8853f50148407eb01397bdb06c46e8.png][]

业务接口，两个房东类都不变：

Service

public interface Service {
        
        void rent();
    }

Landlord

LandlordPro

接下来，重点来了，动态代理类——ProxyFactory

public class ProxyFactory {
        
        //类中的成员变量设计为接口
        Service target;
    
        //传入目标对象
        public ProxyFactory(Service target){
        
            this.target = target;
        }
    
        //返回动态代理对象
        public Object getAgency(){
        
            return Proxy.newProxyInstance(//这个返回值是动态代理对象
                    target.getClass().getClassLoader(), //类加载器，完成目标对象的加载
                    target.getClass().getInterfaces(),//目标对象实现的所有接口
                    new InvocationHandler() {
        //实现代理功能的接口，传入匿名内部类实现
                        @Override
                        public Object invoke(//这个方法的返回值就是目标方法的返回值
                                Object proxy, //创建好的代理对象
                                Method method, //目标方法，如 rent()
                                Object[] args//目标方法的参数
                        ) throws Throwable {
        
                            //代理功能，功能扩展
                            System.out.println("添置家具");
                            System.out.println("商谈租金");
    
                            //主业务功能实现，如何灵活地调用业务接口的各种方法？
                            Object obj = method.invoke(target,args);
    
                            //代理功能，功能扩展
                            System.out.println("签合同，收租金");
    
                            return obj;
    
                        }
                    }
            );
        }
    }

分析一下这个类：

*  前面的写法和静态代理中的Agency一致，先往构造器中传入目标对象的接口
 *  然后就是返回动态代理对象的方法  
    `java.lang.reflect.Proxy.newProxyInstance` 返回一个动态代理对象（根据传入接口生成对应的对象）  
    `java.lang.reflect.InvocationHandler` 这是实现代理的方法的接口，使用此接口中的 `invoke` 方法实现代理和业务功能

最后就是测试类：

public class Zhang {
        
        @Test
        public void testRent(){
        
            ProxyFactory proxyFactory = new ProxyFactory(new LandlordPro());
            Service agency = (Service) proxyFactory.getAgency();
            agency.rent();
        }
    }

查看输出：  
![1c9cce3cb1d0457f989fed2951bfe0c5.png][]

#### 3.动态代理新增业务方法 ####

现在向业务接口中新添一个业务方法 `int increase(int num)`

Service

public interface Service {
        
        void rent();
        String increase(int num);//新增业务
    }

Landlord

public class Landlord implements Service{
        
        //只有房东才有房子
        private House house;
    
        @Override
        public void rent() {
        
            house = new House();
            System.out.println("把房子租出去");
        }
    
        @Override
        public String increase(int num) {
        
            return "房子租金涨价" + num + "元人民币";
        }
    
        private class House{
        
            public House() {
        
            }
        }
    }

LandlordPro

public class LandlordPro implements Service{
        
        private Villa villa;
    
        @Override
        public void rent() {
        
            villa = new Villa();
            System.out.println("出租一套别墅");
        }
    
        @Override
        public String increase(int num) {
        
            return "别墅租金涨价" + num + "元人民币";
        }
    
        private class Villa{
        
            public Villa() {
        
            }
        }
    }

动态代理类完全不用更改

直接进测试类调用新的方法：

查看输出：  
![a6ec4e7e82234b209bdc6d1e493f3c68.png][]

**注意：** 动态代理只会代理接口中的方法，目标对象自身的对象是不会被代理的，这是因为动态代理对象与目标对象类型不一样。

##### 动态代理获取到的代理对象是什么类型的呢？ #####

ProxyFactory proxyFactory = new ProxyFactory(new LandlordPro());
            Service agency = (Service) proxyFactory.getAgency();

我们从代码可以很轻易看出，代理对象 agency 应该是个 Service类型，那么实际上是什么呢？

输出看一下：

System.out.println(agency.getClass());

这才是动态代理的类型  
![2fc235b062324774a3a73e06571c915a.png][]

### 3.CGLib动态代理 ###

**CGLib动态代理：** 通过动态地在内存中构建子类对象，重写父类的方法进行代理功能的增强。

*  如果目标对象没有实现接口，则只能通过CGLib子类代理来进行功能增强。
 *  子类代理是对象字节码框架ASM来实现的

#### 1.简化版 ####

CGLib大概的实现形式如下：子类重写扩展父类的方法。

代理父类对象：

父类——Animal

public class Animal {
        
        public void roar(){
        
            System.out.println("动物进行吼叫");
        }
    }

子类——Cat

public class Cat extends Animal{
        
        @Override
        public void roar() {
        
            //父类实现自己的功能
            super.roar();
            //子类实现代理功能
            System.out.println("喵喵喵~");
        }
    }

测试类——Test

public class Test {
        
        @org.junit.jupiter.api.Test
        public void testAgency(){
        
            Animal cat = new Cat();
            cat.roar();
        }
    }

#### 2.真正的CGLib ####

jdk动态代理有一个瓶颈——使用动态代理的目标对象必须实现一个或多个接口。如果想要代理没有实现接口的类，那么就必须使用CGLib代理。

**CGLib的特点：**

*  一个强大的高性能的代码生成包，可以在运行期扩展java类与实现java接口。广泛地被许多AOP框架使用，例如SpringAOP。
 *  CGLib包的底层是通过一个小而快的字节码处理框架ASM来转换字节码并生成新的类。  
    但使用ASM的前提是，对jvm内部结构（class文件的格式和指令集）很熟悉。

**注意：** 因为CGLib需要子类扩展父类方法，所以不能代理被 `final`、`static` 修饰的方法、类。

##### 代码实现 #####

需要导入cglib包

父类——Animal

public class Animal {
        
        public void roar(){
        
            System.out.println("动物进行吼叫");
        }
    }

代理类——ProxyFactory

public class ProxyFactory implements MethodInterceptor {
        
        
        //目标对象
        private Object target;
        //传入目标对象
        public ProxyFactory(Object target){
        
            this.target = target;
        }
        
        //CGLib采用低层的字节码技术，在子类中采用方法拦截的技术，拦截父类指定方法的调用，并顺势植入代理功能的代码
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        
            //调用目标对象的方法
            Object returnValue = method.invoke(target,objects);
            
            //代理对象的功能
            System.out.println("喵喵喵");
            
            return returnValue;
        }
        
        //生成代理对象
        public Object getProxyInstance(){
        
            //使用工具类
            Enhancer enhancer = new Enhancer();
            //设置父类
            enhancer.setSuperclass(target.getClass());
            //设置回调函数
            enhancer.setCallback(this);
            //创建子类(代理)对象
            return enhancer.create();
        }
    }

测试类——Test

@org.junit.jupiter.api.Test
        public void testCGLibProxy(){
        
            Animal animal = new Animal();
            System.out.println(animal.getClass());
            Animal proxy = (Animal) new ProxyFactory(animal).getProxyInstance();
            System.out.println(proxy.getClass());
            proxy.roar();
        }

## 4.小结 ##

> 什么是代理模式？

无法直接访问目标对象，必须要通过代理对象作为中介来访问目标对象。

> 代理模式的功能？

增强功能  
限制目标对象的访问

> 代理模式分类

静态代理

*  目标对象和代理对象实现同一接口
 *  代理对象实现功能的过程实际上是目标对象自己实现功能的过程
 *  当业务发生变化时，整个模块都需要改动，实现复杂
 *  代理类以.java的文件形式存在，调用前就已经存在，所以比较死板

动态代理

*  代理对象不需要实现业务接口
 *  代理对象在程序运行时动态的在内存中创建
 *  目标对象必须实现接口，才可以使用jdk动态代理，且只能代理接口中的方法

> 动态代理使用到的三个类？

`java.lang.reflect.proxy` 负责生成代理对象

`java.lang.reflect.Method` 负责目标方法的回调，使用反射机制（即利用反射进行目标对象的调用）

`java.lang.reflect.InvocationHandler` 增强功能的代码，当外部目标对象方法被调用时，此接口的实现类被执行

> CGLib动态代理的特点？

子类代理模式，在程序运行时，动态生成代理对象，实现功能扩展

目标对象不需要实现接口，全靠子类来扩展功能

规避了jdk代理中目标对象必须实现接口的弊端

被代理的类和方法不能被 `final` 修饰

底层是由字节码处理框架ASM来完成的

[e5d668e58f16464c89cc4217577374f1.png]: https://img-blog.csdnimg.cn/e5d668e58f16464c89cc4217577374f1.png
[8e0cc87dd7334bf28219390091abb6f1.png]: https://img-blog.csdnimg.cn/8e0cc87dd7334bf28219390091abb6f1.png
[12c2cef4f8bd41c4bd031efc6e5b823b.png]: https://img-blog.csdnimg.cn/12c2cef4f8bd41c4bd031efc6e5b823b.png
[c36219601213428e99127d17b0fddc01.png]: https://img-blog.csdnimg.cn/c36219601213428e99127d17b0fddc01.png
[e93fa552c0b84558b217c6a041884fa7.png]: https://img-blog.csdnimg.cn/e93fa552c0b84558b217c6a041884fa7.png
[d1c90ad2e7ac4376962c99c80cf73a70.png]: https://img-blog.csdnimg.cn/d1c90ad2e7ac4376962c99c80cf73a70.png
[8c8853f50148407eb01397bdb06c46e8.png]: https://img-blog.csdnimg.cn/8c8853f50148407eb01397bdb06c46e8.png
[1c9cce3cb1d0457f989fed2951bfe0c5.png]: https://img-blog.csdnimg.cn/1c9cce3cb1d0457f989fed2951bfe0c5.png
[a6ec4e7e82234b209bdc6d1e493f3c68.png]: https://img-blog.csdnimg.cn/a6ec4e7e82234b209bdc6d1e493f3c68.png
[2fc235b062324774a3a73e06571c915a.png]: https://img-blog.csdnimg.cn/2fc235b062324774a3a73e06571c915a.png