适配器模式（一）

转载请注明原文链接，http://www.cnblogs.com/flyingcloude/p/6992360.html

模式的功能：

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

　　但这并不是说，在适配器里面就不能实现功能，适配器里面可以实现功能，称这种适配器为智能适配器。

[java] view plain copy

  1. package adapter_2;
  2. import java.io.Serializable;
  3. /*
  4. ** @author: flyingcloude
  5. ** @version 2012-1-30 下午2:25:10
  6. **
  7. */
  8. public class LogModel implements Serializable
  9. {
  10. private static final long serialVersionUID = 1L;
  11. /*日志编号*/
  12. private String logId;
  13. /*操作人员*/
  14. private String operateUser;
  15. /*操作时间,以yyyy-mm-dd hh:mm:ss的格式记录*/
  16. private String operateTime;
  17. /*日志内容*/
  18. private String logContent;
  19. public String getLogId()
  20. {
  21. return logId;
  22. }
  23. public void setLogId(String logId)
  24. {
  25. this.logId = logId;
  26. }
  27. public String getOperateUser()
  28. {
  29. return operateUser;
  30. }
  31. public void setOperateUser(String operateUser)
  32. {
  33. this.operateUser = operateUser;
  34. }
  35. public String getOperateTime()
  36. {
  37. return operateTime;
  38. }
  39. public void setOperateTime(String operateTime)
  40. {
  41. this.operateTime = operateTime;
  42. }
  43. public String getLogContent()
  44. {
  45. return logContent;
  46. }
  47. public void setLogContent(String logContent)
  48. {
  49. this.logContent = logContent;
  50. }
  51. public String toString()
  52. {
  53. return "logId=" + logId + ",operateUser= " + operateUser
  54. +",operateTime=" + operateTime+",logContent=" + logContent;
  55. }
  56. }

[java] view plain copy

  1. package adapter_2;
  2. import java.util.List;
  3. /*
  4. ** @author: flyingcloude
  5. ** @version 2012-1-30 下午2:51:32
  6. **
  7. */
  8. public interface LogFileOperateApi
  9. {
  10. /*
  11. *读取日志文件，从文件里面获取存储的日志列表对象
  12. *@return 存储的日志列表对象
  13. */
  14. public List<LogModel> readLogFile();
  15. /*
  16. *写日志文件，把日志列表写出到日志文件中去
  17. *@param list要写到日志文件的日志列表
  18. */
  19. public void writeLogFile(List<LogModel> list);
  20. }

[java] view plain copy

  1. package adapter_2;
  2. import java.io.BufferedInputStream;
  3. import java.io.BufferedOutputStream;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  8. import java.io.ObjectInputStream;
  9. import java.io.ObjectOutputStream;
  10. import java.util.List;
  11. /*
  12. ** @author: flyingcloude
  13. ** @version 2012-1-30 下午2:56:45
  14. **
  15. */
  16. public class LogFileOperate implements LogFileOperateApi{
  17. /*
  18. * 日志文件的路径和文件名称，默认是当前项目根下的AdapterLog.log
  19. */
  20. public String logFilePathName = "AdapterLog.log";
  21. /*
  22. *构造方法，传人文件的路径和名称
  23. *@param logFilePathName文件的路径和名称
  24. */
  25. public LogFileOperate(String logFilePathName)
  26. {
  27. //先判断是否传人了文件的路径和名称，如果是
  28. //就重新设置操作的日志文件的路径和名称
  29. if(logFilePathName != null && logFilePathName.trim().length() > 0)
  30. {
  31. this.logFilePathName = logFilePathName;
  32. }
  33. }
  34. public List<LogModel> readLogFile() {
  35. List<LogModel> list = null;
  36. ObjectInputStream oin = null;
  37. try{
  38. File f = new File(logFilePathName);
  39. if(f.exists())
  40. {
  41. oin = new ObjectInputStream(new BufferedInputStream(new FileInputStream(f)));
  42. list = (List<LogModel>)oin.readObject();
  43. }
  44. }catch(Exception e)
  45. {
  46. e.printStackTrace();
  47. }
  48. finally{
  49. try{
  50. if(oin != null){
  51. oin.close();
  52. }
  53. }catch(IOException e)
  54. {
  55. e.printStackTrace();
  56. }
  57. }
  58. return list;
  59. }
  60. public void writeLogFile(List<LogModel> list) {
  61. File f = new File(logFilePathName);
  62. ObjectOutputStream oout = null;
  63. try{
  64. oout = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(f)));
  65. oout.writeObject(list);
  66. }catch(IOException e){
  67. e.printStackTrace();
  68. }finally{
  69. try{
  70. oout.close();
  71. }catch(IOException e){
  72. e.printStackTrace();
  73. }
  74. }
  75. }
  76. }

