设计模式之适配器模式

1.参考文献：

参考文献1：研磨设计模式——陈臣

参考文献2：前面写过一篇 缺省适配模式 

本文将采用同时支持日志文件与数据库的日志管理系统来说明适配器模式。

2.适配器模式解析

2.1适配器模式的定义

将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

2.2.适配器模式的结构与说明

• Client：客户端，调用自己需要的领域接口Target
• Target：定义客户端需要的跟特定领域相关的接口
• Adaptee：已经存在的接口，通常能满足客户端的功能需求，但是接口和客户端要求的特定领域接口不一致，需要被适配
• 类1是Adapter：适配器，把Adaptee适配称为Client需要的Targe

2.3.适配器模式代码实例

Target.java

/**
 * 定义客户端使用的接口，与特定领域相关
 */
public interface Target {
    /**
     * 示意方法，客户端请求处理的方法
     */
    public void request();
}

Adaptee.java

/**
 * 已经存在的接口，这个接口需要被适配
 */
public class Adaptee {
    /**
     * 示意方法，原本已经存在，已经实现的方法
     */
    public void specificRequest() {
        //具体的功能处理
        System.out.println("this is in Adaptee!");
    }
}

Adapter.java

/**
 * 适配器
 */
public class Adapter implements Target {
    /**
     * 持有需要被适配的接口对象
     */
    private Adaptee adaptee;
    /**
     * 构造方法，传入需要被适配的对象
     * @param adaptee 需要被适配的对象
     */
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    public void request() {
        System.out.println("this is in Adapter!");
        //可能转调已经实现了的方法，进行适配
        adaptee.specificRequest();
    }
}

Client.java

import java.util.*;
public class Client {
    public static void main(String[] args) {
        //准备日志内容，也就是测试的数据
        LogModel lm1 = new LogModel();
        lm1.setLogId("001");
        lm1.setOperateUser("admin");
        lm1.setOperateTime("2010-03-02 10:08:18");
        lm1.setLogContent("这是一个测试");
        
        List<LogModel> list = new ArrayList<LogModel>();
        list.add(lm1);

        //创建操作日志文件的对象
        LogFileOperateApi api = new LogFileOperate(""); 
        
        //保存日志文件
        api.writeLogFile(list);
        
        //读取日志文件的内容
        List<LogModel> readLog = api.readLogFile();
        System.out.println("readLog="+readLog);
    }
}

/**
 *输出结果：
 *readLog=[logId=001,operateUser=admin,operateTime=2010-03-02 10:08:18,logContent=这是一个测试]
 * */

3.日志管理第一版V1

这个版本的日志管理系统只支持以日志文件的形式记录日志。

先简单定义日志对象，也就是描述日志的对象模型。（由于这个对象需要被写入文件中，因此这个对象需要序列化）

LogModel.java

import java.io.*;

/**
 * 日志数据对象
 */
public class LogModel implements Serializable{

    private static final long serialVersionUID = 1L;
    /**
     * 日志编号
     */
    private String logId;
    /**
     * 操作人员
     */
    private String operateUser;
    /**
     * 操作时间，以yyyy-MM-dd HH:mm:ss的格式记录
     */
    private String operateTime;    
    /**
     * 日志内容
     */
    private String logContent;
    
    //getter and setter
    public String getLogId() {
        return logId;
    }
    public void setLogId(String logId) {
        this.logId = logId;
    }
    public String getOperateUser() {
        return operateUser;
    }
    public void setOperateUser(String operateUser) {
        this.operateUser = operateUser;
    }
    public String getOperateTime() {
        return operateTime;
    }
    public void setOperateTime(String operateTime) {
        this.operateTime = operateTime;
    }
    public String getLogContent() {
        return logContent;
    }
    public void setLogContent(String logContent) {
        this.logContent = logContent;
    }
    
    public String toString(){
        return "logId="+logId+",operateUser="+operateUser+",operateTime="+operateTime+",logContent="+logContent;
    }
}

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

LogFileOperateApi.java

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

再接着就是实现日志的存取，实现的方式很简单，就是读写文件。

LogFileOperate.java

import java.io.*;
import java.util.*;

/**
 * 实现对日志文件的操作
 */
