java数据库数据源框架原理--装饰模式和适配器模式

在编程当中有很多的设计模式，这些设计模式对于我们代码的可维护性，高内聚低耦合有很大的帮助。在java的数据库操作当中就使用了装饰模式和适配器模式。

1，装饰模式

在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。简单理解就是把一个对象包装起来，成为一个对象，从而可以对这个对象添加功能或者修改功能。

在连接数据库时，平凡的对数据库进行打开关闭很耗费性能。所有就需要有一个连接池来对数据库进行访问。所有的语句通过连接池的提供的连接器进行连接。所以需要创建自己的连接池，但是需要对连接池进行封装。如下对一个sql的connection接口进行包装。因为连接数据库就必须实现Connection这个接口。当然这个接口的实现是各大数据库厂商的事情，我们在使用的时候是多态方式。

import java.sql.*;
import java.util.LinkedList;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;

/**
 * Created by yanglin on 2016/10/29.
 */
//1、编写一个类，实现与被包装类相同的接口。（具备相同的行为）
//2、定义一个被包装类类型的变量。

public class MyConnection implements Connection {

    private Connection con = null;
    private LinkedList<Connection> pool;//连接池对象
    //3、定义构造方法，把被包装类的对象注入，给被包装类变量赋值。
    public MyConnection(Connection con,LinkedList<Connection> pool) {
        this.con = con;
        this.pool = pool;
    }
    public void close() throws SQLException {
        //修改关闭方法，不关闭添加到连接池当中
        //5、对于需要改写的方法，写自己的代码
        pool.addLast(con);
    }
    public Statement createStatement() throws SQLException {
        //4、对于不需要改写的方法，调用原有的方法。
        //不需要编写的代码，直接调用被包装的对象完成
        return con.createStatement();
    }

    public PreparedStatement prepareStatement(String sql) throws SQLException {
        return con.prepareStatement(sql);
    }

首先实现Connection这个接口，然后创建一个这个接口的引用来接受实现了这个接口的对象。这样就相当于把Connetcion接口的实现的对象进行了包装。在我们不需要改写的代码当中，直接调用构造函数传进来的对象的相同方法完成操作。而对于我们需要改写的方法，就直接修改即可。

---

在sun也提供了连接池的接口，任何一个数据库厂商都需要有一个这个连接池的实现类。使用其中的getConnection()方法来调用连接池当中的Connection对象。这样就提高了程序的可维护性。在这里，我们就调用我们创建的Connetion，因为我们创建的Connection对象重写了关闭的方法。

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.Collections;
import java.util.LinkedList;
import java.util.logging.Logger;

/**
 * Created by yanglin on 2016/10/29.
 */
//DataSource连接池，sun提供的连接池的接口
public class MyDataSource implements DataSource {
    //创建一个存放连接的池子
    private static LinkedList<Connection> pool = (LinkedList<Connection>) Collections.synchronizedList(new LinkedList<Connection>());

    static{
        try {
            for (int i = 0; i < 10; i++) {
                Connection conn = DBUtils.getConnection();
                pool.add(conn);
            }
        } catch (Exception e) {
            throw new ExceptionInInitializerError("初始化数据库连接失败");
        }
    }
    public Connection getConnection() throws SQLException {
        Connection conn = null;
        if(pool.size()>0){
            conn =  pool.removeFirst();//从池中取出一个连接
            MyConnection myConn = new MyConnection(conn,pool);//得到一个包装后的MyConnection对象
            return myConn;
        }else{
            //等待
            //新创建一个连接
            throw new RuntimeException("服务器忙。。。");
        }
    }

    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

在静态块当中，我们创建的Connection是某个数据厂商实现的Connection。实现DataSource然后创建一个linklist当做池子存放Connection对象。关键在与改写getConnection()方法。这里我们还是获取建一个Connection的实现类，然后传入到我们自己实现的MyConnection当中，然后使用我们自己的实现类。

public class TestJDBC {
    @Test
    public void test1(){

        Connection conn = null;
        PreparedStatement ps = null;
        DataSource ds = new MyDataSource();
        try {
            conn = ds.getConnection();//从池中取出一个连接 MyConnection
            ps = conn.prepareStatement("..");
//          ...
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            try {
                conn.close();//该关就关闭，是否真的关了取决于 conn对象中怎么来的
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

---

适配器模式

适配器模式是装饰模式的变体，适配器模式简单理解就是讲接口实现了，使用继承适配器来取代实现接口，这样就可以只重写我们需要的方法，不用去关心我们不需要的方法了，如下创建一个Connection的适配器的部分代码，思想是一样的，传入一个Connection的实现对象，调用这个对象的对应的方法来完成对应的方法。

import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Struct;
import java.util.Map;
import java.util.Properties;
//1、编写一个类，实现与被包装类相同的接口。（具备相同的行为）
//2、定义一个被包装类类型的变量。
//3、定义构造方法，把被包装类的对象注入，给被包装类变量赋值。
//4、对于不需要改写的方法，调用原有的方法。
public class MyConnectionWarper implements Connection {

    private Connection oldConn;
    public MyConnectionWarper(Connection oldConn){
        this.oldConn = oldConn;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return oldConn.unwrap(iface);
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return oldConn.isWrapperFor(iface);
    }

    @Override
    public Statement createStatement() throws SQLException {
        return oldConn.createStatement();
    }

编写我们自己的MyConnection对象，调用时一样的调用。

import java.sql.Connection;
import java.sql.SQLException;
import java.util.LinkedList;

public class MyConnection extends MyConnectionWarper {
    private Connection oldConn;
    private LinkedList<Connection> pool;
    public MyConnection(Connection oldConn,LinkedList<Connection> pool) {
        super(oldConn);
        this.oldConn = oldConn;
        this.pool = pool;
    }
    @Override
    public void close() throws SQLException {
        pool.addLast(oldConn);
    }
}

对于装饰模式的问题：
开始时我不明白为什么不直接使用继承，继承Connection的实现类呢？这样直接重写我们需要的方法不就行了？
后来才发现：实现这个Connection的接口都是不同的数据库，它的实现类都是真对不同数据库实现的，使用继承的话，以后我们修改了数据库，这样实现这个Connection接口的类也变了，我们就得真对这个类再写一个继承，这样是非常糟糕的。而直接实现这个接口，然后传入不同的实现类，我们的代码都可以使用。