10、JDBC相关

最新推荐文章于 2023-05-20 13:32:32 发布

言叶.

最新推荐文章于 2023-05-20 13:32:32 发布

阅读量140

点赞数

分类专栏： MySQL 文章标签： mysql sql 数据库

原文链接：https://www.cnblogs.com/xdp-gacl/p/4002804.html

版权

MySQL 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

10.1、数据库驱动

这里的驱动的概念和平时听到的那种驱动的概念是一样的，比如平时购买的声卡，网卡直接插到计算机上面是不能用的，必须要安装相应的驱动程序之后才能够使用声卡和网卡，同样道理，我们安装好数据库之后，我们的应用程序也是不能直接使用数据库的，必须要通过相应的数据库驱动程序，通过驱动程序去和数据库打交道，如下所示：

10.2、JDBC介绍

SUN公司为了简化、统一对数据库的操作，定义了一套Java操作数据库的规范（接口），称之为JDBC。这套接口由数据库厂商去实现，这样，开发人员只需要学习jdbc接口，并通过jdbc加载具体的驱动，就可以操作数据库。

如下图所示：

JDBC全称为：Java Data Base Connectivity（java数据库连接），它主要由接口组成。

组成JDBC的２个包：java.sql、javax.sql

开发JDBC应用需要以上2个包的支持外，还需要导入相应JDBC的数据库实现(即数据库驱动)。

10.3、编写JDBC程序

搭建实验环境

CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci; 

USE jdbcStudy; 

CREATE TABLE users( 

	id INT PRIMARY KEY, 
    NAME VARCHAR(40), 
    PASSWORD VARCHAR(40), 
    email VARCHAR(60), 
    birthday DATE 
);

INSERT INTO users(id,NAME,PASSWORD,email,birthday) 
VALUES(1,'zhansan','123456','zs@sina.com','1980-12-04'), 
(2,'lisi','123456','lisi@sina.com','1981-12-04'), 
(3,'wangwu','123456','wangwu@sina.com','1979-12-04');

新建一个Java工程，并导入数据驱动

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fnXQMrao-1618929561338)(E:\学习\Topora\MySQL\image-20210419210611857.png)]$

编写程序从user表中读取数据，并打印在命令行窗口中。

package com.tr.lesson01;

import java.sql.*;

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 9:10
 */

//我的第一个JDBC程序
public class JdbcFirstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");//固定写法，加载驱动
        //2.用户信息和url
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL" +
                "=false";
        String username = "root";
        String password = "123456";
        //3.连接成功，数据库对象  Connection 代表数据库 DriverManager
        Connection connection =  DriverManager.getConnection(url, username, password);
        
        //4.执行SQL的对象 statement
        Statement statement = connection.createStatement();
        
        //5.执行SQL的对象 去 执行SQL，可能存在结果，查看返回结果
        String sql = "SELECT * FROM users";
        
        ResultSet resultSet = statement.executeQuery(sql);//返回一个结果集,结果集中封装了我们查询出来的所有的结果
        while (resultSet.next()){
            System.out.println("id = " + resultSet.getObject("id"));
            System.out.println("name = " + resultSet.getObject("NAME"));
            System.out.println("pwd = " + resultSet.getObject("PASSWORD"));
            System.out.println("email = " + resultSet.getObject("email"));
            System.out.println("birthday = " + resultSet.getObject("birthday"));
            System.out.println("=================================");
        }
        //6.释放连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

10.4、对象说明

DriverManager类说明

Jdbc程序中的DriverManager用于加载驱动，并创建与数据库的链接，这个API的常用方法：

DriverManager.registerDriver(new Driver()) 
DriverManager.getConnection(url, user, password)

注意：在实际开发中并不推荐采用registerDriver方法注册驱动。原因有二：

查看Driver的源代码可以看到，如果采用此种方式，会导致驱动程序注册两次，也就是在内存中会有两个Driver对象。
程序依赖mysql的api，脱离mysql的jar包，程序将无法编译，将来程序切换底层数据库将会非常麻烦。

