设计模式（二）——代理模式

设计模式（二）——代理模式

 

本文讲述的是代理模式

我们假设有如下一种场景：

         有关水果的销售，有三种角色：顾客，批发商，果农，大城市里的顾客想要买某种水果，不会直接去找果农，他会找对应的批发商（顾客可以是单个消费者也可以是零售商，这个没差别），批发商会将相应的水果卖给顾客，但是实际上批发商是不生产水果，他只不过是在代果农销售水果而已，而且批发商可以销售各种水果，消费者也只需要通过批发商就可以买到不同果农生产的水果。

下面我们就看如何用java代码实现：

我们先定义类出售水果的人的接口，他们都有一个共同的方法，卖水果：

 

package com.gy.designpattern.proxy;
/**
 * ClassName:IFruitSeller <br/>
 * Function: 这是一个水果卖家的接口，果农和批发商都是这类人，他们都可以卖水果. <br/>
 * Reason:	 TODO ADD REASON. <br/>
 * Date:     2012-7-3 下午5:25:07 <br/>
 * @author   gongyong
 * @version
 * @since    JDK 1.6
 * @see
 */
public interface IFruitSeller {

	/**
	 * sellFruit:出售水果. <br/>
	 * @author gongyong
	 * @since JDK 1.6
	 */
	public void sellFruit();

}

 然后我们定义个种苹果的果农，他实现了该接口：

package com.gy.designpattern.proxy;
/**
 * ClassName:ApplerFarmer <br/>
 * Function: 苹果种植者. <br/>
 * Reason:	 TODO ADD REASON. <br/>
 * Date:     2012-7-3 下午5:29:54 <br/>
 * @author   gongyong
 * @version
 * @since    JDK 1.6
 * @see
 */
public class AppleFarmer implements IFruitSeller{

	/**
	 * 苹果种植者要出售他的水果.
	 * @see com.gy.designpattern.proxy.IFruitSeller#sellFruit()
	 */
	@Override
	public void sellFruit(){
		System.out.println("我卖苹果，3块钱一斤");
	}
}

 

  再定义一个种西瓜的：

package com.gy.designpattern.proxy;
/**
 * ClassName:WatermelonFarmer <br/>
 * Function: 西瓜种植者. <br/>
 * Reason:	 TODO ADD REASON. <br/>
 * Date:     2012-7-3 下午5:32:08 <br/>
 * @author   gongyong
 * @version
 * @since    JDK 1.6
 * @see
 */
public class WatermelonFarmer implements IFruitSeller{

	/**
	 * 西瓜种植者要出售他的西瓜.
	 * @see com.gy.designpattern.proxy.IFruitSeller#sellFruit()
	 */
	@Override
	public void sellFruit(){
		System.out.println("我卖西瓜，1块2一斤");
	}

}

 然后我们定义一个批发商：

package com.gy.designpattern.proxy;
/**
 * ClassName:Wholesalers <br/>
 * Function: 批发商，直接销售水果给顾客. <br/>
 * Reason:	 TODO ADD REASON. <br/>
 * Date:     2012-7-3 下午5:34:31 <br/>
 * @author   gongyong
 * @version
 * @since    JDK 1.6
 * @see
 */
public class Wholesalers implements IFruitSeller{

	private IFruitSeller fuitSeller;

	/**
	 * 该批发商默认的是销售苹果种植者的苹果.
	 *
	 */
	public Wholesalers(){
		this.fuitSeller=new AppleFarmer();
	}


	/**
	 * 批发商也可以销售其他水果种植者的水果.
	 *
	 * @param fruitSeller
	 */
	public Wholesalers(IFruitSeller fruitSeller){
		this.fuitSeller=fruitSeller;

	}

	/**
	 * 我是批发商，我可以卖各种水果,但是实际上我没有水果，真正卖水果的是果农.
	 * @see com.gy.designpattern.proxy.IFruitSeller#sellFruit()
	 */
	@Override
	public void sellFruit(){
		this.fuitSeller.sellFruit();
	}

}

 最后就是顾客，顾客来了要买水果，直接找批发商就好了，他不需要知道果农：

package com.gy.designpattern.proxy;
/**
 * ClassName:Customer <br/>
 * Function: 顾客（批发商的顾客可以是消费者，也可以是零售商）. <br/>
 * Reason:	 顾客不会直接找果农买水果，他会找代理商. <br/>
 * Date:     2012-7-3 下午5:44:54 <br/>
 * @author   gongyong
 * @version
 * @since    JDK 1.6
 * @see
 */
public class Customer {

	public static void main(String[] args){
		// 顾客不会直接找果农买水果，他会找代理商,所以我们先new出代理商
		Wholesalers appleSalers=new Wholesalers();
		//这家代理商默认是卖苹果的，所以顾客来这里买苹果
		System.out.println("-----我要买苹果-----");
		appleSalers.sellFruit();

		//然后顾客想要买西瓜，就找到卖西瓜的代理商
		Wholesalers watermelonSalers=new Wholesalers(new WatermelonFarmer());

		//这家代理商卖西瓜，我在这里买
		System.out.println("-----我要买西瓜-----");
		watermelonSalers.sellFruit();
	}
}

 

OK，到这里就完成了，可以看出，顾客可以有多种需求，而顾客唯一要打交道的就是代理商，而代理商是可以代理各种类型的商品的，如果现在顾客需要买香蕉，那我们只需要定义一个生产香蕉的果农实现IFruitSeller接口，然后让这个代理商代理香蕉（就是在构造函数里注入这个对象），那顾客就可以买到香蕉了。