面试篇之HR问什么是静态代理？什么是动态代理？

傷城~ 2023-09-26 15:55 63阅读 0赞

#### 何为代理？ ####

Java中的代理，开源理解为通过代理去访问实际的目标对象，比如呢？我们平常买卖二手车的中间商，就可以看作一个代理类，不过你也可以直接去和二手车的主人买卖。

那这种情况，在Java中就被称之为代理，代理类除了去实现目标对象外，他还可以去在其中增加许多额外功能。

**理论扩展：**

> 主要解决的问题：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。
> 
> 代理模式的必要条件：共同接口、代理对象、目标对象。
> 
> 宏观特性：对客户端只暴露出接口，不暴露它以下的架构。
> 
> 优点：中间隔离了一层，更加符合开闭原则。

#### 代理是一种？ ####

> **代理是一种设计模式**

*  他并非一种自带的功能，而是一种设计模式。
 *  在代理模式中，一个类代表另一个类的功能。
 *  这种类型的设计模式属于结构型模式。
 *  在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
 *  目的：为其他对象提供一种代理以控制对这个对象的访问。

#### 代理模式分类 ####

代理模式分为两种类型：

>  *  **静态代理**
>  *  **动态代理**

#### 实现静态代理 ####

> 理论不多说，从代码中理解。

创建接口

首先，我们创建一个接口，一般我们一个功能都会去设计一个接口，包括我们的三层架构也是这样，所以我这也写一个接口。

/**
     * @author JanYork
     * @date 2022/10/25 8:59
     * @description 假设Demo是买东西的接口
     */
    public interface Demo {
        /**
         * 买东西
         * @param name 东西的名字
         * @param price 东西的价格
         * @return 买东西的结果
         */
        String buy(String name, int price);
    }
    复制代码

那我们就，假设这个`Demo`是买东西的接口。

也是提供一个简简单单的购买东西的方法(实际上就是输出测试一下)。

实现接口

我们还要去实现这个接口，也就是我们的接口实现类。

/**
     * @author JanYork
     * @date 2022/10/25 9:03
     * @description 真实的Demo类(被代理类)
     */
    public class RealDemo implements Demo {
    
        public RealDemo(String name, int price) {
            this.name = name;
            this.price = price;
        }
    
        private String name;
        private int price;
    
        @Override
        public String buy(String name, int price) {
            System.out.println("买了" + name + "花了" + price + "元");
            return "买了" + name + "花了" + price + "元";
        }
    }
    复制代码

给他两个参数，一个构造，然后重写接口提供的方法，这个不需要多说。

代理类

/**
     * @author JanYork
     * @date 2022/10/25 9:05
     * @description Demo的代理类
     */
    public class ProxyDemo implements Demo {
    
            private RealDemo realDemo;
    
            public ProxyDemo(String name, int price) {
                this.realDemo = new RealDemo(name, price);
            }
    
            @Override
            public String buy(String name, int price) {
                System.out.println("-----代理类开始买东西------");
                String result = realDemo.buy(name, price);
                System.out.println("------代理类买东西结束------");
                return result;
            }
    }
    复制代码

创建代理后我们也需要去实现这个`Demo`接口。

然后需要注入实现接口的类的对象(也就是真实类)。

private RealDemo realDemo;
    复制代码

然后实现构造：

public ProxyDemo(String name, int price) {
        this.realDemo = new RealDemo(name, price);
    }
    复制代码

![format_png][]

然后在重写方法里面调用，可以在调用方法前后干一些事情。

然后我们创建一个`Test`类测试：

![format_png 1][]

#### 静态代理缺陷 ####

**问：既然静态代理可以方便的达到目的，那他有什么缺点吗？**

> 静态代理在代码**运行之前就需要创建好代理类**，因此对于每一个代理对象都需要建一个代理类去代理。如果说，你需要代理的对象很多，那就**需要创建很多代理类**，**降低程序的可维护性**。

**问：那如何解决这个缺陷呢？**

> 动态构建代理类，也就是动态代理。

#### 动态代理 ####

动态代理的代理类是在运行过程中产生的。

`Java`提供了两种实现动态代理的方式：

*  基于`JDK`的动态代理。
 *  基于`Cglib`的动态代理。

> 特点：字节码随用随创建，随用随加载。
> 
> 作用：在不修改源码的基础上对方法增强。

基于JDK实现

> 实现`Jdk`的动态代理需要实现`InvocationHandler`接口，然后实现其中的`invoke`方法。

我们创建一个类，实现`InvocationHandler`(来自`java.lang.reflect`反射包下)接口。

![format_png 2][]

这个类下，有非常丰富的详细的解释，可以看看。

![format_png 3][]

实现了接口后，我们给他用`Object`来替代原先静态代理类中的这一段：

private RealDemo realDemo;
      public ProxyDemo(String name, int price) {
        this.realDemo = new RealDemo(name, price);
    }
    复制代码

也就是这样：

private Object target;
    
    public ProxyHandler(Object target) {
        this.target = target;
    }
    复制代码

然后重写`invoke`方法：

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("-----动态代理开始------");
        Object invoke = method.invoke(target, args);
        System.out.println("------动态代理结束------");
        return invoke;
    }
    复制代码

里面有多个参数，稍后说明。

![format_png 4][]

调用

首先还是创建真实对象，并且给出构造。

