1、代理模式与动态代理

代理设计模式的原理:

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

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

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

动态代理使用场合:

  • 调试
  • 远程方法调用

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

2、静态代理举例

  1. /**
  2.  * 静态代理举例
  3.  *
  4.  * 特点：代理类和被代理类在编译期间，就确定下来了。
  5.  */
  6. interface ClothFactory{
  7.     void produceCloth();
  8. }
  10. //代理类
  11. class PersonTest implements ClothFactory{
  12.     private ClothFactory factory;//用被代理类对象进行实例化
  14.     public PersonTest(ClothFactory factory){
  15.         this.factory = factory;
  16.     }
  18.     @Override
  19.     public void produceCloth() {
  20.         System.out.println("造纸厂开始做一些准备工作");
  22.         factory.produceCloth();
  24.         System.out.println("造纸厂做一些后续收尾工作");
  25.     }
  26. }
  28. //被代理类
  29. class NeckTest implements ClothFactory{
  31.     @Override
  32.     public void produceCloth() {
  33.         System.out.println("造纸厂计划生产一批卫生纸");
  34.     }
  35. }
  37. public class StaticProxyTest {
  38.     public static void main(String[] args) {
  39.         //创建被代理类的对象
  40.         ClothFactory word = new NeckTest();
  42.         //创建代理类的对象
  43.         ClothFactory proxyPaperFactory = new PersonTest(word);
  45.         proxyPaperFactory.produceCloth();
  46.     }
  47. }

3、动态代理举例

  1. import java.lang.reflect.InvocationHandler;
  2. import java.lang.reflect.Method;
  3. import java.lang.reflect.Proxy;
  5. /**
  6.  * 动态代理举例
  7.  */
  8. interface Moon{
  9.     String getBelief();
  11.     void Object(String Moon);
  12. }
  14. //被代理类
  15. class Venus implements Moon{
  18.     @Override
  19.     public String getBelief() {
  20.         return "The only planet in the solar system without a magnetic field.";
  21.     }
  23.     @Override
  24.     public void Object(String MinMoon) {
  25.         System.out.println("周围有很多" + MinMoon);
  26.     }
  27. }
  29. /**
  30.  * 要想实现动态代理，需要解决的问题？
  31.  * 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
  32.  * 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
  33.  */
  34. class BookTest{
  36.     //调用此方法，返回一个代理类的对象。解决问题一
  37.     public static Object getProxyInstance(Object obj){//obj:被代理类的对象
  38.         DeskTest hander = new DeskTest();
  39.         hander.bind(obj);
  40.         return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),hander);
  41.     }
  42. }
  44. class DeskTest implements InvocationHandler{
  46.     private Object obj;//需要使用被代理类的对象进行赋值
  48.     public void bind(Object obj){
  49.         this.obj = obj;
  50.     }
  52.     //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
  53.     //将被代理类要执行的方法a的功能就声明在invoke()中
  54.     @Override
  55.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  57.         //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
  58.         //obj:被代理类的对象
  59.         Object returnValue = method.invoke(obj,args);
  61.         //上述方法的返回值就作为当前类中的invoke()的返回值。
  62.         return returnValue;
  63.     }
  64. }
  66. public class ProductTest {
  67.     public static void main(String[] args) {
  68.         Venus superMan = new Venus();
  69.         //NumTest:代理类的对象
  70.         Moon NumTest = (Moon) BookTest.getProxyInstance(superMan);
  71.         //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
  72.         String belief = NumTest.getBelief();
  73.         System.out.println(belief);
  74.         NumTest.Object("四川大巴山");
  76.         System.out.println("+++++++++++++++++++");
  78.         NeckTest fox = new NeckTest();
  79.         ClothFactory ween = (ClothFactory) BookTest.getProxyInstance(fox);
  81.         ween.produceCloth();
  82.     }
  83. }

4、AOP与动态代理的举例

