设计模式的应用场景(7)--适配器模式

适配器模式

定义：将一个系统的接口转换成另外一种形式，从而使原来不能直接调用的接口变得可以调用。

优点

适配器模式也是一种包装模式，它与装饰模式同样具有包装的功能，此外，对象适配器模式还具有委托的意思。总的来说，适配器模式属于补偿模式，专用来在系统后期扩展、修改时使用。

缺点

过多的使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。

适配器模式应用场景

在软件开发中，也就是系统的数据和行为都正确，但接口不相符时，我们应该考虑用适配器，目的是使控制范围之外的一个原有对象与某个接口匹配。适配器模式主要应用于希望复用一些现存的类，但是接口又与复用环境要求不一致的情况。比如在需要对早期代码复用一些功能等应用上很有实际价值。适用场景大致包含三类：

1、已经存在的类的接口不符合我们的需求；

2、创建一个可以复用的类，使得该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作；

3、在不对每一个都进行子类化以匹配它们的接口的情况下，使用一些已经存在的子类。

下面举例说明适配器模式的使用：

接着上面的例子，内网的负责人写的代码是接收Map类型的

import java.util.HashMap;
import java.util.Map;

public class Application {
public static void execute(HashMap map) {
for (int i = 0; i < map.size(); i++) {
System.out.println(map.get(i+""));
}
}
}

小巩基于外观模式写的接口是提供list

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

public class Facade {
public List getEmpByOrgan(String orgId) {
List list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("王五");
return list;
}
4000

}

那么问题来了，两边接口不一样，需要适配器

import java.util.Map;
import java.util.List;
import java.util.HashMap;

public class ListAdapter extends HashMap{
private List list;
ListAdapter(List list) {
this.list = list;
}
public int size() {
return list.size();
}
public Object get(Object i) {
return list.get((Integer.valueOf(i.toString())).intValue());
}
}

最后，看看客户端调用代码

public class Client {
public static void main(String[] argv) {
Facade facade = new Facade();
ListAdapter listAdapter = new ListAdapter(facade.getEmpByOrgan("1"));
Application.execute(listAdapter);
}
}

上面演示的是对象适配器的用法，可以看到被适配的对象是被引用的。另外一种方式是类适配器，被适配的类是以继承接口方式使用的。

下面的例子展示两种适配器的使用

考虑一个记录日志的应用，用户可能会提出要求采用文件的方式存储日志，也可能会提出存储日志到数据库的需求，这样我们可以采用适配器模式对旧的日志类进行改造，提供新的支持方式。

首先我们需要一个简单的日志对象类

public class LogBean {
private String logId;//日志编号
private String opeUserId;//操作人员

public String getLogId(){
return logId;
}
public void setLogId(String logId){
this.logId = logId;
}

public String getOpeUserId(){
return opeUserId;
}
public void setOpeUserId(String opeUserId){
this.opeUserId = opeUserId;
}
public String toString(){
return "logId="+logId+",opeUserId="+opeUserId;
}
}

接下来定义一个操作日志文件的接口

import java.util.List;

/*
* 读取日志文件，从文件里面获取存储的日志列表对象
* @return 存储的日志列表对象
*/
public interface LogFileOperateApi {
public List<LogBean> readLogFile();
/**
* 写日志文件，把日志列表写出到日志文件中去
* @param list 要写到日志文件的日志列表
*/
public void writeLogFile(List<LogBean> list);
}

然后实现日志文件的存储和获取

import java.io.File;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.List;

/*
* 实现对日志文件的操作
*/
public class LogFileOperate implements LogFileOperateApi{
/*
* 设置日志文件的路径和文件名称
*/
private String logFileName = "file.log";
/*
* 构造方法，传入文件的路径和名称
*/
public LogFileOperate(String logFilename){
if(logFilename!=null){
this.logFileName = logFilename;
}
}

@Override
public List<LogBean> readLogFile() {
// TODO Auto-generated method stub
List<LogBean> list = null;
ObjectInputStream oin =null;
//业务代码
return list;
}

@Override
public void writeLogFile(List<LogBean> list) {
// TODO Auto-generated method stub
File file = new File(logFileName);
ObjectOutputStream oout = null;
//业务代码
}

}

如果这时候需要引入数据库方式，引入适配器之前，我们需要定义日志管理的操作接口

public interface LogDbOpeApi {
/*
* 新增日志
* @param 需要新增的日志对象
*/
public void createLog(LogBean logbean);
}
接下来就要实现适配器了，LogDbOpeApi 接口就相当于 Target 接口，LogFileOperate 就相当于 Adaptee 类

import java.util.List;

/*
* 适配器对象，将记录日志到文件的功能适配成数据库功能
*/
public class LogAdapter implements LogDbOpeApi{
private LogFileOperateApi adaptee;
public LogAdapter(LogFileOperateApi adaptee){
this.adaptee = adaptee;
}
@Override
public void createLog(LogBean logbean) {
// TODO Auto-generated method stub
List<LogBean> list = adaptee.readLogFile();
list.add(logbean);
adaptee.writeLogFile(list);
}
}

最后是客户端代码的实现

import java.util.ArrayList;
import java.util.List;

public class LogClient {
public static void main(String[] args){
LogBean logbean = new LogBean();
logbean.setLogId("1");
logbean.setOpeUserId("michael");
List<LogBean> list = new ArrayList<LogBean>();
LogFileOperateApi logFileApi = new LogFileOperate("");
//创建操作日志的接口对象
LogDbOpeApi api = new LogAdapter(logFileApi);
api.createLog(logbean);
}
}

下面演示累类适配器

import java.util.List;

/*
* 类适配器对象案例
*/
public class ClassAdapter extends LogFileOperate implements LogDbOpeApi{

public ClassAdapter(String logFilename) {
super(logFilename);
// TODO Auto-generated constructor stub
}

@Override
public void createLog(LogBean logbean) {
// TODO Auto-generated method stub
List<LogBean> list = this.readLogFile();
list.add(logbean);
this.writeLogFile(list);
}

}

在实现中，主要是适配器的实现与以前不一样，与对象适配器实现同样的功能相比，类适配器在实现上有所改变：

需要继承 LogFileOperate 的实现，然后再实现 LogDbOpeApi 接口；

需要按照继承 LogFileOperate 的要求，提供传入文件路径和名称的构造方法；

不再需要持有 LogFileOperate 的对象，因为适配器本身就是 LogFileOperate 对象的子类；

以前调用被适配对象的方法的地方，全部修改成调用自己的方法。

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

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

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

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

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

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