设计模式之适配器模式

最新推荐文章于 2022-10-16 15:35:57 发布

sells2012

最新推荐文章于 2022-10-16 15:35:57 发布

阅读量624

点赞数

分类专栏： Java 设计模式

Java 同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

设计模式

7 篇文章 0 订阅

订阅专栏

本文转载自snowball的博客，看完他的博客，发现自己写的博客弱爆了，他的博客地址

一、适配器模式的内容

适配器模式将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。

二、结构型模式可以分为类结构型模式和对象结构型模式

类结构型模式关心类的组合，由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承关系和实现关系。（继承）
对象结构型模式关心类与对象的组合，通过关联关系使得在一个类中定义另一个类的实例对象，然后通过该对象调用其方法。根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系，因此大部分结构型模式都是对象结构型模式。（组合）

三、名称由来

这很像变压器（Adapter），变压器把一种电压变换成另一种电压。美国的生活用电电压是110V，而中国的电压是220V。如果要在中国使用美国电器，就必须有一个能把220V电压转换成110V电压的变压器。这个变压器就是一个Adapter。

Adapter模式也很像货物的包装过程：被包装的货物的真实样子被包装所掩盖和改变，因此有人把这种模式叫做包装（Wrapper）模式。事实上，大家经常写很多这样的Wrapper类，把已有的一些类包装起来，使之有能满足需要的接口。

四、适配器结构

4.1 类适配器

由图中可以看出，Adaptee类没有Request方法，而客户期待这个方法。为了使客户能够使用Adaptee类，提供一个中间环节，即类Adapter类，Adapter类实现了Target接口，并继承自Adaptee，Adapter类的Request方法重新封装了Adaptee的SpecificRequest方法，实现了适配的目的。

因为Adapter与Adaptee是继承的关系，所以这决定了这个适配器模式是类的。

该适配器模式所涉及的角色包括：

目标（Target）角色：这是客户所期待的接口。因为Java不支持多继承，所以Target必须是接口，不可以是类。
源（Adaptee）角色：需要适配的类。
适配器（Adapter）角色：把源接口转换成目标接口。这一角色必须是类。

4.2 对象适配器

从图中可以看出：客户端需要调用Request方法，而Adaptee没有该方法，为了使客户端能够使用Adaptee类，需要提供一个包装（Wrapper）类Adapter。这个包装类包装了一个Adaptee的实例，从而将客户端与Adaptee衔接起来。由于Adapter与Adaptee是委派关系，这决定了这个适配器模式是对象的。

该适配器模式所涉及的角色包括：

目标（Target）角色：这是客户所期待的接口。目标可以是具体的或抽象的类，也可以是接口。
源（Adaptee）角色：需要适配的类。
适配器（Adapter）角色：通过在内部包装（Wrap）一个Adaptee对象，把源接口转换成目标接口。

五、适配器模式示例代码

5.1 类适配器模式

目标角色

[java] view plain copy

public interface Robot
{
public void cry();
public void move();
}

源角色

[java] view plain copy

public class Dog
{
public void wang()
{
System.out.println("狗汪汪叫！");
}
public void run()
{
System.out.println("狗快快跑！");
}
}

[java] view plain copy

public class Bird
{
public void tweedle()
{
System.out.println("鸟儿叽叽叫！");
}
public void fly()
{
System.out.println("鸟儿快快飞！");
}
}

适配器

[java] view plain copy

public class DogAdapter extends Dog implements Robot
{
public void cry()
{
System.out.print("机器人模仿：");
super.wang();
}
public void move()
{
System.out.print("机器人模仿：");
super.run();
}
}

[java] view plain copy

public class BirdAdapter extends Bird implements Robot
{
public void cry()
{
System.out.print("机器人模仿：");
super.tweedle();
}
public void move()
{
System.out.print("机器人模仿：");
super.fly();
}
}

测试

[html] view plain copy

<?xml version="1.0"?>
<config>
<className>BirdAdapter</className>
</config>

[java] view plain copy

import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
public class XMLUtil
{
//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
public static Object getBean()
{
try
{
//创建文档对象
DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dFactory.newDocumentBuilder();
Document doc;
doc = builder.parse(new File("config.xml"));
//获取包含类名的文本节点
NodeList nl = doc.getElementsByTagName("className");
Node classNode=nl.item(0).getFirstChild();
String cName=classNode.getNodeValue();
//通过类名生成实例对象并将其返回
Class c=Class.forName(cName);
Object obj=c.newInstance();
return obj;
}
catch(Exception e)
{
e.printStackTrace();
return null;
}
}
}

[java] view plain copy

public class Client
{
public static void main(String args[])
{
Robot robot=(Robot)XMLUtil.getBean();
robot.cry();
robot.move();
}
}

5.2 对象适配器

目标角色

[java] view plain copy

public interface Duck {
public void quack();
public void fly();
}

源角色

[java] view plain copy

public interface Turkey {
public void gobble();
public void fly();
}

[java] view plain copy

