目录
//JDBC就是使用Java语言操作关系型数据库的一套API
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
/**
* JDBC快速入门
*/
public class JDBCDemo {
public static void main(String[] args) throws Exception {
//1. 注册驱动
//Class.forName("com.mysql.jdbc.Driver");
//2. 获取连接
String url = "jdbc:mysql://127.0.0.1:3306/db1";
String username = "root";
String password = "1234";
Connection conn = DriverManager.getConnection(url, username, password);
//3. 定义sql
String sql = "update account set money = 2000 where id = 1";
//4. 获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
//5. 执行sql
int count = stmt.executeUpdate(sql);//受影响的行数
//6. 处理结果
System.out.println(count);
//7. 释放资源
stmt.close();
conn.close();
}
}
JDBC简介
1、JDBC概念
JDBC就是使用Java语言操作关系型数据库的一套API
全称:( Java DataBase Connectivity ) Java 数据库连接
2、sun公司指定了一套标准接口(JDBC),JDBC中定义了所有操作关系型数据库的规则。
众所周知接口是无法直接使用的,我们需要使用接口的实现类,
而这套实现类(称之为:驱动)就由各自的数据库厂商给出。
3、JDBC本质
官方(sun公司)定义的一套操作所有关系型数据库的规则,即接口
各个数据库厂商去实现这套接口,提供数据库驱动jar包
我们可以使用这套接口(JDBC)编程,真正执行的代码是驱动jar包中的实现类
4、JDBC好处
各数据库厂商使用相同的接口,Java代码不需要针对不同数据库分别开发
可随时替换底层数据库,访问数据库的Java代码基本不变
以后编写操作数据库的代码只需要面向JDBC(接口),操作哪儿个关系型数据库就需要导入该数据库的驱动包,
如需要操作MySQL数据库,就需要再项目中导入MySQL数据库的驱动包。
JDBC快速入门
编写代码步骤
Java操作数据库的流程
第一步:编写Java代码
第二步:Java代码将SQL发送到MySQL服务端
第三步:MySQL服务端接收到SQL语句并执行该SQL语句
第四步:将SQL语句执行的结果返回给Java代码
编写代码步骤:
创建工程,导入驱动jar包
注册驱动
Class.forName("com.mysql.jdbc.Driver");
获取连接
Connection conn = DriverManager.getConnection(url, username, password);
Java代码需要发送SQL给MySQL服务端,就需要先建立连接
定义SQL语句
String sql = “update.” ;
获取执行SQL对象
执行SQL语句需要SQL执行对象,而这个执行对象就是Statement对象
Statement stmt = conn.createStatement();
执行SQL
stmt.executeUpdate(sql);
处理返回结果
释放资源
具体操作
创建新的空的项目
定义项目的名称,并指定位置
对项目进行设置,JDK版本、编译版本
创建模块,指定模块的名称及位置
导入驱动包
将mysql的驱动包放在模块下的lib目录(随意命名)下,并将该jar包添加为库文件
在添加为库文件的时候,有如下三个选项
Global Library : 全局有效
Project Library : 项目有效
Module Library : 模块有效
在src下创建类
编写代码如下
数据库代码:
package com.green.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
/**
* JDBC的快速入门
*/
public class JDBCDemo {
public static void main(String[] args) throws Exception {
//1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接
String url = "jdbc:mysql://127.0.0.1:3306/db1";
String username = "root";//数据库用户名
String password = "1234";//数据库密码
Connection conn = DriverManager.getConnection(url, username, password);
//3、定义SQL
String sql = "update account set money = 2000 where id = 1"; //修改表account id=1 的money=2000
//4、获取执行sql对象Statement
Statement stmt = conn.createStatement();
//5、执行sql
int count = stmt.executeUpdate(sql);//受影响的行数
//6、处理结果
System.out.println(count);
//7、释放资源
stmt.close();
conn.close();
}
}
JDBC API详解
DriverManager
DriverManager(驱动管理类)作用:
注册驱动
registerDriver方法是用于注册驱动的,但是我们之前做的入门案例并不是这样写的。而是如下实现
Class.forName("com.mysql.jdbc.Driver");
查询MySQL提供的Driver类,看它是如何实现的,源码如下:
在该类中的静态代码块中已经执行了 DriverManager 对象的registerDriver()
方法进行驱动的注册了,那么我们只需要加载 Driver 类,该静态代码块就会执行。
而Class.forName("com.mysql.jdbc.Driver"); 就可以加载Driver 类。
==提示:==
MySQL 5之后的驱动包,可以省略注册驱动的步骤
自动加载jar包中META-INF/services/java.sql.Driver文件中的驱动类
获取数据库连接
参数说明:
url : 连接路径
语法:jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2.
示例:jdbc:mysql://127.0.0.1:3306/db1
==细节:==
如果连接的是本机mysql服务器,并且mysql服务默认端口是3306,则url可以简写为:jdbc:mysql:///数据库名称?参数键值对
配置 useSSL=false 参数,禁用安全连接方式,解决警告提示
user :用户名
poassword :密码
Connection
Connection(数据库连接对象)作用:
获取执行 SQL 的对象
管理事务
获取执行对象
普通执行SQL对象
Statement createStatement()
入门案例中就是通过该方法获取的执行对象
预编译SQL的执行SQL对象:防止SQL注入
PreparedStatement prepareStatement(sql)
通过这种方式获取的 PreparedStatement SQL语句执行对象,它可以防止SQL注入。
执行存储过程的对象
CallableStatement prepareCall(sql)
通过这种方式获取的 CallableStatement 执行对象是用来执行存储过程的,
而存储过程在MySQL中不常用
事务管理
开启事务 : BEGIN; 或者 START TRANSACTION;
提交事务 : COMMIT;
回滚事务 : ROLLBACK;
MySQL默认是自动提交事务
JDBC事务管理的方法
Connection几口中定义了3个对应的方法:
开启事务
void setAutoCommit(boolean autoCommit)
参与autoCommit 表示是否自动提交事务,true表示自动提交事务,
false表示手动提交事务。而开启事务需要将该参数设为为false。
提交事务
void commit()
回滚事务
void rollback()
package com.green.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
* JDBC API详解 :DriverManager
*/
public class JDBCDemo3_Connection {
public static void main(String[] args) throws Exception {
//1、注册驱动
//Class.forName("com.mysql.jdbc.Driver"); //MySQL 5之后的驱动包,可以省略注册驱动的步骤
//2、获取连接
//如果连接的是本机mysql服务器,并且mysql服务默认端口是3306,则url可以简写为:jdbc:mysql:///数据库名称?参数键值对
//String url = "jdbc:mysql:///db1";
String url = "jdbc:mysql:///db1?useSSL=false";//配置 useSSL=false 参数,禁用安全连接方式,解决警告提示
String username = "root";//数据库用户名
String password = "123456";//数据库密码
Connection conn = DriverManager.getConnection(url, username, password);
//3、定义SQL
String sql1 = "update account set money = 3000 where id = 1";
String sql2 = "update account set money = 3000 where id = 2";
//4、获取执行sql对象Statement
Statement stmt = conn.createStatement();
try {
//开启事务
conn.setAutoCommit(false);//手动提交事务
//5、执行sql
int count1 = stmt.executeUpdate(sql1);//受影响的行数
//6、处理结果
System.out.println(count1);
int i = 3 / 0;
//5、执行sql
int count2 = stmt.executeUpdate(sql2);//受影响的行数
//6、处理结果
System.out.println(count2);
//提交事务
conn.commit();
} catch (SQLException throwables) {
//回滚事务
conn.rollback();
throwables.printStackTrace();
}
//7、释放资源
stmt.close();
conn.close();
}
}
Statement
概述
Statement对象的作用就是用来执行SQL语句。而针对不同类型的SQL语句使用的方法也不一样。
int executeUpdate(sql):执行DDL、DML语句
返回值:(1)DML语句影响的行数 (2)DDL语句执行后,执行成功也可能返回0
ResultSet executeQuery(sql):执行DQL语句
返回值:ResultSet结果集对象
package com.green.jdbc;
import org.junit.jupiter.api.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
* JDBC的快速入门
*/
public class JDBCDemo4_Statement {
/**
* 执行DML语句(增删改)
*
* @throws Exception
*/
@Test
public void testDML() throws Exception {
//1、注册驱动
//Class.forName("com.mysql.jdbc.Driver"); //MySQL 5之后的驱动包,可以省略注册驱动的步骤
//2、获取连接
//如果连接的是本机mysql服务器,并且mysql服务默认端口是3306,则url可以简写为:jdbc:mysql:///数据库名称?参数键值对
//String url = "jdbc:mysql:///db1";
String url = "jdbc:mysql:///db1?useSSL=false";//配置 useSSL=false 参数,禁用安全连接方式,解决警告提示
String username = "root";//数据库用户名
String password = "123456";//数据库密码
Connection conn = DriverManager.getConnection(url, username, password);
//3、定义SQL
String sql = "update account set money = 3000 where id = 1"; //执行完DML语句,受影响的行数
String sql1 = "insert into account(name,money)values('王五',1000)";
//4、获取执行sql对象Statement
Statement stmt = conn.createStatement();
//5、执行sql
int count = stmt.executeUpdate(sql);//受影响的行数
int count1 = stmt.executeUpdate(sql1);//受影响的行数
//6、处理结果
System.out.println(count);
System.out.println(count1);
if (count > 0) {
System.out.println("修改成功~");
} else {
System.out.println("修改失败~");
}
//7、释放资源
stmt.close();
conn.close();
}
/**
* 执行DDL语句
*
* @throws Exception
*/
@Test
public void testDDL() throws Exception {
//1、注册驱动
//Class.forName("com.mysql.jdbc.Driver"); //MySQL 5之后的驱动包,可以省略注册驱动的步骤
//2、获取连接
//如果连接的是本机mysql服务器,并且mysql服务默认端口是3306,则url可以简写为:jdbc:mysql:///数据库名称?参数键值对
//String url = "jdbc:mysql:///db1";
String url = "jdbc:mysql:///db1?useSSL=false";//配置 useSSL=false 参数,禁用安全连接方式,解决警告提示
String username = "root";//数据库用户名
String password = "123456";//数据库密码
Connection conn = DriverManager.getConnection(url, username, password);
//3、定义SQL
//String sql = "create database db2";
String sql1 = "drop database db2";
//4、获取执行sql对象Statement
Statement stmt = conn.createStatement();
//5、执行sql
//int count = stmt.executeUpdate(sql);//受影响的行数
int count1 = stmt.executeUpdate(sql1);//受影响的行数
//6、处理结果
//System.out.println(count);
System.out.println(count1);//DDL语句执行后,执行成功也可能返回0
// if(count > 0){
// System.out.println("修改成功~");
// }else{
//
// System.out.println("修改失败~");
// }
//7、释放资源
stmt.close();
conn.close();
}
}
注意:
以后开发很少使用java代码操作DDL语句
ResultSet
概述
ResultSet(结果集对象)作用:
-- 封装了SQL查询语句的结果。
而执行了DQL语句后就会返回该对象,对应执行DQL语句的方法如下:
ResultSet executeQuery(sql):执行DQL 语句,返回ResultSet 对象
ResultSet 对象提供了操作查询结果数据的方法,如下:
boolean next()
(1)将光标从当前位置向前移动一行(2)判断当前行是否为有效行
方法返回值说明:
true : 有效行,当前行有数据
false :无效行,当前行没有数据
xxx getXxx(参数):获取数据
xxx : 数据类型;如: int getInt(参数) ;String getString(参数)
参数
int类型的参数:列的编号,从1开始 例:getInt(1);
String类型的参数: 列的名称 例:getInt("id");
开始光标指定于第一行前,如图所示红色箭头指向于表头行。当我们调用了 next() 方法后,
光标就下移到第一行数据,并且方法返回true,此时就可以通过 getInt("id") 获取当前行id字段的值,
也可以通过 getString("name") 获取当前行name字段的值。
如果想获取下一行的数据,继续调用 next() 方法,以此类推。
package com.green.jdbc;
import org.junit.jupiter.api.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
/**
* JDBC的快速入门
*/
public class JDBCDemo5_ResultSet {
/**
* 执行DQL语句(查询)
*
* @throws Exception
*/
@Test
public void testResultSet() throws Exception {
//1、注册驱动
//Class.forName("com.mysql.jdbc.Driver"); //MySQL 5之后的驱动包,可以省略注册驱动的步骤
//2、获取连接
//如果连接的是本机mysql服务器,并且mysql服务默认端口是3306,则url可以简写为:jdbc:mysql:///数据库名称?参数键值对
//String url = "jdbc:mysql:///db1";
String url = "jdbc:mysql:///db1?useSSL=false";//配置 useSSL=false 参数,禁用安全连接方式,解决警告提示
String username = "root";//数据库用户名
String password = "123456";//数据库密码
Connection conn = DriverManager.getConnection(url, username, password);
//3、定义SQL
String sql = "select * from account";
//4、获取statement对象
Statement stmt = conn.createStatement();
//5、执行SQL
ResultSet rs = stmt.executeQuery(sql);
//6、处理结果 遍历rs中的所有数据
//6.1 光标向下移动一行,并且判断当前行是否有数据
/*while (rs.next()){
//6.2 获取数据 getXxx()
int id = rs.getInt(1);
String name = rs.getString(2);
double money = rs.getDouble(3);
System.out.println(id);
System.out.println(name);
System.out.println(money);
System.out.println("--------------");
}*/
while (rs.next()) {
//6.2 获取数据 getXxx()
int id = rs.getInt("id");
String name = rs.getString("name");
double money = rs.getDouble("money");
System.out.println(id);
System.out.println(name);
System.out.println(money);
System.out.println("--------------");
}
//7、释放资源
rs.close();
stmt.close();
conn.close();
}
}
案例
需求:查询account账户表数据,封装为Account对象中,并且存储到ArrayList集合中
package com.green.jdbc;
import com.green.pojo.Account;
import org.junit.jupiter.api.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
public class JDBCDemo5_ResultSet {
/**
* 查询account账户表数据,封装为Account对象中,并且存储到ArrayList集合中
* 1、定义实体类Account
* 2、查询数据,封装到Account对象中去
* 3、将Account对象存进ArrayList集合
* @throws Exception
*/
@Test
public void testResultSet2() throws Exception {
//1、注册驱动
//Class.forName("com.mysql.jdbc.Driver"); //MySQL 5之后的驱动包,可以省略注册驱动的步骤
//2、获取连接
//如果连接的是本机mysql服务器,并且mysql服务默认端口是3306,则url可以简写为:jdbc:mysql:///数据库名称?参数键值对
//String url = "jdbc:mysql:///db1";
String url = "jdbc:mysql:///db1?useSSL=false";//配置 useSSL=false 参数,禁用安全连接方式,解决警告提示
String username = "root";//数据库用户名
String password = "123456";//数据库密码
Connection conn = DriverManager.getConnection(url, username, password);
//3、定义SQL
String sql = "select * from account";
//4、获取statement对象
Statement stmt = conn.createStatement();
//5、执行SQL
ResultSet rs = stmt.executeQuery(sql);
//6、处理结果 遍历rs中的所有数据
//6.1 光标向下移动一行,并且判断当前行是否有数据
//创建集合
List<Account> list = new ArrayList<>();
while (rs.next()) {
//6.2 获取数据 getXxx()
int id = rs.getInt("id");
String name = rs.getString("name");
double money = rs.getDouble("money");
//创建Account对象
Account account = new Account();
//赋值
account.setId(id);
account.setName(name);
account.setMoney(money);
//存入集合
list.add(account);
}
System.out.println(list);
//7、释放资源
rs.close();
stmt.close();
conn.close();
}
}
PreparedStatement
PreparedStatement作用:
预编译SQL语句并执行:预防SQL注入问题
SQL注入是通过操作输入来修改事先定义好的SQL语句,用以达到执行代码对服务器进行攻击的方法。
代码模拟SQL注入问题
package com.green.jdbc;
import org.junit.jupiter.api.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
/**
* 用户登录
*/
public class JDBCDemo6_PreparedStatement {
@Test
public void testLogin() throws Exception {
//2、获取连接
String url = "jdbc:mysql:///db1?useSSL=false";
String username = "root";//数据库用户名
String password = "123456";//数据库密码
Connection conn = DriverManager.getConnection(url, username, password);
//接受用户输入的 用户名和密码
String name = "zhangsan";
String pwd = "1234";
//3、定义SQL
String sql = "select * from tb_user where username = '" + name + "' and password = '" + pwd + "' ";
//获取stmt对象
Statement stmt = conn.createStatement();
//执行SQL
ResultSet rs = stmt.executeQuery(sql);
//判断是否登录成功
if (rs.next()) {
System.out.println("登录成功~~");
} else {
System.out.println("登录失败~~");
}
//释放资源
rs.close();
stmt.close();
conn.close();
}
/**
* 演示SQL注入
*
* @throws Exception
*/
@Test
public void testLogin_Inject() throws Exception {
//2、获取连接
String url = "jdbc:mysql:///db1?useSSL=false";
String username = "root";//数据库用户名
String password = "123456";//数据库密码
Connection conn = DriverManager.getConnection(url, username, password);
//接受用户输入的 用户名和密码
String name = "jdhusbdhus";
String pwd = "' or '1' = '1";//sql注入语句
//3、定义SQL
String sql = "select * from tb_user where username = '" + name + "' and password = '" + pwd + "' ";
System.out.println(sql);//打印sql语句
//select * from tb_user where username = 'jdhusbdhus' and password = '' or '1' = '1'
//获取stmt对象
Statement stmt = conn.createStatement();
//执行SQL
ResultSet rs = stmt.executeQuery(sql);
//判断是否登录成功
if (rs.next()) {
System.out.println("登录成功~~");
} else {
System.out.println("登录失败~~");
}
//释放资源
rs.close();
stmt.close();
conn.close();
}
}
上面代码是将用户名和密码拼接到sql语句中,拼接后的sql语句如下
select * from tb_user where username = 'sjdljfld' and password = ''or '1' = '1'
从上面语句可以看出条件 username = 'sjdljfld' and password = '' 不管是否满足,
而 or 后面的 '1' = '1' 是始终满足的,最终条件是成立的,就可以正常的进行登陆了。
PreparedStatement概述
PreparedStatement作用:
预编译SQL语句并执行:预防SQL注入问题
① 获取 PreparedStatement 对象
// SQL语句中的参数值,使用?占位符替代
String sql = "select * from user where username = ? and password = ?";
// 通过Connection对象获取,并传入对应的sql语句PreparedStatement pstmt = conn.prepareStatement(sql);
②设置参数值
上面的sql语句中参数使用 ? 进行占位,在之前之前肯定要设置这些 ? 的值。
PreparedStatement对象:setXxx(参数1,参数2):给 ? 赋值
Xxx:数据类型 ; 如 setInt (参数1,参数2)
参数:
参数1: ?的位置编号,从1 开始
参数2: ?的值
执行SQL语句
executeUpdate(); 执行DDL语句和DML语句
executeQuery(); 执行DQL语句
==注意:==
调用这两个方法时不需要传递SQL语句,因为获取SQL语句执行对象时已经对SQL语句进行预编译了。
使用PreparedStatement改进
package com.green.jdbc;
import org.junit.jupiter.api.Test;
import java.sql.*;
/**
* API详解:PreparedStatement
*/
public class JDBCDemo6_PreparedStatement {
/**
* 使用PreparedStatement改进
*
* @throws Exception
*/
@Test
public void testLogin_Inject() throws Exception {
//2、获取连接
String url = "jdbc:mysql:///db1?useSSL=false";
String username = "root";//数据库用户名
String password = "123456";//数据库密码
Connection conn = DriverManager.getConnection(url, username, password);
//接受用户输入的 用户名和密码
String name = "jdhusbdhus";
String pwd = "' or '1' = '1";//sql注入语句
//3、定义SQL
String sql = "select * from tb_user where username = ? and password = ?";
//System.out.println(sql);//打印sql语句
//select * from tb_user where username = 'jdhusbdhus' and password = '' or '1' = '1'
//获取pstmt对象
PreparedStatement pstmt = conn.prepareStatement(sql);
//设置?的值
pstmt.setString(1, name);
pstmt.setString(2, pwd);
//执行SQL
ResultSet rs = pstmt.executeQuery();
//判断是否登录成功
if (rs.next()) {
System.out.println("登录成功~~");
} else {
System.out.println("登录失败~~");
}
//释放资源
rs.close();
pstmt.close();
conn.close();
}
}
PreparedStatement原理
PreparedStatement 好处:
预编译SQL,性能更高
防止SQL注入:==将敏感字符进行转义==
Java代码操作数据库流程:
将sql语句发送到MySQL服务器端
MySQL服务端会对sql语句进行如下操作
检查SQL语句
检查SQL语句的语法是否正确。
编译SQL语句。将SQL语句编译成可执行的函数。
检查SQL和编译SQL花费的时间比执行SQL的时间还要长。如果只是重新设置参数,
那么检查SQL语句和编译SQL语句将不需要重复执行。这样就提高了性能。
执行SQL语句
开启预编译功能:useServerPrepStmts=true
配置MySQL执行日志(重启mysql服务后生效) 在mysql配置文件(my.ini)中添加如下配置
log-output=FILE
general-log=1
general_log_file="D:\mysql.log" slow-query-log=1
slow_query_log_file="D:\mysql_slow.log" long_query_time=2
==小结:==
在获取PreparedStatement对象时,将sql语句发送给mysql服务器进行检查,编译(这些步骤很耗时)
执行时就不用再进行这些步骤了,速度更快
如果sql模板一样,则只需要进行一次检查、编译
package com.green.jdbc;
import org.junit.jupiter.api.Test;
import java.sql.*;
/**
* API详解:PreparedStatement
*/
public class JDBCDemo6_PreparedStatement {
/**
* 使用PreparedStatement改进
*
* @throws Exception
*/
@Test
public void testLogin_Inject1() throws Exception {
//useServerPrepStmts=true 设置预编译的参数
String url = "jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true";
String username = "root";//数据库用户名
String password = "123456";//数据库密码
Connection conn = DriverManager.getConnection(url, username, password);
//接受用户输入的 用户名和密码
String name = "jdhusbdhus";
String pwd = "' or '1' = '1";//sql注入语句
//3、定义SQL
String sql = "select * from tb_user where username = ? and password = ?";
//获取pstmt对象
PreparedStatement pstmt = conn.prepareStatement(sql);
//设置?的值
pstmt.setString(1, name);
pstmt.setString(2, pwd);
//执行SQL
ResultSet rs = pstmt.executeQuery();
//判断是否登录成功
if (rs.next()) {
System.out.println("登录成功~~");
} else {
System.out.println("登录失败~~");
}
//释放资源
rs.close();
pstmt.close();
conn.close();
}
}
执行SQL语句,查看 D:\mysql.log 日志如下:
上图中第六行中的 Prepare 是对SQL语句进行预编译
数据库连接池
数据库连接池简介
数据库连接池是个容器,负责分配、管理数据库连接(Connection)
它允许应用程序重复使用一个现有的数据库连接,而不是再重新建立一个;
释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏
好处
资源重用
提升系统响应速度
避免数据库连接遗漏
之前我们代码中使用连接是没有使用都创建一个Connection对象,使用完毕就会将其销毁。
这样重复创建销毁的过程是特别耗费计算机的性能的及消耗时间的。
而数据库使用了数据库连接池后,就能达到Connection对象的复用,如下图
连接池是在一开始就创建好了一些连接(Connection)对象存储起来。用户需要连接数据库时,不需要自己创建连接,
而只需要从连接池中获取一个连接进行使用,使用完毕后再将连接对象归还给连接池;
这样就可以起到资源重用,也节省了频繁创建连接销毁连接所花费的时间,从而提升了系统响应的速度。
数据库连接池实现
标准接口:==DataSource==
官方(SUN) 提供的数据库连接池标准接口,由第三方组织实现此接口。该接口提供了获取连接的功能:
Connection getConnection()
那么以后就不需要通过 DriverManager 对象获取 Connection对象,
而是通过连接池(DataSource)获取 Connection 对象。
常见的数据库连接池
DBCP
C3P0
Druid
使用更多的是Druid,它的性能比其他两个会好一些。Druid(德鲁伊)
Druid连接池是阿里巴巴开源的数据库连接池项目
功能强大,性能优秀,是Java语言最好的数据库连接池之一
Driud使用
导入jar包 druid-1.1.12.jar
定义配置文件
加载配置文件
获取数据库连接池对象
获取连接
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true
username=root
password=1234
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000
package com.green.druid;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.util.Properties;
public class DruidDemo {
public static void main(String[] args) throws Exception {
//1、导入jar包
//2、定义配置文件
//3、加载配置文件
Properties prop = new Properties();
prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
//System.out.println(System.getProperty("user.dir")); //当前文件目录 D:\code\JDBC
//4、获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//5、获取数据库连接 Connection
Connection conn = dataSource.getConnection();
System.out.println(conn);
}
}
JDBC练习
需求
完成商品品牌数据的增删改查操作
查询:查询所有数据
添加:添加品牌
修改:根据id修改
删除:根据id删除
案例实现
环境准备
数据库表 tb_brand
实体类 Brand
测试用例
-- 删除tb_brand表
drop table if exists tb_brand;
-- 创建tb_brand表
create table tb_brand (
-- id 主键
id int primary key auto_increment,
-- 品牌名称
brand_name varchar(20),
-- 企业名称
company_name varchar(20),
-- 排序字段
ordered int,
-- 描述信息
description varchar(100),
-- 状态:0:禁用 1:启用status int
);
-- 添加数据
insert into tb_brand (brand_name, company_name, ordered, description, status)
values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织,构建万物互联的智能世界', 1),
('小米', '小米科技有限公司', 50, 'are you ok', 1);
package com.green.pojo;
/**
* 实体类 品牌
* alt + 鼠标左键 整列编辑
* 在实体类中,基本数据类型建议使用其对应的包装类型
*/
public class Brand {
// id 主键
private Integer id;
// 品牌名称
private String brandName;
// 企业名称
private String companyName;
// 排序字段
private Integer ordered;
// 描述信息
private String description;
// 状态:0:禁用 1:启用
private Integer status;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getBrandName() {
return brandName;
}
public void setBrandName(String brandName) {
this.brandName = brandName;
}
public String getCompanyName() {
return companyName;
}
public void setCompanyName(String companyName) {
this.companyName = companyName;
}
public Integer getOrdered() {
return ordered;
}
public void setOrdered(Integer ordered) {
this.ordered = ordered;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
@Override
public String toString() {
return "Brand{" +
"id=" + id +
", brandName='" + brandName + '\'' +
", companyName='" + companyName + '\'' +
", ordered=" + ordered +
", description='" + description + '\'' +
", status=" + status +
'}';
}
}
查询所有
1、获取Connection
2、定义SQL:select * from tb_brand;
3、获取PreparedStatement对象
4、设置参数:不需要
5、执行SQL
6、处理结果:List<Brand>
7、释放资源
package com.green.example;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.green.pojo.Brand;
import org.junit.jupiter.api.Test;
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
/**
* 品牌数据的增删改查操作
*/
public class BrandTest {
/*1、获取Connection
2、定义SQL:select * from tb_brand;
3、获取PreparedStatement对象
4、设置参数:不需要
5、执行SQL
6、处理结果:List<Brand>
7、释放资源*/
@Test
public void testSelectAll() throws Exception {
//1、获取Connection
//1.1、加载配置文件
Properties prop = new Properties();
prop.load(new FileInputStream("src/druid.properties"));
//1.2、获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//1.3、获取数据库连接 Connection
Connection conn = dataSource.getConnection();
//2、定义SQL:select * from tb_brand;
String sql = "select * from tb_brand";
//3、获取PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement(sql);
//4、设置参数:不需要
//5、执行SQL
ResultSet resultSet = pstmt.executeQuery();
//6、处理结果:List<Brand> 封装Brand对象,装载到List集合
List<Brand> list = new ArrayList<>(); //创建集合对象
while (resultSet.next()) {
//获取数据 getXxx()
int id = resultSet.getInt("id");
String brandName = resultSet.getString("brand_name");
String companyName = resultSet.getString("company_name");
int ordered = resultSet.getInt("ordered");
String description = resultSet.getString("description");
int status = resultSet.getInt("status");
//封装数据
Brand brand = new Brand();
brand.setId(id);
brand.setBrandName(brandName);
brand.setCompanyName(companyName);
brand.setOrdered(ordered);
brand.setDescription(description);
brand.setStatus(status);
list.add(brand);//装载集合
}
System.out.println(list);
//7.释放资源
resultSet.close();
pstmt.close();
conn.close();
}
}
添加:添加数据
修改:根据id修改数据
删除:根据id删除数据
/**
* 添加
* 1、sql:insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?)
* 2、参数:需要除了id之外的所有参数信息
* 3、结果:Boolean
*
* @throws Exception
*/
@Test
public void testAdd() throws Exception {
// 接收页面提交的参数
String brandName = "香飘飘";
String companyName = "香飘飘";
int ordered = 1;
String description = "绕地球一圈";
int status = 1;
//1、获取Connection
//1.1、加载配置文件
Properties prop = new Properties();
prop.load(new FileInputStream("src/druid.properties"));
//1.2、获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//1.3、获取数据库连接 Connection
Connection conn = dataSource.getConnection();
//2、定义SQL:insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);
String sql = "insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?)";
//3、获取PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement(sql);
//4、设置参数:需要除了id之外的所有参数信息
pstmt.setString(1, brandName);
pstmt.setString(2, companyName);
pstmt.setInt(3, ordered);
pstmt.setString(4, description);
pstmt.setInt(5, status);
//5、执行SQL
int count = pstmt.executeUpdate();//受影响的行数
//6、执行结果
System.out.println(count > 0);
//7.释放资源
pstmt.close();
conn.close();
}
/**
* 修改
* 1、sql:
* update tb_brand
* set brand_name = ?,
* company_name= ?,
* ordered = ?,
* description = ?,
* status = ?
* where id = ?
* 2、参数:需要所有参数信息
* 3、结果:Boolean
*
* @throws Exception
*/
@Test
public void testUpdate() throws Exception {
// 接收页面提交的参数
String brandName = "香飘飘";
String companyName = "香飘飘";
int ordered = 1000;
String description = "绕地球三圈";
int status = 1;
int id = 4;
//1、获取Connection
//1.1、加载配置文件
Properties prop = new Properties();
prop.load(new FileInputStream("src/druid.properties"));
//1.2、获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//1.3、获取数据库连接 Connection
Connection conn = dataSource.getConnection();
//2、定义SQL:
String sql = " update tb_brand\n" +
" set brand_name = ?,\n" +
" company_name= ?,\n" +
" ordered = ?,\n" +
" description = ?,\n" +
" status = ?\n" +
" where id = ?";
//3、获取PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement(sql);
//4、设置参数:需要所有参数信息
pstmt.setString(1, brandName);
pstmt.setString(2, companyName);
pstmt.setInt(3, ordered);
pstmt.setString(4, description);
pstmt.setInt(5, status);
pstmt.setInt(6, id);
//5、执行SQL
int count = pstmt.executeUpdate();//受影响的行数
//6、执行结果
System.out.println(count > 0);
//7.释放资源
pstmt.close();
conn.close();
}
/**
* 删除
* 1、sql:delete from tb_brand where id = ?
* 2、参数:id
* 3、结果:Boolean
*
* @throws Exception
*/
@Test
public void testDeleteById() throws Exception {
// 接收页面提交的参数
int id = 4;
//1、获取Connection
//1.1、加载配置文件
Properties prop = new Properties();
prop.load(new FileInputStream("src/druid.properties"));
//1.2、获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//1.3、获取数据库连接 Connection
Connection conn = dataSource.getConnection();
//2、定义SQL:
String sql = "delete from tb_brand where id = ?";
//3、获取PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement(sql);
//4、设置参数:需要除了id参数信息
pstmt.setInt(1, id);
//5、执行SQL
int count = pstmt.executeUpdate();//受影响的行数
//6、执行结果
System.out.println(count > 0);
//7.释放资源
pstmt.close();
conn.close();
}