数据库连接池&JDBCTemplate

1、数据库连接池

概念

数据库连接池是一个存放数据库连接的容器。当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。

好处：节约资源、用户访问高效。

标准接口

javax.sql包下的DataSource

1、方法：

获取连接：getConnection()

归还连接：Connection.close()。如果连接对象是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接，而是归还连接。

2、数据库连接池技术：C3P0、Druid

C3P0

1、步骤：

①导入两个jar包：c3p0-0.9.5.2.jar和mchange-commons-java-0.2.12.jar，同时也需要导入数据库驱动jar包。

②定义配置文件：c3p0.properties或c3p0-config.xml，直接放在src目录下。

③创建核心对象：数据库连接对象，ComboPooledDataSource

④获取连接：getConnection

2、目录结构

3、简单实现

public class Demo {
	public static void main(String[] args) throws SQLException {
		//创建数据库连接池对象
		DataSource ds = new ComboPooledDataSource();
		//获取连接对象
		Connection conn = ds.getConnection();
		//打印
		System.out.println(conn);
	}
}

Druid：阿里巴巴提供

1、步骤：

①导入jar包：druid-1.0.9.jar

②定义配置文件：properties形式，可以叫任何名，可以放在任何目录下。

③加载配置文件

④获取数据库连接池对象：通过工厂类来获取，DruidDataSourceFactory

⑤获取连接：getConnection

2、简单实现

druid.properties（放在了src下）

driverClassName = com.mysql.cj.jdbc.Driver
url = jdbc:mysql://localhost:3306/db1?serverTimezone=GMT%2B8
username = root
password = 
initialSize = 5
maxActive = 10
maxWait = 3000

DruidDemo.java

package druid;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

