JDBC基础自查手册 - 清风与归

本文最后更新于：2020年12月30日下午

一、概述

远古技术了，没人带就一点一点来吧

二、入门

创建数据库和表

create database web_test3;
use web_test3;
create table user(
	id int primary key auto_increment,
	username varchar(20),
	password varchar(20),
	nickname varchar(20),
	age int
);
insert into user values (null,'aaa','123','xiaoli',34);
insert into user values (null,'bbb','123','dawang',32);
insert into user values (null,'ccc','123','xiaoming',28);
insert into user values (null,'ddd','123','dahuang',21);

创建项目，引入mysql-connector-java的jar包，如将mysql-connector-java-5.0.8-bin.jar放在lib文件夹下

开发JDBC

加载驱动
获得连接
基本操作
释放资源

import org.junit.Test;

/**
 * JDBC的入门程序
 * @author jt
 *
 */
public class JDBCDemo1 {

	@Test
	public void demo1() throws Exception{
		// 1.加载驱动
		Class.forName("com.mysql.jdbc.Driver");
        
		// 2.获得JDBC连接(url，username,pwd)
		Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/web_test3", "root", "abc");
        
		// 3.基本操作：执行SQL
		// 3.1获得执行SQL语句的对象
		Statement statement = conn.createStatement();
		// 3.2编写SQL语句:
		String sql = "select * from user";
		// 3.3执行SQL:
		ResultSet rs = statement.executeQuery(sql);
		// 3.4遍历结果集:
		while(rs.next()){
			System.out.print(rs.getInt("id")+" ");
			System.out.print(rs.getString("username")+" ");
			System.out.print(rs.getString("password")+" ");
			System.out.print(rs.getString("nickname")+" ");
			System.out.print(rs.getInt("age"));
			System.out.println();
		}
        
		// 4.释放资源
		rs.close();
		statement.close();
		conn.close();
	}
}

三、常用API

1）DriverManager 驱动管理类

注册驱动
- DriverManager.registerDriver(new Driver());一般不会用，更推荐Class.forName(“com.mysql.jdbc.Driver”);
获得连接：
- DriverManager.getConnection(String url, String user, String password)
  - “jdbc:mysql://localhost:3306/web_test3”, “root”, “abc”
  - jdbc：连接数据库的协议，mysql：是jdbc的子协议
  - localhost：连接的MySQL数据库服务器的主机地址。（连接是本机就可以写成localhost），如果连接不是本机的，就需要写上连接主机的IP地址。
  - 3306：MySQL数据库服务器的端口号，web_test3：数据库名称
- url如果连接的是本机的路径，可以简化为：jdbc:mysql:///web_test3

2）Connection 与数据库连接对象

创建执行SQL语句的对象
- Connection.createStatement()：创建一个Statement对象，来执行SQL
- Connection.prepareCall(String sql)：创建一个CallableStatement对象，来执行数据库中存储过程
- Connection.PreparedStatement：创建一个PreparedStatement对象，来讲参数化的SQL语句发送到数据库。对SQL进行预处理，解决SQL注入漏洞
管理事务
- setAutoCommit：设置自动提交
- commit()：提交
- rollback()：回滚，取消在当前事务中进行的所有更改

3）Statement

执行SQL语句：
- statement.execute(String sql)：执行增删改查等SQL语句
- statement.executeQuery(String sql)：执行查询（select语句）
- statement.executeUpate(String sql)：执行修改，添加，删除的SQL语句
执行批处理：
- statement.addBatch(String sql)：将给定的SQL命令添加到此statement对象的当前命令列表中
- statement.clearBatch()：清空此statement对象的当前SQL命令列表
- statement.executeBatch()：将一批SQL命令提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组

4）ResultSet 结果集

通过select语句得到的查询结果

结果集遍历：ResultSet.next()
结果集获取：ResultSet.getXXX(int columnIndex)或者 ResultSet.getXXX(String columnName)

四、资源释放

JDBC程序执行结束后，将与数据库进行交互的对象释放掉，通常是Connection，Statement，ResultSet。

这几个对象中尤其是Connection对象是非常稀有的。这个对象一定要做到尽量晚创建，尽早释放掉。

