SessionFacade模式并不是GOF经典设计模式之一，它是一种EJB Session Bean应用在J2ee架构中的一种相对比较好的实践 。
大家对DAO一定不陌生，我们通常用Dao维护单个对象的持久化。然后再从Dao之上加一个Facade设计模式，即为Service层。这里说的Session Facade模式也和这种模式类似，只是Dao换成了EAO，EAO组件本身就是一种无状态的 Local EJB，它同样需要使用SessionBean作为其Facade，这个SessionBean可能是Local的也可以能是Remote的。
使用Session Facade模式的架构如下：
在我们现在做得项目中，这种模式的具体实现为：
ICommonEao规定了公共Eao的有方法，CommonEaoImpl是它的实现。
IBusinessEao是针对具体模块的Eao接口，它继承自公共Eao，同时又添加了自己特有的方法。
BusinessEaoImpl是IBusinessEao的具体实现，它必须继承CommonEaoImpl。
整个项目中会有多个类似BusinessEaoImpl的组件，供上层SessionBean组合，来实现业务逻辑。上层SessionBean可看做外观层，可以是Remote的，也可以是Local的，依具体业务而定。
这里给出公共Eao的实现，其他的要根据自己的系统而定。
package ejb.common.eao;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import javax.ejb.Local;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import ejb.common.eao.ICommonEao;
/**
* 操作数据库的基接口的实现类
*
* @author
*/
@Stateless(name = "common_EaoBean")
@Local
public class CommonEaoImpl implements ICommonEao {
@PersistenceContext(unitName = "EjbPersistenceUnit")
private EntityManager em;
/**
* 查询不带参数的原生SQL
*
* @param sql
* 原生SQL
* @return 记录
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> T getByNativeSQLQuery(String sql) {
Query query = em.createNativeQuery(sql);
T obj = null;
List<T> listResult = (List<T>) query.getResultList();
if (listResult.size() != 0) {
obj = (T) listResult.get(0);
}
return obj;
}
/**
* 查询带参数的原生SQL
*
* @param sql
* 原生SQL
* @param values
* 参数数组
* @return 记录
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> T getByNativeSQLQuery(String sql, Object[] values) {
Query query = em.createNativeQuery(sql);
T obj = null;
if (values != null && values.length != 0) {
for (int i = 0; i < values.length; i++) {
query.setParameter(i + 1, values[i]);
}
List<T> listResult = (List<T>) query.getResultList();
if (listResult.size() != 0) {
obj = (T) listResult.get(0);
}
} else {
List<T> listResult = (List<T>) query.getResultList();
if (listResult.size() != 0) {
obj = (T) listResult.get(0);
}
}
return obj;
}
/**
* 查询不带参数的原生SQL,并且把查询的结果封装成实体
*
* @param sql
* 原生SQL
* @param entityClass
* 实体
* @return 实体
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> T getByNativeSQLQuery(String sql, Class<T> entityClass) {
Query query = em.createNativeQuery(sql, entityClass);
T obj = null;
List<T> listResult = (List<T>) query.getResultList();
if (listResult.size() != 0) {
obj = (T) listResult.get(0);
}
return obj;
}
/**
* 查询带参数的原生SQL,并且把查询的结果封装成实体
*
* @param sql
* 原生SQL
* @param entityClass
* 实体
* @return 实体
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> T getByNativeSQLQuery(String sql, Object[] values,
Class<T> entityClass) {
Query query = em.createNativeQuery(sql, entityClass);
T obj = null;
if (values != null && values.length != 0) {
for (int i = 0; i < values.length; i++) {
query.setParameter(i + 1, values[i]);
}
List<T> listResult = (List<T>) query.getResultList();
if (listResult.size() != 0) {
obj = (T) listResult.get(0);
}
} else {
List<T> listResult = (List<T>) query.getResultList();
if (listResult.size() != 0) {
obj = (T) listResult.get(0);
}
}
return obj;
}
/**
* 查询不带参数的原生SQL
*
* @param sql
* 原生SQL
* @return 记录集合
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultListByNativeSQLQuery(String sql) {
Query query = em.createNativeQuery(sql);
List<T> listResult = (List<T>) query.getResultList();
return listResult;
}
/**
* 查询带参数的原生SQL
*
* @param sql
* 原生SQL
* @param values
* 参数数组
* @return 记录集合
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultListByNativeSQLQuery(String sql, Object[] values) {
Query query = em.createNativeQuery(sql);
List<T> listResult = new ArrayList<T>();
if (values != null && values.length != 0) {
for (int i = 0; i < values.length; i++) {
query.setParameter(i + 1, values[i]);
}
listResult = (List<T>) query.getResultList();
} else {
listResult = (List<T>) query.getResultList();
}
return listResult;
}
/**
* 查询不带参数的原生SQL,并且把查询的结果封装成实体
*
* @param sql
* 原生SQL
* @param entityClass
* 实体
* @return 实体集合
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultListByNativeSQLQuery(String sql,
Class<T> entityClass) {
Query query = em.createNativeQuery(sql, entityClass);
List<T> listResult = (List<T>) query.getResultList();
return listResult;
}
/**
* 查询带参数的原生SQL,并且把查询的结果封装成实体
*
* @param sql
* 原生SQL
* @param entityClass
* 实体
* @return 实体集合
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultListByNativeSQLQuery(String sql,
Object[] values, Class<T> entityClass) {
Query query = em.createNativeQuery(sql, entityClass);
List<T> listResult = new ArrayList<T>();
if (values != null && values.length != 0) {
for (int i = 0; i < values.length; i++) {
query.setParameter(i + 1, values[i]);
}
listResult = (List<T>) query.getResultList();
} else {
listResult = (List<T>) query.getResultList();
}
return listResult;
}
/*********************************************************************************************
*
*
* 上面是执行原型sql的接口实现，下面是执行QL的接口实现
*
*
*********************************************************************************************/
/**
* 查找实体
*
* @param entityClass
* 实体类
* @param pk
* 主键
* @return 根据指定主键返回实体
* @author
*/
public <T> T get(Class<T> entityClass, Object pk) {
T obj = em.find(entityClass, pk);
return obj;
}
/**
* 根据相应的字段查询实体类
*
* @param entityClass
* 实体类
* @param fields
* 相应的字段数组
* @param args
* 字段对应的值
* @return 根据相应字段返回的实体
* @author
*/
@SuppressWarnings("unchecked")
public <T> T get(Class<T> entityClass, Object[] fields, Object... args) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from " + entityName + " as o "
+ buildWhereJpql(fields));
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
List<T> listResult = (List<T>) query.getResultList();
if (listResult.size() != 0) {
T obj = (T) listResult.get(0);
return obj;
}
return null;
}
/**
* 根据相应的字段查询实体类
*
* @param entityClass
* 实体类
* @param fields
* 相应的字段数组
* @param args
* 字段对应的值
* @return 根据相应字段返回的实体
* @author
*/
@SuppressWarnings("unchecked")
public <T> T getByLike(Class<T> entityClass, Object[] fields,
Object... args) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from " + entityName + " as o "
+ buildWhereJpqlByLike(fields));
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
List<T> listResult = (List<T>) query.getResultList();
if (listResult.size() != 0) {
T obj = (T) listResult.get(0);
return obj;
}
return null;
}
/**
* 保存实体
*
* @param entity
* 需要保存的实体
* @author
*/
public void save(Object entity) {
em.persist(entity);
}
/**
* 更新实体
*
* @param entity
* 需要更新的实体
* @author
*/
public void update(Object entity) {
em.merge(entity);
}
/**
* 更新方法
*
* @param entityClass
* 实体类
* @param setJpql
* 需要更新的字段，action传入的信息如下：o.name=?1 and o.password=?2
* @param whereJpql
* where查询条件，比如：where o.name=?3 or o.password=?4 or o.desc=?5
* @param args
* 参数值 注意：参数值，其中对应需要更新的字段，以及where查询条件
*/
public <T> void update(Class<T> entityClass, String setJpql,
String whereJpql, Object... args) {
String entityName = entityClass.getSimpleName();
// System.out.println("update "+entityName+ " as o set "
// +setJpql+" "+whereJpql);
// 拼接的字符串类似
// update User as o set o.name=1? where o.name=2?
Query query = em.createQuery("update " + entityName + " as o set "
+ setJpql + " " + whereJpql);
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
query.executeUpdate();
}
/**
* 更新方法
*
* @param entityClass
* 需要更新的实体类
* @param setFields
* 需要更新的字段数组，传入的信息如下：{name,id,functionId}
* @param whereFields
* 查询的条件数组， 传入的信息如下：{name,id,functionId}
* @param args
* 需要更新的字段数组和查询条件数组的参数值。
*/
public <T> void update(Class<T> entityClass, Object[] setFields,
Object[] whereFields, Object... args) {
String entityName = entityClass.getSimpleName();
System.out.println(entityName);
System.out.println("update " + entityName + " as o "
+ buildsetWhereJpql(setFields, whereFields));
Query query = em.createQuery("update " + entityName + " as o "
+ buildsetWhereJpql(setFields, whereFields));
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
query.executeUpdate();
}
/**
* 删除实体
*
* @param entityClass
* 需要删除的实体
* @param pk
* 需要删除的实体的主键
* @author
*/
public void delete(Class<?> entityClass, Object pk) {
em.remove(em.getReference(entityClass, pk));
}
/**
* 执行查询的方法
*
* @param entityClass
* 实体类
* @param whereJpql
* 指定查询返回的第一条记录
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param args
* 作为JPQL查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
public <T> List<T> getResultList(Class<T> entityClass, String whereJpql,
LinkedHashMap<String, String> orderBy, Object... args) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from " + entityName + " as o "
+ whereJpql + buildOrderby(orderBy));
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法
*
* @param entityClass
* 实体类
* @param fields
* 指定查询条件的字段数组
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param args
* 作为JPQL查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
public <T> List<T> getResultList(Class<T> entityClass, Object[] fields,
LinkedHashMap<String, String> orderBy, Object... args) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from " + entityName + " as o "
+ buildWhereJpql(fields) + buildOrderby(orderBy));
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法
*
* @param entityClass
* 实体类
* @param whereJpql
* 指定查询返回的第一条记录
* @param firstResult
* 指定查询返回的第一条记录
* @param maxResult
* 设置查询最多返回多少条记录
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param args
* 作为JPQL查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
public <T> List<T> getResultList(Class<T> entityClass, String whereJpql,
int firstResult, int maxResult,
LinkedHashMap<String, String> orderBy, Object... args) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from " + entityName + " as o "
+ whereJpql + buildOrderby(orderBy));
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
query.setMaxResults(maxResult).setFirstResult(firstResult);
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法
*
* @param entityClass
* 实体类
* @param fields
* 指定查询条件的字段数组
* @param firstResult
* 指定查询返回的第一条记录
* @param maxResult
* 设置查询最多返回多少条记录
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param args
* 作为JPQL查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
public <T> List<T> getResultList(Class<T> entityClass, Object[] fields,
int firstResult, int maxResult,
LinkedHashMap<String, String> orderBy, Object... args) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from " + entityName + " as o "
+ buildWhereJpql(fields) + buildOrderby(orderBy));
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
query.setMaxResults(maxResult).setFirstResult(firstResult);
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法
*
* @param entityClass
* 实体类
* @param notNullfields
* 指定查询条件的不是空的字段数组
* @param nullFields
* 指定查询条件的是空的字段数组
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param args
* 作为JPQL查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultList(Class<T> entityClass,
Object[] notNullfields, Object[] nullFields,
LinkedHashMap<String, String> orderBy, Object... notNullValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from "
+ entityName
+ " as o "
+ buildWhereJpqlByEqualsAndOtherIsNull(notNullfields,
nullFields) + buildOrderby(orderBy));
for (int i = 0; i < notNullValues.length; i++) {
query.setParameter(i + 1, notNullValues[i]);
}
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法[插入相等和不等的参数进行查询]
*
* @param entityClass
* 实体类
* @param equalFields
* 指定相等查询条件的字段数组
* @param notEqualFields
* 指定不相等查询条件的字段数组
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param equalValues
* 作为JPQL相等查询字符串的参数值
* @param notEqualValues
* 作为JPQL不等查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultList(Class<T> entityClass,
Object[] equalFields, Object[] notEqualFields,
LinkedHashMap<String, String> orderBy, Object[] equalValues,
Object... notEqualValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from "
+ entityName
+ " as o "
+ buildWhereJpqlByEqualsAndOtherNotEquals(equalFields,
notEqualFields) + buildOrderby(orderBy));
for (int i = 0; i < equalFields.length; i++) {
query.setParameter(i + 1, equalValues[i]);
}
for (int i = 0; i < notEqualFields.length; i++) {
query.setParameter(i + 1 + equalFields.length, notEqualValues[i]);
}
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法[传入模糊查询和不相等的参数值来查询]
*
* @param entityClass
* 实体类
* @param likeFields
* 指定模糊查询条件的字段数组
* @param notEqualFields
* 指定不相等查询条件的字段数组
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param likeValues
* 作为JPQL模糊查询字符串的参数值
* @param notEqualValues
* 作为JPQL不等查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultListByLike(Class<T> entityClass,
Object[] likeFields, Object[] notEqualFields,
LinkedHashMap<String, String> orderBy, Object[] likeValues,
Object... notEqualValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from "
+ entityName
+ " as o "
+ buildWhereJpqlByLikeAndOtherNotEquals(likeFields,
notEqualFields) + buildOrderby(orderBy));
for (int i = 0; i < likeFields.length; i++) {
query.setParameter(i + 1, likeValues[i]);
}
for (int i = 0; i < notEqualFields.length; i++) {
query.setParameter(i + 1 + likeFields.length, notEqualValues[i]);
}
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法[插入相等和不等的参数进行查询]
*
* @param entityClass
* 实体类
* @param equalFields
* 指定相等查询条件的字段数组
* @param notEqualFields
* 指定不相等查询条件的字段数组
* @param firstResult
* 指定查询返回的第一条记录
* @param maxResult
* 设置查询最多返回多少条记录
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param equalValues
* 作为JPQL相等查询字符串的参数值
* @param notEqualValues
* 作为JPQL不等查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultList(Class<T> entityClass,
Object[] equalFields, Object[] notEqualFields, int firstResult,
int maxResult, LinkedHashMap<String, String> orderBy,
Object[] equalValues, Object... notEqualValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from "
+ entityName
+ " as o "
+ buildWhereJpqlByEqualsAndOtherNotEquals(equalFields,
notEqualFields) + buildOrderby(orderBy));
for (int i = 0; i < equalFields.length; i++) {
query.setParameter(i + 1, equalValues[i]);
}
for (int i = 0; i < notEqualFields.length; i++) {
query.setParameter(i + 1 + equalFields.length, notEqualValues[i]);
}
query.setMaxResults(maxResult).setFirstResult(firstResult);
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法[传入模糊查询和不相等的参数值来查询]
*
* @param entityClass
* 实体类
* @param likeFields
* 指定模糊查询条件的字段数组
* @param notEqualFields
* 指定不相等查询条件的字段数组
* @param firstResult
* 指定查询返回的第一条记录
* @param maxResult
* 设置查询最多返回多少条记录
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param likeValues
* 作为JPQL模糊查询字符串的参数值
* @param notEqualValues
* 作为JPQL不等查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultListByLike(Class<T> entityClass,
Object[] likeFields, Object[] notEqualFields, int firstResult,
int maxResult, LinkedHashMap<String, String> orderBy,
Object[] likeValues, Object... notEqualValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from "
+ entityName
+ " as o "
+ buildWhereJpqlByLikeAndOtherNotEquals(likeFields,
notEqualFields) + buildOrderby(orderBy));
for (int i = 0; i < likeFields.length; i++) {
query.setParameter(i + 1, likeValues[i]);
}
for (int i = 0; i < notEqualFields.length; i++) {
query.setParameter(i + 1 + likeFields.length, notEqualValues[i]);
}
query.setMaxResults(maxResult).setFirstResult(firstResult);
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法
*
* @param entityClass
* 实体类
* @param fields
* 指定模糊查询条件的字段数组
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param args
* 作为JPQL查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
public <T> List<T> getResultListByLike(Class<T> entityClass,
Object[] fields, LinkedHashMap<String, String> orderBy,
Object... args) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from " + entityName + " as o "
+ buildWhereJpqlByLike(fields) + buildOrderby(orderBy));
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法
*
* @param entityClass
* 实体类
* @param fields
* 指定模糊查询条件的字段数组
* @param firstResult
* 指定查询返回的第一条记录
* @param maxResult
* 设置查询最多返回多少条记录
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param args
* 作为JPQL查询字符串的参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
public <T> List<T> getResultListByLike(Class<T> entityClass,
Object[] fields, int firstResult, int maxResult,
LinkedHashMap<String, String> orderBy, Object... args) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from " + entityName + " as o "
+ buildWhereJpqlByLike(fields) + buildOrderby(orderBy));
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
query.setMaxResults(maxResult).setFirstResult(firstResult);
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法
*
* @param entityClass
* 实体类
* @param likeFields
* 指定模糊查询条件的字段数组
* @param equalFields
* 指定相等的查询条件的字段数组
* @param firstResult
* 指定查询返回的第一条记录
* @param maxResult
* 设置查询最多返回多少条记录
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param equalValues
* 作为JPQL查询字符串的相等的参数值
* @param likeValues
* 作为JPQL查询字符串的模糊参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultListByLikeAndEquals(Class<T> entityClass,
Object[] likeFields, Object[] equalFields, int firstResult,
int maxResult, LinkedHashMap<String, String> orderBy,
Object[] equalValues, Object... likeValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from " + entityName + " as o "
+ buildWhereJpqlByLikeAndEqual(likeFields, equalFields)
+ buildOrderby(orderBy));
for (int i = 0; i < likeValues.length; i++) {
query.setParameter(i + 1, likeValues[i]);
}
for (int i = 0; i < equalValues.length; i++) {
query.setParameter(i + 1 + likeValues.length, equalValues[i]);
}
query.setMaxResults(maxResult).setFirstResult(firstResult);
return (List<T>) query.getResultList();
}
/**
* 执行查询的方法[用于判断某些具体参数是不是null的情况]
*
* @param entityClass
* 实体类
* @param likeFields
* 指定模糊查询条件的字段数组
* @param equalFields
* 指定相等的查询条件的字段数组
* @param firstResult
* 指定查询返回的第一条记录
* @param maxResult
* 设置查询最多返回多少条记录
* @param orderBy
* 用于排序，如果无须排序，该参数设为null，Map 对象的key为实体对象的字段名，value为ASC/DESC. 例如
* LinkedHashMap<String,String> orderBy=new
* LinkedHashMap<String,String>();
* orderBy.put("itemName","DESC");表明根据itemName降序排列
* 如果放入多个key-value值，则第一次放入的为首要排序关键字，第二次放入的为次要关键字...
* @param equalValues
* 作为JPQL查询字符串的相等的参数值
* @param likeValues
* 作为JPQL查询字符串的模糊参数值
* @return 返回查询得到的实体List
* @author
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<T> getResultListByLikeAndEquals(Class<T> entityClass,
Object[] likeFields, Object[] equalFields, int firstResult,
int maxResult, LinkedHashMap<String, String> orderBy,
Object... likeValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select o from " + entityName + " as o "
+ buildWhereJpqlByLikeAndEqualsIsNull(likeFields, equalFields)
+ buildOrderby(orderBy));
for (int i = 0; i < likeValues.length; i++) {
query.setParameter(i + 1, likeValues[i]);
}
query.setMaxResults(maxResult).setFirstResult(firstResult);
return (List<T>) query.getResultList();
}
/**
* 将hashmap中的数据拼成字符串
*
* @param orderBy
* LinkedHashMap对象，每个key-value为一个排序的条件
* @return 排序条件字符串
* @author
*/
private String buildOrderby(LinkedHashMap<String, String> orderBy) {
StringBuffer out = new StringBuffer("");
if (orderBy != null && orderBy.size() > 0) {
out.append(" order by ");
for (String key : orderBy.keySet()) {
out.append("o." + key + " " + orderBy.get(key));
out.append(",");
}
out.deleteCharAt(out.length() - 1);
}
return out.toString();
}
/**
* 拼接查询字符串
*
* @param fields
* 相应的字段数组
* @return 拼接查询的字符串
* @author
*/
private String buildWhereJpql(Object[] fields) {
StringBuffer out = new StringBuffer("");
if (fields != null && fields.length > 0) {
out.append(" where ");
for (int index = 0; index < fields.length; index++) {
out.append(" o." + fields[index] + "=?" + (index + 1) + " ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
}
return out.toString();
}
/**
* 拼接查询字符串[用于判断所传入的值是否为null]
*
* @param fields
* 相应的字段数组
* @return 拼接查询的字符串
* @author
*/
private String buildWhereJpqlIsNull(Object[] fields) {
StringBuffer out = new StringBuffer("");
if (fields != null && fields.length > 0) {
out.append(" where ");
for (int index = 0; index < fields.length; index++) {
out.append(" o." + fields[index] + " is null ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
}
return out.toString();
}
/**
* 拼接set字段和where字段的hql语句
*
* @param fields1
* set字段
* @param fields2
* where字段
* @return
*/
private String buildsetWhereJpql(Object[] fields1, Object[] fields2) {
StringBuffer out = new StringBuffer("");
if (fields1 != null && fields1.length > 0) {
out.append(" set ");
for (int index = 0; index < fields1.length; index++) {
out.append(" o." + fields1[index] + "=?" + (index + 1) + " ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
out.append(" where ");
for (int index = 0; index < (fields2.length); index++) {
out.append(" o." + fields2[index] + "=?"
+ (fields1.length + (index + 1)) + " ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
}
return out.toString();
}
/**
* 拼接查询字符串
*
* @param fields
* 相应的字段数组
* @return 拼接查询的字符串
* @author
*/
private String buildWhereJpqlByLike(Object[] fields) {
StringBuffer out = new StringBuffer("");
if (fields != null && fields.length > 0) {
out.append(" where ");
for (int index = 0; index < fields.length; index++) {
out.append(" o." + fields[index] + " like ?" + (index + 1)
+ " ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
}
return out.toString();
}
/**
* 拼接查询字符串
*
* @param notEquals
* 相应的字段数组
* @return 拼接查询的字符串
* @author
*/
private String buildWhereJpqlNotEqual(Object[] notEquals) {
StringBuffer out = new StringBuffer("");
if (notEquals != null && notEquals.length > 0) {
out.append(" where ");
for (int index = 0; index < notEquals.length; index++) {
out.append(" o." + notEquals[index] + "<>?" + (index + 1) + " ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
}
return out.toString();
}
/**
* 拼接查询字符串[用于判断某些参数相似有些参数不等情况]
*
* @param likeFields
* 模糊字段数组
* @param notEqualFields
* 不具体字段数组
* @return 拼接查询的字符串
* @author
*/
private String buildWhereJpqlByLikeAndOtherNotEquals(Object[] likeFields,
Object[] notEqualFields) {
String result = "";
if ((likeFields != null && likeFields.length > 0)
&& (notEqualFields == null || notEqualFields.length == 0)) {
result = buildWhereJpqlByLike(likeFields);
} else if ((likeFields == null || likeFields.length == 0)
&& (notEqualFields != null && notEqualFields.length > 0)) {
result = buildWhereJpqlNotEqual(notEqualFields);
} else if ((likeFields == null || likeFields.length == 0)
&& (notEqualFields == null || notEqualFields.length == 0)) {
result = "";
} else {
StringBuffer out = new StringBuffer("");
out.append(" where ");
for (int index = 0; index < likeFields.length; index++) {
out.append(" o." + likeFields[index] + " like ?" + (index + 1)
+ " ");
out.append("and");
}
for (int index = 0; index < notEqualFields.length; index++) {
out.append(" o." + notEqualFields[index] + " <> ?"
+ (index + 1 + likeFields.length) + " ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
result = out.toString();
}
return result;
}
/**
* 拼接查询字符串[用于判断某些参数相等有些参数不想等的情况]
*
* @param equalFields
* 相等字段数组
* @param notEqualFields
* 不相等字段数组
* @return 拼接查询的字符串
* @author
*/
private String buildWhereJpqlByEqualsAndOtherNotEquals(
Object[] equalFields, Object[] notEqualFields) {
String result = "";
if ((equalFields != null && equalFields.length > 0)
&& (notEqualFields == null || notEqualFields.length == 0)) {
result = buildWhereJpql(equalFields);
} else if ((equalFields == null || equalFields.length == 0)
&& (notEqualFields != null && notEqualFields.length > 0)) {
result = buildWhereJpqlNotEqual(notEqualFields);
} else if ((equalFields == null || equalFields.length == 0)
&& (notEqualFields == null || notEqualFields.length == 0)) {
result = "";
} else {
StringBuffer out = new StringBuffer("");
out.append(" where ");
for (int index = 0; index < equalFields.length; index++) {
out.append(" o." + equalFields[index] + " = ?" + (index + 1)
+ " ");
out.append("and");
}
for (int index = 0; index < notEqualFields.length; index++) {
out.append(" o." + notEqualFields[index] + " <> ?"
+ (index + 1 + equalFields.length) + " ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
result = out.toString();
}
return result;
}
/**
* 拼接查询字符串[用于判断某些具体参数是不是null的情况]
*
* @param likeFields
* 模糊字段数组
* @param equalFields
* 具体字段数组
* @return 拼接查询的字符串
* @author
*/
private String buildWhereJpqlByLikeAndEqualsIsNull(Object[] likeFields,
Object[] equalFields) {
String result = "";
if ((likeFields != null && likeFields.length > 0)
&& (equalFields == null || equalFields.length == 0)) {
result = buildWhereJpqlByLike(likeFields);
} else if ((likeFields == null || likeFields.length == 0)
&& (equalFields != null && equalFields.length > 0)) {
result = buildWhereJpqlIsNull(equalFields);
} else if ((equalFields == null || equalFields.length == 0)
&& (likeFields == null || likeFields.length == 0)) {
result = "";
} else {
StringBuffer out = new StringBuffer("");
out.append(" where ");
for (int index = 0; index < likeFields.length; index++) {
out.append(" o." + likeFields[index] + " like ?" + (index + 1)
+ " ");
out.append("and");
}
for (int index = 0; index < equalFields.length; index++) {
out.append(" o." + equalFields[index] + " is null ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
result = out.toString();
}
return result;
}
/**
* 拼接查询字符串[某些参数不为null，某些参数为null的情况]
*
* @param notNullfields
* 不为空的字段数组
*
* @param nullFields
* 为空的字段数组
* @return 拼接查询的字符串
* @author
*/
private String buildWhereJpqlByEqualsAndOtherIsNull(Object[] notNullfields,
Object[] nullFields) {
String result = "";
if ((notNullfields != null && notNullfields.length > 0)
&& (nullFields == null || nullFields.length == 0)) {
result = buildWhereJpql(notNullfields);
} else if ((notNullfields == null || notNullfields.length == 0)
&& (nullFields != null && nullFields.length > 0)) {
result = buildWhereJpqlIsNull(nullFields);
} else if ((notNullfields == null || notNullfields.length == 0)
&& (nullFields == null || nullFields.length == 0)) {
result = "";
} else {
StringBuffer out = new StringBuffer("");
out.append(" where ");
for (int index = 0; index < notNullfields.length; index++) {
out.append(" o." + notNullfields[index] + "=?" + (index + 1)
+ " ");
out.append("and");
}
for (int index = 0; index < nullFields.length; index++) {
out.append(" o." + nullFields[index] + " is null ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
result = out.toString();
}
return result;
}
/**
* 拼接查询字符串
*
* @param fields
* 相应的字段数组
* @return 拼接查询的字符串
* @author
*/
private String buildWhereJpqlByLikeAndEqual(Object[] likeFields,
Object[] equalFields) {
String result = "";
if ((likeFields != null && likeFields.length > 0)
&& (equalFields == null || equalFields.length == 0)) {
result = buildWhereJpqlByLike(likeFields);
} else if ((likeFields == null || likeFields.length == 0)
&& (equalFields != null && equalFields.length > 0)) {
result = buildWhereJpql(equalFields);
} else if ((equalFields == null || equalFields.length == 0)
&& (likeFields == null || likeFields.length == 0)) {
result = "";
} else {
StringBuffer out = new StringBuffer("");
out.append(" where ");
for (int index = 0; index < likeFields.length; index++) {
out.append(" o." + likeFields[index] + " like ?" + (index + 1)
+ " ");
out.append("and");
}
for (int index = 0; index < equalFields.length; index++) {
out.append(" o." + equalFields[index] + "=?"
+ (index + 1 + likeFields.length) + " ");
out.append("and");
}
out.delete(out.length() - 3, out.length());
result = out.toString();
}
return result;
}
/**
* 查询数据总数
*
* @param entityClass
* 实体类
* @param whereJpql
* 查询条件
* @param args
* 查询参数
* @return 数据总数
* @author
*/
public <T> Long getTotalCount(Class<T> entityClass, Object[] fields,
Object... args) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select count(o) from " + entityName
+ " as o " + buildWhereJpqlByLike(fields));
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
return (Long) query.getResultList().get(0);
}
/**
* 查询数据总数
*
* @param entityClass
* 实体类
* @param whereJpql
* 查询条件
* @param args
* 查询参数
* @return 数据总数
* @author
*/
@Override
public <T> Long getTotalCount(Class<T> entityClass, String whereJpql,
Object... args) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select count(o) from " + entityName
+ " as o " + whereJpql);
for (int i = 0; i < args.length; i++) {
query.setParameter(i + 1, args[i]);
}
return (Long) query.getResultList().get(0);
}
/**
* 获得查询数据总数
*
* @param entityClass
* 实体类
* @param likeFields
* 模糊查询条件
* @param equalFields
* 等于查询条件
* @param equalValues
* 等于查询的值
* @param likeValues
* 模糊查询的值
* @return 数据条数
* @author
*/
@Override
public <T> Long getTotalCount(Class<T> entityClass, Object[] likeFields,
Object[] equalFields, Object[] equalValues, Object... likeValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select count(o) from " + entityName
+ " as o "
+ buildWhereJpqlByLikeAndEqual(likeFields, equalFields));
for (int i = 0; i < likeValues.length; i++) {
query.setParameter(i + 1, likeValues[i]);
}
for (int i = 0; i < equalValues.length; i++) {
query.setParameter(i + 1 + likeValues.length, equalValues[i]);
}
return (Long) query.getResultList().get(0);
}
/**
* 获得查询数据总数[用于判断某些具体参数是不是null的情况]
*
* @param entityClass
* 实体类
* @param likeFields
* 模糊查询条件
* @param equalFields
* 等于查询条件
* @param equalValues
* 等于查询的值
* @param likeValues
* 模糊查询的值
* @return 数据条数
* @author
*/
@Override
public <T> Long getTotalCount(Class<T> entityClass, Object[] likeFields,
Object[] equalFields, Object... likeValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select count(o) from " + entityName
+ " as o "
+ buildWhereJpqlByLikeAndEqualsIsNull(likeFields, equalFields));
for (int i = 0; i < likeValues.length; i++) {
query.setParameter(i + 1, likeValues[i]);
}
return (Long) query.getResultList().get(0);
}
/**
* 获得查询数据总数[用于判断某些参数相等有些参数不想等的情况]
*
* @param entityClass
* 实体类
* @param equalFields
* 查询相等条件
* @param notEqualFields
* 不等于查询条件
* @param equalValues
* 等于查询的值
* @param notEqualValues
* 不等于查询的值
* @return 数据条数
* @author
*/
@Override
public <T> Long getTotalCountByEqualAndNotEqual(Class<T> entityClass,
Object[] equalFields, Object[] notEqualFields,
Object[] equalValues, Object... notEqualValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select count(o) from "
+ entityName
+ " as o "
+ buildWhereJpqlByEqualsAndOtherNotEquals(equalFields,
notEqualFields));
for (int i = 0; i < equalValues.length; i++) {
query.setParameter(i + 1, equalValues[i]);
}
for (int i = 0; i < notEqualValues.length; i++) {
query.setParameter(i + 1 + equalValues.length, notEqualValues[i]);
}
return (Long) query.getResultList().get(0);
}
/**
* 获得查询数据总数[用于判断某些参数相似某些参数不等的情况]
*
* @param entityClass
* 实体类
* @param likeFields
* 模糊查询条件
* @param notEqualFields
* 不等于查询条件
* @param likeValues
* 模糊查询的值
* @param notEqualValues
* 不等于查询的值
* @return 数据条数
* @author
*/
@Override
public <T> Long getTotalCountByLikeAndNotEqual(Class<T> entityClass,
Object[] likeFields, Object[] notEqualFields, Object[] likeValues,
Object[] notEqualValues) {
String entityName = entityClass.getSimpleName();
Query query = em.createQuery("select count(o) from "
+ entityName
+ " as o "
+ buildWhereJpqlByLikeAndOtherNotEquals(likeFields,
notEqualFields));
for (int i = 0; i < likeValues.length; i++) {
query.setParameter(i + 1, likeValues[i]);
}
for (int i = 0; i < notEqualValues.length; i++) {
query.setParameter(i + 1 + likeValues.length, notEqualValues[i]);
}
return (Long) query.getResultList().get(0);
}
}
扫一扫
2466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
