JDBC内容学习

快速入门

1. 创建工程
2. 加载驱动
3. 获得连接
4. 创建执行sql语句对象
5. 执行sql语句，处理结果
6. 释放资源

package com.gavin._02JDBC快速入门;

import com.mysql.jdbc.Driver;   //jar包驱动里面的内容

import java.sql.*;   //java的包

public class Test {
    public static void main(String[] args) throws SQLException {
        //1.   创建java项目,导入mysql驱动jar包
        //2.   加载驱动
        DriverManager.registerDriver(new Driver());

        //3.   获得连接
        String url="jdbc:mysql://127.0.0.1:3306/day01";
        String user="root";
        String password="asd";
        Connection connection = DriverManager.getConnection(url,user,password);

        //4.   创建执行sql语句对象
        Statement statement = connection.createStatement();

        //5.   执行sql语句，处理结果
        String sql = "select * from user";
        ResultSet resultSet = statement.executeQuery(sql);
        while (resultSet.next()){
            //取出来
//            System.out.println(resultSet.getObject("id")+" ");
//            System.out.println(resultSet.getObject("username")+" ");
//            System.out.println(resultSet.getObject("password")+" ");
//            System.out.println(resultSet.getObject("nickname")+" ");
            System.out.print(resultSet.getObject(1)+" ");
            System.out.print(resultSet.getObject(2)+" ");
            System.out.print(resultSet.getObject(3)+" ");
            System.out.println(resultSet.getObject(4));
            System.out.println("---------------");
        }

        //6.   释放资源
        if (resultSet != null){
            resultSet.close();
        }
        if (statement != null){
            statement.close();
        }
        if (connection != null){
            connection.close();
        }
    }
}

关于驱动的理解说明：

Dirver类实现了Driver接口，接口里还有好多方法，都是连接有关的。所以要这个Dirver类，来被DriverManager类来管理操作。

Class.forName(url); 括号内的是全路径，com.mysql.jdbc.Driver是导入的jar包里面的类Dirver所在路径。

看Driver类源码发现，Driver类是jar包里面的。查阅javaAPI文档发现，JDBC提供的是Dirver接口。

Driver类源码：

所以导入驱动Class.forName(com.mysql.jdbc.Dirver)这句话的意思就是：

写了这句话，
加载Driver类的时候会执行里面的static代码块 ，

从而执行DriverManager.xxxxxx这句话，

最终目的就只是为了执行DriverManager.xxxxxxx这句话来newDriver类放入Manager里而已。

而且：

除了这句话用了驱动jar包里的一个Driver类这个东西，jdbc后面的代码全是JDBC的API，jdbc的api是jdk自带的api ，所以后面的代码没用导的驱动jar包里的任何东西！

如果不写这句话，因为后面的都只用了jdk自带的JDBC的API，没导入驱动jar包也不报任何错。

所以，要有这句话！也就是老师解释的，这句话告诉了JDBC目标数据库是mysql还是别的东西，也就是说把相应的东西安装进来，把数据库的东西告诉他，不写这句话驱动jar包白导了。

JDBC API详解

JDBC的接口是在javaAPI里的，jdk自带的，

但驱动，这些接口的实现类，在javaAPI里面没有。

Drivermanager类

驱动管理类（管理驱动的类）

void registerDriver(Driver driver)方法：

调用 registerDriver 方法传入驱动类（driver类）的对象。

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

如果使用API的方式注册驱动，Driver会new两次，所以推荐这种写法：

Class.forName("com.mysql.jdbc.Driver");

反射，导致类的加载，类加载代码块自动执行，就会执行com.mysql.jdbc.Driver里面的静态代码块内容。

getConnection(String url, String user, String password) 方法：

与数据库建立连接

Connection接口

Statement接口

概述：

接口的实现在数据库驱动中. 用来操作sql语句(增删改查)，并返回相应结果对象

作用：

ResultSet executeQuery(String sql) ：

根据查询语句返回结果集。只能执行select语句。

int executeUpdate(String sql) ：

根据执行的DML（insert update delete）语句，返回受影响的行数。

boolean execute(String sql) ：

此方法可以执行任意sql语句，返回boolean值：

