在没有用框架的阶段，为什么要使用DBUtils工具类呢？，因为方便啊，用原生JDBC过于痛苦什么事情都要自己干，碎玉我这个暴躁的人来说完全不能忍受啊。DBUtils会自己给你封装的，多好，在没用框架的阶段用这个相对而言，可以轻松一点，用框架的闭嘴，
1. 工具类 QueryRunner (模板类)
QueryRunner qr=new QueryRunner();
2. 方法
update(Connection conn,String sql,Object...params) 增删改
conn: 数据库连接
sql: 预编译sql语句
params: 占位符的值
query(Connection conn,String sql,ResultSetHandler rs,Object...params) 查询//ResultSetHandler接口
conn: 数据库连接
sql: 预编译sql语句
rs: 结果集处理器
params: 占位符的值
对于数据库的操作无非增删改，查。其中增删改为一类，查为另一类，为什么这么分，看返回的数据就知道了，增删改返回的是执行的行数，而查的返回的结果有三种1.一个数据 2.一条数据 3.多条数据。针对这两类类型，采取不同的方法，
update方法：
@Test
public void update(){
QueryRunner qr=new QueryRunner();
Connection conn=JDBCUtils.getConn();
String sql="insert into user values(null,?,?)";
try {
int m = qr.update(conn, sql, "桐人","qwerty");
System.out.println(m);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Test
public void update1(){
QueryRunner qr=new QueryRunner();
Connection conn=JDBCUtils.getConn();
String sql="update user set name=? where id =?";
try {
int m = qr.update(conn, sql, "桐人1","4");
System.out.println(m);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}query（）方法：
@Test
public void query(){//一个对象的
QueryRunner qr =new QueryRunner();
Connection conn=JDBCUtils.getConn();
String sql="select * from user where id =?";
BeanHandler<User> bean=new BeanHandler<>(User.class);//定义是单个的类类型的
try {
User query = qr.query(conn, sql, bean, 2);
System.out.println(query);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Test
public void query1(){//多个对象
QueryRunner qr=new QueryRunner();
Connection conn=JDBCUtils.getConn();
String sql="select * from user";
BeanListHandler<User> blh=new BeanListHandler<>(User.class);//结果集接收器，定义是list类型的
try {
List<User> query = qr.query(conn, sql, blh);
query.stream().forEach(System.out::println);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Test
public void query2(){//一条数据
QueryRunner qr=new QueryRunner();
Connection conn=JDBCUtils.getConn();
String sql="select count(*) from user";
ScalarHandler<Long> sc=new ScalarHandler<>(); //数量接收器
try {
Long m = qr.query(conn, sql, sc);
System.out.println(m);
//query.stream().forEach(System.out::println);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}针对查询返回的结果定义了三种不同结果集类型。这里不得不说这个
query(Connection conn,String sql,ResultSetHandler rs,Object...params)方法，里面的ResultSetHandler是一个接口，BeanHandler，BeanListHandler，ScalarHandler分别对应，接收一行数据，多行数据，一个数据。<>是指定结果集是什么类型的数据。
处理多条数据的
BeanListHandler<T> blh=new BeanListHandler<>(Class type);
泛型：设置query方法的返回值集合的泛型 List<Score>
List<Score> list = qr.query(conn, sql, blh);
构造器参数： Class type
完成结果集的自动装配 (结果集的列名和对象的属性名一致)
处理一条数据的
BeanHandler<Score> bean=new BeanHandler<>(Score.class);
泛型： 直接设置query方法的返回值类型
构造器参数： 完成结果集的自动装配
. 处理一个数据的
ScalarHandler<String> sh=new ScalarHandler<>();
泛型：设置query方法的返回值类型
模板DAO：
使用模板dao可以省去每一个**Dao.java的公共的语句，你只需要传递sql语句，参数，和查询时的类对象
PS：我用的数据库连接池，所以关闭conn在方法里面，这里的关闭不是真正的关闭，是将该连接对象，重置后放回连接池中去。
package com.thekingqj.day02;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
public class BaseDao<T> {
public boolean update(String sql,Object...params){
Connection conn=JDBCUtils.getConn();
QueryRunner qr=new QueryRunner();
int m=0;
try {
m= qr.update(conn, sql, params);
} catch (SQLException e) {
e.printStackTrace();
}finally{
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(m>0)return true;
else return false;
}
public List<T> getBeanList(String sql,Class<T> type,Object...params){
Connection conn=JDBCUtils.getConn();
QueryRunner qr=new QueryRunner();
BeanListHandler<T> blh=new BeanListHandler<>(type);
try {
List<T> query = qr.query(conn, sql, blh, params);
return query;
} catch (SQLException e) {
e.printStackTrace();
}finally{
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return null;
}
public T getBean(String sql,Class<T> type,Object...params){
Connection conn=JDBCUtils.getConn();
QueryRunner qr=new QueryRunner();
BeanHandler<T> bh=new BeanHandler<>(type);
try {
T query = qr.query(conn, sql, bh, params);
return query;
} catch (SQLException e) {
e.printStackTrace();
}finally{
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return null;
}
public Object getOnly(String sql,Object...params){
Connection conn=JDBCUtils.getConn();
QueryRunner qr=new QueryRunner();
ScalarHandler<Object>sh=new ScalarHandler<>();
try {
Object query = qr.query(conn, sql, sh, params);
return query;
} catch (SQLException e) {
e.printStackTrace();
}finally{
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return null;
}
}
新版BaseDao：
package com.thekingqj.dao;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import com.thekingqj.util.JDBCUtils;
/**
* 定义一个用来被继承的对数据库进行基本操作的Dao
*
* @author saber
*
* @param <T>
*/
public class BaseDao<T> {
private QueryRunner queryRunner = new QueryRunner();
// 定义一个变量来接收泛型的类型
private Class<T> type;
// 获取T的Class对象，获取泛型的类型，泛型是在被子类继承时才确定
@SuppressWarnings("unchecked")
public BaseDao() {
// 获取子类的类型
Class clazz = this.getClass();//这个this是继承BaseDao的实现类对象
// 获取父类的类型
// getGenericSuperclass()用来获取当前类的父类的类型
// ParameterizedType表示的是带泛型的类型
ParameterizedType parameterizedType = (ParameterizedType) clazz.getGenericSuperclass();
// 获取具体的泛型类型 getActualTypeArguments获取具体的泛型的类型
// 这个方法会返回一个Type的数组
Type[] types = parameterizedType.getActualTypeArguments();
// 获取具体的泛型的类型·
this.type = (Class<T>) types[0];
}
/**
* 通用的增删改操作
*
* @param sql
* @param params
* @return
*/
public int update(String sql, Object... params) {
// 获取连接
Connection connection = JDBCUtils.getConnection();
int count = 0;
try {
count = queryRunner.update(connection, sql, params);
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.releaseConnection(connection);
}
return count;
}
/**
* 获取一个对象
*
* @param sql
* @param params
* @return
*/
public T getBean(String sql, Object... params) {
// 获取连接
Connection connection = JDBCUtils.getConnection();
T t = null;
try {
t = queryRunner.query(connection, sql, new BeanHandler<T>(type), params);
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.releaseConnection(connection);
}
return t;
}
/**
* 获取所有对象
*
* @param sql
* @param params
* @return
*/
public List<T> getBeanList(String sql, Object... params) {
// 获取连接
Connection connection = JDBCUtils.getConnection();
List<T> list = null;
try {
list = queryRunner.query(connection, sql, new BeanListHandler<T>(type), params);
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.releaseConnection(connection);
}
return list;
}
}
扫一扫
1170
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