if(rs != null){
    try {
        rs.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }

    rs = null;
}
			
if(statement !=null){
    try {
        statement.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }

    statement = null;
}


if(conn != null){
    try {
        conn.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }

    conn = null;
}

五、JDBC的CRUD操作

Create增加、Retrieve查询、Update更新、Delete删除

通过Statement实现

@Test
/**
 * 保存操作的代码实现
 */
public void demo1(){
    Connection conn = null;
    Statement stmt = null;
    try{
        // 注册驱动:
        Class.forName("com.mysql.jdbc.Driver");
        // 获得连接:
        conn = DriverManager.getConnection("jdbc:mysql:///web_test3", "root", "abc");
        // 执行操作:
        // 创建执行SQL语句对象:
        stmt = conn.createStatement();
        // 编写SQL语句:
        String sql = "insert into user values (null,'eee','123','阿黄',21)";
        // 执行SQL语句:
        int num = stmt.executeUpdate(sql);
        if(num > 0){
            System.out.println("保存用户成功!!!");
        }
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        // 资源释放：
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

            stmt = null;
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            conn = null;
        }
    }
}



@Test
/**
 * 更新操作（update）的代码实现
 */
public void demo2(){
    Connection conn = null;
    Statement stmt  = null;
    try{
        // 注册驱动:
        Class.forName("com.mysql.jdbc.Driver");
        // 获得连接
        conn = DriverManager.getConnection("jdbc:mysql:///web_test3", "root", "abc");
        // 执行操作:
        // 创建执行SQL语句的对象:
        stmt = conn.createStatement();
        // 编写SQL语句：
        String sql = "update user set password='abc',nickname='旺财' where id = 5";
        // 执行SQL语句:
        int num = stmt.executeUpdate(sql);
        if(num > 0){
            System.out.println("修改用户成功!!!");
        }
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        // 资源释放：
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

            stmt = null;
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            conn = null;
        }
    }
}


@Test
/**
 * 查询多条记录
 */
public void demo4(){
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
    try{
        // 注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 获得连接
        conn = DriverManager.getConnection("jdbc:mysql:///web_test3", "root", "abc");
        // 执行操作
        // 创建执行SQL语句的对象:
        stmt = conn.createStatement();
        // 编写SQL:
        String sql = "select * from user";
        // 执行SQL:
        rs = stmt.executeQuery(sql);
        // 遍历结果集:
        while(rs.next()){
            System.out.println(rs.getInt("id")+" "+rs.getString("username")+" "+rs.getString("password"));
        }
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        // 资源释放：
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

            rs = null;
        }
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

            stmt = null;
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            conn = null;
        }
    }
}


@Test
/**
 * 查询一条记录
 */
public void demo5(){
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
    try{
        // 注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 获得连接
        conn = DriverManager.getConnection("jdbc:mysql:///web_test3", "root", "abc");
        // 执行SQL
        // 创建执行SQL语句对象:
        stmt = conn.createStatement();
        // 编写SQL:
        String sql = "select * from user where id = 4";
        rs = stmt.executeQuery(sql);
        // 判断就可以:
        if(rs.next()){
            System.out.println(rs.getInt("id")+" "+rs.getString("username")+" "+rs.getString("password"));
        }
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        // 资源释放：
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

            rs = null;
        }
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

            stmt = null;
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            conn = null;
        }
    }
}


@Test
/**
 * 删除操作的代码实现
 */
public void demo3(){
    Connection conn = null;
    Statement stmt = null;
    try{
        // 注册驱动:
        Class.forName("com.mysql.jdbc.Driver");
        // 获得连接:
        conn = DriverManager.getConnection("jdbc:mysql:///web_test3", "root", "abc");
        // 创建执行SQL语句对象:
        stmt = conn.createStatement();
        // 编写SQL:
        String sql = "delete from user where id = 5";
        // 执行SQL:
        int num = stmt.executeUpdate(sql);
        if(num > 0){
            System.out.println("删除用户成功！！！");
        }
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        // 资源释放：
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

            stmt = null;
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            conn = null;
        }
    }
}

通过PreparedStatement实现

@Test
/**
 * 保存操作
 */
