【Spring】利用spring的JdbcTemplate查询返回结果映射到自定义类型

// org.springframework.jdbc.core.JdbcTemplate 中的查询方法基本都有支持参数RowMapper<T> rowMapper的重载方法。下面只是随便举例2个，还有很多

public <T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper) throws DataAccessException {
    ...
};


public <T> T queryForObject(String sql, Object[] args, RowMapper<T> rowMapper) throws DataAccessException {
    ...
};

//demo01
List<Person> person = jdbcTemplate.query(sql, new RowMapper<Person>() {    
    @Override    
    public Person mapRow(ResultSet rs, int i) throws SQLException {        
        Person p = new Person(); //特别需要new，不然如果结果集是list就只有1个对象        
         p.setId(rs.getString("id"));        
        return p;    
    }});

//特别 如果如demo写，很麻烦要set很多。此时spring提供了一个RowMapper的实现类BeanPropertyRowMapper
//demo02
List<Person> person =  jdbcTemplate.query(sql, new BeanPropertyRowMapper(Person.class));

// BeanPropertyRowMapper的成员变量

/** Logger available to subclasses */
protected final Log logger = LogFactory.getLog(getClass());

/** The class we are mapping to ;要映射的class*/
private Class<T> mappedClass;

/** Whether we‘re strictly validating; 是否严格映射bean和sql结果 */
private boolean checkFullyPopulated = false;

/** Whether we‘re defaulting primitives when mapping a null value */
private boolean primitivesDefaultedForNullValue = false;

/** Map of the fields we provide mapping for;映射字段的set方法 */
private Map<String, PropertyDescriptor> mappedFields;

/** Set of bean properties we provide mapping for ;需要映射的字段*/
private Set<String> mappedProperties;

/**
 * Create a new BeanPropertyRowMapper, accepting unpopulated properties in the target bean.
 * <p>Consider using the {@link #newInstance} factory method instead,which allows for specifying the mapped type once only.
 * @param mappedClass the class that each row should be mapped to
 */
public BeanPropertyRowMapper(Class<T> mappedClass) {
    initialize(mappedClass);
}

/**
 * Create a new BeanPropertyRowMapper.
 * @param mappedClass the class that each row should be mapped to
 * @param checkFullyPopulated whether we‘re strictly validating that all bean properties have been mapped from corresponding database fields
 */
public BeanPropertyRowMapper(Class<T> mappedClass, boolean checkFullyPopulated) {
    initialize(mappedClass);
    this.checkFullyPopulated = checkFullyPopulated; //是否严格验证,所有bean属性已经从对应的数据库字段映射。
}

/**
 * Initialize the mapping metadata for the given class.
 * @param mappedClass the mapped class.
 */
protected void initialize(Class<T> mappedClass) {
    this.mappedClass = mappedClass;  
    this.mappedFields = new HashMap<String, PropertyDescriptor>(); 
    this.mappedProperties = new HashSet<String>();
    //以上都是设置/初始化成员变量

    PropertyDescriptor[] pds = BeanUtils.getPropertyDescriptors(mappedClass);//org.springframework.beans.BeanUtils

   for (PropertyDescriptor pd : pds) {
        if (pd.getWriteMethod() != null) {
            this.mappedFields.put(pd.getName().toLowerCase(), pd); // key:全小写 
              String underscoredName = underscoreName(pd.getName()); // ex：bookName --> book_name
            if (!pd.getName().toLowerCase().equals(underscoredName)) {
              //set与其属性命名的不一致；方法是setBookName 而变量是book_name; 大致是这意思
                this.mappedFields.put(underscoredName, pd);
            }
            this.mappedProperties.add(pd.getName()); //key：与mappedFields不一样
        }
    }
}

/**
 * Convert a name in camelCase to an underscored name in lower case.
 * Any upper case letters are converted to lower case with a preceding underscore.
 * @param name the string containing original name
 * @return the converted name
 */
private String underscoreName(String name) { //ex： bookName --> book_name
    if (!StringUtils.hasLength(name)) {
        return "";
    }
    StringBuilder result = new StringBuilder();
    result.append(name.substring(0, 1).toLowerCase());
    for (int i = 1; i < name.length(); i++) {
        String s = name.substring(i, i + 1);
        String slc = s.toLowerCase();
        if (!s.equals(slc)) { //大写字母转换成  _+小写
            result.append("_").append(slc);
        }
        else {
            result.append(s);
        }
    }
    return result.toString();
}

