Hibernate的querybuilder

最新推荐文章于 2021-09-08 16:42:11 发布
最新推荐文章于 2021-09-08 16:42:11 发布
阅读量373 收藏
点赞数
分类专栏： HIBERNATE 文章标签： hibernate JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tonydark01/article/details/88341809
版权
Hibernate的querybuilder 


package net.esj.basic.dao.querybuilder;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import net.esj.basic.exception.MelonException;
import net.esj.basic.expression.formula.Formula;
import net.esj.basic.utils.Validators;
import net.esj.basic.utils.hibe.AndCriteria;
import net.esj.basic.utils.hibe.HiCriteria;
import net.esj.basic.utils.hibe.OrCriteria;
import net.esj.basic.utils.hibe.SymbolExpression;

import org.hibernate.FetchMode;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.util.Assert;

public class HibernateQueryBuilder<T> implements QueryBuilder<T>, Serializable,
		Cloneable {

	/**
	 * 
	 */
	private static final long serialVersionUID = -2175149119127080340L;

	private DetachedCriteria root = null;

	private Map<String, DetachedCriteria> subCri = new HashMap<String, DetachedCriteria>();

	private Class<T> clazz = null;

	private List<HiCriteria> hiCriterias = new ArrayList<HiCriteria>();

	private HibernateQueryBuilder(Class<T> clazz) {
		this.clazz = clazz;
		root = DetachedCriteria.forClass(clazz);
	}

	@Override
	public HibernateQueryBuilder<T> clone() {
		HibernateQueryBuilder<T> qb = null;
		try {
			qb = (HibernateQueryBuilder<T>) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return qb;
	}

	@Override
	public QueryBuilder<T> addCriterion(Criterion criterion) {
		root.add(criterion);
		return this;
	}

	@Override
	public QueryBuilder<T> allEq(Map propertyNameValues) {
		Assert.notNull(propertyNameValues, "传值不能为空！");
		root.add(Restrictions.allEq(propertyNameValues));
		return this;
	}

	@Override
	public QueryBuilder<T> between(String propertyName, Object lo, Object hi) {
		Assert.notNull(lo, "传值不能为空！");
		Assert.notNull(hi, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.between(propertyName, lo, hi));
		return this;
	}

	@Override
	public QueryBuilder<T> eq(String propertyName, Object value) {
		Assert.notNull(value, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.eq(cri.getPropertyName(), value));
		return this;
	}

	@Override
	public QueryBuilder<T> ge(String propertyName, Object value) {
		Assert.notNull(value, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.ge(cri.getPropertyName(), value));
		return this;
	}

	@Override
	public DetachedCriteria getDetachedCriteria() {
		return root;
	}

	@Override
	public QueryBuilder<T> gt(String propertyName, Object value) {
		Assert.notNull(value, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.gt(cri.getPropertyName(), value));
		return this;
	}

	@Override
	public QueryBuilder<T> ilike(String propertyName, String value,
			MatchMode matchMode) {
		Assert.notNull(value, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(
				Restrictions.ilike(cri.getPropertyName(), value, matchMode));
		return this;
	}

	@Override
	public QueryBuilder<T> ilike(String propertyName, Object value) {
		Assert.notNull(value, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.ilike(cri.getPropertyName(), value));
		return this;
	}

	@Override
	public QueryBuilder<T> in(String propertyName, Object[] values) {
		Assert.notNull(values, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.in(cri.getPropertyName(), values));
		return this;
	}

	@Override
	public QueryBuilder<T> in(String propertyName, Collection<T> values) {
		Assert.notNull(values, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.in(cri.getPropertyName(), values));
		return this;
	}

	@Override
	public QueryBuilder<T> isNotNull(String propertyName) {
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.isNotNull(cri.getPropertyName()));
		return this;
	}

	@Override
	public QueryBuilder<T> isNull(String propertyName) {
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.isNull(cri.getPropertyName()));
		return this;
	}

	@Override
	public QueryBuilder<T> le(String propertyName, Object value) {
		Assert.notNull(value, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.le(cri.getPropertyName(), value));
		return this;
	}

	@Override
	public QueryBuilder<T> like(String propertyName, Object value) {
		Assert.notNull(value, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.like(cri.getPropertyName(), value));
		return this;
	}

	@Override
	public QueryBuilder<T> like(String propertyName, String value,
			MatchMode matchMode) {
		Assert.notNull(value, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(
				Restrictions.like(cri.getPropertyName(), value, matchMode));
		return this;
	}

	@Override
	public QueryBuilder<T> lt(String propertyName, Object value) {
		Assert.notNull(value, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.lt(cri.getPropertyName(), value));
		return this;
	}

	@Override
	public QueryBuilder<T> notEq(String propertyName, Object value) {
		Assert.notNull(value, "传值不能为空！");
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().add(Restrictions.ne(cri.getPropertyName(), value));
		return this;
	}

	@Override
	public QueryBuilder<T> leProperty(String propertyName,
			String otherPropertyName) {
		root.add(Restrictions.leProperty(propertyName, otherPropertyName));
		return this;
	}

	@Override
	public QueryBuilder<T> ltProperty(String propertyName,
			String otherPropertyName) {
		root.add(Restrictions.ltProperty(propertyName, otherPropertyName));
		return this;
	}

	@Override
	public QueryBuilder<T> eqProperty(String propertyName,
			String otherPropertyName) {
		root.add(Restrictions.eqProperty(propertyName, otherPropertyName));
		return this;
	}

	@Override
	public Class<T> getClazz() {
		return clazz;
	}

	@Override
	public QueryBuilder<T> OrderByAsc(String propertyName) {
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().addOrder(Order.asc(cri.getPropertyName()));
		return this;
	}

	@Override
	public QueryBuilder<T> OrderByDesc(String propertyName) {
		CriEntity cri = seekCriteria(propertyName,this);
		cri.getCri().addOrder(Order.desc(cri.getPropertyName()));
		return this;
	}

	@Override
	public QueryBuilder<T> fetch(String propertyTable, FetchMode fetchMode) {
		CriEntity entity = seekCriteria(propertyTable,this);
		entity.getCri().setFetchMode(entity.getPropertyName(), fetchMode);
		return this;
	}

	//TODO in test
	public QueryBuilder<T> hi(String propertyTable,HiCriteria hi){
		DetachedCriteria c =  createSub(propertyTable,this);
		c.add(hi.getCriterion());
		return this;
	}

	@Override
	public QueryBuilder<T> not(String propertyTable,HiCriteria hi) {
		DetachedCriteria c =  createSub(propertyTable,this);
		 c.add(Restrictions.not(hi.getCriterion()));
		 return this;
	}

	@Override
	public QueryBuilder<T> or(String propertyName,
			SymbolExpression expressions, Object[] objects) {
		SymbolExpression[] se = new SymbolExpression[objects.length]; 
		for(int i=0;i<se.length;i++){
			se[i] = expressions;
		}
		return or(propertyName, se, objects);
	}

	@Override
	public QueryBuilder<T> or(String propertyName,	SymbolExpression[] expressions, Object[] objects) {

		String[] proStrings = new String[expressions.length];
		for(int i=0;i<proStrings.length;i++){
			proStrings[i] = propertyName;
		}

		return or(proStrings, expressions, objects);
	}

	@Override
	public QueryBuilder<T> or(String[] propertyNames,	SymbolExpression[] expressions, Object[] objects) {
		if(propertyNames.length != expressions.length
				&& propertyNames.length !=objects.length){
			throw new MelonException("error propertyNames, expressions or objects ");
		}

		if(propertyNames.length==1){
			SymbolExpression.append(this,expressions[0],propertyNames[0],objects[0]);
			return this;
		}

		List<OrEntity> list = new ArrayList<OrEntity>();
		for(int i=0;i<propertyNames.length;i++){
			CriEntity cri = seekCriteria(propertyNames[i],this);
			boolean in = false;
			for(OrEntity or : list){
				if(or.equal(cri.getCri())){
					or.add(cri.getPropertyName(),expressions[i], objects[i]);
					in = true;
					break;
				}
			}
			if(!in){
				OrEntity e = new OrEntity();
				e.setCriteria(cri.getCri());
				e.add(cri.getPropertyName(),expressions[i], objects[i]);
				list.add(e);
			}
		}

		for(OrEntity or : list){
			HiCriteria criteria = OrCriteria.createMe();
			int i = 1;
			HiCriteria tmpCri = AndCriteria.createMe();
			SymbolExpression.append(tmpCri, or.getExpressions()[0], or.getPropertyNames()[0], or.getValues()[0]);

			while(or.getExpressions().length>i){
				HiCriteria hc = AndCriteria.createMe();
				SymbolExpression.append(hc, or.getExpressions()[i], or.getPropertyNames()[i], or.getValues()[i]);
				tmpCri = criteria.add(hc, tmpCri);
				i++;
			}
			or.getCriteria().add(criteria.getCriterion());
		}

		return this;
	}

	@Override
	public CriteriaSpecification createCriteria(String associationPath) {
		return root.createCriteria(associationPath);
	}

	@Override
	public DetachedCriteria getRoot() {
		return root;
	}

	@Override
	public Map<String, DetachedCriteria> getSubCri() {
		return subCri;
	}

	public final static DetachedCriteria createSub(String propertyTable,QueryBuilder qb){
		if(!Validators.isEmpty(propertyTable)){
			String[] tmps = propertyTable.split("\\.");
				String subkey = "";
				String property = "";
				DetachedCriteria parent = qb.getRoot();
				for (int i = 0; i < tmps.length; i++) {
					if (i == 0) {
						subkey = tmps[i];
						property = tmps[i];
					} else {
						subkey = subkey + "." + tmps[i];
						property = tmps[i];
					}
					DetachedCriteria c = (DetachedCriteria) qb.getSubCri().get(subkey);
					if (c == null) {
						DetachedCriteria sub = createSub(parent, property);
						parent = sub;
						qb.getSubCri().put(subkey, parent);
					} else {
						parent = c;
					}
				}
				return (DetachedCriteria) qb.getSubCri().get(subkey);
		}
		return qb.getRoot();
	}

	public final static DetachedCriteria createSub(DetachedCriteria parent, String name) {
		return parent.createCriteria(name);
	}

	/**
	 * 根据key获得criteria节点,若不存在则创建
	 * 
	 * @param key
	 * @return
	 */
	public static final CriEntity seekCriteria(String propertyName,QueryBuilder qb) {
		String[] tmps = propertyName.split("\\.");
		if (tmps.length == 1) {
			return new CriEntity(qb.getRoot(), propertyName);
		}
		String subkey = "";
		String property = "";
		DetachedCriteria parent = qb.getRoot();
		for (int i = 0; i < tmps.length; i++) {
			if (i == 0) {
				subkey = tmps[i];
				property = tmps[i];
			} else {
				subkey = subkey + "." + tmps[i];
				property = tmps[i];
			}
			if (i < tmps.length - 1) {
				DetachedCriteria c = (DetachedCriteria) qb.getSubCri().get(subkey);
				if (c == null) {
					DetachedCriteria sub = createSub(parent, property);
					parent = sub;
					qb.getSubCri().put(subkey, parent);
				} else {
					parent = c;
				}
			}
		}
		return new CriEntity(parent, property);
	}

	public static <E> HibernateQueryBuilder forClass(Class<E> clazz) {
		return new HibernateQueryBuilder(clazz);
	}

	public static class CriEntity {
		private DetachedCriteria cri;
		private String propertyName;

		public CriEntity(DetachedCriteria cri, String propertyName) {
			super();
			this.cri = cri;
			this.propertyName = propertyName;
		}

		public DetachedCriteria getCri() {
			return cri;
		}

		public void setCri(DetachedCriteria cri) {
			this.cri = cri;
		}

		public String getPropertyName() {
			return propertyName;
		}

		public void setPropertyName(String propertyName) {
			this.propertyName = propertyName;
		}
	}

	private static class OrEntity{
		private DetachedCriteria criteria;
		private SymbolExpression[] expressions;
		private Object[] values;
		private String[] propertyNames;

		public DetachedCriteria getCriteria() {
			return criteria;
		}
		public void setCriteria(DetachedCriteria criteria) {
			this.criteria = criteria;
		}
		public SymbolExpression[] getExpressions() {
			return expressions;
		}
		public Object[] getValues() {
			return values;
		}
		public String[] getPropertyNames() {
			return propertyNames;
		}
		public void add(String propertyName,SymbolExpression expression,Object obj){
			if(expressions==null){
				expressions = new SymbolExpression[1];
				expressions[0] = expression;
				values = new Object[1];
				values[0] = obj;
				propertyNames = new String[1];
				propertyNames[0] = propertyName;
			}else{
				int len = expressions.length;
				SymbolExpression[] tmp = new SymbolExpression[len + 1];
				System.arraycopy(expressions, 0, tmp, 0, len);
				tmp[len] = expression;
				expressions = tmp;

				int len2 = values.length;
				Object[] tmp2 = new Object[len2 + 1];
				System.arraycopy(values, 0, tmp2, 0, len2);
				tmp2[len2] = obj;
				values = tmp2;

				int len3 = propertyNames.length;
				String[] tmp3 = new String[len3 + 1];
				System.arraycopy(propertyNames, 0, tmp3, 0, len3);
				tmp3[len3] = propertyName;
				propertyNames = tmp3;
			}
		}

		public boolean equal(DetachedCriteria cri){
			return criteria == cri;
		}
	}

}



支持使用方法：
entity：
class Foo{
String id;
String name;
boo b; //在foo中做many-one映射

setter& getter
}

class boo{
String id;
String key;

setter&getter
}

QueryBuilder<Foo> qb = HibernateQueryBuilder.forClass(Foo.class);
qb.eq("name","123"); //查询foo中name是123的数据
qb.in({"id","name","b.id"},{SymbolExpression.EQUAL,SymbolExpression.LIKE,SymbolExpression.LIKE},{"1","2","3"});
//查询 id为1或name为2或left join b的id为3 的数据

qb.eq("b.name","3");
//SELECT .... FROM Foo left join Boo WHERE b.id = f.id AND b.name='3
三斤牛仔
关注
专栏目录
SQLib：Criteria Builder和Hibernate Query Builder的更简单和自定义的实现
02-17
SQLib：Criteria Builder和Hibernate Query Builder的更简单和自定义的实现
HibernateCRUD基础框架(2)-HQL语句构造器(HqlQueryBuilder,HqlUpdateBuilder)
放眼长期，稳中求进；知行合一，日拱一卒
12-30 269
上篇讲述了最基本的实体类，本篇接着讲述HQL语句构造器，包括查询和更新等。 优点：通过面向对象的方式构造HQL语句，更快捷，不需要手动拼接HQL。 缺点：封装可能降低性能，只能支持常用的和较为简单的HQL构造。 部分功能不完善，待开发。 1.HQL语句构造器 package cn.fansunion.hibernate.sql; import org.apache.commons...
hibernate search -- 多条件查询
cloud的技术积累
09-28 3534
hibernate search组合条件来实现多条件查询
[Hibernate Search] (3) 基础查询
不忘初心，好好沉淀
11-02 1万+
基础查询 目前我们只用到了基于关键字的查询，实际上Hibenrate Search DSL还提供了其它的查询方式，下面我们就来一探究竟。 映射API和查询API 对于映射API，我们可以通过使用Hibernate提供的注解来完成映射工作，同时我们也可以使用JPA提供的注解来完成。类似的，对于查询API，我们也可以从Hibernate和JPA提供的查询API中进行选择。每种方式都有
详解Java的Hibernate框架中的搜索工具的运用
09-03
在Java Web开发中，Hibernate是一个非常流行的ORM（对象关系映射）框架，它简化了数据库操作，使得开发者能够以面向对象的方式处理数据。SSH（Struts、Spring、Hibernate）是经典的三大框架组合，其中Hibernate负责...
23、Doctrine QueryBuilder对象介绍1
08-04
DQL是专门为Doctrine设计的一种查询语言，类似于Hibernate的HQL和Java Persistence API（JPA）的JPQL。与SQL不同，DQL处理的对象是实体（Entities），而不是表。在DQL中，我们可以用Model类的全名代替表名，并使用...
Hibernate Search配置及简单应用
03-28
**Hibernate Search配置及简单应用** Hibernate Search是Hibernate框架的一个扩展，它允许我们在应用程序中实现全文检索功能，使得数据库中的数据可以被快速、高效地搜索。这个功能尤其在处理大量文本数据时非常...
queryBuilder
最新发布
06-13
这种设计常见于ORM（Object-Relational Mapping）框架中，如Hibernate、Laravel Eloquent等。 例如，在Laravel Eloquent中[^4]，你可以这样使用QueryBuilder： ```php // 假设有一个User模型 $users = User::query...
hibernate-search-5.5.1.Final-dist.zip
12-10
《Hibernate Search 5.5.1.Final：全面解析企业级数据检索的利器》 Hibernate Search，作为Hibernate ORM的一个扩展，提供了在Java应用中进行全文搜索和复杂索引的能力。这个压缩包“hibernate-search-5.5.1.Final-...
Hibernate中通过HQL/JPQL查询的方式实现动态数据获取
成长的足迹
07-27 3099
1. JPQL查询 Employee employee = entityManager.createQuery( "select e " + "from Employee e " + "left join fetch e.projects " + "where " + " e.username = :username and " + "
QueryBuilder简单查询
热门推荐
S-H_A-N
10-18 4万+
1.matchAllQuery() matchAllQuery()方法用来匹配全部文档 public class QueryTest { public static void main(String[] args) { //创建对象，设置集群名称和IP地址 ElasticsearchUtils es = new ElasticsearchUtils(
hibernate中的HQL详解（实例）
ziji3810111的博客
06-12 549
本例模仿部门与员工之间来进行HQL的各种查询，一共有两张表，一张部门表，一张员工表，下面是具体查询代码： 1.Junit测试 [java] view plain copy package cn.itcast.a_query;    import org.hibernate.Query;  import org.hibernate.SessionFactory;  i
HibernateSearch
wenyilu的博客
04-09 4732
创建实体类 既然目的是为了展示软件应用，那么首当其冲的实体类就是App类了，现在我们将它定义成下面这样，拥有4个字段： id：主键信息name：App的名字description：App的介绍image：App图片的链接 @Entity public class App {     @Id     @GeneratedValue     private Long
spring中进行es查询，使用QueryBuilders构建各类条件查询
Koikoi12的博客
09-08 7983
首先导入maven依赖 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-elasticsearch</artifactId> <version>4.0.0.RELEASE</version> </dependency> 查询所有 //搜索全部文档 QueryBuilde
Spring Boot进阶(31)：时间范围查询不再困难！使用QueryBuilders进行组合查询，轻松操作Elasticsearch
**My Coding Family**
01-03 3万+
Elasticsearch基本操作之使用QueryBuilders进行范围时间组合查询，一文教会你。
java hibernate 条件,JAVA Hibernate 条件查询 Criteria
weixin_29355377的博客
03-11 149
{s = HibernateUtil.getSession(); // 获取hibernate链接Criteria c = s.createCriteria(User.class); //创建一个 criteria 对象， 引入类对象。c.add(Restrictions.eq("name",name); //增加约束，eq为 equal ，判断该列中是否有与name值相同的数据。//可以增加多条...
Hibernate Search(基于version3.4)--第五章Querying
蓝色工作区
06-27 258
Querying   Hibernate Search的第二个很重要的能力是运行Lucene queries并通过Hibernate session获得受管理的实体。search在提供了Lucene强大的功能之外还保持着Hibernate的编程模式（给Hibernate典型的search机制提供另外的dimension：HQL,Criteria query,native SQL query） ...
Hibernate实现模糊查询的方法
maguanghui_2012的专栏
03-19 3683
大家都知道使用本地SQL进行模糊查询用关键字 LIKE 对于在hibernate里怎么实现呢？ 一、绑定参数法： Sql代码 Session session=HibernateUtil.getSessionFactory ().getCurrentSession(); session.beginTransaction(); String strSQL="f
Hibernate 实战指南
"Hibernate In Action" 《Hibernate In Action》是一本专为深入理解并熟练应用Hibernate框架而编写的书籍。Hibernate是Java开发中的一个流行对象关系映射（ORM）框架，它简化了数据库与应用程序之间的交互，使...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值