java设计模式之代理模式
什么是代理模式
简单说即是在不改变源码的情况下，实现对目标对象的功能扩展。
场景举例
生活场景我以买吃的为例（吃货的世界），买吃的去的是超市而不是食品厂，这个时候超市就是代理的角色，
1,静态代理
1）创建买吃的接口
public interface IBuyfoot { //买吃的 void buyfoot(); }
2）创建一个买吃的人
public class Customer implements IBuyFood { private int cash;//购物款 public int getCash() { return cash; } public void setCash(int cash) { this.cash = cash; } @Override public void buyFood() { Log.e("buyFood", "买吃的花费了-->" + cash + "元"); } }
3.）声明一个食物代理，同样也实现买吃的的接口，帮助客户送吃的
public class BuyFoodProxy implements IBuyFood{ private Customer customer;//接收mairou的顾客 public BuyFoodProxy(Customer customer){ this.customer=customer;//接收买rou顾客 } @Override public void buyFood() {//实现买 吃的开吃 customer.buyFood(); } }
//测试 Customer customer=new Customer(); customer.setCash(120); BuyFoodProxy buyFoodProxy=new BuyFoodProxy(customer); buyFoodProxy.buyCar();
总结，静态代理很容易理解，无非就是代理类和要实现的类实现同样的接口，构造函数实现对目标类的初始化，重写方法时调用目标类的方法。这样的缺点是代理对象必须提前写出，如果接口层发生了变化，代理对象的代码也要进行维护，因此，动态代理应运而生。
2，动态代理（jdk动态代理）
开始和静态代理的一样对Customer进行扩展
public interface IBuyfoot { //买吃的 void buyfoot(); }
//
public class Customer implements IBuyFood {
private int cash;//购物款
public int getCash() {
return cash;
}
public void setCash(int cash) {
this.cash = cash;
}
@Override
public void buyFood() {
Log.e("buyFood", "买吃的花费了-->" + cash + "元");
}
}
这回直接上测试，由于java底层封装了实现细节（之后会详细讲），所以代码非常简单，格式也基本上固定。
调用Proxy类的静态方法newProxyInstance即可，该方法会返回代理类对象
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h ) |
接收的三个参数依次为:
ClassLoader loader：指定当前目标对象使用类加载器，写法固定Class<?>[] interfaces：目标对象实现的接口的类型，写法固定InvocationHandler h：事件处理接口，需传入一个实现类，一般直接使用匿名内部类
测试代码
1public class Test{ 2 public static void main(String[] args) { 3 Coutomer target = new Coutomer(); 4 IBuyFood proxy = (IBuyFood) Proxy.newProxyInstance( 5 target.getClass().getClassLoader(), 6 target.getClass().getInterfaces(), 7 new InvocationHandler() { 8 @Override 9 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 10 System.out.println("向观众问好"); 11 //执行目标对象方法 12 Object returnValue = method.invoke(target, args); 13 System.out.println("谢谢大家"); 14 return returnValue; 15 } 16 }); 17 proxy.buyFood(); 18 } 19 }
总结：以上代码只有标黄的部分是需要自己写出，其余部分全都是固定代码。由于java封装了newProxyInstance这个方法的实现细节，所以使用起来才能这么方便，具体的底层原理将会在下一小节说明。
缺点：可以看出静态代理和JDK代理有一个共同的缺点，就是目标对象必须实现一个或多个接口，加入没有，则可以使用Cglib代理。
3.Cglib代理
前提条件：
- 需要引入cglib的jar文件，由于Spring的核心包中已经包括了Cglib功能，所以也可以直接引入spring-core.jar
- 目标类不能为final
- 目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法
1 /**
2 * 目标对象,没有实现任何接口
3 */
4 public class Singer{
5
6 public void sing() {
7 System.out.println("唱一首歌");
8 }
9 }
1 /**
2 * Cglib子类代理工厂
3 */
4 public class ProxyFactory implements MethodInterceptor{
5 // 维护目标对象
6 private Object target;
7
8 public ProxyFactory(Object target) {
9 this.target = target;
10 }
11
12 // 给目标对象创建一个代理对象
13 public Object getProxyInstance(){
14 //1.工具类
15 Enhancer en = new Enhancer();
16 //2.设置父类
17 en.setSuperclass(target.getClass());
18 //3.设置回调函数
19 en.setCallback(this);
20 //4.创建子类(代理对象)
21 return en.create();
22 }
23
24 @Override
25 public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
26 System.out.println("向观众问好");
27 //执行目标对象的方法
28 Object returnValue = method.invoke(target, args);
29 System.out.println("谢谢大家");
30 return returnValue;
31 }
32 }
这里的代码也非常固定，只有标黄部分是需要自己写出
测试
1 /**
2 * 测试类
3 */
4 public class Test{
5 public static void main(String[] args){
6 //目标对象
7 Singer target = new Singer();
8 //代理对象
9 Singer proxy = (Singer)new ProxyFactory(target).getProxyInstance();
10 //执行代理对象的方法
11 proxy.sing();
12 }
13 }
总结：三种代理模式各有优缺点和相应的适用范围，主要看目标对象是否实现了接口。以Spring框架所选择的代理模式举例
在Spring的AOP编程中：
如果加入容器的目标对象有实现接口，用JDK代理
如果目标对象没有实现接口，用Cglib代理
