设计模式(Java)----代理模式Proxy Pattern

例题1：卓佳易喜欢娇娇，但是娇娇并不认识卓佳易：
1.卓佳易给娇娇送花，送巧克力，送洋娃娃
2.卓佳易也可以找一个人，让这个人吧鲜花，巧克力和洋娃娃送给娇娇。
这是两种方式，但达到的目的是一样的。

class SchoolGirl{
	private String name;
	public String getName() {
		return name;
	}
	public void SetName(String value) {
		name=value;
	}
}
class Pursuit{//追求者
	SchoolGirl mm;
	public Pursuit(SchoolGirl mm) {
		this.mm=mm;
	}
	public void GiveDolls() {
		System.out.println(mm.getName()+"送你洋娃娃");
	}
	public void GiveFlowers() {
		System.out.println(mm.getName()+"送你鲜花");
	}
	public void GiveChocolate() {
		System.out.println(mm.getName()+"送你巧克力");
	}
}
public class Main{
	public static void main(String[] args){
		SchoolGirl jiaojiao=new SchoolGirl();
		jiaojiao.SetName("李娇娇");
		Pursuit zhuojiayi=new Pursuit(jiaojiao);
		zhuojiayi.GiveDolls();
		zhuojiayi.GiveFlowers();
		zhuojiayi.GiveChocolate();
	}
}

从代码来看，卓佳易和娇娇是认识的，并旦卓佳易直接把花，巧克力，洋娃娃送给了娇娇。但是娇娇不认识卓佳易，所以与规定情境不符合。
所以可以通过一个人来送，我们称之为代理。

class SchoolGirl{
	private String name;
	public String getName() {
		return name;
	}
	public void SetName(String value) {
		name=value;
	}
}
class Proxy{//代理
	SchoolGirl mm;
	public Proxy(SchoolGirl mm) {
		this.mm=mm;
	}
	public void GiveDolls() {
		System.out.println(mm.getName()+"送你洋娃娃");
	}
	public void GiveFlowers() {
		System.out.println(mm.getName()+"送你鲜花");
	}
	public void GiveChocolate() {
		System.out.println(mm.getName()+"送你巧克力");
	}
}
public class Main{
	public static void main(String[] args){
		SchoolGirl jiaojiao=new SchoolGirl();
		jiaojiao.SetName("李娇娇");
		Proxy daili=new Proxy(jiaojiao);
		daili.GiveDolls();
		daili.GiveFlowers();
		daili.GiveChocolate();
	}
}

但是这样看来，礼物又变成代理送的了，忽略了追求者。
其实追求者和代理都有送礼物的行动，应该实现相同的接口。
代码要注意以下几点：
1.代理和卓佳易的行为是一样的，送礼物。
2.代理送的礼物是卓佳易易买的。
既然代理和卓佳易的行为都是一栏的，用面向对象的思想考虑，要把变化点抽象出来。

class SchoolGirl{
	private String name;
	public String getName() {
		return name;
	}
	public void SetName(String value) {
		name=value;
	}
}
interface IGiveGift{
	void GiveDolls();
	void GiveFlowers();
	void GiveChocolate();
}
class Pursuit implements IGiveGift{//追求者
	SchoolGirl mm;
	public Pursuit(SchoolGirl mm) {
		this.mm=mm;
	}
	public void GiveDolls() {
		System.out.println(mm.getName()+"送你洋娃娃");
	}
	public void GiveFlowers() {
		System.out.println(mm.getName()+"送你鲜花");
	}
	public void GiveChocolate() {
		System.out.println(mm.getName()+"送你巧克力");
	}
}
class Proxy implements IGiveGift{//代理
	Pursuit gg;
	public Proxy(SchoolGirl mm) {
		gg=new Pursuit(mm);
	}
	public void GiveDolls() {
		gg.GiveDolls();
	}
	public void GiveFlowers() {
		gg.GiveFlowers();
	}
	public void GiveChocolate() {
		gg.GiveChocolate();
	}
}
public class Main{
	public static void main(String[] args){
		SchoolGirl jiaojiao=new SchoolGirl();
		jiaojiao.SetName("李娇娇");
		Proxy daili=new Proxy(jiaojiao);
		daili.GiveDolls();
		daili.GiveFlowers();
		daili.GiveChocolate();
	}
}

 代理模式：为其他对象提供一种代理以控制（隔离，使用接口）对这个对象的访问。

 

abstract class Subject{
	public abstract void Request();
}
class RealSubject extends Subject{

	@Override
	public  void Request() {
		// TODO Auto-generated method stub
		System.out.println("真实请求");
	}
	
}
class Proxy extends Subject{

	RealSubject realSubject;
	@Override
	public void Request() {
		// TODO Auto-generated method stub
		if(realSubject==null) {
			realSubject=new RealSubject();
		}
		realSubject.Request();
	}
	
}
public class Main{
	public static void main(String[] args){
		Proxy proxy=new Proxy();
		proxy.Request();
	}
}

例题2：在软件系统中，无时无刻不在跨越障碍，以一个简单的数学计算程序为例，这个程序只负责进行简单的加减乘除运算。

class Math{
	public double Add(double x,double y) {
		return x+y;
	}
	public double Sub(double x,double y) {
		return x-y;
	}
	public double Mul(double x,double y) {
		return x*y;
	}
	public double Dev(double x,double y) {
		return x/y;
	}
}

如果这个计算程序部署在本地计算机上，使用非常简单也就不用去考虑Proxy模式了。如果这个Math类并没有部署在本地，而是部署在一台服务器上，也就是说Math类与客户程序不在同一个地址空间内，那就要面对跨越Internet这样一个网络障碍。
为了解决这个障碍引起的复杂性，就引出了Proxy模式，使用一个本地的代理来替Math类打点一切，即为系统引入一层间接层。

interface IMath{
	double Add(double x,double y);
	double Sub(double x,double y);
	double Mul(double x,double y);
	double Dev(double x,double y);
}
class Math implements IMath{
	public double Add(double x,double y) {
		return x+y;
	}
	public double Sub(double x,double y) {
		return x-y;
	}
	public double Mul(double x,double y) {
		return x*y;
	}
	public double Dev(double x,double y) {
		return x/y;
	}
}
class MathProxy implements IMath{
	private Math math;
	public MathProxy() {
		math=new Math();
	}
	public double Add(double x,double y) {
		return math.Add(x, y);
	}
	public double Sub(double x,double y) {
		return math.Sub(x, y);
	}
	public double Mul(double x,double y) {
		return math.Mul(x, y);
	}
	public double Dev(double x,double y) {
		return math.Dev(x, y);
	}
}