前言：“只有自己强大，才不会被别人践踏。”
你好，我是梦阳辰，让我们轻松玩编程，一起走进JDBC的世界吧！文章较长建议收藏再看！
1.JDBC概述
2.JDBC编程六步（重点）
3.用数据库实现用户登录功能
4.用PreparedStatement完成增删改查
5.事务问题
6.JDBC工具类的封装
7.行级锁（悲观锁和乐观锁）
1.JDBC概述
1.JDBC是什么？
Java DataBase connectivity(java数据库连接）
Java数据库连接是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。
2.JDBC的本质是什么？
JDBC是sun公司制定的一套接口（interface)
java.sql包下。
为什么java要制定一套JDBC接口？
因为每一个数据库的底层实现原理都不一样。
oracle数据库都有自己的原理。
MySQL数据库也有自己的原理。
MS Sqlserver数据库也有自己的原理。
接口都由调用者和实现者完成。
面向接口调用，面向接口写实现类，这都是属于面向接口编程。
1.调用者为程序员；不需要关心具体是哪个厂家的数据库，只需要面向JDBC接口写代码。
2.实现者为数据库厂家，也被称为驱动，对JDBC进行实现（为class文件）。
3.如果没有实现类驱动可以编译，但无法执行。
为什么要面向接口编程呢？
解耦合：降低程序的耦合度，提高程序的扩展力。
多态机制就是非常典型的：面向抽象编程。
即建议：
Animal a = new cat();
public void feed(Animal a) //面向父类型编程。
3.JDBC开发前的准备工作，先从官网下载对应的驱动jar包，然后将其配置到环境变量classpath当中。
如果是用IDEA开发，需要在IDEA中导入驱动jar包，步骤为：点击file–>Project Structure–>"+"–>java。然后选择你在数据库官网下载的驱动jar包，最后选择要导入的项目（module)即可。如果你还在用eclipse，建议换一下IDEA，哈哈。
classpath=.;+下载的驱动包的路径及文件名。
"."代表当前路径，加了这个，JVM会在当前路径下查找类，如果没找到再到指定位置查找。
注意：虽然在jdk5之后不用配置class环境变量，但是当我们用到JDBC,或者开发JavaEE应用时，则必须要设置classpath环境变量，JVM通过classpath查找类。JDK 1.5 版本以上的JDK，会自动搜索当前路径下的类文件，而且使用java的编译和运行工具时，系统可以自动加载dt.jar和tools.jar文件中的java类，因此不再需要设置classpath环境变量。
2.JDBC编程六步（重点）
第一步：注册驱动（作用：告诉Java程序，即将要连接的是哪个品牌的数据库）
第二步：获取连接（表示JVM的进程和数据库进程之间的通道打开了，这属于进程之间的通信，重量级的，使用完之后一定要关闭）
第三步：获取数据库操作对象（专门执行sql语句的对象）
第四步：执行SQL语句。（DQL,DML)
第五步：处理查询结果集。（当第四步是执行select语句时才有这一步）
第六步：释放资源。即关闭数据库（使用资源之后一定要关闭资源。Java和数据库属于进程间的通信，开启后一定要关闭。）
1.例如：(注意注解）
/*
JDBC编程六步
*/
import java.sql.Driver;//接口
import java.sql.DriverManager;//类
import java.sql.SQLException;//异常类
import java.sql.Connection;//接口
import java.sql.Statement;//类
public class JavaJDBC
{
public static void main(String[] args)
{
Connection conn =null;
Statement stat = null;
try{
//1.注册驱动
Driver driver = new com.mysql.jdbc.Driver();//多态
//Driver driver = new oracle.jdbc.driver.OracleDriver();//oracle的驱动
//注意前面的Driver是接口，后面的Driver是其实现类，因为在不同的包中，故可以这样命名
DriverManager.registerDriver(driver);//静态方法
//2.获取连接(建立通道，数据库和java）
/*
url:统一资源定位符（网络中某个资源的绝对路径）
如：https://www.baidu.com/ 这就是一个URL
URL包括哪几个部分？
协议，IP,PORT,资源名
如：http://182.61.200.7:80/index.html
http://通信协议
182.61.200.7 服务器IP地址
80 服务器上软件的端口
index.html 是服务器上某个资源名
*/
String url="jdbc:mysql://127.0.0.1:3306/xingkong";//或者localhost
/*
jdbc:mysql:// 协议
127.0.0.1 IP地址
3306 mysql数据库端口号
xingkong 具体的数据库实例名
说明：localhost与129.0.0.1都是本机的IP地址。
更改地址就可以访问其他服务器的内容。
什么是通信协议，有什么用？
通信协议是通信之前就提前定好的数据库传送格式。
数据包具体怎么传数据，格式提前定好了。
oracle的URL:
jdbc:oracle:thin:@localhost:1521:xingkong
*/
String user="root";
String password = "1234";
conn =DriverManager.getConnection(url,user,password);//静态方法
System.out.println("数据库连接对象="+conn);
//3.获取数据库操作对象(Statement专门执行sql语句）
stat = conn.createStatement();
//4.执行sql
String sql = "insert into dept(deptno,dname,loc )values(50,'fgagad','sfd')";
//专门执行DML语句的（insert ,delete,update)
//返回值是“影响数据库的记录条数”
int count = stat.executeUpdate(sql);
System.out.println(count==1?"保存成功":"保存失败");
//5.处理查询结果集（这里不是查询，所以不需要这一步）
}catch(SQLException e){
e.printStackTrace();
}finally{
//6.释放资源
//要遵循从小大以此关闭
//分别对其try...catch
try{
if(stat!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
stat.close();
}
}catch(SQLException e){
e.printStackTrace();
}
try{
if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
conn.close();
}
}catch(SQLException e){
e.printStackTrace();
}
}
}
}
url解释：
url:统一资源定位符（网络中某个资源的绝对路径）
如：https://www.baidu.com/ 这就是一个URL
URL包括哪几个部分？
协议，IP,PORT,资源名
如：http://182.61.200.7:80/index.html
http://通信协议
182.61.200.7 服务器IP地址
80 服务器上软件的端口
ndex.html 是服务器上某个资源名
因此：
jdbc:mysql:// 协议
127.0.0.1 IP地址
3306 mysql数据库端口号
xingkong 具体的数据库实例名
说明：localhost与129.0.0.1都是本机的IP地址。
更改地址就可以访问其他服务器的内容。
什么是通信协议，有什么用？
通信协议是通信之前就提前定好的数据库传送格式。
数据包具体怎么传数据，格式提前定好了。
oracle的URL:
jdbc:oracle:thin:@localhost:1521:xingkong
2.简化代码并执行删除和更新操作：
import java.sql.*;
public class JDBCTest2{
public static void main(String[] args){
Connection conn = null;
Statement stat = null;
try{
//1注册驱动
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
//2获取连接
conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/xingkong","root","0910");
//3获取数据库操作对象
stat =conn.createStatement();
//4执行SQL语句
//String sql ="delete from dept where deptno = 40";
String sql ="update dept set dname = 'xin',loc='beijin' where deptno =20";
int count = stat.executeUpdate(sql);
System.out.println(count==1?"修改成功":"修改失败");
}catch(SQLException e){
e.printStackTrace();
}finally{
try{
if(stat!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
stat.close();
}
}catch(SQLException e){
e.printStackTrace();
}
try{
if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
conn.close();
}
}catch(SQLException e){
e.printStackTrace();
}
}
}
}
3.将连接数据库的所有信息配置到，配置文件中：（使用资源绑定器）
这里为重点，因为这种方式非常灵活，这很常用。注意用这种方式需要配置，jdbc.properties文件哦。
如果这里看不懂，这篇文章也许会帮到你：
java的反射机制，看完这篇轻松应对高级框架（超详细总结）
import java.sql.*;
import java.util.*;
public class JDBCTest3
{
public static void main(String[] args)
{
//使用资源绑定器绑定属性配置文件
ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
String driver = bundle.getString("driver");//driver=com.mysql.jdbc.Driver
String url = bundle.getString("url");
String user = bundle.getString("user");
String password= bundle.getString("password");
Connection conn = null;
Statement stat = null;
try{
//1.注册驱动，这里为注册驱动的另一种方式
Class.forName(driver);//反射获取类，这是会在类加在之前执行静态代码块
//2.获取连接
conn = DriverManager.getConnection(url,user,password);
//3.获取数据库操作对象
stat=conn.createStatement();
//4.执行SQL语句
String sql="update dept set dname ='sfaf',loc ='shenzhen' where deptno =20";
int count = stat.executeUpdate(sql);
System.out.println(count==1?"更新成功":"更新失败");
}catch(Exception e){
e.printStackTrace();
}finally{
//6.释放资源
//要遵循从小大以此关闭
//分别对其try...catch
try{
if(stat!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
stat.close();
}
}catch(SQLException e){
e.printStackTrace();
}
try{
if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
conn.close();
}
}catch(SQLException e){
e.printStackTrace();
}
}
}
}
import java.util.*;
import java.sql.*;
public class JDBCTest4
{
public static void main(String[] args)
{
//使用资源绑定器绑定属性配置文件
ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
String driver = bundle.getString("driver");//driver=com.mysql.jdbc.Driver
String url = bundle.getString("url");
String user = bundle.getString("user");
String password= bundle.getString("password");
Connection conn = null;
Statement stat =null;
ResultSet rs =null;
try{
//1.注册驱动
Class.forName(driver);
//2.获取连接
conn=DriverManager.getConnection(url,user,password);
//3.获取数据库操作对象
stat=conn.createStatement();
//4.执行sql语句
String sql="select empno,ename,sal from emp";
//int executeUpdate(insert/delete/update)
//ResultSet executeQuery(select)
rs= stat.executeQuery(sql);//专门执行DQL语句的方法
//5.处理查询结果集
//boolean flag = rs.next();
/*if(rs.next()){
//不管数据库中的数据类型是什么，都以String的形式取出。
String ss = rs.getString(1);//JDBC中所有下标从1开始。不是从0开始。
String ename = rs.getString(2);//第二列中的那个数据
String sal = rs.getString(3);//第三列的那个数据
System.out.println(ss+","+ename+","+sal);
}*/
while(rs.next()){
//不管数据库中的数据类型是什么，都以String的形式取出，如果想以Int类型取出，改为getInt方法，其它类似。
String ss = rs.getString("empno");
String ename = rs.getString("ename");//如果重命名，这里写重命名后的名字
String sal = rs.getString("sal");
System.out.println(ss+","+ename+","+sal);
}
}catch(Exception e){
}finally{
//6.释放资源
try{
if(rs!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
rs.close();
}
}catch(SQLException e){
e.printStackTrace();
}
try{
if(stat!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
stat.close();
}
}catch(SQLException e){
e.printStackTrace();
}
try{
if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
conn.close();
}
}catch(SQLException e){
e.printStackTrace();
}
}
}
}
*不管数据库中的数据类型是什么，都以String的形式取出，如果想以Int类型取出，改为getInt方法，并且，用getInt取出的数据可以参加数学运算，其它类似。
3.用数据库实现用户登录功能
模拟用户登入：
1.程序运行时的时候，提供一个输入的入口，可以让用户输入用户名和密码。
2.用户输入用户名和密码之后，提交信息，java程序收集到用户信息
java程序连接数据库验证用户名和密码是否合法
合法登陆成功，否则登入失败
3.数据的准备：
在实际开发中，表的设计会使用专业的建模工具，这里使用：PowerDesigner
使用PowerDesigner工具进行数据表的设计
4.存在的问题(表中并没有这个用户，但是显示登录成功）
用户：fdas
密码：fdas’ or ‘1’='1
登陆成功
这种现象被称为SQL注入(安全隐患).
5.导致sql注入的根本原因是什么？
用户输入的信息中含有sql语句的关键字，并且这些关键字参与sql语句的编译过程，
导致sql语句的原意被扭曲，进而达到sql注入。
6.详情请看源代码：
package Day1;
//模拟用户登入功能
import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//初始化界面
Map<String,String> userInfromation =initUi();
//验证用户名和密码
boolean loginSuccess= login(userInfromation);
//输出结果
System.out.println(loginSuccess?"登陆成功":"登录失败");
}
/**
* 用户登录
* 用户登录信息
* false表示失败，true表示成功*/
private static boolean login(Map<String, String> userInfromation) {
boolean falg =false;
String loginName= userInfromation.get("username");//用户名
String passcode=userInfromation.get("passcode");//用户密码
//JDBC代码
Connection conn = null;
Statement stat= null;
ResultSet rs= null;
try {
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/newdata?useSSL=false","root","123456");
//3.获取数据库操作对象
stat = conn.createStatement();
//4.执行sql
String sql = "select * from t_users where loginName='"+loginName+"'and passcode='"+passcode+"'";
//以上正好完成了sql语句的拼接，以下代码是，发送sql语句给DBMS进行编译。
//正好将用户提供的”非法信息“编译进去。导致了原sql语句的含义被扭曲了。
rs=stat.executeQuery(sql);
//处理结果集
if(rs.next()){
falg =true;
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
//6.释放资源
if(rs!=null){
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(stat!=null){
try {
stat.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
return falg;
}
/**
* 初始化用户界面
* 返回用户名和密码等信息*/
private static Map<String, String> initUi() {
Scanner sc = new Scanner(System.in);
System.out.println("用户名：");
String username=sc.nextLine();
System.out.println("密码：");
String passcode = sc.nextLine();
Map<String,String>userInfromation= new HashMap<>();
userInfromation.put("username",username);
userInfromation.put("passcode",passcode);
return userInfromation;
}
}
*你会发现某些安全性不高的网站用这种SQL注入的方式可以成功登录，但是可能会显示封号或者报出警告等。
7.那么我们该怎么解决SQL注入的问题呢？（重点，安全性高常用）
问题关键在于我们提供的密码参加了编译。因此我们可以从这里下手。我们可以将提供的信息不参与SQL语句的编译，因此我们需要使用java.sql.PreparedStatement接口。
1.将Statement接口换成PrepareStatement。PrepareStatement是Statement子接口。
PrepareStatement属于预编译的数据库操作对象。
其原理是：预先对SQL语句的框架进行编译，然后再给SQL语句传“值”。
2.将createStatemet();方法，改为：prepareStatement(sql);sql语句提前。并将sql语句的值改为占位符。
3.给占位符“？”传值，（第一个问号下表是1，第二个问号下标是2，JDBC中所有下表从1开始。）
详细请看源代码：
package Day1;
//模拟用户登入功能
* */
import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//初始化界面
Map<String,String> userInfromation =initUi();
//验证用户名和密码
boolean loginSuccess= login(userInfromation);
//输出结果
System.out.println(loginSuccess?"登陆成功":"登录失败");
}
/**
* 用户登录
* 用户登录信息
* false表示失败，true表示成功*/
private static boolean login(Map<String, String> userInfromation) {
boolean falg =false;
String loginName= userInfromation.get("username");//用户名
String passcode=userInfromation.get("passcode");//用户密码
//JDBC代码
Connection conn = null;
PreparedStatement prep= null;
ResultSet rs= null;
try {
//1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/newdata?useSSL=false","root","0910");
//3.获取预编译的数据库操作对象
String sql = "select * from t_users where loginName=? and passcode=?";//?表示占位符，只能填充值，
//程序执行到这，会发送sql语句框子给DBMS,然后DBMS进行sql语句的预先编译。
prep = conn.prepareStatement(sql);
//给占位符？传值，（第一个问号下表是1，第二个问号下标是2，JDBC中所有下表从1开始。
prep.setString(1,loginName);//会自动加单引号，如果是数字用setInt()方法。
prep.setString(2,passcode);
//4.执行sql
//以上正好完成了sql语句的拼接，以下代码是，发送sql语句给DBMS进行编译。
//正好将用户提供的”非法信息“编译进去。导致了原sql语句的含义被扭曲了。
rs=prep.executeQuery();
//处理结果集
if(rs.next()){
falg =true;
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
//6.释放资源
if(rs!=null){
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(prep!=null){
try {
prep.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
return falg;
}
/**
* 初始化用户界面
* 返回用户名和密码等信息*/
private static Map<String, String> initUi() {
Scanner sc = new Scanner(System.in);
System.out.println("用户名：");
String username=sc.nextLine();
System.out.println("密码：");
String passcode = sc.nextLine();
Map<String,String>userInfromation= new HashMap<>();
userInfromation.put("username",username);
userInfromation.put("passcode",passcode);
return userInfromation;
}
}
2.Statement第一次已经编译的SQL语句，后面出现一模一样的不会再编译，直接执行，一但多了一个空格就会重新编译。而PrepareStatement没有这个问题只编译一次。因此后者效率较高。
3.PrepareStatement会在编译的时候进行安全检查。
9.因此可以看出PrepareSatement使用较多(单纯传值。当业务需要SQL注入的时候，使用Statement.
比如：在升序和降序的时候需要使用SQL注入。
因为setString(1,desc)会自动加单引号，但是我们不需要单引号。
4.用PreparedStatement完成增删改查
直接看代码：注意得配置jdbc.properties文件。
package Day1;
import java.util.*;
import java.sql.*;
public class PreparedStatementTest1 {
public static void main(String[] args) {
//使用资源绑定器绑定属性配置文件
ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
String driver = bundle.getString("driver");//driver=com.mysql.jdbc.Driver
String url = bundle.getString("url");
String user = bundle.getString("user");
String password= bundle.getString("password");
Connection conn = null;
PreparedStatement prep =null;
try{
//1.注册驱动
Class.forName(driver);
//2.获取连接
conn=DriverManager.getConnection(url,user,password);
//3.获取预编译的数据库操作对象
//增
/*String sql = "insert into dept(deptno,dname,loc)values(?,?,?)";
prep=conn.prepareStatement(sql);
prep.setInt(1,60);
prep.setString(2,"xing");
prep.setString(3,"shenzhen");*/
//改
/* String sql = "update dept set dname = ?,loc =? where deptno =?";
prep=conn.prepareStatement(sql);
prep.setString(1,"asdf");
prep.setString(2,"ShangHai");
prep.setInt(3,60);*/
//删除
String sql = "delete from dept where deptno =?";
prep=conn.prepareStatement(sql);
prep.setInt(1,60);
//4.执行sql语句
//int executeUpdate(insert/delete/update)
//ResultSet executeQuery(select)
int count=prep.executeUpdate();
System.out.println(count);
}catch(Exception e){
}finally{
//6.释放资源
try{
if(prep!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
prep.close();
}
}catch(SQLException e){
e.printStackTrace();
}
try{
if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
conn.close();
}
}catch(SQLException e){
e.printStackTrace();
}
}
}
}
5.事务问题
JDBC中的事务是自动提交的：
1.只要执行任意一条DML语句，则自动提交一次。这是JDBC默认的事务行为。
但是在实际业务中，同常都是N条DML语句共同联合才能完成的，必须保证他们这些DML
在同一个事物中同时成功或者同时失败。
自动提交存在的问题：
账户转账演示：（单机事务）
package Day1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ResourceBundle;
//JDBC事务机制
public class JDBCTest2 {
public static void main(String[] args) {
//使用资源绑定器绑定属性配置文件
ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
String driver = bundle.getString("driver");//driver=com.mysql.jdbc.Driver
String url = bundle.getString("url");
String user = bundle.getString("user");
String password= bundle.getString("password");
Connection conn = null;
PreparedStatement prep =null;
try{
//1.注册驱动
Class.forName(driver);
//2.获取连接
conn= DriverManager.getConnection(url,user,password);
//将自动提交改为手动提交
conn.setAutoCommit(false);
//3.获取预编译的数据库操作对象
//账户向另一个账户转账
String sql = "update t_acount set balance = ? where acount =?";
prep=conn.prepareStatement(sql);
prep.setDouble(1,333);//转333
prep.setInt(2,123);
int count = prep.executeUpdate();
//假设遇到异常
String s =null;
s.toString();
prep.setDouble(1,334);//收333
prep.setInt(2,1234);
//4.执行sql语句
//int executeUpdate(insert/delete/update)
//ResultSet executeQuery(select)
count+=prep.executeUpdate();
System.out.println(count==2?"转账成功":"转账失败");
conn.commit();
}catch(Exception e){
if(conn!=null){
try {
conn.rollback();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
e.printStackTrace();
}finally{
//6.释放资源
try{
if(prep!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
prep.close();
}
}catch(SQLException e){
e.printStackTrace();
}
try{
if(conn!=null){//不能一起try,如果一起try，假如一个出问题，其他也出问题
conn.close();
}
}catch(SQLException e){
e.printStackTrace();
}
}
}
}
重点代码：
conn.setAutoCommit(flase);
conn.commit();
conn.rollback();
分布式事务（目前了解即可）
6.JDBC工具类的封装
引出问题：你有木有发现前面写的JDBC的六步太繁琐了，代码太多了，那可不可以简化呢？
当然可以，我们可以将其封装解决这个问题。
知识准备：
工具类的构造方法都是私有的。
因为工具类当中的方法都是静态的，不需要new对象，直接采用类名调用。
自己封装的工具类：
package Day1;
import java.sql.*;
public class JDBCTest3 {
private JDBCTest3(){
}
//静态代码块在类加载的时候只执行一次
static {
try {
Class.forName("com.mysql.jdbc.Driver");//注册驱动
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
//获取数据库连接
public static Connection getConnection() throws SQLException{
return DriverManager.getConnection("jdbc:mysql://localhost:3306/newdata?useSSL=false","root","123456");
}
/*conn 连接对象
* prep 数据库操作对象
* rs 结果集
* */
public static void close (Connection conn, Statement prep, ResultSet rs){
//6.释放资源
if(rs!=null){
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(prep!=null){
try {
prep.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
用自己封装的类实现模糊查询：
package Day1;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class JDBCTest4 {
public static void main(String[] args) {
Connection conn =null;
PreparedStatement prep =null;
ResultSet rs = null;
try {
//获取连接
conn=JDBCTest3.getConnection();
//获取预编译的数据库操作对象
String sql ="select name from t_student where name like ?";
prep=conn.prepareStatement(sql);
prep.setString(1,"_e%");
rs=prep.executeQuery();
while (rs.next()){
System.out.println(rs.getString("name"));
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JDBCTest3.close(conn,prep,rs);
}
}
}
7.行级锁（悲观锁和乐观锁）
1.乐观锁：多线程并发，都可以对一行数据修改，只不过需要设置一个版本号。
版本号：比如事务1和事务2开始读到版本号为1.
其中事务1先对数据进行了修改，修改后查找版本号为1，于是提交修改的数据，将版本号改为2.
然后事务2后修改，修改之后查询版本号为2，和最初的版本号不相同，进行回滚操作。
思考：根据上述描述发现，如果两个事务对数据同时修改就会造成，前者数据更新的丢失。
*利用数据库中的数据和已经取出的数据的一致性做为“锁”，与for update相比，乐观锁机制是等到更改数据的时候才去校验，悲观锁是读取数据就开始做了校验，从这个角度来看，乐观锁是对数据库没有额外开销，那么效率相对是高的。
*需要更改的字段可以作为乐观锁的验证字段；或者表里建立version版本号，每更新一次数据版本号+1；或者加lastupdatedate（最后更新时间）
2.悲观锁（行级锁）：事务必须进行排队，数据被锁住了，不允许并发。
在select最后面加上 for update;
单表for update:
没有在for update 时加nowait时，事务需要等待其他事务执行。加上后就不用等待其他事务执行了，一判断有事务，立马抛出异常。
1.select * from table where name= ‘MengYangChen’ for update 锁住了这条数据，那么另一个事务对该数据进行DML操作或者也执行同样的for update操作时，会检测到这笔数据上有行级锁，那么就会等待着锁释放；
2.select * from table where name= ‘MengYangChen’ nowait，意思就是如果这笔数据上本身加了锁，另一个事务去执行这句SQL的时候，发现加了锁，就会直接抛出异常（ORA-00054:资源正忙），不会等待这笔数据的锁释放。
3.select * from table where name= ‘MengYangChen’ wait 5；意思就是如果这笔数据被锁住，另外一个人如果执行这句SQL后，会等待5秒，如果5秒后这句SQL还没有得到这笔数据的锁，就会抛出异常。
4.skip locked
例如：我们如果先执行 A语句：select * from table where name=‘MengYangChen’ for update 这样就会把MengYangChen这行加上锁，然后再执行 B语句的时候：select * from table where name = ‘MengYangChen’ and name=‘XingKong’ for update;这时候肯定查不出来，因为A已经把B要加锁的数据锁了，这样B语句，连XingKong改行的数据都查不出来。
我们可以用skip locked解决该问题：
把B语句改为：select * from table where name = ‘MengYangChen’ and name=‘XingKong’ for update skip locked；意思就是执行的时候如果发现要查询的数据有锁，就把加了锁的数据跳过，把剩下未加锁的数据加锁，然后查询出来！
关联表for update:
现在大部分业务都是联表查询，如果用for update 的话，就会把所有关联表查询出来的列所在的行全部加锁。
例如：select * from t1,t2 where t1.id = t2.id and t1.age = ‘20’ for update；就会把t1和t2两个表中符合条件的行锁定。
那如果我只想锁住一个表该怎么办呢？
在for update后面添加 of column_name(你要加锁的字段名）。
例子：select * from t1,t2 where t1.id = t2.id and t1.age = ‘20’ for update of t1.id;这样只会对t1符合条件的行进行加锁。
关注公众号【轻松玩编程】后台回复“计算机资源”即可获取学习资源。
“一朵花凋零荒芜不了整个春天，一次跌倒也荒废不了整段旅程。走下去，凭着耐心和拼搏，生活自会给予你全部答案。”
我是梦阳辰，期待与你相遇！看到这里素质三连一下呗！