为 true: 执行select有查询的结果

为 false: 执行insert, delete,update, 执行select没有查询的结果

ResultSet接口

1. 封装结果集,查询结果表的对象;

   提供一个游标，默认游标指向结果集第一行之前。

   调用一次next()，游标向下移动一行。

   提供一些get方法。

2. ResultSet接口常用API

    boolean next();将光标从当前位置向下移动一行

    int getInt(int colIndex)以int形式获取ResultSet结果集当前行指定列号值

    int getInt(String colLabel)以int形式获取ResultSet结果集当前行指定列名值

    float getFloat(int colIndex)以float形式获取ResultSet结果集当前行指定列号值

    float getFloat(String colLabel)以float形式获取ResultSet结果集当前行指定列名值

    String getString(int colIndex)以String 形式获取ResultSet结果集当前行指定列号值

    String getString(String colLabel)以String形式获取ResultSet结果集当前行指定列名值

    Date getDate(int columnIndex); 以Date 形式获取ResultSet结果集当前行指定列号值

    Date getDate(String columnName);以Date形式获取ResultSet结果集当前行指定列名值

    void close()关闭ResultSet 对象

package com.gavin._02JDBC快速入门;

public class User {

    private int id;
    private String username;
    private String password;
    private String nickname;

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

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

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

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

package com.gavin._02JDBC快速入门;

import com.mysql.jdbc.Driver;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) throws Exception {
        //1.   创建java项目,导入mysql驱动jar包
        //2.   加载驱动
//        DriverManager.registerDriver(new Driver());
        Class.forName("com.mysql.jdbc.Driver"); //推荐

        //3.   获得连接
        String url="jdbc:mysql://127.0.0.1:3306/day01";
        String user="root";
        String password="asd";
        Connection connection = DriverManager.getConnection(url,user,password);

        //4.   创建执行sql语句对象
        Statement statement = connection.createStatement();

        //5.   执行sql语句，处理结果
        String sql = "select * from user";
        ResultSet resultSet = statement.executeQuery(sql);

        List<User> list = new ArrayList<>();
        while (resultSet.next()){
            //取出来
//            System.out.println(resultSet.getObject("id")+" ");
//            System.out.println(resultSet.getObject("username")+" ");
//            System.out.println(resultSet.getObject("password")+" ");
//            System.out.println(resultSet.getObject("nickname")+" ");
//            System.out.print(resultSet.getObject(1)+" ");
//            System.out.print(resultSet.getObject(2)+" ");
//            System.out.print(resultSet.getObject(3)+" ");
//            System.out.println(resultSet.getObject(4));

//            System.out.print(resultSet.getInt("id")+" ");
//            System.out.print(resultSet.getString("username")+" ");
//            System.out.print(resultSet.getString("password")+" ");
//            System.out.println(resultSet.getString("nickname"));
//            System.out.println("---------------");

            User user1 = new User();
            //没遍历一次，就有一条记录，封装到一个user对象中
            user1.setId(resultSet.getInt("id"));
            user1.setUsername(resultSet.getString("username"));
            user1.setPassword(resultSet.getString("password"));
            user1.setNickname(resultSet.getString("nickname"));

            list.add(user1);
        }

        //6.   释放资源（就是把上面创建的所有对象释放了）
        if (resultSet != null){
            resultSet.close();
        }
        if (statement != null){
            statement.close();
        }
        if (connection != null){
            connection.close();
        }

        System.out.println(list);
    }
}

JDBC操作数据库

案例-增删改查练习

需求

• 使用JDBC完成增删改查练习

package com.gavin._03JDBC完成增删改查;

import com.gavin._02JDBC快速入门.User;
import org.junit.Test;

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

public class Demo {

    //往day01数据库的user表中添加一条记录
    @Test
    public void insert() throws Exception {
        //1.   加载驱动
        Class.forName("com.mysql.jdbc.Driver"); //推荐

        //2.   获得连接
        String url="jdbc:mysql://127.0.0.1:3306/day01?useUnicode=true&characterEncoding=utf8";
        String user="root";
        String password="asd";
        Connection connection = DriverManager.getConnection(url,user,password);

        //3.   创建执行sql语句对象
        Statement statement = connection.createStatement();

        //4.   执行sql语句，处理结果
        String sql = "insert into user values(null,'zl','123456','赵六')";
        int rows = statement.executeUpdate(sql);
        System.out.println("受影响的行数："+rows);

        //5.   释放资源
        if (statement != null){
            statement.close();
        }
        if (connection != null){
            connection.close();
        }
    }

