一天一模式之4适配器模式
初识适配器模式
定义
将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由
于接口不兼容而不能一起工作的那些类可以一起工作。
结构和说明
- Client：客户端，调用自己需要的领域接口Target。
- Target：定义客户端需要的跟特定领域相关的接口。
- Adaptee：已经存在的接口，但与客户端要求的特定领域接口不一致，需要被适配。
- Adapter：适配器，把Adaptee适配成为Client需要的Target
实例代码
定义客户端使用的接口，与特定领域相关
package cn.javass.dp.adapter.example1;
/**
* 定义客户端使用的接口，与特定领域相关
*/
public interface Target {
/**
* 示意方法，客户端请求处理的方法
*/
public void request();
}
已经存在的接口，这个接口需要被适配
package cn.javass.dp.adapter.example1;
/**
* 已经存在的接口，这个接口需要被适配
*/
public class Adaptee {
/**
* 示意方法，原本已经存在，已经实现的方法
*/
public void specificRequest() {
//具体的功能处理
}
}
定义客户端使用的接口，与特定领域相关
package cn.javass.dp.adapter.example1;
/**
* 适配器
*/
public class Adapter implements Target {
/**
* 持有需要被适配的接口对象
*/
private Adaptee adaptee;
/**
* 构造方法，传入需要被适配的对象
* @param adaptee 需要被适配的对象
*/
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void request() {
//可能转调已经实现了的方法，进行适配
adaptee.specificRequest();
}
}
使用适配器的客户端
package cn.javass.dp.adapter.example1;
/**
* 使用适配器的客户端
*/
public class Client {
public static void main(String[] args) {
//创建需被适配的对象
Adaptee adaptee = new Adaptee();
//创建客户端需要调用的接口对象
Target target = new Adapter(adaptee);
//请求处理
target.request();
}
}
体会适配器模式
装配电脑的例子
1：旧的硬盘和电源
2：加入新的硬盘
3：有何问题
如果把上面的问题抽象一下，用对象来描述，那就是：有一个电源类和旧
的硬盘类配合工作得很好，现在又有了一个新的硬盘类，现在想让新的硬盘类和
电源类也配合使用，但是发现它们的接口无法匹配，问题就产生了：如何让原有
的电源类的接口能够适应新的硬盘类的电源接口的需要呢？
4：如何解决
解决方法是采用一个转接线类，转接线可以把电源的接口适配成为新的硬
盘所需要的接口，那么这个转接线类就类似本节的主角——适配器。
同时支持数据库和文件的日志管理
1：日志管理第一版
在第一版的时候，用户要求日志以文件的形式记录。
2：日志管理第二版
要采用数据库来管理日志
不用模式的解决方案
直接参看代码示例
操作第一版
日志数据对象
package cn.javass.dp.adapter.example2;
import java.io.*;
/**
* 日志数据对象
*/
public class LogModel implements Serializable{
/**
* 日志编号
*/
private String logId;
/**
* 操作人员
*/
private String operateUser;
/**
* 操作时间，以yyyy-MM-dd HH:mm:ss的格式记录
*/
private String operateTime;
/**
* 日志内容
*/
private String logContent;
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;
}
}
日志文件操作接口
package cn.javass.dp.adapter.example2;
import java.util.List;
/**
* 日志文件操作接口
*/
public interface LogFileOperateApi {
/**
* 读取日志文件，从文件里面获取存储的日志列表对象
* @return 存储的日志列表对象
*/
public List readLogFile();
/**
* 写日志文件，把日志列表写出到日志文件中去
* @param list 要写到日志文件的日志列表
*/
public void writeLogFile(List list);
}
实现对日志文件的操作
package cn.javass.dp.adapter.example2;
import java.io.*;
import java.util.*;
/**
* 实现对日志文件的操作
*/
public class LogFileOperate implements LogFileOperateApi{
/**
* 日志文件的路径和文件名称，默认是当前classpath下的AdapterLog.log
*/
private String logFilePathName = "AdapterLog.log";
/**
* 构造方法，传入文件的路径和名称
* @param logFilePathName 文件的路径和名称
*/
public LogFileOperate(String logFilePathName) {
//先判断是否传入了文件的路径和名称，如果是，
//就重新设置操作的日志文件的路径和名称
if(logFilePathName!=null && logFilePathName.trim().length()>0){
this.logFilePathName = logFilePathName;
}
}
public List readLogFile() {
List list = null;
ObjectInputStream oin = null;
try {
File f = new File(logFilePathName);
if(f.exists()){
/**
* 使用了装配模式
*/
oin = new ObjectInputStream(
new BufferedInputStream(new FileInputStream(f))
);
list = (List)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 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();
}
}
}
}
客户端
package cn.javass.dp.adapter.example2;
import java.util.ArrayList;
import java.util.List;
import cn.javass.dp.adapter.example3.LogDbOperateApi;
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 list = new ArrayList();
list.add(lm1);
//创建操作日志文件的对象
LogFileOperateApi api = new LogFileOperate("");
//保存日志文件
api.writeLogFile(list);
//读取日志文件的内容
List readLog = api.readLogFile();
System.out.println("readLog="+readLog);
LogDbOperateApi api2 = null;
}
}
操作第二版
定义操作日志的应用接口，为了示例的简单，只是简单的定义了增删改查的方法
package cn.javass.dp.adapter.example3;
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 getAllLog();
}
存在的问题
现在的客户端，无法以同样的方式来直接使用第一版的实现
使用模式的解决方案
示例代码
其他相同，添加了适配器对象
适配器对象，把记录日志到文件的功能适配成第二版需要的增删改查的功能
package cn.javass.dp.adapter.example3;
import java.util.List;
/**
* 适配器对象，把记录日志到文件的功能适配成第二版需要的增删改查的功能
*/
public class Adapter implements LogDbOperateApi{
//优先使用对象组合，而不是使用对象继承
/**
* 持有需要被适配的接口对象
*/
private LogFileOperateApi adaptee;
/**
* 构造方法，传入需要被适配的对象
* @param adaptee 需要被适配的对象
*/
public Adapter(LogFileOperateApi adaptee) {
this.adaptee = adaptee;
}
public void createLog(LogModel lm) {
//1：先读取文件的内容
List list = adaptee.readLogFile();
//2：加入新的日志对象
list.add(lm);
//3：重新写入文件
adaptee.writeLogFile(list);
}
public List getAllLog() {
return adaptee.readLogFile();
}
public void removeLog(LogModel lm) {
//1：先读取文件的内容
List list = adaptee.readLogFile();
//2：删除相应的日志对象
list.remove(lm);
//3：重新写入文件
adaptee.writeLogFile(list);
}
public void updateLog(LogModel lm) {
//1：先读取文件的内容
List list = adaptee.readLogFile();
//2：修改相应的日志对象
for(int i=0;iif(list.get(i).getLogId().equals(lm.getLogId())){
list.set(i, lm);
break;
}
}
//3：重新写入文件
adaptee.writeLogFile(list);
}
}
客户端
package cn.javass.dp.adapter.example3;
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 list = new ArrayList();
list.add(lm1);
//创建操作日志文件的对象
LogFileOperateApi logFileApi = new LogFileOperate("");
//创建新版的操作日志的接口对象
LogDbOperateApi api=new Adapter(logFileApi);
// LogDbOperateApi api = null;
/////////////////////////真正的操作
//保存日志文件
api.createLog(lm1);
//读取日志文件的内容
List allLog = api.getAllLog();
System.out.println("allLog44="+allLog);
}
}
小结一下思路
1：原有文件存取日志的方式，运行得很好
2：现在有了新的基于数据库的实现，新的实现有自己的接口
3：现在想要在第二版的实现里面，能够同时兼容第一版的功能，那么就应有一个类
来实现第二版的接口，然后在这个类里面去调用已有的功能实现，这个类就是适
配器
理解适配器模式
认识适配器模式
1：适配器模式的功能
适配器模式的主要功能是进行转换匹配，目的是复用已有的功能，而不是
来实现新的接口。
适配器里面也可以实现功能，称这种适配器为智能适配器。
2：Adaptee和Target的关系
适配器模式中被适配的接口Adaptee和适配成为的接口Target是没有关联的
3：对象组合
适配器的实现方式其实是依靠对象组合的方式。
5：适配器模式的调用顺序示意图
适配器模式的实现
1：适配器的常见实现
适配器通常是一个类，一般会让适配器类去实现Target接口，然后在适配
器的具体实现里面调用Adaptee。
2：智能适配器
可以在适配器的实现里面，加入新功能的实现，这种适配器被称为智能适配器。
示例代码
智能适配器对象
package cn.javass.dp.adapter.example3;
import java.util.List;
/**
* 适配器对象，把记录日志到文件的功能适配成第二版需要的增删改查的功能
*/
public class Adapter implements LogDbOperateApi{
//优先使用对象组合，而不是使用对象继承
/**
* 持有需要被适配的接口对象
*/
private LogFileOperateApi adaptee;
private TimeUtil adaptee2 = null;
/**
* 构造方法，传入需要被适配的对象
* @param adaptee 需要被适配的对象
*/
public Adapter(LogFileOperateApi adaptee) {
this.adaptee = adaptee;
}
public void createLog(LogModel lm) {
// 开始时间
Long t1=System.currentTimeMillis();
//1：先读取文件的内容
List list = adaptee.readLogFile();
//2：加入新的日志对象
list.add(lm);
//3：重新写入文件
adaptee.writeLogFile(list);
// 结束时间时间
Long t2=System.currentTimeMillis();
this.adaptee2.end();
System.out.println("操作文件时间："+(t2-t1));
}
public List getAllLog() {
return adaptee.readLogFile();
}
public void removeLog(LogModel lm) {
//1：先读取文件的内容
List list = adaptee.readLogFile();
//2：删除相应的日志对象
list.remove(lm);
//3：重新写入文件
adaptee.writeLogFile(list);
}
public void updateLog(LogModel lm) {
//1：先读取文件的内容
List list = adaptee.readLogFile();
//2：修改相应的日志对象
for(int i=0;iif(list.get(i).getLogId().equals(lm.getLogId())){
list.set(i, lm);
break;
}
}
//3：重新写入文件
adaptee.writeLogFile(list);
}
}
3：适配多个Adaptee
示例代码
其他不变，添加一个时间接口
时间接口
package cn.javass.dp.adapter.example3;
public class TimeUtil {
private long a1;
private long a2;
public void begin(){
a1 = System.currentTimeMillis();
}
public void end(){
a2 = System.currentTimeMillis();
}
public void show(){
System.out.println("times11==="+(a2-a1));
}
}
适配器对象
package cn.javass.dp.adapter.example3;
import java.util.List;
/**
* 适配器对象，把记录日志到文件的功能适配成第二版需要的增删改查的功能
*/
public class Adapter implements LogDbOperateApi{
//优先使用对象组合，而不是使用对象继承
/**
* 持有需要被适配的接口对象
*/
private LogFileOperateApi adaptee;
private TimeUtil adaptee2 = null;
/**
* 构造方法，传入需要被适配的对象
* @param adaptee 需要被适配的对象
*/
public Adapter(LogFileOperateApi adaptee,TimeUtil times) {
this.adaptee = adaptee;
this.adaptee2 = times;
}
public void createLog(LogModel lm) {
this.adaptee2.begin();
//1：先读取文件的内容
List list = adaptee.readLogFile();
//2：加入新的日志对象
list.add(lm);
//3：重新写入文件
adaptee.writeLogFile(list);
this.adaptee2.end();
this.adaptee2.show();
}
public List getAllLog() {
return adaptee.readLogFile();
}
public void removeLog(LogModel lm) {
//1：先读取文件的内容
List list = adaptee.readLogFile();
//2：删除相应的日志对象
list.remove(lm);
//3：重新写入文件
adaptee.writeLogFile(list);
}
public void updateLog(LogModel lm) {
//1：先读取文件的内容
List list = adaptee.readLogFile();
//2：修改相应的日志对象
for(int i=0;iif(list.get(i).getLogId().equals(lm.getLogId())){
list.set(i, lm);
break;
}
}
//3：重新写入文件
adaptee.writeLogFile(list);
}
}
4：适配器Adapter实现的复杂程度
适配器Adapter实现的复杂程度，取决于Target和Adaptee的相似程度。
5：缺省适配
缺省适配的意思是：为一个接口提供缺省实现。
示例代码
默认缺省适配器
package cn.javass.dp.adapter.example3;
import java.util.List;
/**
* 默认缺省适配器为部分功能提供实现，
* 其他未实现功能交由子类适配器实现
*
*/
public class DefaultAdapter implements LogDbOperateApi{
@Override
public void createLog(LogModel lm) {
System.out.println("DB createLog===========");
}
@Override
public void updateLog(LogModel lm) {
System.out.println("DB updateLog===========");
}
@Override
public void removeLog(LogModel lm) {
}
@Override
public List getAllLog() {
return null;
}
}
缺省适配器
package cn.javass.dp.adapter.example3;
import java.util.List;
/**
* 缺省适配器：
* 需要功能重新实现的可覆盖父适配器，
* 不覆盖则为使用父类适配器功能
*
*/
public class MyAdapter extends DefaultAdapter{
/**
* 持有需要被适配的接口对象
*/
private LogFileOperateApi adaptee;
private TimeUtil adaptee2 = null;
/**
* 构造方法，传入需要被适配的对象
* @param adaptee 需要被适配的对象
*/
public MyAdapter(LogFileOperateApi adaptee,TimeUtil times) {
this.adaptee = adaptee;
this.adaptee2 = times;
}
public List getAllLog() {
return adaptee.readLogFile();
}
public void removeLog(LogModel lm) {
//1：先读取文件的内容
List list = adaptee.readLogFile();
//2：删除相应的日志对象
list.remove(lm);
//3：重新写入文件
adaptee.writeLogFile(list);
}
}
双向适配器
适配器也可以实现双向的适配，前面我们讲的都是把Adaptee适配成为
Target，其实也可以把Target适配成为Adaptee，也就是说这个适配器可以同时
当作Target和Adaptee来使用。
示例代码
双向适配器对象
package cn.javass.dp.adapter.example4;
import java.util.List;
/**
* 双向适配器对象
*/
public class TwoDirectAdapter implements LogDbOperateApi,LogFileOperateApi{
/**
* 持有需要被适配的文件存储日志的接口对象
*/
private LogFileOperateApi fileLog;
/**
* 持有需要被适配的DB存储日志的接口对象
*/
private LogDbOperateApi dbLog;
/**
* 构造方法，传入需要被适配的对象
* @param fileLog 需要被适配的文件存储日志的接口对象
* @param dbLog 需要被适配的DB存储日志的接口对象
*/
public TwoDirectAdapter(LogFileOperateApi fileLog,LogDbOperateApi dbLog) {
this.fileLog = fileLog;
this.dbLog = dbLog;
}
/*-----以下是把文件操作的方式适配成为DB实现方式的接口-----*/
public void createLog(LogModel lm) {
//1：先读取文件的内容
List list = fileLog.readLogFile();
//2：加入新的日志对象
list.add(lm);
//3：重新写入文件
fileLog.writeLogFile(list);
}
public List getAllLog() {
return fileLog.readLogFile();
}
public void removeLog(LogModel lm) {
//1：先读取文件的内容
List list = fileLog.readLogFile();
//2：删除相应的日志对象
list.remove(lm);
//3：重新写入文件
fileLog.writeLogFile(list);
}
public void updateLog(LogModel lm) {
//1：先读取文件的内容
List list = fileLog.readLogFile();
//2：修改相应的日志对象
for(int i=0;iif(list.get(i).getLogId().equals(lm.getLogId())){
list.set(i, lm);
break;
}
}
//3：重新写入文件
fileLog.writeLogFile(list);
}
public void removeAll(){
System.out.println("now in two direct remove all");
}
/*-----以下是把DB操作的方式适配成为文件实现方式的接口-----*/
public List readLogFile() {
return dbLog.getAllLog();
}
public void writeLogFile(List list) {
//1：最简单的实现思路，先删除数据库中的数据
dbLog.removeAll();
//2：然后循环把现在的数据加入到数据库中
for(LogModel lm : list){
dbLog.createLog(lm);
}
}
}
客户端
package cn.javass.dp.adapter.example4;
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 list = new ArrayList();
list.add(lm1);
//创建操作日志文件的对象
LogFileOperateApi fileLogApi = new LogFileOperate("");
LogDbOperateApi dbLogApi = new LogDbOperate();
//创建经过双向适配后的操作日志的接口对象
LogFileOperateApi fileLogApi2 = new TwoDirectAdapter(fileLogApi,dbLogApi);
LogDbOperateApi dbLogApi2 = new TwoDirectAdapter(fileLogApi,dbLogApi);
//先测试从文件操作适配到第二版，虽然调用的是第二版的接口，其实是文件操作在实现
dbLogApi2.createLog(lm1);
List allLog = dbLogApi2.getAllLog();
System.out.println("allLog555="+allLog);
//再测试从数据库存储适配成第一版的接口，也就是调用第一版的接口，其实是数据实现
System.out.println("--------------------------->File Api ");
fileLogApi2.writeLogFile(list);
fileLogApi2.readLogFile();
}
}
对象适配器和类适配器
1：对象适配器的实现：
依赖于对象组合。就如同前面的实现示例，都是采用的对象
组合的方式，也就是前面讲述的都是对象适配器实现的方式。
2：类适配器的实现：
采用多重继承对一个接口与另一个接口进行匹配。由于Java不
支持多重继承，所以到目前为止，还没有涉及到。
类适配器的结构图如下：
Java中类似实现类适配器
示例代码
类适配器对象
package cn.javass.dp.adapter.example5;
import java.util.List;
/**
* 类适配器对象
*/
public class ClassAdapter extends LogFileOperate implements LogDbOperateApi{
public ClassAdapter(String logFilePathName) {
super(logFilePathName);
}
public void createLog(LogModel lm) {
//1：先读取文件的内容
List list = this.readLogFile();
//2：加入新的日志对象
list.add(lm);
//3：重新写入文件
this.writeLogFile(list);
}
public List getAllLog() {
return this.readLogFile();
}
public void removeLog(LogModel lm) {
//1：先读取文件的内容
List list = this.readLogFile();
//2：删除相应的日志对象
list.remove(lm);
//3：重新写入文件
this.writeLogFile(list);
}
public void updateLog(LogModel lm) {
//1：先读取文件的内容
List list = this.readLogFile();
//2：修改相应的日志对象
for(int i=0;iif(list.get(i).getLogId().equals(lm.getLogId())){
list.set(i, lm);
break;
}
}
//3：重新写入文件
this.writeLogFile(list);
}
}
客户端
package cn.javass.dp.adapter.example5;
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 list = new ArrayList();
list.add(lm1);
//创建新版的操作日志的接口对象
LogDbOperateApi api = new ClassAdapter("");
//保存日志文件
api.createLog(lm1);
//读取日志文件的内容
List allLog = api.getAllLog();
System.out.println("allLog="+allLog);
}
}
思考适配器模式
类适配器和对象适配器的权衡
1：从实现上：
类适配器使用对象继承的方式，是静态的定义方式；而对象适配器使用对象组
合的方式，是动态组合的方式
2：对于类适配器：
由于适配器直接继承了Adaptee，使得适配器不能和Adaptee的子类一起工
作，因为继承是个静态的关系，当适配器继承了Adaptee过后，就不可能再去处理Adaptee
的子类了。
对于对象适配器：
允许一个Adapter和多个Adaptee，包括Adaptee和它所有的子类一
起工作。因为对象适配器采用的是对象组合的关系，只要对象类型正确，是不是子类都无
所谓。
3：对于类适配器：
适配器可以重定义Adaptee的部分行为，相当于子类覆盖父类的部分实现方
法。
对于对象适配器：
要重定义Adaptee的行为比较困难，这种情况下，需要定义
Adaptee的子类来实现重定义，然后让适配器组合子类。
4：对于类适配器：
仅仅引入了一个对象，并不需要额外的引用来间接得到Adaptee。
对于对象适配器：需要额外的引用来间接得到Adaptee。
适配器模式的优缺点
- 1：更好的复用性
- 2：更好的可扩展性
- 3：过多的使用适配器，会让系统非常零乱，不容易整体进行把握
适配器模式的本质
适配器模式的本质是：==转换匹配，复用功能==
何时选用适配器模式
1：如果你想要使用一个已经存在的类，但是它的接口不符合你的需求，这种情况可
以使用适配器模式，来把已有的实现转换成你需要的接口2：如果你想创建一个可以复用的类，这个类可能和一些不兼容的类一起工作，这种
情况可以使用适配器模式，到时候需要什么就适配什么3：如果你想使用一些已经存在的子类，但是不可能对每一个子类都进行适配，这种
情况可以选用对象适配器，直接适配这些子类的父类就可以了