Java动态代理

一.前言

为了让我们更好的理解动态代理，让我们先来了解一下静态代理。
静态代理的特点是：代理类和被代理类在编译期间，就确定下来了。
先直接上代码：

//代理类与被代理类需要实现的接口
interface ClothFactory{
    
    void produceCloth();
}

//代理类
class ProxyClothFactory implements ClothFactory{
    

    //用被代理类对象进行实例化
    private ClothFactory factory;
    
    public ClothFactory getFactory() {
    
        return factory;
    }

    public void setFactory(ClothFactory factory) {
    
        this.factory = factory;
    }

    public ProxyClothFactory(ClothFactory factory){
    
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
    
        //代理类做一些前期准备工作，这里直接用输出语句简写
        System.out.println("代理类做一些准备工作-------------");
        //调用被代理类
        factory.produceCloth();
        //代理类做一些后期收尾工作，这里直接用输出语句简写
        System.out.println("代理类做一些收尾工作-------------");
    }
}

//被代理类0
class PumaClothFactory implements ClothFactory{
    

    @Override
    public void produceCloth() {
    
        System.out.println("Puma工厂正在生产服装！");
    }
}

//被代理类1
class AdidasClothFactory implements ClothFactory{
    

    @Override
    public void produceCloth() {
    
        System.out.println("Adidas工厂正在生产服装！");
    }
}


public class StaticProxyTest {
    
    public static void main(String[] args) {
    
        //创建被代理类0的对象
        PumaClothFactory puma = new PumaClothFactory();
        //创建代理类的对象，在构造起中传入被代理类作为实参
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(puma);
        //调用代理类对象的produceCloth()方法，
        // 实际上在代理类对象的produceCloth()方法中调用了被代理类对象的produceCloth()方法，实现静态代理
        proxyClothFactory.produceCloth();

        System.out.println();

        //创建被代理类1的对象
        AdidasClothFactory adidas = new AdidasClothFactory();
        //把被代理类对象改为adidas
        proxyClothFactory.setFactory(adidas);
        //调用代理类对象的produceCloth()方法
        proxyClothFactory.produceCloth();
    }
}

输出结果：

代理类做一些准备工作-------------
Puma工厂正在生产服装！
代理类做一些收尾工作-------------

代理类做一些准备工作-------------
Adidas工厂正在生产服装！
代理类做一些收尾工作-------------

Process finished with exit code 0

分析：
上述代码中代理类与被代理类都实现了同一个接口ClothFactory；
在被代理类中实现了接口的produceCloth()方法；
在代理类中声明了被代理类对象作为其属性，然后又在代理类的有参构造起中对其属性进行赋值；
在代理类中同样也实现了produceCloth()方法，但是在该方法中还通过其属性factory调用了被代理类的produceCloth()方法；
从而达到了静态代理的效果。

ps：被代理类也可以为实现了ClothFactory接口的其他类，如AdidasClothFactory。

二.动态代理

与静态代理相比，动态代理需要解决的两个问题：
1.如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
2.当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法。

ps：也就是说代理类的对象是根据被代理类的对象动态生成的。
直接上代码：（详情看代码中的注释）

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @Author: YuShiwen
 * @Date: 2020/11/5 3:56 PM
 * @Version: 1.0
 */

/*
* 与静态代理相比，动态代理需要解决的两个问题：
* 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
* 问题二：当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法。
* */

interface ShoesFactory{
      
    void produceShoes();
    void produceCasualShoes();
}

//被代理类
class PumaShoesFactory implements ShoesFactory{
      
    @Override
    public void produceShoes() {
      
        System.out.println("Puma工厂开始生产运动鞋！");
    }

    @Override
    public void produceCasualShoes() {
      
        System.out.println("Puma工厂开始生产休闲鞋！");
    }
}


/************************根据被代理类动态生产代理类************************/
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
    // 第一个参数proxy为代理类的对象；
    // 第二个参数method是代理类对象调的是什么方法，这里就是什么方法；
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      

        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法。
        //obj:被代理类的对象
        Object value = method.invoke(obj, args);
        //上述方法的返回值就作为当前类中的invoke()方法的返回值
        return value;

    }
}
/************************根据被代理类动态生产代理类************************/



public class DynamicProxyTest {
      
    public static void main(String[] args) {
      
        PumaShoesFactory pumaShoesFactory = new PumaShoesFactory();
        //proxyInstance为代理类的对象
        ShoesFactory proxyInstance = (ShoesFactory) ProxyFactory.getProxyInstance(pumaShoesFactory);
        //当通过代理类对象调用方法时，会自动的调用被代理类中的同名的方法。
        proxyInstance.produceShoes();
        proxyInstance.produceCasualShoes();

        System.out.println("************下面用前面提到的静态代理类作为参数**************");

        PumaClothFactory pumaClothFactory = new PumaClothFactory();
        ClothFactory proxyInstance1 = (ClothFactory) ProxyFactory.getProxyInstance(pumaClothFactory);
        proxyInstance1.produceCloth();

        AdidasClothFactory adidasClothFactory = new AdidasClothFactory();
        ClothFactory proxyInstance2 = (ClothFactory) ProxyFactory.getProxyInstance(adidasClothFactory);
        proxyInstance2.produceCloth();
    }
}

运行结果：

Puma工厂开始生产运动鞋！
Puma工厂开始生产休闲鞋！
************下面用前面提到的静态代理类作为参数**************
Puma工厂正在生产服装！
Adidas工厂正在生产服装！

Process finished with exit code 0

三.动态代理添加通用方法

可以看到上述动态代理中，调用生产鞋的方法和生产服装的方法时没有做生产前的处理和生产后的处理，下面我们将创建一个类，在该类中添加两个方法作为其共用方法。
在上述二的代码基础上添加如下类：

//如下类中的方法作为共用的方法
class ProxyFactoryUtil{
        
    public void method0(){
        
        System.out.println("++++++++++++工厂生产产品前期做准备+++++++++++");
    }

    public void method1(){
        
        System.out.println("++++++++++++工厂生产产品后期做准备+++++++++++");
    }
}

更改MyInvocationHandler类，改后代码如下：

class MyInvocationHandler implements InvocationHandler{
          private Object obj;//赋值时需要使用被代理类的对象进行赋值 public void bind(Object obj){
          this.obj = obj; } //当我们通过代理类的对象调用方法a时，就会自动调用如下的invoke方法 //将被代理类要执行的方法a的功能就声明在invoke()中，解决问题二。 @Override // 第一个参数proxy为代理类的对象； // 第二个参数method是代理类对象调的是什么方法，这里就是什么方法； public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          ProxyFactoryUtil util = new ProxyFactoryUtil(); util.method0(); //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法。 //obj:被代理类的对象 Object value = method.invoke(obj, args); util.method1(); //上述方法的返回值就作为当前类中的invoke()方法的返回值 return value; } } 

运行结果：

++++++++++++工厂生产产品前期做准备+++++++++++ Puma工厂开始生产运动鞋！ ++++++++++++工厂生产产品后期做准备+++++++++++ ++++++++++++工厂生产产品前期做准备+++++++++++ Puma工厂开始生产休闲鞋！ ++++++++++++工厂生产产品后期做准备+++++++++++ ************下面用前面提到的静态代理类作为参数************** ++++++++++++工厂生产产品前期做准备+++++++++++ Puma工厂正在生产服装！ ++++++++++++工厂生产产品后期做准备+++++++++++ ++++++++++++工厂生产产品前期做准备+++++++++++ Adidas工厂正在生产服装！ ++++++++++++工厂生产产品后期做准备+++++++++++ Process finished with exit code 0