设计模式之动态代理

一、代理的简要介绍
　　1、ProxyPattern（即：代理模式），23种常用的面向对象软件的设计模式之一

   　　2、代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

​ 　　  3、作用：增强一个类中的某个方法.对程序进行扩展，Spring框架中AOP。

二、动态代理介绍
1、动态代理：

• ​ 动态代理它可以直接给某一个目标(被代理 对象)对象(实现了某个或者某些接口)生成一个代理对象，而不需要代理类存在，如上图中经理人需要存在。
• ​ 动态代理与代理模式原理是一样的，只是它没有具体的代理类，直接通过反射生成了一个代理对象

　2、动态代理的分类

• jdk提供一个Proxy类可以直接给实现接口类的对象直接生成代理对象 API: 调用, 缺少什么参数,传什么
• ​ spring中动态代理:cglib 继承

 

3、动态代理作用

• 最终是学习AOP（面向切面编程），它与装饰者模式有点相似，它比装饰者模式还要灵活！

 

   三、jdk中的动态代理

　　1、Java.lang.reflect.Proxy类可以直接生成一个代理对象

• Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)生成一个代理对象

  • 参数1:ClassLoader loader 代理对象的类加载器 一般使用被代理对象的类加载器

  • 参数2:Class<?>[] interfaces 代理对象的要实现的接口 一般使用的被代理对象实现的接口

  • 参数3:InvocationHandler h (接口)执行处理类

• InvocationHandler中的invoke(Object proxy, Method method, Object[] args)方法：调用代理类的任何方法，此方法都会执行

  • 参数3.1:代理对象(慎用)

  • 参数3.2:当前执行的方法

  • 参数3.3:当前执行的方法运行时传递过来的参数

    • 返回值:当前方法执行的返回值

2、Proxy.newProxyInstance方法参数介绍

• ClassLoader：类加载器！
  • 它是用来加载器的，把.class文件加载到内存，形成Class对象！

 

• Class[]　interfaces：指定要实现的接口们
• InvocationHandler：代理对象的所有方法(个别不执行，getClass())都会调用InvocationHandler的invoke()方法。

3、InvocationHandler方法参数介绍

　　public Object invoke(Object proxy, Method method, Object[] args);

　　这个invoke()方法在什么时候被调用！在调用代理对象所实现接口中的方法时

• Object proxy：当前对象，即代理对象！在调用谁的方法！
• Method method：当前被调用的方法（目标方法）
• Object[] args：实参！

4、简单示例

import org.junit.Test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyDemo {
    @Test
    public void test(){
        Person woman = new Woman();
        Person person =(Person) Proxy.newProxyInstance(woman.getClass().getClassLoader(),
                woman.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //增强sleep方法
                        if ("sleep".equals(method.getName())) {
                            System.out.println("大字睡姿.....");
                            return null;
                        }
                        return method.invoke(woman, args);
                    }
                });
        person.eat();
        person.sleep();
        String s = person.run("快步跑");
        System.out.println(s);
    }

    interface Person{
        void eat();
        void sleep();
        String run(String state);
    }

    class Woman implements Person{

        @Override
        public void eat() {
            System.out.println("小口吃...");
        }

        @Override
        public void sleep() {
            System.out.println("淑女睡...");
        }

        @Override
        public String run(String state) {
            return "Woman" + state + "......";
        }
    }
}

 

四、动态代理模型

• 目标对象：被增强的对象
• 代理对象：需要目标对象，然后在目标对象上添加了增强后的对象！
• 目标方法：增强的内容
• 代理对象 = 目标对象 + 增强

 

