行为模式--代理Proxy模式（Java）

Posted 2020-09-23 zhaoqiang1980

代理（AOP切面的雏形）：

题记：顾名思义就是将某件事，某个东西的使用权进行为让授权转移。代理相当于中介（不同于中介者模式），在原本操作的类之间添加了一个桥梁。但代理不能去修改原有目标。比如：一个人要买       房，让中介帮忙给看个房，但中介不能将原有看房这件事变更为看车。他可以对看房提出各种要求和咨询。

回到程序的角度，调用者将调用某些共性类的处理交由代理类处理，代理类根据调用者的要求即满足什么情况可以调用，什么情况不能调用，（卖房者委托中介100万以上卖，100万以下不卖）对处理做前后的包装，但是代理类不能去改变被调用类的内部处理（可口可乐中国区可修改可口可乐包装，但不能在没授权情况下去更改可口可乐饮料）。

1.静态代理

2.动态代理

1.静态代理：对指定接口类做代理，通过对执行方法前后做处理，来实现代理的作用。因对指定接口类，因此可做某些特定类的特殊处理。

 1 /**
 2  * 静态代理，也被称为decate模式
 3  * 
 4  * @author DennyZhao
 5  * @date 2017年6月13日
 6  * @version 1.0
 7  */
 8 public class AnimalProxyFactory implements AnimalFactory {
 9     /**
10      * 序列号
11      */
12     private static final long serialVersionUID = -3421761900236678842L;
13     
14     
15     private AnimalFactory animal;
16     
17     public AnimalProxyFactory(AnimalFactory animal){
18         this.animal = animal;
19     }
20     @Override
21     public int getLegs() {
22         System.out.println("before....action");
23         int legs = animal.getLegs();
24         System.out.println("after....action");
25         return legs;
26     }
27 
28 }

View Code

测试Main：

　　// 静态代理
　　Rabit rabit = new Rabit();
　　AnimalProxyFactory proxyFactory = new AnimalProxyFactory(rabit);
　　System.out.println(proxyFactory.getLegs());    

运行结果： 

　　>>>before....action
　　>>>after....action
　　>>>4  

       2.动态代理：动态代理通过Proxy类创建代理，通过InvokationHandler去调用方法。

 1 package pattern.creation.factory;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileNotFoundException;
 5 import java.io.IOException;
 6 import java.lang.reflect.Proxy;
 7 import java.util.Properties;
 8 
 9 /**
10  * 动态代理模式
11  * 
12  * @author DennyZhao
13  * @date 2017年6月13日
14  * @version 1.0
15  */
16 public class ProxyFactory {
17     private static final String CLASS_NAME_PATH = "pattern/classname.properties";
18     @SuppressWarnings("unchecked")
19     public static <T> T getInstance(String name) throws IllegalArgumentException, InstantiationException, IllegalAccessException{
20         String className = getClassName(name);
21         T result = null;
22         try {
23             Class clazz = Class.forName(className);
24             result = (T)Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new MyInvocationHandler(clazz.newInstance()));
25         } catch (ClassNotFoundException e) {
26             e.printStackTrace();
27         }
28         return result;
29     }
30 
31     /**
32      * 获取类名称
33      * @return
34      */
35     private static String getClassName(String name) {
36         Properties pro = new Properties();
37         try {
38             String url = ProxyFactory.class.getClassLoader().getResource("").getPath() + CLASS_NAME_PATH;
39             pro.load(new FileInputStream(url));
40         } catch (FileNotFoundException e) {
41             e.printStackTrace();
42         } catch (IOException e) {
43             e.printStackTrace();
44         }
45         return (String)pro.get(name);
46     }
47 }

View Code

     注意* ： 代理面向的是接口，因此委托的类都需要实现指定的接口。

　　　　　　result = (T)Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new MyInvocationHandler(clazz.newInstance()));

 　　　　　　clazz.getInterfaces()：如果一个clazz实现多个接口，此处要传入接口Class。

　　　　　　MyInvocationHandler 实现 InvocationHandler接口，里面要实现一个invoke方法，在这个invoke方法中填写处理。

MyInvocationHandler 

// 可通过放射机制，来处理特殊类的特殊请求。

测试Main:

// 动态代理，AOP切面的雏形做法
AnimalFactory sheep = ProxyFactory.getInstance("sheep");
sheep.getLegs();

// 动态代理，AOP切面的做法
PlantFactory plum = ProxyFactory.getInstance("plum");
plum.getColor();

// 动态代理，AOP切面的做法
AnimalFactory rabit0 = ProxyFactory.getInstance("rabit");
rabit0.getLegs();

结果：

before-------
sheep has 4 legs....
after-------
before-------
plum green purple....
after-------
before-------
兔子是特殊的
after-------