Java QueryBuilder类代码示例

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
@Override
public FullTextQuery getFTSQuery(String filterText, final Class<?> entityType, Integer maxResults, String... fields) {

	// entityManager para busquedas de tipo FTS
	final FullTextEntityManager fullTextEntityManager = org.hibernate.search.jpa.Search.getFullTextEntityManager(entityManager);

	// se crea el query usando Hibernate Search query DSL
	final QueryBuilder queryBuilder = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(entityType).get();

	// se crea el query sobre los campos indicados
	final Query query = queryBuilder.keyword().onFields(fields).matching(filterText.trim()).createQuery();

	// se enmascara el query de Lucene en uno de Hibernate
	final FullTextQuery jpaQuery = fullTextEntityManager.createFullTextQuery(query, entityType);

	// se define la cantidad maxima de resultados si es mayor a cero
	if (maxResults > 0) {
		jpaQuery.setMaxResults(maxResults);
	}
	// se retorna el query listo para ejecución o para inyeccion de criterias
	return jpaQuery;
}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
@Transactional
@Override
public Page<Book> search(String query, Pageable page) {
	FullTextEntityManager manager = this.getFullTextEntityManager();

	QueryBuilder builder = manager.getSearchFactory().buildQueryBuilder().forEntity(Book.class).get();

	Query luceneQuery = builder.keyword().fuzzy()
			.onFields("author", "title", "lang", "description", "isbn", "genre", "location").matching(query)
			.createQuery();

	FullTextQuery q = manager.createFullTextQuery(luceneQuery, Book.class);
	q.setProjection(FullTextQuery.THIS, FullTextQuery.SCORE);

	long total = q.getResultSize();
	q.setFirstResult(page.getOffset()).setMaxResults(page.getPageSize());

	@SuppressWarnings("unchecked")
	List<Object[]> result = q.getResultList();
	List<Book> fine = new LinkedList<>();
	for (Object[] i : result) {
		fine.add((Book) i[0]);
	}
	return new PageImpl<>(fine, page, total);
}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
@Override
public FullTextQuery getFTSWildcardQuery(String filterText, final Class<?> entityType, Integer maxResults, String field) {

	// entityManager para busquedas de tipo FTS
	final FullTextEntityManager fullTextEntityManager = org.hibernate.search.jpa.Search.getFullTextEntityManager(entityManager);

	// se crea el query usando Hibernate Search query DSL
	final QueryBuilder queryBuilder = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(entityType).get();

	// se crea el query sobre los campos indicados
	final Query query = queryBuilder.phrase().onField(field).sentence(filterText.trim()).createQuery();

	// se enmascara el query de Lucene en uno de Hibernate
	final FullTextQuery jpaQuery = fullTextEntityManager.createFullTextQuery(query, entityType);

	// se define la cantidad maxima de resultados si es mayor a cero
	if (maxResults > 0) {
		jpaQuery.setMaxResults(maxResults);
	}
	// se retorna el query listo para ejecución o para inyeccion de criterias
	return jpaQuery;
}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public List<PostPO> searchByTag(Paging paigng, String tag) {
	FullTextSession fullTextSession = Search.getFullTextSession(super.session());
    SearchFactory sf = fullTextSession.getSearchFactory();
    QueryBuilder qb = sf.buildQueryBuilder().forEntity(PostPO.class).get();
    org.apache.lucene.search.Query luceneQuery  = qb.phrase().onField("tags").sentence(tag).createQuery();

    FullTextQuery query = fullTextSession.createFullTextQuery(luceneQuery);
    query.setFirstResult(paigng.getFirstResult());
    query.setMaxResults(paigng.getMaxResults());

	Sort sort = new Sort(new SortField("id", SortField.Type.LONG, true));
	query.setSort(sort);
	
	paigng.setTotalCount(query.getResultSize());
	
	return query.list();
}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
@Transactional
@Override
public Collection<User> search(String query) {
    FullTextEntityManager manager = this.getFullTextEntityManager();

    QueryBuilder builder = manager.getSearchFactory().buildQueryBuilder().forEntity(User.class).get();

    Query luceneQuery = builder.keyword().fuzzy()
            .onFields("username").matching(query)
            .createQuery();

    FullTextQuery q = manager.createFullTextQuery(luceneQuery, User.class);
    q.setProjection(FullTextQuery.THIS, FullTextQuery.SCORE);

    @SuppressWarnings("unchecked")
    List<Object[]> result = q.getResultList();
    List<User> fine = new LinkedList<>();
    result.stream().forEach((i) -> {
        fine.add((User) i[0]);
    });
    return fine;
}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
@Override
public List<Product> searchByText(String text) {
	Product productEntity = newInstance();
	FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(em);

	QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder()
			.forEntity(productEntity.getClass()).get();
	if (!Strings.isNullOrEmpty(text)) {
		Query query = qb.keyword().onField("name").andField("details").andField("technicalDetails").matching(text)
				.createQuery();

		javax.persistence.Query persistenceQuery = fullTextEntityManager.createFullTextQuery(query,
				productEntity.getClass());
		List<Product> result = persistenceQuery.getResultList();

		if (CollectionUtils.isNotEmpty(result)) {
			for (Product product : result) {
				loadImagesFromQuantities(product.getQuantities());
			}
		}
		return result;
	}
	return Collections.emptyList();
}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
public Map<Integer , List<Products>> extractProducts( String id , int page ) {

        FullTextEntityManager fullTextEntityManager = org.hibernate.search.jpa.Search.getFullTextEntityManager(
                em );

        QueryBuilder queryBuilder = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(
                Products.class ).get();
        org.apache.lucene.search.Query query = queryBuilder.keyword().onField( "category.id" ).matching(
                id ).createQuery();

        FullTextQuery fullTextQuery = fullTextEntityManager.createFullTextQuery( query ,
                                                                                 Products.class );
        Sort sort = new Sort( new SortField( "price" , SortField.DOUBLE ) );
        fullTextQuery.setSort( sort );

        //fullTextQuery.initializeObjectsWith(ObjectLookupMethod.SKIP, DatabaseRetrievalMethod.FIND_BY_ID);
        fullTextQuery.setFirstResult( page * 3 );
        fullTextQuery.setMaxResults( 3 );
        List<Products> results = fullTextQuery.getResultList();

        Map<Integer , List<Products>> results_and_total = new HashMap<Integer , List<Products>>();
        results_and_total.put( fullTextQuery.getResultSize() , results );

        return results_and_total;
    }
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
public List<Products> searchProducts( String search ) {

        FullTextEntityManager fullTextEntityManager = org.hibernate.search.jpa.Search.getFullTextEntityManager(
                em );

        QueryBuilder queryBuilder = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(
                Products.class ).get();
        org.apache.lucene.search.Query query = queryBuilder.keyword().onField( "product" ).matching(
                search ).createQuery();

        FullTextQuery fullTextQuery = fullTextEntityManager.createFullTextQuery( query ,
                                                                                 Products.class );

        //fullTextQuery.initializeObjectsWith(ObjectLookupMethod.SKIP, DatabaseRetrievalMethod.FIND_BY_ID);
        fullTextQuery.setMaxResults( 3 );

        List results = fullTextQuery.getResultList();

        return results;
    }
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
public Customers extractCustomer( String email , String password ) {

        FullTextEntityManager fullTextEntityManager = org.hibernate.search.jpa.Search.getFullTextEntityManager(
                em );

        QueryBuilder queryBuilder = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(
                Customers.class ).get();
        org.apache.lucene.search.Query query = queryBuilder.bool().must( queryBuilder.keyword()
                .onField( "email" ).matching( email ).createQuery() ).must( queryBuilder.keyword()
                        .onField( "password" ).matching( password ).createQuery() ).createQuery();

        FullTextQuery fullTextQuery = fullTextEntityManager.createFullTextQuery( query ,
                                                                                 Customers.class );

        //fullTextQuery.initializeObjectsWith(ObjectLookupMethod.SKIP, DatabaseRetrievalMethod.FIND_BY_ID);
        List results = fullTextQuery.getResultList();

        if ( results.isEmpty() ) {
            return null;
        }

        return ( Customers ) results.get( 0 );
    }
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
@Nullable
@SuppressWarnings({ CompilerWarnings.UNCHECKED })
private Long[] processKeywords(EntityManager entityManager, @Nullable Integer maxResults) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder queryBuilder = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(this.entityImplClass).get();
    BooleanJunction<?> conjunction = queryBuilder.bool();

    PropertyMetadata keywordPropMetadata;

    for (String keywordPropName : this.keywords.keySet()) {
        conjunction = conjunction.must(queryBuilder.keyword()
            .onFields((keywordPropMetadata = this.entityPropMetadatas.get(keywordPropName)).getLowercaseFieldName(),
                keywordPropMetadata.getEdgeNgramFieldName(), keywordPropMetadata.getNgramFieldName(), keywordPropMetadata.getPhoneticFieldName())
            .matching(StringUtils.join(this.keywords.get(keywordPropName), StringUtils.SPACE)).createQuery());
    }

    FullTextQuery fullTextQuery = fullTextEntityManager.createFullTextQuery(new InterceptingQuery(conjunction.createQuery()), this.entityImplClass);
    fullTextQuery.setProjection(ProjectionConstants.ID);

    if (maxResults != null) {
        fullTextQuery.setMaxResults(maxResults);
    }

    return ((List<Object[]>) fullTextQuery.getResultList()).stream().map(fullTextResult -> ((Long) fullTextResult[0])).toArray(Long[]::new);
}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
@Test
@Transactional(timeout=900)
public void testSearchIndex() throws Exception {

	final QueryBuilder qb = getFullTextEntityManager().getSearchFactory().buildQueryBuilder()
			.forEntity(DocumentContentData.class).get();
	final org.apache.lucene.search.Query luceneQuery = qb.keyword().onFields("content").matching("programmering")
			.createQuery();

	// wrap Lucene query in a javax.persistence.Query
	final javax.persistence.Query jpaQuery = getFullTextEntityManager().createFullTextQuery(luceneQuery,
			DocumentContentData.class);

	// execute search
	final List<DocumentContentData> result = jpaQuery.setMaxResults(500).getResultList();
	assertTrue("expect some result",result.size()> 0);
}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <T> List<T> executeSearchQuery(
		RestSearchKey key,
		Class<T> typeClass,
		FullTextSession fullTextEntityManager,
		QueryBuilder queryBuilder,
		Map<String, Query> crtsMap
		) {

	FullTextQuery fullTextQuery = createFullTextQuery(typeClass,
			fullTextEntityManager, queryBuilder, crtsMap);

	if(key.hasOrders()){

		hibernateSearchBuilder.defineOrder(key, fullTextQuery);
	}

	hibernateSearchBuilder.definePaging(key, fullTextQuery);

	return fullTextQuery.list(); 

}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
private <T> FullTextQuery createFullTextQuery(Class<T> typeClass,
		FullTextSession fullTextSession,
		QueryBuilder queryBuilder, Map<String, Query> crtsMap) {
	BooleanJunction<?> booleanJunction = hibernateSearchBuilder.createFinalBooleanJunction(
			queryBuilder, crtsMap);

	FullTextQuery fullTextQuery = null;
	
	if(booleanJunction == null){
		fullTextQuery =
		fullTextSession.createFullTextQuery(queryBuilder.all().createQuery(), typeClass);
	} else {
		
		fullTextQuery =
		fullTextSession.createFullTextQuery(
				booleanJunction.createQuery(), typeClass);
	}
	return fullTextQuery;
}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <T> List<T> executeSearchQuery(
		RestSearchKey key,
		Class<T> typeClass,
		FullTextEntityManager fullTextEntityManager,
		QueryBuilder queryBuilder,
		Map<String, Query> crtsMap
		) {

	FullTextQuery fullTextQuery = createFullTextQuery(typeClass,
			fullTextEntityManager, queryBuilder, crtsMap);

	if(key.hasOrders()){

		hibernateSearchBuilder.defineOrder(key, fullTextQuery);
	}

	hibernateSearchBuilder.definePaging(key, fullTextQuery);

	return fullTextQuery.getResultList(); 

}
 

import org.hibernate.search.query.dsl.QueryBuilder; //导入依赖的package包/类
private <T> FullTextQuery createFullTextQuery(Class<T> typeClass,
		FullTextEntityManager fullTextEntityManager,
		QueryBuilder queryBuilder, Map<String, Query> crtsMap) {
	BooleanJunction<?> booleanJunction = hibernateSearchBuilder.createFinalBooleanJunction(
			queryBuilder, crtsMap);

	FullTextQuery fullTextQuery = null;

	if(booleanJunction == null){
		fullTextQuery =
		fullTextEntityManager.createFullTextQuery(
				queryBuilder.all().createQuery(), typeClass);
	} else {
		
		fullTextQuery =
		fullTextEntityManager.createFullTextQuery(
				booleanJunction.createQuery(), typeClass);
	}
	return fullTextQuery;
}