一 、JDBC
1. 概念：Java DataBase Connectivity Java 数据库连接， Java语言操作数据库
JDBC本质其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。
2. 快速入门：
步骤：
- 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
* 复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
* 右键–>Add As Library
- 注册驱动
Class.forName(“com.mysql.jdbc.Driver”);- 获取数据库连接对象 Connection
Connection conn = DriverManager.getConnection(“jdbc:mysql://localhost:3306/db4”, “root”, “root”);- 定义sql
String sql = “UPDATE account SET balance = 2500 WHERE id = ‘1’”;- 通过连接对象创建执行sql的对象 Statement
Statement statement = conn.createStatement();- 执行sql，接受返回结果
int count = statement.executeUpdate(sql);- 处理结果
System.out.println(count);- 释放资源
statement.close();
conn.close();
代码实现：
-
表中的原数据：
-
项目机构
-
代码如下：
public class JdbcDemo { public static void main(String[] args) throws Exception { //1. 导入驱动jar包 //2.注册驱动 Class.forName("com.mysql.jdbc.Driver"); //3.获取数据库连接对象 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db4", "root", "root"); //4.定义sql语句 String sql = "UPDATE account SET balance = 2500 WHERE id = '1'"; //5.通过连接对象创建执行sql的对象 Statement Statement statement = conn.createStatement(); //6.执行sql int count = statement.executeUpdate(sql); //7.处理结果 System.out.println(count); //8.释放资源 statement.close(); conn.close(); } } -
结果如下：
-
数据更新后如下：
3. 详解各个对象：
⑴ DriverManager：驱动管理对象
功能：
① 注册驱动：告诉程序该使用哪一个数据库驱动jar
static void registerDriver(Driver driver):注册与给定的驱动程序 DriverManager 。
写代码使用： Class.forName("com.mysql.jdbc.Driver");
通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块
注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。
② 获取数据库连接：
方法：static Connection getConnection(String url, String user, String password)
参数：
- url：指定连接的路径
* 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
* 例子：jdbc:mysql://localhost:3306/db4
* 细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称 - user：用户名
- password：密码
⑵ Connection：数据库连接对象
功能：
① 获取执行sql 的对象
* Statement createStatement()
* PreparedStatement prepareStatement(String sql)
②管理事务：
* 开启事务：setAutoCommit(boolean autoCommit)：调用该方法设置参数为false，即开启事务
* 提交事务：commit()
* 回滚事务：rollback()
⑶ Statement：执行sql的对象
执行sql
① boolean execute(String sql)：可以执行任意的sql 了解
② int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句
返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则执行成功，反之，则失败。
③ ResultSet executeQuery(String sql) ：执行DQL（select)语句
练习：
account表 添加一条记录录
代码如下：
public class JdbcDemoPlus {
public static void main(String[] args) {
Connection conn = null;
Statement statement = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取数据库连接对象
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db4", "root", "root");
//3.定义sql语句
String sql = "INSERT INTO account (id,NAME,balance) VALUES(3,'wangwu',1000)";
//4.通过连接对象创建执行sql的对象 Statement
statement = conn.createStatement();
//5.执行sql
int count = statement.executeUpdate(sql);
System.out.println(count);
if(count > 0){
System.out.println("添加成功！");
}else{
System.out.println("添加失败！");
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}finally {
//6. 释放资源
//避免空指针异常
if(statement != null){
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
⑷ ResultSet：结果集对象,封装查询结果
① boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true
② getXxx(参数):获取数据
* Xxx：代表数据类型 如： int getInt() , String getString()
* 参数类型：
1. int：代表列的编号,从1开始 如： getString(1)
2. String：代表列名称。 如： getDouble(“balance”)
注意：
使用步骤：
1. 游标向下移动一行
2. 判断是否有数据
3. 获取数据
例如：
//游标向下移动一行，并判断游标是否是最后一行末尾。
while(rs.next()){
//获取数据
int id = rs.getInt(1);
String name = rs.getString(“name”);
double balance = rs.getDouble(3);
System.out.println(id + “—” + name + “—” + balance);
}
例如：
public class JdbcDemoPlus {
public static void main(String[] args) {
Connection conn = null;
Statement statement = null;
ResultSet resultSet = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取数据库连接对象
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db4", "root", "root");
//3.定义sql语句
String sql = "select * from account";
//4.通过连接对象创建执行sql的对象 Statement
statement = conn.createStatement();
//5.执行sql
resultSet = statement.executeQuery(sql);
while (resultSet.next()){
//6.获取数据
int id = resultSet.getInt(1);
String name = resultSet.getString("name");
double balance = resultSet.getDouble(3);
System.out.println(id+":"+name +":"+balance);
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}finally {
//7. 释放资源
//避免空指针异常
if(resultSet != null){
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(statement != null){
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
结果如下：
⑸ PreparedStatement：执行sql的对象
① SQL注入问题：
在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
输入用户随便，输入密码：a’ or ‘a’ = 'a
sql：select * from user where username = ‘fhdsjkf’ and password = ‘a’ or ‘a’ = ‘a’
代码如下：
public class JdbcDemoPlus {
public static void main(String[] args) {
Connection conn = null;
Statement statement = null;
ResultSet resultSet = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取数据库连接对象
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db4", "root", "root");
//2.1键盘录入，接受用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String username = sc.nextLine();
System.out.println("请输入密码：");
String password = sc.nextLine();
//3.定义sql语句
String sql = "SELECT * FROM USER WHERE username = '"+username+"' AND PASSWORD = '"+password+"' ";
System.out.println(sql);
//4.通过连接对象创建执行sql的对象 Statement
statement = conn.createStatement();
//5.执行sql
resultSet = statement.executeQuery(sql);
if (resultSet.next()){
System.out.println("登录成功!!!");
}else{
System.out.println("账号或者密码错误！！！");
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}finally {
//7. 释放资源
//避免空指针异常
if(resultSet != null){
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(statement != null){
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
结果如下：
② 解决sql注入问题：使用PreparedStatement对象来解决
预编译的SQL：参数使用?作为占位符
步骤：
- 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
- 注册驱动
- 获取数据库连接对象 Connection
- 定义sql
- 注意：sql的参数使用？作为占位符。 如：select * from user where username = ? and password = ?;
- 获取执行sql语句的对象 PreparedStatement Connection.prepareStatement(String sql)
- 给？赋值：
* 方法： setXxx(参数1,参数2)
* 参数1：？的位置编号 从1 开始
* 参数2：？的值- 执行sql，接受返回结果，不需要传递sql语句
- 处理结果
- 释放资源
代码如下：
public class JdbcDemoPlus {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pst = null;
ResultSet resultSet = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取数据库连接对象
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db4", "root", "root");
//2.1键盘录入，接受用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String username = sc.nextLine();
System.out.println("请输入密码：");
String password = sc.nextLine();
//3.定义sql语句
String sql = "SELECT * FROM USER WHERE username = ? AND PASSWORD = ? ";
//4.通过连接对象创建执行sql的对象 prepareStatement
pst = conn.prepareStatement(sql);
//5. 设置参数
pst.setString(1,username);
pst.setString(2,password);
//6.执行sql
resultSet = pst.executeQuery();
if (resultSet.next()){
System.out.println("登录成功!!!");
}else{
System.out.println("账号或者密码错误！！！");
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}finally {
//7. 释放资源
//避免空指针异常
if(resultSet != null){
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(pst != null){
try {
pst.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
结果如下：
注意：后期都会使用
PreparedStatement来完成增删改查的所有操作
1. 可以防止SQL注入
2. 效率更高
4. 抽取JDBC工具类 ： JDBCUtils
⑴ 目的：简化书写
⑵分析：
① 注册驱动也抽取
② 抽取一个方法获取连接对象
- 需求：不想传递参数（麻烦），还得保证工具类的通用性。
- 解决：配置文件
jdbc.properties
url=
user=
password=
③ 抽取一个方法释放资源
代码如下：
-
项目结构：
-
配置文件
-
工具类
public class JdbcUtil { private static String url; private static String user; private static String password; private static String driver; /** * 文件的读取，只需要读取一次即可拿到这些值。使用静态代码块 */ static{ try { //读取资源文件，获取值。 //1. 创建Properties集合类。 Properties pro = new Properties(); //获取src路径下的文件的方式--->ClassLoader 类加载器 ClassLoader classLoader = JdbcUtil.class.getClassLoader(); URL res = classLoader.getResource("jdbc.properties"); String path = res.getPath(); System.out.println(path);///E:/project/kejizhentan-jdbc/out/production/kejizhentan-jdbc/jdbc.properties //2.加载文件 pro.load(new FileReader(path)); //3. 获取数据，赋值 url = pro.getProperty("url"); user = pro.getProperty("user"); password = pro.getProperty("password"); driver = pro.getProperty("driver"); System.out.println(url+"=>"+user+"=>"+password+"=>"+driver); //4.注册驱动 Class.forName(driver); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } } /** * 获取连接 * @return 连接对象 */ public static Connection getConnection() throws SQLException { return DriverManager.getConnection(url,user,password); } /** * 释放资源 * @param pst * @param conn */ public static void close(PreparedStatement pst, Connection conn){ if( pst != null){ try { pst.close(); } catch (SQLException e) { e.printStackTrace(); } } if( conn != null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } /** * 释放资源 * @param rs * @param pst * @param conn */ public static void close(ResultSet rs, PreparedStatement pst, Connection conn){ if( rs != null){ try { rs.close(); } catch (SQLException e) { e.printStackTrace(); } } if( pst != null){ try { pst.close(); } catch (SQLException e) { e.printStackTrace(); } } if( conn != null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } } -
工具类的使用
/** * @Description: 测试JdbcUtil工具类 * @Author: kejizhentan * @Version: 1.0 */ public class JdbcUtilTest { public static void main(String[] args) { Connection conn = null; PreparedStatement pst = null; ResultSet resultSet = null; try { //1.通过工具类获取数据库连接对象 conn = JdbcUtil.getConnection(); //2.定义sql语句 String sql ="select * from account where name = ?"; //3.通过连接对象获取PreparedStatement对象 pst = conn.prepareStatement(sql); //4.设置参数 pst.setString(1,"zhangsan"); //5.执行sql resultSet = pst.executeQuery(); //遍历结果集 while(resultSet.next()){ System.out.println(resultSet.getInt(1)+":"+resultSet.getString(2)+":"+resultSet.getDouble(3)); } } catch (SQLException e) { e.printStackTrace(); }finally { //6.关闭资源 JdbcUtil.close(resultSet,pst,conn); } } } -
结果如下：
5. JDBC控制事务
⑴ 事务使用不当造成的后果
以转账为例
-
账户中原有的数据
-
不加事务的代码如下：
JDBC工具类：public class JdbcUtil { private static String url; private static String user; private static String password; private static String driver; /** * 文件的读取，只需要读取一次即可拿到这些值。使用静态代码块 */ static{ try { //读取资源文件，获取值。 //1. 创建Properties集合类。 Properties pro = new Properties(); //获取src路径下的文件的方式--->ClassLoader 类加载器 ClassLoader classLoader = JdbcUtil.class.getClassLoader(); URL res = classLoader.getResource("jdbc.properties"); String path = res.getPath(); //2.加载文件 pro.load(new FileReader(path)); //3. 获取数据，赋值 url = pro.getProperty("url"); user = pro.getProperty("user"); password = pro.getProperty("password"); driver = pro.getProperty("driver"); //4.注册驱动 Class.forName(driver); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } } /** * 获取连接 * @return 连接对象 */ public static Connection getConnection() throws SQLException { return DriverManager.getConnection(url,user,password); } /** * 释放资源 * @param pst * @param conn */ public static void close(PreparedStatement pst, Connection conn){ if( pst != null){ try { pst.close(); } catch (SQLException e) { e.printStackTrace(); } } if( conn != null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } /** * 释放资源 * @param rs * @param pst * @param conn */ public static void close(ResultSet rs, PreparedStatement pst, Connection conn){ if( rs != null){ try { rs.close(); } catch (SQLException e) { e.printStackTrace(); } } if( pst != null){ try { pst.close(); } catch (SQLException e) { e.printStackTrace(); } } if( conn != null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } }真正的代码
public class TransactionTest { public static void main(String[] args) { Connection conn = null; PreparedStatement pstmt1 = null; PreparedStatement pstmt2 = null; try { //1.获取连接 conn = JdbcUtil.getConnection(); //2.定义sql语句 //2.1 张三 - 500 String sql1 = "update account set balance = balance - ? where id = ?"; //2.2 李四 + 500 String sql2 = "update account set balance = balance + ? where id = ?"; //3.通过连接获取PreparedStatement pstmt1 = conn.prepareStatement(sql1); pstmt2 = conn.prepareStatement(sql2); //4.设置参数 //4.1张三的账号 pstmt1.setDouble(1,500); pstmt1.setInt(2,1); //4.2李四的账号 pstmt2.setDouble(1,500); pstmt2.setInt(2,2); //执行sql pstmt1.executeUpdate(); // 手动制造异常 int i = 3/0; pstmt2.executeUpdate(); System.out.println("执行完毕"); } catch (SQLException e) { e.printStackTrace(); }finally { //5.关闭资源 JdbcUtil.close(pstmt1,conn); JdbcUtil.close(pstmt2,null); } } } -
执行结果如下：
-
账户中的数据
因为没有加事务，导致张三钱虽然扣了，但是李四并没有收到钱。这位显然是不合理的。
⑵ 事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。
① 操作：
- 开启事务
- 提交事务
- 回滚事务
② 使用Connection对象来管理事务
- 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
* 在执行sql之前开启事务 - 提交事务：commit()
* 当所有sql都执行完提交事务 - 回滚事务：rollback()
* 在catch中回滚事务
代码如下
-
账户中原有的数据
-
加事务的代码如下：
JDBC工具类：public class JdbcUtil { private static String url; private static String user; private static String password; private static String driver; /** * 文件的读取，只需要读取一次即可拿到这些值。使用静态代码块 */ static{ try { //读取资源文件，获取值。 //1. 创建Properties集合类。 Properties pro = new Properties(); //获取src路径下的文件的方式--->ClassLoader 类加载器 ClassLoader classLoader = JdbcUtil.class.getClassLoader(); URL res = classLoader.getResource("jdbc.properties"); String path = res.getPath(); //2.加载文件 pro.load(new FileReader(path)); //3. 获取数据，赋值 url = pro.getProperty("url"); user = pro.getProperty("user"); password = pro.getProperty("password"); driver = pro.getProperty("driver"); //4.注册驱动 Class.forName(driver); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } } /** * 获取连接 * @return 连接对象 */ public static Connection getConnection() throws SQLException { return DriverManager.getConnection(url,user,password); } /** * 释放资源 * @param pst * @param conn */ public static void close(PreparedStatement pst, Connection conn){ if( pst != null){ try { pst.close(); } catch (SQLException e) { e.printStackTrace(); } } if( conn != null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } /** * 释放资源 * @param rs * @param pst * @param conn */ public static void close(ResultSet rs, PreparedStatement pst, Connection conn){ if( rs != null){ try { rs.close(); } catch (SQLException e) { e.printStackTrace(); } } if( pst != null){ try { pst.close(); } catch (SQLException e) { e.printStackTrace(); } } if( conn != null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } }真正的代码
public class TransactionTest { public static void main(String[] args) { Connection conn = null; PreparedStatement pstmt1 = null; PreparedStatement pstmt2 = null; try { //1.获取连接 conn = JdbcUtil.getConnection(); //开启事务 conn.setAutoCommit(false); //2.定义sql语句 //2.1 张三 - 500 String sql1 = "update account set balance = balance - ? where id = ?"; //2.2 李四 + 500 String sql2 = "update account set balance = balance + ? where id = ?"; //3.通过连接获取PreparedStatement pstmt1 = conn.prepareStatement(sql1); pstmt2 = conn.prepareStatement(sql2); //4.设置参数 //4.1张三的账号 pstmt1.setDouble(1,500); pstmt1.setInt(2,1); //4.2李四的账号 pstmt2.setDouble(1,500); pstmt2.setInt(2,2); //执行sql pstmt1.executeUpdate(); // 手动制造异常 int i = 3/0; pstmt2.executeUpdate(); //提交事务 conn.commit(); System.out.println("执行完毕"); } catch (SQLException e) { //事务回滚 try { if(conn != null) { conn.rollback(); } } catch (SQLException e1) { e1.printStackTrace(); } e.printStackTrace(); }finally { //5.关闭资源 JdbcUtil.close(pstmt1,conn); JdbcUtil.close(pstmt2,null); } } } -
执行结果如下：
-
账户中的数据
如果代码出现异常，将回滚数据。这样实现了事务的同时成功和同时失败。
二、 数据库连接池
1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。
当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。
2. 好处：
- 节约资源
- 用户访问高效
3. 实现：
-
标准接口：
DataSourcejavax.sql包下的
① 方法：- 获取连接：
getConnection() - 归还连接：
Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接
② 一般我们不去实现它，由数据库厂商来实现
C3P0：数据库连接池技术Druid：数据库连接池实现技术，由阿里巴巴提供的
- 获取连接：
4. C3P0：数据库连接池技术
① 步骤：
-
导入jar包 (两个)
c3p0-0.9.5.2.jarmchange-commons-java-0.2.12.jar
不要忘记导入数据库驱动jar包(总共三个jar包) -
定义配置文件：
名称： c3p0.properties 或者 c3p0-config.xml
路径：直接将文件放在src目录下即可。 -
创建核心对象 数据库连接池对象 ComboPooledDataSource
-
获取连接： getConnection
代码如下：
-
包
-
项目结构
-
配置文件
<c3p0-config> <!-- 使用默认的配置读取连接池对象 --> <default-config> <!-- 连接参数 --> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql://localhost:3306/db4</property> <property name="user">root</property> <property name="password">root</property> <!-- 连接池参数 --> <!--初始化申请的连接数量--> <property name="initialPoolSize">5</property> <!--最大的连接数量--> <property name="maxPoolSize">10</property> <!--超时时间--> <property name="checkoutTimeout">3000</property> </default-config> <named-config name="otherc3p0"> <!-- 连接参数 --> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql://localhost:3306/db3</property> <property name="user">root</property> <property name="password">root</property> <!-- 连接池参数 --> <property name="initialPoolSize">5</property> <property name="maxPoolSize">8</property> <property name="checkoutTimeout">1000</property> </named-config> </c3p0-config> -
功能代码
public class C3p0Datasoure { public static void main(String[] args) { Connection conn = null; PreparedStatement pst = null; ResultSet resultSet = null; try { //1.创建数据库连接池对象 DataSource ds = new ComboPooledDataSource(); //2. 获取连接对象 conn = ds.getConnection(); //3.定义sql语句 String sql = "select * from account where id = ?"; //4.通过连接对象获取 pst = conn.prepareStatement(sql); //5.通过pst设置参数 pst.setInt(1,1); //通过pst执行sql resultSet = pst.executeQuery(); while(resultSet.next()){ System.out.println(resultSet.getInt(1)+":"+resultSet.getString(2)+":"+resultSet.getDouble(3)); } } catch (SQLException e) { e.printStackTrace(); }finally { if(resultSet != null){ try { resultSet.close(); } catch (SQLException e) { e.printStackTrace(); } } if(pst != null){ try { pst.close(); } catch (SQLException e) { e.printStackTrace(); } } if(resultSet != null){ try { resultSet.close(); } catch (SQLException e) { e.printStackTrace(); } } } } } -
结果如下：
5. Druid：数据库连接池实现技术，由阿里巴巴提供的(相对而言比较常用)
① 步骤：
- **导入jar包
druid-1.0.9.ja**r
不要忘记导入数据库驱动jar包(总共两个jar包) - 定义配置文件：
- 是properties形式的
- 可以叫任意名称，可以放在任意目录下
- 加载配置文件。Properties
- 获取数据库连接池对象：通过工厂来来获取
DruidDataSourceFactory - 获取连接：getConnection
代码：
//3.加载配置文件
Properties pro = new Properties();
InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream(“druid.properties”);
pro.load(is);
//4.获取连接池对象
DataSource ds = DruidDataSourceFactory.createDataSource(pro);
//5.获取连接
Connection conn = ds.getConnection();
② 定义工具类
- 定义一个类 JDBCUtils
- 提供静态代码块加载配置文件，初始化连接池对象
- 提供方法
1. 获取连接方法：通过数据库连接池获取连接
2. 释放资源
3. 获取连接池的方法
代码如下：
-
包
-
项目结构
-
配置文件
driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql:///db4 username=root password=root # 初始化连接数量 initialSize=5 # 最大连接数 maxActive=10 # 最大等待时间 maxWait=3000 -
功能代码
工具类/** * Druid连接池的工具类 */ public class DatasourceUtil { //1.定义成员变量 DataSource private static DataSource ds ; static{ try { //1.加载配置文件 Properties pro = new Properties(); pro.load(DatasourceUtil.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(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; } }功能代码
public class DruidDatasource { public static void main(String[] args) { Connection conn = null; PreparedStatement pstmt = null; ResultSet resultSet = null; try { //1.获取连接 conn = DatasourceUtil.getConnection(); //2.定义sql String sql = "select * from account where id = ?"; //3.获取pstmt对象 pstmt = conn.prepareStatement(sql); //4.设置参数 pstmt.setInt(1,1); //5.执行sql resultSet = pstmt.executeQuery(); while(resultSet.next()){ System.out.println(resultSet.getInt(1)+":"+resultSet.getString(2)+":"+resultSet.getDouble(3)); } } catch (SQLException e) { e.printStackTrace(); }finally { //释放资源 DatasourceUtil.close(resultSet,pstmt,conn); } } } -
结果如下
三、 Spring JDBC
Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
⑴ 步骤：
- 导入jar包
- 创建
JdbcTemplate对象。依赖于数据源DataSource
JdbcTemplate template = new JdbcTemplate(ds); - 调用JdbcTemplate的方法来完成
CRUD的操作-
update():执行DML语句。增、删、改语句 -
queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
注意：这个方法查询的结果集长度只能是1 -
queryForList():查询结果将结果集封装为list集合
注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中 -
query():查询结果，将结果封装为JavaBean对象query的参数：RowMapper
一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
new BeanPropertyRowMapper<类型>(类型.class) -
queryForObject：查询结果，将结果封装为对象
一般用于聚合函数的查询
-
练习：
需求：
1. 修改1号数据的 salary 为 10000
2. 添加一条记录
3. 删除刚才添加的记录
4. 查询id为1的记录，将其封装为Map集合
5. 查询所有记录，将其封装为List
6. 查询所有记录，将其封装为Emp对象的List集合
7. 查询总记录数
-
包
-
项目结构
-
配置文件
driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql:///db4 username=root password=root # 初始化连接数量 initialSize=5 # 最大连接数 maxActive=10 # 最大等待时间 maxWait=3000 -
account的实体类对象
public class Account { private int id; private String name; private double balance; public Account() { } public Account(int id, String name, double balance) { this.id = id; this.name = name; this.balance = balance; } 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 getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Account account = (Account) o; return id == account.id && Double.compare(account.balance, balance) == 0 && Objects.equals(name, account.name); } @Override public int hashCode() { return Objects.hash(id, name, balance); } @Override public String toString() { return "Account{" + "id=" + id + ", name='" + name + '\'' + ", balance=" + balance + '}'; } } -
获取连接池的工具类
/** * Druid连接池的工具类 */ public class DatasourceUtil { //1.定义成员变量 DataSource private static DataSource ds ; static{ try { //1.加载配置文件 Properties pro = new Properties(); pro.load(DatasourceUtil.class.getClassLoader().getResourceAsStream("druid.properties")); //2.获取DataSource ds = DruidDataSourceFactory.createDataSource(pro); } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } } /** * 获取连接池方法 */ public static DataSource getDataSource(){ return ds; } } -
单元测试类
public class JDBCTemplate { //1. 获取JDBCTemplate对象 private JdbcTemplate template = new JdbcTemplate(com.kejizhean.demo.DatasourceUtil.getDataSource()); /** * 1. 修改1号数据的 balance 为 10000 */ @Test public void test1(){ //1.定义sql String sql = "update account set balance = 10000 where id = 1"; //2.执行sql int count = template.update(sql); System.out.println(count); } /** * 2. 添加一条记录 */ @Test public void test2(){ String sql = "insert into account(id,name,balance) values(?,?,?)"; int count = template.update(sql, 3, "wangwu", 1222); System.out.println(count); } /** * 3.删除刚才添加的记录 */ @Test public void test3(){ String sql = "delete from account where id = ?"; int count = template.update(sql, 3); System.out.println(count); } /** * 4.查询id为1的记录，将其封装为Map集合 * 注意：这个方法查询的结果集长度只能是1 */ @Test public void test4(){ String sql = "select * from account where id = ?"; Map<String, Object> map = template.queryForMap(sql, 1); System.out.println(map);//{id=1, NAME=zhangsan, balance=10000.0} } /** * 5. 查询所有记录，将其封装为List */ @Test public void test5(){ String sql = "select * from account"; List<Map<String, Object>> list = template.queryForList(sql); for (Map<String, Object> stringObjectMap : list) { System.out.println(stringObjectMap); } } /** * 6. 查询所有记录，将其封装为Emp对象的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 account = new Account(); account.setId(rs.getInt("id")); account.setName(rs.getString("name")); account.setBalance(rs.getDouble("balance")); return account; } }); for (Account account : list) { System.out.println(account); } } /** * 6_2. 查询所有记录，将其封装为Emp对象的List集合 */ @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"; Long total = template.queryForObject(sql, Long.class); System.out.println(total); } }
260
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