// jdbcTemplate调用RowMapper.mapRow(...) 
public class RowMapperResultSetExtractor<T> implements ResultSetExtractor<List<T>> {

    private final RowMapper<T> rowMapper;

    private final int rowsExpected;


    /**
     * Create a new RowMapperResultSetExtractor.
     * @param rowMapper the RowMapper which creates an object for each row
     */
    public RowMapperResultSetExtractor(RowMapper<T> rowMapper) {
        this(rowMapper, 0);
    }

    /**
     * Create a new RowMapperResultSetExtractor.
     * @param rowMapper the RowMapper which creates an object for each row
     * @param rowsExpected the number of expected rows
     * (just used for optimized collection handling)
     */
    public RowMapperResultSetExtractor(RowMapper<T> rowMapper, int rowsExpected) {
        Assert.notNull(rowMapper, "RowMapper is required");
        this.rowMapper = rowMapper;
        this.rowsExpected = rowsExpected;
    }


    @Override
    public List<T> extractData(ResultSet rs) throws SQLException {
        List<T> results = (this.rowsExpected > 0 ? new ArrayList<T>(this.rowsExpected) : new ArrayList<T>());
        int rowNum = 0;
        while (rs.next()) {
            results.add(this.rowMapper.mapRow(rs, rowNum++));//调用核心； 1、每行的rowMapper是同一个对象，所以可以缓存映射关系 2、mapRow为什么是new对象也是因为这个。不然list.add的是同一个return对象。
        }
        return results;
    }
}

// BeanPropertyRowMapper中mapRow的实现    
@Override
public T mapRow(ResultSet rs, int rowNumber) throws SQLException {
    Assert.state(this.mappedClass != null, "Mapped class was not specified");
    T mappedObject = BeanUtils.instantiate(this.mappedClass);  //实例化一个新对象；就是class.newInstance();

    BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(mappedObject); //这也是spring自己的,有兴趣可以看。在这主要就是类似method.invoke(…)
    initBeanWrapper(bw); //这是个空方法，用于子类扩展

     ResultSetMetaData rsmd = rs.getMetaData();
    int columnCount = rsmd.getColumnCount();  // 与rsmd都是sql结果集的信息
     Set<String> populatedProperties = (isCheckFullyPopulated() ? new HashSet<String>() : null);//是否严格映射bean和sql

    for (int index = 1; index <= columnCount; index++) {
       String column = JdbcUtils.lookupColumnName(rsmd, index);  // 得到sql的列名/别名
        PropertyDescriptor pd = this.mappedFields.get(column.replaceAll(" ", "").toLowerCase());  // 从缓存中得到方法信息
        if (pd != null) {
            try {
                Object value = getColumnValue(rs, index, pd);  // 得到每列的值。为什么要pd：因为要根据类型获取相应的值。
                if (logger.isDebugEnabled() && rowNumber == 0) {
                    logger.debug("Mapping column ‘" + column + "‘ to property ‘" +
                            pd.getName() + "‘ of type " + pd.getPropertyType());
                }
                try {
                    bw.setPropertyValue(pd.getName(), value);  // 设置结果
                 }
                catch (TypeMismatchException e) {
                    if (value == null && primitivesDefaultedForNullValue) {
                        logger.debug("Intercepted TypeMismatchException for row " + rowNumber +
                                " and column ‘" + column + "‘ with value " + value +
                                " when setting property ‘" + pd.getName() + "‘ of type " + pd.getPropertyType() +
                                " on object: " + mappedObject);
                    }
                    else {
                        throw e;
                    }
                }
                if (populatedProperties != null) { //严格映射的逻辑判断
                    populatedProperties.add(pd.getName());
                }
            }
            catch (NotWritablePropertyException ex) {
                throw new DataRetrievalFailureException(
                        "Unable to map column " + column + " to property " + pd.getName(), ex);
            }
        }
    }

    if (populatedProperties != null && !populatedProperties.equals(this.mappedProperties)) { //严格映射的逻辑判断 
        throw new InvalidDataAccessApiUsageException("Given ResultSet does not contain all fields " +
                "necessary to populate object of class [" + this.mappedClass + "]: " + this.mappedProperties);
    }

    return mappedObject;
}

