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

2/10/2017来源:ASP.NET技巧人气:571

一、  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();
	}
}