1、JDBC概念与原理
概念：
JDBC是java访问数据库的标准规范，是一种用于执行SQL语句的Java API，可以为 多种关系数据库提供统一访问，
它由一组用Java语言编写的类和接口组成。是Java访问数据库的标准规范
原理：
JDBC是接口，驱动是接口的实现，没有驱动将无法完成数据库连接，从而不能操作数据库！每个数据库厂商都需
要提供自己的驱动，用来连接自己公司的数据库，也就是说驱动一般都由数据库生成厂商提供
总结：
JDBC就是由sun公司定义的一套操作所有关系型数据库的规则(接口)，而数据库厂商需要实现这套接口,提供数据库
驱动jar包, 我们可以使用这套接口编程,真正执行的代码是对应驱动包中的实现类
2、JDBC 开发
配置：
1、下载MySQL驱动包，并且创建一个jar包仓库文件
2、在ider中配置jar包仓库的位置
3、创建一个新的项目，然后配置jar包就可以使用 api了
API使用: 1.注册驱动
1、API使用: 注册驱动
- JDBC规范定义驱动接口： java.sql.Driver
- Mysql驱动包提供了实现类：com.mysql.jdbc.Driver
加载注册驱动的方式 描述
Class.forName(数据库驱动实现类） 加载和注册数据库驱动，数据库驱动由数据库厂商MySql提供
"com.mysql.jdbc.Driver"
2、代码示例
1）注册驱动
public class JDBCDemo1{
public static void main(String[] agrs) throws ClassNotFoundException{
//1.注册驱动
// forName 方法执行将类进行初始化
Class.forName("com.mysql.jdbc.Driver");
}
}
2）为什么这样可以注册驱动?
Class类的forName方法可以将一个类初始化，看看下面的源码
// Driver类是MySql提供的数据库驱动类, 实现了JDBC的Driver接口 java.sql.Driver
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
// 空参构造
public Driver() throws SQLException {
}
//静态代码块,Class类的 forName()方法将Driver类 加载到内存, static代码块会自动执行
static {
try {
/* DriverManager 驱动管理类
registerDriver(new Driver) 注册驱动的方法
注册数据库驱动
*/
DriverManager.registerDriver(new Driver());
} catch (SQLException var1) {
throw new RuntimeException("Can't register driver!");
}
}
}
注意： 从 JDBC3 开始，目前已经普遍使用的版本。可以不用注册驱动而直接使用。 Class.forName 这句话可以省略
API使用: 2.获得连接
1.Connection接口：
- Connection 接口，代表一个连接对象，具体的实现类由数据库的厂商实现
- 使用 DriverManager类的静态方法，getConnection可以获取数据库的连接
- 获取连接的静态方法 说明
Connection getConnection(String url,String user,String password) 通过连接字符串和用户名以及密码来获取数据库连接对象
2.getConnection方法3个连接参数说明：
连接参数 说明
user 登录用户名
password 登录密码
url mysql URL的格式： jdbc:mysql://localhost:3306/数据库名
对URL的详细说明：
举例：jdbc:mysql://localhost:3306/db4?characterEncoding=UTF-8
3、代码示例
publi class JDBCDemo{
public static void main(String[] args) thows Exception{
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接 url、用户名、密码
String url = "jdbc:mysql://localhost:3306/db4";
Connection con = DriverManager.getConnection(url, "root", "123456");
//com.mysql.jdbc.JDBC4Connection@2e3fc542
System.out.println(con);
}
}
API 使用: 3.获取语句执行平台
1、通过Connection 的 createStatement方法 获取sql语句执行对象
Connection接口中的方法 说明
Statement createStreamenet() 创建SQL语句执行对象
2、Statement：代表一条语句对象，用于发送SQL语句给服务器，用于执行静态SQL语句并返回生成结果的对象
Statement 类的常用方法 说明
int executeUpdate(String sql); 执行insert update delete语句.返回int类型,代表受影响的行数
ResultSet executeQuery(String sql); 执行select语句, 返回ResultSet结果集对象
代码示例：
public calss JDBCDemo{
public statci void main(String[] args) throws Exception{
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接url、用户名、密码
String url = "jdbc:mysql://localhost:3306/db1";
Connection con = DriverManager.getConnection(url,"root","123456");
//3.获取 Statement 对象
Statement statement = con.createStatement();
//4.执行创建表操作
String sql = "create table tests01(id int, name varchar(20), age int);";
//5.增删改操作 使用executeUpdate 增加一张表
int i = statement.executeUpdate(sql);
//6.返回值是受影响的函数
System.out.println(i);
//7.关闭流
statement.close();
con.close();
}
}
API 使用: 4.处理结果集
- 只有在进行查询操作的时候，才会处理结果集
- ResultSet接口
作用： 封装数据库查询的结果集，对结果集进行遍历，取出每一条记录
ResultSet接口方法： 说明：
boolean next() 1) 游标向下一行
2) 返回 boolean 类型，如果还有下一条记录，返回 true，否则返回 false
xxx getXxx(String or int ) 1) 通过列名，参数是 String 类型。返回不同的类型
2) 通过列号，参数是整数，从 1 开始。返回不同的类型
ps:列名和列号的理解
id、username、password、birthday都是列名
列号1对应的就是id 、列号2对应的就是username
- 示例
public calss JDBCDemo{
public statci void main(String[] args) throws Exception{
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接url、用户名、密码
String url = "jdbc:mysql://localhost:3306/db1";
Connection con = DriverManager.getConnection(url,"root","123456");
//3.获取 Statement 对象
Statement statement = con.createStatement();
//4.查询语句
String sql = "select * from jdbc_user";
//执行查询操作,返回的是一个 ResultSet 结果对象
ResultSet resultSet = statement.executeQuery(sql);
//5.处理结果集的方式1
// next 方法判断是否还有下一条数据
boolean next = resultSet.next();
System.out.println(next);
//getXXX 方法获取数据 两种方式
int id = resultSet.getInt("id");//列名
System.out.println(id);
int anInt = resultSet.getInt(1);//列号
System.out.println(anInt);
//5.处理结果集的方式2
while(resultSet.next()){
//获取id
int id = resultSet.getInt("id");
//获取姓名
String username = resultSet.getString("username");
//获取生日
Date birthday = resultSet.getDate("birthday");
System.out.println(id + " = " +username + " : " + birthday);
}
// 关闭连接
resultSet.close();
statement.close();
con.close();
}
}
API 使用: 5.释放资源
- 需要释放的对象： ResultSet结果集，Statement语句，Connection连接
- 释放原则： 先开的后关，后开的先关 ResultSet ==> Statement ==> Connection
- 放在哪个代码块中：
finally 块 与IO流一样，使用后的东西都需要关闭！关闭的顺序是先开后关, 先得到的后关闭，后得到的先关闭
代码示例：
public class JDBCDemo{
public static void main(String[] args){
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try{
//1.注册驱动（省略）
//2.获取连接
String url = "jdbc:mysql://localhost:3306/db3";
connection = DriverManager.getConnection(url,"root","123456");
//3.获取 Statement 对象
statement = connection.createStatemenet();
String sql = "select * from jdbc_user";
resultSet = statement.executeQuery(sql);
}catch(SQLException e){
e.printStackTrace();
}finally{
/**
* 开启顺序: connection ==> statement => resultSet
* 关闭顺序: resultSet ==> statement ==> connection
*/
try {
connection.close();
resultSet.close();
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
总结步骤：
1.获取驱动（可以省略）
2.获取数据库连接对象 Connection
3.获取数据库语句执行对象 Statement
4.处理结果集（只在查询时处理）ResultSet
5.释放资源 先开后关原则
二、JDBC 通过JDBC工具类实现增删该查
-什么时候需要创建工具类
如果一个功能需要经常用到，我们坚毅吧这个功能做成一个工具类，可以在不同的地方重用
- 插入记录遇到中文乱码问题：
jdbc:mysql://localhost:3306/db4?characterEncoding=UTF-8
characterEncoding=UTF-8 指定字符的编码、解码格式。
/*
JDBC工具类
*/
public class JDBCUtil {
//1. 将连接信息定义为 字符串常量
public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
public static final String URL = "jdbc:mysql://localhost:3306/db4?characterEncoding=UTF-8";
public static final String USER = "root";
public static final String PASSWORD = "root";
//2.静态代码块
static {
try {
//1.注册驱动
Class.forName(DRIVERNAME);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
//3.获取连接的静态方法
public static Connection getConnection(){
//获取连接对象 并返回
try {
Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
return connection;
} catch (SQLException throwables) {
throwables.printStackTrace();
return null;
}
}
//4.关闭资源的方法
public static void close(Connection con, Statement statement) throws Exception {
if(statement != null){
statement.close();
}
if(con != null){
con.close();
}
}
public static void close(Connection con, Statement statement, ResultSet resultSet)throws Exception{
if(resultSet != null){
try {
resultSet.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
con.close();
}
}
案例：
public class TestDML {
/**
* 添加数据
*/
@Test
public void testInsert() throws Exception {
//1.通过JDBCUtils工具类获取连接
Connection connection = JDBCUtil.getConnection();
//2. 获取Statement对象
Statement statement = connection.createStatement();
//2.1 编写SQL
String sql = "insert into jdbc_user values(null,'铁柱','123','2020/11/11')";
//2.2 执行sql
int i = statement.executeUpdate(sql);
System.out.println(i);
//3.关闭流
JDBCUtil.close(connection,statement);
}
/**
* 更新操作 根据ID修改用户名
*/
@Test
public void testUpdate() throws Exception{
Connection connection = JDBCUtil.getConnection();
Statement statement = connection.createStatement();
String sql = "update jdbc_user set username = '二丫' where id = 1";
int i = statement.executeUpdate(sql);
System.out.println(i);
JDBCUtil.close(connection,statement);
}
/**
* 删除操作 根据名字删除
*/
@Test
public void testDelete() throws Exception{
Connection connection = JDBCUtil.getConnection();
Statement statement = connection.createStatement();
String sql = "delete from jdbc_user where username in('admin2','test1','test2')";
statement.executeUpdate(sql);
JDBCUtil.close(connection,statement);
}
}
public class TestDQL {
@Test
public static void main(String[] args) throws Exception{
//1.获取连接对象
Connection connection = JDBCUtil.getConnection();
//2.获取Statement对象
Statement statement = connection.createStatement();
//3.编写SQL
String sql = "SELECT * FROM jdbc_user WHERE username = '二丫';";
ResultSet resultSet = statement.executeQuery(sql);
//4.处理结果集
while(resultSet.next()){
//通过列名 获取字段信息
int id = resultSet.getInt("id");
String username = resultSet.getString("username");
String password = resultSet.getString("password");
String birthday = resultSet.getString("birthday");
System.out.println(id+" "+username+" " + password +" " + birthday);
}
//4.释放资源
JDBCUtil.close(connection,statement,resultSet);
}
}
三、SQL注入问题
- SQL注入案例：用户登陆
public class TestLogin01 {
/**
* 用户登录案例
* 使用 Statement字符串拼接的方式完成查询
* @param args
*/
public static void main(String[] args) throws Exception{
//1.获取连接
Connection connection = JDBCUtil.getConnection();
//2.获取Statement
Statement statement = connection.createStatement();
//3.获取用户输入的用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名： ");
String name = sc.nextLine();
System.out.println("请输入密码： ");
String pass = sc.nextLine();
System.out.println(pass);
//4.拼接SQL执行查询
String sql = "select * from jdbc_user " +
"where username = " + " '" + name +"'" + " and password = " + " '" + pass + "'";
System.out.println(sql);
ResultSet resultSet = statement.executeQuery(sql);
//5.处理结果集,判断结果集是否为空
if(resultSet.next()){
System.out.println("登录成功! 欢迎您: " + name);
}else {
System.out.println("登录失败!");
}
//释放资源
JDBCUtil.close(connection,statement,resultSet);
}
}
1、什么是SQL注入？
我们让用户输入的密码和 SQL 语句进行字符串拼接。用户输入的内容作为了 SQL 语句语法的一部分，
改变了 原有 SQL 真正的意义，以上问题称为 SQL 注入
上面案例中当填写密码为：123' or '1'=’1 就会形成sql注入
拼接之后的语句：
select * from jdbc_user where username = 'abc' and password = 'abc' or '1'='1'
username='abc' and password='abc' 为假 '1'='1' 真
相当于 select * from user where true=true; 查询了所有记录
要解决SQL注入就是不能让用户输入的密码和我们的SQL语句进行 简单的字符串拼接
四、预处理对象
1、PreparedStatement 接口的介绍
PreparedStatement 是 Statement 接口的子接口，继承于父接口种所有的方法，它是一个预编译的SQL语句对象
预编译是指SQL语句被预编译，并存储在PerparedStatement对象种，然后可以使用此对象多次高效的执行该语句
2、PreparedStatement 接口的特点
因为有预先编译的功能，提高 SQL 的执行效率。
可以有效的防止 SQL 注入的问题，安全性更高
3、获取PerparedStatement对象
通过Connection创建PreparedStatement对象
Connection接口中的方法 说明
PreparedStatement prepareStatement(String sql) 指定预编译的 SQL 语句，SQL 语句中使用占位符 ? 创建一个语句对象
4、PreparedStatement接口常用方法
常用方法 说明
int executeUpdate(); 执行insert update delete语句.
ResultSet executeQuery(); 执行select语句. 返回结果集对象 Resulet
5、使用PreparedStatement的步骤
1) 编写 SQL 语句，未知内容使用?占位：
"SELECT * FROM jdbc_user WHERE username=? AND password=?";
2) 获得 PreparedStatement 对象
3) 设置实际参数：setXxx( 占位符的位置, 真实的值)
4) 执行参数化 SQL 语句
5) 关闭资源
使用 PreparedStatement 预处理对象,可以有效的避免SQL注入 案例：
public class TestLogin02 {
/**
* 使用预编译对象 PrepareStatement 完成登录案例
* @param args
* @throws SQLException
*/
public static void main(String[] args) throws Exception {
//1.获取连接
Connection connection = JDBCUtil.getConnection();
//2.获取Statement
Statement statement = connection.createStatement();
//3.获取用户输入的用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名： ");
String name = sc.nextLine();
System.out.println("请输入密码： ");
String pass = sc.nextLine();
System.out.println(pass);
//4.获取 PrepareStatement 预编译对象
//4.1 编写SQL 使用 ？占位符方式
String sql = "select * from jdbc_user where username = ? and password = ?";
PreparedStatement ps = connection.prepareStatement(sql);
//4.2 设置占位符参数
ps.setString(1,name);
ps.setString(2,pass);
//5. 执行查询 处理结果集
ResultSet resultSet = ps.executeQuery();
if(resultSet.next()){
System.out.println("登录成功! 欢迎您: " + name);
}else{
System.out.println("登录失败!");
}
//6.释放资源
JDBCUtil.close(connection,statement,resultSet);
}
}
分别使用 Statement对象 和 PreparedStatement对象进行插入操作:
public class TestPs {
public static void main(String[] args) throws Exception{
Connection con = JDBCUtil.getConnection();
//获取 Sql语句执行对象
Statement st = con.createStatement();
//插入两条数据
st.executeUpdate("insert into jdbc_user values(null,'张三','123','1992/12/26')");
st.executeUpdate("insert into jdbc_user values(null,'李四','123','1992/12/26')");
//获取预处理对象
PreparedStatement ps = con.prepareStatement("insert into jdbc_user values(?,?,?,?)");
//第一条数 设置占位符对应的参数
ps.setString(1,null);
ps.setString(2,"长海");
ps.setString(3,"qwer");
ps.setString(4,"1990/1/10");
//执行插入
ps.executeUpdate();
//第二条数据
ps.setString(1,null);
ps.setString(2,"小斌");
ps.setString(3,"1122");
ps.setString(4,"1990/1/10");
//执行插入
ps.executeUpdate();
//释放资源
st.close();
ps.close();
con.close();
}
}
分析：
6、 Statement 与 PreparedStatement的区别?
1、Statement 用于执行静态的SQL语句，在执行时，必须指定一个事先准备好的SQL语句
2、PrepareStatement是预编译的SQL语句对象，语句中可以包含动态参数“?”，在执行时可以为“?”动态设置参数 值。
3、PrepareStatement可以减少编译次数提高数据库性能。
五、JDBC 控制事务
1、数据准备
-- 创建账户表
CREATE TABLE account(
-- 主键
id INT PRIMARY KEY AUTO_INCREMENT,
-- 姓名
NAME VARCHAR(10),
-- 转账金额
money DOUBLE
);
-- 添加两个用户
INSERT INTO account (NAME, money) VALUES ('tom', 1000), ('jack', 1000);
2、事务相关API
3、开发步骤
1. 获取连接
2. 开启事务
3. 获取到 PreparedStatement , 执行两次更新操作
4. 正常情况下提交事务
5. 出现异常回滚事务
6. 最后关闭资源
4、代码示例
1、
-- 创建账户表
CREATE TABLE account(
-- 主键
id INT PRIMARY KEY AUTO_INCREMENT,
-- 姓名
name VARCHAR(10),
-- 转账金额
money DOUBLE
);-- 添加两个用户
INSERT INTO account (NAME, money) VALUES ('tom', 1000), ('jack', 1000);
2、开发步骤
1.获取连接
2.开启事务
3.获取到 PerparedStatement, 执行两次更新操作
4.正常情况下提交事务
5.出现异常回滚事务
6.最后关闭资源
3、案例
public class JDBCTransaction {
//JDBC 操作事务
public static void main(String[] args) throws Exception {
//1.数据库连接驱动对象 connection
Connection connection = null;
//2.SQL预处理对象 preparedStatement
PreparedStatement preparedStatement = null;
try{
//1.获取连接
connection = JDBCUtil.getConnection();
//2.开启事务
connection.setAutoCommit(false);
//3.获取到preparedStatement 执行两次更新操作
//3.1 tom 账户 -500
preparedStatement = connection.prepareStatement("update account set money = money - ? where name = ? ");
preparedStatement.setDouble(1,500.0);
preparedStatement.setString(2,"tom");
preparedStatement.executeUpdate();
//模拟tom转账后 出现异常
System.out.println(1/0);
//3.2 jack账户 + 500
preparedStatement = connection.prepareStatement("update account set money = money + ? where name = ?");
preparedStatement.setDouble(1,500.0);
preparedStatement.setString(2,"jack");
preparedStatement.executeUpdate();
//4.正常情况下提交事务
connection.commit();
System.out.println("转账成功！");
}catch (Exception e){
e.printStackTrace();
try {
//5.出现异常回滚事务
connection.rollback();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}finally {
//6.最后关闭资源
JDBCUtil.close(connection,preparedStatement);
}
}
}