下面列出了怎么用org.hibernate.transform.Transformers的API类实例代码及写法,或者点击链接到github查看源代码。
void run() {
var db = setup().openStatelessSession();
var sqlString = "SELECT first_name as firstName, last_name as lastName, count(*) films\n" +
"FROM actor AS a\n" +
"JOIN film_actor AS fa USING (actor_id)\n" +
"GROUP BY a.actor_id, first_name, last_name\n" +
"ORDER BY films DESC\n" +
"LIMIT 10";
db.createNativeQuery(sqlString)
.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).stream().forEach(o -> out.println(o));
//need other public classes which jbang can't compile/include at the moment.
//db.createNativeQuery(sqlString).addScalar("firstName").addScalar("lastName").addScalar("films")
// .setResultTransformer(Transformers.aliasToBean(DTO.class)).stream().forEach(o -> out.println(o));
}
@SuppressWarnings("unchecked")
public <T> T queryUniqueResult(String queryString, QueryWrapper queryWrapper, Class<T> resultClass, List<ResultType> returnTypeList) {
Session session = sessionBox.getCurrentSession();
Query query = createSQLQuery(session, queryString);
setParameter(query, queryWrapper);
setScalar(query, returnTypeList);
if (resultClass != null && !this.isPrimitive(resultClass) && !this.isString(resultClass)) {
if (null == returnTypeList || returnTypeList.isEmpty()) {
query.setResultTransformer(new ResultToBean(resultClass));
} else {
query.setResultTransformer(Transformers.aliasToBean(resultClass));
}
}
if (null == resultClass) {
query.setResultTransformer(new ResultToBean(resultClass));
}
Object value = query.uniqueResult();
if (value instanceof BigInteger) {
if (Long.class == resultClass) {
value = ((BigInteger) value).longValue();
}
}
return (T) value;
}
public <S> Page<S> find(String queryString, String queryCount, NamedParams params, Pageable pageable, Class<S> transformer) {
Assert.hasText(queryString, "Query must has text!");
Assert.hasText(queryCount, "Query count must has text!");
Assert.notNull(params, "QueryParams must not be null!");
Assert.notNull(pageable, "PageRequest must not be null!");
Assert.notNull(transformer, "TransformerClass must not be null!");
Query query = em.createQuery(queryString);
setQueryParams(query, params);
query.setMaxResults(pageable.getPageSize());
query.setFirstResult((int) pageable.getOffset());
List<S> resultList = query.unwrap(QueryImpl.class).setResultTransformer(Transformers.aliasToBean(transformer)).list();
Query countQuery = em.createQuery(queryCount);
setQueryParams(countQuery, params);
Long total = (Long) countQuery.getSingleResult();
Page<S> page = new PageImpl(resultList, pageable, total);
return page;
}
public <S> List<S> findBySql(StringQuery stringQuery, Class<S> transformer) {
Assert.notNull(stringQuery, "StringQuery must not be null!");
String sql = stringQuery.getQuery();
NamedParams params = stringQuery.getParams();
Assert.notNull(params, "NamedParams must not be null!");
Query query = em.createNativeQuery(sql);
setQueryParams(query, params);
NativeQuery sqlQuery = query.unwrap(NativeQuery.class);
stringQuery.getScalars().forEach((s, type) -> {
sqlQuery.addScalar(s, type);
});
return sqlQuery.setResultTransformer(Transformers.aliasToBean(transformer)).list();
}
@Override
public List loadOrganizzationEngines(final String tenant) {
List orgEngs = list(new ICriterion() {
@Override
public Criteria evaluate(Session session) {
return session
.createCriteria(SbiEngines.class)
.createAlias("sbiProductTypeEngine", "_sbiProductTypeEngine")
.createAlias("_sbiProductTypeEngine.sbiProductType", "_sbiProductType")
.createAlias("_sbiProductType.sbiOrganizationProductType", "_sbiOrganizationProductType")
.createAlias("_sbiOrganizationProductType.sbiOrganizations", "_sbiOrganizations")
.add(Restrictions.eq("_sbiOrganizations.name", tenant))
.setProjection(
Projections.projectionList().add(org.hibernate.criterion.Property.forName("label").as("engineLabel"))
.add(org.hibernate.criterion.Property.forName("_sbiProductType.label").as("productTypeLabel")))
.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
}
});
return orgEngs;
}
@Override
public Criteria evaluate(Session session) {
Criteria criteria = session.createCriteria(SbiGlGlossary.class);
criteria.setProjection(
Projections.projectionList().add(Projections.property("glossaryId"), "glossaryId").add(Projections.property("glossaryNm"), "glossaryNm"))
.setResultTransformer(Transformers.aliasToBean(SbiGlGlossary.class));
if (glossary != null && !glossary.isEmpty()) {
criteria.add(Restrictions.like("glossaryNm", glossary, MatchMode.ANYWHERE).ignoreCase());
}
if (page != null && itemsPerPage != null) {
criteria.setFirstResult((page - 1) * itemsPerPage);
criteria.setMaxResults(itemsPerPage);
}
return criteria;
}
@Override
public List<String> listPlaceholderByMeasures(final List<String> measures) {
List<SbiKpiPlaceholder> lst = list(new ICriterion<SbiKpiPlaceholder>() {
@Override
public Criteria evaluate(Session session) {
DetachedCriteria detachedCriteria = DetachedCriteria.forClass(SbiKpiRuleOutput.class).createAlias("sbiKpiRule", "sbiKpiRule")
.createAlias("sbiKpiAlias", "sbiKpiAlias").setProjection(Property.forName("sbiKpiRule.sbiKpiRuleId.id"))
.add(Restrictions.eq("sbiKpiRule.active", 'T')).add(Restrictions.in("sbiKpiAlias.name", measures));
Criteria c = session.createCriteria(SbiKpiRule.class).createAlias("sbiKpiPlaceholders", "sbiKpiPlaceholders")
.add(Property.forName("sbiKpiRuleId.id").in(detachedCriteria)).add(Restrictions.eq("active", 'T'))
.setProjection(Projections.distinct(Projections.property("sbiKpiPlaceholders.name").as("name")))
.setResultTransformer(Transformers.aliasToBean(SbiKpiPlaceholder.class));
return c;
}
});
List<String> placeholdername = new ArrayList<>();
for (SbiKpiPlaceholder sbiKpiPlaceholder : lst) {
placeholdername.add(sbiKpiPlaceholder.getName());
}
return placeholdername;
}
@Override
public List<Threshold> listThreshold() {
List<SbiKpiThreshold> sbiLst = list(new ICriterion<SbiKpiThreshold>() {
@Override
public Criteria evaluate(Session session) {
return session
.createCriteria(SbiKpiThreshold.class)
.setProjection(
Projections.projectionList().add(Projections.property("id"), "id").add(Projections.property("name"), "name")
.add(Projections.property("description"), "description"))
.setResultTransformer(Transformers.aliasToBean(SbiKpiThreshold.class));
}
});
List<Threshold> thresholds = new ArrayList<>();
for (SbiKpiThreshold sbiThreshold : sbiLst) {
thresholds.add(from(sbiThreshold, false));
}
return thresholds;
}
/**
* 传入查询的原生SQL语句
* @param sqlQuery 原生SQL语句
* @return List<Map<String,String>>
*/
public List<Map<String,Object>> findMapBySqlQuery(String sqlQuery){
// try {
// Query queryObject = getCurrentSession().createSQLQuery(sqlQuery).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
// return queryObject.list();
// } catch (RuntimeException re) {
// throw re;
// }
javax.persistence.Query query = entityManager.createNativeQuery(sqlQuery);
// query.unwrap(SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
query.unwrap(Query.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
List<Map<String,Object>> list= query.getResultList();
entityManager.close();
return list;
}
public <N extends Object>Pager<N> findBySql(String sql, Object[] args,
Map<String, Object> alias, Class<?> clz, boolean hasEntity) {
sql = initSort(sql);
String cq = getCountHql(sql,false);
SQLQuery sq = getSession().createSQLQuery(sql);
SQLQuery cquery = getSession().createSQLQuery(cq);
setAliasParameter(sq, alias);
setAliasParameter(cquery, alias);
setParameter(sq, args);
setParameter(cquery, args);
Pager<N> pages = new Pager<N>();
setPagers(sq, pages);
if(hasEntity) {
sq.addEntity(clz);
} else {
sq.setResultTransformer(Transformers.aliasToBean(clz));
}
List<N> datas = sq.list();
pages.setDatas(datas);
long total = ((BigInteger)cquery.uniqueResult()).longValue();
pages.setTotal(total);
return pages;
}
public <N extends Object> List<N> listBySql(String sql, Object[] args, Map<String, Object> alias, Class<?> clz,
boolean hasEntiry) {
sql = initSort(sql);
SQLQuery sq = getSession().createSQLQuery(sql);
setAliasParameter(sq, alias);
setParameter(sq, args);
if (hasEntiry) {
sq.addEntity(clz);
} else {
sq.setResultTransformer(Transformers.aliasToBean(clz));
}
return sq.list();
}
@Test
@Ignore
public void testGroupConcatJPQLQuery() {
doInJPA(entityManager -> {
List<PostSummaryDTO> postSummaries = entityManager.createQuery(
"select " +
" p.id as id, " +
" p.title as title, " +
" group_concat(t.name) as tags " +
"from Post p " +
"left join p.tags t " +
"group by p.id, p.title")
.unwrap(Query.class)
.setResultTransformer(Transformers.aliasToBean(PostSummaryDTO.class))
.getResultList();
assertEquals(1, postSummaries.size());
LOGGER.info("Post tags: {}", postSummaries.get(0).getTags());
});
}
@Test
@Ignore
public void testGroupConcatJPQLQuery() {
doInJPA(entityManager -> {
List<PostSummaryDTO> postSummaries = entityManager.createQuery(
"select " +
" p.id as id, " +
" p.title as title, " +
" group_concat(t.name) as tags " +
"from Post p " +
"left join p.tags t " +
"group by p.id, p.title")
.unwrap(Query.class)
.setResultTransformer(Transformers.aliasToBean(PostSummaryDTO.class))
.getResultList();
assertEquals(1, postSummaries.size());
LOGGER.info("Post tags: {}", postSummaries.get(0).getTags());
});
}
@Test
public void testGroupConcatJPQLQuery() {
doInJPA(entityManager -> {
List<PostSummaryDTO> postSummaries = entityManager.createQuery(
"select " +
" p.id as id, " +
" p.title as title, " +
" group_concat(t.name) as tags " +
"from Post p " +
"left join p.tags t " +
"group by p.id, p.title")
.unwrap(Query.class)
.setResultTransformer(Transformers.aliasToBean(PostSummaryDTO.class))
.getResultList();
assertEquals(1, postSummaries.size());
LOGGER.info("Post tags: {}", postSummaries.get(0).getTags());
});
}
@Test
public void testGroupConcatJPQLQuery() {
doInJPA(entityManager -> {
List<PostSummaryDTO> postSummaries = entityManager.createQuery(
"select " +
" p.id as id, " +
" p.title as title, " +
" group_concat(t.name) as tags " +
"from Post p " +
"left join p.tags t " +
"group by p.id, p.title")
.unwrap(Query.class)
.setResultTransformer(Transformers.aliasToBean(PostSummaryDTO.class))
.getResultList();
assertEquals(1, postSummaries.size());
LOGGER.info("Post tags: {}", postSummaries.get(0).getTags());
});
}
@SuppressWarnings("rawtypes")
private Map getJobDateRange(Session session, boolean ignoreTestAccounts) {
//Get min and max values of dates
Criteria rangeCriteria = session.createCriteria(JobLogEntry.class);
testAccountFilter.addCriteriaForTestAccounts(session, ignoreTestAccounts, rangeCriteria);
ProjectionList projections = Projections.projectionList();
projections.add(Projections.min(JobLogContainer.START_TIME), "min");
projections.add(Projections.max(JobLogContainer.START_TIME), "max");
rangeCriteria.setProjection(projections);
rangeCriteria.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
@SuppressWarnings("unchecked")
List<Map> rangeList = rangeCriteria.list();
return rangeList.get(0);
}
/**
* {@inheritDoc}
*/
@Override
public List<UserProfile> getUserProfiles(final int start, final int count) {
//get fields directly from the sakaiperson table and use Transformers.aliasToBean to transform into UserProfile pojo
//the idea is we *dont* want a SakaiPerson object
final HibernateCallback<List<UserProfile>> hcb = session -> {
final Query q = session.getNamedQuery(QUERY_GET_SAKAI_PERSON);
//see scalars in the hbm
q.setFirstResult(start);
q.setMaxResults(count);
q.setResultTransformer(Transformers.aliasToBean(UserProfile.class));
q.setCacheMode(CacheMode.GET);
return q.list();
};
return getHibernateTemplate().execute(hcb);
}
/**
* CommonDAO 内部方法, NativeQuery
*
* @param entityManager
* entityManager
* @param sql
* sql
* @param values
* values
* @return Query对象
*/
private Query createNativeQuery(EntityManager entityManager, String sql, Class resultClass, boolean mapResult,
Map<String, Object> values) {
Query query = null;
if (resultClass != null) {
query = entityManager.createNativeQuery(sql, resultClass);
} else {
query = entityManager.createNativeQuery(sql);
}
// 封装为Map结果
if (mapResult) {
query.unwrap(org.hibernate.Query.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
}
if (values != null && values.size() > 0) {
for (Entry<String, Object> e : values.entrySet()) {
query.setParameter(e.getKey(), e.getValue());
}
}
return query;
}
/**
* CommonDAO 内部方法, NativeQuery
*
* @param entityManager
* entityManager
* @param sql
* sql
* @param values
* values
* @return Query对象
*/
private Query createNativeQuery(EntityManager entityManager, String sql, Class resultClass, boolean mapResult,
Map<String, Object> values) {
Query query = null;
if (resultClass != null) {
query = entityManager.createNativeQuery(sql, resultClass);
} else {
query = entityManager.createNativeQuery(sql);
}
// 封装为Map结果
if (mapResult) {
query.unwrap(org.hibernate.Query.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
}
if (values != null && values.size() > 0) {
for (Entry<String, Object> e : values.entrySet()) {
query.setParameter(e.getKey(), e.getValue());
}
}
return query;
}
/**
* CommonDAO 内部方法, NativeQuery
*
* @param entityManager
* entityManager
* @param sql
* sql
* @param values
* values
* @return Query对象
*/
private Query createNativeQuery(EntityManager entityManager, String sql, Class resultClass, boolean mapResult,
Map<String, Object> values) {
Query query = null;
if (resultClass != null) {
query = entityManager.createNativeQuery(sql, resultClass);
} else {
query = entityManager.createNativeQuery(sql);
}
// 封装为Map结果
if (mapResult) {
query.unwrap(org.hibernate.Query.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
}
if (values != null && values.size() > 0) {
for (Entry<String, Object> e : values.entrySet()) {
query.setParameter(e.getKey(), e.getValue());
}
}
return query;
}
/**
* {@inheritDoc}
*/
@Override
public List<UserProfile> getUserProfiles(final int start, final int count) {
//get fields directly from the sakaiperson table and use Transformers.aliasToBean to transform into UserProfile pojo
//the idea is we *dont* want a SakaiPerson object
final HibernateCallback<List<UserProfile>> hcb = session -> {
final Query q = session.getNamedQuery(QUERY_GET_SAKAI_PERSON);
//see scalars in the hbm
q.setFirstResult(start);
q.setMaxResults(count);
q.setResultTransformer(Transformers.aliasToBean(UserProfile.class));
q.setCacheMode(CacheMode.GET);
return q.list();
};
return getHibernateTemplate().execute(hcb);
}
public Page<RegisterPromotionVO> getPromotionDetails(long memberId, PageModel pageModel){
StringBuilder headSql = new StringBuilder("select a.id id ,a.username presentee,a.email presenteeEmail, ")
.append("a.mobile_phone presenteePhone,a.real_name presenteeRealName,a.registration_time promotionTime, ")
.append("b.level promotionLevel ") ;
StringBuilder endSql = new StringBuilder(" from member a join member_promotion b on a.inviter_id = b.inviter_id and a.inviter_id = "+memberId);
StringBuilder countHead = new StringBuilder("select count(*) ") ;
Page<RegisterPromotionVO> page = createNativePageQuery(countHead.append(endSql),headSql.append(endSql),pageModel,Transformers.aliasToBean(RegisterPromotionVO.class)) ;
RewardPromotionSetting setting = rewardPromotionSettingService.findByType(PromotionRewardType.REGISTER) ;
BigDecimal one = JSONObject.parseObject(setting.getInfo()).getBigDecimal("one");
BigDecimal two = JSONObject.parseObject(setting.getInfo()).getBigDecimal("two");
for(RegisterPromotionVO vo:page.getContent()){
vo.setUnit(setting.getCoin().getUnit());
if(vo.getPromotionLevel()== PromotionLevel.ONE.getOrdinal()){
vo.setReward(one);
}else if(vo.getPromotionLevel()== PromotionLevel.TWO.getOrdinal()){
vo.setReward(two);
}else{
vo.setReward(BigDecimal.ZERO);
}
}
return page ;
}
public Map getOrderBySn(Long memberId, String orderSn) {
String sql = "select o.*,m.real_name from otc_order o join member m on o.customer_id=m.id and o.member_id=:memberId and o.order_sn =:orderSn ";
Query query = em.createNativeQuery(sql);
//设置结果转成Map类型
query.unwrap(SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
Object object = query.setParameter("memberId", memberId).setParameter("orderSn", orderSn).getSingleResult();
Map map = (HashMap) object;
return map;
}
public Map findAdminDetail(Long id) {
String sql = "select a.id,a.role_id roleId,a.department_id departmentId,a.real_name realName,a.avatar,a.email,a.enable,a.mobile_phone mobilePhone,a.qq,a.username, " +
"d.name as 'departmentName',r.role from admin a LEFT join department d on a.department_id=d.id LEFT JOIN admin_role r on a.role_id=r.id WHERE a.id=:adminId ";
Query query = em.createNativeQuery(sql);
//设置结果转成Map类型
query.unwrap(SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
Object object = query.setParameter("adminId", id).getSingleResult();
Map map = (HashMap) object;
return map;
}
@Override
public List<Map> queryBySql(String sql) {
Query query = entityManager.createNativeQuery(sql);
query.unwrap(NativeQueryImpl.class)
.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
List list = query.getResultList();
return list;
}
@Test
public void test_sql_hibernate_dto_query_example() {
doInJPA(this::entityManagerFactory, entityManager -> {
Session session = entityManager.unwrap(Session.class);
//tag::sql-hibernate-dto-query-example[]
List<PersonSummaryDTO> dtos = session.createNativeQuery(
"SELECT p.id as id, p.name as name " +
"FROM Person p")
.setResultTransformer(Transformers.aliasToBean(PersonSummaryDTO.class))
.list();
//end::sql-hibernate-dto-query-example[]
assertEquals(3, dtos.size());
});
}
public Page<RegisterPromotionVO> getPromotionDetails(long memberId, PageModel pageModel){
StringBuilder headSql = new StringBuilder("select a.id id ,a.username presentee,a.email presenteeEmail, ")
.append("a.mobile_phone presenteePhone,a.real_name presenteeRealName,a.registration_time promotionTime, ")
.append("b.level promotionLevel ") ;
StringBuilder endSql = new StringBuilder(" from member a join member_promotion b on a.inviter_id = b.inviter_id and a.inviter_id = "+memberId);
StringBuilder countHead = new StringBuilder("select count(*) ") ;
Page<RegisterPromotionVO> page = createNativePageQuery(countHead.append(endSql),headSql.append(endSql),pageModel,Transformers.aliasToBean(RegisterPromotionVO.class)) ;
RewardPromotionSetting setting = rewardPromotionSettingService.findByType(PromotionRewardType.REGISTER) ;
BigDecimal one = JSONObject.parseObject(setting.getInfo()).getBigDecimal("one");
BigDecimal two = JSONObject.parseObject(setting.getInfo()).getBigDecimal("two");
for(RegisterPromotionVO vo:page.getContent()){
vo.setUnit(setting.getCoin().getUnit());
if(vo.getPromotionLevel()== PromotionLevel.ONE.getOrdinal()){
vo.setReward(one);
}else if(vo.getPromotionLevel()== PromotionLevel.TWO.getOrdinal()){
vo.setReward(two);
}else{
vo.setReward(BigDecimal.ZERO);
}
}
return page ;
}
public Map getOrderBySn(Long memberId, String orderSn) {
String sql = "select o.*,m.real_name from otc_order o join member m on o.customer_id=m.id and o.member_id=:memberId and o.order_sn =:orderSn ";
Query query = em.createNativeQuery(sql);
//设置结果转成Map类型
query.unwrap(SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
Object object = query.setParameter("memberId", memberId).setParameter("orderSn", orderSn).getSingleResult();
Map map = (HashMap) object;
return map;
}
protected SQLQuery getQuery(String queryString, Map<String, Object> where, int start, int limit, boolean returnMap) {
Session session = this.getSession();
SQLQuery query = null;
if (start > -1 && limit > 0) {
query = session.createSQLQuery(queryString);
query.setFirstResult(start);
query.setMaxResults(limit);
} else {
query = session.createSQLQuery(queryString);
}
if (where != null) {
for (Entry<String, Object> entry : where.entrySet()) {
Object value = entry.getValue();
String key = entry.getKey();
if (value instanceof Collection) {
query.setParameterList(key, (Collection) value);
} else if (value instanceof Object[]) {
query.setParameterList(key, (Object[]) value);
} else {
query.setParameter(key, value);
}
}
}
if (returnMap) {
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
}
return query;
}
@SuppressWarnings("unchecked")
public <T> List<T> queryList(String queryString, QueryWrapper queryWrapper, Class<T> resultClass, List<ResultType> returnTypeList) {
Session session = sessionBox.getCurrentSession();
List<T> list = null;
Query query = createSQLQuery(session, queryString);
setParameter(query, queryWrapper);
if (null != returnTypeList) {
setScalar(query, returnTypeList);
}
if (resultClass != null && !this.isPrimitive(resultClass) && !this.isString(resultClass)) {
if (null == returnTypeList || returnTypeList.isEmpty()) {
query.setResultTransformer(new ResultToBean(resultClass));
} else {
query.setResultTransformer(Transformers.aliasToBean(resultClass));
}
}
if (null == resultClass) {
query.setResultTransformer(new ResultToBean(resultClass));
}
list = query.list();
if (null == list) {
list = new ArrayList<>();
}
return list;
}