JDBC基础
目录
1.概念：Java DataBase Connectivity Java 数据库连接， Java语言操作数据库
JDBC本质：其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。
2.操作步骤
常规八步骤
1. **导入驱动jar包** mysql-connector-java-5.1.37-bin.jar
1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
2.右键–>Add As Library
2. **注册驱动**
3. **获取数据库连接对象 Connection**
4. **定义sql**
5. **获取执行sql语句的对象 Statement**
6. **执行sql，接受返回结果**
7. **处理结果**
8. **释放资源**
代码实现
代码实现：
//1. 导入驱动jar包
//2.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//3.获取数据库连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
//4.定义sql语句
String sql = "update account set balance = 500 where id = 1";
//5.获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
//6.执行sql
int count = stmt.executeUpdate(sql);
//7.处理结果
System.out.println(count);
//8.释放资源
stmt.close();
conn.close();
3.详解各个对象
3.1 DriverManager: 驱动管理对象**
*功能：
注册驱动：告诉程序应该使用哪一个数据库驱动jar
static void registerDriver(Driver driver) //注册与给定的驱动程序 DriverManager
写代码使用： Class.forName("com.mysql.jdbc.Driver");
通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。
获取数据库连接
-
方法：
static Connection getConnection(String url, String user, String password) ` -
参数
**url: 指定连接的路径**
语法：jdbc:mysql://ip地址(域名)：端口号/数据库名称
eg: jdbc:mysql://localhost:3306/test
细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称。
**user： 用户名**
**password： 密码**
3.2 Connection: 数据库连接对象
### 功能：
- 获取执行sql对象
* Statement createStatement()
* PreparedStatement prepareStatement(String sql)
- 管理事务
* 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
* 提交事务：commit()
* 回滚事务：rollback()
3.3 Statement：执行sql的对象**
- 执行sql
- boolean execute(String sql): 可以执行任意sql
- int excuteUpdate(String sql): 执行数据的增删改以及表格的创建、删除、修改
- 返回影响的行数，通过这个影响的行数，判断DML是否执行成功。
- executeQuery(String sql)：执行查询语句
实例：增删改操作
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import java.sql.*;
import java.util.Properties;
public class JDBCTest {
public static void main(String[] args) {
testInsert();
}
public static void testInsert() {
Statement stmt = null;
Connection conn = null;
try {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2. 定义sql
String sql = "INSERT INTO user_table\n" +
"VALUES('CJ','ROOT',1400);";
//3.获取数据库连接的Connection对象
conn = DriverManager.getConnection("jdbc:mysql:///test", "root", "HWJ");
//4.获取执行sql的对象 Statement
stmt = conn.createStatement();
//5.执行sql
int count = stmt.executeUpdate(sql);//影响的行数
//6.处理结果
System.out.println(count);
if(count > 0){
System.out.println("添加成功！");
}else{
System.out.println("添加失败！");
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}finally {
//stmt.close();
//7. 释放资源
//避免空指针异常
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
3.4 ResultSet：结果集对象,封装查询结果
1）boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾（是否有数据）。如果是，则返回false;如果不是，则返回true。
2）getXxx(参数):获取数据
3）Xxx：代表数据类型 如： int getInt() , String getString()
参数：
-
int 代表列的编号，从1开始 如：getString(1)
-
String 代表列名称。如 getDouble("balance")
注意：
-
使用步骤：
游标向下移动一行
判断是否有数据
获取数据
//循环判断游标是否是最后一行末尾。 while(rs.next()){ //获取数据 //6.2 获取数据 int id = rs.getInt(1); String name = rs.getString("name"); double balance = rs.getDouble(3); System.out.println(id + "---" + name + "---" + balance); }
-
4.抽取JDBC工具类 ： JDBCUtils
核心思想：简化程序书写，程序解耦合
分析：注册驱动、连接对象、释放资源均可抽取。
1、配置参数属性文件 jdbc.Properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test
user=root
password=HWJ
2、抽取方法连接对象
2.1、 定义实体类 Customers
package domain;
/*
step1. 定义Customers类
step2. 定义方法 public List<Emp> findAll(){}
step3. 实现方法 select * from customers
此函数作用：封装customers表数据的javaBean
1.提高代码的可复用性:对于通用的事务处理逻辑,数据库操作等都可以
封装在JavaBean中,通过调用JavaBean的属性和方法可快速进行程序设计。
*/
import java.util.Date;
public class Customers {
private int Id;
private String name;
private String email;
private Date birth;
public int getId() {
return Id;
}
public void setId(int id) {
Id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
@Override
public String toString() {
return "Customers{" +
"Id=" + Id +
", name='" + name + '\'' +
", email='" + email + '\'' +
", birth=" + birth +
'}';
}
}
5.抽取方法释放资源
package utils;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.*;
import java.util.Properties;
import java.util.Set;
public class JDBCUtils {
public static String url;
public static String user;
public static String password;
public static String driver;
// 文件的读取：只要读取一次就可以拿到这些值
static {
try{
//1. 创建Properties集合类
Properties pro=new Properties();
// 获取src路径下文件的方式-->ClassLoader 类加载器
ClassLoader classLoader=JDBCUtils.class.getClassLoader();
//URL 统一资源定位符，获取绝对路径
URL res=classLoader.getResource("jdbc.properties");
String path=res.getPath();
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 (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 获取连接
* @return 连接对象
*/
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url, user, password);
}
public static void close(Statement stmt, Connection conn){
if( stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if( conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* 释放资源
* @param stmt
* @param conn
*/
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();
}
}
}
}
6.主函数
package JDBC;
import domain.Customers;
import utils.JDBCUtils;
import java.sql.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/*
* 定义一个方法，查询customers表的数据将其封装为对象，然后装载集合，返回。
*/
public class JDBCSelectDemo {
public static void main(String []args) {
// List<Customers> list = new JDBCSelectDemo().findAll();
List<Customers> list = new JDBCSelectDemo().findAll2();
// System.out.println(list.size());
System.out.println(list);
}
public static List<Customers> findAll2() {
Statement stmt = null;
Connection conn = null;
ResultSet rs = null;
Customers customer = null;
ArrayList<Customers> list = null;
try {
conn = JDBCUtils.getConnection();
// 定义sql
String sql = "SELECT * FROM `customers`";
// 获取sql执行对象
stmt = conn.createStatement();
// 执行sql
rs = stmt.executeQuery(sql);
list = new ArrayList<Customers>();
// 遍历结果集，封装对象，装载对象
while (rs.next()) {
int id = rs.getInt(1);
String name = rs.getString("name");
String email = rs.getString("email");
Date birth = rs.getDate("birth");
System.out.println(rs.toString());
// customer实例化，在这之前，声明为null可进行赋值操作,但不可调用方法。
customer=new Customers();
customer.setId(id);
customer.setName(name);
customer.setEmail(email);
customer.setBirth(birth);
list.add(customer);
}
} catch ( SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.close(stmt, conn);
}
return list;
}
// public static List<Customers> findAll() {
// Statement stmt = null;
// Connection conn = null;
// ResultSet rs = null;
// Customers customer = null;
// ArrayList<Customers> list = null;
// try {
//
// // 注册驱动
// Class.forName("com.mysql.jdbc.Driver");
//// //获取数据库连接的Connection对象
// conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "HWJ");
//
// // 定义sql
// String sql = "SELECT * FROM `customers`";
// // 获取sql执行对象
// stmt = conn.createStatement();
// // 执行sql
// rs = stmt.executeQuery(sql);
// list = new ArrayList<Customers>();
// // 遍历结果集，封装对象，装载对象
// while (rs.next()) {
// int id = rs.getInt(1);
// String name = rs.getString("name");
// String email = rs.getString("email");
// Date birth = rs.getDate("birth");
// Byte photo = rs.getByte("photo");
// System.out.println(rs.toString());
//// customer实例化，在这之前，声明为null可进行赋值操作,但不可调用方法。
// customer=new Customers();
//
// customer.setId(id);
// customer.setName(name);
// customer.setEmail(email);
// customer.setBirth(birth);
// customer.setPhoto(photo);
// list.add(customer);
// }
// } catch (ClassNotFoundException | SQLException e) {
// e.printStackTrace();
// } finally {
// try {
// if (stmt != null) {
// stmt.close();
// }
// } catch (SQLException e) {
// e.printStackTrace();
// }
// try {
// if (conn != null) {
// conn.close();
// }
// } catch (SQLException e) {
// e.printStackTrace();
// }
// try {
// if (rs != null) {
// rs.close();
// }
// } catch (SQLException e) {
// e.printStackTrace();
// }
// }
// return list;
// }
}
7. 预定义sql执行对象 PreparedStatement
7.1 SQL注入问题
在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
输入用户随便，输入密码：’a’ or ‘a’ = ‘a’
sql：select * from user where username = ‘fhdsjkf’ and password = ‘a’ or ‘a’ = ‘a’
7.2 解决sql注入问题
使用PreparedStatement对象来解决
7.3 预编译的SQL
参数使用?作为占位符
7.4 步骤：
-
导入驱动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语句
-
处理结果
-
释放资源
总结 其与Statement区别：
-
定义sql语句的区别 PreparedStatement 是直接用？
-
获取执行SQL语句
conn.createStatement 与 Connection.prepareStatement（SQL）
-
给?赋值
-
执行sql
-
PreparedStatement不需要该步骤，已经在连接对象时已经预定义。直接执行即可
stmt.executeUpdate(sql);
pstmt.executeUpdate();
-
8.JDBC控制事务
事务
一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。
操作
- 开启事务
- 提交事务
- 回滚事务
使用Connection对象来管理事务
- 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
- 在执行sql之前开启事务
- 提交事务：commit()
- 当所有sql都执行完提交事务
- 回滚事务：rollback()
- 出错即回滚至初始状态（conn为null），在catch中回滚事务。
代码
package JDBC;
import utils.JDBCUtil;
import java.sql.*;
public class JDBCTransaction {
public static void main(String [] args) {
Connection conn=null;
PreparedStatement pstmt1=null;
PreparedStatement pstmt2=null;
Integer rs1=null;
Integer rs2=null;
try{
conn= JDBCUtil.getConnection();
//开启事务
conn.setAutoCommit(false);
String sql1="UPDATE user_table\n" +
"SET balance=balance+?\n" +
"WHERE user=?";
String sql2="UPDATE user_table\n" +
"SET balance=balance-?\n" +
"WHERE user=?";
pstmt1=conn.prepareStatement(sql1);
pstmt1.setDouble(1, 500);
pstmt1.setString(2, "AA");
pstmt2=conn.prepareStatement(sql2);
pstmt2.setDouble(1, 500);
pstmt2.setString(2, "BB");
rs1=pstmt1.executeUpdate();
rs2=pstmt2.executeUpdate();
conn.commit();
} catch (SQLException e) {
try{
if(conn!=null){
conn.rollback();
}
} catch (SQLException ex) {
ex.printStackTrace();
}finally{
JDBCUtil.close(pstmt1, conn);
JDBCUtil.close(pstmt2, null);
}
e.printStackTrace();
}
}
}
谋定而后动，知止而有得
浙公网安备 33010602011771号