RowProcessor的实现子类:BasicRowProcessor
- /**
- * RowProcessor接口的实现类
- */
- public class BasicRowProcessor implements RowProcessor {
- /**
- * 默认转换器
- * 如果没有指定,则使用这个进行resultSet的转换
- */
- private static final BeanProcessor defaultConvert = new BeanProcessor();
- private static final BasicRowProcessor instance = new BasicRowProcessor();
- /**
- * 返回BasicRowProcessor的单实例
- * 过期方法,建议使用构造器创建对象,这个方法将在DbUtils 1.1中去掉
- * @return 这个类的单实例.
- * @deprecated
- */
- public static BasicRowProcessor instance() {
- return instance;
- }
- /**
- * 使用这个实例来进行bean的转换
- */
- private final BeanProcessor convert;
- /**
- * BasicRowProcessor构造器.
- * 默认使用BeanProcessor转换
- */
- public BasicRowProcessor() {
- this(defaultConvert);
- }
- /**
- * BasicRowProcessor构造器.
- * @param convert 当需要将表属性名转换为bean属性时要使用的BeanProcessor实例
- * @since DbUtils 1.1
- */
- public BasicRowProcessor(BeanProcessor convert) {
- super();
- this.convert = convert;
- }
- /**
- * 将ResultSet的一行转换为一个Object[]数组
- * 这个实现将ResultSet中的数据顺序的存入数组.
- * 如果列值为NULL,则数组元素设置为null.
- */
- public Object[] toArray(ResultSet rs) throws SQLException {
- ResultSetMetaData meta = rs.getMetaData();//获取ResultSet的MetaData对象
- int cols = meta.getColumnCount();//获取列数
- Object[] result = new Object[cols];
- for (int i = 0; i < cols; i++) {
- result[i] = rs.getObject(i + 1);//获取每列对应的值,并赋给新数组
- }
- return result;
- }
- /**
- * 将ResultSet的指定行转换为一JavaBean.
- * 这个实现代理需要一个BeanProcessor实例.
- * 具体的可参见:BeanProcessor的toBean(java.sql.ResultSet, java.lang.Class)方法
- */
- public <T> T toBean(ResultSet rs, Class<T> type) throws SQLException {
- return this.convert.toBean(rs, type);
- }
- /**
- * 将ResultSet的指定行转换为一JavaBean集合.
- * 该方法同样需要一个BeanProcessor实例
- * 具体的可参见:BeanProcessor的toBeanList(java.sql.ResultSet, java.lang.Class)方法
- */
- public <T> List<T> toBeanList(ResultSet rs, Class<T> type) throws SQLException {
- return this.convert.toBeanList(rs, type);
- }
- /**
- * 将指定的ResultSet行转换为一个Map
- * 这个实现返回一个以大小写无关的列名为键值的Map集合
- * 例如:调用map.get("COL")或者map.get("col")返回相同的值.
- */
- public Map<String, Object> toMap(ResultSet rs) throws SQLException {
- Map<String, Object> result = new CaseInsensitiveHashMap();//创建一个自定义的大小写无关的Map实例
- ResultSetMetaData rsmd = rs.getMetaData();
- int cols = rsmd.getColumnCount();
- for (int i = 1; i <= cols; i++) {
- result.put(rsmd.getColumnName(i), rs.getObject(i));//这一用法就是将列名为键值
- }
- return result;
- }
- }
BasicRowProcessor这个类实现了RowProcessor接口的ResultSet转换为其它对象的方法,现对这个类的几点具体说明如下:
1)
- public Object[] toArray(ResultSet rs) throws SQLException
这个方法也实在是没啥好说的,一切尽在掌握,很直白,就是利用ResultSet的MetaData对象来对当前行进行数据的处理操作,最后存入一数组对象,所以,略过!
2)
- public <T> T toBean(ResultSet rs, Class<T> type) throws SQLException {
- return this.convert.toBean(rs, type);
- }
- public <T> List<T> toBeanList(ResultSet rs, Class<T> type) throws SQLException {
- return this.convert.toBeanList(rs, type);
- }
这两个方法之所以会要一起列出来,主要是出于以下几个原因的考虑,一点是,它们都需要一个BeanProcessor实例来对ResultSet进行处理;另一点则是,我不想把对这两个的分析放在这里,而是想考虑放到下一节:BeanProcessor的分析(对BeanProcessor的分析也会碰到一新东西,那就是Java的内省Introspector,挺有意思的一知识点,你,值得期待)。实际上呢,我们通过对BasicRowProcessor的分析,我们也可以知道,它默认是采用这个BeanProcessor来处理ResultSet的。
3)
- public Map<String, Object> toMap(ResultSet rs) throws SQLException
根据这个方法的注释说明,它根据列名获取值,是大小写无关的,实际上一般的Map不可能做到这一点,因为Java是个区分大小写的语言,所以,它肯定对Map进行了封装。实际上呢,这个类里面有个静态的内部类CaseInsensitiveHashMap,真正的奥秘就在这里!这里我把它移出来了,现对此Map的分析如下:
- /**
- * 为了不区分大小写查找而将所有的key转换为小写字符串的Map.
- * 这个HashMap的实现不允许键值为null,因为我们要将所有的键值变为小写,
- * 即调用key.toString().toLowerCase().
- */
- private static class CaseInsensitiveHashMap extends HashMap<String, Object> {
- /**
- * 以小写字母为键值的内部Map集合
- * 所有的查询操作步骤操作经过以下三步:
- * 1)、将参数Key转换为小写
- * 2)、获取小写Key获取真实Key
- * 3)、通过真实的Key值获取到值
- */
- private final Map<String,String> lowerCaseMap = new HashMap<String,String>();
- /**
- * Required for serialization support.
- *
- * @see java.io.Serializable
- */
- private static final long serialVersionUID = -2848100435296897392L;
- @Override
- public boolean containsKey(Object key) {
- Object realKey = lowerCaseMap.get(key.toString().toLowerCase());
- return super.containsKey(realKey);
- // Possible optimisation here:
- // Since the lowerCaseMap contains a mapping for all the keys,
- // we could just do this:
- // return lowerCaseMap.containsKey(key.toString().toLowerCase());
- }
- @Override
- public Object get(Object key) {
- Object realKey = lowerCaseMap.get(key.toString().toLowerCase());//获取真正的Key值,然后回去值
- return super.get(realKey);
- }
- @Override
- public Object put(String key, Object value) {
- /*
- * In order to keep the map and lowerCaseMap synchronized,
- * we have to remove the old mapping before putting the
- * new one. Indeed, oldKey and key are not necessaliry equals.
- * (That's why we call super.remove(oldKey) and not just
- * super.put(key, value))
- */
- Object oldKey = lowerCaseMap.put(key.toLowerCase(), key);//返回之前存在的值,实际上对应的Key
- Object oldValue = super.remove(oldKey);
- super.put(key, value);
- return oldValue;//返回之前的值
- }
- @Override
- public void putAll(Map<? extends String,?> m) {
- for (Map.Entry<? extends String, ?> entry : m.entrySet()) {
- String key = entry.getKey();
- Object value = entry.getValue();
- this.put(key, value);
- }
- }
- @Override
- public Object remove(Object key) {
- Object realKey = lowerCaseMap.remove(key.toString().toLowerCase());//返回该键对应的值
- //实际上我们可以理解为拿到真正的Key值,然后删除对应的值
- return super.remove(realKey);
- }
- }
很一目了然了已经,通过成员变量lowerCaseMap来达到大小写通吃的目的,这个lowerCaseMap,Key值为小写化的列名,Value值才对应真实列名(即未做最小化处理的列名)。所以说,每次在以列名获取值时,先对其进行最小化,再通过lowerCaseMap获取对应的真实列名,然后再获取到值,这样就达到了一个不区分大小写的效果。OK,这个Map转换总算整明白了。这样呢,我们对这个BasicRowProcessor类的解读也算是圆满完成了。