Java后端学习笔记 -- JDBC(三)

最新推荐文章于 2022-08-01 17:37:52 发布

离渊灬

最新推荐文章于 2022-08-01 17:37:52 发布

阅读量451

点赞数 1

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

本文链接：https://blog.csdn.net/IceTiger_/article/details/105743613

版权

JavaWeb 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

写在开头：本文是学习Java后端开发的个人笔记，便于自己复习。如果只是想快速学会使用jdbc的朋友可以直接跳转至JDBC(三)的二三四部分。文章内容引用了尚硅谷的jdbc教学，有兴趣的朋友可以上B站搜索学习。

JDBC(三)

Ⅰ DAO及其实现类
 Ⅱ 数据库连接池
 Ⅲ Apache-DBUtils实现CRUD操作
 Ⅳ 完善DAO及其实现类

Ⅰ DAO及其实现类

简要介绍
DAO：Data Access Object访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。有时也称作：BaseDAO
作用：为了实现功能的模块化，更有利于代码的维护和升级。
接下来以之前的users表做示例；下面的示例都用到了之前的工具类JDBCutils和Bean中的Users类
BaseDAO示例

/*
 * 定义一个用来被继承的对数据库进行基本操作的Dao
 */
public abstract class BaseDAO<T> {

    private Class<T> clazz = null;

    {
        // 获取当前BaseDAO子类继承的父类中的泛型
        Type genericSuperclass = this.getClass().getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;

        Type[] typeArguments = paramType.getActualTypeArguments();  //获取了父类的泛型参数
        clazz = (Class<T>) typeArguments[0];
    }



    /* 通用的增删改操作 --- 考虑数据库事务 */
    public static int update(Connection conn, String sql, Object ...args){
        PreparedStatement psmt= null;
        try {
            //1、预编译sql语句，返回PreparedStatment的实例
            psmt = conn.prepareStatement(sql);
            //2、填充占位符
            for(int i=0; i< args.length; i++){
                psmt.setObject(i+1, args[i]);
            }
            //3、执行
            return psmt.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //4、关闭资源
            JDBCutils.closeResource(null, psmt);
        }
        return 0;
    }

