java 设计模式 代理模式

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

静态代理

涉及到的对象
代理类 CustommerProxy ，授代理类 ICustommer，分别都要实现接口
关系图如下

场景示例：
现假如我客户Custommer类是由A程序员开发的，Custommer类中有一个dosometing方法。
现有程序员B，他是毕业生，刚过来，程序员A给他发了一个包，没有源代码，并跟小B说需要对这个方法进行优化，需要在调用dosometing之前先校验该用户是否登录了。那么问题来了，小B在不知道源代码的情况下，如何进行代码重构

由于小B比较优秀，很快就想到了代理模式，所以当当的就写下了如下代码
接口类，由于代理类和被代理类

package com.cmh.service;

public interface Custommer {
    void dosomething();

}

被代理类的实现类

public class ICustommer implements Custommer{

    @Override
    public void dosomething() {
        // TODO Auto-generated method stub
        System.out.println("I have something");
    }

}

代理类的实现类

public class CustommerProxy implements Custommer{

    private ICustommer custommer;

    public CustommerProxy(ICustommer custommer){
        this.custommer = custommer;
    }

    @Override
    public void dosomething() {
        // TODO Auto-generated method stub
        System.out.println("do something before");
        custommer.dosomething();
        System.out.println("do something after");
    }

}

测试类

public static void main(String[] args) {
        pack();
    }

    public static void pack(){
        ICustommer cus = new ICustommer();
        Custommer proxy = new CustommerProxy(cus);
        proxy.dosomething();
    }

小B觉得这个也太他妈简单了，于是就屁颠屁颠的跟他老大小A说，so easy，准备听听他老大好好的夸他，他老大一看代码，哎不错哦，这小子是可塑之才，当场就跟他说，小伙子，不错嘛，那我再考考你，假如现在项目出现了变动，就是说我不仅在Custommer 需要改这个逻辑，我在其他类也需要这个逻辑。那么怎么办？

小B心理一阵低估，握草，你大爷，然后就屁颠屁颠的跑回去找相关的资料，突然一个字眼出现在了小B眼前，动态代理？

动态代理

动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 原来是利用反射的机制来实现的，今天我们不讨论反射，我们看JDK的动态代理的实现。

若想实现 动态代理，就必须实现InvocationHandler 接口,InvocationHandler 的参数详解

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

loader:　　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载

interfaces:　　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了

h:　　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

小B给出的代码：

接口和原先的实现类都没变

package com.cmh.service;

public interface Custommer {
    void dosomething();
    void deletesomething();

}

实现类

package com.cmh.service;

public class ICustommer implements Custommer{

    @Override
    public void dosomething() {
        // TODO Auto-generated method stub
        System.out.println("I have something");
    }

    @Override
    public void deletesomething() {
        // TODO Auto-generated method stub
        System.out.println("I have Delete something");
    }

}

动态代理类

package com.cmh.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class FactoryProxy implements InvocationHandler{

    private Object target;

    public Object getInstance(Object target) {    
        this.target = target;    
        //取得代理对象    
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        Object result=null;    
        System.out.println("before");    
        //执行方法   
        result=method.invoke(target, args);    
        System.out.println("after");
        return result;    
    }
}

测试类

public static void pack2(){
        FactoryProxy proxy = new FactoryProxy();
        Custommer custommer =(Custommer) proxy.getInstance(new ICustommer());
        custommer.dosomething();
        custommer.deletesomething();
    }

至此，动态类就差不多了，动态代理在spring AOP或者struts2 中的拦截器中用的比较多。