public class DruidDemo {
	public static void main(String[] args) {
		//1.导入jar包
		//2.定义配置文件
		//3.加载配置文件
		Connection conn = null;
		try {
			Properties pro = new Properties();
			ClassLoader classLoader = DruidDemo.class.getClassLoader();
			InputStream is = classLoader.getResourceAsStream("druid.properties");
			pro.load(is);
			//4.获取连接池对象
			DataSource ds = DruidDataSourceFactory.createDataSource(pro);
			//5.获取连接
			conn = ds.getConnection();
			System.out.println(conn);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(conn != null) {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

Druid例子，工具类实现数据库添加操作

druid.properties

driverClassName = com.mysql.cj.jdbc.Driver
url = jdbc:mysql://localhost:3306/db1?serverTimezone=GMT%2B8
username = root
password = 
initialSize = 5
maxActive = 10
maxWait = 3000

JDBCUtils.java

package utils;

import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import javax.sql.DataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

/*
 * Druid连接池的工具类
 */
public class JDBCUtils {
	//1.定义成员变量
	private static DataSource ds;
	
	static {
		try {
			//1.加载配置文件
			Properties pro = new Properties();
			pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
			//2.获取DataSource
			ds = DruidDataSourceFactory.createDataSource(pro);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	//获取连接
	public static Connection getConnection() throws SQLException {
		return ds.getConnection();
	}
	
	//释放资源
	public static void close(Statement stmt, Connection conn) {
		if(stmt != null) {
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		if(conn != null) {
			try {
				conn.close(); // 归还连接
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	
	//释放资源
	public static void close(ResultSet rs, Statement stmt, Connection conn) {
		if(rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		if(stmt != null) {
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		if(conn != null) {
			try {
				conn.close(); // 归还连接
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	
	//获取连接池
	public static DataSource getDataSource() {
		return ds;
	}
}

DruidDemo.java

package druid;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import utils.JDBCUtils;

public class DruidDemo {
	public static void main(String[] args) {
		//完成添加操作，给account表添加一条记录
		Connection conn = null;
		PreparedStatement pstmt = null;
		try {
			conn = JDBCUtils.getConnection();
			String sql = "insert into account values(null, ?, ?)";
			pstmt = conn.prepareStatement(sql);
			pstmt.setString(1, "Mike");
			pstmt.setDouble(2, 5000);
			int count = pstmt.executeUpdate();
			System.out.println(count);
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			JDBCUtils.close(pstmt, conn);
		}
	}
}

2、JDBCTemplate

简单说明

Spring框架对JDBC的简单封装，提供了一个JDBCTemplate对象简化JDBC的开发。

步骤

1、导入jar包。

2、创建JdbcTemplate对象，依赖于数据源DataSource。

3、调用JdbcTemplate的方法来完成数据库操作：

      update()：执行DML语句。

      queryForMap()：查询结果，将结果集封装为map集合。

      queryForList()：查询结果，将结果集封装为list集合。

      query()：查询结果，将结果集封装为JavaBean对象。

      queryForObject()：查询结果，将结果集封装为对象。

例子

druid.properties和JDBCUtils.java用的是上面那个例子的。

Demo.java

package jdbctemplate;

import org.springframework.jdbc.core.JdbcTemplate;
import utils.JDBCUtils;

public class Demo {
	public static void main(String[] args) {
		//1.导入jar包
		//2.创建JDBCTemplate对象
		JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
		//3.调用方法
		String sql = "update account set money = 5000 where id = ?";
		int count = template.update(sql, 1);
		System.out.println(count);
	}
}

不需要我们再去手动申请连接和释放连接了。

JDBCTemplate执行DML、DQL语句

Account.java

package jdbctemplate;

public class Account {
	private int id;
	private String name;
	private double money;
	
	public int getId() {
		return id;
	}
	
	public void setId(int id) {
		this.id = id;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public double getMoney() {
		return money;
	}
	
	public void setMoney(double money) {
		this.money = money;
	}

	@Override
	public String toString() {
		return "Account [id=" + id + ", name=" + name + ", money=" + money + "]";
	}
}

Demo.java

package jdbctemplate;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import utils.JDBCUtils;

public class Demo {
	private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
	
	//1.将1号的money改为8000
	@Test
	public void test1() {
		String sql = "update account set money = 8000 where id = ?";
		int count = template.update(sql, 1);
		System.out.println(count);
	}
	
	//2.添加一条记录
	@Test
	public void test2() {
		String sql = "insert into account values(?, ?, ?)";
		int count = template.update(sql, 5, "Anny", 6000);
		System.out.println(count);
	}
	
	//3.删除一条记录
	@Test
	public void test3() {
		String sql = "delete from account where id = ?";
		int count = template.update(sql, 5);
		System.out.println(count);
	}
	
	//4.查询id为1的记录，将其封装成map集合
	@Test
	public void test4() {
		String sql = "select * from account where id = ?";
		Map<String, Object> mp = template.queryForMap(sql, 1);
		System.out.println(mp);
	}
	
	//5.查询所有记录，将其封装为List
	@Test
	public void test5() {
		String sql = "select * from account";
		List<Map<String, Object>> list = template.queryForList(sql);
		for(Map<String, Object> mp : list) {
			System.out.println(mp);
		}
	}
	
	//6.查询所有记录，将其封装为Account对象的List集合
	@Test
	public void test6() {
		String sql = "select * from account";
		List<Account> list = template.query(sql, new RowMapper<Account>() {
			@Override
			public Account mapRow(ResultSet rs, int i) throws SQLException {
				Account ac = new Account();
				ac.setId(rs.getInt("id"));
				ac.setName(rs.getString("name"));
				ac.setMoney(rs.getDouble("money"));
				return ac;
			}
		});
		
		for(Account account : list) {
			System.out.println(account);
		}
	}
	
	//简化操作
	@Test
	public void test6_2() {
		String sql = "select * from account";
		List<Account> list = template.query(sql, new BeanPropertyRowMapper<Account>(Account.class));
		for(Account account : list) {
			System.out.println(account);
		}
	}
	
	//7.查询总记录数
	@Test
	public void test7() {
		String sql = "select count(id) from account";
		Integer sum = template.queryForObject(sql, Integer.class);
		System.out.println(sum);
	}
}