一.前言
为了让我们更好的理解动态代理，让我们先来了解一下静态代理。
静态代理的特点是：代理类和被代理类在编译期间，就确定下来了。
先直接上代码
//代理类与被代理类需要实现的接口interfaceClothFactory{ voidproduceCloth(); } //代理类classProxyClothFactoryimplementsClothFactory{ //用被代理类对象进行实例化privateClothFactoryfactory; publicClothFactorygetFactory() { returnfactory; } publicvoidsetFactory(ClothFactoryfactory) { this.factory=factory; } publicProxyClothFactory(ClothFactoryfactory){ this.factory=factory; } publicvoidproduceCloth() { //代理类做一些前期准备工作，这里直接用输出语句简写System.out.println("代理类做一些准备工作-------------"); //调用被代理类factory.produceCloth(); //代理类做一些后期收尾工作，这里直接用输出语句简写System.out.println("代理类做一些收尾工作-------------"); } } //被代理类0classPumaClothFactoryimplementsClothFactory{ publicvoidproduceCloth() { System.out.println("Puma工厂正在生产服装！"); } } //被代理类1classAdidasClothFactoryimplementsClothFactory{ publicvoidproduceCloth() { System.out.println("Adidas工厂正在生产服装！"); } } publicclassStaticProxyTest { publicstaticvoidmain(String[] args) { //创建被代理类0的对象PumaClothFactorypuma=newPumaClothFactory(); //创建代理类的对象，在构造起中传入被代理类作为实参ProxyClothFactoryproxyClothFactory=newProxyClothFactory(puma); //调用代理类对象的produceCloth()方法，// 实际上在代理类对象的produceCloth()方法中调用了被代理类对象的produceCloth()方法，实现静态代理proxyClothFactory.produceCloth(); System.out.println(); //创建被代理类1的对象AdidasClothFactoryadidas=newAdidasClothFactory(); //把被代理类对象改为adidasproxyClothFactory.setFactory(adidas); //调用代理类对象的produceCloth()方法proxyClothFactory.produceCloth(); } }
输出结果：
代理类做一些准备工作-------------Puma工厂正在生产服装！代理类做一些收尾工作-------------代理类做一些准备工作-------------Adidas工厂正在生产服装！代理类做一些收尾工作-------------Processfinishedwithexitcode0
分析：
上述代码中代理类与被代理类都实现了同一个接口ClothFactory；
在被代理类中实现了接口的produceCloth()方法；
在代理类中声明了被代理类对象作为其属性，然后又在代理类的有参构造起中对其属性进行赋值；
在代理类中同样也实现了produceCloth()方法，但是在该方法中还通过其属性factory调用了被代理类的produceCloth()方法；
从而达到了静态代理的效果。
ps：被代理类也可以为实现了ClothFactory接口的其他类，如AdidasClothFactory。
二.动态代理
与静态代理相比，动态代理需要解决的两个问题：
1.如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
2.当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法。
ps：也就是说代理类的对象是根据被代理类的对象动态生成的。
直接上代码：（详情看代码中的注释）
importjava.lang.reflect.InvocationHandler; importjava.lang.reflect.Method; importjava.lang.reflect.Proxy; /*** @Author: YuShiwen* @Date: 2020/11/5 3:56 PM* @Version: 1.0*//** 与静态代理相比，动态代理需要解决的两个问题：* 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。* 问题二：当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法。* */interfaceShoesFactory{ voidproduceShoes(); voidproduceCasualShoes(); } //被代理类classPumaShoesFactoryimplementsShoesFactory{ publicvoidproduceShoes() { System.out.println("Puma工厂开始生产运动鞋！"); } publicvoidproduceCasualShoes() { System.out.println("Puma工厂开始生产休闲鞋！"); } } /************************根据被代理类动态生产代理类************************/classProxyFactory{ //调用此方法返回一个代理类的对象，解决问题一；//即根据传入的被代理类对象，动态的创建一个代理类和其对象publicstaticObjectgetProxyInstance(Objectobj){//obj:被代理类的对象MyInvocationHandlerhandler=newMyInvocationHandler(); handler.bind(obj); returnProxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler); } } //classMyInvocationHandlerimplementsInvocationHandler{ privateObjectobj;//赋值时需要使用被代理类的对象进行赋值publicvoidbind(Objectobj){ this.obj=obj; } //当我们通过代理类的对象调用方法a时，就会自动调用如下的invoke方法//将被代理类要执行的方法a的功能就声明在invoke()中，解决问题二。// 第一个参数proxy为代理类的对象；// 第二个参数method是代理类对象调的是什么方法，这里就是什么方法；publicObjectinvoke(Objectproxy, Methodmethod, Object[] args) throwsThrowable { //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法。//obj:被代理类的对象Objectvalue=method.invoke(obj, args); //上述方法的返回值就作为当前类中的invoke()方法的返回值returnvalue; } } /************************根据被代理类动态生产代理类************************/publicclassDynamicProxyTest { publicstaticvoidmain(String[] args) { PumaShoesFactorypumaShoesFactory=newPumaShoesFactory(); //proxyInstance为代理类的对象ShoesFactoryproxyInstance= (ShoesFactory) ProxyFactory.getProxyInstance(pumaShoesFactory); //当通过代理类对象调用方法时，会自动的调用被代理类中的同名的方法。proxyInstance.produceShoes(); proxyInstance.produceCasualShoes(); System.out.println("************下面用前面提到的静态代理类作为参数**************"); PumaClothFactorypumaClothFactory=newPumaClothFactory(); ClothFactoryproxyInstance1= (ClothFactory) ProxyFactory.getProxyInstance(pumaClothFactory); proxyInstance1.produceCloth(); AdidasClothFactoryadidasClothFactory=newAdidasClothFactory(); ClothFactoryproxyInstance2= (ClothFactory) ProxyFactory.getProxyInstance(adidasClothFactory); proxyInstance2.produceCloth(); } }
运行结果：
Puma工厂开始生产运动鞋！Puma工厂开始生产休闲鞋！************下面用前面提到的静态代理类作为参数**************Puma工厂正在生产服装！Adidas工厂正在生产服装！Processfinishedwithexitcode0
三.动态代理添加通用方法
可以看到上述动态代理中，调用生产鞋的方法和生产服装的方法时没有做生产前的处理和生产后的处理，下面我们将创建一个类，在该类中添加两个方法作为其共用方法。
在上述二的代码基础上添加如下类：
//如下类中的方法作为共用的方法classProxyFactoryUtil{ publicvoidmethod0(){ System.out.println("++++++++++++工厂生产产品前期做准备+++++++++++"); } publicvoidmethod1(){ System.out.println("++++++++++++工厂生产产品后期做准备+++++++++++"); } }
更改MyInvocationHandler类，改后代码如下：
classMyInvocationHandlerimplementsInvocationHandler{ privateObjectobj;//赋值时需要使用被代理类的对象进行赋值publicvoidbind(Objectobj){ this.obj=obj; } //当我们通过代理类的对象调用方法a时，就会自动调用如下的invoke方法//将被代理类要执行的方法a的功能就声明在invoke()中，解决问题二。// 第一个参数proxy为代理类的对象；// 第二个参数method是代理类对象调的是什么方法，这里就是什么方法；publicObjectinvoke(Objectproxy, Methodmethod, Object[] args) throwsThrowable { ProxyFactoryUtilutil=newProxyFactoryUtil(); util.method0(); //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法。//obj:被代理类的对象Objectvalue=method.invoke(obj, args); util.method1(); //上述方法的返回值就作为当前类中的invoke()方法的返回值returnvalue; } }
运行结果：
++++++++++++工厂生产产品前期做准备+++++++++++Puma工厂开始生产运动鞋！++++++++++++工厂生产产品后期做准备+++++++++++++++++++++++工厂生产产品前期做准备+++++++++++Puma工厂开始生产休闲鞋！++++++++++++工厂生产产品后期做准备+++++++++++************下面用前面提到的静态代理类作为参数**************++++++++++++工厂生产产品前期做准备+++++++++++Puma工厂正在生产服装！++++++++++++工厂生产产品后期做准备+++++++++++++++++++++++工厂生产产品前期做准备+++++++++++Adidas工厂正在生产服装！++++++++++++工厂生产产品后期做准备+++++++++++Processfinishedwithexitcode0
