本文介绍了JDBC的基本使用，包括加载数据库驱动、创建数据库连接、执行SQL语句（查询、插入、删除、更新）以及结果集的处理。还讨论了SQL注入问题和如何通过PrepareStatement防止。此外，文章提到了数据库事务的概念和ACID原则，并通过示例展示了如何在Java中实现转账事务。最后，简述了数据库连接池的作用和配置，如DBCP和C3P0，并提供了相关工具类的代码示例。
JDBC（重点）
用Java操作数据库
数据库驱动
驱动：声卡，显卡，数据库
数据库可以直接在电脑上使用，但是应用程序无法直接连接到数据库，中间需要驱动，不同的数据库有不同的驱动，这些驱动是由各数据库厂商提供的。
我们的程序会通过数据库驱动和数据库打交道。
JDBC
SUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个（Java操作数据库的）规范，俗称JDBC(Java DataBase Connection)，这些规范的实现由具体的厂商去做。
对于开发人员来说，只需要掌握JDBC的接口操作即可。
事实上，在架构里面没有什么是加一层解决不了的，如果有，就再加一层！
学习JDBC，主要学习两个包
- java.sql
- javax.sql
还需要导入一个数据库驱动包：mysql-connector-java-5.1.47.jar
第一个JDBC程序
准备工作：创建测试数据库
CREATE DATABASE `jdbcStudy` CHARACTER SET utf8 COLLATE utf8_general_ci;
USE `jdbcStudy`;
CREATE TABLE `users`(
`id` INT PRIMARY KEY,
`NAME` VARCHAR(40),
`PASSWORD` VARCHAR(40),
`email` VARCHAR(60),
birthday DATE
);
INSERT INTO `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)
VALUES('1','zhangsan','123456','zs@sina.com','1980-12-04'),
('2','lisi','123456','lisi@sina.com','1981-12-04'),
('3','wangwu','123456','wangwu@sina.com','1979-12-04')
-
使用IDEA创建一个普通项目
-
导入数据库驱动
-
编写代码
package JDBC; import java.sql.*; /** * 我的第一个JDBC程序 */ public class JdbcFirstDemo { public static void main(String[] args) throws ClassNotFoundException, SQLException { // 1.加载驱动 // 固定写法 Class.forName("com.mysql.jdbc.Driver"); // 2.连接信息（用户信息和url） String url = "jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=true"; String username = "root"; String password = "123456"; // 3.连接成功，返回数据库对象 Connection代表数据库 Connection connection = DriverManager.getConnection(url, username, password); // 4.执行SQL的对象 statement Statement statement = connection.createStatement(); // 5.用SQL的对象去执行SQL，可能存在结果，查看返回结果 String sql = "SELECT * FROM users"; /* 查询就会执行query，注意其他三个：删除、查询、更新都是更新，都叫做Update，查询完会返回一个结果集合 */ ResultSet resultSet = statement.executeQuery(sql); // 查询完会返回一个结果集合，这个结果集合中封装了所有的我们查询出来的结果 while (resultSet.next()) { System.out.println("id=" + resultSet.getObject("id")); System.out.println("name=" + resultSet.getObject("NAME")); System.out.println("pwd=" + resultSet.getObject("PASSWORD")); System.out.println("email=" + resultSet.getObject("email")); System.out.println("birthday=" + resultSet.getObject("birthday")); System.out.println("====================="); } // 6.释放连接 最早的最后释放 resultSet.close(); statement.close(); connection.close(); } }代码步骤总结：
- 加载驱动
- 连接数据库DriverManger
- 获得执行SQL的对Statement
- 获得返回的结果集
- 释放连接
JDBC中的对象分析
-
加载驱动部分解释
// 1.加载驱动 // 本来的写法： DriverManager.registerDriver(new com.mysql.jdbc.Driver()); // 固定写法 Class.forName("com.mysql.jdbc.Driver");进入Driver类源码，发现其中就是静态代码块用来注册驱动的。即已经帮我们注册好了。
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // package com.mysql.jdbc; import java.sql.DriverManager; import java.sql.SQLException; public class Driver extends NonRegisteringDriver implements java.sql.Driver { public Driver() throws SQLException { } static { try { DriverManager.registerDriver(new Driver()); } catch (SQLException var1) { throw new RuntimeException("Can't register driver!"); } } }使用反射Class.forName调用会默认对类进行初始化，类初始化的时候其实就已经执行了这段静态代码块了，所以不用去new，new的话反而多注册了一次。
-
URL
String url = "jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=true"; // mysql默认的端口号是3306 //jdbc:mysql://localhost:3306/数据库名?参数1&参数2&参数3 //jdbc:mysql://主机地址:端口号/数据库名?参数1&参数2&参数3... // oracle默认的端口号是1521 // jdbc:oracle:thin:@localhost:1521:sid // 把jdbc：mysql看做http这种协议的话 // 协议：//主机地址：端口号/数据库名?参数1&参数2&参数3 -
连接成功，获取数据库驱动对象
Connection connection = DriverManager.getConnection(url, username, password); // connection 代表一个数据库 // 数据库级别干的事情 // 数据库设置自动提交 connection.setAutoCommit(); // 事务提交 connection.commit(); // 回滚 connection.rollback(); -
执行SQL的对象statement
// 4.执行SQL的对象 statement Statement statement = connection.createStatement();除了Statement还有一个PrepareStatement也是执行SQL的对象
// 查询操作 返回ResultSet statement.executeQuery(); // 执行所有SQL，有个判断的过程，效率会降低一些 statement.execute(); // 更新、插入、删除都使用这个，返回值为匹配到的（受影响的）行数 statement.executeUpdate(); // 执行多条SQL（批处理） statement.executeBatch(); -
编写SQL
// 5.用SQL的对象去执行SQL，可能存在结果，查看返回结果 String sql = "SELECT * FROM users"; -
查询的结果集对象
这个结果集封装了所有的查询结果
使用方式：
-
获得指定的数据类型
// 在不知道列类型的情况下使用 resultSet.getObject(); // 如果知道列的类型就用指定的类型 resultSet.getString(); resultSet.getInt(); resultSet.getDouble(); ... -
遍历操作
while(resultSet.next()){} // 移动指针到最前面，从第一个数据开始查 resultSet.beforeFirst(); // 移动到最后 resultSet.afterLast(); // 移动到下一个数据 resultSet.next(); // 移动到前一行 resultSet.previous; // 移动到指定行 resultSet.absoulte(row);
-
-
释放连接，很消耗资源，一定要关掉
// 6.释放连接 最早的最后释放 resultSet.close(); statement.close(); connection.close();
statement对象
JDBC中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查的语句即可。
Statement对象的excuteUpdate方法，用于向数据库发送增删改的SQL语句，excuteUpdate执行完后，将会返回一个整数（即增删改语句导致了数据库几行数据发生了改变）
Statement.excuteQuery方法用于向数据库发送查询语句，excuteQuery方法返回代表查询结果的ResultSet对象。
-
CRUD操作-create
Statement st = conn.createStatement(); String sql = "insert into user(...,) values(...,)"; int num = st.excuteUpdate(sql); if(num>0){ System.out.println("插入成功!"); } -
CRUD操作-delete
Statement st = conn.createStatement(); String sql = "delete from user where id=1"; int num = st.excuteUpdate(sql); if(num>0){ System.out.println("删除成功!"); } -
CRUD操作-update
Statement st = conn.createStatement(); String sql = "update user set name='' where id=1"; int num = st.excuteUpdate(sql); if(num>0){ System.out.println("修改成功!"); } -
CRUD操作-Retrieve
Statement st = conn.createStatement(); String sql = "select * from user"; ResultSet rs = st.excuteQuery(sql); while(rs.next()){ //根据数据类型进行映射 }
使用代码实现CRUD
-
提取工具类
为什么要提取工具类？
因为只有SQL语句和结果在变化，其他语句都没有变化，一遍一遍写很烦，为了提高效率，我们把重复的内容提取为工具类，提高效率，放在Utils文件夹下。
此外，用户信息和URL可以放在配置文件中，以减少内容的重复。
package JDBC.lesson2.utils; import java.io.InputStream; import java.sql.*; import java.util.Properties; public class JdbcUtils { private static String driver = null; private static String url = null; private static String username = null; private static String password = null; static { try { InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties"); Properties properties = new Properties(); properties.load(in); driver = properties.getProperty("driver"); url = properties.getProperty("url"); username = properties.getProperty("username"); password = properties.getProperty("password"); // 1.驱动只用加载一次 Class.forName(driver); } catch (Exception e) { throw new RuntimeException(e); } } // 获取连接 public static Connection getConnection() throws SQLException { return DriverManager.getConnection(url, username, password); } // 释放连接资源 public static void release(Connection con, Statement st, ResultSet rs){ if (rs != null) { try { rs.close(); } catch (SQLException e) { throw new RuntimeException(e); } } if (st != null) { try { st.close(); } catch (SQLException e) { throw new RuntimeException(e); } } if (con != null) { try { con.close(); } catch (SQLException e) { throw new RuntimeException(e); } } } } -
测试插入代码
package JDBC.lesson2; import JDBC.lesson2.utils.JdbcUtils; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class TestInsert { public static void main(String[] args) { Connection conn = null; Statement st = null; ResultSet rs = null; try { // 获取数据库连接 conn = JdbcUtils.getConnection(); // 获得SQL的执行对象 st = conn.createStatement(); // JDBC 插入数据时，就算全部插入，也要写上所有要插入的字段名，不能省略 String sql = "INSERT INTO users(id, `Name`, `PASSWORD`, `email`, `birthday`)\n" + "VALUES(4,'liu','123456','123@qq.com','2002-11-11')"; int i = st.executeUpdate(sql); if (i > 0) { System.out.println("插入成功！"); } } catch (SQLException e) { throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, rs); } } } -
测试删除代码
package JDBC.lesson2; import JDBC.lesson2.utils.JdbcUtils; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class TestDelete { public static void main(String[] args) { Connection conn = null; Statement st = null; ResultSet rs = null; try { // 获取数据库连接 conn = JdbcUtils.getConnection(); // 获得SQL的执行对象 st = conn.createStatement(); String sql = "delete from users where id = 4"; int i = st.executeUpdate(sql); if (i > 0) { System.out.println("删除成功！"); } } catch (SQLException e) { throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, rs); } } } -
测试修改代码
package JDBC.lesson2; import JDBC.lesson2.utils.JdbcUtils; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class TestUpdate { public static void main(String[] args) { Connection conn = null; Statement st = null; ResultSet rs = null; try { // 获取数据库连接 conn = JdbcUtils.getConnection(); // 获得SQL的执行对象 st = conn.createStatement(); String sql = "UPDATE users SET `NAME`='liuliuliu',`email`='luck1y@firefox.com' WHERE `id` = 1"; int i = st.executeUpdate(sql); if (i > 0) { System.out.println("更新成功！"); } } catch (SQLException e) { throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, rs); } } } -
测试查询方法
package JDBC.lesson2; import JDBC.lesson2.utils.JdbcUtils; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class TestSelect { public static void main(String[] args) { Connection conn = null; Statement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnection(); st = conn.createStatement(); // SQL String sql = "SELECT * FROM users WHERE `id` = 1"; // 查询，查询完毕会返回一个结果集 rs = st.executeQuery(sql); while (rs.next()) { System.out.println(rs.getString("NAME")); } } catch (SQLException e) { throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, rs); } } }
SQL注入问题
SQL存在漏洞，会被攻击，导致数据泄露。
本质：SQL可以拼接，拼接关键字OR会导致语句不安全
package JDBC.lesson2;
import JDBC.lesson2.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class SQLInjection {
public static void main(String[] args) {
//正常登陆，不报错
// login("liuliuliu","123456");
//SQL注入，通过or欺骗服务器，将获得所有的数据
login("' or '1=1","' or '123456");
}
//登陆业务
public static void login(String username,String password){
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try{
conn = JdbcUtils.getConnection();
st = conn.createStatement();
//正常登陆：SELECT * FROM users WHERE `NAME`='liuliuliu' AND `password`= '123456'
//SQL注入：SELECT * FROM users WHERE `NAME`='' or '1=1' AND `password`= '' or '123456'
String sql = "SELECT * FROM users WHERE `NAME`='"+username+"' AND `password`= '"+password+"'";
rs = st.executeQuery(sql);
while (rs.next()){
System.out.println(rs.getString("NAME"));
System.out.println(rs.getString("password"));
System.out.println("==============================");
}
}catch (SQLException e){
e.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
PrepareStatement对象
PrepareStatement可以防止SQL注入，并且效率更好！所以一般使用它来进行增删改查。
-
插入
package JDBC.lesson3; import JDBC.lesson2.utils.JdbcUtils; import java.sql.Connection; import java.util.Date; import java.sql.PreparedStatement; import java.sql.SQLException; public class TestInsert { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; try { conn = JdbcUtils.getConnection(); // 区别 // 1.使用?占位符代替参数 String sql = "INSERT INTO users(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES(?,?,?,?,?)"; // 参数部分需要一个预编译的sql，先写SQL但不执行 st = conn.prepareStatement(sql); // 手动给参数赋值 st.setInt(1,5); st.setString(2,"Liu"); st.setString(3,"12312312"); st.setString(4,"1234543@qq.com"); // 注意：两个Date包的包名 // 数据库：java.sql.Date() // Java：java.util.Date() st.setDate(5,new java.sql.Date(new Date().getTime())); // 3.执行SQL int i = st.executeUpdate(); if (i > 0) { System.out.println("执行成功！"); } } catch (SQLException e) { throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, null); } } } -
删除
package JDBC.lesson3; import JDBC.lesson2.utils.JdbcUtils; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException; public class TestDelete { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; try { conn = JdbcUtils.getConnection(); // 区别 // 1.使用?占位符代替参数 String sql = "DELETE FROM users WHERE id=?"; // 参数部分需要一个预编译的sql，先写SQL但不执行 st = conn.prepareStatement(sql); // 手动给参数赋值 st.setInt(1, 5); // 3.执行SQL int i = st.executeUpdate(); if (i > 0) { System.out.println("删除成功！"); } } catch (SQLException e) { throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, null); } } } -
修改
package JDBC.lesson3; import JDBC.lesson2.utils.JdbcUtils; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException; public class TestUpdate { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; try { conn = JdbcUtils.getConnection(); // 区别 // 1.使用?占位符代替参数 String sql = "UPDATE users SET `NAME`=? WHERE id=?"; // 参数部分需要一个预编译的sql，先写SQL但不执行 st = conn.prepareStatement(sql); // 手动给参数赋值 st.setString(1, "刘子"); st.setInt(2, 1); // 3.执行SQL int i = st.executeUpdate(); if (i > 0) { System.out.println("更新成功！"); } } catch (SQLException e) { throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, null); } } } -
查询
package JDBC.lesson3; import JDBC.lesson2.utils.JdbcUtils; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class TestSelect { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnection(); String sql = "SELECT * FROM users WHERE id=?"; // 预编译 st = conn.prepareStatement(sql); // 传参 st.setInt(1,1); // 执行 rs = st.executeQuery(); if (rs.next()) { System.out.println(rs.getString("NAME")); } } catch (SQLException e) { throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, rs); } } } -
避免SQL注入的原理和测试
package JDBC.lesson3; import JDBC.lesson2.utils.JdbcUtils; import java.sql.*; public class SQLInjection { public static void main(String[] args) { //正常登陆，不报错 // login("lisi","123456"); //SQL注入，通过or欺骗服务器，将获得所有的数据 login("'' or 1=1", "123456"); } //登陆业务 public static void login(String username,String password){ Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try{ conn = JdbcUtils.getConnection(); // PrepareStatement 防止SQL注入的本质，把传递进来的参数当做字符 // 假设其中存在转义字符，比如''会被直接转义 String sql = "SELECT * FROM users WHERE `NAME`=? and `PASSWORD`=?"; st = conn.prepareStatement(sql); st.setString(1,username); st.setString(2,password); rs = st.executeQuery(); while (rs.next()){ System.out.println(rs.getString("NAME")); System.out.println(rs.getString("password")); System.out.println("=============================="); } }catch (SQLException e){ e.printStackTrace(); }finally { JdbcUtils.release(conn,st,rs); } } }
如何将IDEA作为管理数据库的可视化工具
由于新版的IDEA Community没有自带的DataBase管理工具，于是要去插件市场自行下载一个：DataBase Navigator
JDBC操作事务
要么都成功要么都失败
ACID原则：原子性、一致性、隔离性、持久性
原子性：要么全部完成，要么都不完成
一致性：事务前后总数不变
隔离性：多个进程互不干扰
持久性：一旦提交不可逆，持久化到数据库
用Java实现转账事务模拟
-
测试事务成功
package JDBC.lesson4; import JDBC.lesson2.utils.JdbcUtils; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class TestTransaction { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnection(); // 1.关闭数据库的自动提交，并自动开启事务 conn.setAutoCommit(false); String sql1 = "update account set money = money-100 where name = 'A'"; st = conn.prepareStatement(sql1); st.executeUpdate(); String sql2 = "update account set money = money+100 where name = 'B'"; st = conn.prepareStatement(sql2); st.executeUpdate(); // 2.业务完毕，提交事务 conn.commit(); System.out.println("操作成功！"); } catch (SQLException e) { try { // 如果失败就回滚业务 conn.rollback(); } catch (SQLException ex) { throw new RuntimeException(ex); } throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, rs); } } } -
测试事务失败
package JDBC.lesson4; import JDBC.lesson2.utils.JdbcUtils; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class TestTransaction1 { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnection(); // 1.关闭数据库的自动提交，并自动开启事务 conn.setAutoCommit(true); String sql1 = "update account set money = money-100 where `NAME` = 'A'"; st = conn.prepareStatement(sql1); st.executeUpdate(); // 模拟事务执行失败 int x = 1 / 0; String sql2 = "update account set money = money+100 where `NAME` = 'B'"; st = conn.prepareStatement(sql2); st.executeUpdate(); // 2.业务完毕，提交事务 conn.commit(); System.out.println("操作成功！"); } catch (SQLException e) { try { // 如果失败就回滚业务,默认就是会回滚的。因为 by zero 中断了程序，所以这句话并没有执行，但是还是发生了回滚 conn.rollback(); } catch (SQLException ex) { throw new RuntimeException(ex); } throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, rs); } } }
数据库连接池
数据库连接 – 执行完毕 – 释放 （从连接到释放是十分浪费系统资源的），所以出现了池化技术。
池化技术：准备一些预先的资源，过来就连接预先准备好的。
举例说明：
- 没用池化技术时：银行开门，只服务你一个人，服务后关门，下一位顾客来时再开门，如此重复。
- 用了池化技术后：银行开门，有若干个业务员在等待客户，来客户了直接服务，等到没有客户，服务器关闭，才关门。
所以在池化技术中，需要：
- 最小连接数：根据业务常用连接数来设定。
- 最大连接数：业务最高承载上限，超过最大连接数的就要等待。
- 等待超时：等到一定的时间，则发送异常，不要再等了。
编写线程池只需要实现一个接口：DataSource
此接口专门用来获得与数据库的连接：
- DBCP
- C3P0
- Druid：阿里巴巴的
使用了这些数据库连接池之后，在项目开发中就不需要编写连接数据库的代码了
-
DBCP
要用到两个包：commons-dbcp-1.4.jar 和 commons-pools-1.6.jar
导入到IDEA的lib中
-
配置文件 dbcpconfig.properties
#连接设置 关键字不要改动，这些是定义好的数据源要读取的 driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false username=root password=123456 #<!-- 初始化连接 --> initialSize=10 #最大连接数量 maxActive=50 #<!-- 最大空闲连接 --> maxIdle=20 #<!-- 最小空闲连接 --> minIdle=5 #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 --> maxWait=60000 #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：【属性名=property;】 #注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。 connectionProperties=useUnicode=true;characterEncoding=UTF8 #指定由连接池所创建的连接的自动提交（auto-commit）状态。 defaultAutoCommit=true #driver default 指定由连接池所创建的连接的只读（read-only）状态。 #如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix） defaultReadOnly= #driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。 #可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE defaultTransactionIsolation=READ_UNCOMMITTED -
工具类
package JDBC.lesson5.utils; import org.apache.commons.dbcp.BasicDataSource; import org.apache.commons.dbcp.BasicDataSourceFactory; import javax.sql.DataSource; import java.io.InputStream; import java.sql.*; import java.util.Properties; public class JdbcUtils_DBCP { private static DataSource dataSource = null; static { try { InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("db.properties"); Properties properties = new Properties(); properties.load(in); // 创建数据源 工厂模式--> 创建对象 dataSource = BasicDataSourceFactory.createDataSource(properties); } catch (Exception e) { throw new RuntimeException(e); } } //获取连接 public static Connection getConnection() throws SQLException { //从数据源中获取连接 return dataSource.getConnection(); } // 释放连接资源 public static void release(Connection con, Statement st, ResultSet rs){ if (rs != null) { try { rs.close(); } catch (SQLException e) { throw new RuntimeException(e); } } if (st != null) { try { st.close(); } catch (SQLException e) { throw new RuntimeException(e); } } if (con != null) { try { con.close(); } catch (SQLException e) { throw new RuntimeException(e); } } } } -
测试
package JDBC.lesson5; import JDBC.lesson2.utils.JdbcUtils; import JDBC.lesson5.utils.JdbcUtils_DBCP; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class TestDBCP { public static void main(String[] args) { Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try { /* 有变化的位置 */ conn = JdbcUtils_DBCP.getConnection(); // 1.关闭数据库的自动提交，并自动开启事务 conn.setAutoCommit(false); String sql1 = "update account set money = money-100 where `NAME` = 'A'"; st = conn.prepareStatement(sql1); st.executeUpdate(); String sql2 = "update account set money = money+100 where `NAME` = 'B'"; st = conn.prepareStatement(sql2); st.executeUpdate(); // 2.业务完毕，提交事务 conn.commit(); System.out.println("操作成功！"); } catch (SQLException e) { try { // 如果失败就回滚业务 conn.rollback(); } catch (SQLException ex) { throw new RuntimeException(ex); } throw new RuntimeException(e); } finally { JdbcUtils.release(conn, st, rs); } } }
-
-
C3P0
要用到两个包：mchange-commons-java-0.2.19.jar 和 c3p0-0.9.5.5.jar
导入到IDEA的lib中
-
配置文件（.xml)
<?xml version="1.0" encoding="UTF-8"?> <c3p0-config> <!-- c3p0的缺省（默认）配置 如果在代码中ComboPooledDataSource ds=new ComboPooledDataSource();这样写就表示使用的是c3p0的缺省（默认） --> <default-config> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false</property> <property name="user">root</property> <property name="password">123456</property> <property name="acquiredIncrement">5</property> <property name="initialPoolSize">10</property> <property name="minPoolSize">5</property> <property name="maxPoolSize">20</property> </default-config> <!-- c3p0的命名配置 如果在代码中ComboPooledDataSource ds=new ComboPooledDataSource("MySQL");这样写就表示使用的是name是MySQL --> <named-config name="MySQL"> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false</property> <property name="user">root</property> <property name="password">123456</property> <property name="acquiredIncrement">5</property> <property name="initialPoolSize">10</property> <property name="minPoolSize">5</property> <property name="maxPoolSize">20</property> </named-config> </c3p0-config> -
工具类
package JDBC.lesson5.utils; import com.mchange.v2.c3p0.ComboPooledDataSource; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class JdbcUtils_C3P0 { private static ComboPooledDataSource dataSource = null; static { try { // 创建数据源 工厂模式--> 创建对象 // 配置文件写法 dataSource = new ComboPooledDataSource("MySQL"); // 代码版配置（不推荐） // dataSource = new ComboPooledDataSource(); // dataSource.setDriverClass(); // dataSource.setUser(); } catch (Exception e) { throw new RuntimeException(e); } } //获取连接 public static Connection getConnection() throws SQLException { //从数据源中获取连接 return dataSource.getConnection(); } // 释放连接资源 public static void release(Connection con, Statement st, ResultSet rs){ if (rs != null) { try { rs.close(); } catch (SQLException e) { throw new RuntimeException(e); } } if (st != null) { try { st.close(); } catch (SQLException e) { throw new RuntimeException(e); } } if (con != null) { try { con.close(); } catch (SQLException e) { throw new RuntimeException(e); } } } } -
实现类
package JDBC.lesson5; import JDBC.lesson5.utils.JdbcUtils_C3P0; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class TestC3P0 { public static void main(String[] args) { Connection conn = null; Statement st = null; ResultSet rs = null; try { // 获取数据库连接 conn = JdbcUtils_C3P0.getConnection(); // 获得SQL的执行对象 st = conn.createStatement(); // JDBC 插入数据时，就算全部插入，也要写上所有要插入的字段名，不能省略 String sql = "INSERT INTO users(id, `Name`, `PASSWORD`, `email`, `birthday`)\n" + "VALUES(4,'liu','123456','123@qq.com','2002-11-11')"; int i = st.executeUpdate(sql); if (i > 0) { System.out.println("插入成功！"); } } catch (SQLException e) { throw new RuntimeException(e); } finally { JdbcUtils_C3P0.release(conn, st, rs); } } }
-
-
Druid后面会详细学习
结论：无论使用什么数据源，本质还是一样的，都是实现类DataSource接口，实现了getConnection方法。
扫一扫
1735
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
