Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
net.cassite.daf4j.jpa.JPQLDataAccess Maven / Gradle / Ivy
A library provides implementation of DAF4J DataAccess using JPA
package net.cassite.daf4j.jpa;
import net.cassite.daf4j.*;
import net.cassite.daf4j.types.*;
import net.cassite.daf4j.util.ConstantMap;
import net.cassite.daf4j.util.AliasMap;
import net.cassite.daf4j.util.Location;
import net.cassite.daf4j.Selectable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.persistence.*;
import javax.persistence.Query;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.*;
/**
* Use JPQLDataSource instead. toJoin;
public IExpression expression;
public Object obj;
public Condition condition;
public String aggregateFunctions;
public List selectNonAggregationAliases;
public boolean doGroupBy = false;
public boolean notDistinctOrAlreadyDone = true;
public boolean generatingSelect = false;
public Args doClone() {
Args args = new Args();
args.sb = this.sb;
args.whereClause = this.whereClause;
args.queryParameter = queryParameter;
args.entity = entity;
args.entityClass = this.entityClass;
args.aliasMap = this.aliasMap;
args.constantMap = this.constantMap;
args.toJoin = this.toJoin;
args.aggregateFunctions = this.aggregateFunctions;
args.selectNonAggregationAliases = this.selectNonAggregationAliases;
args.doGroupBy = this.doGroupBy;
args.notDistinctOrAlreadyDone = this.notDistinctOrAlreadyDone;
args.generatingSelect = this.generatingSelect;
return args;
}
public Args fillObj(Object obj) {
Args a = doClone();
a.obj = obj;
return a;
}
public Args fillExp(IExpression exp) {
Args a = doClone();
a.expression = exp;
return a;
}
public Args fillWhere(Where where) {
Args a = doClone();
a.whereClause = where;
return a;
}
public Args fillCondition(Condition condition) {
Args a = doClone();
a.condition = condition;
return a;
}
public Args prepareForSubQuery(PreResult query) {
Args a = this.doClone();
a.aliasMap = new AliasMap(aliasPrefix, this.aliasMap.getAliasCount());
a.toJoin = new LinkedHashMap();
a.sb = new StringBuilder();
a.entity = query.entity;
a.entityClass = query.entity.getClass();
a.whereClause = query.whereClause;
a.queryParameter = null;
a.aggregateFunctions = null;
a.selectNonAggregationAliases = new ArrayList();
a.doGroupBy = false;
a.notDistinctOrAlreadyDone = true;
a.generatingSelect = false;
return a;
}
}
private final EntityManager entityManager;
private EntityTransaction tx;
public JPQLDataAccess(EntityManager entityManager) {
this.entityManager = entityManager;
}
/**
* 生成表达式 list, Args args, Set alreadySearched, List> locationsMightBeJoined) {
Map objectStringMap = new LinkedHashMap();
try {
for (Field f : entity.getClass().getFields()) {
// is IData
if (IData.class.isAssignableFrom(f.getType())) {
// get 1st generic type
Class cls;
try {
cls = ((Class) ((ParameterizedType) f.getGenericType()).getActualTypeArguments()[0]);
} catch (ClassCastException e) {
// not generic type , maybe one of XTypes
Class type = f.getType();
if (XInt.class.isAssignableFrom(type)) {
cls = Integer.class;
} else if (XLong.class.isAssignableFrom(type)) {
cls = Long.class;
} else if (XDouble.class.isAssignableFrom(type)) {
cls = Double.class;
} else if (XDate.class.isAssignableFrom(type)) {
cls = Date.class;
} else if (XString.class.isAssignableFrom(type)) {
cls = String.class;
} else if (XBool.class.isAssignableFrom(type)) {
cls = Boolean.class;
} else {
throw e;
}
}
// is not java. / javax.
if (!cls.getName().startsWith("java.") && !cls.getName().startsWith("javax.")) {
IData data = (IData) f.get(entity);
Object obj = data.get();
if (obj == null) continue;
if (obj instanceof Iterable) {
// is aggregate
Iterator it = ((Iterable) obj).iterator();
if (it.hasNext()) {
Object o = it.next();
List tmp = new ArrayList(list);
tmp.add(f.getName());
locationsMightBeJoined.add(new ArrayList(tmp));
if (o == toFind) {
list.add(f.getName());
if (toFind != args.entity) {
for (List locationList : locationsMightBeJoined) {
Location loc = DataUtils.generateLocationAndFillMap(locationList, args.aliasMap);
if (!args.toJoin.containsKey(loc)) {
args.toJoin.put(loc, args.aliasMap.get(loc));
}
}
}
return DataUtils.generateLocationAndFillMap(list, args.aliasMap);
} else {
if (!alreadySearched.contains(o)) {
alreadySearched.add(o);
objectStringMap.put(o, f.getName());
}
}
}
} else {
List tmp = new ArrayList(list);
tmp.add(f.getName());
locationsMightBeJoined.add(new ArrayList(tmp));
// is plain object
if (obj == toFind) {
list.add(f.getName());
if (toFind != args.entity) {
for (List locationList : locationsMightBeJoined) {
Location loc = DataUtils.generateLocationAndFillMap(locationList, args.aliasMap);
if (!args.toJoin.containsKey(loc)) {
args.toJoin.put(loc, args.aliasMap.get(loc));
}
}
}
return DataUtils.generateLocationAndFillMap(list, args.aliasMap);
} else {
if (!alreadySearched.contains(obj)) {
alreadySearched.add(obj);
objectStringMap.put(obj, f.getName());
}
}
}
}
}
}
// not found
for (Object obj : objectStringMap.keySet()) {
List nextList = new ArrayList(list);
nextList.add(objectStringMap.get(obj));
List> nextLocationsMightBeJoined = new ArrayList>(locationsMightBeJoined);
Location location = findEntity(obj, toFind, nextList, args, alreadySearched, nextLocationsMightBeJoined);
if (null != location) {
// found
return location;
}
}
return null;
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
/**
* 获取Entity位置,若没有找到则抛出异常
*
* @param toFind 要寻找的实体
* @param args Args对象
* @return 实体的位置(Location对象)
*/
private Location findEntity(Object toFind, Args args) {
Location l = findEntity(args.entity, toFind, new ArrayList(), args, new HashSet(), new ArrayList>());
if (l == null) {
throw new IllegalArgumentException("Cannot find location of " + toFind);
}
return l;
}
/**
* 将IData转化为字符串()));
if (entity != args.entity) {
Location location = findEntity(entity, args);
alias = args.aliasMap.get(location);
}
return alias + "." + DataUtils.findFieldNameByIData(data);
}
/**
* 生成condition类型对应的语句,例如 u.age > 18
* 根据传入的queryParameter确定是否查询部分字段,调用DataUtils.findFieldNameByIData
* 根据entity类型生成from子句
* 调用generateJoinWhere生成join和where子句
* 调用generateGroupByHaving生成groupby和having子句
* 根据传入的queryParameter生成末尾的语句,例如order by
*
*
* @param args Args对象
* @return 生成的语句
*/
private String generateSelect(Args args, boolean isProjection) {
if (args.queryParameter != null && args.queryParameter.parameters.containsKey(QueryParameterTypes.distinct)) {
args.notDistinctOrAlreadyDone = false;
}
args.generatingSelect = true;
String entityAlias = args.aliasMap.get(new Location(new ArrayList(0)));
args.sb.append("SELECT ");
if (isProjection) {
// generate focus
if (args.queryParameter == null || !(args.queryParameter instanceof QueryParameterWithFocus) || ((QueryParameterWithFocus) args.queryParameter).focusMap.size() == 0) {
args.queryParameter = new QueryParameterWithFocus(args.queryParameter, null);
QueryParameterWithFocus qpwf = (QueryParameterWithFocus) args.queryParameter;
try {
for (Field f : args.entityClass.getFields()) {
if (IData.class.isAssignableFrom(f.getType()) && !ParameterAggregate.class.isAssignableFrom(f.getType())) {
qpwf.focus((IData) f.get(args.entity));
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
boolean isFirst = true;
for (Selectable o : ((QueryParameterWithFocus) args.queryParameter).focusMap.keySet()) {
if (isFirst) {
isFirst = false;
} else {
args.sb.append(", ");
}
if (o instanceof IData) {
IData d = (IData) o;
if (d.getEntity() == args.entity) {
String alias = entityAlias + "." + DataUtils.findFieldNameByIData(d);
if (!args.notDistinctOrAlreadyDone) {
args.sb.append("DISTINCT ");
args.notDistinctOrAlreadyDone = true;
}
args.sb.append(alias);
args.selectNonAggregationAliases.add(alias);
} else {
Location loc = findEntity(d.getEntity(), args);
String alias = args.aliasMap.get(loc) + "." + DataUtils.findFieldNameByIData(d);
if (!args.notDistinctOrAlreadyDone) {
args.sb.append("DISTINCT ");
args.notDistinctOrAlreadyDone = true;
}
args.sb.append(alias);
args.selectNonAggregationAliases.add(alias);
args.toJoin.put(loc, args.aliasMap.get(loc));
}
} else if (o instanceof IExpression) {
args.sb.append(generateExpression(args.fillExp((IExpression) o)));
if (DataUtils.expressionIsAggregate((IExpression) o)) {
args.doGroupBy = true;
} else {
// analyse IData
IExpression exp = (IExpression) o;
Object[] objs = exp.expArgs();
for (Object obj : objs) {
if (obj instanceof IData) {
Location location = findEntity(((IData) obj).getEntity(), args);
List locList = location.getLocation();
locList.add(DataUtils.findFieldNameByIData((IData) obj));
Location loc = DataUtils.generateLocationAndFillMap(locList, args.aliasMap);
args.selectNonAggregationAliases.add(args.aliasMap.get(loc));
}
}
}
}
}
} else {
if (!args.notDistinctOrAlreadyDone) {
args.sb.append("DISTINCT ");
args.notDistinctOrAlreadyDone = true;
}
args.sb.append(entityAlias);
args.selectNonAggregationAliases.add(entityAlias);
}
args.generatingSelect = false;
args.sb.append(" FROM ").append(args.entityClass.getSimpleName()).append(" ").append(entityAlias);
generateJoinWhere(args); // where
generateGroupByHaving(args); // group by having
if (args.queryParameter != null) {
for (QueryParameterTypes type : args.queryParameter.parameters.keySet()) {
Object[] argsArr = args.queryParameter.parameters.get(type);
if (type == QueryParameterTypes.orderBy) {
args.sb.append(" ORDER BY ");
for (Object o : argsArr) {
OrderBase order = (OrderBase) o;
Location loc = findEntity(order.data.getEntity(), args);
Field f = DataUtils.findFieldByContainedEntity(order.data.getEntity(), args.entity);
args.sb.append(args.aliasMap.get(loc)).append(".").append(f.getName());
}
} else if (type != QueryParameterTypes.limit && type != QueryParameterTypes.top && type != QueryParameterTypes.distinct) {
throw new UnsupportedOperationException(type + " not supported");
}
}
}
return args.sb.toString();
}
/**
* 向Query填入额外信息,例如limit,top,以及填入需要填写的常量 constantMap) {
for (Integer i : constantMap.keySet()) {
query.setParameter(i, constantMap.get(i));
}
}
/**
* 初始化Args对象();
args.selectNonAggregationAliases = new ArrayList();
}
@Override
public En find(Class entityClass, Object pkValue) {
return entityManager.find(entityClass, pkValue);
}
/**
* 执行查询,注入实体并返回结果List 实体类型
* @return 查询的实体结果List
* @see JPQLDataAccess#initArgs(Args, Object, Where, QueryParameter)
* @see JPQLDataAccess#generateSelect(Args, boolean)
* @see EntityManager#createQuery(String)
* @see JPQLDataAccess#setParametersToQuery(Query, QueryParameter, ConstantMap)
*/
@SuppressWarnings("unchecked")
@Override
public List list(En entity, Where whereClause, QueryParameter parameter) {
Args args = new Args();
initArgs(args, entity, whereClause, parameter);
String selectQuery = generateSelect(args, false);
logger.debug("Generated JPQL Query is : {} ---- WITH PARAMETERS : {}", selectQuery, args.constantMap);
javax.persistence.Query query = entityManager.createQuery(selectQuery);
setParametersToQuery(query, parameter, args.constantMap);
return (List) query.getResultList();
}
/**
* 检查parameter,若为空则返回一个"查询所有非Iterable字段"的parameter.若不为空则直接返回
*
* @param entity 要查询的实体
* @param parameter 查询参数
* @return 非空的parameter
*/
private QueryParameterWithFocus validateQueryParameterWithFocus(Object entity, QueryParameterWithFocus parameter) {
if (parameter == null) {
try {
Focus focus = new Focus();
for (Field f : entity.getClass().getFields()) {
if (IData.class.isAssignableFrom(f.getType()) && !ParameterAggregate.class.isAssignableFrom(f.getType())) {
focus.focus((IData) f.get(entity));
}
}
parameter = new QueryParameterWithFocus(null, focus);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
return parameter;
}
/**
* 查询部分字段的查询的初始化
*
* @param args Args对象
* @param entity 要查询实体
* @param whereClause 查询条件
* @param parameter 查询参数
* @return 生成的查询语句
*/
private String mapInit(Args args, Object entity, Where whereClause, QueryParameterWithFocus parameter) {
initArgs(args, entity, whereClause, parameter);
return generateSelect(args, true);
}
/**
* 将JPA返回的List<Object[]>转化为List<Map<字段名,对象>>
*
* @param resultList JPA返回List
* @param parameter 查询参数
* @return 转换后的List<Map>
*/
private List> listToMap(List resultList, QueryParameterWithFocus parameter) {
List> list = new ArrayList>(resultList.size());
for (Object res : resultList) {
Map map = new LinkedHashMap();
if (res.getClass().isArray()) {
int i = 0;
for (String alias : parameter.focusMap.values()) {
map.put(alias, ((Object[]) res)[i]);
++i;
}
} else {
map.put(parameter.focusMap.values().iterator().next(), res);
}
list.add(map);
}
return list;
}
/**
* 执行查询,生成List<Map<字段名,对象>>形式的结果> projection(Object entity, Where whereClause, QueryParameterWithFocus parameter) {
Args args = new Args();
parameter = validateQueryParameterWithFocus(entity, parameter);
String selectQuery = mapInit(args, entity, whereClause, parameter);
logger.debug("Generated JPQL Query is : {} ---- WITH PARAMETERS : {}", selectQuery, args.constantMap);
javax.persistence.Query query = entityManager.createQuery(selectQuery);
setParametersToQuery(query, parameter, args.constantMap);
return listToMap(query.getResultList(), (QueryParameterWithFocus) args.queryParameter);
}
/**
* 初始化更新