推荐方式：Class.forName(“com.mysql.jdbc.Driver”);

采用此种方式不会导致驱动对象在内存中重复出现，并且采用此种方式，程序仅仅只需要一个字符串，不需要依赖具体的驱动，使程序的灵活性更高。

数据库URL讲解

URL用于标识数据库的位置，通过URL地址告诉JDBC程序连接哪个数据库，URL的写法为：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FQnoCBEJ-1618929561341)(E:\学习\Topora\MySQL\image-20210420094747913.png)]$

常用数据库URL地址的写法：

Oracle写法：jdbc:oracle:thin:@localhost:1521:sid
SqlServer写法：jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=sid
MySql写法：jdbc:mysql://localhost:3306/sid

如果连接的是本地的Mysql数据库，并且连接使用的端口是3306，那么的url地址可以简写为

jdbc：mysql://数据库

Connection类讲解

Jdbc程序中的Connection，它用于代表数据库的链接，Collection是数据库编程中最重要的一个对象，

客户端与数据库所有交互都是通过connection对象完成的，这个对象的常用方法：

createStatement()：创建向数据库发送sql的statement对象。
prepareStatement(sql) ：创建向数据库发送预编译sql的PrepareSatement对象。
setAutoCommit(boolean autoCommit)：设置事务是否自动提交。
commit() ：在链接上提交事务。
rollback() ：在此链接上回滚事务。

Statement类讲解

Jdbc程序中的Statement对象用于向数据库发送SQL语句， Statement对象常用方法：

executeQuery(String sql) ：用于向数据发送查询语句。
executeUpdate(String sql)：用于向数据库发送insert、update或delete语句返回受影响的行数
execute(String sql)：用于向数据库发送任意sql语句
addBatch(String sql) ：把多条sql语句放到一个批处理中。
executeBatch()：向数据库发送一批sql语句执行。

ResultSet类讲解

Jdbc程序中的ResultSet用于代表Sql语句的执行结果。Resultset封装执行结果时，采用的类似于表格的方式。ResultSet 对象维护了一个指向表格数据行的游标，初始的时候，游标在第一行之前，调用ResultSet.next() 方法，可以使游标指向具体的数据行，进行调用方法获取该行的数据。

ResultSet既然用于封装执行结果的，所以该对象提供的都是用于获取数据的get方法：

获取任意类型的数据
- getObject(int index)
- getObject(string columnName)
获取指定类型的数据，例如：
- getString(int index)
- getString(String columnName)

ResultSet还提供了对结果集进行滚动的方法：

next()：移动到下一行
Previous()：移动到前一行
absolute(int row)：移动到指定行
beforeFirst()：移动resultSet的最前面。
afterLast() ：移动到resultSet的最后面。

释放资源

Jdbc程序运行完后，切记要释放程序在运行过程中，创建的那些与数据库进行交互的对象，这些对象通常是ResultSet, Statement和Connection对象，特别是Connection对象，它是非常稀有的资源，用完后必须马上释放，如果Connection不能及时、正确的关闭，极易导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放。

为确保资源释放代码能运行，资源释放代码也一定要放在fifinally语句中。

10.5、statement对象

Jdbc中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。

Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sql语句，executeUpdate执行完后，将会返回一个整数（即增删改语句导致了数据库几行数据发生了变化）。

Statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

CRUD操作-create

使用executeUpdate(String sql)方法完成数据添加操作，示例操作：

Statement st = conn.createStatement(); 
String sql = "insert into user(….) values(…..) "; 
int num = st.executeUpdate(sql); 
if(num>0){ 
    System.out.println("插入成功！！！"); 
}

CRUD操作-delete

使用executeUpdate(String sql)方法完成数据删除操作，示例操作：

