設計模式學習之代理模式

代理模式的定義：爲其餘對象提供一種代理以控制這個對象的訪問，代理模式也叫作委託模式

代理模式通用類圖以下：

Subject抽象主題角色：抽象主題類能夠是抽象類或者接口。

RealSubject具體主題角色：叫作被委託對象，被代理對象，是業務邏輯的具體執行者

Proxy代理主題角色：叫作委託類、代理類。負責對真實角色的應用。

抽象角色：

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public interface IGamePlayer {

    /**
     * 登陸游戲
     * @param user
     * @param password
     */
    void login(String user,String password);

    /**
     * 殺怪
     */
    void killBoss();

    /**
     * 升級
     */
    void upgrade();
}

被代理類的實現：

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public class GamePlayer implements IGamePlayer {

    private String name = "";

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

    @Override
    public void login(String user, String password) {
        System.out.println("登陸名爲--" + user + "--的用戶" + this.name + "登陸成功！");
    }

    @Override
    public void killBoss() {
        System.out.println(this.name + "在打怪！");
    }

    @Override
    public void upgrade() {
        System.out.println(this.name + "又升一級！");
    }
}

代理類：

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public class GamePlayerProxy implements IGamePlayer{

    private IGamePlayer gamePlayer = null;

    /**
     * 構造函數指定對誰進行代練
     * @param _gamePlayer
     */
    public GamePlayerProxy(IGamePlayer _gamePlayer){
        this.gamePlayer = _gamePlayer;
    }

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

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

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

具體場景實現：

import java.util.Date;

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public class Client {

    /**
     * 普通本身玩遊戲
     * @param args
     */
 /*   public static void main(String[] args) {

        IGamePlayer player = new GamePlayer("H_Lin");
        System.out.println("開始時間是：" + new Date());
        player.login("User_Lin","123456");
        player.killBoss();
        player.upgrade();
        System.out.println("遊戲結束時間：" + new Date());
    }*/

    /**
     * 經過代練玩遊戲
     * @param args
     */
    public static void main(String[] args) {
        //定義一個遊戲玩家
        IGamePlayer gamePlayer = new GamePlayer("張三");
        //定義一個遊戲代練
        IGamePlayer proxy = new GamePlayerProxy(gamePlayer);
        System.out.println("開始時間是：" + new Date());
        proxy.login("zhangSan","123456");
        proxy.killBoss();
        proxy.upgrade();
        System.out.println("遊戲結束時間：" + new Date());
    }
}

代理模式的優勢：

1. 職責清晰，真實角色就是實現實際的業務邏輯，不關係其餘非本職責的事務，經過後期的代理完成一件事務。
2. 高擴展性，具體的角色是能夠隨時變化的，只要它實現了接口，代理類能夠在不作任何修改的狀況下使用。

講到代理就就必須提起動態代理了。什麼是動態代理？動態代理是在實現階段不用關心代理誰，而是在運行階段才指定代理哪個對象。

具體類圖以下：

建立一個動態代理類：

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public class GamePlayerTH implements InvocationHandler{

    /**
     * 被代理的對象
     */
    Object obj = null;

    public GamePlayerTH(Object _obj){
        this.obj = _obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(this.obj,args);
        return result;
    }
}

具體實現場景：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.Date;

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public class ClientTH {

    public static void main(String[] args) throws Exception{
        //定義一個遊戲玩家
        IGamePlayer player = new GamePlayer("張三");
        InvocationHandler handler = new GamePlayerTH(player);
        System.out.println("開始時間是：" + new Date());
        ClassLoader cl = player.getClass().getClassLoader();
        IGamePlayer proxy = (IGamePlayer) Proxy.newProxyInstance(cl,player.getClass().getInterfaces(),handler);
        proxy.login("zhangSan","123456");
        proxy.killBoss();
        proxy.upgrade();
        System.out.println("遊戲結束時間：" + new Date());
    }
}