public static <T> T instantiate(Class<T> clazz) throws BeanInstantiationException {
        Assert.notNull(clazz, "Class must not be null");
        if (clazz.isInterface()) {
            throw new BeanInstantiationException(clazz, "Specified class is an interface");
        }
        try {
            return clazz.newInstance();
        }
        catch (InstantiationException ex) {
            throw new BeanInstantiationException(clazz, "Is it an abstract class?", ex);
        }
        catch (IllegalAccessException ex) {
            throw new BeanInstantiationException(clazz, "Is the constructor accessible?", ex);
        }
    }

/**
 * Initialize the given BeanWrapper to be used for row mapping.
 * To be called for each row.
 * <p>The default implementation is empty. Can be overridden in subclasses.
 * @param bw the BeanWrapper to initialize
 */
protected void initBeanWrapper(BeanWrapper bw) {
}

protected Object getColumnValue(ResultSet rs, int index, PropertyDescriptor pd) throws SQLException {
    return JdbcUtils.getResultSetValue(rs, index, pd.getPropertyType());
}

// JdbcUtils.class   根据set参数的类型，决定sql返回值调用类型
public static Object getResultSetValue(ResultSet rs, int index, Class<?> requiredType) throws SQLException {
    if (requiredType == null) {
        return getResultSetValue(rs, index);
    }

    Object value;

    // Explicitly extract typed value, as far as possible.
    if (String.class.equals(requiredType)) {
        return rs.getString(index);
    }
    else if (boolean.class.equals(requiredType) || Boolean.class.equals(requiredType)) {
        value = rs.getBoolean(index);
    }
    else if (byte.class.equals(requiredType) || Byte.class.equals(requiredType)) {
        value = rs.getByte(index);
    }
    else if (short.class.equals(requiredType) || Short.class.equals(requiredType)) {
        value = rs.getShort(index);
    }
    else if (int.class.equals(requiredType) || Integer.class.equals(requiredType)) {
        value = rs.getInt(index);
    }
    else if (long.class.equals(requiredType) || Long.class.equals(requiredType)) {
        value = rs.getLong(index);
    }
    else if (float.class.equals(requiredType) || Float.class.equals(requiredType)) {
        value = rs.getFloat(index);
    }
    else if (double.class.equals(requiredType) || Double.class.equals(requiredType) ||
            Number.class.equals(requiredType)) {
        value = rs.getDouble(index);
    }
    else if (BigDecimal.class.equals(requiredType)) {
        return rs.getBigDecimal(index);
    }
    else if (java.sql.Date.class.equals(requiredType)) {
        return rs.getDate(index);
    }
    else if (java.sql.Time.class.equals(requiredType)) {
        return rs.getTime(index);
    }
    else if (java.sql.Timestamp.class.equals(requiredType) || java.util.Date.class.equals(requiredType)) {
        return rs.getTimestamp(index);
    }
    else if (byte[].class.equals(requiredType)) {
        return rs.getBytes(index);
    }
    else if (Blob.class.equals(requiredType)) {
        return rs.getBlob(index);
    }
    else if (Clob.class.equals(requiredType)) {
        return rs.getClob(index);
    }
    else {
        // Some unknown type desired -> rely on getObject.
        if (getObjectWithTypeAvailable) {
            try {
                return rs.getObject(index, requiredType);
            }
            catch (AbstractMethodError err) {
                logger.debug("JDBC driver does not implement JDBC 4.1 ‘getObject(int, Class)‘ method", err);
            }
            catch (SQLFeatureNotSupportedException ex) {
                logger.debug("JDBC driver does not support JDBC 4.1 ‘getObject(int, Class)‘ method", ex);
            }
            catch (SQLException ex) {
                logger.debug("JDBC driver has limited support for JDBC 4.1 ‘getObject(int, Class)‘ method", ex);
            }
        }
        // Fall back to getObject without type specification...
        return getResultSetValue(rs, index);
    }

    // Perform was-null check if necessary (for results that the JDBC driver returns as primitives).
    return (rs.wasNull() ? null : value);
}