image.png

  • 改进后的说明：代码段1、代码段2、代码段3和深色代码段分离开了，但代码段1、2、3又和一个特定的方法A耦合了！最理想的效果是：代码块1、2、3既可以执行方法A，又无须在程序中以硬编码的方式直接调用深色代码的方法。
  • 使用Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理
  • 这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理。



image.png

  1. /**
  2.  * 静态代理举例
  3.  *
  4.  * 特点：代理类和被代理类在编译期间，就确定下来了。
  5.  */
  6. interface ClothFactory{
  7.     void produceCloth();
  8. }
  10. //代理类
  11. class PersonTest implements ClothFactory{
  12.     private ClothFactory factory;//用被代理类对象进行实例化
  14.     public PersonTest(ClothFactory factory){
  15.         this.factory = factory;
  16.     }
  18.     @Override
  19.     public void produceCloth() {
  20.         System.out.println("造纸厂开始做一些准备工作");
  22.         factory.produceCloth();
  24.         System.out.println("造纸厂做一些后续收尾工作");
  25.     }
  26. }
  28. //被代理类
  29. class NeckTest implements ClothFactory{
  31.     @Override
  32.     public void produceCloth() {
  33.         System.out.println("造纸厂计划生产一批卫生纸");
  34.     }
  35. }
  37. public class StaticProxyTest {
  38.     public static void main(String[] args) {
  39.         //创建被代理类的对象
  40.         ClothFactory word = new NeckTest();
  42.         //创建代理类的对象
  43.         ClothFactory proxyPaperFactory = new PersonTest(word);
  45.         proxyPaperFactory.produceCloth();
  46.     }
  47. }
  1. package github4;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. /**
  8.  * 动态代理举例
  9.  */
  10. interface Moon{
  11.     String getBelief();
  13.     void Object(String Moon);
  14. }
  16. //被代理类
  17. class Venus implements Moon{
  20.     @Override
  21.     public String getBelief() {
  22.         return "The only planet in the solar system without a magnetic field.";
  23.     }
  25.     @Override
  26.     public void Object(String MinMoon) {
  27.         System.out.println("周围有很多" + MinMoon);
  28.     }
  29. }
  31. /**
  32.  * 要想实现动态代理，需要解决的问题？
  33.  * 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
  34.  * 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
  35.  */
  36. class BookTest{
  38.     //调用此方法，返回一个代理类的对象。解决问题一
  39.     public static Object getProxyInstance(Object obj){//obj:被代理类的对象
  40.         DeskTest hander = new DeskTest();
  41.         hander.bind(obj);
  42.         return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),hander);
  43.     }
  44. }
  46. class DeskTest implements InvocationHandler{
  48.     private Object obj;//需要使用被代理类的对象进行赋值
  50.     public void bind(Object obj){
  51.         this.obj = obj;
  52.     }
  54.     //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
  55.     //将被代理类要执行的方法a的功能就声明在invoke()中
  56.     @Override
  57.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  58.         SunTest util = new SunTest();
  59.         util.Star();
  61.         //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
  62.         //obj:被代理类的对象
  63.         Object returnValue = method.invoke(obj,args);
  65.         util.Star2();
  67.         //上述方法的返回值就作为当前类中的invoke()的返回值。
  68.         return returnValue;
  69.     }
  70. }
  72. class SunTest{
  74.     public void Star(){
  75.         System.out.println("====================通用方法一====================");
  77.     }
  79.     public void Star2(){
  80.         System.out.println("====================通用方法二====================");
  81.     }
  83. }
  85. public class ProductTest {
  86.     public static void main(String[] args) {
  87.         Venus superMan = new Venus();
  88.         //NumTest:代理类的对象
  89.         Moon NumTest = (Moon) BookTest.getProxyInstance(superMan);
  90.         //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
  91.         String belief = NumTest.getBelief();
  92.         System.out.println(belief);
  93.         NumTest.Object("四川大巴山");
  95.         System.out.println("+++++++++++++++++++");
  97.         NeckTest fox = new NeckTest();
  98.         ClothFactory ween = (ClothFactory) BookTest.getProxyInstance(fox);
  100.         ween.produceCloth();
  101.     }
  102. }