策略设计模式

1)转自java思想,

需求:添加对象的过程有可能用"+",有的对象可能用add方法,则添加对象方法抽象出来,将变化的事务完全隔离到一个函数对象中,就是处理2个相同的对象,得到一个结果

public interface Combiner<T> {
	public T combine(T x,T y);
}

处理任何相同的2个对象得到其中一个的结果,可以用于2个对象处理之后还是相同对象,有BigDecimal,Integer,String,StringBuffer

用法:

public class IntegerAdder implements Combiner<Integer>{
		@Override
		public Integer combine(Integer x, Integer y) {
			return x+y;
		}
	}

可以用户2个int数相加

IntegerAdder ia = new IntegerAdder();
		System.out.println(ia.combine(1, 3));

但是往往需要更灵活的运用,创建通用类,与其他泛型类进行结合

public static<T> T reduce(Iterable<T> seq,Combiner<T> combiner){
		Iterator<T> iter = seq.iterator();
		if(iter.hasNext()){
			T result = iter.next();
			while(iter.hasNext()){
				result = combiner.combine(result, iter.next());
			}
			return result;
		}
		return null;
	}

传入int的循环数组进行遍历处理,更加方便,利用设计模式的技术,我感觉用的更好的是应该能写出像上面的工具,才是真正学会设计模式!!

2)spring BeanDefinitionParserDelegate解析非默认标签时通过NamespaceHandlerResolver得到NamespaceHandler的策略,通过反射存储类路径名称得到的类

public interface NamespaceHandlerResolver {
	/**
	 * 通过标签的命名空间得到解析此标签的处理器
	 * @param namespaceUri 标签的命名空间
	 * @return 
	 */
	NamespaceHandler resolve(String namespaceUri);
}

spring中只有一种实现

职责单一,获取NamerspaceHandler,内部数据全部通过固定文件获取,实例化时不用传递参数,都是有默认值的构造方法中的参数有得到配置文件地址,和classLoader这些都可以静态方法获得,不用太依靠别的类的实例化,方便

public NamespaceHandler resolve(String namespaceUri) {
		Map<String, Object> handlerMappings = getHandlerMappings();   //私有方法获得命名空间对应的处理器的map文件
		Object handlerOrClassName = handlerMappings.get(namespaceUri); 
		if (handlerOrClassName == null) {
			return null;
		}
		else if (handlerOrClassName instanceof NamespaceHandler) {     //Object直接返回的是实例好的Handler则直接返回
			return (NamespaceHandler) handlerOrClassName;
		}
		else {
			String className = (String) handlerOrClassName;        //否则实例化
			try {
				Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
				if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
					throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
							"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
				}
				NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
				namespaceHandler.init(); //初始化
				handlerMappings.put(namespaceUri, namespaceHandler);//直接替换掉?不加上this下次再次通过nameuri获取还会得到初始化的啊,意义何在?不加this难道只为了,不破坏里面的值吗?
				return namespaceHandler;                            //返回对应的Handler
			}
		}
	}

其他使用此地方的类:

XmlBeanDefinitionReader

protected XmlReaderContext createReaderContext(Resource resource) {
		//获取namespaceHandlerResolver默认的是从spring.handlers获取
		if (this.namespaceHandlerResolver == null) {
			this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();//不是直接实例化,而是通过方法获得,以后如果发现更好的数据结构可以替换
		}
		return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
				this.sourceExtractor, this, this.namespaceHandlerResolver);
	}

	/**
	 * Create the default implementation of {@link NamespaceHandlerResolver} used if none is specified.
	 * Default implementation returns an instance of {@link DefaultNamespaceHandlerResolver}.
	 */
	protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {//方法为protected可以专门替换此方法,但是看spring源码替换的机会不大,因为写死用用的XmlBeandifinitionReader
		return new DefaultNamespaceHandlerResolver(getResourceLoader().getClassLoader());
	}

3)摘自spring中org.springframework.beans.Mergeable可合并的接口,此例子跟第一例子有点类似

public interface Mergeable {   //可以合并的类
    public Object merge(Object parent);
}

在spring中有4种实现,看一种实现

public class MergeList<E> extends ArrayList<E> implements Mergeable{
    //返回他们值的和
    @Override
    public List<E> merge(Object parent) {
        List<E> merged = new ArrayList<E>();
        merged.addAll((List) parent);
        merged.addAll(this);
        return merged;
    }
}