Statement st = conn.createStatement(); 
String sql = "delete from user where id=1"; 
int num = st.executeUpdate(sql); 
if(num>0){ 
    System.out.println(“删除成功！！！"); 
}

CRUD操作-update

使用executeUpdate(String sql)方法完成数据修改操作，示例操作：

Statement st = conn.createStatement(); 
String sql = "update user set name='' where name=''"; 
int num = st.executeUpdate(sql); 
if(num>0){ 
    System.out.println(“修改成功！！！"); 
}

CRUD操作-read

使用executeQuery(String sql)方法完成数据查询操作，示例操作：

Statement st = conn.createStatement(); 
String sql = "select * from user where id=1"; 
ResultSet rs = st.executeUpdate(sql); 
while(rs.next()){ 
	//根据获取列的数据类型，分别调用rs的相应方法映射到java对象中 
}

使用jdbc对数据库增删改查

1、新建一个 lesson02 的包

2、在src目录下创建一个db.properties文件，如下图所示：

driver=com.mysql.jdbc.Driver 
url=jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=true 
username=root 
password=123456

3、在lesson02 下新建一个 utils 包，新建一个类 JdbcUtils

package com.tr.lesson02.utils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 10:51
 */

public class JdbcUtils {
    private static String      driver   = null;
    private static String      url      = null;
    private static String      username = null;
    private static String      password = null;
    private static InputStream in;
    
    static {
        try {
            //读取db.properties文件中的数据库连接信息
            in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties prop = new Properties();
            prop.load(in);
            
            driver = prop.getProperty("driver");
            url = prop.getProperty("url");
            username = prop.getProperty("username");
            password = prop.getProperty("password");
            
            //1.驱动只用加载一次
            Class.forName(driver);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } 
        }
    }
    
    //获取连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }
    
    //释放连接资源
    public static void release(Connection connection, Statement statement, ResultSet resultSet) {
        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();
            }
        }
    }
}

使用statement对象完成对数据库的CRUD操作

1、插入一条数据

package com.tr.lesson02;

import com.tr.lesson02.utils.JdbcUtils;

import java.sql.*;

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 11:19
 */