    /* 通用的查询操作(返回一个对象) --- 考虑数据库事务 */
    public T getInstance(Connection conn, String sql, Object ...args){
        PreparedStatement psmt = null;
        ResultSet rs = null;

        try {
            // 预编译sql语句
            psmt = conn.prepareStatement(sql);

            // 填充占位符
            for(int i=0; i<args.length; i++){
                psmt.setObject(i+1, args[i]);
            }

            // 执行
            rs = psmt.executeQuery();
            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通过元数据获取结果集中的列数
            int columnCount = rsmd.getColumnCount();
            // 处理结果集
            if(rs.next()){
                T t = clazz.getDeclaredConstructor().newInstance();
                // 处理结果集一行数据中的每一个列
                for(int i=0; i<columnCount; i++){
                    // 获取列值
                    Object columnValue = rs.getObject(i + 1);
                    // 获取每个列的列名：rsmd.getColumnName() 不推荐使用
                    // 获取每个列的别名：rsmd.getColumnLabel()
                    String columnName = rsmd.getColumnLabel(i + 1);
                    // 给t对象指定的columnName属性，赋值为columnValue：通过反射
                    Field field = t.getClass().getDeclaredField(columnName);
                    field.setAccessible(true);
                    field.set(t, columnValue);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCutils.closeResource(null, psmt, rs);
        }

        return null;
    }

    /* 通用的查询操作(返回多个对象) --- 考虑数据库事务 */
    public List<T> getForList(Connection conn, String sql, Object ...args){
        PreparedStatement psmt = null;
        ResultSet rs = null;

        try {
            // 预编译sql语句
            psmt = conn.prepareStatement(sql);

            // 填充占位符
            for(int i=0; i<args.length; i++){
                psmt.setObject(i+1, args[i]);
            }

            // 执行
            rs = psmt.executeQuery();
            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通过元数据获取结果集中的列数
            int columnCount = rsmd.getColumnCount();
            //创建集合对象
            ArrayList<T> list = new ArrayList<>();
            // 处理结果集
            while (rs.next()){
                T t = clazz.getDeclaredConstructor().newInstance();
                // 处理结果集一行数据中的每一个列：给t对象指定的属性赋值
                for(int i=0; i<columnCount; i++){
                    // 获取列值
                    Object columnValue = rs.getObject(i + 1);
                    // 获取每个列的列名：rsmd.getColumnName() 不推荐使用
                    // 获取每个列的别名：rsmd.getColumnLabel()
                    String columnName = rsmd.getColumnLabel(i + 1);
                    // 给t对象指定的columnName属性，赋值为columnValue：通过反射
                    Field field = t.getClass().getDeclaredField(columnName);
                    field.setAccessible(true);
                    field.set(t, columnValue);
                }
                list.add(t);
            }

            return list;

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCutils.closeResource(null, psmt, rs);
        }

        return null;
    }

    /* 用于查询特殊值的通用方法 */
    public <E> E getValue(Connection conn, String sql, Object ...args){
        PreparedStatement psmt= null;
        ResultSet rs = null;
        try {
            psmt = conn.prepareStatement(sql);
            for(int i=0; i<args.length; i++){
                psmt.setObject(i+1,args[i]);
            }

            rs = psmt.executeQuery();

            if(rs.next()){
                return (E)rs.getObject(1);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(null, psmt, rs);
        }
        return null;
    }
}

UserDAO

/*
 * 此接口用于规范针对于Users表的常用操作
 */
public interface UsersDAO {

    /**
     * 将users对象添加到数据库中
     * @param conn
     * @param users
     */
    public void insert(Connection conn, Users users);

    /**
     * 根据指定的id，删除表中的一条记录
     * @param conn
     * @param id
     */
    public void deleteById(Connection conn, int id);

    /**
     * 针对内存中的users对象，去修改数据表中指定的记录
     * @param conn
     * @param users
     */
    public void update(Connection conn, Users users);

    /**
     * 针对指定的id，查询得到对应的users对象
     * @param conn
     * @param id
     * @return
     */
    public Users getUsersById(Connection conn, int id);

    /**
     * 查询表中的所有记录
     * @param conn
     * @return
     */
    public List<Users> getAll(Connection conn);

    /**
     * 返回数据表中的数据的条目数
     * @param conn
     * @return
     */
    public Long getCount(Connection conn);

    /**
     * 返回数据表中最大的年龄
     * @param conn
     * @return
     */
    public int getMaxAge(Connection conn);
}

UserDAOImpl示例

/**
 * DAO:data(base) access object
 */
public class UsersDAOImpl extends BaseDAO<Users> implements UsersDAO {
    @Override
    public void insert(Connection conn, Users users) {
        String sql = "insert into users(name,age) values(?,?)";
        update(conn, sql, users.getName(), users.getAge());
    }

    @Override
    public void deleteById(Connection conn, int id) {
        String sql = "delete from users where id = ?";
        update(conn, sql, id);
    }

    @Override
    public void update(Connection conn, Users users) {
        String sql = "update users set name = ?,age = ? where id = ?";
        update(conn, sql, users.getName(), users.getAge(), users.getId());
    }

    @Override
    public Users getUsersById(Connection conn, int id) {
        String sql = "select id,name,age from users where id = ?";
        Users users = getInstance(conn, sql, id);
        return users;

    }

    @Override
    public List<Users> getAll(Connection conn) {
        String sql = "select id,name,age from users";
        List<Users> list = getForList(conn, sql);
        return list;
    }

    @Override
    public Long getCount(Connection conn) {
        String sql = "select count(*) from users";
        return getValue(conn, sql);
    }

    @Override
    public int getMaxAge(Connection conn) {
        String sql = "select max(age) from users";
        return getValue(conn, sql);
    }
}

UserDAOImplTest示例

public class UsersDAPImplTest {
    private UsersDAO dao = new UsersDAOImpl();

    @Test
    public void testInsert(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            Users users = new Users(1, "艾米利亚", 18);
            dao.insert(conn,users);
            System.out.println("添加成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null);
        }
    }

    @Test
    public void testDeleteById(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            dao.deleteById(conn, 3);
            System.out.println("删除成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null);
        }
    }

    @Test
    public void testUpdateConnectionUsers(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            Users users = new Users(2, "艾米利亚", 18);
            dao.update(conn, users);
            System.out.println("修改成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null);
        }
    }

    @Test
    public void testGetUsrsById(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            Users users = dao.getUsersById(conn, 1);
            System.out.println(users);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null);
        }
    }

    @Test
    public void testGetAll(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            List<Users> list = dao.getAll(conn);
            list.forEach(System.out::println);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null);
        }
    }

    @Test
    public void testGetCount(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            Long count = dao.getCount(conn);
            System.out.println("表中的记录数为：" + count);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null);
        }
    }

    @Test
    public void testGetMaxAge(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            int age= dao.getMaxAge(conn);
            System.out.println("表中的最大年龄为：" + age);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null);
        }
    }
}

