设计模式之代理模式

动态代理

以jdk的动态代理为例，简单实现。

需要的角色：1、抽象主题。 2、真实主题。 3、动态代理的handler。4、动态代理实例proxy。5、业务场景类

代码清单如下：

/**
 * 业务场景类
 * @author haokui
 * 
 */
public class Main {
    
    /**
     * 测试方法
     * @param args
     */
    public static void main(String[] args) {
        
        //定义一个主题
        IGameplay player = new Gameplay();
        
        //定义一个handler
        InvocationHandler handler = new MyInvocationHandler(player);
        
        //定义主题的代理
        IGameplay proxy = DynamicProxy.newProxyInstance(player.getClass().getClassLoader(), player.getClass().getInterfaces(), handler);
        
        //代理的一下行为
        proxy.login("张三");
        proxy.doSomething();
    }
}
/**
 * 抽象主题
 * @author haokui
 *
 */
interface IGameplay {
    /**
     * 主题的一些行为
     */
    void login(String username);
    void doSomething();
}
/**
 * 真实主题
 * @author haokui
 *
 */
class Gameplay implements IGameplay{

    @Override
    public void login(String username) {
        System.out.println(username + "登陆成功!");
    }

    @Override
    public void doSomething() {
        System.out.println("打游戏中...");
    }
}

/**
 * 动态代理的handler类
 * @author haokui
 *
 */
class MyInvocationHandler implements InvocationHandler {
    
    //目标对象，也就是被代理的对象
    private Object target = null;
    
    //通过构造函数传递一个对象
    public MyInvocationHandler(Object obj) {
        this.target = obj;
    }
    
    /**
     * 代理方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        
        //如果是登陆，不管是谁登陆，发一个消息通知
        if (method.getName().equalsIgnoreCase("login")) {
            System.out.println("有人在使用朕的账号登陆!");
        }
        //执行被代理的方法
        return    method.invoke(this.target, args);
    }
}
/**
 * 动态代理类，产生代理对象
 * @author haokui
 *
 * @param <T>
 */
class DynamicProxy<T> {
    
    /**
     * 产生代理实例
     * @param <T>
     * @param classLoader
     * @param interfaces
     * @param handler
     * @return
     */
    public static <T> T newProxyInstance(ClassLoader classLoader, Class<?>[] interfaces, InvocationHandler handler) {
        return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
    }
}