策略模式（Strategy）定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。
策略模式让算法独立于使用它的客户而独立变化。
策略模式结构图：
策略模式解析：
Context(应用场景):
1、需要使用ConcreteStrategy提供的算法。
2、 内部维护一个Strategy的实例。
3、 负责动态设置运行时Strategy具体的实现算法。
4、负责跟Strategy之间的交互和数据传递。
Strategy(抽象策略类)：
1、 定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，Context使用这个接口调用不同的算法，一般使用接口或抽象类实现。
ConcreteStrategy(具体策略类)：
2、 实现了Strategy定义的接口，提供具体的算法实现。
策略模式实战1：
package org.leiwen.dp.action.stragety.constants;
import java.util.Map;
//常量接口
public interface ConstantProvider {
Map<String, String> loadConfiguration();
}
package org.leiwen.dp.action.stragety.constants.impl;
import java.io.File;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.leiwen.dp.action.stragety.constants.ConfigurationException;
import org.leiwen.dp.action.stragety.constants.ConstantProvider;
public class
XmlConstantProvider implements ConstantProvider {
private String configFileName;
private Map<String, String> config = new HashMap<String, String>();
public XmlConstantProvider(String fileName) {
this.configFileName = fileName;
}
public XmlConstantProvider() {
}
@Override
public Map<String, String> loadConfiguration() {
// 使用SAXReader解析算法
SAXReader saxReader = new SAXReader();
ClassLoader classLoader = this.getClass().getClassLoader();
InputStream inputStream = classLoader
.getResourceAsStream(configFileName);
if (inputStream == null) {
throw new ConfigurationException("intputStream == null");
}
Document doc = null;
try {
doc = saxReader.read(inputStream);
Element root = doc.getRootElement();
List<Element> elements = root.elements("constant");
for (Element e : elements) {
String name = e.attributeValue("name");
String value = e.attributeValue("value");
if (name != null && value != null) {
config.put(name, value);
}
}
} catch (DocumentException e) {
throw new ConfigurationException(e);
}
return config;
}
}
package org.leiwen.dp.action.stragety.constants.impl;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import org.leiwen.dp.action.stragety.constants.ConfigurationException;
import org.leiwen.dp.action.stragety.constants.ConstantProvider;
//常量提供者的实现，读取属性文件的方式
public class
PropertiesConstantProvider implements ConstantProvider {
public static final String FILE_NAME = "constants.properties";
private Map<String, String> context = new HashMap<String, String>();
@Override
public Map<String, String> loadConfiguration() {
Properties props = new Properties();
InputStream in = this.getClass().getClassLoader()
.getResourceAsStream(FILE_NAME);
try {
props.load(in);
} catch (IOException e) {
throw new ConfigurationException(e);
}
Set<Entry<Object, Object>> entrys = props.entrySet();
for (Entry<Object, Object> entry : entrys) {
String name = (String) entry.getKey();
String value = (String) entry.getValue();
if (name != null && value != null) {
context.put(name, value);
}
}
return context;
}
}
package org.leiwen.dp.action.stragety.constants.impl;
import java.util.Map;
import org.leiwen.dp.action.stragety.constants.ConstantProvider;
//自定义常量提供器
public class
CustomConstantProvider implements ConstantProvider {
@Override
public Map<String, String> loadConfiguration() {
// 根据自己的配置格式，实现相应的算法
return null;
}
}
package org.leiwen.dp.action.stragety.constants;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
//常量管理器
public class
ConstantManager {
// 内部封装了所有的容器加载器ContainerProvider
private List<ConstantProvider> providers = new CopyOnWriteArrayList<ConstantProvider>();
// 保存所有的常量
private Map<String, String> context = new HashMap<String, String>();
// 增加常量提供器
public void addConfigurationProvider(ConstantProvider provider) {
providers.add(provider);
}
// 初始化过程，实际上就是将各种各样的配置元素，无论是XML形式还是Properties文件形式（甚至可能是其它自定义的配置形式）
// 转化为Java对象的过程。
public void init() {
// 不同的ConstantProvider之间并没有依赖关系。这一点告诉我们，所有的常量加载器对于我们而言是一视同仁的。
for (ConstantProvider provider : providers) {
Map<String, String> map;
try {
map = provider.loadConfiguration();
if (map != null) {
context.putAll(map);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 打印常量
public void printConstants() {
for (Map.Entry<String, String> entry : context.entrySet()) {
String name = entry.getKey();
String value = entry.getValue();
System.out.println(name + "=" + value);
}
}
}
package org.leiwen.dp.action.stragety.constants;
import org.dom4j.DocumentException;
public class
ConfigurationException extends RuntimeException {
public ConfigurationException() {
super();
}
public ConfigurationException(String message, Throwable cause) {
super(message, cause);
}
public ConfigurationException(String message) {
super(message);
}
public ConfigurationException(Throwable cause) {
super(cause);
}
}
2个配置文件（都位于类路径下）
constants.properties
name=fans
school=wust
constants.xml
<constants>
<constant name="fans" value="leiwen" />
<constant name="fanssoft" value="软林至尊，fans同盟。" />
</constants>
package org.leiwen.dp.action.stragety.constants;
import org.leiwen.dp.action.stragety.constants.impl.PropertiesConstantProvider;
import org.leiwen.dp.action.stragety.constants.impl.XmlConstantProvider;
/**
* @author 雷文 2012-3-24
*/
public class
StragetyTest {
//
public static void main(String[] args) {
ConstantProvider xmlProvider = new XmlConstantProvider("constants.xml");
ConstantProvider propProvider = new PropertiesConstantProvider();
ConstantManager manager = new ConstantManager();
manager.addConfigurationProvider(xmlProvider);
manager.addConfigurationProvider(propProvider);
manager.init();
manager.printConstants();
}
}
程序运行结果：
策略模式实战2（大话设计模式书上的例子）：
package org.leiwen.dp.action.stragety.basic;
//现金收费抽象类
public abstract class CashSuper { // 使用枚举类型表示收费类型
public enum PayType {
CASH_NORMAL, CASH_RETURN, CASH_REBATE
}; // 现金收取抽象类的抽象方法，收取现金，参数为原价，返回值为当前价
public abstract double acceptCash(double money);}
package org.leiwen.dp.action.stragety.basic;
/**
* 正常收费子类
*/
public class CashNormal extends CashSuper { //正常收费，原价返回
public double acceptCash(double money) {
return money;
}
} package org.leiwen.dp.action.stragety.basic;
/**
* 打折收费子类
* @author Administrator
*
*/
public class
CashRebate extends CashSuper {
private double moneyRebate = 1;
//打折收费，初始化时，需要输入折扣率，如八折，就是0.8
public CashRebate(double moneyRebate) {
this.moneyRebate = moneyRebate;
}
public double acceptCash(double money) {
return money * moneyRebate;
}
}
package org.leiwen.dp.action.stragety.basic;
/**
* 返利收费子类
*/
public class
CashReturn extends CashSuper {
private double moneyCondition = 0.0;
private double moneyReturn = 0.0;
// 返利收费，初始化时必须要输入返利条件和返利值，比如满300返100，则moneyCondition=300，moneyReturn=100
public CashReturn(double moneyCondition, double moneyReturn) {
this.moneyCondition = moneyCondition;
this.moneyReturn = moneyReturn;
}
public double acceptCash(double money) {
double result = money;
//若大于返利条件，则需要减去返利值
if (money >= moneyCondition) {
result = money - Math.floor(money / moneyCondition) * moneyReturn;
}
return result;
}
}
package org.leiwen.dp.action.stragety.basic;
//策略模式实现
public class
CashContext {
private CashSuper cs;
//通过构造方法，传入具体的收费策略
public CashContext(CashSuper cs) {
this.cs = cs;
}
public double getResult(double money) {
//根据收费策略的不同，获得计算结果
return cs.acceptCash(money);
}
}
package org.leiwen.dp.action.stragety.basic;
/**
* @author 雷文 2012-2-17
* @since 1.0
*/
public class
StragetyTest {
public static void main(String[] args) {
// 测试策略模式的实现
//CashSuper cs = CashFactory.createCashAccept(PayType.CASH_REBATE);
CashSuper cs = new CashRebate(0.8);
CashContext context = new CashContext(cs);
double money = context.getResult(200);
System.out.println("实收：" + money + "元");
}
}
有任何赞美，批评，建议，意见，欢迎留言，欢迎拍砖。(*^__^*)