Ⅱ 数据库连接池

JDBC数据库连接池的必要性
在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤：
- 在主程序（如servlet、beans）中建立数据库连接
- 进行sql操作
- 断开数据库连接
这种模式开发，存在的问题:
- 普通的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connection加载到内存中，再验证用户名和密码(得花费0.05s～1s的时间)。需要数据库连接的时候，就向数据库要求一个，执行完成后再断开连接。这样的方式将会消耗大量的资源和时间。数据库的连接资源并没有得到很好的重复利用。若同时有几百人甚至几千人在线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。
- 对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启数据库。
- 这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。
数据库连接池技术
为解决传统开发中的数据库连接问题，可以采用数据库连接池技术。
数据库连接池的基本思想：就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。

工作原理：
数据库连接池技术的优点
- 资源重用
由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。
- 更快的系统反应速度
数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，
从而减少了系统的响应时间
- 新的资源分配手段
对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源
- 统一的连接管理，避免数据库连接泄漏
在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露

多种开源的数据库连接池
JDBC 的数据库连接池使用 javax.sql.DataSource 来表示，DataSource 只是一个接口，该接口通常由服务器(Weblogic, WebSphere, Tomcat)提供实现，也有一些开源组织提供实现
DataSource 通常被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把 DataSource 称为连接池
DataSource用来取代DriverManager来获取Connection，获取速度快，同时可以大幅度提高数据库访问速度。
特别注意：
数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但conn.close()并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。

（1）C3P0数据库连接池
C3P0 是一个开源组织提供的一个数据库连接池，速度相对较慢，稳定性还可以。hibernate官方推荐使用
获取连接示例：

// 使用C3P0数据库连接池的配置文件方式，获取数据库的连接
private static DataSource cpds = new ComboPooledDataSource("helloc3p0");
public static Connection getConnection2() throws SQLException{
	Connection conn = cpds.getConnection();
	return conn;
}

其中，src下的配置文件为：【c3p0-config.xml】

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
	<named-config name="helloc3p0">
		<!-- 获取连接的4个基本信息 -->
		<property name="user">root</property> 
		<property name="password">abc123</property> 
		<property name="jdbcUrl">jdbc:mysql:///test</property> 
		<property name="driverClass">com.mysql.jdbc.Driver</property>

		<!-- 涉及到数据库连接池的管理的相关属性的设置 --> 
		<!-- 若数据库中连接数不足时, 一次向数据库服务器申请多少个连接 -->
		<property name="acquireIncrement">5</property>
		<!-- 初始化数据库连接池时连接的数量 --> 
		<property name="initialPoolSize">5</property>
		<!-- 数据库连接池中的最小的数据库连接数 --> 
		<property name="minPoolSize">5</property>
		<!-- 数据库连接池中的最大的数据库连接数 --> 
		<property name="maxPoolSize">10</property>
		<!-- C3P0 数据库连接池可以维护的 Statement 的个数 --> 
		<property name="maxStatements">20</property>
		<!-- 每个连接同时可以使用的 Statement 对象的个数 --> 
		<property name="maxStatementsPerConnection">5</property>
		
	</named-config>
</c3p0-config>

（2）DBCP数据库连接池
DBCP 是Apache提供的数据库连接池。tomcat 服务器自带dbcp数据库连接池。速度相对c3p0较快，但因自身存在BUG，Hibernate3已不再提供支持。
获取连接示例：

//使用dbcp数据库连接池的配置文件方式，获取数据库的连接
private static DataSource source = null;
static{
	try {
		Properties pros = new Properties();

		InputStream is = DBCPTest.class.getClassLoader().getResourceAsStream("dbcp.properties");
		pros.load(is);
		//根据提供的BasicDataSourceFactory创建对应的DataSource对象
		source = BasicDataSourceFactory.createDataSource(pros);
	} catch (Exception e) {
		e.printStackTrace();
	}
}
public static Connection getConnection4() throws Exception {
	Connection conn = source.getConnection();
	return conn;
}

