QueryRunner 基本用法的实践

QueryRunner 是什么

QueryRunner 是dbutils包下一个为了增强 JDBC 的类，简化了 JDBC 中数据操作，以及数据与对象之间的转化

使用之前需要先导jar包，jar包下载地址为:http://commons.apache.org/proper/commons-dbutils/

涉及到事务时创建QueryRunner对象时，不需要传入参数，但需要在方法里传入和其他层同一个Connection对象。

不涉及到事务时，创建QueryRunner对象，需要提供一个DateSource对象，QueryRunner内部从连接池获得连接

update()方法

实现对数据表的 insert delete update
1.int update(String sql,Object…params)–>可执行增、删、改语句

2.int update(Connection conn,String sql,Object…params)–>同样支持增、删、改操作，但是方法不管理Connection了，支持事务

package com.example.stu.controller;

import com.example.stu.po.User;
import com.example.stu.util.JdbcUtil;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;

import java.sql.SQLException;
import org.apache.commons.dbutils.QueryRunner;

public class TestDemo{
    private static Connection con = JDBCUtilConfig.getConnection();
    private static QueryRunner runner = new QueryRunner(JdbcUtil.getDataSource());

	public int test(){
		// 添加的sql語句
        String sql1 = "insert into user (name, age, sex) values (?,?,?)";
        // 刪除的sql語句
        String sql2 = "delete form user where id = ?";
        
        Object[] params1 = {"dzl","25","M"}; // 添加的參數
        int row;
        try {
            row = runner.update(sql1, params1);
            // row = runner.update(sql1, 6);
        } catch (SQLException se){
            se.printStackTrace();
        }
       	return row;
   	}
    	
    public int test1(){
        // 创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        // 修改的sql語句
        String sql = "update user set name=?, age=?,sex=? where id=?";
        Object[] params = {"dzl","26","F","1"}; // 修改的參數

        //调用QueryRunner方法update
        
        int row = qr.update(con, sql, params);
        // 判断insert,update,delete执行是否成功 对返回值row判断 if(row>0) 执行成功
        return row;
    }
}

query()方法

1.T query(String sql,ResultSetHandler rsh,Object…params)–>可执行查询

2.T query(Connection conn,String sql,ResultSetHandler rsh,Object…params)–>可执行查询，支持事务

update方法和query方法参数里面有一处不同，里面增加了一个ResultSetHandler接口，作用是为了把从数据库中查询出来的数据转化成对象，有五种实现

1.BeanHandler(单行) -->构造器需要一个Class类型参数，用来把一行结果转换成指定类型的javaBean对象，前提是JavaBean对象里面的参数名称和数据库里面的参数名称要相同

2.BeanListHandler(多行）–>构造器也需要一个Class类型的参数，用来把一行结果集转换成一个javaBean，那么多行就是转换成list.

3.MapHandler(单行)–>把一行结果集转换成Map对象

4.MapListHandler(多行）–>把一行记录转换成一个Map，多行就是多个Map，即List

5.ScalarHandler(单行单列）–>通常用与Select count(*) from table 语句，返回一个Object.

package com.example.stu.controller;

import com.example.stu.po.User;
import com.example.stu.util.JdbcUtil;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;

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

public class Test {
    private static QueryRunner runner = new QueryRunner(JdbcUtil.getDataSource());

    /**
     * 结果集第一种处理方法，ArrayHandler
     * 将结果第一行存储到对象数组中Object[]
     * */
    public static void ArrayHandler(){
        String sql = "select * from user";
        try {
            Object[] result = runner.query(sql, new ArrayHandler());
            for (Object obj : result) {
                System.out.println(obj);
            }

        } catch (SQLException se){
            se.printStackTrace();
        }
    }

    /**
     * 结果集的第二种处理方法，ArrayListHandler
     * 将结果集的每一行，封装到对象数组中，出现很多对象数组
     * 对象数组存储到List集合
     * */
    public static void arrayListHandler(){
        String sql = "select * from user";
        try {
            List<Object[]> result = runner.query(sql, new ArrayListHandler());
            for (Object[] objs : result) {
                for (Object obj : objs) {
                    System.out.print(obj+"\t");
                }
                System.out.println();
            }

        } catch (SQLException se){
            se.printStackTrace();
        }
    }

    /**
     * 结果集的第三种处理方法BeanHandler
     * 将结果集的第一行数据，封装为JavaBean对象
     * 注意：被封装成数据到JavaBean对象，Sort类必须有空参构造
     * */
    public static void beanHandler(){
        String sql = "select * from user";
        try {
            User user = runner.query(sql, new BeanHandler<User>(User.class));
            System.out.println(user);
        } catch (SQLException se){
            se.printStackTrace();
        }
    }

    /**
     * 结果集第四种处理方法，BeanListHandler
     * 将数据结果集的每一行数据，封装为JavaBean对象
     * 多个JavaBean对象封装到List集合中
     * */
    public static void beanListHandler(){
        String sql = "select * from user";
        try {
            List<User> list = runner.query(sql, new BeanListHandler<User>(User.class));
            for (User u : list){
                System.out.println(u);
            }
        } catch (SQLException se){
            se.printStackTrace();
        }
    }

    /**
     * 结果集第五种处理方法，ColumnListHandler
     * 结果集，指定列的数据，存储到List集合中
     * List<Object> 每个列数据类型不同
     * */
    public static void columnListHandler(){
        String sql = "select * from user";
        try {
            List<Object> list = runner.query(sql, new ColumnListHandler<Object>("name"));
            for (Object o : list){
                System.out.println(o);
            }
        } catch (SQLException se){
            se.printStackTrace();
        }
    }

    /**
     * 结果集第六种处理方法、
     * 对于查询后，只有一个结果
     * */
    public static void scalarHandler(){
        String sql = "select * from user";
        try {
            long count = runner.query(sql, new ScalarHandler<Long>());
            System.out.println(count);
        } catch (SQLException se){
            se.printStackTrace();
        }
    }

    /**
     * 结果集的第七种处理方式，MapHandler
     * 将结果集第一行数据，封装到Map集合中
     * Map<键，值> 键：列名 值：这列数据
     * */
    public static void mapHandler(){
        String sql = "select * from user";
        try {
            Map<String,Object> map = runner.query(sql, new MapHandler());
            for (String key: map.keySet()){
                System.out.println(key + "--------->" + map.get(key));
            }
        } catch (SQLException se){
            se.printStackTrace();
        }
    }

    /**
     * 结果集第八种处理方法，MapListHandler
     * 将结果集每一行存储到Map集合，键：列名 值：数据
     * Map集合过多，存储到List集合
     * */
    public static void mapListHandler(){
        String sql = "select * from user";
        try {
            List<Map<String, Object>> list = runner.query(sql, new MapListHandler());
            for (Map<String, Object> map: list){
                for (String key: map.keySet()){
                    System.out.print(key + " ------->" + map.get(key));
                }
                System.out.println();
            }
        } catch (SQLException se){
            se.printStackTrace();
        }
    }
}

附上 JdbcUtil 文件

package com.example.stu.util;

import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;

public class JdbcUtil {
    private static DataSource dataSource = null;

    static{
        if(dataSource == null){
            dataSource = new ComboPooledDataSource();
        }
    }
    public static DataSource getDataSource(){
        return dataSource;
    }

    public static void initDataSource(){
        if(dataSource == null){
            dataSource = new ComboPooledDataSource();
        }
    }
}

以上例子没有实测，如若发现问题，还请记得留言评论。（没错，就是来骗评论的）