Hibernate结合JPA编写通用泛型多条件查询

项目中使用Hibernate和JPA对数据库对象进行实例化，但是生成的方法不支持多条件查询。而如果针对每一个数据库对象进行多条件查询编码，则会变得很麻烦，而且一旦以后发生表结构发生变化，这些方法可能还需要进行重新编码。所以考虑编写一个方法可以对数据库对象进行多条件查询，并返回泛型对象，这样就可以方便使用。具体实现思路如下：

第一步：编写数据库查询参数对象，此部分包含两个，一个是查询实体名称（QueryCondition.java），一个是数据库查询条件对象（QueryParameter.java）。

数据库查询条件对象（QueryParameter.java）包含三个参数，分别为参数名、参数值、查询条件表达式

package com.imstudio.jpa;
public class QueryParameter {

	public enum QueryOperateType {
		Equal, CharIn
	}

	public String ParameterName;
	public Object ParameterValue;
	public QueryOperateType ParameterType;

	public QueryParameter() {

	}

	public QueryParameter(String parameterName, Object parameterValue,
			QueryOperateType parameterType) {
		this.ParameterName = parameterName;
		this.ParameterValue = parameterValue;
		this.ParameterType = parameterType;
	}

	public String getParameterName() {
		return ParameterName;
	}

	public QueryOperateType getParameterType() {
		return ParameterType;
	}

	public Object getParameterValue() {
		return ParameterValue;
	}

	public void setParameterName(String parameterName) {
		ParameterName = parameterName;
	}

	public void setParameterType(QueryOperateType parameterType) {
		this.ParameterType = parameterType;
	}

	public void setParameterValue(Object parameterValue) {
		ParameterValue = parameterValue;
	}

}

查询对象实体（QueryCondition.java）包含查询实体名称以及查询参数对象

package com.imstudio.jpa;
import java.util.ArrayList;
import java.util.List;

public class QueryCondition {
	public String ModelName;
	public List<QueryParameter> Parameters = new ArrayList<QueryParameter>();

	public QueryCondition() {

	}

	public QueryCondition(String modelName) {
		this.ModelName = modelName;
	}

	public QueryCondition(String modelName, List<QueryParameter> parameters) {
		this.ModelName = modelName;
		this.Parameters = parameters;
	}

	public void add(QueryParameter queryParameter) {
		this.Parameters.add(queryParameter);
	}

	public String getModelName() {
		return ModelName;
	}

	public List<QueryParameter> getParameters() {
		return Parameters;
	}

	public void setModelName(String modelName) {
		ModelName = modelName;
	}

	public void setParameters(List<QueryParameter> parameters) {
		Parameters = parameters;
	}
}

在完成上述两个实体对象之后就可以具体查询方法的编写了，在查询中使用到一个变量querySymbols，下述编码是从配置文件web.xml中获取，这里主要是为了在使用不同数据库的时候查询关键字标示符的修改。同时为了增加查询方法的通用性，查询返回数据这里定义为泛型。

package com.imstudio.jpa;import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import org.apache.struts2.ServletActionContext;
import com.imstudio.jpa.QueryParameter.QueryOperateType;

public class QueryDataAction {    
    public String errorCode;
    public QueryDataAction() {
    
    }    
    
    public QueryDataAction(String errorCode) {
            this.errorCode = errorCode;
    } 
       
    public String getErrorCode() {
            return errorCode;
    };

    @SuppressWarnings("unchecked")    
    public <T> List<T> queryByPropertys(QueryCondition queryCondition) {
        String querySymbols = ServletActionContext.getServletContext()
                .getInitParameter("QuerySymbols");
        StringBuffer sqlBuffer = new StringBuffer();
        sqlBuffer.append("select model \n");
        sqlBuffer.append("from " + queryCondition.ModelName + " as model \n");        
        boolean first = true;        
        for (int pi = 0; pi < queryCondition.Parameters.size(); pi++) {
             if (queryCondition.Parameters.get(pi).getParameterName() != null) {                                if (first) {
                    sqlBuffer.append("where ");
                    first = false;
                } else {
                    sqlBuffer.append("and ");
                }                
                if (queryCondition.Parameters.get(pi).getParameterType() == QueryOperateType.Equal) {
                    sqlBuffer.append("model."
                            + queryCondition.Parameters.get(pi)
                                    .getParameterName()                            + " = "
                            + querySymbols                            + queryCondition.Parameters.get(pi)
                                    .getParameterName() + " \n");
                } else if (queryCondition.Parameters.get(pi).getParameterType() == QueryOperateType.CharIn) {
                    sqlBuffer.append("InStr(model."
                            + queryCondition.Parameters.get(pi)
                                    .getParameterName()                            + " , "
                            + querySymbols                            + queryCondition.Parameters.get(pi)
                                    .getParameterName() + " ) > 0 \n");
                }
            }
        }
        List<T> list = new ArrayList<T>();        
        try {
            EntityManagerHelper.log(sqlBuffer.toString(), Level.INFO, null);
            EntityManager emEntityManager = EntityManagerHelper
                    .getEntityManager();
            Query queryObject = emEntityManager.createQuery(sqlBuffer
                    .toString());            
                    for (int li = 0; li < queryCondition.Parameters.size(); li++) {
                queryObject.setParameter(queryCondition.Parameters.get(li)
                        .getParameterName(), queryCondition.Parameters.get(li)
                        .getParameterValue());
            }
            list = queryObject.getResultList();
            emEntityManager.close();

        } catch (RuntimeException re) {
            errorCode += "CM000006";
            EntityManagerHelper.log("queryByPropertys error", Level.SEVERE, re);
            throw re;
        }        return list;
    }    
    
    public void setErrorCode(String errorCode) {
            this.errorCode = errorCode;
    }

}

Hibernate结合JPA编写通用泛型多条件查询