专栏首页Java 技术分享JDBC(MySQL)一周学习总结(二)

JDBC(MySQL)一周学习总结(二)

上一篇文章我们总结了获取数据库连接以及操作数据表的一些知识点,本篇将继续上次的文章给大家分享!

1. 上一篇文章我们可以对数据表进行增删改查的操作了,对与一些小项目的部分功能我们也足以胜任。但现在有一个需求是一个人下了一个订单,并将这个订单的下单时间等信息插入了订单表,并且其主键是自动生成主键值,当我们想要找到该用户买了哪些商品(商品表)时,则需要用订单 ID 去获取商品列表,此时就需要获得数据库自动生成的主键值(不针对于不自动生成主键的数据库,如 Oracle)。

取得数据库自动生成的主键值,使用重载的 prepareStatement(sql, flag) 方法使其生成自动生成的主键值,使用 getGennratedKeys() 获得自动生成的主键值的结果集,代码如下(具体方法可以在 API 中进行进一步的了解):

  @Test
    public void testGetKey() {

        Connection connection;
        PreparedStatement preparedStatement;

        connection = JDBCTools.getConnection();
        String sql = "INSERT INTO book (book_name, isbn, price, stock) VALUES (?, ?, ?, ?)";
        try {
//            设置其可以返回自动生成的主键值
            preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            preparedStatement.setString(1, "R");
            preparedStatement.setString(2, "10011");
            preparedStatement.setInt(3, 220);
            preparedStatement.setInt(4, 10);

            preparedStatement.executeUpdate();
//            获取自动生成的主键值,需要调用方法 getGeneratedKeys(),返回一个结果集,这个方法
            ResultSet resultSet = preparedStatement.getGeneratedKeys();

            if (resultSet.next()) {
                System.out.println(resultSet.getObject(1));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

2. 处理 Blob 类型数据,如插入图片,读取图片的操作,往数据库中插入 BLOB 类型的数据必须使用 prepareStatement,因为插入 BLOB 类型的数据使用的 sql 语句无法拼写出来;下面是插入 Blob 型数据

    @Test
    public void testBlob() {

        Connection connection;
        PreparedStatement preparedStatement;

        connection = JDBCTools.getConnection();
        String sql = "INSERT INTO pic_blob (pic) VALUES ( ?)";
        try {
            preparedStatement = connection.prepareStatement(sql);

            File file = new File("C:\\Users\\lenovo\\Desktop\\key.png");
            InputStream inputStream = null;
            try {
                inputStream = new FileInputStream(file);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
//            使用输入流填充参数
            preparedStatement.setBlob(1, inputStream);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

  插入 Blob 类型数据就肯定可以读取 Blbo 型数据,理解了上面的方法后就大概知道了读取需要使用 OutputStream,你可以先自己尝试一下如何去写,看有什么困难在看下面的代码:

@Test
    public void testBlobGet() {

        Connection connection;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        connection = JDBCTools.getConnection();
        String sql = "SELECT pic FROM pic_blob WHERE id=?";
        try {
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, 1);

            resultSet = preparedStatement.executeQuery();
//            和 IO 那块一样,使用字节数组加快读取速度
            byte[] buffer = new byte[1024];
            int len;

            while (resultSet.next()) {
                try {
                    Blob pic = resultSet.getBlob(1);
//                    获取输入流
                    InputStream inputStream = pic.getBinaryStream();
//                    将图片存到一个位置,通过输出流
                    OutputStream outputStream = new FileOutputStream("C:\\Users\\lenovo\\Desktop\\key2.png");

                    while ((len = inputStream.read(buffer)) != -1) {
                        outputStream.write(buffer, 0, len);
                    }
                    outputStream.close();
                    inputStream.close();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.releaseConnection(connection, preparedStatement, resultSet);
        }
    }

3.  数据库事务处理。简单的说几个对数据库的操作要么全都执行,要么全都不执行,需要保持一致性,Mysql 数据库默认的执行一个操作便会自动提交,为了处理事务我们必须设置数据库不是自动提交的,还有若每个对数据表的操作都是自己单独的连接,那么就无法保证事务,所以我们需要更改以前写的工具类,使其使用一个数据库连接,然后等所有操作结束之后我们再手动提交操作,若发生异常便进行回滚,具体代码如下:

 @Test
    public void testTransaction1() {
        Connection connection = null;
        try {
//         为下面的 update 方法传入一个统一的连接
            connection = JDBCTools.getConnection();
//        关闭自动提交
            connection.setAutoCommit(false);
            String sql1 = "UPDATE book SET price = price - 500 WHERE id = 1";
            update(connection, sql1);
//            制造异常检查事务的正确性
//            int i = 2 / 0;

            String sql2 = "UPDATE book SET price = price + 500 WhERE id = 2";
            update(connection, sql2);
//            执行完毕,手动提交
            connection.commit();
        } catch (SQLException e) {
            try {
//             如果发生异常将其进行回滚
                connection.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            e.printStackTrace();
        }
    }

//     更改后的 update 方法使用的 connection 不再是在其内部每次调用方法获取新的连接,而是传入一个连接使其统一
    public void update(Connection connection, String sql, Object... args) {
        PreparedStatement preparedStatement = null;

        try {
            preparedStatement = connection.prepareStatement(sql);

            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }

            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.releaseConnection(null,  preparedStatement, null);
        }
    }

  如果数据库中同时运行多个事务,若没有设置合适隔离级别将会出现各种并发问题:脏读,不可重复读,幻读等问题。将数据库隔离级别设置的越高数据的一致性就越高但并发性也就越差。

  Oracle 数据库支持两种事务隔离级别,READ_COMMITED(读已提交),SERIALIZABLE(串行化),其默认的隔离级别是 READ_COMMITED

  MySQL 数据库支持四种事务隔离级别,默认的隔离级别是 REPEATBLE READ(读未提交)。大多数情况下我们设置为 READ_COMMITED 最为合适,我们可以使用  connection.setTransactionIsolation(); 来设置数据库的隔离级别

4. 我们在这之前所使用的数据库连接是每次从数据库中获取一个使用完毕就将其放入数据库,这样的操作比较浪费,所以也就有了数据库连接池,其基本思想: 为数据库连接建立一个缓冲池,预先放入一定数量的连接,需要时从缓冲池中取出一个,使用完毕放入,当使用的时候没有多余的连接时需要等待。这样就节省了很多的时间,下面是使用 c3p0 连接池获取数据库连接的代码:

    @Test
    public void testC3p0() {
//       在使用之前需要导入对应的 jar 包文件
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setDriverClass("com.mysql.jdbc.Driver");
            dataSource.setJdbcUrl("jdbc:mysql:///sh_db");
            dataSource.setUser("root");
            dataSource.setPassword("zy961029");

            System.out.println(dataSource.getConnection());
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

   和之前的一样,我们也需要将上面的方法加以配置文件的处理(程序中的 helloc3p0 是配置文件中所配置  <name-config name="helloC3p0"> )

 @Test
    public void testC3p0Config() {
//       注意 jar 包的版本问题,0.9.2 之前的不支持下面的写法
        ComboPooledDataSource dataSource = new ComboPooledDataSource("helloC3p0");
        try {
            Connection connection = dataSource.getConnection();
            System.out.println(connection);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
<?xml version="1.0" encoding="UTF-8" ?>
<c3p0-config>
    <named-config name="helloC3p0">
        <property name="user">root</property>
        <property name="password">zy961029</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///sh_db</property>

        <property name="maxStatements">1</property>
        <property name="maxStatementsPerConnection">5</property>
    </named-config>
</c3p0-config>

 5. 使用 DBUtils,commons-dbutils 是 Apache 组织提供的一个开源 JDBC 工具类,它是对 JDBC 的简单封装,学习成本低,并且简化了代码,不影响代码的性能

使用 DBUTils 进行简单的增删改查功能(可以在包内的 API 中进行对相应的类进行了解 )

QueryRunner 类简化了 SQL 查询,与 ResultSetHandler 组合可以完成大部分的数据操作,减少编码量

package com.jdbc.dao.my.dbutils;

import com.jdbc.dao.my.first.test.JDBCTools;
import com.jdbc.dao.my.first.test.SH_DB;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.*;
import org.junit.Test;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * Created by shkstart on 2017/11/02.
 */
public class DBUtilsTest {

    //    C3p0 获取数据库连接
    @Test
    public void testGetConnection() {
//        更新工具类中获取数据库连接的方法,使用 c3p0 数据库连接
        Connection connection = JDBCTools.getConnection();
        System.out.println(connection);
    }

    //    使用 QueryRunner 删除数据 --> DBUtils
    @Test
    public void testUpdate() {
        QueryRunner queryRunner = new QueryRunner();
        Connection connection;
        connection = JDBCTools.getConnection();
//        String sql = "DELETE FROM book WHERE id=?";
        String sql = "INSERT INTO book (book_name, isbn, price, stock) values(?, ?, ?, ?)";
        try {
            queryRunner.update(connection, sql, "C#", "1008", 120, 40);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.releaseConnection(connection, null, null);
        }
    }

//    将查询到的所有数据打印出来,
    @Test
    public void resultSetHandler() {
        QueryRunner queryRunner = new QueryRunner();
        Connection connection;
        final List<SH_DB> sh_dbs = new ArrayList<SH_DB>();
        connection = JDBCTools.getConnection();
        String sql = "SELECT book_name bookName, isbn, price, stock FROM book";
        try {
            queryRunner.query(connection, sql, new ResultSetHandler<Object>() {
                @Override
                public Object handle(ResultSet resultSet) throws SQLException {
                    while (resultSet.next()) {
                        String bookName = resultSet.getString(1);
                        String isbn = resultSet.getString(2);
                        int price = resultSet.getInt(3);
                        int stock = resultSet.getInt(4);
                        SH_DB sh_db = new SH_DB(bookName, isbn, price, stock);
                        sh_dbs.add(sh_db);
                    }
                    return sh_dbs;
                }
            });

            System.out.println(sh_dbs);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

//    把结果集的第一条记录转为创建 BeanHandler 对象时传入的对象
    @Test
    public void testBeanHandler() {
        Connection connection;
        QueryRunner queryRunner = new QueryRunner();
        connection = JDBCTools.getConnection();

        String sql = "SELECT * FROM BOOK";
        try {
            SH_DB sh_db = queryRunner.query(connection, sql, new BeanHandler<SH_DB>(SH_DB.class));
            System.out.println(sh_db);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

//    返回查询结果的 list 结果集,其中查询语句必须使用表对应 bean 的列的别名
//    BeanHandler 也一样
    @Test
    public void testBeanListHandler() {
        Connection connection = JDBCTools.getConnection();
        String sql = "SELECT book_name bookName, isbn, price, stock FROM book";
        QueryRunner queryRunner = new QueryRunner();

        try {
            List<SH_DB> sh_dbs = (List<SH_DB>) queryRunner.query(connection, sql, new BeanListHandler(SH_DB.class));
            System.out.println(sh_dbs);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

//  将查询结果的第一行存放进一个 map 中,键位 列名,而不是列的别名, 值为 所对应的值
    @Test
    public void testMapHandler() {
        Connection  connection = JDBCTools.getConnection();
        QueryRunner queryRunner = new QueryRunner();
        String sql = "SELECT book_name bookName, isbn, price, stock from book " +
                "where id = ?";

        try {
            Map<String, Object> map = queryRunner.query(connection, sql, new MapHandler(), 5);
            System.out.println(map);

            for (Map.Entry<String, Object> entry : map.entrySet()) {
                System.out.println(entry.getKey());
                System.out.println(entry.getValue());
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

//    将查询结果的存入一个 List,其 list 的元素为一个 map,对应一列
    @Test
    public void testListHandler() {
        Connection connection = JDBCTools.getConnection();
        QueryRunner queryRunner = new QueryRunner();
        String sql = "SELECT book_name bookName, isbn, price, stock from book";

        try {
            List<Map<String, Object>> listMap = queryRunner.query(connection, sql, new MapListHandler());
            System.out.println(listMap);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

//    将查询的一个结果放入 object 返回,比如返回记录数,返回某一列的值,如果 sql 语句是返回多条记录的
//    那么 ScalarHandler 将返回的是第一列的值
    @Test
    public void testScalarHandler() {
        Connection connection = JDBCTools.getConnection();
        QueryRunner queryRunner = new QueryRunner();
        String sql = "SELECT COUNT(*) FROM book";

        try {
            Object object = queryRunner.query(connection, sql, new ScalarHandler());
            System.out.println(object);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

上一篇加上本篇就是上一周所学习的东西,太多,总结起来也挺费力的如果有什么错误还望指出,谢谢!!!

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Struts2 转换器

    bgZyy
  • Struts2 转换器

    bgZyy
  • JDBC(MySQL)一周学习总结(一)

    bgZyy
  • Java程序员11面阿里,错失offer,期间还面了EMC+网易+美团......

    一直在面阿里,从提前批投蚂蚁中间件与阿里中间件,最后阿里中间件面完了hr,但是很遗憾最后没能进,被调到了盒马。不过最终还是拿到了盒马的offer。期间还面了EM...

    秃顶的Java程序员
  • 『ACM-算法-动态规划』初识DP动态规划算法

    一、多阶段决策过程的最优化问题 在现实生活中,有类活 动的过程,由于 它的特殊性,可将过程分成若干个互相阶段。在它的每一阶段都需要作出决策,从而使整个过程达到...

    风骨散人Chiam
  • 关于物联网 LoRa WLAN 的安全研究

    很早就关注了“信安之路”很多干货,学到很多知识。现在来回报大家了,疫情期间在闭关提升自己,也写了些文章,以后可以分享。

    信安之路
  • YOLOv4损失函数全面解析

    转载于:周威@知乎,https://zhuanlan.zhihu.com/p/159209199

    计算机视觉联盟
  • iOS 键盘和UIMenuController的并存问题

    且行且珍惜_iOS
  • python进行crc校验的方法

    import serial import re import time ''' 读卡器操作类: ''' class reader(): ...

    py3study
  • 近日微信支付提示HTTPS服务器更换证书,商户该如何应对?

    2018年3月8日,微信支付商户平台发布公告:微信支付HTTPS服务器计划于2018年5月29日更换服务器证书。这则公告对使用沃通SSL证书的商户没有任何影响,...

    zhangdd

扫码关注云+社区

领取腾讯云代金券