JDBC实现增删改查，使用连接池

JDBC：Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。我们通常说的JDBC是面向关系型数据库的。

JDBC作用：
连接数据库
发送sql语句
处理结果
JDBC操作步骤：
1.数据库和表（）
2.创建一个项目
3.导入驱动jar包
4.编码:
注册驱动
获取连接
编写sql
创建预编译的语句执行者
设置参数
执行sql
处理结果
释放资源

初始化数据库和表:

CREATE DATABASE day07;
		USE day07;	
		
		create table category(
			cid varchar(20) primary key,
			cname varchar(20)
		);
		
		insert into category values('c001','电器');
		insert into category values('c002','服饰');
		insert into category values('c003','化妆品');
		insert into category values('c004','书籍');

这里面省略第二步和第三步
接下来我们看编码部分：
1.查询数据库的数据：

@Test
	public void f2() throws Exception{
		//注册驱动
		//Class.forName("com.mysql.jdbc.Driver");
		DriverManager.registerDriver(new Driver());	
		//获取连接 		ctrl+o 整理包
		Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbc", "root", "123456");
		//编写sql
		String  sql="select * from category";
		//创建语句执行者
		PreparedStatement st=conn.prepareStatement(sql);	
		//设置参数	
		//执行sql
		ResultSet rs=st.executeQuery();		
		//处理结果
		while(rs.next()){
			System.out.println(rs.getString("cid")+"::"+rs.getString("cname"));
		}
		//释放资源.
		rs.close();
		st.close();
		conn.close();
	}

上面那个是传统的方法，下面我们来介绍工具类（JdbcUtils）：

