策略模式--策略实现的封装性和随意扩展性

 策略模式，这名字听起来有点唬人，思想确实不错，但是我想每个做过面向对象开发的人都会有这个思想，今天又看到这个概念了，顺手就来实现一下。

首先定义一个接口：

package pan.common; import java.util.Map; interface Strategy { /** * 查找一个map中所有相同的值 * @param items */ public void checkSameItems(Map<String, String> items); }

这就是整个策略模式的核心了。接着是两个实现了：

实现一：

package pan.common; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; class StrategyImplA implements Strategy { public void checkSameItems(Map<String, String> items) { Set<String> keySet = items.keySet(); Iterator<String> keyIterator = keySet.iterator(); Map<String, String> itemsConvert = new HashMap<String, String>(); while(keyIterator.hasNext()) { String key = keyIterator.next(); if (items.get(key) == null || "".equals(items.get(key))) { continue; } if (itemsConvert.containsKey(items.get(key))) { System.out.println("The " + itemsConvert.get(items.get(key)) + " and the " + key + " are same."); } else { itemsConvert.put(items.get(key), key); } } } }

实现二：

package pan.common; import java.util.Map; import java.util.Set; class StrategyImplB implements Strategy { public void checkSameItems(Map<String, String> items) { Set<String> keySet = items.keySet(); String[] keys = keySet.toArray(new String[keySet.size()]); String[] values = items.values().toArray(new String[items.values().size()]); for (int i = 0; i < values.length; i++) { if (values[i] == null || "".equals(values[i])) { continue; } for (int j = i + 1; j < values.length; j++) { if (values[i].equals(values[j])) { System.out.println("The " + keys[i] + " and the " + keys[j] + " are same."); } } } } }

为了可以随便增加实现而不影响接口的调用并且封装实现，让接口的实现也可以即插即用，把实现类定义在properties中，通过类反射导入。

定义Strategy.properties：

A=pan.common.StrategyImplA
B=pan.common.StrategyImplB

package pan.common; import java.io.File; import java.io.FileInputStream; import java.util.Enumeration; import java.util.HashMap; import java.util.Map; import java.util.Properties; public class CommonUtil { /** * @param items * @param type * @throws Exception */ public static void checkSameItems(Map<String, String> items, String type) throws Exception { Map<String, String> impls = readProperties("Strategy.properties"); String impl = impls.get(type); if (impl == null) { throw new Exception("no such impl"); } Class classImpl= Class.forName(impl); Strategy strategy = (Strategy) classImpl.newInstance(); strategy.checkSameItems(items); } /** * @param path * @return * @throws Exception */ private static Map<String, String> readProperties(String path) throws Exception { Properties properties = new Properties(); Map<String, String> impl = new HashMap<String, String>(); properties.load(new FileInputStream(new File(path))); Enumeration enums = properties.keys(); while (enums.hasMoreElements()) { String key = (String) enums.nextElement(); String value = properties.getProperty(key); impl.put(key, value); } return impl; } }

下面就可以测试一下了：

package pan.test; import java.util.HashMap; import java.util.Map; import pan.common.CommonUtil; public class Test { /** * @param args */ public static void main(String[] args) { Map<String, String> items = new HashMap<String, String>(); for (int i = 0; i < 1000; i++) { items.put(String.valueOf(i), String.valueOf(i)); } items.put("1000", "999"); try { CommonUtil.checkSameItems(items, "A"); CommonUtil.checkSameItems(items, "C"); } catch (Exception e) { e.printStackTrace(); } } }

 

都输出The 999 and the 1000 are same.
如果还有第三种实现方法，则再加入StrategyImplC.java，并在Strategy.properties中追加配置，即可追加一种实现而不影响真正的接口
public void checkSameItems(Map<String, String> items, String type) throws Exception；