美文网首页
《设计模式之禅》读书笔记-2.6-代理模式

《设计模式之禅》读书笔记-2.6-代理模式

作者: yeing | 来源:发表于2016-03-07 06:42 被阅读89次

    2.6 代理模式

    代理的原理可先参看此文章：Java基础-001-枚举、反射、类加载器、内省、注解、泛型、代理

    定义：

    Proxy Pattern，也叫委托模式
    Provide a surrogate or placeholder for another object to control access to it
    为其它对象提供一种代理以控制对这个对象的访问
    许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。

    角色定义：

    Subject抽象主题角色

    可以是抽象类或接口，是一个最普通的业务类型定义，无特殊要求

    RealSubject具体主题角色（真实角色）

    也叫做被委托角色、被代理角色。是业务逻辑的具体执行者

    Proxy代理主题角色

    也叫做委托类、代理类。负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并在真实主题角色处理完毕前后做预处理和善后处理。

    优点：

    1. 职责清晰

    真实角色实现实际的业务逻辑，不用关心其它非本职责的逻辑，后期通过代理完成一件事务，结果就是编程简洁清晰

    1. 高扩展性

    具体主题角色可随时发生变化。只要实现了抽象主题接口，代理类就不用再次修改。

    1. 智能化

    动态代理

    使用场景：

    参考Spring AOP

    2.6.1 扩展-普通代理

    客户端只能访问代理角色，不能访问真实角色

    代码：

    /**
 * 抽象角色
 */
interface IGamePlayer{
    public void login(String user, String password);//登录
    public void killBoss();//打怪
    public void upgrade();//升级
}

/**
 * 真实角色
 */
class GamePlayer implements IGamePlayer{
    private String name;
    /**
     * 构造函数限制谁能创建对象，并同时传递姓名
     * 还可以增加其它限制，比如类名必须为Proxy等
     * 
     * 在实际的项目中，一般都是通过约定来禁止new一个真实的角色
     */
    public GamePlayer(IGamePlayer gamePlayer, String name) throws Exception{
        if(gamePlayer == null){
            throw new Exception("不能创建真实角色");
        }else{
            this.name = name;
        }
    }
    
    @Override
    public void login(String user, String password) {
        System.out.println("登录名：" + user +"; 密码：" + password + "。登录成功！");
    }
    @Override
    public void killBoss() {
        System.out.println(this.name + "在打怪！");
    }
    @Override
    public void upgrade() {
        System.out.println(this.name + "又升了一级！");
    }
}

/**
 * 代理类
 */
class GamePlayerProxy implements IGamePlayer{
    private IGamePlayer gamePlayer;
    public GamePlayerProxy(String name){
        try{
            gamePlayer = new GamePlayer(this, name);
        }catch(Exception e){
            //异常处理
        }
    }
    @Override
    public void login(String user, String password) {
        this.gamePlayer.login(user, password);
    }

    @Override
    public void killBoss() {
        this.gamePlayer.killBoss();
    }

    @Override
    public void upgrade() {
        this.gamePlayer.upgrade();
    }
}

/**
 * 场景类
 */
class Client{
    public static void main(String[] args) {
        IGamePlayer proxy = new GamePlayerProxy("张三");
        proxy.login("zhangsan", "123456");
        proxy.killBoss();
        proxy.upgrade();
    }
}

    2.6.2 扩展-强制代理

    要求：

    1. 必须通过真实角色才能找到代理角色
    2. 直接通过代理类或new真实角色来调用方法都不能得到想要的结果
    3. 真实角色管理代理角色

    代码：

    /**
 * 抽象角色
 */
interface IGamePlayer_Force{
    public void login(String user, String password);
    public void killBoss();
    public void upgrade();
    //每个类都可以找自己的代理
    public IGamePlayer_Force getProxy();
}
/**
 * 具体角色
 */
class GamePlayer_Force implements IGamePlayer_Force{
    private String name;
    private IGamePlayer_Force proxyForce;
    
    public GamePlayer_Force(String name){
        this.name = name;
    }

    @Override
    public void login(String user, String password) {
        if (this.isProxy()) {
            System.out.println("登录名：" + user +"; 密码：" + password + "。登录成功！");
        } else {
            System.out.println("请使用指定的代理访问");
        }
    }

    @Override
    public void killBoss() {
        if (this.isProxy()) {
            System.out.println(this.name + "在打怪！");
        } else {
            System.out.println("请使用指定的代理访问");
        }
    }

    @Override
    public void upgrade() {
        if (this.isProxy()) {
            System.out.println(this.name + "又升了一级！");
        } else {
            System.out.println("请使用指定的代理访问");
        }
    }

    @Override
    public IGamePlayer_Force getProxy() {
        this.proxyForce = new GamePlayerProxy_Force(this);
        return this.proxyForce;
    }
    
    // 校验是否是代理访问
    private boolean isProxy() {
        if (this.proxyForce == null) {
            return false;
        } else {
            return true;
        }
    }
}


/**
 * 代理类
 */
class GamePlayerProxy_Force implements IGamePlayer_Force {
    private IGamePlayer_Force gamePlayerForce;
    
    public GamePlayerProxy_Force(IGamePlayer_Force gamePlayerForce){
        this.gamePlayerForce = gamePlayerForce;
    }

