设计格局之动态代理

一、代理的简要介绍
  1、ProxyPattern(即:代理模式),23种常用的面向对象软件的设计模式之一

 
   2、代理情势的定义:为另外对象提供一种代理以控制对这一个目标的访问。在好几情况下,一个目的不切合或者不可以一向引用另一个对象,而代理对象可以在客户端和目的对象之间起到中介的成效。

​   
 3、功能:增强一个类中的某个方法.对先后进行扩大,Spring框架中AOP。

图片 1

二、动态代理介绍
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对象!

图片 2

 

  • Class[] interfaces:指定要贯彻的接口们
  • InvocationHandler:代理对象的拥有办法(个别不履行,getClass())都会调用InvocationHandler的invoke()方法。

3、InvocationHandler方法参数介绍

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

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

图片 3

  • Object proxy:当前目标,即代理对象!在调用谁的点子!
  • Method method:当前被调用的法门(目标措施)
  • Object[] args:实参!

4、简单示例

 1 import org.junit.Test;
 2 import java.lang.reflect.InvocationHandler;
 3 import java.lang.reflect.Method;
 4 import java.lang.reflect.Proxy;
 5 
 6 public class ProxyDemo {
 7     @Test
 8     public void test(){
 9         Person woman = new Woman();
10         Person person =(Person) Proxy.newProxyInstance(woman.getClass().getClassLoader(),
11                 woman.getClass().getInterfaces(),
12                 new InvocationHandler() {
13                     @Override
14                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
15                         //增强sleep方法
16                         if ("sleep".equals(method.getName())) {
17                             System.out.println("大字睡姿.....");
18                             return null;
19                         }
20                         return method.invoke(woman, args);
21                     }
22                 });
23         person.eat();
24         person.sleep();
25         String s = person.run("快步跑");
26         System.out.println(s);
27     }
28 
29     interface Person{
30         void eat();
31         void sleep();
32         String run(String state);
33     }
34 
35     class Woman implements Person{
36 
37         @Override
38         public void eat() {
39             System.out.println("小口吃...");
40         }
41 
42         @Override
43         public void sleep() {
44             System.out.println("淑女睡...");
45         }
46 
47         @Override
48         public String run(String state) {
49             return "Woman" + state + "......";
50         }
51     }
52 }

 

四、动态代理模型
  • 目标对象:被提升的目标
  • 代办对象:需要目的对象,然后在目的对象上添加了增进后的靶子!
  • 对象措施:增强的情节
  • 代理对象 = 目的对象 + 增强

图片 4

 

五、案例
案例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类图:图片 5

 

相关文章