设计模式之动态代理

一、代理的简要介绍
　　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类图：