適配器模式

結構型模式概述

    結構型模式(Structural Pattern)描述如何將類或者對象結合在一起形成更大的結構，就像搭積木，可以通過簡單積木的組合形成復雜的、功能更為強大的結構。

    結構型模式可以分為 類結構型模式和 對象結構型模式：

        •  類結構型模式關心類的組合，由多個類可以組合成一個更大的系統，在類結構型模式中一般只存在繼承關系和實現關系。

        •  對象結構型模式關心類與對象的組合，通過關聯關系使得在一個類中定義另一個類的實例對象，然后通過該對象調用其方法。根據“合成復用原則”，在系統中盡量使用關聯關系來替代繼承關系，因此大部分結構型模式都是對象結構型模式。

模式動機

    在軟件開發中采用類似於電源適配器的設計和編碼技巧被稱為適配器模式。

    通常情況下，客戶端可以通過目標類的接口訪問它所提供的服務。有時，現有的類可以滿足客戶類的功能需要，但是它所提供的接口不一定是客戶類所期望的，這可能是因為現有類中方法名與目標類中定義的方法名不一致等原因所導致的。在這種情況下，現有的接口需要轉化為客戶類期望的接口，這樣保證了對現有類的重用。如果不進行這樣的轉化，客戶類就不能利用現有類所提供的功能，適配器模式可以完成這樣的轉化。

    在適配器模式中可以定義一個包裝類，包裝不兼容接口的對象，這個包裝類指的就是適配器(Adapter)，它所包裝的對象就是適配者(Adaptee)，即被適配的類。

    適配器提供客戶類需要的接口，適配器的實現就是把客戶類的請求轉化為對適配者的相應接口的調用。也就是說：當客戶類調用適配器的方法時，在適配器類的內部將調用適配者類的方法，而這個過程對客戶類是透明的，客戶類並不直接訪問適配者類。因此，適配器可以使由於接口不兼容而不能交互的類可以一起工作。這就是適配器模式的模式動機。

模式定義

適配器模式(Adapter Pattern)  ：將一個接口轉換成客戶希望的另一個接口，適配器模式使接口不兼容的那些類可以一起工作，其別名為包裝器(Wrapper)。適配器模式既可以作為類結構型模式，也可以作為對象結構型模式。

模式結構

類適配器

 

對象適配器

 

適配器模式包含如下角色：

    •  Target：目標抽象類

    •  Adapter：適配器類

    •  Adaptee：適配者類

    •  Client：客戶類

模式分析

典型的類適配器代碼：

 

public class Adapter extends Adaptee implements Target
{
    public void request()
    {
        specificRequest();
    }
}

 典型的對象適配器代碼：

 

public class Adapter extends Target
{
    private Adaptee adaptee;
    
    public Adapter(Adaptee adaptee)
    {
        this.adaptee=adaptee;
    }
    
    public void request()
    {
        adaptee.specificRequest();
    }
} 

 

適配器模式實例與解析

實例一：仿生機器人

    • 現需要設計一個可以模擬各種動物行為的機器人，在機器人中定義了一系列方法，如機器人叫喊方法cry()、機器人移動方法move()等。如果希望在不修改已有代碼的基礎上使得機器人能夠像狗一樣叫，像狗一樣跑，使用適配器模式進行系統設計。

 

實例代碼(JAVA)：

 

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

public class Bird
{
    public void tweedle()
    {
        System.out.println("鳥兒嘰嘰叫！");
    }
    
    public void fly()
    {
        System.out.println("鳥兒快快飛！");
    }
}

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

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

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

//配置文件config.xml
<?xml version="1.0"?>
<config>
    <className>BirdAdapter</className>
</config>

//通過反射得到具體的適配器類
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;
               }
        }
}

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

 

實例二：加密適配器

    • 某系統需要提供一個加密模塊，將用戶信息（如密碼等機密信息）加密之后再存儲在數據庫中，系統已經定義好了數據庫操作類。為了提高開發效率，現需要重用已有的加密算法，這些算法封裝在一些由第三方提供的類中，有些甚至沒有源代碼。使用適配器模式設計該加密模塊，實現在不修改現有類的基礎上重用第三方加密方法。