    //修改day01数据库的user表中wangwu的密码123456
    @Test
    public void update() throws Exception {
        //1.   加载驱动
        Class.forName("com.mysql.jdbc.Driver"); //推荐

        //2.   获得连接
        String url="jdbc:mysql://127.0.0.1:3306/day01?useUnicode=true&characterEncoding=utf8";
        String user="root";
        String password="asd";
        Connection connection = DriverManager.getConnection(url,user,password);

        //3.   创建执行sql语句对象
        Statement statement = connection.createStatement();

        //4.   执行sql语句，处理结果
        String sql = "update user set password='123456' where username='wangwu'";
        int rows = statement.executeUpdate(sql);
        System.out.println("受影响的行数："+rows);

        //5.   释放资源
        if (statement != null){
            statement.close();
        }
        if (connection != null){
            connection.close();
        }
    }

    //删除day01数据库的user表中wangwu
    @Test
    public void delete() throws Exception {
        //1.   加载驱动
        Class.forName("com.mysql.jdbc.Driver"); //推荐

        //2.   获得连接
        String url="jdbc:mysql://127.0.0.1:3306/day01?useUnicode=true&characterEncoding=utf8";
        String user="root";
        String password="asd";
        Connection connection = DriverManager.getConnection(url,user,password);

        //3.   创建执行sql语句对象
        Statement statement = connection.createStatement();

        //4.   执行sql语句，处理结果
        String sql = "delete from user where username='wangwu'";
        int rows = statement.executeUpdate(sql);
        System.out.println("受影响的行数："+rows);

        //5.   释放资源
        if (statement != null){
            statement.close();
        }
        if (connection != null){
            connection.close();
        }
    }

    //查询day01数据库的user表数据
    @Test
    public void select() throws Exception {
        //1.   加载驱动
        Class.forName("com.mysql.jdbc.Driver"); //推荐

        //2.   获得连接
        String url="jdbc:mysql://127.0.0.1:3306/day01";
        String user="root";
        String password="asd";
        Connection connection = DriverManager.getConnection(url,user,password);

        //3.   创建执行sql语句对象
        Statement statement = connection.createStatement();

        //4.   执行sql语句，处理结果
        String sql = "select * from user";
        ResultSet resultSet = statement.executeQuery(sql);

        List<User> list = new ArrayList<>();
        while (resultSet.next()){

            User user1 = new User();
            //每遍历一次，就有一条记录，封装到一个user对象中
            user1.setId(resultSet.getInt("id"));
            user1.setUsername(resultSet.getString("username"));
            user1.setPassword(resultSet.getString("password"));
            user1.setNickname(resultSet.getString("nickname"));

            list.add(user1);
        }

        //5.   释放资源
        if (resultSet != null){
            resultSet.close();
        }
        if (statement != null){
            statement.close();
        }
        if (connection != null){
            connection.close();
        }

        System.out.println(list);
    }
}

JDBCUtils工具类读取配置文件

db.properties：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/day01?useUnicode=true&characterEncoding=utf8
user=root
password=asd

JDBCUtils：

package com.gavin.utils;

