JDBC+SQL注入+事务的特性和隔离级别

一.JDBC

1.概念

JDBC: Java DataBase Connectivity 使用Java语言操作数据库,就是使用Java语言，去操作数据库。
		  JDBC，其实就是Java定义的一套和数据库建立连接的规范(接口)，那么各家数据库厂商， 想要Java去操作各家的数据库，必须实现这套接口，我们把数据库厂商写的这套实现类，称之为数据库驱动。

2.快速入门

JDBC 六步:
1.导入数据库的驱动jar包  注意各个版本所使用的jar包是不同的,以及要添加依赖
2.加载驱动jar包  
   只需要加载驱动,Driver类中会自动创建驱动对象
3.获取连接对象
4.获取操作对象
5.执行sql语句
6.释放资源

Driver类:

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        try {
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

JDBC六步连接:

package org.westos.demo;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class MyTest {
    public static void main(String[] args) throws Exception{
        //jdbc数据库连接的六步操作
        //1.导入jar包,记得添加依赖

        //2.加载驱动,只需要加载驱动,Driver类会自动注册驱动对象
        Class.forName("com.mysql.jdbc.Driver");

        //3.获取连接对象
        String url="jdbc:mysql://localhost:3306/mydb2";
        String username="root";
        String password="123456";
        Connection connection = DriverManager.getConnection(url, username, password);

        //4.获取操作对象
        Statement statement = connection.createStatement();

        //5.发送sql  executeUpdate()执行增删改操作 DML
        //返回值 返回的是影响的行数
        int i = statement.executeUpdate("insert into user values(11,'lbw','123456')");
        if (i!=0){
            System.out.println("插入成功");
        }else {
            System.out.println("插入失败");
        }

        //6.释放资源
        connection.close();
        statement.close();

    }
}

3.JDBC 5.x和8.x的区别

1.jar包要导入9.x的jar包  参数要在后面进行拼接
   String url = "jdbc:mysql://127.0.0.1:3306/mydb?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8";
2.Driver类的位置改变了
   JDBC driver 由“com.mysql.jdbc.Driver”改为“com.mysql.cj.jdbc.Driver”

4.语法

package org.westos.demo;

import com.mysql.jdbc.NonRegisteringDriver;

import java.sql.*;

public class MyTest2 {
    public static void main(String[] args) throws Exception {
        //1.导入驱动jar包
        //2.加载驱动 Driver.class  也可以省略不写。
        Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");

    /*
    Driver类:
        public class Driver extends NonRegisteringDriver implements java.sql.Driver {
            public Driver() throws SQLException {
            }

            static {
                try {
                    DriverManager.registerDriver(new Driver());
                } catch (SQLException var1) {
                    throw new RuntimeException("Can't register driver!");
                }
            }
        }*/

        //3.获取连接对象
       /*           主协议:字协议://主机:      端口/资源路径
        如果是本地连接，那么localhost:3306可以省略不写
        */
        //String url="jdbc:mysql://localhost:3306/mydb2";
        String url="jdbc:mysql:///mydb2";
        String username="root";
        String password="123456";
        //这里的用户名和密码就是使用数据库的用户的用户名和密码
        //DriverManager驱动管理类
        Connection connection = DriverManager.getConnection(url, username, password);
         /* java.sql
        接口 Connection与特定数据库的连接（会话）。在连接上下文中执行 SQL 语句并返回结果。*/

        //4.获取操作对象   Statement 用于执行静态 SQL 语句并返回它所生成结果的对象。
        Statement statement = connection.createStatement();

        //5.executeUpdate(""); 执行DML 增删改语句  返回值i 返回的是受影响的行数
        int i =statement.executeUpdate("insert into user values(12,'压缩','123456')");

          /*
            executeQuery() 执行DQL 查询语句
      ResultSet executeQuery (String sql)
        执行给定的 SQL 语句，该语句返回单个 ResultSet 对象。

        boolean execute (String sql)
        执行给定的 SQL 语句，该语句可能返回多个结果。返回的是一个Boolean类型*/
        //6.释放资源
        connection.close();
        statement.close();
    }
}

5.几个类的介绍

 Class.forName("com.mysql.jdbc.Driver"); 加载驱动，也可以省略不写
 注册驱动这个动作是Driver里面有个静态代码块在做
    static {
            try {
                DriverManager.registerDriver(new Driver());
            } catch (SQLException var1) {
                throw new RuntimeException("Can't register driver!");
            }
        }
        
 类 DriverManager Java提供的 管理一组 JDBC 驱动程序的基本服务。
 
 接口 Connection  试图建立到给定数据库 URL 的连接。
 接口 Statement 用于执行静态 SQL 语句并返回它所生成结果的对象。
  boolean b = statement.execute(sql);//用来执行所有的SQL语句 返回：
如果第一个结果为 ResultSet 对象，则返回 true；如果其为更新计数或者不存在任何结果，则返回 false 
  int i = statement.executeUpdate(sql);//用来执行DML语句 用来对表中数据进行增删改 返回值是影响的行数
        statement.executeQuery(sql);//用来执行DQl语句

6.结果集对象 ResultSet

 statement.executeQuery(sql);
 用来执行DQl语句,返回的是一个结果集对象ResultSet
 
 	结果集对象，是我们执行了查询语句之后返回的一个查询结果对象
ResultSet 对象具有指向其当前数据行的光标。 最初，光标被置于第一行之前。next 方法将光标移动到下一行；因为该方法在 ResultSet 对象没有下一行时返回 false，所以可以在 while循环中使用它来迭代结果集。

 while (resultSet.next()){
            //参数就是数据库中的字段序号 从1开始
            //String username = resultSet.getString(1);
            //int age = resultSet.getInt(2);
            //通过字段名来获取字段的值
            String username = resultSet.getString("username");
            int age = resultSet.getInt("age");
            //System.out.println(username+"==="+age);
            //我们从数据库中取出了数据，就是为了要使用这些数据，那我们就要对这些数据进行封装
            Student student = new Student(username, age);
            list.add(student);
        }

7.使用类封装数据库中的数据

数据库中的表对应Java中的类,字段对应属性值
  通常,我们会将类定义在同一个包下,起名为bean
	注意事项:
		bean中的实体类对应数据库中的表对应,字段和属性值要一一对应

User类:

package org.westos.bean;

public class User {
    //实体类中的属性名和数据类型要跟表中的字段名和数据类型保持一致。
    private int id;
    private String name;
    private String password;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    public User() {
    }
}

测试类:

package org.westos.demo;

import org.westos.bean.User;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;

//测试类
public class MyTest3 {
    public static void main(String[] args) throws Exception{
       //1.导入jar包,记得添加依赖
       //2.注册驱动
       Class.forName("com.mysql.jdbc.Driver");

       //3.获取连接对象
        String url="jdbc:mysql://localhost:3306/mydb2";
        String username="root";
        String password="123456";
        Connection connection = DriverManager.getConnection(url, username, password);

        //4.获取操作对象
        Statement statement = connection.createStatement();
        //执行查询语句
        String sql="select * from user,orders where user.id=orders.uid";
        //ResultSet 结果集对象
        ResultSet resultSet = statement.executeQuery(sql);
        ArrayList<User> list = new ArrayList<>();

        while (resultSet.next()){
            //根据列号或者列名来获得
            int id = resultSet.getInt(1);
            String username1 = resultSet.getString("username");
            String password1 = resultSet.getString("password");
           // System.out.println(id+"=="+username1+"=="+password1);
            /*  1==张三==123456
                2==李四==123456
                3==王五==123456*/
                //把查询出的数据，封装到对象中。
            User user = new User();
            user.setId(id);
            user.setName(username1);
            user.setPassword(password1);

            //把数据放到集合里
            list.add(user);
        }
        for (User user : list) {
            System.out.println(user);
            /*
            User{id=1, name='张三', password='123456'}
            User{id=2, name='李四', password='123456'}
            User{id=3, name='王五', password='123456'}
            */
        }
        //6.释放资源
        connection.close();
        statement.close();
        resultSet.close();
    }
}

8.模拟登录案例

package org.westos.demo;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Scanner;

public class MyTest4 {
    public static void main(String[] args) throws Exception{
        //模拟登录
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名");
        String username = sc.nextLine();
        System.out.println("请输入密码");
        String password = sc.nextLine();

        //使用JDBC从数据库中获取数据
        //2.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //3.获取连接对象
        String url="jdbc:mysql://localhost:3306/mydb2";
        String username1="root";
        String password1="123456";
        Connection connection = DriverManager.getConnection(url,username1,password1);
        //4.获取操作对象
        Statement statement = connection.createStatement();

        //5.执行sql语句,返回结果集对象 拼串,单引号也要拼起来
        //String sql="select * from user where user.usrname='"+zs+"' and user.password='"+123456+"'";
        String sql="select * from user where user.username='"+username+"'and user.password='"+password+"'";
        ResultSet resultSet = statement.executeQuery(sql);

        //如果查询出来就证明登录成功
        if (resultSet.next()){
            System.out.println("登录成功");
        }else {
            System.out.println("登录失败");
        }
        //6.释放资源
        connection.close();
        statement.close();
        resultSet.close();
    }
}

结果:

请输入用户名
	lbw
请输入密码
	123456
登录成功

9.SQL注入

SQL 注入:利用数据库大的语法规则漏洞，拼接一些特特殊的串，从而绕过数据库正常的规则校验。
例如,在模拟登录中,就可以使用sql注入绕过校验

package org.westos.demo;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Scanner;

public class MyTest5 {
    public static void main(String[] args) throws Exception{
        //SQL注入  模拟登录

        String username = "1' or '1'='1";

        String password = "1' or '1'='1";

        //使用JDBC从数据库中获取数据
        //2.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //3.获取连接对象
        String url="jdbc:mysql://localhost:3306/mydb2";
        String username1="root";
        String password1="123456";
        Connection connection = DriverManager.getConnection(url,username1,password1);
        //4.获取操作对象
        Statement statement = connection.createStatement();

        String sql="select * from user where user.username='"+username+"'and user.password='"+password+"'";
        ResultSet resultSet = statement.executeQuery(sql);

        if(resultSet.next()){
            System.out.println("登陆成功");
        }else{
            System.out.println("失败");
        }

        //释放资源
        connection.close();
        statement.close();
        resultSet.close();
    }
}

同样显示:登录成功

10.预编译操作对象 PreparedStatement

为了防止SQL注入攻击,可以使用PreparedStatement进行预编译获取操作对象,参数使用?占位,我们提前把sql传进			来，进行预编译
		对问号进行赋值 问号从左往右数，从1开始

package org.westos.demo;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class MyTest6 {
    public static void main(String[] args) throws Exception{
        //SQL注入  模拟登录

        String username = "1' or '1'='1";

        String password = "1' or '1'='1";

        //使用JDBC从数据库中获取数据
        //2.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //3.获取连接对象
        String url="jdbc:mysql://localhost:3306/mydb2";
        String username1="root";
        String password1="123456";
        Connection connection = DriverManager.getConnection(url,username1,password1);
        //4.获取操作对象
        //我们使用PreparedStatement可以预防sql注入的操作读写。我们提前把sql传进来，进行预编译
        //参数使用?占位
        String sql="select * from user where user.username=? and user.password=?";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //对问号进行赋值 问号从左往右数，从1开始
        preparedStatement.setString(1,username);
        preparedStatement.setString(2,password);
        //执行查询
        ResultSet resultSet = preparedStatement.executeQuery(sql);

        if(resultSet.next()){
            System.out.println("登陆成功");
        }else{
            System.out.println("失败");
        }

        //6.释放资源
        connection.close();
        preparedStatement.close();
        resultSet.close();
    }
}

现在就显示登录失败了.

11.从文件中取出数据

在同一个包下建一个工具类

package org.westos.utils;

import java.io.FileReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;

public class JDBCUtils {
    private static String url;
    private static String username;
    private static String password;

    //私有化构造
    private JDBCUtils(){
    }

    static {
        try {
            Properties properties = new Properties();
            properties.load(new FileReader("aaa.properties"));

            Class.forName(properties.getProperty("className"));
            url =properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    //获取连接对象
    public static Connection getConnection() throws Exception{
        Connection connection = DriverManager.getConnection(url, username, password);
        return connection;
    }
    //释放资源
    public static void close(Connection connection, Statement statement, ResultSet resultSet) throws Exception{
        if (connection != null) {
            connection.close();
        }
        if (statement != null) {
            statement.close();
        }
        if (resultSet != null) {
            resultSet.close();
        }
    }
        //返回失败需要方法的重载
    public static void close(Connection connection, Statement statement) throws Exception{
        if (connection != null) {
            connection.close();
        }
        if (statement != null) {
            statement.close();
        }

    }
}

配置文件

className=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb2
username=root
password=123456

测试类:

package org.westos.demo;

import org.westos.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class MyTest7 {
    public static void main(String[] args) throws Exception{
        Connection connection = JDBCUtils.getConnection();

        PreparedStatement preparedStatement = connection.prepareStatement("select * from user");

        ResultSet resultSet = preparedStatement.executeQuery();
        System.out.println(resultSet.next());
        JDBCUtils.close(connection, preparedStatement,resultSet);
    }
}

二.批处理

 插入大量数据时，一行一行插入过于缓慢,建议使用批处理来做
 statement.addBatch();//添加批处理，先将数据缓存起来
  statement.executeBatch();//执行批处理
  statement.clearBatch();//清空缓存

package org.westos.demo2;

import org.westos.bean.User;
import org.westos.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.ArrayList;

public class MyTest {
    public static void main(String[] args) throws Exception{
        //批处理
        //模拟一些数据
        ArrayList<User> list = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            User user=new User(i,"添加姓名"+i,"123456");
            list.add(user);
        }

        //获取数据库连接
        Connection connection = JDBCUtils.getConnection();
        System.out.println(connection);
        //("insert into users(id,username,password) values (?,?,?)");
        //String sql="insert into student(id,username,password) values(?,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement("insert into student2(id,username,password) values(?,?,?)");
        System.out.println(preparedStatement);
        //从list中取出数据
          for (User user : list) {
            preparedStatement.setInt(1,user.getId());
            preparedStatement.setString(2,user.getName());
            preparedStatement.setString(3,user.getPassword());
            //一行一行插入，效率慢。
            //preparedStatement.executeUpdate();
            //先把数据缓存起来
            preparedStatement.addBatch(); //添加到批处理
        }

        //统一执行批处理
        preparedStatement.executeBatch();

          
        //清空缓存。
        preparedStatement.clearBatch();

        //释放资源
        JDBCUtils.close(connection,preparedStatement);
    }
}

三.JDBC调用存储过程和函数

1.语法

1、通过Connection对象的prepareCall()方法创建一个CallableStatement对象的实例。在使用Connection对象的prepareCall()方法时，需要传入一个String类型的字符串，该字符串用于指明如何调用存储过程。
        
        语法:
       {?=call<procedure -name >[( < arg1 >,<arg2 >, ...)]} //调用函数的语法
        {call<procedure -name >[( < arg1 >,<arg2 >, ...)]}  //调用存储过程的语法

2、通过CallableStatement对象的registerOutParameter()方法注册OUT参数
3、通过CallableStatement对象的setXxx()方法设定IN或IN OUT参数
若想将参数默认值设为Null,可以使用setNull()方法
4、通过CallableStatement对象的execute()方法执行存储过程
5、如果所调用的是带返回参数的存储过程，还需要通过CallableStatement对象的getXxx()方法获取其返回值

2.JDBC调用存储过程

存储过程:

DELIMITER $$

CREATE
  
    PROCEDURE `mydb2`.`myTestPro7`(IN num INT, OUT countNum INT)
    
    BEGIN
		DELETE FROM student2 WHERE id = num;
		SELECT COUNT(*) INTO countNum FROM student2;
    END$$

DELIMITER ;

JDBC调用存储过程:

package org.westos.demo3;

import org.westos.utils.JDBCUtils;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.Types;

public class MyTest {
    public static void main(String[] args) throws Exception{
        //JDBC调用存储过程
        //  {call<procedure -name >[( < arg1 >,<arg2 >, ...)]}  //调用存储过程的语法
        // //调用server端的存储过程和函数
        Connection connection = JDBCUtils.getConnection();
        String sql="{call myTestPro7(?,?)}";
        //调用自定义的存储过程
        CallableStatement callableStatement = connection.prepareCall(sql);
        //设置IN模式下的输入参数
        callableStatement.setInt(1,1);
        //注册OUT模式下的输出参数
        callableStatement.registerOutParameter(2, Types.INTEGER);

        //执行SQL,execute()方法返回true/false，如果返回结果中包含ResultSet，返回true，其余情况返回false
        callableStatement.execute();
        int count = callableStatement.getInt(2);
        //获OUT模式下的参数返回值
        System.out.println(count);//99

    }
}

3. JDBC调用函数

语法:
  {?=call<procedure -name >[( < arg1 >,<arg2 >, ...)]} //调用函数的语法

函数:调用md5进行加密

package org.westos.demo3;

import org.westos.utils.JDBCUtils;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.Types;

public class MyTest2 {
    public static void main(String[] args) throws Exception{
        //  {?=call<procedure -name >[( < arg1 >,<arg2 >, ...)]} //调用函数的语法
        Connection conn = JDBCUtils.getConnection();
        // {?=call<procedure -name >[( < arg1 >,<arg2 >, ...)]} //调用函数的语法
        String sql="{?=call md5(?)}";
        CallableStatement callableStatement = conn.prepareCall(sql);
         //设置
        callableStatement.setString(2,"123456");
        //注册输出参数
        callableStatement.registerOutParameter(1, Types.VARCHAR);
        //执行
        callableStatement.execute();

        //获取函数的返回值。
        String string = callableStatement.getString(1);
        System.out.println(string);//e10adc3949ba59abbe56e057f20f883e

        conn.close();
        callableStatement.close();
    }
}

4.注意事项

1.输出参数要先进行注册
2.通过CallableStatement对象的execute()方法执行存储过程

四.获取自增长键的值

当向数据库中插入一条数据的时候，默认是拿不到自增主键的值的，

package org.westos.demo3;

import org.westos.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;

public class MyTest3 {
    public static void main(String[] args) throws Exception{
        //获取自增长键的值
        Connection connection = JDBCUtils.getConnection();

        //如果你要获取这个自增长键的值，那就再加一个参数 Statement.RETURN_GENERATED_KEYS
        String sql="insert into test2(name, age) values (?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);

        //往表里添加数据
        preparedStatement.setString(1,"李白");
        preparedStatement.setInt(2,20);

        int i = preparedStatement.executeUpdate();
        //获取自增长键的值
        ResultSet generatedKeys = preparedStatement.getGeneratedKeys();
        while (generatedKeys.next()){
            int keysInt = generatedKeys.getInt(1);
            System.out.println(keysInt);//3
        }

        JDBCUtils.close(connection,preparedStatement,generatedKeys);
    }
}

五.事务

1.概述

事务：一件事情，生活中指的是一些公事。
	数据库中的事务：一个操作，这个操作，可能会包含很多步骤，那么这些个步骤，必须看做一个统一的整齐，来组成这个事务。
	这些组成事务的步骤，要么同时成功，要么同时失败，不允许成功几个步骤，失败几个步骤。
转账：张三给李四转账。

基本概念：
事务使指一组最小逻辑操作单元，里面有多个操作组成。组成事务的每一部分必须要同时提交成功，如果有一个操作失败，整个操作就回滚。

2.事务的四大特性

事务ACID特性
	原子性（Atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。 
	一致性（Consistency）
事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
	隔离性（Isolation）
事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
	持久性（Durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响

默认情况下，Connection 对象处于自动提交模式下，这意味着它在执行每个语句后都会自动提交更改。

如果禁用了自动提交模式，那么要提交更改就必须显式调用commit 方法，否则无法保存数据库更改。

如果连接处于自动提交模式下，则它的所有 SQL 语句将被执行并作为单个事务提交。否则，它的 SQL 语句将聚集到事务中，直到调用 commit 方法或 rollback 方法为止。默认情况下，新连接处于自动提交模式。

事务的演示:转账操作

1.数据表bank

CREATE TABLE bank(
  id INT PRIMARY KEY AUTO_INCREMENT,
  NAME VARCHAR(30),
  money INT
)

INSERT INTO bank VALUES(NULL, '张三', 1000),(NULL, '李四', 1000);

2、转账(不同事务)

事务：一组SQL语句，要么同时成功，要么同时失败

转账：必须用到事务操作，张三-500，李四+500要么同时成功，要么同时失败，不能张三-500，而李四没有+500
        张三-500
        异常
        李四+500
  如果转账操作属于两个事务,则会出现下列情况

package org.westos.demo3;

import org.westos.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;

public class MyTest4 {
    public static void main(String[] args) throws Exception{
        //事务默认自动提交，两个操作分属两个不同的事务
        Connection connection1 = JDBCUtils.getConnection();
        Connection connection2 = JDBCUtils.getConnection();

        PreparedStatement ps1 = connection1.prepareStatement("update bank set money=money-500 where id=1");
        PreparedStatement ps2 = connection2.prepareStatement("update bank set money=money+500 where id=2");

        ps1.executeUpdate();
        //模拟异常,ps1提交,ps2未提交
        System.out.println(1/0);
        ps2.executeUpdate();
        
        JDBCUtils.close(connection1,ps1);
        JDBCUtils.close(connection2,ps2);
    }
}

发现:张三的钱减了,但是李四的钱没加,就是因为两次提交事务的过程中间遇到了异常,

​ 因此,转账操作应当属于一次事务

3.转账(一次事务)

异常转账:

package org.westos.demo3;

import org.westos.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;

public class MyTest5 {

    private static Connection connection;

    public static void main(String[] args) throws Exception{
        try {


            connection = JDBCUtils.getConnection();
            connection.setAutoCommit(false); //把事务设置为手动提交。

            PreparedStatement ps1 = connection.prepareStatement("update bank set money=money-500 where id=1");
            PreparedStatement ps2 = connection.prepareStatement("update bank set money=money+500 where id=2");
            ps1.executeUpdate();
            //模拟异常
            System.out.println(1 / 0);

            ps2.executeUpdate();

            //手动提交事务
            //connection.commit();

            JDBCUtils.close(connection, ps1);
            JDBCUtils.close(connection, ps2);
        } catch (Exception e) {
            e.printStackTrace();
            //一旦遇到异常，就回滚事务
            connection.rollback();
        }finally {
            //不管是否转账成功,都要提交事务
            connection.commit();
        }
        System.out.println("转账完成");

    }
}

正常转账:

package org.westos.demo3;

import org.westos.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;

public class MyTest2 {

    private static Connection connection;

    public static void main(String[] args) throws Exception{

        try {
            connection = JDBCUtils.getConnection();
            connection.setAutoCommit(false); //把事务设置为手动提交。

            PreparedStatement ps1 = connection.prepareStatement("update bank set money=money-500 where id=1");
            PreparedStatement ps2 = connection.prepareStatement("update bank set money=money+500 where id=2");
            ps1.executeUpdate();
            ps2.executeUpdate();

            //手动提交事务
            connection.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //一旦遇到异常，就回滚事务
            connection.rollback();
        } finally {
        }
    }
}

3.事务回滚到回滚点

事务的默认回滚点是初始化状态,及money都为1000状态,回滚点也可以手动去设置

package org.westos.demo3;

import org.westos.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.Savepoint;

public class MyTest6 {
    private static Connection connection;
    private static Savepoint savepoint;

    public static void main(String[] args) throws Exception{
        try {


            connection = JDBCUtils.getConnection();
            connection.setAutoCommit(false); //把事务设置为手动提交。

            //第一次转账

            PreparedStatement ps1 = connection.prepareStatement("update bank set money=money-500 where id=1");
            PreparedStatement ps2 = connection.prepareStatement("update bank set money=money+500 where id=2");
            ps1.executeUpdate();
            ps2.executeUpdate();

            //设置回滚点,savepoint是回滚点的名字
            savepoint = connection.setSavepoint();

            PreparedStatement ps3 = connection.prepareStatement("update bank set money=money-500 where id=1");
            PreparedStatement ps4 = connection.prepareStatement("update bank set money=money+500 where id=2");
            ps3.executeUpdate();
            //模拟异常
            System.out.println(1 / 0);
            ps4.executeUpdate();

        }catch (Exception e){
            e.printStackTrace();
            //一旦遇到异常，就回滚事务
            //connection.rollback();
            //回滚到回滚点的地方,传入参数代表是回滚点的名字
             connection.rollback(savepoint);
        }finally {
            connection.commit();
        }
    }
}

六.事务的隔离级别

事务总结:
	事务的特性:★★★
		ACID
		原子性:事务里面的操作单元不可切割,要么全部成功,要么全部失败
		一致性:事务执行前后,业务状态和其他业务状态保持一致.
		隔离性:一个事务执行的时候最好不要受到其他事务的影响
		持久性:一旦事务提交或者回滚.这个状态都要持久化到数据库中
		
		
	不考虑隔离性会出现的读问题★★
		脏读:在一个事务中读取到另一个事务没有提交的数据
		
		不可重复读:在一个事务中,两次查询的结果不一致(针对的update操作)  不可重复读，是指在数据库访问中，一个事务范围内两个相同的查询却返回了不同数据。
		虚读(幻读):在一个事务中,两次查询的结果不一致(针对的insert操作) 无法演示出来,MySQL已经默认避免了
		
			MySQL 有四种隔离级别

	通过设置数据库的隔离级别来避免上面的问题(理解)
		read uncommitted  	读未提交	上面的三个问题都会出现
		read committed  	读已提交	可以避免脏读的发生 Oracle 默认级别
		repeatable read		可重复读	可以避免脏读和不可重复读的发生  MySQL 默认级别
		serializable		串行化		可以避免所有的问题
	了解
		演示脏读的发生:
			将数据库的隔离级别设置成 读未提交
				set session transaction isolation level read uncommitted;
			查看数据库的隔离级别
				select @@tx_isolation;
			演示:
			打开两个窗口进行演示:给两个窗口设置好同的隔离级别
			开启事务  start transaction;
			修改数据:update bank set money=1500 where username='lisi';
			让另一个窗口开启事务 查询数据 他查到了  就是脏读
			我这边窗口 一回滚(rollback),钱又没过去
		避免脏读的发生,将隔离级别设置成  读已提交
			set session transaction isolation level read committed;
			不可避免不可重复读的发生.
		
		避免不可重复读的发生 经隔离级别设置成 可重复读
			set session transaction isolation level  repeatable read;
			
		演示串行化 可以避免所有的问题
			set session transaction isolation level  serializable;  我这边的事务不提交,那边的事务无法执行
			锁表的操作. 
		
	四种隔离级别的效率
		read uncommitted>read committed>repeatable read>serializable
	四种隔离级别的安全性
		read uncommitted<read committed<repeatable read<serializable
		
	开发中绝对不允许脏读发生.
		mysql中默认级别:repeatable read
		oracle中默认级别:read committed

	java中控制隔离级别:(了解)
		Connection的api
			void setTransactionIsolation(int level) 
				level是常量