RealDemo realDemo = new RealDemo("苹果", 10);
    复制代码

然后创建动态代理对象，将正式对象传输过去。

ProxyHandler proxyHandler = new ProxyHandler(realDemo);
    复制代码

然后我们调用，实际上就是使用`Proxy`这个类来调用`newProxyInstance`这个方法。

Proxy.newProxyInstance(realDemo.getClass().getClassLoader(), realDemo.getClass().getInterfaces(), proxyHandler);
    复制代码

![format_png 5][]

这个方法是一个静态方法，参数如下。

newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
    复制代码

第一个是一个类加载器，第二个是一个带泛型的Class数组，并且要求是一个`interfaces`，第三个参数就是实现了`InvocationHandler`的对象了。

那我们调用时给出的参数就是：

//获取真实类的类加载器
    realDemo.getClass().getClassLoader(), 
    //获取真实类所实现的接口
    realDemo.getClass().getInterfaces(),
    //实现InvocationHandler接口的对象
    proxyHandler
    复制代码

这部分对反射这方面知识有很多设计，不懂的还是建议去折腾折腾。

**那我们整个调用动态对象的方法，如下：**

public class TestDemo {
        public static void main(String[] args) {
    //        ProxyDemo proxyDemo = new ProxyDemo("苹果", 10);
    //        proxyDemo.buy("苹果", 10);
    
            //调用动态代理
            RealDemo realDemo = new RealDemo("苹果", 10);
    
            ProxyHandler proxyHandler = new ProxyHandler(realDemo);
    
            Demo demo = (Demo) Proxy.newProxyInstance(realDemo.getClass().getClassLoader(), realDemo.getClass().getInterfaces(), proxyHandler);
            demo.buy("苹果", 10);
        }
    }
    复制代码

`Proxy.newProxyInstance`方法返回的是一个`Object`，我们将他转型为我们的接口对象。

然后通过对象调用对应方法。

效果

![format_png 6][]

优势

一个动态代理可以对N个需要代理的对象起作用，只需要将需要代理类的参数放入`Proxy.newProxyInstance`方法即可。

缺陷

`JDK`只能代理接口！

> `JDK`动态代理确实只能代理接口，JDK动态代理是基于接口的方式，换句话来说就是代理类和目标类都实现同一个接口。如果想要代理类的话可以使用`CGLib`，`CGLib`动态代理是代理类去继承目标类，然后实现目标类的方法。

基于CGLib实现

首先引入依赖：

<dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>版本号</version>
    </dependency>
    复制代码

如果你是`Spring`项目，那就不必了，已经整合了。

我们创建一个类，用于给`CGLib`测试。

/**
     * @author JanYork
     * @date 2022/10/25 10:32
     * @description 基于Cglib的动态代理的目标类
     */
    public class CgDemo {
        public String buy(String name, int price) {
            System.out.println("买了" + name + "，价格是" + price);
            return "买了" + name + "，价格是" + price;
        }
    }
    复制代码

然后创建`CGLib`的代理类：

/**
     * @author JanYork
     * @date 2022/10/25 10:34
     * @description
     */
    public class CgProxy implements MethodInterceptor {
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("-----cglib代理开始------");
            Object invoke = methodProxy.invokeSuper(o, objects);
            System.out.println("------cglib代理结束------");
            return invoke;
        }
    }
    复制代码

调用

//创建Enhancer对象
    Enhancer enhancer = new Enhancer();
    //设置父类(也就是目标类)
    enhancer.setSuperclass(CgDemo.class);
    //设置回调函数
    enhancer.setCallback(new CgProxy());
    //创建代理对象
    CgDemo cgDemo = (CgDemo) enhancer.create();
    //调用代理对象的方法
    cgDemo.buy("苹果", 10);
    复制代码

`Enhancer`是`cglib.proxy`下的一个**生成动态子类**以启用方法拦截的类。

> `Enhancer` 类是 `CGLib` 中最常用的一个类，和 `JDK 1.3` 动态代理中引入的 `Proxy` 类差不多（`Proxy` 类是`Java`动态代理机制的主类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象）。
> 
> 和 `Proxy` 不同的是，`Enhancer` 类既能够代理普通的`class`，也能够代理接口。`Enhancer` 创建一个被代理对象的子类并且拦截所有的方法调用（包括从 `Object` 中继承的 `toString()` 和 `hashCode()` 方法）。

效果

![format_png 7][]

应用场景

**问：动态代理这么牛，平常工作中有使用到吗？**

在平常的业务代码，几乎是用不到代理的。

但是，`Spring`系列框架中的`AOP`，以及`RPC`框架中都用到了动态代理。

> **如：AOP通过动态代理对目标对象进行了增强，比如我们最常用的前置通知、后置通知等。**

[format_png]: https://img-blog.csdnimg.cn/img_convert/a7a0540010359ce5aa3f0afc7b8944fb.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/2cee0123fc32e6b7f0e0930541e15d1d.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/a6ab9331136ef7a313f4e95985f0510e.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/ec0eef1f98395e5d88770b41a162dde1.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/d4fca37721ded2db2954d6d376b22432.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/b02d452cb082e520e336f692983b1aad.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/c056a898221f0c2d71d767543970fc3b.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/87661f0d016aa75e1f7fd0034930a87a.webp?x-oss-process=image/format,png