[java] view plain copy

  1. package adapter_2;
  2. import java.util.List;
  3. /*
  4. ** @author: flyingcloude
  5. ** @version 2012-1-31 上午8:58:56
  6. **
  7. */
  8. public interface LogDbOperateApi
  9. {
  10. /*
  11. * 新增日志
  12. * @param lm 需要新增的日志对象
  13. */
  14. public void createLog(LogModel lm);
  15. /*
  16. * 修改日志
  17. * @param lm 需要修改的日志对象
  18. */
  19. public void updateLog(LogModel lm);
  20. /*
  21. * 删除日志
  22. * @param lm 需要删除的日志对象
  23. */
  24. public void removeLog(LogModel lm);
  25. /*
  26. * 获取所有的日志
  27. * @return 所有的日志对象
  28. */
  29. public List<LogModel> getAllLog();
  30. }

[java] view plain copy

  1. package adapter_2;
  2. import java.util.List;
  3. /*
  4. ** @author: flyingcloude
  5. ** @version 2012-1-31 上午9:10:44
  6. **
  7. */
  8. public class Adapter implements LogDbOperateApi
  9. {
  10. /*
  11. * 持有需要被适配的接口对象
  12. */
  13. private LogFileOperateApi adaptee;
  14. /*
  15. * 构造方法，传人需要被适配的对象
  16. * @param adaptee 需要被适配的对象
  17. */
  18. public Adapter(LogFileOperateApi adaptee)
  19. {
  20. this.adaptee = adaptee;
  21. }
  22. public void createLog(LogModel lm) {
  23. //先读取文件的内容
  24. List<LogModel> list = adaptee.readLogFile();
  25. //加入新的日志对象
  26. list.add(lm);
  27. //重新写入文件
  28. adaptee.writeLogFile(list);
  29. }
  30. public void updateLog(LogModel lm) {
  31. //先读取文件的内容
  32. List<LogModel> list = adaptee.readLogFile();
  33. //修改相应的日志对象
  34. for(int i = 0; i < list.size(); i++)
  35. {
  36. if(list.get(i).getLogId().equals(lm.getLogId()))
  37. {
  38. list.set(i, lm);
  39. break;
  40. }
  41. }
  42. //重新写入文件
  43. adaptee.writeLogFile(list);
  44. }
  45. public void removeLog(LogModel lm) {
  46. //先读取文件的内容
  47. List<LogModel> list = adaptee.readLogFile();
  48. //删除相应的日志对象
  49. list.remove(lm);
  50. //重新写入文件
  51. adaptee.writeLogFile(list);
  52. }
  53. public List<LogModel> getAllLog() {
  54. return adaptee.readLogFile();
  55. }
  56. }

[java] view plain copy

  1. package adapter_2;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. /*
  5. ** @author: flyingcloude
  6. ** @version 2012-1-30 下午4:19:01
  7. **
  8. */
  9. public class Client{
  10. /**
  11. * @param args
  12. */
  13. public static void main(String[] args) {
  14. //准备日志内容，也就是测试的数据
  15. LogModel lml = new LogModel();
  16. lml.setLogId("001");
  17. lml.setOperateUser("admin");
  18. lml.setOperateTime("2010-03-02 10:08:18");
  19. lml.setLogContent("这是一个测试");
  20. List<LogModel> list = new ArrayList<LogModel>();
  21. list.add(lml);
  22. //创建操作日志文件的对象
  23. LogFileOperateApi logFileApi = new LogFileOperate("log");
  24. //创建新版操作日志的接口对象
  25. LogDbOperateApi api = new Adapter(logFileApi);
  26. //保存日志文件
  27. api.createLog(lml);
  28. //读取日志文件的内容
  29. List<LogModel> allLog = api.getAllLog();
  30. System.out.println("allLog=" + allLog);
  31. }
  32. }

上述代码中，LogModel.Java,LogFileOperateApi.java,LogFileOperate.java是在日志管理软件中就实现了的，但是随着应用的深入，需要增加日志新增、日志修改、日志删除、读取所有日志的功能，可是又不想抛弃LogFileOperateApi.java、LogFileOperate.java的实现，故采用了适配器模式，将LogFileOperateApi.java、LogFileOperate.java中进行转换。

转载请注明原文链接，http://www.cnblogs.com/flyingcloude/p/6992360.html

时间： 2024-10-13 22:53:02

适配器模式（一）的相关文章

Happy 设计模式之适配器模式（JAVA）

设计模式-适配器模式 适配器模式定义 适配器模式,将一个类的的接口转换成客户或者产品希望的接口形式,就是原本不兼容或者甚至不相干的接口不能一起工作的接口一起工作,完成需求或者客户的需求. 适配器模式的使用场景 1.当你使用一个已经存在的类,而他的接口不符合你的需求. 2.你想要创建一个复用的类,该类可以与其相关的类或者不可见的类协同工作. 适配器角色 Target:目标接口 TargetImpl:目标实现类 Adapter:适配器 Adaptee:被适配者 代码解析: package com.d

Javascript设计模式理论与实战：适配器模式