public class LogFileOperate implements LogFileOperateApi{
    /**
     * 日志文件的路径和文件名称，默认是当前classpath下的AdapterLog.log
     * 就是项目的根目录下，与.classpath文件同目录
     */
    private String logFilePathName = "AdapterLog.log";    
    /**
     * 构造方法，传入文件的路径和名称
     * @param logFilePathName 文件的路径和名称
     */
    public LogFileOperate(String logFilePathName) {
        //先判断是否传入了文件的路径和名称，如果是，
        //就重新设置操作的日志文件的路径和名称
        if(logFilePathName!=null && logFilePathName.trim().length()>0){
            this.logFilePathName = logFilePathName;
        }
    }
    
    //读文件
    public  List<LogModel> readLogFile() {
        List<LogModel> list = null;
        ObjectInputStream oin = null;
        try {
            File f = new File(logFilePathName);
            if(f.exists()){
                oin = new ObjectInputStream(
                        new BufferedInputStream(new FileInputStream(f))
                );
                list = (List<LogModel>)oin.readObject();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            try {
                if(oin!=null){
                    oin.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return list;
    }

    //写文件
    public void writeLogFile(List<LogModel> list){
        File f = new File(logFilePathName);
        ObjectOutputStream oout = null;
        try {
            oout = new ObjectOutputStream(
                    new BufferedOutputStream(new FileOutputStream(f))
            );
            oout.writeObject(list);            
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                oout.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

最后写一个客户端测试一下，看看是否实现了日志的读写

Client.java

import java.util.*;
public class Client {
    public static void main(String[] args) {
        //准备日志内容，也就是测试的数据
        LogModel lm1 = new LogModel();
        lm1.setLogId("001");
        lm1.setOperateUser("admin");
        lm1.setOperateTime("2010-03-02 10:08:18");
        lm1.setLogContent("这是一个测试");
        
        List<LogModel> list = new ArrayList<LogModel>();
        list.add(lm1);

        //创建操作日志文件的对象
        LogFileOperateApi api = new LogFileOperate(""); 
        
        //保存日志文件
        api.writeLogFile(list);
        
        //读取日志文件的内容
        List<LogModel> readLog = api.readLogFile();
        System.out.println("readLog="+readLog);
    }
}

/**
 *输出结果：
 *readLog=[logId=001,operateUser=admin,operateTime=2010-03-02 10:08:18,logContent=这是一个测试]
 * */

4.日志管理第二版V2

第一版日志管理系统使用一段时间以后，考虑升级系统，要求使用数据库来管理日志。数据库管理日志的接口如下，具体实现省略。

LogDbOperateApi.java

import java.util.*;
/**
 * 定义操作日志的应用接口，为了示例的简单，
 * 只是简单的定义了增删改查的方法
 */
public interface LogDbOperateApi {
    /**
     * 新增日志
     * @param lm 需要新增的日志对象
     */
    public void createLog(LogModel lm);
    /**
     * 修改日志
     * @param lm 需要修改的日志对象
     */
    public void updateLog(LogModel lm);
    /**
     * 删除日志
     * @param lm 需要删除的日志对象
     */
    public void removeLog(LogModel lm);
    /**
     * 获取所有的日志
     * @return 所有的日志对象
     */
    public List<LogModel> getAllLog();
}

但是，后来客户又提出新的要求，希望实现数据库管理日志的通知，又能够实现文件存储（也就是第一版的日志管理系统）。那么现在又面临这什么样的问题呢。我们知道，当我们使用第二版日志管理系统以后。我们的客户端是面向数据库操作日志的接口，也就是LogDbOperateApi，而不是原来第一版的LogFileOperateApi。客户端所面临的领域接口发生了变化，我们又希望不改变第一版文件管理日志的接口与实现而能够直接复用。这就是我们的需求。而适配器模式就能够帮助我们解决这样的问题。

仔细分析上面的问题，问题的根源在于接口的不兼容，功能是基本实现了，也就是说，只要想办法让第一版和第二版的接口跟客户端都匹配起来，就可以实现复用第一版的功能了。按照适配器模式的实现方式，可以定义一个类（Adapter）来实现第二版的接口（Target），然后再内部实现的时候，转调第一版已经实现了的功能，这样就可以通过对象组合的方式，既复用了第一版已有的功能，又同时满足了第二版调用的要求。

5.使用适配器模式来实现同时支持数据库与文件的日志管理系统

实例

把适配器简单的实现出来，代码如下：

import java.util.List;

/**
 * 适配器对象，把记录日志到文件的功能适配成第二版需要的增删改查的功能
 */
public class Adapter implements LogDbOperateApi{
    /**
     * 持有需要被适配的接口对象
     */
    private LogFileOperateApi adaptee;
    /**
     * 构造方法，传入需要被适配的对象
     * @param adaptee 需要被适配的对象
     */
    public Adapter(LogFileOperateApi adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void createLog(LogModel lm) {
        //首先创建日志并保存到数据库中，此处省略
        System.out.println("now in LogDbOperate createLog");
        //接下来是日子文件操作
        //1：先读取文件的内容
        List<LogModel> list = adaptee.readLogFile();
        
        //2：加入新的日志对象
        System.out.println(lm.getLogId());
        list.add(lm);
        //3：重新写入文件
        adaptee.writeLogFile(list);
    }
    
    @Override
    public List<LogModel> getAllLog() {
        //读取数据库中的日志文件，此处省略
        System.out.println("now in LogDbOperate getAllLog");
        //接下来是日子文件操作
        return adaptee.readLogFile();
    }
    
    @Override
    public void removeLog(LogModel lm) {
        //删除数据库中的日志文件，此处省略
        System.out.println("now in LogDbOperate removeLog");
        //接下来是日子文件操作
        //1：先读取文件的内容
        List<LogModel> list = adaptee.readLogFile();
        //2：删除相应的日志对象
        list.remove(lm);
        //3：重新写入文件
        adaptee.writeLogFile(list);
    }
    
    @Override
    public void updateLog(LogModel lm) {
        //更新数据库中的日志文件，此处省略
        System.out.println("now in LogDbOperate updateLog");
        //接下来是日子文件操作
        //1：先读取文件的内容
        List<LogModel> list = adaptee.readLogFile();
        //2：修改相应的日志对象
        for(int i=0;i<list.size();i++){
            if(list.get(i).getLogId().equals(lm.getLogId())){
                list.set(i, lm);
                break;
            }
        }
        //3：重新写入文件
        adaptee.writeLogFile(list);
    }
}

此时的客户端也需要一些改变，代码如下：

import java.util.*;
public class Client {
    public static void main(String[] args) {
        //准备日志内容，也就是测试的数据
        LogModel lm1 = new LogModel();
        lm1.setLogId("001");
        lm1.setOperateUser("admin");
        lm1.setOperateTime("2010-03-02 10:08:18");
        lm1.setLogContent("这是一个测试");
        
        List<LogModel> list = new ArrayList<LogModel>();
        list.add(lm1);

        //创建操作日志文件的对象
        LogFileOperateApi logFileApi = new LogFileOperate("");
        
        //创建新版的操作日志的接口对象
        LogDbOperateApi api = new Adapter(logFileApi); 
        
        //保存日志文件
        api.createLog(lm1);
        
        //读取日志文件的内容
        List<LogModel> allLog = api.getAllLog();
        System.out.println("allLog="+allLog);
    }
}

程序运行结果：

now in LogDbOperate createLog
001
now in LogDbOperate getAllLog
allLog=[logId=001,operateUser=admin,operateTime=2010-03-02 10:08:18,logContent=这是一个测试]

6.总结

6.1.模式的功能

适配器的模式的主要功能是进行匹配转换，目的是复用已有的功能，而不是来实现新的接口。也就是，客户端需要的功能应该是已经实现好了的，不需要适配器模式来实现，适配器模式主要负责把不兼容的接口转换成客户端期望的样子就可以了。

但是这并不是说，在适配器里面就不能实现功能。适配器里面可以实现功能，我们称这种适配为智能适配器。而且，在接口匹配和转换的过程中，也有可能需要额外实现一定的功能，才能转换过来 ，比如需要调整参数以进行匹配等。

6.2.Adaptee和Target的关系

适配器模式中被适配的接口Adaptee和适配称为的接口Target是没有关联的，也就是说，Adaptee和Target中的方法既可以相同，也可以不同。极端情况下两个接口里面的方法可能是完全不同的，当然这种情况下页可以完全相同。

6.3.对象组合

根据前面的实现，会发现适配器的实现方式其实依靠对象组合的方式。通过给适配器对象组合被适配的对象（在Adapter实例拥有Adaptee类型的成员变量），代码如下：

public Adapter(Adaptee adaptee) 
{
    this.adaptee = adaptee;
}

然后当客户端调用Target的时候，适配器（adapter）会把相应的功能委托给被适配的对象（adaptee）去完成。

6.4适配器模式调用的顺序

1.调用客户端需要的功能

2.这个功能会由适配器来实现（target.request()）

3.适配器会转调被适配对象的功能。（adaptee.specificRequest()）

public void request() {
    System.out.println("this is in Adapter!");
    //可能转调已经实现了的方法，进行适配
    adaptee.specificRequest();
}