工厂模式 以及其在JDBC操作中的应用

最近在重温设计模式以及看Spring5源码，这边记录下工厂模式在JDBC操作案例中的应用。

这边主要介绍抽象工厂模式：

另外还要介绍下产品等级结构和产品族：

横向代表产品族，比如美的空调、美的洗衣机、美的热水器；

纵向代表产品等级结构，比如美的空调、海尔空调、格力空调等；

然后我们需要引入工厂进行更好的理解：

我们看左侧的箭头（小房子）代表的工厂，就相当于美的工厂、海信工厂、格力工厂。

 

下面正式结合实际情景再次理解：

在以前，我们对数据库操作经常需要重复的进行数据库连接创建等耗时耗力的工作，为了遵守高内聚低耦合的原则，我们又将这些操作封装在工具类中，虽然这样能降低代码的重复性，但我们依然不可避免的每次调用需要创建数据库连接。

为了解决这个问题，我们利用工厂模式先将数据库连接先创建好，放到容器中缓存，业务需要调用时现取现用即可。

当然这其中不止含有工厂模式，话不多说，来看看代码：

package java.other;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * 自定义连接池getlnstance(),返回Pool的唯一实例，第一次调用时将执行构造函数
 * 构造函数Pool()调用驱动装载loadDrivers()函数；
 * createPool()函数创建连接池，loadDrivers()装载驱动
 * getConnection()返回一个连接实例
 * getConnection(long time)添加时间限制
 * freeConnection(Connection con)将con连接实例返回连接池
 * getnum()返回空闲连接数
 * getnumActive()返回当前使用的连接数
 */
public abstract class Pool {
    public String propertiesName = "connection-INF.properties";
    private static Pool instance = null; // 定义唯一实例
    protected int maxConnect = 100; // 最大连接数
    protected int normalConnect = 10; // 保持连接数
    protected String driverName = null; // 驱动字符串
    protected Driver driver = null; // 驱动变量

