设计模式之组合模式

组合（Composite Pattern）模式的定义：允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式来处理个别对象以及对象的组合。属于结构型设计模式。

在组合模式中，整个树形结构中的对象都属于同一种类型，带来的好处就是用户不需要辨别是树枝节点还是叶子节点，可以直接进行操作，给用户的使用带来极大的便利

创建一个接口或者抽象类，作为根节点

public interface HandlerMethodArgumentResolver {

	boolean supportsParameter(MethodParameter parameter);
	
	@Nullable
	Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
}

创建一个已经实现或者继承根节点的类，作为树枝节点（在某些情况下也是叶子节点），用来管理和组织树枝节点

public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {
    protected final Log logger = LogFactory.getLog(this.getClass());
    
    //组织和管理树枝节点，当 argumentResolvers == null 时，此节点便是叶子节点
    private final List argumentResolvers = new LinkedList();
    
    private final Map argumentResolverCache = new ConcurrentHashMap(256);

    public HandlerMethodArgumentResolverComposite() {
    }

	//树枝节点的管理行为
    public List getResolvers() {
        return Collections.unmodifiableList(this.argumentResolvers);
    }

    public boolean supportsParameter(MethodParameter parameter) {
        return this.getArgumentResolver(parameter) != null;
    }

    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        HandlerMethodArgumentResolver resolver = this.getArgumentResolver(parameter);
        if (resolver == null) {
            throw new IllegalArgumentException("Unknown parameter type [" + parameter.getParameterType().getName() + "]");
        } else {
            return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
        }
    }

	//树枝节点的管理行为
    private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
        HandlerMethodArgumentResolver result = (HandlerMethodArgumentResolver)this.argumentResolverCache.get(parameter);
        if (result == null) {
            Iterator var3 = this.argumentResolvers.iterator();

            while(var3.hasNext()) {
                HandlerMethodArgumentResolver methodArgumentResolver = (HandlerMethodArgumentResolver)var3.next();
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" + parameter.getGenericParameterType() + "]");
                }

                if (methodArgumentResolver.supportsParameter(parameter)) {
                    result = methodArgumentResolver;
                    this.argumentResolverCache.put(parameter, methodArgumentResolver);
                    break;
                }
            }
        }

        return result;
    }

	//树枝节点的管理行为
    public HandlerMethodArgumentResolverComposite addResolver(HandlerMethodArgumentResolver resolver) {
        this.argumentResolvers.add(resolver);
        return this;
    }

	//树枝节点的管理行为
    public HandlerMethodArgumentResolverComposite addResolvers(List resolvers) {
        if (resolvers != null) {
            Iterator var2 = resolvers.iterator();

            while(var2.hasNext()) {
                HandlerMethodArgumentResolver resolver = (HandlerMethodArgumentResolver)var2.next();
                this.argumentResolvers.add(resolver);
            }
        }

        return this;
    }
}

类图如下

• 所有的对象都具有一些相似的行为
• 对象与对象之间本质是相同的，但是表现出来的却有一定的层次区分，就像公司老板和公司职员，本质都是人，都能说话，但是说话的语调和工作的内容等却不一致的