前言:“只有自己强大,才不会被别人践踏。”
你好,我是梦阳辰,让我们轻松玩编程,一起走进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符合条件的行进行加锁。
关注公众号【轻松玩编程】后台回复“计算机资源”即可获取学习资源。
“一朵花凋零荒芜不了整个春天,一次跌倒也荒废不了整段旅程。走下去,凭着耐心和拼搏,生活自会给予你全部答案。”
我是梦阳辰,期待与你相遇!看到这里素质三连一下呗!