實例代碼(JAVA)：

 

//目標抽象類
public abstract class DataOperation
{
    private String password;
    
    public void setPassword(String password)
    {
        this.password=password;
    }
        
    public String getPassword()
    {
        return this.password;
    }
    
    public abstract String doEncrypt(int key,String ps);
}

//適配者類
public final class Caesar 
{
    public String doEncrypt(int key,String ps)
    {   
        String es="";
        for(int i=0;i<ps.length();i++)
        {
            char c=ps.charAt(i);
            if(c>='a'&&c<='z')
            {
                c+=key%26;
            if(c>'z') c-=26;
            if(c<'a') c+=26;
            }
            if(c>='A'&&c<='Z')
            {
                c+=key%26;
            if(c>'Z') c-=26;
            if(c<'A') c+=26;
            }
            es+=c;
        }
        return es;
    }
}

//適配器類
public class CipherAdapter extends DataOperation
{
    private Caesar cipher;
    
    public CipherAdapter()
    {
        cipher=new Caesar();
    }
    
    public String doEncrypt(int key,String ps)
    {
        return cipher.doEncrypt(key,ps);
    }
}

//新適配者類
public final class NewCipher
{
    public String doEncrypt(int key,String ps)
    { 
        String es="";
        for(int i=0;i<ps.length();i++)
        {
            String c=String.valueOf(ps.charAt(i)%key);
            es+=c;
        }
        return es;
    }
}

//新適配器類
public class NewCipherAdapter extends DataOperation
{
    private NewCipher cipher;
    
    public NewCipherAdapter()
    {
        cipher=new NewCipher();
    }
    
    public String doEncrypt(int key,String ps)
    {
        return cipher.doEncrypt(key,ps);
    }
}

//配置文件 config.xml
<?xml version="1.0"?>
<config>
    <className>NewCipherAdapter</className>
</config>

//使用JAVA反射得到配置文件中的適配器類實例
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;
               }
        }
}

//客戶端
public class Client
{
    public static void main(String args[])
    {
        DataOperation dao=(DataOperation)XMLUtil.getBean();
        dao.setPassword("sunnyLiu");
        String ps=dao.getPassword();
        String es=dao.doEncrypt(6,ps);
        System.out.println("明文為：" + ps);
        System.out.println("密文為：" + es);
    }
}

 

模式優缺點

優點

    • 將目標類和適配者類解耦，通過引入一個適配器類來重用現有的適配者類，而無須修改原有代碼。

    • 增加了類的透明性和復用性，將具體的實現封裝在適配者類中，對於客戶端類來說是透明的，而且提高了適配者的復用性。

    • 靈活性和擴展性都非常好，通過使用配置文件，可以很方便地更換適配器，也可以在不修改原有代碼的基礎上增加新的適配器類，完全符合“開閉原則”。

    • 由於適配器類是適配者類的子類，因此可以在適配器類中置換一些適配者的方法，使得適配器的靈活性更強。

缺點

    • 對於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三種通知類型借助適配器模式來實現。

 

public interface AdvisorAdapter{ 
 //將一個Advisor適配成MethodInterceptor 
 MethodInterceptor getInterceptor(Advisor advisor); 
 //判斷此適配器是否支持特定的Advice 
 boolean supportsAdvice(Advice advice); 
}

     (3)在JDK類庫中也定義了一系列適配器類，如在com.sun.imageio.plugins.common包中定義的InputStreamAdapter類，用於包裝ImageInputStream接口及其子類對象。

 

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);
    }
} 

 

模式擴展

默認適配器模式(Default Adapter Pattern)或缺省適配器模式

     • 當不需要全部實現接口提供的方法時，可先設計一個抽象類實現接口，並為該接口中每個方法提供一個默認實現（空方法），那么該抽象類的子類可有選擇地覆蓋父類的某些方法來實現需求，它適用於一個接口不想使用其所有的方法的情況。因此也稱為單接口適配器模式。

 

雙向適配器

    • 在對象適配器的使用過程中，如果在適配器中同時包含對目標類和適配者類的引用，適配者可以通過它調用目標類中的方法，目標類也可以通過它調用適配者類中的方法，那么該適配器就是一個雙向適配器。