Java 类org.hibernate.search.jpa.FullTextEntityManager 实例源码

项目：ait-platform 文件：AitFTSRepo.java

@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;
}

项目：bookManager 文件：BookDatabaseImpl.java

@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);
}

项目：oscm 文件：SearchServiceBeanTest.java

@Test
public void searchSubscriptions() throws Exception {
    DataServiceBean bean = spy(new DataServiceBean());
    SubscriptionSearchServiceBean ssb = spy(
            new SubscriptionSearchServiceBean());
    doReturn(bean).when(ssb).getDm();

    FullTextEntityManager ftem = mock(FullTextEntityManager.class,
            Mockito.RETURNS_DEEP_STUBS);
    doReturn(ftem).when(ssb).getFtem();

    Subscription sub = new Subscription();
    sub.setKey(1L);
    FullTextQuery fullTextQuery = mock(FullTextQuery.class);
    when(ftem.createFullTextQuery(any(BooleanQuery.class),
            any(Class.class))).thenReturn(fullTextQuery);
    doReturn(Arrays.asList(sub)).when(fullTextQuery).getResultList();

    Collection<Long> result = ssb.searchSubscriptions("searchphrase");
    assertTrue(result.contains(new Long(1L)));
}

项目：Sound.je 文件：EntitySearch.java

/**
 * Searches the lucene store for a specific query
 *
 * @param <T>       What type of information are we searching
 * @param clazz     The class of the information we are searching
 * @param queryText The query text
 * @return list of entities
 * @throws ParseException the parse exception
 */
public final <T extends BaseEntity> List<Object[]> search(final Class<T> clazz, final String queryText) throws ParseException {
    final FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);

    final SearchFactory searchFactory = fullTextEntityManager.getSearchFactory();

    final QueryParser parser = new MultiFieldQueryParser(getClassLuceneFields(clazz), searchFactory.getAnalyzer(clazz));

    final List<Query> parsedQueries = Arrays.stream(queryText.split("AND"))
            .map(e -> parseQuery(e, parser))
            .filter(Objects::nonNull)
            .collect(Collectors.toList());

    final BooleanQuery.Builder bq = new BooleanQuery.Builder();
    parsedQueries.forEach(e -> bq.add(e, BooleanClause.Occur.MUST));

    final FullTextQuery jpaQuery = fullTextEntityManager.createFullTextQuery(bq.build(), clazz);
    jpaQuery.setProjection(ProjectionConstants.SCORE, ProjectionConstants.EXPLANATION, ProjectionConstants.THIS);

    return (List<Object[]>) jpaQuery.getResultList();
}

项目：ait-platform 文件：AitFTSRepo.java

@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;
}

项目：my-paper 文件：SearchServiceImpl.java

public void index(Class<?> type) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    if (type == Article.class) {
        for (int i = 0; i < articleDao.count(); i += 20) {
            List<Article> articles = articleDao.findList(i, 20, null, null);
            for (Article article : articles) {
                fullTextEntityManager.index(article);
            }
            fullTextEntityManager.flushToIndexes();
            fullTextEntityManager.clear();
            articleDao.clear();
        }
    } else if (type == Product.class) {
        for (int i = 0; i < productDao.count(); i += 20) {
            List<Product> products = productDao.findList(i, 20, null, null);
            for (Product product : products) {
                fullTextEntityManager.index(product);
            }
            fullTextEntityManager.flushToIndexes();
            fullTextEntityManager.clear();
            productDao.clear();
        }
    }
}

项目：CoCoTemp 文件：StartupService.java

/**
 * Call at the startup of the server.
 *
 *  - Enables Hibernate's FullTextEntityManager for Full-text searching.
 *  - Initializes roles in database
 */
public void initialize()
{
    logger.info("Linking entityManager.");
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    logger.info(String.format("entityManager: %s linked.", entityManager));

    try
    {
        logger.info("Beginning to index data.");
        fullTextEntityManager.createIndexer().startAndWait();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    logger.info("Index complete.");

    // Initialize user roles in database
    Role publicRole = createRole(1, "ROLE_PUBLIC");
    roleRepository.save(publicRole);
    Role adminRole = createRole(2, "ROLE_ADMIN");
    roleRepository.save(adminRole);
}

项目：LSChatServer 文件：UserDatabaseImpl.java

@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;
}

项目：development 文件：SearchServiceBeanTest.java

@Test
public void searchSubscriptions() throws Exception {
    DataServiceBean bean = spy(new DataServiceBean());
    SubscriptionSearchServiceBean ssb = spy(
            new SubscriptionSearchServiceBean());
    doReturn(bean).when(ssb).getDm();

    FullTextEntityManager ftem = mock(FullTextEntityManager.class,
            Mockito.RETURNS_DEEP_STUBS);
    doReturn(ftem).when(ssb).getFtem();

    Subscription sub = new Subscription();
    sub.setKey(1L);
    FullTextQuery fullTextQuery = mock(FullTextQuery.class);
    when(ftem.createFullTextQuery(any(BooleanQuery.class),
            any(Class.class))).thenReturn(fullTextQuery);
    doReturn(Arrays.asList(sub)).when(fullTextQuery).getResultList();

    Collection<Long> result = ssb.searchSubscriptions("searchphrase");
    assertTrue(result.contains(new Long(1L)));
}

项目：mercurius 文件：ProductDAOImpl.java

@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();
}

项目：owsi-core-parent 文件：HibernateSearchDaoImpl.java

