设计模式（java)工厂模式+策略模式+门面模式

场景：设计一个交易系统中的子模块------扣款子模块

扣款子模块中主要包括两部分：

1.IC卡类和交易信息类

其中IC卡中包括两种金额：固定金额和自由金额；交易信息类负责记录每一笔交易。

2.扣款策略类

扣款策略有以下两种：

a. IC卡固定金额 = IC卡现有固定金额-交易金额/2

    IC卡自由金额 = IC卡自由金额-交易金额/2

b. 全部消费从IC卡自由金额中扣除

类图实现：

主要涉及如下几个角色：

1.IC卡类和交易类

2.扣款策略接口

3.扣款策略的封装类

4.策略枚举类

5.策略工厂

6.扣款模块封装

7.场景类

代码实现

Card类：

package org.apache.java.designpatter.factoryandstrategy;

public class Card {
	
	private String No;
	private int steadyMoney;   //卡内固定交易金额
	private int freeMoney;  //卡内自由交易金额
	
	public String getNo() {
		return No;
	}
	public void setNo(String no) {
		No = no;
	}
	public int getSteadyMoney() {
		return steadyMoney;
	}
	public void setSteadyMoney(int steadyMoney) {
		this.steadyMoney = steadyMoney;
	}
	public int getFreeMoney() {
		return freeMoney;
	}
	public void setFreeMoney(int freeMoney) {
		this.freeMoney = freeMoney;
	}
}

Trade类：

public class Trade {
	
	private String tradeNo;
	private int mount;   //交易金额
	
	public String getTradeNo() {
		return tradeNo;
	}
	public void setTradeNo(String tradeNo) {
		this.tradeNo = tradeNo;
	}
	public int getMount() {
		return mount;
	}
	public void setMount(int mount) {
		this.mount = mount;
	}
	
}

扣款策略接口

public interface IDeduction {
	
	public boolean exec(Card card, Trade trade);

}

扣款策略类

public class SteadyDeduction implements IDeduction {

	public boolean exec(Card card, Trade trade) {
		int halfMoney = (int) Math.rint(trade.getMount() / 2.0);
		card.setSteadyMoney(card.getSteadyMoney() - halfMoney);
		card.setFreeMoney(card.getFreeMoney() - halfMoney);
		return true;
	}

}

public class FreeDeduction implements IDeduction {

	public boolean exec(Card card, Trade trade) {
		card.setFreeMoney(card.getFreeMoney() - trade.getMount());
		return true;
	}

}

扣款策略封装

public class DeductionContext {
	
	private IDeduction deduction;

	public DeductionContext(IDeduction deduction) {
		this.deduction = deduction;
	}
	
	public boolean exec(Card card, Trade trade) {
		return this.deduction.exec(card, trade);
	}
	
}

策略枚举

public enum StrategyManage {
	
	SteadyDeduction("org.apache.java.designpatter.factoryandstrategy.SteadyDeduction"),
	FreeDeducation("org.apache.java.designpatter.factoryandstrategy.FreeDeduction");
	
	String value = "";

	private StrategyManage(String value) {
		this.value = value;
	}

	public String getValue() {
		return value;
	}
}

策略工厂

public class StrategyFactory {
	
	public static IDeduction getDeduction(StrategyManage strategy) {
		IDeduction deduction = null;
		try {
			deduction = (IDeduction) Class.forName(strategy.getValue()).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return deduction;
	}

}

扣款模块封装

public class DeductionFacade {
	
	public static Card deduct(Card card, Trade trade) {
		
		StrategyManage reg = getDeducationType(trade);    //获得消费策略
		
		IDeduction deduction = StrategyFactory.getDeduction(reg);   //初始化一个消费策略 对象
		
		DeductionContext context = new DeductionContext(deduction);    //执行封装
		
		context.exec(card, trade);    //执行扣款
		
		return card;
		
	}
	
	private static StrategyManage getDeducationType(Trade trade) {
		if (trade.getTradeNo().contains("abc")) {
			return StrategyManage.FreeDeducation;
		}else {
			return StrategyManage.SteadyDeduction;
		}
	}

}

场景类

public class Client {
	
	
	private static Card initCard() {
		Card card = new Card();
		card.setNo("");
		card.setFreeMoney(0);
		card.setSteadyMoney(0);
		return card;
	}
	
	private static Trade initTrade() {
		Trade trade = new Trade();
		trade.setMount(0);
		trade.setTradeNo("");
		return trade;
	}
	
	public static void main(String[] args) {
		
		Card card = initCard();
		boolean flag = true;
		while (flag) {
			Trade trade = initTrade();
			DeductionFacade.deduct(card, trade);
		}
	}

}

在该场景中用到如下几个设计模式：

策略（strategy)模式：负载对扣款策略进行封装，保证了两个策略可以自由的切换。

工厂（factory）模式：修正策略模式必须对外暴露具体策略的问题，由工厂模式直接产生一个具体策略对象，其他模块则不需要依赖具体策略。

门面(facade)模式：负责对复杂的扣款系统进行封转，封转的结果就是避免高层模块深入子系统内部，同时提供系统高内聚、低耦合的特性。