public void demo1(){
	Connection conn = null;
	PreparedStatement pstmt = null;
	try{
           
		// 获得连接:
		conn = JDBCUtils.getConnection();
		// 编写SQL语句:
		String sql = "insert into user values (null,?,?,?,?)";
		// 预编译SQL:
		pstmt = conn.prepareStatement(sql);
		// 设置参数:
		pstmt.setString(1, "eee");
		pstmt.setString(2, "abc");
		pstmt.setString(3, "旺财");
		pstmt.setInt(4, 32);
		// 执行SQL
		int num = pstmt.executeUpdate();
		if(num > 0){
			System.out.println("保存成功！");
		}
           
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		JDBCUtils.release(pstmt, conn);
	}
}
  
  
@Test
/**
 * 修改操作
 */
public void demo2(){
	Connection conn = null;
	PreparedStatement pstmt = null;
	try{
		// 获得连接:
		conn = JDBCUtils.getConnection();
		// 编写SQL语句:
		String sql = "update user set username = ?,password =?,nickname=?,age = ? where id = ?";
		// 预编译SQL:
		pstmt = conn.prepareStatement(sql);
		// 设置参数:
		pstmt.setString(1, "abc");
		pstmt.setString(2, "1234");
		pstmt.setString(3, "旺旺");
		pstmt.setInt(4, 23);
		pstmt.setInt(5, 6);
		// 执行SQL：
		int num = pstmt.executeUpdate();
		if(num > 0){
			System.out.println("修改成功！");
		}
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		JDBCUtils.release(pstmt, conn);
	}
}
  
  
   @Test
/**
 * 删除操作
 */
public void demo3(){
	Connection conn = null;
	PreparedStatement pstmt  = null;
	try{
		// 获得连接：
		conn = JDBCUtils.getConnection();
		// 编写SQL语句:
		String sql = "delete from user where id = ?";
		// 预编译SQL
		pstmt = conn.prepareStatement(sql);
		// 设置参数:
		pstmt.setInt(1, 4);
		// 执行SQL:
		int num = pstmt.executeUpdate();
		if(num > 0){
			System.out.println("删除成功！");
		}
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		JDBCUtils.release(pstmt, conn);
	}
}
  
@Test
/**
 * 查询操作
 */
public void demo4(){
	Connection conn = null;
	PreparedStatement pstmt = null;
	ResultSet rs = null;
	try{
		// 获得连接:
		conn = JDBCUtils.getConnection();
		// 编写SQL:
		String sql = "select * from user";
		// 预编译SQL:
		pstmt = conn.prepareStatement(sql);
		// 设置参数:
		// 执行SQL:
		rs = pstmt.executeQuery();
		// 遍历结果集:
		while(rs.next()){
			System.out.println(rs.getInt("id")+" "+rs.getString("username")+" "+rs.getString("password")+" "+rs.getString("nickname"));
		}
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		JDBCUtils.release(rs, pstmt, conn);
	}
}

六、工具类的抽取

因为传统JDBC的开发，注册驱动，获得连接，释放资源这些代码都是重复编写的。所以可以将重复的代码提取到一个类中来完成。

/**
 * JDBC的工具类
 * @author jt
 *
 */
public class JDBCUtils {
	private static final String driverClassName;
	private static final String url;
	private static final String username;
	private static final String password;
	
	static{
		driverClassName="com.mysql.jdbc.Driver";
		url="jdbc:mysql:///web_test3";
		username="root";
		password="abc";
	}