protected void reindexClasses(FullTextEntityManager fullTextEntityManager, Set<Class<?>> entityClasses)
        throws InterruptedException {
    int batchSize = propertyService.get(HIBERNATE_SEARCH_REINDEX_BATCH_SIZE);
    int loadThreads = propertyService.get(HIBERNATE_SEARCH_REINDEX_LOAD_THREADS);

    if (LOGGER.isInfoEnabled()) {
        LOGGER.info("Targets for indexing job: {}", entityClasses);
    }

    for (Class<?> clazz : entityClasses) {
        ProgressMonitor progressMonitor = new ProgressMonitor();
        Thread t = new Thread(progressMonitor);
        LOGGER.info(String.format("Reindexing %1$s.", clazz));
        t.start();
        MassIndexer indexer = fullTextEntityManager.createIndexer(clazz);
        indexer.batchSizeToLoadObjects(batchSize)
                .threadsToLoadObjects(loadThreads)
                .cacheMode(CacheMode.NORMAL)
                .progressMonitor(progressMonitor)
                .startAndWait();
        progressMonitor.stop();
        t.interrupt();
        LOGGER.info(String.format("Reindexing %1$s done.", clazz));
    }
}

项目：sdcct 文件：SdcctCriteriaImpl.java

@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);
}

项目：spring-scaffy 文件：JPAHibernateSearchDao.java

@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(); 

}

项目：spring-scaffy 文件：JPAHibernateSearchDao.java

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;
}

项目：javaee-lab 文件：HibernateSearchUtil.java

@SuppressWarnings("unchecked")
public <T> List<T> find(Class<T> clazz, SearchParameters sp, List<SingularAttribute<?, ?>> availableProperties) {
    // log.info("Searching {} with terms : {} with available Properties: {}", new Object[]{clazz.getSimpleName(), sp.getTerms(), availableProperties});
    FullTextEntityManager fullTextEntityManager = getFullTextEntityManager(entityManager);
    Query query = sp.getLuceneQueryBuilder().build(fullTextEntityManager, sp, availableProperties);

    if (query == null) {
        return null;
    }

    FullTextQuery ftq = fullTextEntityManager.createFullTextQuery( //
            query, clazz);
    if (sp.getMaxResults() > 0) {
        ftq.setMaxResults(sp.getMaxResults());
    }
    return ftq.getResultList();
}

项目：javaee-lab 文件：HibernateSearchUtil.java

@SuppressWarnings("unchecked")
public <T> List<Serializable> findId(Class<T> clazz, SearchParameters sp, List<SingularAttribute<?, ?>> availableProperties) {
    //log.info("Searching {} with terms : {} with available Properties: {}", new Object[]{clazz.getSimpleName(), sp.getTerms(), availableProperties});
    FullTextEntityManager fullTextEntityManager = getFullTextEntityManager(entityManager);
    Query query = sp.getLuceneQueryBuilder().build(fullTextEntityManager, sp, availableProperties);

    if (query == null) {
        return null;
    }

    FullTextQuery ftq = fullTextEntityManager.createFullTextQuery( //
            query, clazz);
    ftq.setProjection("id");
    if (sp.getMaxResults() > 0) {
        ftq.setMaxResults(sp.getMaxResults());
    }
    List<Serializable> ids = newArrayList();
    List<Object[]> resultList = ftq.getResultList();
    for (Object[] result : resultList) {
        ids.add((Serializable) result[0]);
    }
    return ids;
}

项目：javaee-lab 文件：DefaultLuceneQueryBuilder.java

@Override
public Query build(FullTextEntityManager fullTextEntityManager, SearchParameters searchParameters, List<SingularAttribute<?, ?>> availableProperties) {
    List<String> clauses = getAllClauses(searchParameters, searchParameters.getTerms(), availableProperties);

    StringBuilder query = new StringBuilder();
    query.append("+(");
    for (String clause : clauses) {
        if (query.length() > 2) {
            query.append(" AND ");
        }
        query.append(clause);
    }
    query.append(")");

    if (query.length() == 3) {
        return null;
    }
    //log.debug("Lucene query: {}", query);
    try {
        return new QueryParser(availableProperties.get(0).getName(), fullTextEntityManager.getSearchFactory().getAnalyzer("custom"))
                .parse(query.toString());
    } catch (Exception e) {
        throw propagate(e);
    }
}

项目：lapetiterennes 文件：AdherentResourceTest.java

@Test
@Transactional
public void searchAdherentSortOnName() throws Exception {
    // Given
    adherent.setNom("FERRÉ");
    adherentRepository.saveAndFlush(adherent);

    final Adherent secondAdherent = new Adherent();
    secondAdherent.setPrenom(DEFAULT_PRENOM);
    secondAdherent.setNom("BERRUBÉ");
    adherentRepository.saveAndFlush(secondAdherent);

    final FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    fullTextEntityManager.flushToIndexes();

    // When
    restAdherentMockMvc.perform(get("/api/adherents/search?criteria=eRR&sort=nom").accept(TestUtil.APPLICATION_JSON_UTF8)).andExpect(status().isOk())
    .andExpect(jsonPath("$.[*].nom").value(contains("BERRUBÉ", "FERRÉ")));
}

项目：javaee-samples 文件：AuditService.java

public List<AuditFlow> searchAuditFlowPhrase(String textSearch, int fromRownum, int maxRownums) {
    FullTextEntityManager fullTextEntityManager = getFullTextEntityManager(em);

    QueryBuilder qb = fullTextEntityManager.getSearchFactory()
            .buildQueryBuilder()
            .forEntity(AuditFlow.class)
            .get();

    Query luceneQuery = qb.phrase()
            .onField("error")
            .sentence(textSearch)
            .createQuery();

    return fullTextEntityManager.createFullTextQuery(luceneQuery, AuditFlow.class)
            .setFirstResult(fromRownum)
            .setMaxResults(maxRownums)
            .getResultList();
}