第19天(就业班) BeanUtils组件用法及类型转换器、DbUtils组件、jdbc优化

一、  BeanUtils组件用法及类型转换器

使用BenUtils组件：

1. 引入commons-beanutils-1.8.3.jar核心包

2. 引入日志支持包: commons-logging-1.1.3.jar

如果缺少日志jar文件，报错：

java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory
at org.apache.commons.beanutils.ConvertUtilsBean.<init>(ConvertUtilsBean.java:157)
at org.apache.commons.beanutils.BeanUtilsBean.<init>(BeanUtilsBean.java:117)
at org.apache.commons.beanutils.BeanUtilsBean$1.initialValue(BeanUtilsBean.java:68)
at
package com.xp.tools;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.Converter;
import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;
import org.junit.Test;

public class App {
//1. 对javabean的基本操作
@Test
public void test1() throws Exception {
// a. 基本操作
Admin admin = new Admin();
// admin.setUserName("Jack");
// admin.setPwd("999");
// b. BeanUtils组件实现对象属性的拷贝
BeanUtils.copyProperty(admin, "userName", "jack");
BeanUtils.setProperty(admin, "age", 18);
// 总结1： 对于基本数据类型，会自动进行类型转换!
// c. 对象的拷贝
Admin newAdmin = new Admin();
BeanUtils.copyProperties(newAdmin, admin);
// d. map数据，拷贝到对象中
Admin adminMap = new Admin();
Map<String,Object> map = new HashMap<String,Object>();
map.put("userName", "Jerry");
map.put("age", 29);
// 注意：map中的key要与javabean的属性名称一致
BeanUtils.populate(adminMap, map);

// 测试
System.out.println(adminMap.getUserName());
System.out.println(adminMap.getAge());
}
//2. 自定义日期类型转换器
@Test
public void test2() throws Exception {
// 模拟表单数据
String name = "jack";
String age = "20";
String birth = " ";
// 对象
Admin admin = new Admin();
// 注册日期类型转换器：1， 自定义的方式
ConvertUtils.register(new Converter() {
// 转换的内部实现方法，需要重写
@Override
public Object convert(Class type, Object value) {
// 判断
if (type != Date.class) {
return null;
}
if (value == null || "".equals(value.toString().trim())) {
return null;
}
try {
// 字符串转换为日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
return sdf.parse(value.toString());
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
},Date.class);
// 把表单提交的数据，封装到对象中
BeanUtils.copyProperty(admin, "userName", name);
BeanUtils.copyProperty(admin, "age", age);
BeanUtils.copyProperty(admin, "birth", birth);
//------ 测试------
System.out.println(admin);
}
//2. 使用提供的日期类型转换器工具类
@Test
public void test3() throws Exception {
// 模拟表单数据
String name = "userName";
String age = "20";
String birth = null;
// 对象
Admin admin = new Admin();
// 注册日期类型转换器：2， 使用组件提供的转换器工具类
ConvertUtils.register(new DateLocaleConverter(), Date.class);
// 把表单提交的数据，封装到对象中
BeanUtils.copyProperty(admin, "userName", name);
BeanUtils.copyProperty(admin, "age", age);
BeanUtils.copyProperty(admin, "birth", birth);
//------ 测试------
System.out.println(admin);
}
}

二、  BeanUtils在项目中应用

public class WebUtils {

@Deprecated
public static <T> T copyToBean_old(HttpServletRequest request, Class<T> clazz) {
try {
// 创建对象
T t = clazz.newInstance();

// 获取所有的表单元素的名称
Enumeration<String> enums = request.getParameterNames();
// 遍历
while (enums.hasMoreElements()) {
// 获取表单元素的名称:<input type="password" name="pwd"/>
String name = enums.nextElement(); // pwd
// 获取名称对应的值
String value = request.getParameter(name);
// 把指定属性名称对应的值进行拷贝
BeanUtils.copyProperty(t, name, value);
}

return t;
} catch (Exception e) {
throw new RuntimeException(e);
}
}

/**
* 处理请求数据的封装
*/
public static <T> T copyToBean(HttpServletRequest request, Class<T> clazz) {
try {
// （注册日期类型转换器）
// 创建对象
T t = clazz.newInstance();
BeanUtils.populate(t, request.getParameterMap());
return t;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}三、 更新通用方法

元数据

元数据－ DataBaseMetaData

 元数据：数据库、表、列的定义信息。

 Connection.getDatabaseMetaData()

 DataBaseMetaData对象

• getURL()：返回一个String类对象，代表数据库的URL。

• getUserName()：返回连接当前数据库管理系统的用户名。

• getDatabaseProductName()：返回数据库的产品名称。

• getDatabaseProductVersion()：返回数据库的版本号。

• getDriverName()：返回驱动驱动程序的名称。

• getDriverVersion()：返回驱动程序的版本号。

• isReadOnly()：返回一个boolean值，指示数据库是否只允许读操作。

元数据－ ParameterMetaData

 PreparedStatement . getParameterMetaData() 

• 获得代表PreparedStatement元数据的ParameterMetaData对象。 

• Select * from user where name=? And password=?

 ParameterMetaData对象

• getParameterCount() 

• 获得指定参数的个数

• getParameterType(int param) 

• 获得指定参数的sql类型

元数据－ ResultSetMetaData

 ResultSet. getMetaData() 

• 获得代表ResultSet对象元数据的ResultSetMetaData对象。 

 ResultSetMetaData对象

• getColumnCount() 

• 返回resultset对象的列数

• getColumnName(int column) 

• 获得指定列的名称

• getColumnTypeName(int column)

• 获得指定列的类型 

使用元数据简化JDBC代码

 业务背景：系统中所有实体对象都涉及到基本的CRUD操作：

• 所有实体的CUD操作代码基本相同，仅仅发送给数据库的SQL语句不同而已，因此可以把CUD操作的所有相同代码抽取到工具类的一个update方法中，并定义参数接收变化的SQL语句。

实体的R操作，除SQL语句不同之外，根据操作的实体不同，对ResultSet的映射也各不相同，因此可义一个query方法，除以参数形式接收变化的SQL语句外，可以使用策略模式由qurey方法的调用者决定如何把ResultSet中的数据映射到实体对象中
package com.xp.metadata;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import org.junit.Test;
import com.xp.utils.JdbcUtil;

public class App {
//1. 数据库元数据
@Test
public void testDB() throws Exception {
// 获取连接
Connection conn = JdbcUtil.getConnection();
// 获取数据库元数据
DatabaseMetaData metaData = conn.getMetaData();// alt + shift + L 快速获取方法返回值

System.out.println(metaData.getUserName());
System.out.println(metaData.getURL());
System.out.println(metaData.getDatabaseProductName());
}
//2. 参数元数据
@Test
public void testParams() throws Exception {
// 获取连接
Connection conn = JdbcUtil.getConnection();
// SQL
String sql = "select * from dept where deptid=? and deptName=?";
// Object[] values = {"tom","888"};

PreparedStatement pstmt = conn.prepareStatement(sql);
// 参数元数据
ParameterMetaData p_metaDate = pstmt.getParameterMetaData();
// 获取参数的个数
int count = p_metaDate.getParameterCount();
// 测试
System.out.println(count);
}
// 3. 结果集元数据
@Test
public void testRs() throws Exception {
String sql = "select * from dept ";
// 获取连接
Connection conn = JdbcUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql);
ResultSet rs = pstmt.executeQuery();
// 得到结果集元数据(目标：通过结果集元数据，得到列的名称)
ResultSetMetaData rs_metaData = rs.getMetaData();
// 迭代每一行结果
while (rs.next()) {
// 1. 获取列的个数
int count = rs_metaData.getColumnCount();
// 2. 遍历，获取每一列的列的名称
for (int i=0; i<count; i++) {
// 得到列的名称
String columnName = rs_metaData.getColumnName(i + 1);
// 获取每一行的每一列的值
Object columnValue = rs.getObject(columnName);
// 测试
System.out.print(columnName + "=" + columnValue + ",");
}
System.out.println();
}
}
}Dao操作的抽取

Dao操作通用的步骤：

0. 写SQL语句

1. 获取连接

2. 创建stmt

3. 执行sql

a) 更新

b) 查询

4. 关闭/异常

通过的dao,

1. 更新

String sql = “select * from admin”;

String sql = “select * from admin  where  id=?  And pwd =?”;

public void update(String sql, Object[]  paramValues);

2. 查询

String sql = “select * from admin”;

String sql = “select * from admin  where  id=?  And pwd =?”;

// 传入的什么类型的对象，就封装为什么类型

// 要求： 列的名称，要与指定类型的对象的属性名称一样

Public    List<T>    query  (String sql , Object[] paramValues ,  Class<T> clazz);

T  t;  // 对象赋值
package com.xp.jdbc;

public class Admin {
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
private String userName;
private String pwd;
}
@Override
public String toString() {
return "Admin [id=" + id + ", userName=" + userName + ", pwd=" + pwd
+ "]";
}四、 查询的通用方法
package com.xp.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.beanutils.BeanUtils;

import com.xp.utils.JdbcUtil;

public class BaseDao {
// 初始化参数
private Connection con;
private PreparedStatement pstmt;
private ResultSet rs;

/**
* 更新的通用方法
* @param sql 更新的sql语句(update/insert/delete)
* @param paramsValue sql语句中占位符对应的值(如果没有占位符，传入null)
*/
public void update(String sql,Object[] paramsValue){

try {
// 获取连接
con = JdbcUtil.getConnection();
// 创建执行命令的stmt对象
pstmt = con.prepareStatement(sql);
// 参数元数据： 得到占位符参数的个数
int count = pstmt.getParameterMetaData().getParameterCount();

// 设置占位符参数的值
if (paramsValue != null && paramsValue.length > 0) {
// 循环给参数赋值
for(int i=0;i<count;i++) {
pstmt.setObject(i+1, paramsValue[i]);
}
}
// 执行更新
pstmt.executeUpdate();

} catch (Exception e) {
throw new RuntimeException(e);
} finally {
JdbcUtil.closeAll(con, pstmt, null);
}
}

/**
* 查询的通用方法
* @param sql
* @param paramsValue
*/
public <T> List<T> query(String sql, Object[] paramsValue,Class<T> clazz){

try {
// 返回的集合
List<T> list = new ArrayList<T>();
// 对象
T t = null;

// 1. 获取连接
con = JdbcUtil.getConnection();
// 2. 创建stmt对象
pstmt = con.prepareStatement(sql);
// 3. 获取占位符参数的个数， 并设置每个参数的值
//int count = pstmt.getParameterMetaData().getParameterCount();
if (paramsValue != null && paramsValue.length > 0) {
for (int i=0; i<paramsValue.length; i++) {
pstmt.setObject(i+1, paramsValue[i]);
}
}
// 4. 执行查询
rs = pstmt.executeQuery();
// 5. 获取结果集元数据
ResultSetMetaData rsmd = rs.getMetaData();
// ---> 获取列的个数
int columnCount = rsmd.getColumnCount();

// 6. 遍历rs
while (rs.next()) {
// 要封装的对象
t = clazz.newInstance();

// 7. 遍历每一行的每一列, 封装数据
for (int i=0; i<columnCount; i++) {
// 获取每一列的列名称
String columnName = rsmd.getColumnName(i + 1);
// 获取每一列的列名称, 对应的值
Object value = rs.getObject(columnName);
// 封装： 设置到t对象的属性中 【BeanUtils组件】
BeanUtils.copyProperty(t, columnName, value);
}

// 把封装完毕的对象，添加到list集合中
list.add(t);
}
return list;
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
JdbcUtil.closeAll(con, pstmt, rs);
}
}
}
package com.xp.jdbc;
import java.util.List;
public class AdminDao extends BaseDao{
// 删除
public void delete(int id) {
String sql = "delete from admin where id=?";
Object[] paramsValue = {id};
super.update(sql, paramsValue);
}
// 插入
public void save(Admin admin) {
String sql = "insert into admin (userName,pwd) values (?,?)";
Object[] paramsValue = {admin.getUserName(),admin.getPwd()};
super.update(sql, paramsValue);
}
// 查询全部
public List<Admin> getAll(){
String sql = "select * from admin";
List<Admin> list = super.query(sql, null, Admin.class);
return list;
}
// 根据条件查询(主键)
public Admin findById(int id){
String sql = "select * from admin where id=?";
List<Admin> list = super.query(sql, new Object[]{id}, Admin.class);
return (list!=null&&list.size()>0) ? list.get(0) : null;
}
}
package com.xp.jdbc;

import java.util.List;

import org.junit.Test;
public class AdminDaoTest {
@Test
public void testUpdate() throws Exception {
AdminDao adminDao = new AdminDao();
//adminDao.delete(2);
//adminDao.save(new Admin());
// 测试查询
List<Admin> list = adminDao.getAll();
System.out.println(list);
}
}五、 DbUtils组件

O-R Mapping简介