其中，src下的配置文件为：【dbcp.properties】

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/project1?
rewriteBatchedStatements=true&useServerPrepStmts=false
username=root
password=558597
initialSize=10

（3）Druid数据库连接池
Druid是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、Proxool等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，可以说是目前最好的连接池之一。
获取连接示例：

  /* 使用Druid数据库连接池，获取数据库的连接 */
private static DataSource source;
static {
    try {
        Properties pros = new Properties();

        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");

        pros.load(is);

        source = DruidDataSourceFactory.createDataSource(pros);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
public static Connection getConnection() throws SQLException {

    Connection conn = source.getConnection();
    return conn;
}

其中，src下的配置文件为：【druid.properties】

url=jdbc:mysql://localhost:3306/project1
username=root
password=558597
driverClassName=com.mysql.jdbc.Driver

initialSize=10
maxActive=20
maxWait=1000
filters=wall

一些详细配置参数：

配置	缺省	说明
name		配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。如果没有配置，将会生成一个名字，格式是：”DataSource-” + System.identityHashCode(this)
url		连接数据库的url，不同数据库不一样。例如：mysql : jdbc:mysql://10.20.153.104:3306/druid2 oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto
username		连接数据库的用户名
password		连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用 ConfigFilter。
driverClassName		根据url自动识别这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)
initialSize	0	初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
maxActive	8	最大连接池数量
maxIdle	8	已经不再使用，配置了也没效果
minIdle		最小连接池数量
maxWait		获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置 useUnfairLock属性为true使用非公平锁。
poolPreparedStatements	false	是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
maxOpenPreparedStatements	-1	要启用PSCache，必须配置大于0，当大于0时， poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
validationQuery		用来检测连接是否有效的sql，要求是一个查询语句。如果 validationQuery为null，testOnBorrow、testOnReturn、 testWhileIdle都不会其作用。
testOnBorrow	true	申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
testOnReturn	false	归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
testWhileIdle	false	建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行 validationQuery检测连接是否有效。
timeBetweenEvictionRunsMillis		有两个含义： 1)Destroy线程会检测连接的间隔时间2)testWhileIdle的判断依据，详细看testWhileIdle属性的说明
numTestsPerEvictionRun		不再使用，一个DruidDataSource只支持一个EvictionRun

Ⅲ Apache-DBUtils实现CRUD操作

Apache-DBUtils简介
commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。
API介绍：
org.apache.commons.dbutils.QueryRunner
org.apache.commons.dbutils.QueryRunner
工具类：org.apache.commons.dbutils.DbUtils

主要API的使用
（1）DbUtils
DbUtils ：提供如关闭连接、装载JDBC驱动程序等常规工作的工具类，里面的所有方法都是静态的。主要方法如下：
- public static void close(…) throws java.sql.SQLException： DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL，如果不是的话，它们就关闭Connection、Statement和ResultSet。
- public static void closeQuietly(…)：这一类方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭，还能隐藏一些在程序中抛出的SQLEeception。
- public static void commitAndClose(Connection conn)throws SQLException：用来提交连接的事务，然后关闭连接
- public static void commitAndCloseQuietly(Connection conn)：用来提交连接，然后关闭连接，并且在关闭连接时不抛出SQL异常。
- public static void rollback(Connection conn)throws SQLException：：允许conn为null，因为方法内部做了判断
- public static void rollbackAndClose(Connection conn)throws SQLException
- rollbackAndCloseQuietly(Connection)
- public static boolean loadDriver(java.lang.String driverClassName)：这一方装载并注册JDBC驱动程序，如果成功就返回true。使用该方法，你不需要捕捉这个异ClassNotFoundException。

