设计模式练习（6）——适配器模式

适配器模式

一、题目：

某OA系统需要提供一个加密模块，将用户机密信息(如口令、邮箱等)加密之后，存储在数据库中，系统已经定义好了数据库操作类，为了提高开发效率，现需要重用已有的加密算法，这些加密算法封装在由第三方提供的类中，有些甚至没有源代码，试使用适配器模式，设计该模块，在不修改现有类的基础上，重用第三方加密算法。
现有一个接口DataOperation定义了排序算法sort(int [])，和查找方法search（int[],int），已知类QuikSort的quickSort方法实现了快速排序算法，类BinarySearch类的binarySearch（int[], int）实现了二分查找法，现使用适配器模式设计一个系统，在不修改源代码的情况下将类，将QuickSort和类BinarySearch类的方法实适配到DataOperation接口。
（1）绘制适配器模式结构视图；
（2）请绘制该实例类图，并代码实现。

二、所用模式结构视图：

三、实例类图：

四、实例实现代码：

(因为区分，所以在类的前面加了Gj19)

抽象操作类：目标接口

package AdapterPattern;
/**
 * 抽象操作类：目标接口
 * @author gong
 *
 */
public interface Gj19DataOperation {
    public int[] sort(int array[]); //排序  
    public int search(int array[],int key); //查找  
}

操作适配器：适配器

package AdapterPattern;
/**
 * 操作适配器：适配器
 * @author gong
 *
 */
public class Gj19OperationAdapter implements Gj19DataOperation {
    private Gj19QuickSort sortObj; // 定义适配者Gj19QuickSort对象
    private Gj19BinarySearch searchObj; // 定义适配者Gj19BinarySearch对象

    public Gj19OperationAdapter() {
        sortObj = new Gj19QuickSort();
        searchObj = new Gj19BinarySearch();
    }

    public int[] sort(int array[]) {
        return sortObj.quickSort(array); // 调用适配者类Gj19QuickSort的排序方法
    }

    public int search(int array[], int key) {
        return searchObj.binarySearch(array, key); // 调用适配者类Gj19BinarySearch的查找方法
    }

}

快速排序类：适配者

package AdapterPattern;
/**
 * 快速排序类：适配者 
 * @author gong
 *
 */
public class Gj19QuickSort {
    public int[] quickSort(int array[]) {  
        sort(array,0,array.length-1);  
        return array;  
    }  

    public void sort(int array[],int p, int r) {  
        int q=0;  
        if(p<r) {  
            q=partition(array,p,r);  
            sort(array,p,q-1);  
            sort(array,q+1,r);  
        }  
    }  

    public int partition(int[] a, int p, int r) {  
        int x=a[r];  
        int j=p-1;  
        for (int i=p;i<=r-1;i++) {  
            if (a[i]<=x) {  
                j++;  
                swap(a,j,i);  
            }  
        }  
        swap(a,j+1,r);  
        return j+1;   
    }  

    public void swap(int[] a, int i, int j) {     
        int t = a[i];     
        a[i] = a[j];     
        a[j] = t;     
    }  
}

二分查找类：适配者

package AdapterPattern;
/**
 * 二分查找类：适配者
 * @author gong
 *
 */
public class Gj19BinarySearch {
    public int binarySearch(int array[], int key) {
        int low = 0;
        int high = array.length - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            int midVal = array[mid];
            if (midVal < key) {
                low = mid + 1;
            } else if (midVal > key) {
                high = mid - 1;
            } else {
                return 1; // 找到元素返回1
            }
        }
        return -1; // 未找到元素返回-1
    }
}

为了让系统具备良好的灵活性和可扩展性，我引入了工具类XMLUtil和配置文件

package AdapterPattern;

/**
 * 为了让系统具备良好的灵活性和可扩展性，我引入了工具类XMLUtil和配置文件
 * @author gong
 */
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class Gj19XMLUtil {
    //该方法用于从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;  
        }  
    }  
}

XML配置文件

<?xml version="1.0" ?>
<config>  
    <className>AdapterPattern.Gj19OperationAdapter</className>  
</config> 

客户端测试类

package AdapterPattern;
/**
 * 客户端测试类
 * @author gong
 *
 */
public class Gj19Client {
    public static void main(String args[]) {  
        Gj19DataOperation gj19Dataoperation;  //针对抽象目标接口编程  
        gj19Dataoperation = (Gj19DataOperation)Gj19XMLUtil.getBean(); //读取配置文件，反射生成对象
        int scores[] = {42,78,87,69,90,96,88,76}; //定义成绩数组  
        int result[];  
        int score;  

        System.out.println("排序结果：");  
        result = gj19Dataoperation.sort(scores);  
        //遍历输出成绩  
        for(int i : scores) {  
            System.out.print(i + ",");  
        }  
        System.out.println();  

        System.out.println("查找88：");  
        score = gj19Dataoperation.search(result,90);  
        if (score != -1) {  
            System.out.println("找到88。");  
        }  
        else {  
            System.out.println("没有找到96。");  
        }  

        System.out.println("查找96：");  
        score = gj19Dataoperation.search(result,92);  
        if (score != -1) {  
            System.out.println("找到96。");  
        }  
        else {  
            System.out.println("没有找到96。");  
        }  
    }  

}

五、运行结果：