手写数据库连接池，让抽象工厂不再抽象

接下来创建Java产品族，Java视频JavaVideo类的代码如下。

public class JavaVideo implements IVideo {

public void record() {

System.out.println(“录制Java视频”);

}

}

扩展产品等级Java课堂笔记JavaNote类。

public class JavaNote implements INote {

public void edit() {

System.out.println(“编写Java笔记”);

}

}

创建Java产品族的具体工厂JavaCourseFactory。

public class JavaCourseFactory extends CourseFactory {

public INote createNote() {

super.init();

return new JavaNote();

}

public IVideo createVideo() {

super.init();

return new JavaVideo();

}

}

随后创建Python产品族，Python视频PythonVideo类的代码如下。

public class PythonVideo implements IVideo {

public void record() {

System.out.println(“录制Python视频”);

}

}

扩展产品等级Python课堂笔记PythonNote类。

public class PythonNote implements INote {

public void edit() {

System.out.println(“编写Python笔记”);

}

}

创建Python产品族的具体工厂PythonCourseFactory。

public class PythonCourseFactory implements CourseFactory {

public INote createNote() {

return new PythonNote();

}

public IVideo createVideo() {

return new PythonVideo();

}

}

最后来看客户端调用代码。

public static void main(String[] args) {

JavaCourseFactory factory = new JavaCourseFactory();

factory.createNote().edit();

factory.createVideo().record();

}

上面代码完整地描述了Java课程和Python课程两个产品族，也描述了视频和笔记两个产品等级。抽象工厂非常完美、清晰地描述了这样一层复杂的关系。但是，不知道大家有没有发现，如果再继续扩展 《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》无偿开源 威信搜索公众号【编程进阶路】 产品等级，将源码Source也加入课程中，则代码从抽象工厂到具体工厂要全部调整，这显然不符合开闭原则。

[](()4 使用抽象工厂模式重构数据库连接池

---

还是演示课堂开始的JDBC *** 作案例，我们每次 *** 作都需要重新创建数据库连接。其实每次创建都非常耗费性能，消耗业务调用时间。我们使用抽象工厂模式，将数据库连接预先创建好，放到容器中缓存着，当业务调用时就只需现取现用。我们来看代码。

Pool抽象类的代码如下。

/**

• 自定义连接池getInstance()返回POOL唯一实例，第一次调用时将执行构造函数

• 构造函数Pool()调用驱动装载loadDrivers()函数；

• 连接池创建createPool()函数，loadDrivers()装载驱动

• createPool()创建连接池，getConnection()返回一个连接实例，

• getConnection(long time)添加时间限制

• freeConnection(Connection con)将con连接实例返回连接池，getnum()返回空闲连接数

• getnumActive()返回当前使用的连接数

• @author Tom

*/

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驱动程序

• @param dri 接收驱动字符串

*/

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的实例

• @param driverName 数据库驱动字符串

• @return

• @throws IOException

• @throws ClassNotFoundException

• @throws IllegalAccessException

• @throws InstantiationException

*/

public static synchronized Pool getInstance() throws IOException,

InstantiationException, IllegalAccessException,

ClassNotFoundException {

if (instance == null) {

instance = (Pool) Class.forName(“org.e_book.sqlhelp.Pool”).newInstance();

}

return instance;

}

/**

• 获得一个可用的连接，如果没有，则创建一个连接，并且小于最大连接限制

• @return

*/

public abstract Connection getConnection();

/**

• 获得一个连接，有时间限制

• @param time 设置该连接的持续时间（以毫秒为单位）

• @return

*/

public abstract Connection getConnection(long time);

/**

• 将连接对象返回连接池

• @param con 获得连接对象

*/

public abstract void freeConnection(Connection con);

/**

• 返回当前空闲的连接数

• @return

*/

public abstract int getnum();

/**

• 返回当前工作的连接数

• @return

*/

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数据库连接池的代码如下。

/**

• 数据库连接池管理类

• @author Tom

*/

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; //连接池实例变量

/**

• 产生数据连接池

• @return

*/

public static synchronized DBConnectionPool getInstance()

{

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©; //往容器中添加一个连接对象

num++; //记录总连接数

}

}

}catch(Exception e)

{

e.printStackTrace();

}

}

/**

• 初始化

• @throws IOException

*/

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

}

/**

• 如果不再使用某个连接对象，则可调此方法将该对象释放到连接池

• @param con

*/

public synchronized void freeConnection(Connection con) {

freeConnections.addElement(con);

num++;

checkedOut–;

numActive–;

notifyAll(); //解锁

}

/**

• 创建一个新连接

• @return

*/

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;

}

/**

• 返回当前空闲的连接数

• @return

*/

public int getnum() {

return num;

}

/**

• 返回当前可用的连接数

• @return

*/

public int getnumActive() {

return numActive;

}

/**

• （单例模式）获取一个可用连接

• @return

*/

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