（2）QueryRunner类
该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。
QueryRunner类提供了两个构造器：
- 默认的构造器
- 需要一个 javax.sql.DataSource 来作参数的构造器
QueryRunner类的主要方法：
- 更新
+ public int update(Connection conn, String sql, Object… params) throws SQLException:用来执行一个更新（插入、更新或删除）操作。
- 插入
+ public T insert(Connection conn,String sql,ResultSetHandler rsh, Object… params) throws SQLException：：只支持INSERT语句，其中 rsh - The handler used to create the result object from the ResultSet of auto-generated keys. 返回值: An object generated by the handler.即自动生成的键值
- 批处理
+ public int[] batch(Connection conn,String sql,Object[][] params)throws SQLException： INSERT,UPDATE, or DELETE语句
+ public T insertBatch(Connection conn,String sql,ResultSetHandler rsh,Object[][] params)throws SQLException：只支持INSERT语句
- 查询
+ public Object query(Connection conn, String sql, ResultSetHandler rsh,Object… params) throws SQLException：执执行一个查询操作，在这个查询中，对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理 PreparedStatement 和 ResultSet 的创建和关闭。

应用举例：
添加测试：

 // 测试添加
@Test
public void testInsert() {
    Connection conn = null;
    try {
        QueryRunner runner = new QueryRunner();
        conn = JDBCutils.getConnection();
        String sql = "insert into users(name,age) values(?,?)";
        int insertCount = runner.update(conn, sql, "艾米利亚", 18);
        System.out.println("添加了" + insertCount + "条记录");
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JDBCutils.closeResource(conn,null,null);
    }
}

删除测试：

  // 测试删除
@Test
public void testDelete(){
    Connection conn = null;
    try {
        QueryRunner runner = new QueryRunner();
        conn = JDBCutils.getConnection();
        String sql = "delete from users where id = ?";
        int deleteCount = runner.update(conn, sql, 2);
        System.out.println("删除了" + deleteCount + "条记录");
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JDBCutils.closeResource(conn,null,null);
    }
}

修改测试：

// 测试修改
@Test
public void testUpdate() throws SQLException {
    Connection conn = null;
    try {
        QueryRunner runner = new QueryRunner();
        conn = JDBCutils.getConnection();
        String sql = "update users set age = 60 where name = ?";
        int updateCount = runner.update(conn, sql, "张三");
        System.out.println("修改了" + updateCount + "条记录");
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JDBCutils.closeResource(conn, null,null);
    }
}

（3）ResultSetHandler接口及实现类
该接口用于处理 java.sql.ResultSet，将数据按要求转换为另一种形式。
ResultSetHandler 接口提供了一个单独的方法：Object handle (java.sql.ResultSet .rs)。
接口的主要实现类：
- ArrayHandler：把结果集中的第一行数据转成对象数组。
- ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
- BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
- BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
- ColumnListHandler：将结果集中某一列的数据存放到List中。
- KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。
- MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
- MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
- ScalarHandler：查询单个值对象

应用举例：
查询测试一：查询一条记录；使用ResultSetHandler的实现类：BeanHandler

 // 测试查询：查询一条记录
// 使用ResultSetHandler的实现类：BeanHandler
@Test
public void testQuery1(){
    Connection conn = null;
    try {
        QueryRunner runner = new QueryRunner();
        conn = JDBCutils.getConnection();
        String sql = "select id,name,age from users where name = ?";
        BeanHandler<Users> handler = new BeanHandler<>(Users.class);
        Users users = runner.query(conn, sql, handler, "张三");
        System.out.println(users);
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JDBCutils.closeResource(conn,null,null);
    }
}

查询测试二：查询多条记录构成的集合；使用ResultSetHandler的实现类：BeanListHandler

// 测试查询:查询多条记录构成的集合
// 使用ResultSetHandler的实现类：BeanListHandler
@Test
public void testQuery2() {
    Connection conn = null;
    try {
        QueryRunner runner = new QueryRunner();
        conn = JDBCutils.getConnection();
        String sql = "select id,name,age from users";
        BeanListHandler<Users> handler= new BeanListHandler<>(Users.class);
        List<Users> list = runner.query(conn, sql, handler);
        list.forEach(System.out::println);
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JDBCutils.closeResource(conn,null,null);
    }
}

查询测试三：查询特殊值(总和，最大值，最小值等等)；使用ResultSetHandler的实现类：ScalarHandler

// 测试查询：查询表中共有多少条记录
// 使用ResultSetHandler的实现类：ScalarHandler
@Test
public void testQuery3() {
    Connection conn = null;
    try {
        QueryRunner runner = new QueryRunner();
        conn = JDBCutils.getConnection();
        String sql = "select count(*) from users";
        ScalarHandler handler = new ScalarHandler();
        Long count = (Long)runner.query(conn,sql,handler);
        System.out.println("Users表中共用" + count + "条记录");
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JDBCutils.closeResource(conn,null,null);
    }
}

 // 测试查询：查询表中最大的年龄
