动态代理

javajavase
代理设计模式的原理
使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上

静态代理

interface ClothFactory {
    void produceCloth();
}
// 被代理类
class NikeClothFactory implements ClothFactory {
    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}
// 代理类
class ProxyClothFactory implements ClothFactory {
    private ClothFactory factory;    // 用被代理类对象进行实例化
    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }
    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");
        factory.produceCloth();
        System.out.println("代理工厂做一些后续的收尾工作");
    }
}
public class StaticProxyTest {
    public static void main(String[] args) {
        // 创建被代理类的对象
        ClothFactory nike = new NikeClothFactory();
        // 创建代理类的对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
        proxyClothFactory.produceCloth();
    }
}

• 静态代理的缺点
  • 代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。
  • 每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理

    动态代理

    之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能

动态代理的特点
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象

• 相比于静态代理的优点：抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法

动态代理的实现
需要解决的两个主要问题

1. 如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象

通过 Proxy.newProxyInstance() 实现

1. 当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a

通过 InvocationHandler 接口的实现类及其方法invoke()
动态代理相关的API

• Proxy：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
• 提供用于创建动态代理类和动态代理对象的静态方法

**static Class<?> getProxyClass(ClassLoader loader, Class<?>... interface)**
创建一个动态代理类所对应的Class对象
**static Object newProxyInstance(ClassLoader loader, Class<?>... interface, InvocationHandler h)**
直接创建一个动态代理对象

动态代理实现步骤

1. 创建一个实现接口 InvocationHandler 的类，它必须实现invoke方法，以完成代理的具体操作
2. 创建被代理类以及接口
3. 通过Proxy的静态方法newProxyInstance(ClassLoader loader, Class<?>…interface, InvocationHandler h)创建一个接口代理

4. 通过代理类的实例调用被代理类的方法 ```java /*

   • 动态代理的举例 */ interface Human { String getBelief();

     void eat(String food); }

// 被代理类 class SuperMan implements Human { @Override public String getBelief() { return “I believe I can fly!”; }

@Override
public void eat(String food) {
    System.out.println("我喜欢吃" + food);
}

}

class HumanUtil { public void method1() { System.out.println(“===============通用方法一===============”); }

public void method2() {
    System.out.println("===============通用方法二===============");
}

}

/ 要想实现动态代理，需要解决的问题？ 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。 / class ProxyFactory { // 调用此方法，返回一个代理类的对象。解决问题一 public static Object getProxyInstance(Object obj) { // obj:被代理类的对象 MyInvocationHandler handler = new MyInvocationHandler(); handler.bind(obj); return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler); } }

class MyInvocationHandler implements InvocationHandler { private Object obj; // 需要使用被代理类的对象进行赋值

public void bind(Object obj) {
    this.obj = obj;
}
// 当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
// 将被代理类要执行的方法a的功能就声明在invoke()中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    HumanUtil util = new HumanUtil();
    util.method1();
    // method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
    // obj:被代理类的对象
    Object returnValue = method.invoke(obj, args);
    util.method2();
    //method方法的返回值就作为当前类中的invoke()的返回值。
    return returnValue;
}

}

public class ProxyTest { public static void main(String[] args) { SuperMan superMan = new SuperMan();

    // proxyInstance:代理类的对象
    Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
    // 当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
    String belief = proxyInstance.getBelief();
    System.out.println(belief);
    proxyInstance.eat("四川麻辣烫");
    System.out.println("*****************************");
    NikeClothFactory nikeClothFactory = new NikeClothFactory();
    ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory
        .getProxyInstance(nikeClothFactory);
    proxyClothFactory.produceCloth();
}

}

**动态代理与AOP**
- 使用 Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理。
- 这种动态代理在 AOP 中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异：
- AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理
![](https://cdn.nlark.com/yuque/0/2020/png/1379492/1590769779635-a4b882fc-ab11-490f-9850-1c7b0e22dfe0.png#height=235&id=BypSD&originHeight=449&originWidth=573&originalType=binary&ratio=1&size=0&status=done&style=none&width=300)
```java
// 公共接口
interface Dog {
    void info();
    void run();
}
// 被代理类
class HuntingDog implements Dog {
    @Override
    public void info() {
        System.out.println("我是一只猎狗");
    }
    @Override
    public void run() {
        System.out.println("我跑的很快");
    }
}
// 通用方法
class DogUtils {
    public void method1() {
        System.out.println("=======通用方法一=======");
    }
    public void method2() {
        System.out.println("=======通用方法二=======");
    }
}
// 动态代理实现
class MyInvocationHandler1 implements InvocationHandler {
    // 需要被代理的对象
    private Object target;
    public void SetTarget(Object target) {
        this.target = target;
    }
    // 当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    // 将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        DogUtils dogUtils = new DogUtils();
        // 执行DogUtils对象中的method1
        dogUtils.method1();
        // 通过obj对象来调用执行method方法
        Object result = method.invoke(target, args);
        // 执行DogUtils对象中的method2
        dogUtils.method2();
        return result;
    }
}
// 动态代理类
class MyProxyFactory1 {
    //为target生成动态代理对象
    public static Object getProxy(Object target) {
        // 创建一个MyInvocationHandler对象
        MyInvocationHandler1 handler = new MyInvocationHandler1();
        // 为MyInvocationHandler设置target对象
        handler.SetTarget(target);
        //创建返回一个动态代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                                      target.getClass().getInterfaces(), handler);
    }
}
public class AOPTest {
    public static void main(String[] args) {
        Dog target = new HuntingDog();
        Dog dog = (Dog) MyProxyFactory1.getProxy(target);
        dog.info();
        dog.run();
    }
}