代理模式

代理模式

1. 定义：为其他对象提供一种代理以控制对这个对象的访问。
2. 包括对象：Subject抽象主题角色（抽象类或接口）、RealSubject具体主题角色（被委托角色、被代理角色）、Proxy代理主题角色（负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作）。
3. 优点：职责清晰（真实的角色就是实现实际的业务逻辑，通过后期的代理
   完成一件事务）、高扩展性（具体主题角色是随时都会发生变化的）、智能化（动态代理）。

通用代理

1.Subject抽象主题角色

public interface Subject {
    //定义一个方法
    public void request();
}

2.RealSubject具体主题角色

public class RealSubject implements Subject {
    // 实现方法
    public void request() {
        // 业务逻辑处理
    }
}

3.Proxy代理主题角色

public class Proxy implements Subject {
    private Subject subject = null;

    // 默认被代理者
    public Proxy() {
        this.subject = new Proxy();
    }

    // 通过构造函数传递代理者
    public Proxy(Object... objects) {
    }

    // 实现接口中定义的方法
    public void request() {
        this.before();
        this.subject.request();
        this.after();
    }

    // 预处理
    private void before() {
        // do something
    }

    // 善后处理
    private void after() {
        // do something
    }

}

强制代理

概念：强制代理的概念就是要从真实角色查找到代理角色，不允许直接访问真实角色。

1.抽象角色

public interface IGamePlayer {
    //登录游戏
    public void login(String user,String password);
    //杀怪，这是网络游戏的主要特色
    public void killBoss();
    //升级
    public void upgrade();
    //每个人都可以找一下自己的代理
    public IGamePlayer getProxy();
}

2.真实角色

public class GamePlayer implements IGamePlayer {
    private String name = "";
    // 我的代理是谁
    private IGamePlayer proxy = null;

    public GamePlayer(String _name) {
        this.name = _name;
    }

    // 找到自己的代理
    public IGamePlayer getProxy() {
        this.proxy = new GamePlayerProxy(this);
        return this.proxy;
    }

    // 打怪，最期望的就是杀老怪
    public void killBoss() {
        if (this.isProxy()) {
            System.out.println(this.name + "在打怪！");
        } else {
            System.out.println("请使用指定的代理访问");
        }
    }

    // 进游戏之前你肯定要登录吧，这是一个必要条件
    public void login(String user, String password) {
        if (this.isProxy()) {
            System.out.println("登录名为" + user + "的用户" + this.name + "登录成功！");
        } else {
            System.out.println("请使用指定的代理访问");
            ;
        }
    }

    // 升级，升级有很多方法，花钱买是一种，做任务也是一种
    public void upgrade() {
        if (this.isProxy()) {
            System.out.println(this.name + " 又升了一级！");
        } else {
            System.out.println("请使用指定的代理访问");
        }
    }

    // 校验是否是代理访问
    private boolean isProxy() {
        if (this.proxy == null) {
            return false;
        } else {
            return true;
        }
    }
}

3.代理角色

public class GamePlayerProxy implements IGamePlayer {
    private IGamePlayer gamePlayer = null;

    // 构造函数传递用户名
    public GamePlayerProxy(IGamePlayer _gamePlayer) {
        this.gamePlayer = _gamePlayer;
    }

    // 代练杀怪
    public void killBoss() {
        this.gamePlayer.killBoss();
    }

    // 代练登录
    public void login(String user, String password) {
        this.gamePlayer.login(user, password);
    }

    // 代练升级
    public void upgrade() {
        this.gamePlayer.upgrade();
    }

    // 代理的代理暂时还没有，就是自己
    public IGamePlayer getProxy() {
        return this;
    }
}

4.测试类

public class Client {
    public static void main(String[] args) {
        // 定义一个游戏的角色
        IGamePlayer player = new GamePlayer("张三");
        //然后再定义一个代练者(受限)
        //IGamePlayer proxy = new GamePlayerProxy(player);
        // 获得指定的代理
        IGamePlayer proxy = player.getProxy();
        // 开始打游戏，记下时间戳
        System.out.println("开始时间是：2009-8-25 10:45");
        proxy.login("zhangSan", "password");
        // 开始杀怪
        proxy.killBoss();
        // 升级
        proxy.upgrade();
        // 记录结束游戏时间
        System.out.println("结束时间是：2009-8-26 03:40");
    }
}

动态代理

1.概念：动态代理是在实现阶段不用关心代理谁，而在运行阶段才指定代理哪一个对象。现在有一个非常流行的名称叫做面向横切面编程，也就是AOP（Aspect Oriented Programming），其核心就是采用了动态代理机制。

2.模型：两条独立发展的线路。动态代理实现代理的职责，业务逻辑Subject实现相关的逻辑功能，两者之间没有必然的相互耦合的关系。通知Advice从另一个切面切入，最终在高层模块也就是Client进行耦合，完成逻辑的封装任务。

1.Subject

public interface Subject {
    // 业务操作
    public void doSomething(String str);
}

2.RealSubject

public class RealSubject implements Subject {
    // 业务操作
    public void doSomething(String str) {
        System.out.println("do something!---->" + str);
    }
}

3.IAdvice

public interface IAdvice {
    // 通知只有一个方法，执行即可
    public void exec();
}

4.BeforeAdvice

public class BeforeAdvice implements IAdvice {
    public void exec() {
        System.out.println("我是前置通知，我被执行了！");
    }
}

5.DynamicProxy

public class DynamicProxy<T> {
    public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {
        // 寻找JoinPoint连接点，AOP框架使用元数据定义
        if (true) {
            // 执行一个前置通知
            (new BeforeAdvice()).exec();
        }
        // 执行目标，并返回结果
        return (T) Proxy.newProxyInstance(loader, interfaces, h);
    }
}

6.SubjectDynamicProxy

public class SubjectDynamicProxy extends DynamicProxy {
    public static <T> T newProxyInstance(Subject subject) {
        // 获得ClassLoader
        ClassLoader loader = subject.getClass().getClassLoader();
        // 获得接口数组
        Class<?>[] classes = subject.getClass().getInterfaces();
        // 获得handler
        InvocationHandler handler = new MyInvocationHandler(subject);
        return newProxyInstance(loader, classes, handler);
    }
}

7.MyInvocationHandler

public class MyInvocationHandler implements InvocationHandler {
    // 被代理的对象
    private Object target = null;

    // 通过构造函数传递一个对象
    public MyInvocationHandler(Object _obj) {
        this.target = _obj;
    }

    // 代理方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 执行被代理的方法
        return method.invoke(this.target, args);
    }
}

8.Client

public class Client {
    public static void main(String[] args) {
        // 定义一个主题
        Subject subject = new RealSubject();
        // 定义主题的代理
        Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);
        // 代理的行为
        proxy.doSomething("Finish");
    }
}

注：《设计模式之禅》笔记