public class WildTurkey implements Turkey {
public void gobble() {
System.out.println("Gobble gobble");
}
public void fly() {
System.out.println("I'm flying a short distance");
}
}

适配器

[java] view plain copy

public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
public void quack() {
turkey.gobble();
}
public void fly() {
for(int i=0; i < 5; i++) {
turkey.fly();
}
}
}

测试

[java] view plain copy

public class DuckTestDrive {
public static void main(String[] args) {
MallardDuck duck = new MallardDuck();
WildTurkey turkey = new WildTurkey();
Duck turkeyAdapter = new TurkeyAdapter(turkey);
System.out.println("The Turkey says...");
turkey.gobble();
turkey.fly();
System.out.println("\nThe Duck says...");
testDuck(duck);
System.out.println("\nThe TurkeyAdapter says...");
testDuck(turkeyAdapter);
}
static void testDuck(Duck duck) {
duck.quack();
duck.fly();
}
}

六、适配器模式扩展

默认适配器模式(Default Adapter Pattern)或缺省适配器模式

当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求，它适用于一个接口不想使用其所有的方法的情况。因此也称为单接口适配器模式。

双向适配器

在对象适配器的使用过程中，如果在适配器中同时包含对目标类和适配者类的引用，适配者可以通过它调用目标类中的方法，目标类也可以通过它调用适配者类中的方法，那么该适配器就是一个双向适配器。

七、适配器优缺点

适配器模式的优点

将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，而无须修改原有代码。
增加了类的透明性和复用性，将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性。
灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。

类适配器模式还具有如下优点：

由于适配器类是适配者类的子类，因此可以在适配器类中置换一些适配者的方法，使得适配器的灵活性更强。

类适配器模式的缺点如下：

对于Java、C#等不支持多重继承的语言，一次最多只能适配一个适配者类，而且目标抽象类只能为抽象类，不能为具体类，其使用有一定的局限性，不能将一个适配者类和它的子类都适配到目标接口。

对象适配器模式还具有如下优点：

一个对象适配器可以把多个不同的适配者适配到同一个目标，也就是说，同一个适配器可以把适配者类和它的子类都适配到目标接口。

对象适配器模式的缺点如下：

与类适配器模式相比，要想置换适配者类的方法就不容易。如果一定要置换掉适配者类的一个或多个方法，就只好先做一个适配者类的子类，将适配者类的方法置换掉，然后再把适配者类的子类当做真正的适配者进行适配，实现过程较为复杂。

八、适配器的适用环境

在以下情况下可以使用适配器模式：

系统需要使用现有的类，而这些类的接口不符合系统的需要。
想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。

九、适配器应用

(1) Sun公司在1996年公开了Java语言的数据库连接工具JDBC，JDBC使得Java语言程序能够与数据库连接，并使用SQL语言来查询和操作数据。JDBC给出一个客户端通用的抽象接口，每一个具体数据库引擎（如SQL Server、Oracle、MySQL等）的JDBC驱动软件都是一个介于JDBC接口和数据库引擎接口之间的适配器软件。抽象的JDBC接口和各个数据库引擎API之间都需要相应的适配器软件，这就是为各个不同数据库引擎准备的驱动程序。

(2)在Spring AOP框架中，对BeforeAdvice、AfterAdvice、ThrowsAdvice三种通知类型借助适配器模式来实现。

[java] view plain copy

public interface AdvisorAdapter{
//将一个Advisor适配成MethodInterceptor
MethodInterceptor getInterceptor(Advisor advisor);
//判断此适配器是否支持特定的Advice
boolean supportsAdvice(Advice advice);
}

(3)在JDK类库中也定义了一系列适配器类，如在com.sun.imageio.plugins.common包中定义的InputStreamAdapter类，用于包装ImageInputStream接口及其子类对象。

[java] view plain copy

public class InputStreamAdapter extends InputStream {
ImageInputStream stream;
public InputStreamAdapter(ImageInputStream stream) {
super();
this.stream = stream;
}
public int read() throws IOException {
return stream.read();
}
public int read(byte b[], int off, int len) throws IOException {
return stream.read(b, off, len);
}
}

Adapter ^{_{(recognizeable by creational methods taking an instance of different abstract/interface type and returning an implementation of own/another abstract/interface type which decorates/overrides the given instance)}}

java.io.InputStreamReader(InputStream) (returns a Reader)
java.io.OutputStreamWriter(OutputStream) (returns a Writer)
javax.xml.bind.annotation.adapters.XmlAdapter#marshal() and #unmarshal()

十、参考文献

http://blog.csdn.net/rocket5725/article/details/4297957
http://stackoverflow.com/questions/1673841/examples-of-gof-design-patterns
《Head First 设计模式》
《设计模式》刘伟主编清华大学出版社

sells2012

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式之适配器模式

本文转载自snowball的博客，看完他的博客，发现自己写的博客弱爆了，他的博客地址一、适配器模式的内容适配器模式将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。二、结构型模式可以分为类结构型模式和对象结构型模式类结构型模式关心类的组合，由多
复制链接

扫一扫