java设计模式之适配器模式详解编程语言

List list=new ArrayList(); 
for(Iterator it=list.iterator();it.hasNext();) 
{ 
 System.out.println(it.next()); 
}

这样，如果将老版本的程序运行在新的 Java 编译器上就会出错。因为 List 接口中已经没有 elements()，而只有 iterator() 了。那么如何将老版本的程序运行在新的 Java 编译器上呢? 如果不加修改，是肯定不行的，但是修改要遵循“开－闭”原则。我们可以用 Java 设计模式中的适配器模式解决这个问题。

采用适配器模式

import java.util.ArrayList; 
import java.util.Enumeration; 
import java.util.Iterator; 
import java.util.List; 
 
public class NewEnumeration implements Enumeration 
{ 
 
 Iterator it; 
 public NewEnumeration(Iterator it) 
 { 
 this.it=it; 
 // TODO Auto-generated constructor stub 
 } 
 
 public boolean hasMoreElements() 
 { 
 // TODO Auto-generated method stub 
 return it.hasNext(); 
 } 
 
 public Object nextElement() 
 { 
 // TODO Auto-generated method stub 
 return it.next(); 
 } 
 public static void main(String[] args) 
 { 
 List list=new ArrayList(); 
 list.add("a"); 
 list.add("b"); 
 list.add("C"); 
 for(Enumeration e=new NewEnumeration(list.iterator());e.hasMoreElements();) 
 { 
 System.out.println(e.nextElement()); 
 } 
 } 
}

Java I/O 库大量使用了适配器模式，例如 ByteArrayInputStream 是一个适配器类，它继承了 InputStream 的接口，并且封装了一个 byte 数组。换言之，它将一个 byte 数组的接口适配成 InputStream 流处理器的接口。

我们知道 Java 语言支持四种类型：Java 接口，Java 类，Java 数组，原始类型（即 int,float 等）。前三种是引用类型，类和数组的实例是对象，原始类型的值不是对象。也即，Java 语言的数组是像所有的其他对象一样的对象，而不管数组中所存储的元素类型是什么。这样一来的话，ByteArrayInputStream 就符合适配器模式的描述，是一个对象形式的适配器类。FileInputStream 是一个适配器类。在 FileInputStream 继承了 InputStrem 类型，同时持有一个对 FileDiscriptor 的引用。这是将一个 FileDiscriptor 对象适配成 InputStrem 类型的对象形式的适配器模式。

同样地，在 OutputStream 类型中，所有的原始流处理器都是适配器类。ByteArrayOutputStream 继承了 OutputStream 类型，同时持有一个对 byte 数组的引用。它一个 byte 数组的接口适配成 OutputString 类型的接口，因此也是一个对象形式的适配器模式的应用。

FileOutputStream 继承了 OutputStream 类型，同时持有一个对 FileDiscriptor 对象的引用。这是一个将 FileDiscriptor 接口适配成 OutputStream 接口形式的对象型适配器模式。

Reader 类型的原始流处理器都是适配器模式的应用。StringReader 是一个适配器类，StringReader 类继承了 Reader 类型，持有一个对 String 对象的引用。它将 String 的接口适配成 Reader 类型的接口。

Spring 中使用适配器模式的典型应用

在 Spring 的 AOP 里通过使用的 Advice（通知）来增强被代理类的功能。Spring 实现这一 AOP 功能的原理就使用代理模式（1、JDK 动态代理。2、CGLib 字节码生成技术代理。）对类进行方法级别的切面增强，即，生成被代理类的代理类，并在代理类的方法前，设置拦截器，通过执行拦截器中的内容增强了代理方法的功能，实现的面向切面编程。

Advice（通知）的类型有：BeforeAdvice、AfterReturningAdvice、ThrowSadvice 等。每个类型 Advice（通知）都有对应的拦截器，MethodBeforeAdviceInterceptor、AfterReturningAdviceInterceptor、ThrowsAdviceInterceptor。Spring 需要将每个 Advice（通知）都封装成对应的拦截器类型，返回给容器，所以需要使用适配器模式对 Advice 进行转换。

MethodBeforeAdvice 类

public interface MethodBeforeAdvice extends BeforeAdvice {  
  
 void before(Method method, Object[] args, Object target) throws Throwable;  
  
}  
public interface MethodBeforeAdvice extends BeforeAdvice { 
 
void before(Method method, Object[] args, Object target) throws Throwable; 
 
}

Adapter 类接口

public interface AdvisorAdapter {  
  
 boolean supportsAdvice(Advice advice);  
  
 MethodInterceptor getInterceptor(Advisor advisor);  
  
}  
public interface AdvisorAdapter { 
 
boolean supportsAdvice(Advice advice); 
 
MethodInterceptor getInterceptor(Advisor advisor); 
 
}

MethodBeforeAdviceAdapter 类

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {  
  
 public boolean supportsAdvice(Advice advice) {  
 return (advice instanceof MethodBeforeAdvice);  
 }  
  
 public MethodInterceptor getInterceptor(Advisor advisor) {  
 MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();  
 return new MethodBeforeAdviceInterceptor(advice);  
 }  
  
}  
class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable { 
 
public boolean supportsAdvice(Advice advice) { 
return (advice instanceof MethodBeforeAdvice); 
} 
 
public MethodInterceptor getInterceptor(Advisor advisor) { 
MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice(); 
return new MethodBeforeAdviceInterceptor(advice); 
} 
 
}

DefaultAdvisorAdapterRegistry 类

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());  
 }  
  
  
 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);  
 }  
  
 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()]);  
 }  
  
 public void registerAdvisorAdapter(AdvisorAdapter adapter) {  
 this.adapters.add(adapter);  
 }  
  
}

类适配器和对象适配器的选择

1. 从实现上：类适配器使用对象继承的方式，属于静态的定义方式。对象适配器使用对象组合的方式，属于动态组合的方式；

2. 从工作模式上：类适配器直接继承了 Adaptee，使得适配器不能和 Adaptee 的子类一起工作。对象适配器允许一个 Adapter 和多个 Adaptee，包括 Adaptee 和它所有的子类一起工作；

3. 从定义角度：类适配器可以重定义 Adaptee 的部分行为，相当于子类覆盖父类的部分实现方法。对象适配器要重定义 Adaptee 很困难；

4. 从开发角度：类适配器仅仅引入了一个对象，并不需要额外的引用来间接得到 Adaptee。对象适配器需要额外的引用来间接得到 Adaptee。

总的来说，建议使用对象适配器方式。