public class JdbcUtils_ {
	// 获取连接
	public static Connection getConnection() throws ClassNotFoundException, SQLException {
		// 注册驱动   ctrl+shift+f格式化代码
		Class.forName("com.mysql.jdbc.Driver");

		// 获取连接 ctrl+o 整理包
		Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbc", "root", "123456");
		return conn;
	}
	/**
	 * 释放资源
	 * @param conn 连接
	 * @param st 语句执行者
	 * @param rs 结果集
	 */
	public static void closeResource(Connection conn, Statement st, ResultSet rs) {
		closeResultSet(rs);
		closeStatement(st);
		closeConn(conn);
	}
	/**
	 * 释放连接
	 * @param conn 连接
	 */
	public static void closeConn(Connection conn){
		if(conn!=null){
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			conn=null;
		}
		
	}
	/**
	 * 释放语句执行者
	 * @param st 语句执行者
	 */
	public static void closeStatement(Statement st){
		if(st!=null){
			try {
				st.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			st=null;
		}
		
	}
	/**
	 * 释放结果集
	 * @param rs 结果集
	 */
	public static void closeResultSet(ResultSet rs){
		if(rs!=null){
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			rs=null;
		}	
	}

2.通过这个工具类，我们来实现插入一条数据

@Test
	public void f3(){
		Connection conn=null;
		ResultSet rs=null;
		PreparedStatement st=null;
		
		try {
			//获取连接
			conn=**JdbcUtils**.getConnection();

			//编写sql
			String sql="insert into  category values(?,?)";
			
			//获取语句执行者
			st=conn.prepareStatement(sql);
			
			//设置参数
			st.setString(1, "c006");
			st.setString(2, "户外");
			
			//执行sql 
			int i=st.executeUpdate();
			
			//处理结果
			if(i==1){
				System.out.println("success");
			}else{
				System.out.println("fail");
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//释放资源
			JdbcUtils.closeResource(conn, st, rs);
		}
		
	}

3.介绍完工具类，我们来看一个连接池，这里面介绍dbcp和c3p0

Dbcp:

public class DbcpDemo {
	@Test
	//硬编码
	public void f1() throws Exception{
		//创建连接池
		BasicDataSource ds = new BasicDataSource();
		
		//配置信息
		ds.setDriverClassName("com.mysql.jdbc.Driver");
		ds.setUrl("jdbc:mysql://localhost:3306/jdbc");	//如果是本地的可以把localhost端口3306的可以省略  jdbc:mysql:///jdbc
		ds.setUsername("root");
		ds.setPassword("123456");
		
		Connection conn=ds.getConnection();
		String sql="insert into category values(?,?);";
		PreparedStatement st=conn.prepareStatement(sql);
		
		//设置参数
		st.setString(1, "c010");
		st.setString(2, "饮料");
		
		int i = st.executeUpdate();
		System.out.println(i);
		JdbcUtils.closeResource(conn, st, null);
	}
	
	@Test
	public void f2() throws Exception{
		//存放配置文件
		Properties prop = new Properties();
		prop.load(new FileInputStream("src/dbcp.properties"));//通过配置文件的方式
		//设置
		//prop.setProperty("driverClassName", "com.mysql.jdbc.Driver");
		
		//创建连接池
		DataSource ds = new BasicDataSourceFactory().createDataSource(prop);
		
		Connection conn=ds.getConnection();
		String sql="insert into category values(?,?);";
		PreparedStatement st=conn.prepareStatement(sql);
		
		//设置参数
		st.setString(1, "c012");
		st.setString(2, "饮料1");
		
		int i = st.executeUpdate();
		System.out.println(i);
		JdbcUtils.closeResource(conn, st, null);
	}
}

配置文件jdbc.properties

driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbc
user=root
password=123456

C3p0:

public class C3p0Demo {
	@Test
	//硬编码
	public void f1() throws Exception{
		ComboPooledDataSource ds = new ComboPooledDataSource();
		
		//设置基本参数
		ds.setDriverClass("com.mysql.jdbc.Driver");
		ds.setJdbcUrl("jdbc:mysql:///jdbc");
		ds.setUser("root");
		ds.setPassword("123456");
		
		Connection conn=ds.getConnection();
		String sql="insert into category values(?,?)";
		PreparedStatement st=conn.prepareStatement(sql);
		
		//设置参数
		st.setString(1, "c013");
		st.setString(2, "毒药");
		
		int i = st.executeUpdate();
		System.out.println(i);
		JdbcUtils.closeResource(conn, st, null);
	}
	
	@Test
	public void f2() throws Exception{
		//ComboPooledDataSource ds = new ComboPooledDataSource();//**会自动调用c3p0配置文件，加上__会自动调用xml**
		ComboPooledDataSource ds =new ComboPooledDataSource("ch12321");//若查找不到命名的配置 使用默认的配置
		Connection conn=ds.getConnection();
		String sql="insert into category values(?,?);";
		PreparedStatement st=conn.prepareStatement(sql);
		
		//设置参数
		st.setString(1, "c124");
		st.setString(2, "解药");
		
		int i = st.executeUpdate();
		System.out.println(i);
		JdbcUtils.closeResource(conn, st, null);
	}
}

c3p0的配置文件有两种，一种是properties，一种是xml，这里只介绍xml：

<c3p0-config>
	<!-- 默认配置，如果没有指定则使用这个配置 -->
	<default-config>
		<!-- 基本配置 -->
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/jdbc</property>
		<property name="user">root</property>
		<property name="password">123456</property>
	
		<!--扩展配置-->
		<property name="checkoutTimeout">30000</property>
		<property name="idleConnectionTestPeriod">30</property>
		<property name="initialPoolSize">10</property>
		<property name="maxIdleTime">30</property>
		<property name="maxPoolSize">100</property>
		<property name="minPoolSize">10</property>
		<property name="maxStatements">200</property>
	</default-config> 
	
	
	<!-- 命名的配置 -->
	<named-config name="ch">
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/xxxx</property>
		<property name="user">root</property>
		<property name="password">123456</property>
		
		
		<!-- 如果池中数据连接不够时一次增长多少个 -->
		<property name="acquireIncrement">5</property>
		<property name="initialPoolSize">20</property>
		<property name="minPoolSize">10</property>
		<property name="maxPoolSize">40</property>
		<property name="maxStatements">20</property>
		<property name="maxStatementsPerConnection">5</property>
	</named-config>
</c3p0-config> 

通过上面两个，我们可以抽取工具类DataSourceUtils

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class DataSourceUtils {
	private static ComboPooledDataSource ds=new ComboPooledDataSource();
	/**
	 * 获取数据源
	 * @return 连接池
	 */
	public static DataSource getDataSource(){
		return ds;
	}
	/**
	 * 获取连接
	 * @return 连接
	 * @throws SQLException
	 */
	public static Connection getConnection() throws SQLException{
		return ds.getConnection();
	}
	/**
	 * 释放资源
	 * 
	 * @param conn
	 *            连接
	 * @param st
	 *            语句执行者
	 * @param rs
	 *            结果集
	 */
	public static void closeResource(Connection conn, Statement st, ResultSet rs) {
		closeResultSet(rs);
		closeStatement(st);
		closeConn(conn);
	}

	/**
	 * 释放连接
	 * 
	 * @param conn
	 *            连接
	 */
	public static void closeConn(Connection conn) {
		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			conn = null;
		}

	}
	/**
	 * 释放语句执行者
	 * 
	 * @param st
	 *            语句执行者
	 */
	public static void closeStatement(Statement st) {
		if (st != null) {
			try {
				st.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			st = null;
		}

	}
	/**
	 * 释放结果集
	 * 
	 * @param rs
	 *            结果集
	 */
	public static void closeResultSet(ResultSet rs) {
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			rs = null;
		}

	}
}

那么知道这两种连接池了，我们测试一个JDBC的CURD就容易了：

public class CURDDemo {
	//插入一条数据
	@Test
	public void insert() throws SQLException{
		//1.创建queryrunner类
		QueryRunner qr = new QueryRunner(DataSourceUtils.getDataSource());
		
		//2.编写sql
		String sql="insert into category values(?,?)";
		
		
		//3.执行sql
		qr.update(sql, "c201","厨房电器");
		
	}
	//更新一条数据
	@Test
	public void update() throws SQLException{
		QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
		
		String sql="update category set cname = ? where cid = ?";
		
		qr.update(sql, "达电器","c000");
	}
	//删除一条数据
	@Test
	public void delete() throws SQLException {
		QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
		String sql="delete from category where cid = ?";
		qr.update(sql, "c013");
	}
	//查询数据请看下面
}

查询数据：看你需要封装的对象是什么

下面是对应的代码，以及运行结果：

import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.Test;

import com.ch.domain.Category;
import com.ch.utils.DataSourceUtils;

public class ResultHandleDemo {
	@Test
	public void arrayHandler() throws SQLException{
		QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
		
		String sql="select * from category";

		Object[] query = qr.query(sql, new ArrayHandler());
		System.out.println(Arrays.toString(query));
	}
	
	@Test
	public void arrayListHandler() throws SQLException{
		QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
		
		String sql="select * from category";
		List<Object[]> list = qr.query(sql, new ArrayListHandler());
		for (Object[] obj : list) {
			System.out.println(Arrays.toString(obj));
		}
	}

	@Test
	public void beanHandler() throws SQLException{
		QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
		
		String sql="select * from category";
		
		Category bean = qr.query(sql, new BeanHandler<>(Category.class));
		
		System.out.println(bean);
	}


	@Test
	public void beanListHandler() throws SQLException{
		QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
		
		String sql="select * from category";
		
		List<Category> list = qr.query(sql, new BeanListHandler<>(Category.class));
		
		for (Category bean : list) {
			
			System.out.println(bean);
		}
	}
	
	@Test
	public void mapHandler() throws SQLException{
		QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
		
		String sql="select * from category";
		
		Map<String, Object> map = qr.query(sql, new MapHandler());
		System.out.println(map);
	}
	
	@Test
	public void mapListHandler() throws SQLException{
		QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
		
		String sql="select * from category";

		List<Map<String, Object>> list = qr.query(sql, new MapListHandler());
		for (Map<String, Object> map : list) {
			System.out.println(map);
		}
	}
	
	@Test
	public void scalarHandler() throws SQLException{
		QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
		
		String sql="select count(*) from category";
		
		Object obj = qr.query(sql, new ScalarHandler());

		System.out.println(obj.getClass().getName());//查看数据类型
	}
	
}

(了解)ArrayHandler, 将查询结果的第一条记录封装成数组,返回

(了解)ArrayListHandler, 将查询结果的每一条记录封装成数组,将每一个数组放入list中返回

BeanHandler, 将查询结果的第一条记录封装成指定的bean对象,返回

BeanListHandler, 将查询结果的每一条记录封装成指定的bean对象,将每一个bean对象放入list中 返回.

(了解) ColumnListHandler, 将查询结果的指定一列放入list中返回
(了解) MapHandler, 将查询结果的第一条记录封装成map,字段名作为key,值为value 返回

MapListHandler, 将查询结果的每一条记录封装map集合,将每一个map集合放入list中返回

ScalarHandler,针对于聚合函数 例如:count(*) 返回的是一个Long值