每日设计模式之—代理模式（静态代理）

代理模式之静态代理模式

 代理模式在生活中十分常见，比如代购，其本质是本该自己完成的事情找别人帮忙完成了，这就是代理。比如说喜欢玩游戏的朋友，每天都是开黑升级打怪，升级打怪，（日积月累，累啊），但是还想升级咋办呢？？？

方案一：各种砸钱（高昂的费用，但是省了时间）

方案二：找代练（费用稍低，本质还是时间堆积，不过是把打怪的时间转嫁给另外一个哥们而已）。

        找代练也有两种方式：

        第一种：知道具体的xxx（一般只能代练某一款具体的游戏）干这项工作，直接联系xxx帮忙；

        第二种：没什么人脉，但是知道有人成立了公司（可以为任意的人代练任意一款游戏），可以帮忙代练。

那回到程序的角度来考虑呢，这方案二就是咱们要讨论的代理模式。

再看咱们的方案二的第一种方式：这种方式，你需要知道你把你的账号给了谁，然后你的账号才能完成升级。而第二种方式，你完全不知道你的账号交给了具体的某个谁。这两种不同的方式也就对应了代理模式不同的实现方式（静态代理和动态代理）。

说了这么多，言归正传，来看看我们的代理模式的定义：

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

下面呢，我们就用程序的方式来模拟这个升级打怪的过程：

public class StaticProxy {
	public static void main(String[] args) {
		GamePlayer player = new XXXGamePlayer("张三丰");//真实的玩家账号

        //如果没有代练，则player需要自己登陆、打怪和升级
        //有了代练，player只需要将自己的账号信息交给playerProxy即可，自己可以专注于自己的事
		GamePlayer playerProxy = new XXXGamePlayerProxy(player);//代练
		
		playerProxy.login();
		
		playerProxy.play();
		
		playerProxy.upgrade();
	}
}

interface GamePlayer {
	public void login();

	public void play();

	public void upgrade();
}

class XXXGamePlayer implements GamePlayer {
	
	public XXXGamePlayer(String name) {
		super();
		this.name = name;
	}

	private String name;

	@Override
	public void play() {
		System.out.println("playing......");
	}

	@Override
	public void upgrade() {
		System.out.println(".....upgrade.");
	}

	@Override
	public void login() {
		System.out.println(name + " login in.");
	}
}

class XXXGamePlayerProxy implements GamePlayer {

	public XXXGamePlayerProxy(GamePlayer player) {
		super();
		this.player = player;
	}

	GamePlayer player;

	@Override
	public void play() {
		this.player.play();
	}

	@Override
	public void upgrade() {
		this.player.upgrade();
		System.out.println("升级成功，收费5元。");
	}

	@Override
	public void login() {
		this.player.login();
	}

}

张三丰找了代练，再也不用每天熬夜开黑，日夜颠倒打怪升级了，小日子过的是逍遥自在。。。。。。可是，过了没多久又觉得无聊，有玩起了另一款游戏，又是每天开黑，打怪升级，玩了一段时间内心煎熬，感觉辜负了大好的青春年华，但是又摆脱不了升级带来的快感，于是又想起了找代练，于是代码变成了下面这样：

public class StaticProxy {
	public static void main(String[] args) {
		GamePlayer player = new XXXGamePlayer("张三丰");
		GamePlayer playerProxy = new XXXGamePlayerProxy(player);

		playerProxy.login();

		playerProxy.play();

		playerProxy.upgrade();
		
		
		GamePlayer player1 = new XXX_newGamePlayer("张三丰");
		GamePlayer newPlayerProxy = new XXX_newGamePlayerProxy(player1);
		
		newPlayerProxy.login();
		
		newPlayerProxy.play();
		
		newPlayerProxy.upgrade();
		
	}
}

interface GamePlayer {
	public void login();

	public void play();

	public void upgrade();
}

class XXX_newGamePlayer implements GamePlayer {
	private String name;

	public XXX_newGamePlayer(String name) {
		super();
		this.name = name;
	}

	@Override
	public void play() {
		System.out.println("playing......");
	}

	@Override
	public void upgrade() {
		System.out.println(".....upgrade.");
	}

	@Override
	public void login() {
		System.out.println(name + " login in.");
	}

}

class XXX_newGamePlayerProxy implements GamePlayer {

	public XXX_newGamePlayerProxy(GamePlayer player) {
		super();
		this.player = player;
	}

	GamePlayer player;

	@Override
	public void play() {
		this.player.play();
	}

	@Override
	public void upgrade() {
		this.player.upgrade();
		System.out.println("升级成功，收费6元。");
	}

	@Override
	public void login() {
		this.player.login();
	}
}

	class XXXGamePlayer implements GamePlayer {

		public XXXGamePlayer(String name) {
			super();
			this.name = name;
		}

		private String name;

		@Override
		public void play() {
			System.out.println("playing......");
		}

		@Override
		public void upgrade() {
			System.out.println(".....upgrade.");
		}

		@Override
		public void login() {
			System.out.println(name + " login in.");
		}
	}

class XXXGamePlayerProxy implements GamePlayer {

	public XXXGamePlayerProxy(GamePlayer player) {
		super();
		this.player = player;
	}

	GamePlayer player;

	@Override
	public void play() {
		this.player.play();
	}

	@Override
	public void upgrade() {
		this.player.upgrade();
		System.out.println("升级成功，收费5元。");
	}

	@Override
	public void login() {
		this.player.login();
	}

}

从上边张三丰玩游戏的过程我们可以总结出代理模式的一般类图结构：

虽然代理模式能够降低核心代码类的复杂度，让核心代码类专注于处理自己的业务，但是这种代理方式也带来了另一个问题：也许大家已经看出来了，一旦张三丰玩一款新的游戏就需要重新找一个代练（声明新的代理类），这样在开发过程中会导致类膨胀，随着需要代理的业务越来越复杂，代理类会越来越多。

那么这个问题该如何解决呢？请关注下一篇文章