精华内容
下载资源
问答
  • DBUtils

    多人点赞 2019-11-10 11:38:37
    DBUtils 简介 DBUtils是Java编程中的数据库操作实用工具,小巧简单实用。DBUtils封装了对JDBC的操作,简化了JDBC操作,可以减少60%以上的代码。 DBUtils三个核心功能介绍 QueryRunner:r核心类提供对sql语句操作的...

    DBUtils

    简介

    DBUtils是Java编程中的数据库操作实用工具,小巧简单实用。DBUtils封装了对JDBC的操作,简化了JDBC操作,可以减少60%以上的代码。

    DBUtils三个核心功能介绍

    • QueryRunner:核心类提供对sql语句操作的API
      • QueryRunner(DataSourcr ds):提供数据源(连接池),DbUtils底层自动维护连接connection
      • update(String sql,Obj…params):执行更新操作
      • query(String sql,ResultSetHandlerrsh,Object…panrams):执行查询操作
    • ResultSetHandler:结果集处理类,用于定义select操作后,怎样封装结果集
      • ArrayHandler:把查询结果集中的第一行数据放到一个数组中。适合取1条记录。
      • ArrayListHandler:将查询的结果的每一行数据都放到一个数组中,然后再将数组放到集合List中。适合取多条记录。
      • BeanHandler:将结果集中的第一行数据封装到一个对应的JavaBean实例中
      • BeanListHandler:将结果集中的每一行数据都封装到一个对应的JavaBean实例中,然后再将这些对象存放到List里。
      • MapHandler:将结果集中的第一行数据封装到一个Map里,key是列名,value就是对应的值。
      • MapListHandler:将查询的结果的每一行存入到一个map中,键为列名,值为各列值;然后再将map存入list中
      • ColumnListHandler:将结果集中某一列的数据存放到List中。
      • KeyedHandler(name):将结果集中的每一行数据都封装到一个Map里(List),再把这些map再存到一个map里,其key为指定的列。
      • ScalarHandler:将结果集第一行的某一列放到某个对象中。//重点
    • DBUtils:工具类,定义了关闭资源与事务处理的方法。

    示例:采用Druid和dbutils实现对Dept的CRUD

    • 第一步:Dept.java:Dept源代码

    • 第二步:新建项目,加入Maven依赖:

      <dependency>
        <groupId>commons-dbutils</groupId>
        <artifactId>commons-dbutils</artifactId>
        <version>1.7</version>
      </dependency>
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.1.17</version>
      </dependency>
      
    • 第二步:在resources目录下创建mysql.properties,代码如下:

      driverClassName=com.mysql.cj.jdbc.Driver
      url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC&user=root&password=&useUnicode=true&characterEncoding=UTF8&autoReconnect=true&failOverReadOnly=false
      username=root
      password=root
      
      
      filters=stat
      initialSize=2
      maxActive=300
      maxWait=60000
      timeBetweenEvictionRunsMillis=60000
      minEvictableIdleTimeMillis=300000
      validationQuery=SELECT 1
      testWhileIdle=true
      testOnBorrow=false
      testOnReturn=false
      poolPreparedStatements=false
      maxPoolPreparedStatementPerConnectionSize=200
      
    • 第三步:创建数据库连接工具类:

      public class DBUtil {
          private static final ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
          private static DataSource dataSource = null;
      
          private DBUtil() {
          }
      
          static {    //配置文件加载,只执行一次
              try (InputStream is = DBUtil.class.getResourceAsStream("/mysql.properties");) {
                  Properties properties = new Properties();
                  properties.load(is);
                  dataSource = DruidDataSourceFactory.createDataSource(properties);
              } catch (Exception e1) {
                  throw new RuntimeException("读取配置文件异常", e1);
              }
          }
      
          public static Connection getConnection() {    //获取连接
              Connection conn = null;
              try {
                  conn = threadLocal.get();   //从当前线程获得 conn
                  if (conn == null || conn.isClosed()) {
                      conn = dataSource.getConnection();
                      threadLocal.set(conn);
                  }
              } catch (Exception e) {
                  throw new RuntimeException("连接数据库异常", e);
              }
              return conn;
          }
      
          public static QueryRunner getQueryRunner() {
              return new QueryRunner(dataSource);
          }
      
          public static void release(Connection conn) {
              try { // 建议采用这种形式来释放资源,因为finally里面的一定会被释放
                  if (conn != null) {
                      conn.close();
                  }
              } catch (SQLException e) {
                  e.printStackTrace();
              }
          }
      }
      
    • 第四步:测试事务

      public static void main(String[] args) {
          Connection conn = getConnection();
          try {
              conn.setAutoCommit(false); // 设置事务提交为手动
              String sql = "insert into tb_dept (dname,loc) values(?,?)";
              QueryRunner queryRunner = getQueryRunner();
              queryRunner.update(conn, sql, "aa", "aaaaa");
              System.out.println(3 / 0);
              queryRunner.update(sql, "bb", "bbbbbbbbbb");
              conn.commit();
          } catch (SQLException e) {
              e.printStackTrace();
              try {
                  conn.rollback();
              } catch (SQLException ex) {
                  ex.printStackTrace();
              }
          } finally {
              release(conn);
          }
      }
      
    • 第五步:DeptDaoImpl.java

      public class DeptDaoImpl {
          private QueryRunner queryRunner = DBUtil.getQueryRunner();
      
          public int insertDept(Dept dept) throws SQLException {
              String sql = "insert into tb_dept (deptno, dname, loc) values (?, ?, ?)";
              return queryRunner.update(sql, dept.getDeptno(), dept.getDname(), dept.getLoc());
          }
      
          public int batchInsertDept(List<Dept> deptList) throws SQLException {
              Object[][] params = new Object[deptList.size()][3];
      
              for (int i = 0; i < params.length; i++) {
                  Dept dept = deptList.get(i);
                  params[i][0] = dept.getDeptno();
                  params[i][1] = dept.getDname();
                  params[i][2] = dept.getLoc();
              }
      
              StringBuilder wenHao = new StringBuilder();
              for (int i = 0; i < params[0].length; i++) {
                  wenHao.append("?,");
              }
              String sql = "insert into tb_dept values(" + wenHao.deleteCharAt(wenHao.length() - 1) + ")";
      
              queryRunner.batch(sql, params);
              return 1;  // 如果不抛出异常,就返回1,表示删除成功
          }
      
          public int deleteDeptByDeptno(Byte deptno) throws SQLException {
              String sql = "delete from tb_dept where deptno = ?";
              return queryRunner.update(sql, deptno);
          }
      
          public int deleteDeptByCondition(Dept dept) throws SQLException {
              List<Object> paramValueList = new ArrayList<>();
              StringBuffer paramBuf = new StringBuffer("1=1 ");
      
              if (dept.getDeptno() != null) {
                  paramBuf.append("and deptno= ? ");
                  paramValueList.add(dept.getDeptno());
              }
              if (dept.getDname() != null) {
                  paramBuf.append("and dname= ? ");
                  paramValueList.add(dept.getDname());
              }
              if (dept.getLoc() != null) {
                  paramBuf.append("and loc= ? ");
                  paramValueList.add(dept.getLoc());
              }
      
              String sql = "delete from tb_dept where " + paramBuf.substring(0, paramBuf.length() - 3);
              return queryRunner.update(sql, paramValueList.toArray());
          }
      
          public int batchDeleteDeptByDeptnos(String deptnos) throws SQLException {
              String[] split = deptnos.split(",");
              Object[][] params = new Object[1][];
      
              StringBuilder wenHao = new StringBuilder();
              for (int i = 0; i < split.length; i++) {
                  wenHao.append("?,");
              }
              params[0] = split;
      
              String sql = "delete from tb_dept where deptno in (" + wenHao.deleteCharAt(wenHao.length() - 1) + ")";
      
              queryRunner.batch(sql, params);
              return 1;  // 如果不抛出异常,就返回1,表示删除成功
          }
      
          public int updateDept(Dept dept) throws SQLException {
              String sql = "update tb_dept set dname= ? ,loc= ? where deptno = ?";
              return queryRunner.update(sql, dept.getDname(), dept.getLoc(), dept.getDeptno());
          }
      
          public long selectCount() throws SQLException {
              String sql = "select count(*) from tb_dept";
              // ScalarHandler:将查询的结果的第一行的某一列放到一个对象中;精确定位到某个值
              Long query = queryRunner.query(sql, new ScalarHandler<Long>());
              return query.intValue();
          }
      
          public long selectCountByCondition(Dept dept) throws SQLException {
              List<Object> paramValueList = new ArrayList<>();
              StringBuffer paramBuf = new StringBuffer("1=1 ");
      
              if (dept.getDeptno() != null) {
                  paramBuf.append("and deptno= ? ");
                  paramValueList.add(dept.getDeptno());
              }
              if (dept.getDname() != null) {
                  paramBuf.append("and dname= ? ");
                  paramValueList.add(dept.getDname());
              }
              if (dept.getLoc() != null) {
                  paramBuf.append("and loc= ? ");
                  paramValueList.add(dept.getLoc());
              }
      
              String sql = "select count(*) from tb_dept where " + paramBuf.substring(0, paramBuf.length() - 3);
              Long query = queryRunner.query(sql, new ScalarHandler<Long>(), paramValueList.toArray());
              return query.intValue();
          }
      
          public Dept selectDeptByDeptno(Byte deptno) throws SQLException {
              String sql = "select deptno as deptno, dname as dname, loc as loc from tb_dept where  deptno = ?";
              return queryRunner.query(sql, new BeanHandler<>(Dept.class), deptno);
          }
      
          public List<Dept> selectAllDept() throws SQLException {
              String sql = "select deptno as deptno, dname as dname, loc as loc from tb_dept";
              return queryRunner.query(sql, new BeanListHandler<>(Dept.class));
          }
      
          public List<Dept> selectDeptByCondition(Dept dept) throws SQLException {
              List<Object> paramValueList = new ArrayList<>();
              StringBuffer paramBuf = new StringBuffer("1=1 ");
      
              if (dept.getDeptno() != null) {
                  paramBuf.append("and deptno= ? ");
                  paramValueList.add(dept.getDeptno());
              }
              if (dept.getDname() != null) {
                  paramBuf.append("and dname= ? ");
                  paramValueList.add(dept.getDname());
              }
              if (dept.getLoc() != null) {
                  paramBuf.append("and loc= ? ");
                  paramValueList.add(dept.getLoc());
              }
      
              String sql = "select deptno as deptno, dname as dname, loc as loc  from tb_dept where " + paramBuf.substring(0, paramBuf.length() - 3);
              return queryRunner.query(sql, new BeanListHandler<>(Dept.class), paramValueList.toArray());
          }
      
          public List<Dept> selectDeptWithPagination(int page, int rows) throws SQLException {
              String sql = "select deptno as deptno, dname as dname, loc as loc from tb_dept limit ?, ?";
              return queryRunner.query(sql, new BeanListHandler<>(Dept.class), (page - 1) * rows, rows);
          }
      
          public List<Dept> selectDeptWithPaginationByCondition(int page, int rows, Dept dept) throws SQLException {
              List<Object> paramValueList = new ArrayList<>();
              StringBuffer paramBuf = new StringBuffer("1=1 ");
      
              if (dept.getDeptno() != null) {
                  paramBuf.append("and deptno= ? ");
                  paramValueList.add(dept.getDeptno());
              }
              if (dept.getDname() != null) {
                  paramBuf.append("and dname= ? ");
                  paramValueList.add(dept.getDname());
              }
              if (dept.getLoc() != null) {
                  paramBuf.append("and loc= ? ");
                  paramValueList.add(dept.getLoc());
              }
      
              String sql = "select deptno as deptno, dname as dname, loc as loc  from tb_dept where " + paramBuf.substring(0, paramBuf.length() - 3) + " limit ?, ?";
      
              paramValueList.add((page - 1) * rows);
              paramValueList.add(rows);
              return queryRunner.query(sql, new BeanListHandler<>(Dept.class), paramValueList.toArray());
          }
      }
      

    动态SQL与静态SQL

    SQL 语句从编译和运行的角度可以分为静态 SQL和 动态 SQL,所谓SQL的动态和静态,是指SQL语句在何时被编译和执行。

    这两种 SQL 在使用方式、运行机制和性能表现等方面各有特点 :

    • 静态 SQL:静态 SQL 语句一般用于嵌入式 SQL 应用中,在程序运行前,SQL 语句在编程时候必须是确定好的,例如 SQL 语句中涉及的列名和表名必须是存在的。静态 SQL 语句的编译是在应用程序运行前进行的,编译的结果会存储在数据库内部。而后程序运行时,数据库将直接执行编译好的 SQL 语句,降低运行时的开销。
    • 动态 SQL:动态 SQL 语句是在应用程序运行时被编译和执行的,例如,使用 DB2 的交互式工具 CLP 访问数据库时,用户输入的 SQL 语句是不确定的,因此 SQL 语句只能被动态地编译。动态 SQL 的应用较多,常见的 CLI 和 JDBC 应用程序都使用动态 SQL。

    静态sql的存取路径是在运行前就确定好的,而动态sql的存取路径是在运行时动态生成的。

    注意:在SQL中如果某些参数没有确定,如"select * from t1 where c1>? and c2<?",这种语句是静态SQL,不是动态SQL,虽然个别参数的值不知道,但整个SQL的结构已经确定,数据库是可以将它编译的,在执行阶段只需将个别参数的值补充进来即可。

    展开全文
  • DbUtils

    2020-03-26 23:58:16
    DbUtils 1. 轻量级数据库ORM框架DbUtils 1.1 DbUtils介绍 Apache组织下的一个轻量级ORM框架 Commons DbUtils: JDBC Utility Component 两个核心方法 update方法 ==> insert,update,delete query方法 ==>...

    DbUtils

    1. 轻量级数据库ORM框架DbUtils

    1.1 DbUtils介绍
    	Apache组织下的一个轻量级ORM框架
    	Commons DbUtils: JDBC Utility Component
    两个核心方法
    	update方法 ==> insert,update,delete
    	query方法 ==> select
    
    一个核心类
    	QueryRunner DbUtils的核心类
    
    1.2 DbUtils ORM工具使用
    package com.qfedu.c_dbutils;
    
    import com.qfedu.b_studentsys.entity.Student;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.ResultSetHandler;
    import org.apache.commons.dbutils.handlers.*;
    import org.junit.Test;
    import util.JdbcUtil;
    
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    
    /**
     * DbUtils ORM框架演示
     *
     * @author Anonymous 2020/3/25 16:03
     */
    public class DbUtilsTest {
        @Test
        public void testInsert() throws SQLException {
            // 1. DbUtils核心类 QueryRunner对象
            QueryRunner runner = new QueryRunner();
    
            // 2. 插入数据到Student数据表中
            String sql = "insert into student(name, age, gender, score, address) value(?, ?, ?, ?, ?)";
            Object[] parameters = {"老黑", 70, true, 59, "河南郑州"};
    
            // 3. 获取数据库连接
            Connection connection = JdbcUtil.getConnection();
    
            // 4. 执行Update方法
            runner.update(connection, sql, parameters);
    
            JdbcUtil.close(connection);
        }
    
        /**
         * 了解操作方式, ResultSetHandler
         */
        @Test
        public void testQuery1() throws SQLException {
            // 1. DbUtils核心类 QueryRunner对象
            QueryRunner runner = new QueryRunner();
    
            // 2. SQL语句
            String sql = "select * from student where id = 1";
    
            Connection connection = JdbcUtil.getConnection();
    
            /*
             ResultSetHandler 核心接口
                ResultSet结果集 Handler处理,
                核心方法 handler(ResultSet rs)
             */
            Student student = runner.query(connection, sql, rs -> {
                Student stu = null;
                if (rs.next()) {
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    int age = rs.getInt("age");
                    boolean gender = rs.getBoolean("gender");
                    float score = rs.getFloat("score");
                    String address = rs.getString("address");
    
                    stu = new Student(id, name, age, gender, score, address);
                }
                return stu;
            });
    
            System.out.println(student);
            JdbcUtil.close(connection);
        }
    
        /**
         * BeanHandler
         */
        @Test
        public void queryBean() throws SQLException {
            // 1. DbUtils核心类 QueryRunner对象
            QueryRunner runner = new QueryRunner();
    
            // 2. SQL语句
            String sql = "select * from student where id = 1";
    
            Connection connection = JdbcUtil.getConnection();
    
            /*
            BeanHandler: 处理符合JavaBean规范的类对象,传入参数是对应JavaBean规范 Class对象
             */
            Student student = runner.query(connection, sql, new BeanHandler<>(Student.class));
    
            System.out.println(student);
    
            JdbcUtil.close(connection);
        }
    
        /**
         * BeanListHandler
         */
        @Test
        public void queryBeanList() throws SQLException {
            // 1. DbUtils核心类 QueryRunner对象
            QueryRunner runner = new QueryRunner();
    
            // 2. SQL语句
            String sql = "select * from student where id > ?";
    
            Connection connection = JdbcUtil.getConnection();
    
            /*
            BeanListHandler: 处理符合JavaBean规范的实体类,并且返回值是一个List集合
            包含制定的JavaBean实体类
             */
            List<Student> list = runner.query(connection, sql, new BeanListHandler<>(Student.class), 2);
    
            for (Student student : list) {
                System.out.println(student);
            }
            JdbcUtil.close(connection);
        }
    
        /**
         * ArrayHandler
         */
        @Test
        public void queryArray() throws SQLException {
            // 1. DbUtils核心类 QueryRunner对象
            QueryRunner runner = new QueryRunner();
    
            // 2. SQL语句
            String sql = "select * from student where id = 1";
    
            Connection connection = JdbcUtil.getConnection();
    
            /*
            ArrayHandler: 查询一个数据行,数据行中的所有数据整合成一个Object类型数组返回
             */
            Object[] values = runner.query(connection, sql, new ArrayHandler());
    
            System.out.println(Arrays.toString(values));
    
            JdbcUtil.close(connection);
        }
    
        /**
         * ArrayListHandler
         */
        @Test
        public void queryArrayList() throws SQLException {
            // 1. DbUtils核心类 QueryRunner对象
            QueryRunner runner = new QueryRunner();
    
            // 2. SQL语句
            String sql = "select * from student where id > ?";
    
            Connection connection = JdbcUtil.getConnection();
    
            /*
            ArrayListHandler: 查询结果集中所有数据行,每一行数据对应一个Object类型数组,存储在List集合中
             */
            List<Object[]> list = runner.query(connection, sql, new ArrayListHandler(), 2);
    
            for (Object[] values : list) {
                System.out.println(Arrays.toString(values));
            }
            JdbcUtil.close(connection);
        }
    
        /**
         * MapHandler
         */
        @Test
        public void queryMap() throws SQLException {
            // 1. DbUtils核心类 QueryRunner对象
            QueryRunner runner = new QueryRunner();
    
            // 2. SQL语句
            String sql = "select * from student where id = 1";
    
            Connection connection = JdbcUtil.getConnection();
    
            /*
            MapHandler: 处理一个数据行,数据行中字段是对应Key,字段对应数据是value,组成一个Map双边队列
             */
            Map<String, Object> map = runner.query(connection, sql, new MapHandler());
    
            System.out.println(map);
        }
    
        /**
         * MapListHandler
         */
        @Test
        public void queryMapList() throws SQLException {
            // 1. DbUtils核心类 QueryRunner对象
            QueryRunner runner = new QueryRunner();
    
            // 2. SQL语句
            String sql = "select * from student where id > ?";
    
            Connection connection = JdbcUtil.getConnection();
    
            /*
            MapListHandler: 结果集中所有的数据行,每一行对应一个Map对象,字段名为Key,字段对应的数据为value,所有数据行存储
            在List中
             */
            List<Map<String, Object>> mapList = runner.query(connection, sql, new MapListHandler(), 2);
    
            for (Map<String, Object> map : mapList) {
                System.out.println(map);
            }
        }
    }
    
    
    1.3 ResultHandler以及其子类
    ResultSetHandler 核心接口
    	ResultSet结果集 Handler处理,	
    	核心方法 handler(ResultSet rs)
     
    BeanHandler: 
    	处理符合JavaBean规范的类对象,传入参数是对应JavaBean规范 Class对象
    
    BeanListHandler: 
    	处理符合JavaBean规范的实体类,并且返回值是一个List集合包含制定的JavaBean实体类
    
    ArrayHandler: 
    	查询一个数据行,数据行中的所有数据整合成一个Object类型数组返回
    
    ArrayListHandler: 
    	查询结果集中所有数据行,每一行数据对应一个Object类型数组,存储在List集合中
    
    MapHandler: 
    	处理一个数据行,数据行中字段是对应Key,字段对应数据是value,组成一个Map双边队列
    
    MapListHandler: 
    	结果集中所有的数据行,每一行对应一个Map对象,字段名为Key,字段对应的数据为value,所有数据行存储在List中
    
    展开全文
  • DButils

    千次阅读 2018-07-30 11:12:36
    Dbutils是什么?(当我们很难理解一个东西的官方解释的时候,就让我们记住它的作用) Dbutils:主要是封装了JDBC的代码,简化dao层的操作。 作用:帮助java程序员,开发Dao层代码的简单框架。 为什么需要Dbutils...

    Dbutils是什么?(当我们很难理解一个东西的官方解释的时候,就让我们记住它的作用)
    Dbutils:主要是封装了JDBC的代码,简化dao层的操作。
    作用:帮助java程序员,开发Dao层代码的简单框架。
    为什么需要Dbutils ?
    在使用Dbutils 之前,我们Dao层使用的技术是JDBC,那么分析一下JDBC的弊端:
    (1)数据库链接对象、sql语句操作对象,封装结果集对象,这三大对象会重复定义
    (2)封装数据的代码重复,而且操作复杂,代码量大
    (3)释放资源的代码重复
    结果:
    (1)程序员在开发的时候,有大量的重复劳动。(
    (2)2)开发的周期长,效率低

    使用Dbutils注意事项:
    (1)需要导入的jar包
    (2)添加c3p0配置文件
    (3)可以自行添加一个JDBCUtils工具类:用来获取c3p0连接池对象

    使用前查询指定的账号信息:
    这里写图片描述

    使用后的获取指定的账号信息:
    这里写图片描述
    用这个:
    这里写图片描述
    代替:

    这里写图片描述

    这里写图片描述

    new BeanHandler<User>(User.class),params

    (BeanHandler类)
    代表:

    if (rs.next()){
        User user = new User();
        user.setUserId(rs.getString("userId"));//从结果集当前记录中取出userId
        user.setPassword(rs.getString("password"));
        user.setName(rs.getString("name"));
        user.setPhone(rs.getString("phone"));
        user.setSex(rs.getByte("sex"));
        return user;

    DbUtils 关闭链接等操作
    QueryRunner 进行查询的操作
    ArrayHandler :将ResultSet中第一行的数据转化成对象数组
    ArrayListHandler将ResultSet中所有的数据转化成List,List中存放的是Object[]
    BeanHandler :将ResultSet中第一行的数据转化成类对象
    BeanListHandler :将ResultSet中所有的数据转化成List,List中存放的是类对象
    ColumnListHandler :将ResultSet中某一列的数据存成List,List中存放的是Object对象
    KeyedHandler :将ResultSet中存成映射,key为某一列对应为Map。Map中存放的是数据
    MapHandler :将ResultSet中第一行的数据存成Map映射
    MapListHandler :将ResultSet中所有的数据存成List。List中存放的是Map
    ScalarHandler :将ResultSet中一条记录的其中某一列的数据存成Object
    SqlNullCheckedResultSet :对ResultSet进行操作,改版里面的值
    StringTrimmedResultSet :去除ResultSet中中字段的左右空格。Trim()
    主要方法:
    DbUtils类:启动类
    ResultSetHandler接口:转换类型接口
    MapListHandler类:实现类,把记录转化成List
    BeanListHandler类:实现类,把记录转化成List,使记录为JavaBean类型的对象
    Query Runner类:执行SQL语句的类

    展开全文
  • Dbutils

    千次阅读 2017-03-29 22:38:48
    一:Dbutils是什么?(当我们很难理解一个东西的官方解释的时候,就让我们记住它的作用) Dbutils:主要是封装了JDBC的代码,简化dao层的操作。 作用:帮助java程序员,开发Dao层代码的简单框架。 框架的作用...

    转载自:http://www.cnblogs.com/CQY1183344265/p/5854418.html

    一:Dbutils是什么?(当我们很难理解一个东西的官方解释的时候,就让我们记住它的作用)
    Dbutils:主要是封装了JDBC的代码,简化dao层的操作。
    作用:帮助java程序员,开发Dao层代码的简单框架。
    框架的作用:帮助程序员,提高程序的开发效率。
    出生:Dbutils是由Apache公司提供。

    二:为什么需要Dbutils ?
    在使用Dbutils 之前,我们Dao层使用的技术是JDBC,那么分析一下JDBC的弊端:
    (1)数据库链接对象、sql语句操作对象,封装结果集对象,这三大对象会重复定义
    (2)封装数据的代码重复,而且操作复杂,代码量大
    (3)释放资源的代码重复
    结果:(1)程序员在开发的时候,有大量的重复劳动。(2)开发的周期长,效率低

    三:Dbutils三个核心类介绍:
    1:DbUtils:连接数据库对象—-jdbc辅助方法的集合类,线程安全
    构造方法:DbUtils()
    作用:控制连接,控制书屋,控制驱动加载额一个类。

    2:QueryRunner:SQL语句的操作对象,可以设置查询结果集的封装策略,线程安全。
    构造方法:
    (1)QueryRunner():创建一个与数据库无关的QueryRunner对象,后期再操作数据库的会后,需要手动给一个Connection对象,它可以手动控制事务。
    Connection.setAutoCommit(false); 设置手动管理事务
    Connection.commit(); 提交事务

    (2)QueryRunner(DataSource ds):创建一个与数据库关联的queryRunner对象,后期再操作数据库的时候,不需要Connection对象,自动管理事务。
    DataSource:数据库连接池对象。

    构造函数与增删改查方法的组合:
    QueryRunner()
    update(Connection conn, String sql, Object… params)
    query(Connection conn, String sql, ResultSetHandler rsh, Object… params)

    QueryRunner(DataSource ds)
    update(String sql, Object… params)
    query(String sql, ResultSetHandler rsh, Object… params)

    (3)ResultSetHandle:封装数据的策略对象——将封装结果集中的数据,转换到另一个对象
    策略:封装数据到对象的方式(示例:将数据库保存在User、保存到数组、保存到集合)
    方法介绍:handle(ResultSet rs)
    A: DBUtils工具类结果集处理的方式
    a: QueryRunner实现查询操作
    query(Connection conn, String sql, ResultSetHandler rsh, Object… params) ,用来完成表数据的查询操作
    b: ResultSetHandler结果集处理类
    ①ArrayHandler 将结果集中的第一条记录封装到一个Object[]数组中,数组中的每一个元素就是这条记录中的每一个字段的值
    ②ArrayListHandler 将结果集中的每一条记录都封装到一个Object[]数组中,将这些数组在封装到List集合中。
    ③BeanHandler 将结果集中第一条记录封装到一个指定的javaBean中。
    ④BeanListHandler 将结果集中每一条记录封装到指定的javaBean中,将这些javaBean在封装到List集合中
    ⑤ColumnListHandler 将结果集中指定的列的字段值,封装到一个List集合中
    ⑥ScalarHandler 它是用于单数据。例如select count(*) from 表操作。
    ⑦MapHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
    ⑧MapListHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合
    常用的是BeanHandlerBeanListHandlerScalarHandler

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,161
精华内容 11,664
关键字:

dbutils