设计模式（6）：代理模式

代理模式：

定义：

为其他对象提供一种代理以控制对这个对象的访问。







Subject抽象主题角色：

抽象主题类可以是抽象类也可以是接口。



RealSubject具体主题角色：

被代理角色



Proxy代理主题角色：

代理类，负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实角色处理完毕前后做预处理和善后处理工作。就是替具体主题角色完成抽象类中的方法。





代理模式的优点：

职责清晰

高扩展性

智能化



游戏代理：

interface IGamePlayer {
	// 登陆
	public void login(String user, String password);

	// 杀怪
	public void killBoss();

	// 升级
	public void upgrade();
}

class GamePlayer implements IGamePlayer {
	private String name = "";

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

	public void login(String user, String password) {
		System.out.println("登陆名为" + this.name + "登陆成功");
	}

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

	public void upgrade() {
		System.out.println(this.name + "升级了");
	}
}

/* 代练 */
class GamePlayerProxy implements IGamePlayer {

	private IGamePlayer gamePlayer = null;

	// 通过构造函数传递被代练者
	public GamePlayerProxy(IGamePlayer gamePlayer) {
		this.gamePlayer = gamePlayer;
	}

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

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

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

}

public class Client {

	public static void main(String[] args) {
		IGamePlayer player = new GamePlayer("zhangsan");
		IGamePlayer proxy = new GamePlayerProxy(player);
		proxy.login("zhangsan", "12345");
		proxy.killBoss();
		proxy.upgrade();
	}

}

普通代理与强制代理：

普通代理就是我们要知道代理的存在，而强制代理则是调用者直接调用真实角色，不用关心代理是否存在。



普通代理：







修改了之前两个类的构造函数，GamePlayer的构造函数增加了gamePlayer参数，而代理角色只要传入代理者名字即可，而不需要说是替哪个对象做代理。

interface IGamePlayer {
	// 登陆
	public void login(String user, String password);

	// 杀怪
	public void killBoss();

	// 升级
	public void upgrade();
}

class GamePlayer implements IGamePlayer {
	private String name = "";
	private IGamePlayer gamePlayer;

	public GamePlayer(IGamePlayer gamePlayer, String name) throws Exception {
		if (gamePlayer == null) {
			throw new Exception("不能创建真实角色！");
		} else {
			this.name = name;
		}
	}

	public void login(String user, String password) {
		System.out.println("登陆名为" + this.name + "登陆成功");
	}

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

	public void upgrade() {
		System.out.println(this.name + "升级了");
	}
}

/* 代练 */
class GamePlayerProxy implements IGamePlayer {

	private IGamePlayer gamePlayer = null;

	public GamePlayerProxy(String name) {

		try {
			gamePlayer = new GamePlayer(this, name);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

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

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

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

}

public class Client {

	public static void main(String[] args) {
		IGamePlayer proxy = new GamePlayerProxy("zhangsan");
		proxy.login("zhangsan", "12345");
		proxy.killBoss();
		proxy.upgrade();
	}
}

运行结果完全相同，在该模式下，调用者只知道代理而不用知道真实角色是谁。





强制代理：



调用者直接调用真实角色，而不用关心代理是否存在，其代理的产生是由真实角色决定的。必须通过真实角色查找到代理角色。只有通过真实角色指定的代理类才可以访问。









在接口上增加了一个getProxy方法，真实角色GamePlayer可以指定一个自己的代理，除了代理外谁都不能访问。

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 proxy;

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

	public IGamePlayer getProxy() {
		this.proxy = new GamePlayerProxy(this);
		return this.proxy;
	}

	private boolean isProxy() {
		if (this.proxy == null) {
			return false;
		}
		return true;
	}

	public void login(String user, String password) {
		if (isProxy()) {
			System.out.println("登陆名为" + this.name + "登陆成功");
		} else {
			System.out.println("请使用指定的代理访问");
		}
	}

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

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

}

/* 代练 */
class GamePlayerProxy implements IGamePlayer {

	private IGamePlayer gamePlayer = null;

	public GamePlayerProxy(IGamePlayer gamePlayer) {

		this.gamePlayer = gamePlayer;

	}

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

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

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

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

}

public class Client {

	public static void main(String[] args) {
		IGamePlayer player = new GamePlayer("zhangsan");
		IGamePlayer proxy = player.getProxy();
		proxy.login("zhangsan", "12345");
		proxy.killBoss();
		proxy.upgrade();
	}
}

强制代理的概念就是要从真实角色查找到代理角色，不能直接访问真实角色。高层模块只要调用getProxy就可以访问真实角色的所有方法。





代理是有个性的



代理类不仅仅可以实现主题接口，也可以实现其他接口完不成的任务，而且代理的目的是在目标对象方法的基础上做增强。



游戏代理是要收费的，增加一个IProxy接口，其作用是计算代理费用。

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

/* 代练 */
class GamePlayerProxy implements IGamePlayer, IProxy {

	private IGamePlayer gamePlayer = null;

	public GamePlayerProxy(IGamePlayer gamePlayer) {

		this.gamePlayer = gamePlayer;

	}

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

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

	public void upgrade() {
		this.gamePlayer.upgrade();
		this.count();
	}

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

	// 计算费用
	public void count() {
		System.out.println("升级总费用：10000");
	}

}

动态代理。。。。