	/**
	 * 1.注册驱动
	 */
	public static void loadDriver(){
		try {
			Class.forName(driverClassName);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	
    
	/**
	 * 2.获得连接
	 */
	public static Connection getConnection(){
		Connection conn = null;
		try{
			// 将驱动一并注册:
			loadDriver();
			// 获得连接
			conn = DriverManager.getConnection(url,username, password);
		}catch(Exception e){
			e.printStackTrace();
		}
		return conn;
	}
	
    
	/**
	 * 3.释放资源
	 */
	public static void release(Statement stmt,Connection conn){
		if(stmt != null){
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			
			stmt = null;
		}
		if(conn != null){
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			conn = null;
		}
	}
	
	public static void release(ResultSet rs,Statement stmt,Connection conn){
		// 资源释放：
		if(rs != null){
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			
			rs = null;
		}
		if(stmt != null){
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			
			stmt = null;
		}
		if(conn != null){
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			conn = null;
		}
	}
}

测试下工具类，具体如下：

@Test
/**
 * 查询操作：使用工具类
 */
public void demo1(){
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
    
    try{
        // 获得连接:
        conn = JDBCUtils.getConnection();
        // 创建执行SQL语句的对象:
        stmt = conn.createStatement();
        // 编写SQL:
        String sql = "select * from user";
        // 执行查询:
        rs = stmt.executeQuery(sql);
        // 遍历结果集:
        while(rs.next()){
            System.out.println(rs.getInt("id")+" "+rs.getString("username")+" "+rs.getString("password"));
        }
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        // 释放资源:
        JDBCUtils.release(rs, stmt, conn);
    }
}

七、配置文件

属性文件db.properties，其由key=value组成

定义配置文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://web_test3
username=root
password=abc

在工具类中解析属性文件

static{
    //获取属性文件中的内容
    Properties properties = new Properties();
	try{
        properties.load(new FileInputStream("src/db.properties"));
    } catch (FileNotFoundException e){
        e.printStackTrace();
    } catch (IOException e){
        e.printStackTrace();
    }
    
    driverClassname=properties. getproperty("driverClassName");
    url=properties.getproperty("url");
    username=properties.getproperty("username")
    password=properties.getproperty("password")
}

八、SQL注入漏洞

只知道用户名，无需密码即可完成登录。

原因分析：当采取用户名aaa’ or ‘1=1 时，select * from user where username = ‘“+username”’ and password = ‘“+password”’变成了select * from user where username = ‘aaa’ or ‘1=1’and password = ‘“+password”’，有一个or产生了，只要用户名存在即可通过。

解决方法：使用PreparedStatement对象替换掉Statement对象，将SQL预先进行编译，使用？作为占位符，之后再传入变量。

public class UserDao {
	
	public boolean login(String username,String password){
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
        
		// 定义一个变量:
		boolean flag = false;
		try{
			// 获得连接:
			conn = JDBCUtils.getConnection();
			// 编写SQL语句:
			String sql = "select * from user where username = ? and password = ?";
			// 预编译SQL
			pstmt = conn.prepareStatement(sql);
			// 设置参数:
			pstmt.setString(1, username);
			pstmt.setString(2, password);
			// 执行SQL语句:
			rs = pstmt.executeQuery();
			if(rs.next()){
				// 说明根据用户名和密码可以查询到这条记录
				flag = true;
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			JDBCUtils.release(rs, pstmt, conn);
		}
		return flag;
	}
}

/**
* SQL 注入漏洞
*/
public class JDBCDemo4{
    public void demo1(){
        UserDao userDao = new UserDao();
        boolean flag = userDao.login("aaa' or '1=1","qweerttyu");
        boolean flag = userDao.login("aaa' -- ","qweerttyu");
        if (flag){
            System.out.println("登陆成功");
        } else{
            System.out.println("登陆失败");
        }
    }
}

九、批处理

批量执行SQL语句

@Test
/**
 * 批处理基本操作
 */
public void demo1(){
	Connection conn = null;
	Statement stmt = null;
	try{
		// 获得连接:
		conn = JDBCUtils.getConnection();
		// 创建执行批处理对象:
		stmt = conn.createStatement();
           
		// 编写一批SQL语句：
		String sql1 = "create database test1";
		String sql2 = "use test1";
		String sql3 = "create table user(id int primary key auto_increment,name varchar(20))";
		String sql4 = "insert into user values (null,'aaa')";
		String sql5 = "insert into user values (null,'bbb')";
		String sql6 = "insert into user values (null,'ccc')";
		String sql7 = "update user set name = 'mmm' where id = 2";
		String sql8 = "delete from user where id = 1";
		// 添加到批处理
		stmt.addBatch(sql1);
		stmt.addBatch(sql2);
		stmt.addBatch(sql3);
		stmt.addBatch(sql4);
		stmt.addBatch(sql5);
		stmt.addBatch(sql6);
		stmt.addBatch(sql7);
		stmt.addBatch(sql8);
		// 执行批处理:
		stmt.executeBatch();
           
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		JDBCUtils.release(stmt, conn);
	}
}



@Test
/**
 * 批量插入记录:
 * * 默认情况下MySQL批处理没有开启的，需要在url后面拼接一个参数即可。
 */
public void demo2(){
	// 记录开始时间:
	long begin = System.currentTimeMillis();
       
	Connection conn = null;
	PreparedStatement pstmt = null;
       
	try{
		// 获得连接:
		conn = JDBCUtils.getConnection();
           
		// 编写SQL语句：
		String sql = "insert into user values (null,?)";
           
		// 预编译SQL:
		pstmt = conn.prepareStatement(sql);
           
		for(int i=1;i<=10000;i++){
               
			pstmt.setString(1, "name"+i);
               
			// 添加到批处理
			pstmt.addBatch();
			// 注意问题：
			// 一段时间执行一次批处理，避免内存溢出
			if(i % 1000 == 0){
				// 执行批处理:
				pstmt.executeBatch();
				// 清空批处理:
				pstmt.clearBatch();
			}
		}
           
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		JDBCUtils.release(pstmt, conn);
	}
       
	long end = System.currentTimeMillis();
	System.out.println((end-begin));
}

十、事务

事务指的是逻辑上的一组操作，组成这组操作的各个逻辑单元要么全部成功，要么全部失败。

环境准备：

创建数据库和表

create database web_test4;
use web_test4;
create table account(
	id int primary key auto_increment,
	name varchar(20),
	money double
);
insert into account values (null,'aaa',10000);
insert into account values (null,'bbb',10000);
insert into account values (null,'ccc',10000);

转账案例代码

@Test
/**
 * 完成转账的案例
 */
public void demo1(){
	Connection conn = null;
	PreparedStatement pstmt  = null;
	try{
		/**
		 * 完成转账代码：
		 * * 扣除某个账号的钱
		 * * 给另外一个账号加钱
		 */
           
		// 获得连接：
		conn = JDBCUtils.getConnection();
           
		// 编写SQL语句：
		String sql = "update account set money = money + ? where name = ?";
           
		// 预编译SQL:
		pstmt = conn.prepareStatement(sql);
           
		// 设置参数:
		// 用aaa账号给bbb账号转1000元
		pstmt.setDouble(1, -1000);
		pstmt.setString(2, "aaa");
           
		// 执行SQL：扣除aaa账号1000元
		pstmt.executeUpdate();
		
		// int i = 1 / 0;
         // 在转账中没有添加事务的管理，出现aaa账号的钱被转丢了，但是bbb账号的钱没有任何变化。需要给转账的功能添加事务的管理。
		 
		// 给bbb账号加1000
		pstmt.setDouble(1, 1000);
		pstmt.setString(2, "bbb");
		pstmt.executeUpdate();
           
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		JDBCUtils.release(pstmt, conn);
	}
}

事务管理API

setAutoCommit：此连接自动提交事务
commit：提交事务
rollback：回滚

@Test
/**
 * 完成转账的案例
 */
public void demo1(){
    Connection conn = null;
    PreparedStatement pstmt  = null;
    try{
        /**
         * 完成转账代码：
         * * 扣除某个账号的钱
         * * 给另外一个账号加钱
         */

        // 获得连接：
        conn = JDBCUtils.getConnection();
        // 开启事务
        conn.setAutoCommit(false);

        // 编写SQL语句：
        String sql = "update account set money = money + ? where name = ?";

        // 预编译SQL:
        pstmt = conn.prepareStatement(sql);

        // 设置参数:
        // 用aaa账号给bbb账号转1000元
        pstmt.setDouble(1, -1000);
        pstmt.setString(2, "aaa");
        // 执行SQL：扣除aaa账号1000元
        pstmt.executeUpdate();

        int i = 1 / 0;

        // 给bbb账号加1000
        pstmt.setDouble(1, 1000);
        pstmt.setString(2, "bbb");
        pstmt.executeUpdate();

        // 提交事务:
        conn.commit();

    }catch(Exception e){
        // 回滚事务,避免钱中途飞了
        try {
            conn.rollback();

        } catch (SQLException e1) {
            e1.printStackTrace();
        }
        e.printStackTrace();
    }finally{
        JDBCUtils.release(pstmt, conn);
    }
}

十一、连接池

1）概述

连接池是装有连接的容器，使用连接的话，可以从连接池中进行获取，使用完成之后将连接归还给连接池。

提升性能：连接对象创建和销毁是需要耗费时间的，在服务器初始化的时候就初始化一些连接。把这些连接放入到内存中，使用的时候可以从内存中获取，使用完成之后将连接放入连接池中。从内存中获取和归还的效率要远远高于创建和销毁的效率。

2）Druid 开源连接池

Druid是阿里旗下的开源连接池产品，使用非常简单，可以与Spring框架进行快速整合。

@Test
/**
 * Druid的使用:
 * * 手动设置参数的方式
 */
public void demo1(){
       
	Connection conn = null;
	PreparedStatement pstmt = null;
	ResultSet rs = null;
       
	try{
		// 使用连接池：
		DruidDataSource dataSource = new DruidDataSource();
           
		// 手动设置数据库连接的参数:
		dataSource.setDriverClassName("com.mysql.jdbc.Driver");
		dataSource.setUrl("jdbc:mysql:///web_test4");
		dataSource.setUsername("root");
		dataSource.setPassword("abc");
           
		// 获得连接：
		// conn = JDBCUtils.getConnection();
		conn = dataSource.getConnection();
           
		// 编写SQL:
		String sql = "select * from account";
           
		// 预编译SQL:
		pstmt = conn.prepareStatement(sql);
           
		// 设置参数:
		// 执行SQL:
		rs = pstmt.executeQuery();
		while(rs.next()){
			System.out.println(rs.getInt("id")+" "+rs.getString("name")+" "+rs.getDouble("money"));
		}
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		JDBCUtils.release(rs, pstmt, conn);
	}
}

也可以采用配置文件设置参数，从而使用Druid连接池

	@Test
	/**
	 * Druid的使用:
	 * * 配置方式设置参数
	 * Druid配置方式可以使用属性文件配置的。
	 * * 文件名称没有规定但是属性文件中的key要一定的。
	 */
	public void demo2(){
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try{
			// 使用连接池：
			// 从属性文件中获取：
			Properties properties = new Properties();
			properties.load(new FileInputStream("src/druid.properties"));
			DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
            
			// 获得连接：
//			conn = JDBCUtils.getConnection();
			conn = dataSource.getConnection();
            
			// 编写SQL:
			String sql = "select * from account";
            
			// 预编译SQL:
			pstmt = conn.prepareStatement(sql);
            
			// 设置参数:
			// 执行SQL:
			rs = pstmt.executeQuery();
			while(rs.next()){
				System.out.println(rs.getInt("id")+" "+rs.getString("name")+" "+rs.getDouble("money"));
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			JDBCUtils.release(rs, pstmt, conn);
		}
	}

3）C3P0 连接池

C3P0也是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准拓展。目前使用它的开源项目有Hibernate和Spring等。

手动设置参数

@Test
	/**
	 * 手动设置参数的方式:
	 */
	public void demo1(){
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try{
			// 获得连接：从连接池中获取：
			// 创建连接池：
			ComboPooledDataSource dataSource = new ComboPooledDataSource();
            
			// 设置连接参数:
			dataSource.setDriverClass("com.mysql.jdbc.Driver");
			dataSource.setJdbcUrl("jdbc:mysql:///web_test4");
			dataSource.setUser("root");
			dataSource.setPassword("abc");
            
			// 从连接池中获得连接:
			conn = dataSource.getConnection();
            
			// 编写SQL：
			String sql = "select * from account";
            
			// 预编译SQL:
			pstmt = conn.prepareStatement(sql);
            
			// 执行SQL：
			rs = pstmt.executeQuery();
            
			while(rs.next()){
				System.out.println(rs.getInt("id")+" "+rs.getString("name")+" "+rs.getDouble("money"));
                
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			JDBCUtils.release(rs, pstmt, conn);
		}
	}

采用配置文件的方式：

配置连接池

使用连接池

@Test
/**
 * 采用配置文件的方式：
 */
public void demo2(){
       
	Connection conn = null;
	PreparedStatement pstmt = null;
	ResultSet rs = null;
       
	try{
		// 获得连接：从连接池中获取：
		// 创建连接池：创建连接池默认去类路径下查找c3p0-config.xml
		ComboPooledDataSource dataSource = new ComboPooledDataSource(); // 可以指定名称，找不到时会使用默认的
           
		// 从连接池中获得连接:
		conn = dataSource.getConnection();
           
		// 编写SQL：
		String sql = "select * from account";
           
		// 预编译SQL:
		pstmt = conn.prepareStatement(sql);
           
		// 执行SQL：
		rs = pstmt.executeQuery();
           
		while(rs.next()){
			System.out.println(rs.getInt("id")+" "+rs.getString("name")+" "+rs.getDouble("money"));
		}
           
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		JDBCUtils.release(rs, pstmt, conn);
	}
}

4）改写工具类

连接池对象应该是一个应用只创建一次就可以的，不需要每次使用均创建一个新的连接池

十二、DBUtils

DBUtils是一个对JDBC进行简单封装的开源工具类库，将重复的代码（获得连接、预编译SQL、释放资源等）抽取出来放到工具类中，简化JDBC的编程。

1）API概述

核心运行类QueryRunner：

有参、无参构造均可

常用方法有update、query、batch等

// 一般情况下执行Crud操作
// 1.构造
QueryRunner(DataSource ds);
// 2.方法
int update(String sql,Object… args);
T query(String sql,ResultSetHandler rsh,Object… args);  // 执行SQL语句，返回结果对象


// 当有事务管理，且要执行CRUD时，
// 1.构造（不传入连接池）：
QueryRunner();
// 2.方法（参数包含连接）:
int update(Connection conn,String sql,Object… args);
T query(Connection conn,String sql,ResultSetHandler rsh,Object… args);

DbUtils类：
- commitAndCloseQuietly(connection conn)：提交连接然后关闭它
- rollbackAndCloseQuietly(connection conn)：回滚连接，然后关闭

2）增删查改示例

	@Test
	/**
	 * 添加、删除、修改操作，具体的操作由对应的sql语句区分，其他都一样
	 */
	public void demo1() throws SQLException{
		// 创建核心类：QueryRunner:
		QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
       // 调用update方法
		queryRunner.update("insert into account values (null,?,?)", "ddd",10000);
		queryRunner.update("delete from account where id = ?", 3);
		queryRunner.update("update account set name=?,money=? where id =?", "eee",20000,4);
	}


// 查询
// 1.查询一条记录
@Test
public class demo1 {
    // 创建核心类
    QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
    // 执行查询
    Account account = queryRunner.query("select * from account where id = ?", new ResultSetHandler<account>(){
        @Override
        public Account handle(ResultSet rs){
            Account account = new Account();
            if(rs.next()){
                account.setId(rs.getInt("id"));
                account.setName(rs.getString("name"));
                account.setMoney(rs.getDouble("money"));
            }
            return account;
        }
    },1);
    System.out.println(account);
}

// 2.查询多条记录
@Test
public class demo2 {
    // 创建核心类
    QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());

    // 执行查询
    Account account = queryRunner.query("select * from account", new ResultSetHandler<list<account>>(){
        @Override
        public List<Account> handle(ResultSet rs){
            // 创建集合来封装数据
            List<Account> list = new ArrayList<Account>();
            while(rs.next()){
                // 封装数据
                Account account = new Account();

                account.setId(rs.getInt("id"));
                account.setName(rs.getString("name"));
                account.setMoney(rs.getDouble("money"));

                list.add(account);
            }
            return list;
        }
    });

    // 显示
    for(Account account : list){
        System.out.println(account);
    }
}

3）ResultSetHandler实现类

ArrayHandler：将一条记录封装到一个Object数组中
ArrayListHandler：将多条记录封装到一个装有Object数组的集合中
BeanHandler：将一条记录封装到一个JavaBean中
BeanListHandler：将多条记录封装到一个装有JavaBean的List集合中
MapHandler：将一条记录封装到一个Map集合中，Map的key是列名，Map的value就是表中列的记录值
MapListHandler：将多条记录封装到一个装有Map的List集合中。
ColumnListHandler：将数据中的某列封装到List集合中
ScalarHandler：封装单个值

KeyedHandler：将一条记录封装到一个Map集合中。将多条记录封装到一个装有Map集合的Map集合中。而且外面的Map的key是可以指定的。

package com.itheima.dbutils.demo3;

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.ColumnListHandler;
import org.apache.commons.dbutils.handlers.KeyedHandler;
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.itheima.dbutils.domain.Account;
import com.itheima.jdbc.utils.JDBCUtils2;

/**
 * ResultSetHandler的实现类
 */
public class DBUtilsDemo3 {

	@Test
	/**
	 * ArrayHandler:将一条记录封装到一个Object数组中
	 */
	public void demo1() throws SQLException {
		QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
		Object[] objs = queryRunner.query("select * from account where id = ?", new ArrayHandler(), 1);
		System.out.println(Arrays.toString(objs));
	}

	@Test
	/**
	 * ArrayListHandler:将多条记录封装到一个装有Object数组的List集合中 *
	 * 一条记录封装到Objecct[]数组中，多条记录就是多个Object[]，那么多个Object数组就将其装入List集合中即可。
	 */
	public void demo2() throws SQLException {
		QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
		List<Object[]> list = queryRunner.query("select * from account", new ArrayListHandler());
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}
	}

	@Test
	/**
	 * BeanHandler：将一条记录封装到一个JavaBean中
	 */
	public void demo3() throws SQLException {
		QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
		Account account = queryRunner.query("select * from account where id = ?",
				new BeanHandler<Account>(Account.class), 2);
		System.out.println(account);
	}

	@Test
	/**
	 * BeanListHandler:将多条记录封装到一个装有JavaBean的List集合中。 
	 * *一条记录就是一个Java的对象（JavaBean），如果多条记录（多个Java的对象），将多个Java对象装到一个List集合中。
	 */
	public void demo4() throws SQLException {
		QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
		List<Account> list = queryRunner.query("select * from account ", new BeanListHandler<Account>(Account.class));
		for (Account account : list) {
			System.out.println(account);
		}
	}
	
    
    
    
	@Test
	/**
	 * MapHandler：将一条记录封装到一个Map集合中，Map的key是列名，Map的value就是表中列的记录值。
	 */
	public void demo5() throws SQLException{
		QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
		Map<String,Object> map = queryRunner.query("select * from account where id = ?", new MapHandler(), 4);
		System.out.println(map);
	}
	
	@Test
	/**
	 * MapListHandler：将多条记录封装到一个装有Map的List集合中。
	 */
	public void demo6() throws SQLException{
		QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
		List<Map<String,Object>> list = queryRunner.query("select * from account", new MapListHandler());
		for (Map<String, Object> map : list) {
			System.out.println(map);
		}
	}
    
    
    
	
	@Test
	/**
	 * ColumnListHandler：将某列的值封装到List集合中
	 */
	public void demo7() throws SQLException{
		QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
		List<Object> list = queryRunner.query("select name,money from account", new ColumnListHandler("name"));
		for (Object object : list) {
			System.out.println(object);
		}
	}
	
	@Test
	/**
	 * ScalarHandler:单值封装
	 */
	public void demo8() throws SQLException{
		QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
		Object obj = queryRunner.query("select count(*) from account", new ScalarHandler());
		System.out.println(obj);
	}
	
	@Test
	/**
	 * KeyedHandler：将一条记录封装到一个Map集合中。将多条记录封装到一个装有Map集合的Map集合中。而且外面的Map的key是可以指定的。
	 */
	public void demo9() throws SQLException{
		QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
		Map<Object,Map<String,Object>> map = queryRunner.query("select * from account", new KeyedHandler("id"));
		for (Object key : map.keySet()) {
			System.out.println(key+" "+map.get(key));
		}
	}
}

JavaWeb

JavaWEB Java JDBC

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议，转载请注明出处！

Spring使用手册上一篇

Servlet基础下一篇