提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

接口定义

/** * Implementors define a strategy for transforming query results into the * actual application-visible query result list. * * @see org.hibernate.Criteria#setResultTransformer(ResultTransformer) * @see org.hibernate.Query#setResultTransformer(ResultTransformer) * * @author Gavin King */
public interface ResultTransformer extends Serializable { 
   
	/** * 以单行查询结果为参数，通过构造子实例化最终对象。 */
	public Object transformTuple(Object[] tuple, String[] aliases);

	/** * 统一处理最终查询结果集，将其转化为最终对象 * Hibernate 在处理查询结果集时，最后会调用该方法 * @param collection The result. * @return The transformed result. */
	public List transformList(List collection);
}

实现类

接口方法未说明则默认为不作处理。

AliasToBeanConstructorResultTransformer

transformTuple ：以单行查询结果为参数，通过构造子实例化最终对象。

AliasToBeanResultTransformer

transformTuple ：以查询时指定的属性别名作为最终对象的属性名，通过反射实例化最终对象，并调用属性的 setter 方法将查询结果值设置到最终对象里。

BasicTransformerAdapter

ResultTransformer 的空操作实现类，且是抽象的。

AliasToEntityMapResultTransformer

transformTuple ：以查询时指定的别名作为 key ，以结果值作为 value ，将单行查询结果组装成一个 Map 。

DistinctResultTransformer

transformList ：剔除重复的对象，按照 == 判断查询结果是否相同。

PassThroughResultTransformer

transformTuple ： 如果单行结果只有一个元素则直接返回该元素值，否则不做处理。

RootEntityResultTransformer

transformTuple ：返回最后一个元素，也就是根实体对象。

ToListResultTransformer

transformTuple ：将单行查询结果由数组转换为 List 。

DistinctRootEntityResultTransformer

DistinctResultTransformer 和 RootEntityResultTransformer 的组合。

transformTuple ：返回最后一个元素，也就是根实体对象。

transformList ：剔除重复的对象，按照 == 判断查询结果是否相同。

应用示例

AliasToBeanResultTransformer

设若我们有简单的视图层Bean UserDTO ，对应实体 User 如下：

public class User { 
   
	id
	name
}
public class UserDTO { 
   
	userId
	userName
}

通过 AliasToBeanResultTransformer 可以直接将查询结果转换为 UserDTO （当然在只需查询 UserDTO 属性的情况下）。

Criteria 查询

public List<UserDTO> query(Integer userId, String keyword) { 
   
         Criteria crit = userDao.createCriteria();
         
         crit.add(Restrictions.eq("this.id", userId));
         crit.add(Restrictions.like("this.name", keyword, MatchMode.ANYWHERE));

         ProjectionList pl = Projections.projectionList();

         pl.add(Property.forName("id"), "userId"); // 注：别名需与 UserDTO 中的属性名一致
         pl.add(Property.forName("name"), "userName");

         crit.setProjection(pl).setResultTransformer(new AliasToBeanResultTransformer(UserDTO.class));

         return crit.list();

}

HQL 查询

public List<UserDTO> query(Integer userId, String keyword) { 
   

         StringBuffer hql = new StringBuffer();

         hql.append("select id as userId, ");  // 注：需通过 as 指定别名
         hql.append("name as userName");
         hql.append("from User ");
         hql.append("where id=:id and name like :keyword ");
         
         Map<String, Object> pars = new HashMap<>();
         pars.put("id", userId);
         pars.put("keyword", "%" + keyword + "%");

         Query query = userDao.createQuery(hql.toString(), pars)
         	.setResultTransformer(new AliasToBeanResultTransformer(UserDTO.class));

         return query.list();

}

SQL 查询

public List<UserDTO> queryAd(Integer userId, String keyword) { 
   
         StringBuffer sql = new StringBuffer();
         
         sql.append("select id as userId, ");  // 注：需通过 as 指定别名
         sql.append("name as userName");
         sql.append("from t_user");
         sql.append("where id=:id and name like :keyword ");

         Map<String, Object> pars = new HashMap<>();

         pars.put("id", userId);
         pars.put("keyword", "%" + keyword + "%");

         Query query = userDao.createSQLQuery(sql.toString(), pars)
         .addScalar("userId", StandardBasicTypes.INTEGER); // 注：并将 as 的别名声明为一个查询项，并指定类型
         .addScalar("userName", StandardBasicTypes.STRING);
         .setResultTransformer(new AliasToBeanResultTransformer(UserDTO.class));

         return query.list();

}

自定义 ResultTransformer ： KeyValueResultTransformer

transformList：将查询结果集组装成一个Map

在某些情况下，我们需要获取某个对象的 id 和 name ，而且要组成一个 Map 。

public class KeyValueResultTransformer<K, V> extends BasicTransformerAdapter { 
   

    private static final long serialVersionUID = 5603955993685930635L;

    @SuppressWarnings("unchecked")
    public List transformList(List list) { 
   
        Map<K, V> kvs = new HashMap<K, V>();
        for (Object[] obj : (List<Object[]>) list) { 
   
            if (obj.length != 2) { 
   
                throw new IllegalArgumentException("one row must have two tuples");
            }
            if (obj[0] != null) { 
   
                kvs.put((K) obj[0], (V) obj[1]);
            }
        }
        List<Map<K, V>> ml = new ArrayList<Map<K, V>>();
        ml.add(kvs);
        return ml;
    }

}

使用

public Map<Integer, String> queryAdIdAndName(Integer userId, String keyword) { 
   
         Criterion res = Restrictions.eq("this.userId", userId);

         Criteria crit = adDao.createCriteria(res);

         crit.add(Restrictions.like("this.name", keyword, MatchMode.ANYWHERE));         

         ProjectionList pl = Projections.projectionList();

         pl.add(Property.forName("adId"), "id");

         pl.add(Property.forName("name"), "name");

         crit.setProjection(pl).setResultTransformer(new KeyValueResultTransformer<Integer, String>());

         return (Map<Integer, String>) crit.uniqueResult();
}

总结

待更新