 常用O-R Mapping映射工具

• Hibernate

• Ibatis

• Commons DbUtils(只是对JDBC简单封装)

DbUtils组件

 commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。因此dbutils成为很多不喜欢hibernate的公司的首选。

 API介绍：

• org.apache.commons.dbutils.QueryRunner 

• org.apache.commons.dbutils.ResultSetHandler

• 工具类

 org.apache.commons.dbutils.DbUtils  

 下载组件，引入jar文件 : commons-dbutils-1.6.jar

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 commitAndCloseQuietly(Connection conn)： 用来提交连接，然后关闭连接，并且在关闭连接时不抛出SQL异常。 

• public static boolean loadDriver(java.lang.String driverClassName)：这一方装载并注册JDBC驱动程序，如果成功就返回true。使用该方法，你不需要捕捉这个异常ClassNotFoundException。

DButil实例

|-- DbUtils   关闭资源、加载驱动

|-- QueryRunner   组件的核心工具类：定义了所有的与数据库操作的方法(查询、更新)
该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。

QueryRunner类提供了两个构造方法：

默认的构造方法

需要一个 javax.sql.DataSource 来作参数的构造方法。
Int  update(Connection conn, String sql, Object param);   执行更新带一个占位符的sql

Int  update(Connection conn, String sql, Object…  param); 执行更新带多个占位符的sql

Int[]  batch(Connection conn, String sql, Object[][] params)        批处理

T  query(Connection conn ,String sql, ResultSetHandler<T> rsh, Object... params)   查询方法

Int  update( String sql, Object param);  

Int  update( String sql, Object…  param); 

Int[]  batch( String sql, Object[][] params)       

注意： 如果调用DbUtils组件的操作数据库方法，没有传入连接对象，那么在实例化QueryRunner对象的时候需要传入数据源对象： QueryRunner qr = new QueryRunner(ds);

DbUtils提供的封装结果的一些对象：

1） BeanHandler: 查询返回单个对象

2） BeanListHandler: 查询返回list集合，集合元素是指定的对象

3)  ArrayHandler, 查询返回结果记录的第一行，封装对对象数组, 即返回：Object[]
4)  ArrayListHandler, 把查询的每一行都封装为对象数组，再添加到list集合中
5)  ScalarHandler 查询返回结果记录的第一行的第一列  (在聚合函数统计的时候用)
6)  MapHandler  查询返回结果的第一条记录封装为map
package com.xp.dbutils;

