Use o padrão de fábrica abstrato para simplesmente simular o pool de conexão do banco de dados

Use o padrão de fábrica abstrato para simular o pool de conexão JDBC

Padrão de método de
fábrica padrão de fábrica simples padrão de
fábrica abstrato

1. Pool de conexão

Pool de conexão: o pool de conexão é uma tecnologia para criar e gerenciar um pool de buffer de conexões, essas conexões estão prontas para serem utilizadas por qualquer thread que precise delas.

Aqui eu uso o padrão abstrato de fábrica para simplesmente simular o pool de conexão do banco de dados

2. Preparação

Primeiro, descubra as quatro funções na fábrica abstrata

O que precisamos é de um pool que possa ser usado para obter conexões de banco de dados diretamente, de modo que o objeto específico seja o pool de conexões de banco de dados e o objeto abstrato seja o objeto de conexão de banco de dados Connection object.

A fábrica abstrata define o comportamento geral do pool de conexão do banco de dados, cria um pool de conexão, obtém uma conexão e recicla uma conexão.

A fábrica concreta herda a fábrica abstrata e refina o comportamento do pool de conexão, como obter as conexões disponíveis atualmente e assim por diante.

Fábrica abstrata: comportamento geral do pool de conexão

Fábrica de concreto: herda a fábrica abstrata e fornece o comportamento concreto do pool de conexão

Objeto abstrato: Conexão

Objeto específico: pool de conexão de banco de dados

Depois de descobrir isso, você pode começar a trabalhar

3. Perceba

Fábrica abstrata:

public	abstract class Pool {

	public Driver driver = null;//驱动对象
	
	public String propertiesName = "jdbc.properties";//配置文件名称
	
	public int normalConnect = 10;//保持连接数
	
	public String driverName = null;//驱动字符串
	
	public String username;//用户名
	
	public String password;//密码
	
	public String url;//地址
	
	
	{//静态代码块初始化成员变量
		InputStream is = Pool.class.getResourceAsStream(propertiesName);
		Properties p = new Properties();
		//加载配置文件
		try {
			p.load(is);
			this.driverName = p.getProperty("driverName");
			this.username = p.getProperty("username");
			this.password = p.getProperty("password");
			this.url = p.getProperty("url");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 注册JDBC驱动
	 */
	@SuppressWarnings("deprecation")
	public void loadDriver() {
		try {
			Driver driver = (Driver) Class.forName(driverName).newInstance();
			this.driver = driver;
			System.out.println("驱动注册成功"+driverName);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("驱动注册失败检查驱动字符串是否正确");
		}
	}
	
	
	/**
	 * 从连接池中拿到一个连接
	 * @return
	 */
	public abstract Connection getConnection();
	
	
	/**
	 * 把一个连接返回连接池
	 * @param con 连接对象
	 */
	public abstract void freeConnection(Connection con);
	
	
	/**
	 * 关闭所有的连接，撤销驱动注册
	 */
	public abstract void release();
	
}

Fábrica específica:

public class DBconnectionPool extends Pool {

	// 空闲连接
	private int num = 0;
	// 存储连接的容器
	private Vector<Connection> freeConnections = new Vector<Connection>();

	/**
	 * 初始化
	 */
	public DBconnectionPool() {
		super.loadDriver();// 加载驱动
		for (int i = 0; i < normalConnect; i++) {// 创建连接
			freeConnections.add(newConnection());
			num++;
		}
	}

	/**
	 * 从连接池中拿到一个连接
	 * 
	 * @return
	 */
	@Override
	public Connection getConnection() {
		if (freeConnections.size() > 0) {// 连接池中有空闲连接
			Connection con = freeConnections.get(0);
			freeConnections.removeElementAt(0);
			num--;
			System.out.println("客户端拿取了一个连接"+con);
			return con;
		}
		System.out.println("连接池无可用连接");
		return null;
	}

	/**
	 * 把一个连接返回连接池
	 * 
	 * @param con 连接对象
	 */
	@Override
	public void freeConnection(Connection con) {
		freeConnections.add(con);
		num++;
		System.out.println("客户端放回了一个连接");
	}

	/**
	 * 关闭连接，并注销驱动
	 */
	@Override
	public void release() {
		freeConnections.removeAllElements();//移除所有连接
		num=0;
		try {
			DriverManager.deregisterDriver(driver);//注销驱动
		} catch (SQLException e) {
			e.printStackTrace();
			System.out.println("驱动注销失败");
		}
		System.out.println("连接池已经关闭");
	}

	/**
	 * 创建一个连接
	 * 
	 * @return
	 * @throws SQLException
	 */
	public Connection newConnection() {
		try {
			Connection con = DriverManager.getConnection(url, username, password);
			System.out.println("连接池创建了一个连接");
			return con;
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("连接创建失败");
			return null;
		}
	}

	/**
	 * 返回可用连接
	 * 
	 * @return
	 */
	public int getNum() {
		return num;
	}

}

Chamada de cliente

public class Client {

	public static void main(String[] args) throws SQLException {
		//创建连接池
		DBconnectionPool pool = new	DBconnectionPool();
		System.out.println(pool.getNum());//10
		//拿到一个连接
		Connection con1 = pool.getConnection();
		pool.getConnection();//再次获取
		
		System.out.println(pool.getNum());//8
		
		pool.freeConnection(con1);//放回一个连接
		con1.close();
		System.out.println(pool.getNum());//9
		pool.release();//注销连接池
		pool.getConnection();//这个时候已经连接池中已经没有可用的连接了
	}
	
}

Arquivo de configuração

dica: um pacote jar (mysql-connector-java.jar) é necessário para conectar ao banco de dados