• 一文带你搞定JDBC


    前言:“只有自己强大,才不会被别人践踏。”
    你好,我是梦阳辰,让我们轻松玩编程,一起走进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符合条件的行进行加锁。

    关注公众号【轻松玩编程】后台回复“计算机资源”即可获取学习资源。

    “一朵花凋零荒芜不了整个春天,一次跌倒也荒废不了整段旅程。走下去,凭着耐心和拼搏,生活自会给予你全部答案。”
    我是梦阳辰,期待与你相遇!看到这里素质三连一下呗!


     
    以梦为马,不负韶华。
  • 相关阅读:
    阅读ajax.pdf
    XPath 学习
    随想
    Angular JS 学习
    Angular JS 学习
    URL Rewrite in IIS with Regular Pattern
    LinQ In Action 学习第四章
    GC垃圾回收
    jvm底层
    类加载流程
  • 原文地址:https://www.cnblogs.com/huangjiahuan1314520/p/12796893.html
Copyright © 2020-2023  润新知