import org.junit.Test;

public class Demo {
public void sum(int... num) {

int total = 0;
for (int i=0;i <num.length;i++) {
total += num[i];
}
System.out.println("和： " + total);
}

@Test
public void test() {
int[] n = {1,2,3};
//sum(n);
sum(1,2,5,5);
}
}
package com.xp.dbutils;
import java.sql.Connection;

import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.junit.Test;
import com.xp.utils.JdbcUtil;
public class App_update {
private Connection conn;
// 1. 更新
@Test
public void testUpdate() throws Exception {
String sql = "delete from admin where id=?";
// 连接对象
conn = JdbcUtil.getConnection();

// 创建DbUtils核心工具类对象
QueryRunner qr = new QueryRunner();
qr.update(conn, sql, 26);

// 关闭
DbUtils.close(conn);
}
// 2. 批处理
@Test
public void testBatch() throws Exception {
String sql = "insert into admin (userName, pwd) values(?,?)";
conn = JdbcUtil.getConnection();
QueryRunner qr = new QueryRunner();
// 批量删除
qr.batch(conn, sql, new Object[][]{ {"jack1","888"},{"jack2","999"} });

// 关闭
conn.close();
}
}QueryRunner类的主要方法

 public Object query(Connection conn, String sql, Object[] params, ResultSetHandler rsh) throws SQLException：执行一个查询操作，在这个查询中，对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理 PreparedStatement 和 ResultSet 的创建和关闭。

 public Object query(String sql, Object[] params, ResultSetHandler rsh) throws SQLException:　几乎与第一种方法一样；唯一的不同在于它不将数据库连接提供给方法，并且它是从提供给构造方法的数据源(DataSource) 或使用的setDataSource 方法中重新获得 Connection。

 public Object query(Connection conn, String sql, ResultSetHandler rsh) throws SQLException : 执行一个不需要置换参数的查询操作。

 public int update(Connection conn, String sql, Object[] params) throws SQLException:用来执行一个更新（插入、更新或删除）操作。

 public int update(Connection conn, String sql) throws SQLException：用来执行一个不需要置换参数的更新操作。