    @Override
    public void login(String user, String password) {
        this.gamePlayerForce.login(user, password);
    }

    @Override
    public void killBoss() {
        this.gamePlayerForce.killBoss();
    }

    @Override
    public void upgrade() {
        this.gamePlayerForce.upgrade();
    }

    //代理类的代理暂时没有，返回自己
    @Override
    public IGamePlayer_Force getProxy() {
        return this;
    }
}

/**
 * 场景类
 */
class Client_Force {
    public static void main(String[] args) {
        IGamePlayer_Force player = new GamePlayer_Force("张三");
        IGamePlayer_Force proxy = player.getProxy();

        proxy.login("zhangSan", "password");
        proxy.killBoss();
        proxy.upgrade();
    }
}

    2.6.3 扩展-代理类的个性

    interface IProxy {
    public void count(); //计算费用
}

class GamePlayerProxy_Force implements IGamePlayer_Force, IProxy {
    //...
    
    @Override
    public void upgrade() {
        this.gamePlayerForce.upgrade();
        this.count();
    }
    @Override
    public void count() {
        System.out.println("升级费用是:￥100");
    }
}

    2.6.4 扩展-动态代理

    动态代理： 在实现阶段不用关心代理是谁，在运行阶段才指定代理哪一个类。

    代码一：参考代码（引子）

    interface IGamePlayer{
    public void login(String user, String password);
    public void killBoss();
    public void upgrade();
    public IGamePlayer getProxy();//每个类都可以找自己的代理
}

class GamePlayer implements IGamePlayer{
    private String name;
    private IGamePlayer proxyForce;
    
    public GamePlayer(String name){
        this.name = name;
    }
    //...
}

//动态代理
class GamePlayIH implements InvocationHandler {
    Object obj ; // 被代理的实例
    // 我要代理谁
    public GamePlayIH(Object _obj) {
        this.obj = _obj;
    }
    // 调用被代理的方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(this.obj, args);
        return result;
    }
}


class Client2 {
    public static void main(String[] args) throws Throwable {
        IGamePlayer player = new GamePlayer("张三");//对应强制代理的GamePlayer_Force
        //定义一个handler
        InvocationHandler handler = new GamePlayIH(player);
        //获得类的class loader
        ClassLoader cl = player.getClass().getClassLoader();
        //动态产生一个代理者
        IGamePlayer proxy = (IGamePlayer)Proxy.newProxyInstance(cl, 
                             new Class[]{IGamePlayer.class}, handler);
        proxy.login("zhangSan", "password");
        proxy.killBoss();//开始杀怪
        proxy.upgrade();//升级
    }
}

    代码二：模板代码（定义用）

    /**
 * ❉    ❉     ❉     ❉     ❉     ❉    主题    ❉    ❉     ❉     ❉     ❉     ❉    
 */
//抽象主题
interface Subject{
    public void doSomething(String str);
}

//真实主题
class RealSubject implements Subject{
    public void doSomething(String str){
        System.out.println("doSomething: " + str);
    }
}

/**
 * ❉    ❉     ❉     ❉     ❉     ❉    动态代理的Handler    ❉    ❉     ❉     ❉     ❉     ❉    
 */
class MyInvocationHandler implements InvocationHandler{
    private Object target; //被代理对象
    
    public MyInvocationHandler(Object obj){
        this.target = obj;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(target, args);
    }
}

/**
 * ❉    ❉     ❉     ❉     ❉     ❉    动态代理类    ❉    ❉     ❉     ❉     ❉     ❉    
 */
class DynamicProxy<T>{
    public static<T> T newProxyInstance(ClassLoader loader, 
                        Class<?>[] interfaces, InvocationHandler h){
        //寻找JoinPoint连接点
        if(true){
            (new BeforeAdvice()).exec();
        }
        return (T) Proxy.newProxyInstance(loader, interfaces, h);
    }
}

/**
 * ❉    ❉     ❉     ❉     ❉     ❉    通知    ❉    ❉     ❉     ❉     ❉     ❉    
 */
//通知接口
interface IAdvice{
    public void exec();
}

//前置通知
class BeforeAdvice implements IAdvice{
    public void exec(){
        System.out.println("我是前置通知");
    }
}

/**
 * ❉    ❉     ❉     ❉     ❉     ❉    补充：具体业务动态代理类    ❉    ❉     ❉     ❉     ❉     ❉    
 */
class SubjectDynamicProxy extends DynamicProxy{
    public static<T> T newProxyInstance(Subject subject){
        ClassLoader loader = subject.getClass().getClassLoader();
        Class<?>[] cls = subject.getClass().getInterfaces();
        InvocationHandler h = new MyInvocationHandler(subject);
        return newProxyInstance(loader, cls, h);
    }
}


/**
 * ❉    ❉     ❉     ❉     ❉     ❉    场景类    ❉    ❉     ❉     ❉     ❉     ❉    
 */
class ProxyClient{
    public static void main(String[] args) {
        //定义主题类
        Subject subject = new RealSubject();
        //定义主题类的代理
        Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);
        proxy.doSomething("Finish");
    }
}

    相关文章

      网友评论

          本文标题：《设计模式之禅》读书笔记-2.6-代理模式

          本文链接：https://www.haomeiwen.com/subject/yfbakttx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|《设计模式之禅》读书笔记-2.6-代理模式|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！