// 使用ResultSetHandler的实现类：ScalarHandler
@Test
public void testQuery4(){
    Connection conn = null;
    try {
        QueryRunner runner = new QueryRunner();
        conn = JDBCutils.getConnection();
        String sql = "select max(age) from users";
        ScalarHandler handler = new ScalarHandler();
        Integer maxAge = (Integer) runner.query(conn, sql, handler);
        System.out.println("表中最大的年龄为" + maxAge);
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JDBCutils.closeResource(conn,null,null);
    }
}

如果ResultSetHandler的实现类没有我们需要的子类，那么我们也可以根据需求自定义一个

// 自定义ResultSetHandler的实现类
@Test
public void testQuery5(){
    Connection conn = null;
    try {
        QueryRunner runner = new QueryRunner();
        conn = JDBCutils.getConnection();
        String sql = "select id,name,age from users where id = ?";
        ResultSetHandler<Users> handler = new ResultSetHandler<Users>() {
            @Override
            public Users handle(ResultSet rs) throws SQLException{
                System.out.println("handle");

                if(rs.next()){
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    int age = rs.getInt("age");

                    return new Users(id, name, age);
                }
                return null;
            }
        };

        Users users = runner.query(conn, sql, handler, 2);
        System.out.println(users);
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JDBCutils.closeResource(conn,null,null);
    }
}

Ⅳ 完善DAO及其实现类

JDBCutils

public class JDBCutils {