六、 DbUtis组件查询结果对象用法

ResultSetHandler接口

 该接口用于处理 java.sql.ResultSet，将数据按要求转换为另一种形式。

 ResultSetHandler 接口提供了一个单独的方法：Object handle (java.sql.ResultSet .rs)。

ResultSetHandler 接口的实现类

 ArrayHandler：把结果集中的第一行数据转成对象数组。

 ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。

 BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。

 BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。

 ColumnListHandler(列名)：将结果集中某一列的数据存放到List中。

 KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。

 MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。

 MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List

使用jdbc操作多个表
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.junit.Test;

import cn.itcast.c_jdbc.Admin;
import cn.itcast.utils.JdbcUtil;

public class App_query {

private Connection conn;

// 一、查询， 自定义结果集封装数据
@Test
public void testQuery() throws Exception {
String sql = "select * from admin where id=?";
// 获取连接
conn = JdbcUtil.getConnection();
// 创建DbUtils核心工具类对象
QueryRunner qr = new QueryRunner();
// 查询
Admin admin = qr.query(conn, sql, new ResultSetHandler<Admin>() {

// 如何封装一个Admin对象
public Admin handle(ResultSet rs) throws SQLException {
if (rs.next()) {
Admin admin = new Admin();
admin.setId(rs.getInt("id"));
admin.setUserName(rs.getString("userName"));
admin.setPwd(rs.getString("pwd"));
return admin;
}
return null;
}

}, 29);

// 测试
System.out.println(admin);
// 关闭
conn.close();

}

// 二、查询， 使用组件提供的结果集对象封装数据

// 1）BeanHandler: 查询返回单个对象
@Test
public void testQueryOne() throws Exception {
String sql = "select * from admin where id=?";
// 获取连接
conn = JdbcUtil.getConnection();
// 创建DbUtils核心工具类对象
QueryRunner qr = new QueryRunner();
// 查询返回单个对象
Admin admin = qr.query(conn, sql, new BeanHandler<Admin>(Admin.class), 29);

System.out.println(admin);
conn.close();
}

// 2）BeanListHandler: 查询返回list集合，集合元素是指定的对象
@Test
public void testQueryMany() throws Exception {
String sql = "select * from admin";
conn = JdbcUtil.getConnection();
QueryRunner qr = new QueryRunner();
// 查询全部数据
List<Admin> list = qr.query(conn, sql, new BeanListHandler<Admin>(Admin.class));

System.out.println(list);
conn.close();
}
@Test
// 3) ArrayHandler, 查询返回结果记录的第一行，封装对对象数组, 即返回：Object[]
// 4) ArrayListHandler, 把查询的每一行都封装为对象数组，再添加到list集合中
// 5) ScalarHandler 查询返回结果记录的第一行的第一列 (在聚合函数统计的时候用)
// 6) MapHandler 查询返回结果的第一条记录封装为map
public void testArray() throws Exception {
String sql = "select * from admin";
conn = JdbcUtil.getConnection();
QueryRunner qr = new QueryRunner();
// 查询
//Object[] obj = qr.query(conn, sql, new ArrayHandler());
//List<Object[]> list = qr.query(conn, sql, new ArrayListHandler());
//Long num = qr.query(conn, sql, new ScalarHandler<Long>());
Map<String, Object> map = qr.query(conn,sql, new MapHandler());

conn.close();
}
}