public class TestInsert {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        
        try {
             conn = JdbcUtils.getConnection();
             st = conn.createStatement();
             String sql = "INSERT into `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES(" +
                     "5,'zhaoliu','123456','zxcvbnn.@163.com','1997-01-09')";
            int rows = st.executeUpdate(sql);
            if (rows > 0) {
                System.out.println("输入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

2、删除一条数据

package com.tr.lesson02;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 13:10
 */

public class TestDelete {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet re = null;
        
        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();
            String sql = "DELETE FROM users WHERE NAME like '%凡%'";
            int i = st.executeUpdate(sql);
            if (i > 0){
                System.out.println("删除成功");
            }else {
                System.out.println("没有该元素");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, re);
        }
    }
}

3、修改一条数据

package com.tr.lesson02;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 12:54
 */

public class TestUpdate {
    public static void main(String[] args) {
        Connection coon = null;
        Statement st = null;
        ResultSet re = null;
        
        try {
            coon = JdbcUtils.getConnection();
            st = coon.createStatement();
            String sql = "UPDATE `users` SET `NAME` = '羽凡' WHERE id = 4";
    
            int i = st.executeUpdate(sql);
            if (i > 0) {
                System.out.println("更新成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(coon, st, re);
        }
    }
}

4、查询一条数据

package com.tr.lesson02;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 13:16
 */

public class TestSelect {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        
        try {
             conn = JdbcUtils.getConnection();
             st = conn.createStatement();
             String sql = "SELECT id,`NAME`,birthday FROM users WHERE id < 4";
             
             rs = st.executeQuery(sql);
             while (rs.next()){
                 System.out.println("id = " + rs.getInt("id"));
                 System.out.println("username = " + rs.getString("NAME"));
                 System.out.println("birthday = " + rs.getDate("birthday"));
                 System.out.println("==========================================");
             }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

SQL 注入问题

通过巧妙的技巧来拼接字符串，造成SQL短路，从而获取数据库数据

package com.tr.lesson02;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 14:12
 */

public class SQL注入 {
    public static void main(String[] args) {
        // login("zhangsan","123456");
        login("'OR '1=1", "' or '1=1");
    }
    
    //登录业务
    public static void login(String username, String password) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        
        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();
            //select * from users where name='' or '1=1' and password = '' or '1=1'
            String sql = "SELECT * FROM users WHERE `NAME` = '" + username + "' AND" +
                    " password = '" + password + "'";
            
            rs = st.executeQuery(sql);//查询完毕之后返回一个结果集
            while (rs.next()) {
                System.out.println("username = " + rs.getString("NAME"));
                System.out.println("password = " + rs.getString("password"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

10.6、PreparedStatement对象

PreperedStatement是Statement的子类，它的实例对象可以通过调用Connection.preparedStatement()方法获得，相对于Statement对象而言：PreperedStatement可以避免SQL注入的问题。

Statement会使数据库频繁编译SQL，可能造成数据库缓冲区溢出。

PreparedStatement可对SQL进行预编译，从而提高数据库的执行效率。并PreperedStatement对于sql中的参数，允许使用占位符的形式进行替换，简化sql语句的编写。

使用PreparedStatement对象完成对数据库的CRUD操作

1、插入数据

package com.tr.lesson03;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 15:46
 */

public class TestInsert02 {
    public static void main(String[] args) {
        Insert(6, "无房", "1234567899", "5290455@qq.com");
    }
    
    public static void Insert(int id, String username, String password, String email){
        Connection conn = null;
        PreparedStatement st = null;
    
        try {
            //获取一个数据库连接
            conn = JdbcUtils.getConnection();
        
            //要执行的SQL命令，SQL中的参数使用?作为占位符
            String sql = "INSERT into `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES(?,?,?,?,?)";
            //通过conn对象获取负责执行SQL命令的prepareStatement对象
            st = conn.prepareStatement(sql);//预编译SQL，先写sql，然后不执行
        
            //为SQL语句中的参数赋值，注意，索引时从开始的
            st.setInt(1,id);//id时int类型的
            st.setString(2,username);//name是varchar类型的
            st.setString(3,password);
            st.setString(4,email);
            //注意点: sql.Date    数据库  java.sql.Date()
            //       util.Date   Java    new Date().getTime()  获取时间戳
            st.setDate(5,new java.sql.Date(new Date().getTime()));
        
            //执行插入操作，executeUpdate方法返回成功的条数
            int i = st.executeUpdate();
            if (i > 0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //执行完成之后释放资源
            JdbcUtils.release(conn, st, null);
        }
    }
}

2、删除数据

package com.tr.lesson03;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 15:51
 */

public class TestDelete {
    public static void main(String[] args) {
        delete("无房");
    }
    
    public static void delete(String username){
        Connection conn = null;
        PreparedStatement st = null;
        
        try {
            conn = JdbcUtils.getConnection();
            
            String sql = "delete from `users` where `NAME` = ?";
            st = conn.prepareStatement(sql);
            st.setString(1,username);
    
            int i = st.executeUpdate();
            if (i > 0){
                System.out.println("删除成功");
            } else {
                System.out.println("没有这条数据");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}

3、修改数据

package com.tr.lesson03;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 15:51
 */

public class TestUpdate {
    public static void main(String[] args) {
        update("张无忌",6);
    }
    
    public static void update(String username, int id){
        Connection conn = null;
        PreparedStatement st = null;
        
        try {
            conn = JdbcUtils.getConnection();
            
            String sql = "update `users` set `Name` = ? where `id`= ?";
            st = conn.prepareStatement(sql);
            st.setString(1,username);
            st.setInt(2,id);
            
            int i = st.executeUpdate();
            if (i > 0){
                System.out.println("修改成功");
            } else {
                System.out.println("没有这条数据");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}

4、查询数据

package com.tr.lesson03;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 15:51
 */

public class TestSelect {
    public static void main(String[] args) {
        select(7);
    }
    
    public static void select(int id){
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        
        try {
            conn = JdbcUtils.getConnection();
            
            String sql = "select * from `users` where `id` < ?";
            st = conn.prepareStatement(sql);
            st.setInt(1,id);
            
            
            rs = st.executeQuery();
            while (rs.next()){
                System.out.println("id = " + rs.getInt("id"));
                System.out.println("name = " + rs.getString("NAME"));
                System.out.println("pwd = " + rs.getString("PASSWORD"));
                System.out.println("email = " + rs.getString("email"));
                System.out.println("birthday = " + rs.getDate("birthday"));
                System.out.println("=================================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

避免SQL注入

package com.tr.lesson03;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 14:12
 */

public class SQL注入 {
    public static void main(String[] args) {
        //login("lisi","123456"); //正常登录
        login("''OR '1=1'", "'' or '1=1'");//SQL注入
    }
    
    //登录业务
    public static void login(String username, String password) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        
        try {
            conn = JdbcUtils.getConnection();
            //preparedStatement 防止sql注入的本质，把传递进来的参数当作字符
            //假设其中存在转义字符，就直接忽略，'会被直接转义为\'
            //select * from users where name='' or '1=1' and password = '' or '1=1'
            String sql = "SELECT * FROM `users` WHERE `NAME` = ? AND password = ?";
            
            st = conn.prepareStatement(sql);
            st.setString(1,username);
            st.setString(2,password);
            rs = st.executeQuery();
            while (rs.next()) {
                System.out.println("username = " + rs.getString("NAME"));
                System.out.println("password = " + rs.getString("password"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

原理：执行的时候参数会用引号包起来，并把参数中的引号作为转义字符，从而避免了参数也作为条件的一部分

10.7、IDEA连接数据库

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AEMIcGgP-1618929561342)(E:\学习\Topora\MySQL\image-20210420171315762.png)]$

连接数据库：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j6DzlM6u-1618929561343)(E:\学习\Topora\MySQL\image-20210420173042293.png)]$

连接成功以后，可以选择数据库

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Me3DGS0i-1618929561344)(E:\学习\Topora\MySQL\image-20210420173207202.png)]$

双击数据库，查看内容

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z3ecnkxd-1618929561345)(E:\学习\Topora\MySQL\image-20210420173507572.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-04hvNLJ6-1618929561345)(E:\学习\Topora\MySQL\image-20210420173803243.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fhtsmkum-1618929561346)(E:\学习\Topora\MySQL\image-20210420184516418.png)]$

10.8、事务

概念

事务指逻辑上的一组操作，组成这组操作的各个单元，要不全部成功，要不全部不成功。

ACID原则

原子性(Atomic)

整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被回滚（ROLLBACK）到事务开始前的状态，就像这个事务从来没有执行过一样。

一致性(Consist)

一个事务可以封装状态改变（除非它是一个只读的）。事务必须始终保持系统处于一致的状态，不管在任何给定的时间并发事务有多少。也就是说：如果事务是并发多个，系统也必须如同串行事务一样操作。其主要特征是保护性和不变性(Preserving an Invariant)，以转账案例为例，假设有五个账户，每个账户余额是100元，那么五个账户总额是500元，如果在这个5个账户之间同时发生多个转账，无论并发多少个，比如在A与B账户之间转账5元，在C与D账户之间转账10元，在B与E之间转账15元，五个账户总额也应该还是500元，这就是保护性和不变性。

隔离性(Isolated)

隔离状态执行事务，使它们好像是系统在给定时间内执行的唯一操作。如果有两个事务，运行在相同的时间内，执行相同的功能，事务的隔离性将确保每一事务在系统中认为只有该事务在使用系统。这种属性有时称为串行化，为了防止事务操作间的混淆，必须串行化或序列化请求，使得在同一时间仅有一个请求用于同一数据。

持久性(Durable)

在事务完成以后，该事务对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。
事务如果没有提交，恢复到原状

隔离性问题

1、脏读：脏读指一个事务读取了另外一个事务未提交的数据。

2、不可重复读：不可重复读指在一个事务内读取表中的某一行数据，多次读取结果不同。

3、虚读(幻读) : 虚读(幻读)是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。

代码测试

/*创建账户表*/
CREATE TABLE account(
                        id Int PRIMARY KEY AUTO_INCREMENT,
                        NAME VARCHAR(40),
                        money FLOAT
);

/*插入测试数据*/
insert into account(name,money) values('A',1000),('B',1000),('C',1000);

当Jdbc程序向数据库获得一个Connection对象时，默认情况下这个Connection对象会自动向数据库提交

在它上面发送的SQL语句。若想关闭这种默认提交方式，让多条SQL在一个事务中执行，可使用下列的

JDBC控制事务语句

Connection.setAutoCommit(false);//开启事务(start transaction)
Connection.rollback();//回滚事务(rollback)
Connection.commit();//提交事务(commit)

程序编写

1、模拟转账成功的业务场景

package com.tr.lesson04;

import com.tr.lesson02.utils.JdbcUtils;

import java.sql.*;

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 18:49
 */

public class TestTransaction01 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();
            //关闭数据库的自动提交，会自动开启事务
            conn.setAutoCommit(false);//通知数据库开启事务(start transaction)
            
            String sql1 = "update `account` set `money`= money - 100 where NAME = 'A'";
            st = conn.prepareStatement(sql1);
            st.executeUpdate();
            
            String sql2 = "update `account` set `money`= money + 100 where NAME = 'B'";
            st = conn.prepareStatement(sql2);
            st.executeUpdate();
            
            //业务完毕，提交事务
            conn.commit();;//上面的两条SQL执行Update语句成功之后就通知数据库提交事务 (commit)
            System.out.println("成功");//log4j
            
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

2、模拟转账过程中出现异常导致有一部分SQL执行失败后让数据库自动回滚事务

package com.tr.lesson04;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 18:49
 */

public class TestTransaction02 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();
            //关闭数据库的自动提交，会自动开启事务
            conn.setAutoCommit(false);//通知数据库开启事务(start transaction)
            
            String sql1 = "update `account` set `money`= money - 100 where NAME = 'A'";
            st = conn.prepareStatement(sql1);
            st.executeUpdate();
            //用这句代码模拟执行完SQL1之后程序出现了异常而导致后面的SQL无法正常执行，事务也无法正常提交，此时数据库会自动执行回滚操作
            int x = 1 / 0;
            String sql2 = "update `account` set `money`= money + 100 where NAME = 'B'";
            st = conn.prepareStatement(sql2);
            st.executeUpdate();
            
            //业务完毕，提交事务
            conn.commit();;//上面的两条SQL执行Update语句成功之后就通知数据库提交事务 (commit)
            System.out.println("成功");//log4j
            
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

3、模拟转账过程中出现异常导致有一部分SQL执行失败时手动通知数据库回滚事务

package com.tr.lesson04;

import com.tr.lesson02.utils.JdbcUtils;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 18:49
 */

public class TestTransaction02 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();
            //关闭数据库的自动提交，会自动开启事务
            conn.setAutoCommit(false);//通知数据库开启事务(start transaction)
            
            String sql1 = "update `account` set `money`= money - 100 where NAME = 'A'";
            st = conn.prepareStatement(sql1);
            st.executeUpdate();
            //用这句代码模拟执行完SQL1之后程序出现了异常而导致后面的SQL无法正常执行，事务也无法正常提交，此时数据库会自动执行回滚操作
            int x = 1 / 0;
            String sql2 = "update `account` set `money`= money + 100 where NAME = 'B'";
            st = conn.prepareStatement(sql2);
            st.executeUpdate();
            
            //业务完毕，提交事务
            conn.commit();;//上面的两条SQL执行Update语句成功之后就通知数据库提交事务 (commit)
            System.out.println("成功");//log4j
            
        } catch (SQLException e) {
            try {
                //捕获到异常之后手动通知数据库执行回滚事务的操作
                conn.rollback();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

10.9、数据库连接池

用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机。

数据库连接池的基本概念

数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现的尤为突出.对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标.数据库连接池正是针对这个问题提出来的.数据库连接池负责分配，管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。

数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中, 这些数据库连接的数量是由最小数据库连接数来设定的.无论这些数据库连接是否被使用,连接池都将一直保证至少拥有这么多的连接数量.连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中.

数据库连接池的最小连接数和最大连接数的设置要考虑到以下几个因素:

最小连接数:是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费.
最大连接数:是连接池能申请的最大连接数,如果数据库连接请求超过次数,后面的数据库连接请求将被加入到等待队列中,这会影响以后的数据库操作
如果最小连接数与最大连接数相差很大:那么最先连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接.不过,这些大于最小连接数的数据库连接在使用完不会马上被释放,他将被放到连接池中等待重复使用或是空间超时后被释放.

编写连接池需实现java.sql.DataSource接口。

开源数据库连接池

现在很多WEB服务器(Weblogic, WebSphere, Tomcat)都提供了DataSoruce的实现，即连接池的实现。通常我们把DataSource的实现，按其英文含义称之为数据源，数据源中都包含了数据库连接池的实现。

也有一些开源组织提供了数据源的独立实现：

DBCP 数据库连接池
C3P0 数据库连接池

在使用了数据库连接池之后，在项目的实际开发中就不需要编写连接数据库的代码了，直接从数据源获得数据库的连接。

DBCP数据源

DBCP 是 Apache 软件基金组织下的开源连接池实现，要使用DBCP数据源，需要应用程序应在系统中增加如下两个 jar 文件：

Commons-dbcp.jar：连接池的实现
Commons-pool.jar：连接池实现的依赖库

Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。

测试：

1、导入相关jar包

2、在类目录下加入dbcp的配置文件：dbcpconfig.properties

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000

#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如： Informix）
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

3、编写工具类 JdbcUtils_DBCP

package com.tr.lesson05.utils;

import org.apache.commons.dbcp.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 10:51
 */

public class JdbcUtils_DBCP {
    private static InputStream in;
    /**
     * 在java中，编写数据库连接池需实现java.sql.DataSource接口，每一种数据库连接池都 是DataSource接口的实现
     *  DBCP连接池就是java.sql.DataSource接口的一个具体实现
     */
    private static DataSource ds = null;
    //在静态代码块中创建数据库连接池
    static {
        try {
            //读取db.properties文件中的数据库连接信息
            in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties prop = new Properties();
            prop.load(in);
            
            //创建数据源 工厂模式 --> 创建
            ds = BasicDataSourceFactory.createDataSource(prop);
        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    //获取连接
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();//从数据源中获取连接
    }
    
    //释放连接资源
    public static void release(Connection coon, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (coon != null) {
            try {
                coon.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

测试类

package com.tr.lesson05;

import com.tr.lesson02.utils.JdbcUtils;
import com.tr.lesson05.utils.JdbcUtils_DBCP;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 20:52
 */

public class TestDBCP {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
    
        try {
            //获取数据库连接
            conn = JdbcUtils_DBCP.getConnection();
            String sql = "INSERT into `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES(?,?,?,?,?)";
        
            st = conn.prepareStatement(sql);//预编译SQL，先写sql，然后不执行
        
            //手动给参数赋值
            st.setInt(1,7);
            st.setString(2,"赵晓芳");
            st.setString(3,"123456");
            st.setString(4,"841418@qq.com");
            //注意点: sql.Date    数据库  java.sql.Date()
            //       util.Date   Java    new Date().getTime()  获取时间戳
            st.setDate(5,new java.sql.Date(new Date().getTime()));
        
            //执行
            int i = st.executeUpdate();
            if (i > 0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils_DBCP.release(conn, st, null);
        }
    }
}

C3P0

C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目

前使用它的开源项目有Hibernate，Spring等。C3P0数据源在项目开发中使用得比较多。

c3p0与dbcp区别

dbcp没有自动回收空闲连接的功能
c3p0有自动回收空闲连接功能

测试

1、导入相关jar包

2、在类目录下加入C3P0的配置文件：c3p0-config.xml

<?xml version="1.0" encoding="UTF-8"?>

<c3p0-config>

    <!--
    C3P0的缺省(默认)配置，
    如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource();”这样写
    就表示使用的是C3P0的缺省(默认)配置信息来创建数据源
    -->

    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false</property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>

    <!--
    C3P0的命名配置，如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");”
    这样写就表示使用的是name是MySQL的配置信息来创建数据源
    -->

    <named-config name="MySQL">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false</property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </named-config>

</c3p0-config>

3、创建工具类

package com.tr.lesson05.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 10:51
 */

public class JdbcUtils_C3P0 {
    /**
     * 在java中，编写数据库连接池需实现java.sql.DataSource接口，每一种数据库连接池都 是DataSource接口的实现
     * DBCP连接池就是java.sql.DataSource接口的一个具体实现
     */
    private static ComboPooledDataSource ds = null;
    
    //在静态代码块中创建数据库连接池
    static {
        try {
          /*  //代码版配置 不推荐使用
            ds = new ComboPooledDataSource();
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/jdbcstudy");
            ds.setUser("root");
            ds.setPassword("123456");
            ds.setInitialPoolSize(10);
            ds.setMinPoolSize(5);
            ds.setMaxPoolSize(20);*/
            
            //通过读取C3P0的xml配置文件创建数据源，C3P0的xml配置文件c3p0-config.xml 必须放在src目录下
            //ds = new ComboPooledDataSource();//使用C3P0的默认配置来创建数据源
            ds = new ComboPooledDataSource("MySql"); //使用C3P0的命名配置来创建数 据源
        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }
    
    //获取连接
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();//从数据源中获取连接
    }
    
    //释放连接资源
    public static void release(Connection coon, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                //关闭存储查询结果的ResultSet对象
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                //关闭负责执行SQL命令的Statement对象
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (coon != null) {
            try {
                //将Connection连接对象还给数据库连接池
                coon.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

测试

package com.tr.lesson05;

import com.tr.lesson05.utils.JdbcUtils_C3P0;

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

/**
 * @author TRasdzz
 * @version 1.0
 * @since create in 2021/4/20 20:52
 */

public class TestC3P0 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
    
        try {
            //获取数据库连接
            conn = JdbcUtils_C3P0.getConnection();//原来是自己实现的，现在是别人实现的
            String sql = "INSERT into `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES(?,?,?,?,?)";
        
            st = conn.prepareStatement(sql);//预编译SQL，先写sql，然后不执行
        
            //手动给参数赋值
            st.setInt(1,8);
            st.setString(2,"王强");
            st.setString(3,"123456");
            st.setString(4,"8414@qq.com");
            //注意点: sql.Date    数据库  java.sql.Date()
            //       util.Date   Java    new Date().getTime()  获取时间戳
            st.setDate(5,new java.sql.Date(new Date().getTime()));
        
            //执行
            int i = st.executeUpdate();
            if (i > 0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils_C3P0.release(conn, st, null);
        }
    }
}

结论

无论使用什么数据源，本质还是一样的 DataSourse接口不会变，方法就不会变

言叶.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
10、JDBC相关

10.1、数据库驱动这里的驱动的概念和平时听到的那种驱动的概念是一样的，比如平时购买的声卡，网卡直接插到计算机上面是不能用的，必须要安装相应的驱动程序之后才能够使用声卡和网卡，同样道理，我们安装好数据库之后，我们的应用程序也是不能直接使用数据库的，必须要通过相应的数据库驱动程序，通过驱动程序去和数据库打交道，如下所示：10.2、JDBC介绍SUN公司为了简化、统一对数据库的操作，定义了一套Java操作数据库的规范（接口），称之为JDBC。这套接口由数据库厂商去实现，这样，开发人员只需要学习jdbc接
复制链接

扫一扫

专栏目录