    /* 使用Druid数据库连接池，获取数据库的连接 */
    private static DataSource source;
    static {
        try {
            Properties pros = new Properties();

            InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");

            pros.load(is);

            source = DruidDataSourceFactory.createDataSource(pros);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection() throws SQLException {

        Connection conn = source.getConnection();
        return conn;
    }

    /* 使用DButils,关闭资源 */
    public static void closeResource(Connection conn, PreparedStatement psmt, ResultSet rs){
      DbUtils.closeQuietly(conn);
      DbUtils.closeQuietly(psmt);
      DbUtils.closeQuietly(rs);
    }
}

BaseDAO

/*
 * 定义一个用来被继承的对数据库进行基本操作的Dao
 */
public abstract class BaseDAO<T> {
    private QueryRunner queryRunner = new QueryRunner();
    // 定义一个变量来接收泛型的类型
    private Class<T> type;

    // 获取T的Class对象，获取泛型的类型，泛型是在被子类继承时才确定
    public BaseDAO() {
        // 获取子类的类型
        Class clazz = this.getClass();
        // 获取父类的类型
        // getGenericSuperclass()用来获取当前类的父类的类型
        // ParameterizedType表示的是带泛型的类型
        ParameterizedType parameterizedType = (ParameterizedType) clazz.getGenericSuperclass();
        // 获取具体的泛型类型 getActualTypeArguments获取具体的泛型的类型
        // 这个方法会返回一个Type的数组
        Type[] types = parameterizedType.getActualTypeArguments();
        // 获取具体的泛型的类型·
        this.type = (Class<T>) types[0];
    }

    /* 通用的增删改操作 --- 考虑数据库事务 */
    public int update(Connection conn, String sql, Object... args) {
        int count = 0;
        try {
            count = queryRunner.update(conn, sql, args);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }

    /* 通用的查询操作(返回一个对象) --- 考虑数据库事务 */
    public T getBean(Connection conn, String sql, Object... args) {
        T t = null;
        try {
            t = queryRunner.query(conn, sql, new BeanHandler<T>(type), args);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return t;
    }

    /* 通用的查询操作(返回多个对象) --- 考虑数据库事务 */
    public List<T> getBeanList(Connection conn, String sql, Object... args) {
        List<T> list = null;
        try {
            list = queryRunner.query(conn, sql, new BeanListHandler<T>(type), args);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }

    /* 用于查询特殊值的通用方法 */
    public Object getValue(Connection conn, String sql, Object... args) {
        Object count = null;
        try {
            // 调用queryRunner的query方法获取一个单一的值
            count = queryRunner.query(conn, sql, new ScalarHandler(), args);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }
}

UserDAO

/*
 * 此接口用于规范针对于Users表的常用操作
 */
public interface UsersDAO {

    /**
     * 将users对象添加到数据库中
     * @param conn
     * @param users
     */
    public void insert(Connection conn, Users users);

    /**
     * 根据指定的id，删除表中的一条记录
     * @param conn
     * @param id
     */
    public void deleteById(Connection conn, int id);

    /**
     * 针对内存中的users对象，去修改数据表中指定的记录
     * @param conn
     * @param users
     */
    public void update(Connection conn, Users users);

    /**
     * 针对指定的id，查询得到对应的users对象
     * @param conn
     * @param id
     * @return
     */
    public Users getUsersById(Connection conn, int id);

    /**
     * 查询表中的所有记录
     * @param conn
     * @return
     */
    public List<Users> getAll(Connection conn);

    /**
     * 返回数据表中的数据的条目数
     * @param conn
     * @return
     */
    public Long getCount(Connection conn);

    /**
     * 返回数据表中最大的年龄
     * @param conn
     * @return
     */
    public int getMaxAge(Connection conn);
}

UserDAOImpl

**
 * DAO:data(base) access object
 */
public class UsersDAOImpl extends BaseDAO<Users> implements UsersDAO {
    @Override
    public void insert(Connection conn, Users users) {
        String sql = "insert into users(name,age) values(?,?)";
        update(conn, sql, users.getName(), users.getAge());
    }

    @Override
    public void deleteById(Connection conn, int id) {
        String sql = "delete from users where id = ?";
        update(conn, sql, id);
    }

    @Override
    public void update(Connection conn, Users users) {
        String sql = "update users set name = ?,age = ? where id = ?";
        update(conn, sql, users.getName(), users.getAge(), users.getId());
    }

    @Override
    public Users getUsersById(Connection conn, int id) {
        String sql = "select id,name,age from users where id = ?";
        Users users = getBean(conn, sql, id);
        return users;

    }

    @Override
    public List<Users> getAll(Connection conn) {
        String sql = "select id,name,age from users";
        List<Users> list = getBeanList(conn, sql);
        return list;
    }

    @Override
    public Long getCount(Connection conn) {
        String sql = "select count(*) from users";
        return (Long) getValue(conn, sql);
    }

    @Override
    public int getMaxAge(Connection conn) {
        String sql = "select max(age) from users";
        return (int) getValue(conn, sql);
    }
}

UserDAOImplTest

public class UsersDAPImplTest {
    private UsersDAO dao = new UsersDAOImpl();

    @Test
    public void testInsert(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            Users users = new Users(1, "艾米利亚", 18);
            dao.insert(conn,users);
            System.out.println("添加成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null,null);
        }
    }

    @Test
    public void testDeleteById(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            dao.deleteById(conn, 4);
            System.out.println("删除成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null,null);
        }
    }

    @Test
    public void testUpdateConnectionUsers(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            Users users = new Users(1, "艾米利亚", 18);
            dao.update(conn, users);
            System.out.println("修改成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null,null);
        }
    }

    @Test
    public void testGetUsrsById(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            Users users = dao.getUsersById(conn, 1);
            System.out.println(users);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null,null);
        }
    }

    @Test
    public void testGetAll(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            List<Users> list = dao.getAll(conn);
            list.forEach(System.out::println);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null,null);
        }
    }

    @Test
    public void testGetCount(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            Long count = dao.getCount(conn);
            System.out.println("表中的记录数为：" + count);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null,null);
        }
    }

    @Test
    public void testGetMaxAge(){
        Connection conn = null;
        try {
            conn = JDBCutils.getConnection();
            int age= dao.getMaxAge(conn);
            System.out.println("表中的最大年龄为：" + age);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutils.closeResource(conn,null,null);
        }
    }
}

离渊灬

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java后端学习笔记 -- JDBC(三)

写在开头：本文是学习Java后端开发的个人笔记，便于自己复习。文章内容引用了尚硅谷的jdbc教学，有兴趣的朋友可以上B站搜索。JDBC(三) Ⅰ DAO及其实现类 Ⅱ 数据库连接池 Ⅲ Apache-DBUtils实现CRUD操作Ⅰ DAO及其实现类Ⅱ 数据库连接池Ⅲ Apache-DBUtils实现CRUD操作...
复制链接

扫一扫

专栏目录