    //私有构造函数，不允许外界访问
    protected Pool() {
        try {
            init();
            loadDrivers(driverName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //初始化所有从配置文件中读取的成员变量
    private void init() throws IOException {
        InputStream is = Pool.class.getResourceAsStream(propertiesName);
        Properties p = new Properties();
        p.load(is);
        this.driverName = p.getProperty("driverName");
        this.maxConnect = Integer.parseInt(p.getProperty("maxConnect"));
        this.normalConnect = Integer.parseInt(p.getProperty("normalConnect"));
    }

    //装载和注册所有JDBC驱动程序
    protected void loadDrivers(String dri) {
        String driverClassName = dri;
        try {
            driver = (Driver) Class.forName(driverClassName).newInstance();
            DriverManager.registerDriver(driver);
            System.out.println("成功注册 JDBC 驱动福序" + driverClassName);
        } catch (Exception e) {
            System.out.println("无法注册 JDBC 驱动程序:" + driverClassName + "，错误：" + e);
        }
    }

    //创建连接池
    public abstract void createPool();

    /**
     * (单例模式)返回数据库连接池Pool的实例
     * 

     * gparam driverName数据库驱动字符串
     *
     * @return ^throws lOException
     * ^throws ClassNotFoundException
     * ^throws IllegalAccessException
     * ^throws InstantiationException
     */
    public static synchronized Pool getlnstance() throws IOException,
            InstantiationException, IllegalAccessException,
            ClassNotFoundException {
        if (instance == null) {
            instance.init();
            instance = (Pool) Class.forName("org.e_book.sqlhelp.Pool").
                    newInstance();
        }
        return instance;
    }

    //获得一个可用的连接，如果没有则创建一个连接，且小于最大连接限制
    public abstract Connection getConnection();

    //获得一个连接，有时间限制
    public abstract Connection getConnection(long time);

    //将连接对象返回给连接池
    public abstract void freeConnection(Connection con);

    //返回当前空闲连接数
    public abstract int getnum();

    //返回当前工作的连接数
    public abstract int getnumActive();

    protected synchronized void release() {
        //撤销驱动
        try {
            DriverManager.deregisterDriver(driver);
            System.out.println("撤销 JDBC 驱动程序" + driver.getClass().getName());
        } catch (SQLException e) {
            System.out.println("无法撤销 JDBC 驱动程序的注册：" + driver.getClass().getName());
        }
    }
}

下面是DBConnectionPool数据库连接池

package java.other;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.*;
import java.util.Date;

//数据库链接池管理类
public final class DBConnectionPool extends Pool {
    private int checkedOut;//正在使用的连接数
    private Vector freeConnections = new Vector();//存放产生的连接对 象容器
    private String password = null; // 密码
    private String url = null;//连接字符串
    private String userName = null;//用户名
    private static int num = 0;//空闲连接数
    private static int numActive = 0;//当前可用的连接数
    private static DBConnectionPool pool = null; //连接池实例变量


    //产生数据连接池
    public static synchronized DBConnectionPool getlnstance() {
        if (pool == null) {
            pool = new DBConnectionPool();
        }
        return pool;
    }

    //获得一个数据库连接池的实例
    private DBConnectionPool() {
        try {
            init();
            for (int i = 0; i < normalConnect; i++) { //初始 normalConn 个连接
                Connection c = newConnection();
                if (c != null) {
                    freeConnections.addElement(c); //往容器中添加一个连接对象
                    num++; //记录总连接数
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //初始化
    private void init() throws IOException {
        InputStream is = DBConnectionPool.class.getResourceAsStream(propertiesName);
        Properties p = new Properties();
        p.load(is);
        this.userName = p.getProperty("userName");
        this.password = p.getProperty("password");
        this.driverName = p.getProperty("driverName");
        this.url = p.getProperty("url");
        this.driverName = p.getProperty("driverName");
        this.maxConnect = Integer.parseInt(p.getProperty("maxConnect"));
        this.normalConnect = Integer.parseInt(p.getProperty("normalConnect"));
    }

    //如果不再使用某个连接对象，可调此方法将该对象释放到连接池
    public synchronized void freeConnection(Connection con) {
        freeConnections.addElement(con);
        num++;
        checkedOut--;
        numActive--;
        notifyAll(); //解锁
    }

    //创建一个新连接
    private Connection newConnection() {
        Connection con = null;
        try {
            if (userName == null) { // 用户、密码都为空
                con = DriverManager.getConnection(url);
            } else {
                con = DriverManager.getConnection(url, userName, password);
            }
            System.out.println("连接池创建一个新的连接");
        } catch (SQLException e) {
            System.out.println("创建这个 URL 的连接" + url);
            return null;
        }
        return con;
    }

    //返回当前空闲连接数
    public int getnum() {
        return num;
    }

    //返回当前连接数
    public int getnumActive() {
        return numActive;
    }

    // (单例模式)获取一个可用连接
    public synchronized Connection getConnection() {
        Connection con = null;
        if (freeConnections.size() > 0) { // 还有空闲的连接
            num--;
            con = (Connection) freeConnections.firstElement();
            freeConnections.removeElementAt(0);
            try {
                if (con.isClosed()) {
                    System.out.println("从连接池中删除一个无效连接");
                    con = getConnection();
                }
            } catch (SQLException e) {
                System.out.println("从连接池中删除一个无效连接");
                con = getConnection();
            }
        } else if (maxConnect == 0 || checkedOut < maxConnect) {
            // 没有空闲连接且当前连接小于最大允许值，最大值为0则不限制
            con = newConnection();
        }
        if (con != null) { //当前连接数加1
            checkedOut++;
        }
        numActive++;
        return con;
    }

    //获取一个连接，并加上等待时间限制，单位为毫秒
    public synchronized Connection getConnection(long timeout) {
        long startTime = new Date().getTime();
        Connection con;
        while ((con = getConnection()) == null) {
            try {
                wait(timeout); // 线程等待
            } catch (InterruptedException e) {
            }
            if ((new Date().getTime() - startTime) >= timeout) {
                return null; //如果超时，则返回
            }
        }
        return con;
    }

    //关闭所有连接
    public synchronized void release() {
        try {
            //将当前连接赋值到枚举中
            Enumeration allConnections = freeConnections.elements();
            //使用循环关闭所用连接
            while (allConnections.hasMoreElements()) {
                //如果此枚举对象至少还有一个可提供的元素，则返回此枚举对象的下一个元素
                Connection con = (Connection) allConnections.nextElement();
                try {
                    con.close();
                    num--;
                } catch (SQLException e) {
                    System.out.println("羌必关闭连接池中的连接");
                }
            }
            freeConnections.removeAllElements();
            numActive = 0;
        } finally {
            super.release();
        }
    }

    //建立连接池
    public void createPool() {
        pool = new DBConnectionPool();
        if (pool != null) {
            System.out.println("创建连接池成功");
        } else {
            System.out.println("创建连接池失败");
        }
    }
}

 

---

代码可以在我的github上找到：https://github.com/YellowDii/MySpring.git

参考资料：《Spring5核心原理与30个类手写实战》