有的时候在开发过程中,我们会发现,客户端需要的接口和提供的接口发生不兼容的问题.由于特殊的原因我们无法修改客户端接口.在这种情况下,我们需要适配现有接口和不兼容的类,这就要提到适配器模式.通过适配器,我们可以在不用修改旧代码的情况下也能使用它们,这就是适配器的能力. 基本理论 适配器模式:将一个接口转换成客户端需要的接口而不需要去修改客户端代码,使得不兼容的代码可以一起工作. 适配器主要有3个角色组成:(1)客户端:调用接口的类(2)适配器:用来连接客户端接口和提供服务的接口的类(3)适配者:提

适配器模式开发

Adapter模式也叫适配器模式,是构造型模式之一,通过Adapter模式可以改变已有类(或外部类)的接口形式. 在大规模的系统开发过程中,我们常常碰到诸如以下这些情况:我们需要实现某些功能,这些功能已有还不太成熟的一个或多个外部组件, 如果我们自己重新开发这些功能会花费大量时间:所以很多情况下会选择先暂时使用外部组件, 以后再考虑随时替换.避免代码大面积修改Adapter模式就是针对这种类似需求而提出来的.Adapter模式通过定义一个新的接口(对要实现功能加以抽象),和一个实现该接口的Ada

7 结构型模式-----适配器模式

模式动机:有时软件复用的一个难题就是接口的不兼容性,适配器的职责就是为客户提供兼容的适配者接口,使得客户只需访问一类接口就可以调用合适的适配者,而其中的适配细节则有适配器来完成. 模式定义(Adapter Pattern):将一个接口转换为用户期望的接口,使得那些接口不兼容的类可以一起工作. 模式结构图: 模式代码: bt_适配器模式.h: 1 #ifndef AP_H 2 #define AP_H 3 #include <iostream> 4 5 using namespace std;

适配器模式（Adapter）

1.定义: 适配器模式是将一个类的接口转换成客户端希望的另一个接口,适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作. 结构与说明: Client:客户端,调用自己需要的领域接口Target. Target:定义客户端需要的跟特定领域相关的接口. Adaptee:已经存在的接口,但与客户端需要的特定领域接口不一致,需要被适配. Adapter:适配器,把Adaptee适配成Client需要的Target. 2.代码示例 (1)已经存在的应用接口,需要被适配的类Adaptee 1

设计模式【适配器模式】

适配器模式的核心思想:把原有的接口转换成调用者所期望的接口,从而使不同接口的类可以一起工作. 在此,需要介绍适配器中包含的3个角色: ■源角色Adaptee:需要适配的目标或接口. ■目标角色Target:所期望得到的接口. ■适配器角色Adapter:适配类是本模式的核心,用来把源接口转换成目标接口,显然这三者的相互关系组成了适配器模式的原型. [转载使用,请注明出处:http://blog.csdn.net/mahoking] 适配器模式也叫做包装器模式(Wrapper),根据适配器对象的不

Java模式(适配器模式)

今天看了下Java中的适配器模式,下面就来小做下总结和谈谈感想,以便日后使用. 首先,先来先讲讲适配器.适配就是由“源”到“目标”的适配,而其中链接两者的关系就是适配器.它负责把“源”过度到“目标”.举个简单的样例,比方有一个“源”是一个对象人,他拥有2种技能各自是说日语和说英语,而某个岗位(目标)须要你同一时候回说日语.英语.和法语,好了,如今我们的任务就是要将人这个“源”适配的这个岗位中,怎样适配呢?显而易见地我们须要为人加入一个说法语的方法,这样才干满足目标的须要. 接着讨论怎样加说法语这

【结构型模式】《大话设计模式》——读后感 （12）在NBA我需要翻译？——适配器模式

适配器模式:将一个类的接口转换成客户希望的另外一个接口,Adapter模式使得原本由于接口不兼容而不能在一起工作的 那些类可以在一起工作了[DP] UML类图: 简单模拟一下代码: //已存在的.具有特殊功能.但不符合我们既有的标准接口的类 package com.sjmx.adapter; //已存在的.具有特殊功能.但不符合我们既有的标准接口的类 public class Adaptee { public void specificRequest() { System.out.println

设计模式之四：适配器模式(Adapter Pattern)

在软件系统中,由于应用环境的变化,常常需要将"一些现存的对象"放在新的环境中应用,但是新环境要求的接口是这些现存对象所不满足的.如果能既能利用现有对象的良好实现,同时又能满足新的应用环境所要求的接口?这就是适配器模式要解决的问题. 目的:将一个类的接口转换成客户希望的另外一个接口.Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作. 下面以日志记录程序为例子说明Adapter模式.假设我们在软件开发中要记录日志,包括数据库记录日志DatabaseLog和文本文件

设计模式之适配器模式与外观模式

适配器模式将一个类的接口,转换成客户期望的另一个接口.适配器让原本接口不兼容的类可以合作无间. 例子:火鸡变鸭子. 先定义一个鸭子接口. package cn.sp.test06; /** * 鸭子 * @author 2YSP * */ public interface Duck { //具备呱呱叫 和 飞行的能力 public void quack(); public void fly(); } package cn.sp.test06; /** * 绿头鸭是鸭子的子类 * @author