五、案例
案例1:Waiter

 1 package demo2;
 2 
 3 import org.junit.Test; 4 import java.lang.reflect.InvocationHandler; 5 import java.lang.reflect.Method; 6 import java.lang.reflect.Proxy; 7 8 public class Demo2 { 9  @Test 10 public void fun1() { 11 Waiter manWaiter = new ManWaiter(); 12 /* 13 * 给出三个参数，来创建方法，得到代理对象 14 * */ 15 ClassLoader loader = this.getClass().getClassLoader(); 16 Class[] interfaces = {Waiter.class}; 17 InvocationHandler h = new WaiterInvocationHandler(manWaiter);//参数manWaiter类表示目标对象 18 //得到代理对象，代理对象就是在目标对象的基础上进行了增强的对象！ 19 Waiter waiterProxy = (Waiter) Proxy.newProxyInstance(loader,interfaces,h); 20 waiterProxy.serve();//前面添加"你好"，后面添加"再见" 21 22  } 23 } 24 class WaiterInvocationHandler implements InvocationHandler { 25 private Waiter waiter;//目标对象 26 27 public WaiterInvocationHandler(Waiter waiter) { 28 this.waiter = waiter; 29  } 30  @Override 31 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 32 System.out.println("您好！"); 33 this.waiter.serve();//调用目标对象的目标方法 34 System.out.println("再见！"); 35 return null; 36  } 37 }

1 package demo2;
2 
3 public class ManWaiter implements Waiter { 4  @Override 5 public void serve() { 6 System.out.println("服务中..."); 7  } 8 }

1 package demo2;
2 
3 //服务
4 public interface Waiter { 5 //服务 6 public void serve(); 7 }

 案例2：

 1 /**
 2  * 目标是让目标对象和增强都可以切换！
 3  */
 4 public class Demo3 {
 5  @Test 6 public void fun1() { 7 ProxyFactory factory = new ProxyFactory(); 8 factory.setTargetObject(new ManWaiter()); 9 factory.setBeforeAdvice(new BeforeAdvice() { //设置前置增强 10  @Override 11 public void before() { 12 System.out.println("您好！"); 13  } 14  }); 15 factory.setAfterAdvice(new AfterAdvice() { //设置后置增强 16  @Override 17 public void after() { 18 System.out.println("再见！"); 19  } 20  }); 21 22 Waiter waiter = (Waiter) factory.createProxy(); 23  waiter.serve(); 24  } 25 }

 1 package demo3;
 2 
 3 import java.lang.reflect.InvocationHandler; 4 import java.lang.reflect.Method; 5 import java.lang.reflect.Proxy; 6 7 /** 8 * 它用来生成代理对象 9 * 它需要所有的参数 10 * 目标对象 11 * 增强 12 */ 13 /* 14 * 1、创建代理工厂 15 * 2、给工厂设置三样东西： 16 * 目标对象：setTargetObject(XXX); 17 * 前置增强：setBeforeAdvice(该接口的实现) 18 * 后置增强：setAfterAdvice（该接口的实现） 19 * 3、调用createProxy（）得到代理对象 20 * 执行代理对象方法时： 21 * 执行BeforeAdvice的before（） 22 * 目标对象的目标方法 23 * 执行AfterAdvice的after（） 24 * */ 25 public class ProxyFactory { 26 private Object targetObject;//目标对象 27 private BeforeAdvice beforeAdvice;//前置增强 28 private AfterAdvice afterAdvice;//后置增强 29 30 //用来生成代理对象 31 public Object createProxy() { 32 /* 33 * 1、给出三大参数 34 * */ 35 ClassLoader loader = this.getClass().getClassLoader(); 36 Class[] interfaces = targetObject.getClass().getInterfaces(); 37 InvocationHandler h = new InvocationHandler() { 38  @Override 39 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 40 /* 41 * 在调用代理对象的方法时会执行这里的内容 42 * */ 43 //执行前置增强 44 if (beforeAdvice != null) { 45  beforeAdvice.before(); 46  } 47 Object result = method.invoke(targetObject,args);//执行目标对象的目标方法 48 //执行后置增强 49 if (afterAdvice != null) { 50  afterAdvice.after(); 51  } 52 return result; 53  } 54  }; 55 //2、得到代理对象 56 Object proxObject = Proxy.newProxyInstance(loader,interfaces,h); 57 return proxObject; 58  } 59 public Object getTargetObject() { 60 return targetObject; 61  } 62 public void setTargetObject(Object targetObject) { 63 this.targetObject = targetObject; 64  } 65 public BeforeAdvice getBeforeAdvice() { 66 return beforeAdvice; 67  } 68 public void setBeforeAdvice(BeforeAdvice beforeAdvice) { 69 this.beforeAdvice = beforeAdvice; 70  } 71 public AfterAdvice getAfterAdvice() { 72 return afterAdvice; 73  } 74 public void setAfterAdvice(AfterAdvice afterAdvice) { 75 this.afterAdvice = afterAdvice; 76  } 77 }

1 /**
2  * 前置增强
3  */
4 public interface BeforeAdvice {
5     public void before(); 6 }

1 /**
2  * 后置增强
3  */
4 public interface AfterAdvice {
5     public void after(); 6 }

 案例2类图：