import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JDBCUtils {

    private static String driver;
    private static String url;
    private static String user;
    private static String password;

    static {
        try {
            //使用Properties对象加载配置文件
            //创建Properties对象
            Properties pro = new Properties();

            //读取配置文件中的数据
//            pro.load(new FileInputStream("day01\\srcc\\dp.properties"));
            //返回输入流的路径默认到src路径
            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("dp.properties");
            pro.load(is);

            //通过pro对象给属性赋值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");

            //1.加载驱动
            Class.forName(driver);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获得连接
     *
     * @return  连接
     * @throws Exception
     */
    public static Connection getConnection() throws Exception{
        //2.获得连接
        Connection connection = DriverManager.getConnection(url,user,password);
        return connection;
    }

    /**
     * 释放资源
     *
     * @param resultSet
     * @param statement
     * @param connection
     */
    public static void release(ResultSet resultSet, Statement statement,Connection connection){
        if (resultSet != null){
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement != null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

测试：

package com.gavin._04JDBC工具类测试;

import com.gavin._02JDBC快速入门.User;
import com.gavin.utils.JDBCUtils;

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

public class Test {

    //往day01数据库的user表中添加一条记录
    @org.junit.Test
    public void insert() throws Exception {
        Connection connection = JDBCUtils.getConnection();

        //3.创建执行sql语句对象
        Statement statement = connection.createStatement();

        //4.执行sql语句，处理结果
        String sql = "insert into user values(null,'wangwu','123','王五')";
        int rows = statement.executeUpdate(sql);
        System.out.println("受影响的行数："+rows);

        //5.释放资源
        JDBCUtils.release(null,statement,connection);
    }

    //修改day01数据库的user表中wangwu的密码123456
    @org.junit.Test
    public void update() throws Exception {
        Connection connection = JDBCUtils.getConnection();

        //3.创建执行sql语句对象
        Statement statement = connection.createStatement();

        //4.执行sql语句，处理结果
        String sql = "update user set password='123456' where username='wangwu'";
        int rows = statement.executeUpdate(sql);
        System.out.println("受影响的行数："+rows);

        //5.释放资源
        JDBCUtils.release(null,statement,connection);
    }

    //删除day01数据库的user表中zl
    @org.junit.Test
    public void delete() throws Exception {
        Connection connection = JDBCUtils.getConnection();

        //3.创建执行sql语句对象
        Statement statement = connection.createStatement();

        //4.执行sql语句，处理结果
        String sql = "delete from user where username='zl'";
        int rows = statement.executeUpdate(sql);
        System.out.println("受影响的行数："+rows);

        //5.释放资源
        JDBCUtils.release(null,statement,connection);
    }

    //查询day01数据库的user表数据
    @org.junit.Test
    public void select() throws Exception {
        Connection connection = JDBCUtils.getConnection();

        //3.创建执行sql语句对象
        Statement statement = connection.createStatement();

        //4.执行sql语句，处理结果
        String sql = "select * from user";
        ResultSet resultSet = statement.executeQuery(sql);

        List<User> list = new ArrayList<>();
        while (resultSet.next()){

            User user1 = new User();
            //每遍历一次，就有一条记录，封装到一个user对象中
            user1.setId(resultSet.getInt("id"));
            user1.setUsername(resultSet.getString("username"));
            user1.setPassword(resultSet.getString("password"));
            user1.setNickname(resultSet.getString("nickname"));

            list.add(user1);
        }

        //5.释放资源
        JDBCUtils.release(resultSet,statement,connection);

        System.out.println(list);
    }
}

JDBCUtils:

然后，连接信息给提炼出来写法(使用db.properties)：

Utils中：

配置文件解析原理

PreparedStatement

写sql时条件要条件（username=值），上面都不要条件直接select*

案例：登录案例

需求：

在控制台输入用户名和密码,查询数据库,如果数据库存在当前用户,显示登录成功!

如果数据库不存在当前用户,显示登录失败!

package com.gavin._05登录案例;

import com.gavin._02JDBC快速入门.User;
import com.gavin.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/*
需求
 在控制台输入用户名和密码,查询数据库,如果数据库存在当前用户,显示登录成功!
 如果数据库不存在当前用户,显示登录失败!
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        //1.获取用户输入的用户名和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请用户输入用户名：");
        String username = sc.nextLine();
        System.out.println("请用户输入密码：");
        String password = sc.nextLine();

        //2.根据用户输入的用户名和密码去数据库查询数据，然后封装到User对象中
        //2.1 获得连接
        Connection connection = JDBCUtils.getConnection();

        //2.2 创建执行sql语句对象
        Statement statement = connection.createStatement();

        //2.3 执行sql语句，处理结果
        String sql = "select * from user where username='"+username+"' and password='"+password+"'";
//        select * from user where username='zs' and password='123465";
        ResultSet resultSet = statement.executeQuery(sql);

        User user = null;
        while (resultSet.next()){

            user = new User();
            //每遍历一次，就有一条记录，封装到一个user对象中
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }

        //2.4 释放资源
        JDBCUtils.release(resultSet,statement,connection);

        //3.判断是否查询到了数据
        if (user != null){
            //3.1 如果查到了数据，就显示登录成功
            System.out.println("登陆成功！");
        }else {
            //3.2 如果没查到数据，就显示登录失败
            System.out.println("登陆失败！");
        }
    }
}

登录中SQL注入问题

上面案例遇到sql注入的问题：

注入问题解决：PreparedStatement

PreparedStatement概述：

预编译sql语句，是Statement接口的子接口。

特点：

 性能要比Statemt要高

 会把sql语句先编译，格式固定好

 sql语句中的参数会发生变化，过滤掉用户输入的关键字（比如：or）

用法：

 通过connection对象创建

 connection. preparedStatement(String sql);创建PreparedStatement对象

 sql表示预编译的sql语句，如果sql语句有参数用？来占位

package com.gavin._06登录中SQL注入问题解决;

import com.gavin._02JDBC快速入门.User;
import com.gavin.utils.JDBCUtils;

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

/*
需求
 在控制台输入用户名和密码,查询数据库,如果数据库存在当前用户,显示登录成功!
 如果数据库不存在当前用户,显示登录失败!
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        //1.获取用户输入的用户名和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请用户输入用户名：");
        String username = sc.nextLine();
        System.out.println("请用户输入密码：");
        String password = sc.nextLine();

        //2.根据用户输入的用户名和密码去数据库查询数据，然后封装到User对象中
        //2.1 获得连接
        Connection connection = JDBCUtils.getConnection();

        //2.2 创建执行sql语句对象
        String sql = "select * from user where username=? and password=?";
        PreparedStatement ps = connection.prepareStatement(sql);

        //2.3 设置参数
        ps.setString(1,username);
        ps.setString(2,password);

        //2.3 执行sql语句，处理结果
        ResultSet resultSet = ps.executeQuery();//注意：这个时候不再传入sql语句

        User user = null;
        while (resultSet.next()){

            user = new User();
            //每遍历一次，就有一条记录，封装到一个user对象中
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }

        //2.4 释放资源
        JDBCUtils.release(resultSet,ps,connection);

        //3.判断是否查询到了数据
        System.out.println(user);
        if (user != null){
            //3.1 如果查到了数据，就显示登录成功
            System.out.println("登陆成功！");
        }else {
            //3.2 如果没查到数据，就显示登录失败
            System.out.println("登陆失败！");
        }
    }
}

案例-使用preparedStatement完成CRUD

需求：

通过PreparedStatement完成增、删、改、查

package com.gavin._07使用preparedStatement完成CRUD;

import com.gavin._02JDBC快速入门.User;
import com.gavin.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

public class Demo {

    //往day01数据库的user表中添加一条记录
    @org.junit.Test
    public void insert() throws Exception {
        Connection connection = JDBCUtils.getConnection();

        //3.创建执行sql语句对象
        String sql = "insert into user values(null,?,?,?)";
        PreparedStatement ps = connection.prepareStatement(sql);

        //4.设置参数
        ps.setString(1,"zl");
        ps.setString(2,"123");
        ps.setString(3,"老六");

        //5.执行sql语句，处理结果
        int rows = ps.executeUpdate(); //Update返回行数或什么都不返回
        System.out.println("受影响的行数："+rows);

        //6.释放资源
        JDBCUtils.release(null,ps,connection);
    }

    //修改day01数据库的user表中zl的密码123456
    @org.junit.Test
    public void update() throws Exception {
        Connection connection = JDBCUtils.getConnection();

        //3.创建执行sql语句对象
        String sql = "update user set password=? where username=?";
        PreparedStatement ps = connection.prepareStatement(sql);

        //4.设置参数
        ps.setString(1,"123456");
        ps.setString(2,"zl");

        //5.执行sql语句，处理结果
        int rows = ps.executeUpdate();
        System.out.println("受影响的行数："+rows);

        //6.释放资源
        JDBCUtils.release(null,ps,connection);
    }

    //删除day01数据库的user表中zl
    @org.junit.Test
    public void delete() throws Exception {
        Connection connection = JDBCUtils.getConnection();

        //3.创建执行sql语句对象
        String sql = "delete from user where username=?";
        PreparedStatement ps = connection.prepareStatement(sql);

        //4.设置参数
        ps.setString(1,"zl");

        //5.执行sql语句，处理结果
        int rows = ps.executeUpdate();
        System.out.println("受影响的行数："+rows);

        //6.释放资源
        JDBCUtils.release(null,ps,connection);
    }

    //查询day01数据库的user表数据
    @org.junit.Test
    public void select() throws Exception {
        Connection connection = JDBCUtils.getConnection();

        //3.创建执行sql语句对象
        String sql = "select * from user";
        PreparedStatement ps = connection.prepareStatement(sql);

        //4.执行sql语句，处理结果
        ResultSet resultSet = ps.executeQuery();//executeQuery返回大量数据封装进的ResultSet对象

        List<User> list = new ArrayList<>();
        while (resultSet.next()){

            User user = new User();
            //每遍历一次，就有一条记录，封装到一个user对象中
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));

            list.add(user);
        }

        //5.释放资源
        JDBCUtils.release(resultSet,ps,connection);

        System.out.println(list);
    }

}

JDBC事务的处理

JDBC事务介绍

package com.gavin._08JDBC事务操作;

import com.gavin.utils.JDBCUtils;

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

public class Demo {

    public static void main(String[] args) throws Exception {
        Connection connection = null;
        PreparedStatement ps = null;
        try{
            //1.获得连接
            connection = JDBCUtils.getConnection();

            //2.开启事务
            connection.setAutoCommit(false);

            //3.创建执行sql语句对象
            String sql = "update user set password=? where username=?";
            ps = connection.prepareStatement(sql);

            //4.设置参数
            ps.setString(1,"123");
            ps.setString(2,"ls");

            //5.执行sql语句，处理结果
            int rows = ps.executeUpdate();
            System.out.println("受影响的行数："+rows);

            int i=1/0;//出现异常

            //6.提交事务
            connection.commit();
        }catch (Exception e){
            e.printStackTrace();
            //如果出现异常就回滚事务
            connection.rollback();
        }finally {
            //7.释放资源
            JDBCUtils.release(null,ps,connection);
        }
    }
}

案例-转账案例

 案例的准备工作：建account表

create table account(

id int primary key auto_increment,

name varchar(20),

money double

);

insert into account values (null,'zs',1000);

insert into account values (null,'ls',1000);

insert into account values (null,'ww',1000);

需求

zs给ls转100, 使用事务进行控制

package com.gavin._09转账案例;

import com.gavin.utils.JDBCUtils;

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

/*
需求
 zs给ls转100, 使用事务进行控制

 */
public class Demo {
    public static void main(String[] args) throws Exception {
        Connection connection = null;
        PreparedStatement ps1 = null;
        PreparedStatement ps2 = null;
        try{
            //1.获得连接
            connection = JDBCUtils.getConnection();

            //2.开启事务
            connection.setAutoCommit(false);

            //3.创建执行sql语句对象
            String sql1 = "update account set money=money-? where name=?";
            String sql2 = "update account set money=money+? where name=?";
            ps1 = connection.prepareStatement(sql1);
            ps2 = connection.prepareStatement(sql2);

            //4.设置参数
            //zs账户-100
            ps1.setDouble(1,100);
            ps1.setString(2,"zs");
            ps1.executeUpdate();

            int i=1/0;//出现异常

            //ls账户+100
            ps2.setDouble(1,100);
            ps2.setString(2,"ls");
            ps2.executeUpdate();

            //5.提交事务
            connection.commit();
        }catch (Exception e){
            e.printStackTrace();
            //如果出现异常就回滚事务
            connection.rollback();
        }finally {
            //6.释放资源
            JDBCUtils.release(null,ps1,connection);
            JDBCUtils.release(null,ps2,null);
        }
    }
}