快速学习设计模式-适配器模式

 

该模式设计关键点

 适配器模式，关键点是，通过一个适配类，将另外一个类的功能，适配成规范的接口方法。

 这个模式要好好理解一下，没有那么简答的。最后以spring源码中的使用做为深入理解的入口。

 

UML图

 

 

适配器模式，看起来非常简单，一个类Adaptee，有一个方法specificRequest（），另外有一个接口叫做 Target，它声明了一个方法叫做request（），然后想要在不改变Adaptee的前提下，把Adaptee的specificRequest（），转换成request（）去调用。

 

适配器模式在spring中AOP部分的源码

Adaptee（将要被转换的类）

 前置通知的方法 MethodBeforeAdvice ，这是想要转换的类

public interface MethodBeforeAdvice extends BeforeAdvice {

	void before(Method method, Object[] args, Object target) throws Throwable;

}

target （目标接口，就是希望被转换的类，转换成这样的形式） 

Adapter的接口 AdvisorAdapter，这是想要转换成的类。

public interface AdvisorAdapter {
	// 判断通知类型是否匹配
	boolean supportsAdvice(Advice advice);
	// 获取对应的拦截器
	MethodInterceptor getInterceptor(Advisor advisor);

}

Adapter（适配器）

MethodBeforeAdviceAdapter  这是适配器，实现了AdvisorAdapter。

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

	@Override
	public boolean supportsAdvice(Advice advice) {
		return (advice instanceof MethodBeforeAdvice);
	}

	@Override
	public MethodInterceptor getInterceptor(Advisor advisor) {
        //在适配器里边，通过引入另外一个类，并调用其方法，达到发挥其功能的作用
		MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
		// 通知类型匹配对应的拦截器
		return new MethodBeforeAdviceInterceptor(advice);
	}
}

 

 整体的串一下思路，其实就是通过适配器，将我们的一个A类的通知方法转换成了拦截器，将A类的通知方法，交给B类拦截器去执行（代码到这里，只能看到，通知方法被转换成了拦截器）。我们定义的AOP的通知方法，本身就是通过拦截器来执行的。

 

感悟

在写适配器模式的时候，真的是看了网上很多文章，都很浅显。感觉读完戛然而止，甚至觉得我完全没有必要用这个设计模式。可能这就是需求不一样吧。 但是把这个设计模式放在spring中，将AOP的通知方法，转换成拦截器，然后统一执行拦截器。AOP通知的方法，在在拦截器中被执行。真的是太巧妙了。

 

感兴趣的话，再看一段spring的源码

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {

	private final List<AdvisorAdapter> adapters = new ArrayList<AdvisorAdapter>(3);


	/**
	 * Create a new DefaultAdvisorAdapterRegistry, registering well-known adapters.
	 */
	public DefaultAdvisorAdapterRegistry() {
		// 注册相应的适配器
		registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
		registerAdvisorAdapter(new AfterReturningAdviceAdapter());
		registerAdvisorAdapter(new ThrowsAdviceAdapter());
	}

	// 包装类  将通知转换为了 对应的适配器
	// 本案例中将 MyMethodBeforeAdvice转换为了MethodBeforeAdviceAdapter
	@Override
	public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
		if (adviceObject instanceof Advisor) {
			return (Advisor) adviceObject;
		}
		if (!(adviceObject instanceof Advice)) {
			throw new UnknownAdviceTypeException(adviceObject);
		}
		Advice advice = (Advice) adviceObject;
		if (advice instanceof MethodInterceptor) {
			// So well-known it doesn't even need an adapter.
			return new DefaultPointcutAdvisor(advice);
		}
		for (AdvisorAdapter adapter : this.adapters) {
			// Check that it is supported.
			if (adapter.supportsAdvice(advice)) {
				return new DefaultPointcutAdvisor(advice);
			}
		}
		throw new UnknownAdviceTypeException(advice);
	}
	// 获取适配器对应的所有的拦截器
	@Override
	public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
		List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
		Advice advice = advisor.getAdvice();
		if (advice instanceof MethodInterceptor) {
			interceptors.add((MethodInterceptor) advice);
		}
		for (AdvisorAdapter adapter : this.adapters) {
			if (adapter.supportsAdvice(advice)) {
								// 调用了适配器的方法
				interceptors.add(adapter.getInterceptor(advisor));
			}
		}
		if (interceptors.isEmpty()) {
			throw new UnknownAdviceTypeException(advisor.getAdvice());
		}
		return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
	}

	@Override
    // 通过这个方法，可以扩展AOP的通知类型
	public void registerAdvisorAdapter(AdvisorAdapter adapter) {
		this.adapters.add(adapter);
	}
}