Lucene直接和Hibernate整合

最新推荐文章于 2019-11-27 09:49:49 发布
置顶 最新推荐文章于 2019-11-27 09:49:49 发布
阅读量2.1k 收藏 3
点赞数 2
分类专栏： lucene 文章标签： hibernate lucene string null exception query
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yodlove/article/details/6837886
版权

1、配置Hibernate拦截器

<!-- Hibernate 拦截器，用于同步更新索引 -->
 <bean id="luceneEntityInterceptor" class="com.zrar.cms.service.lucene.impl.LuceneEntityInterceptor" lazy-init="false"/>
 
<!-- Hibernate配置 -->
 <bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
   <!--  配置Hibernate拦截器,用于同步索引-->
    <property name="entityInterceptor" ref="luceneEntityInterceptor" />
  <property name="dataSource" ref="dataSource" />
  <property name="lobHandler" ref="lobHandler" />
  <property name="namingStrategy">
   <bean class="org.hibernate.cfg.ImprovedNamingStrategy" />
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">${hibernate.dialect}</prop>
    <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
    <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
   </props>
  </property>
  <property name="packagesToScan" value="com.zrar.cms.entity" />
 </bean>

这个拦截器是用于同步索引，可以在sava时创建索引，因为我只有在状态为发布时才创建，所以未加

public class LuceneEntityInterceptor extends EmptyInterceptor {
 @Autowired
 @Qualifier("contentLuceneServiceImpl")
 private ContentLuceneService contentLuceneService;
 private static final long serialVersionUID = 7319416231145791577L;
 

/*public boolean onSave(
   Object entity,
   Serializable id,
   Object[] state,
   String[] propertyNames,
   Type[] types) {
  return false;
 }*/
 // 更新数据时回调此方法
 public boolean onFlushDirty(final Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types) {
  super.onFlushDirty(entity, id, currentState, previousState, propertyNames, types);
   if(entity instanceof Content){
    if(((Content)entity).getContentStatus().compareTo(DictionaryStaticValues.CONTENT_STATUS_PUBLISH)==0){
     //更新索引
     new Thread(){
      public void run(){
       contentLuceneService.saveIndex(((Content)entity));
      }
     }.start();
    }
    else{//删除该索引
     final String contentid = ((Content)entity).getContentId();
     new Thread(){
      public void run(){
       contentLuceneService.deleteIndex(contentid);
      }
     }.start();
    }
  }
  return true;
 }

 // 删除
 public void onDelete(Object entity, final Serializable id, Object[] state, String[] propertyNames, Type[] types) {
  super.onDelete(entity, id, state, propertyNames, types);
  if(entity instanceof Content){
   new Thread(){
    public void run(){
     contentLuceneService.deleteIndex(id.toString());
    }
   }.start();
  }
 }

 

2、文章中去掉HTML标记的工具类，采用的是HTMLParser

public class HtmlUtil {
 /**
  * 去掉HTML标记
  * @param content
  * @return
  */
 public static String getContentText(String content) {
  if(content==null){
   return "";
  }
  try {
   Parser parser = Parser.createParser(content, "UTF-8");
   TextExtractingVisitor textExtractingVisitor = new TextExtractingVisitor();
   parser.visitAllNodesWith(textExtractingVisitor);
   return textExtractingVisitor.getExtractedText();
  } catch (ParserException e) {
   e.printStackTrace();
   return content;
  }
 }
}

 

 

分词采用的Ikanalzer，分词工具类

public class AnalyzerUtil {
 private static Analyzer analyzer;
 public static Analyzer getIkAnalyzer(){
  if(analyzer==null){
   //当为true时，分词器迚行最大词长切分 ；当为false时，分词器迚行最细粒度切
   analyzer = new IKAnalyzer(true);
  }
  return analyzer;
 }

}

 

然后是索引操作的serviceImpl类


import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.document.DateTools;
import org.apache.lucene.document.DateTools.Resolution;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Field.Index;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.search.BooleanClause.Occur;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TermRangeQuery;
import org.apache.lucene.search.TopScoreDocCollector;
import org.apache.lucene.search.highlight.Highlighter;
import org.apache.lucene.search.highlight.InvalidTokenOffsetsException;
import org.apache.lucene.search.highlight.QueryScorer;
import org.apache.lucene.search.highlight.SimpleFragmenter;
import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
import org.apache.lucene.search.highlight.TokenSources;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.util.Version;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.wltea.analyzer.lucene.IKQueryParser;
import org.wltea.analyzer.lucene.IKSimilarity;

import com.zrar.cms.constant.DictionaryStaticValues;
import com.zrar.cms.dao.content.ContentDao;
import com.zrar.cms.entity.Category;
import com.zrar.cms.entity.Content;
import com.zrar.cms.entity.Topic;
import com.zrar.cms.service.lucene.ContentLuceneService;
import com.zrar.cms.util.AnalyzerUtil;
import com.zrar.cms.util.FilePathSptUtil;
import com.zrar.cms.util.HtmlUtil;
import com.zrar.cms.vo.content.ContentBean;
import com.zrar.dao.util.Page;

@Service
@Transactional
public class ContentLuceneServiceImpl implements ContentLuceneService {
 private final static Logger logger = LoggerFactory.getLogger(ContentLuceneServiceImpl.class);
 @Autowired
 @Qualifier("contentDaoImpl")
 private ContentDao contentDao;

 private String[] fileds = new String[]{ "contentTitle", "contentContext","keywords"};
 
 private Occur[] occurs =  new Occur[] { Occur.SHOULD, Occur.SHOULD,Occur.SHOULD };

 private int maxIndexCount = 200;

 public boolean deleteIndex(String contentId) {
  IndexWriter indexWriter = null;
  Directory d = null;
  try {
   d = FSDirectory.open(new File(FilePathSptUtil.LUCENE_INDEX));
   while(d!=null&&IndexWriter.isLocked(d)){//如果文件锁住,等待解锁
    Thread.sleep(1000);
    logger.error("索引已经锁住，正在等待....");
   }
   IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_30, AnalyzerUtil.getIkAnalyzer());
   indexWriter = new IndexWriter(d, indexWriterConfig);
   Term term = new Term("id", contentId);
   indexWriter.deleteDocuments(term);
   indexWriter.optimize();
   indexWriter.commit();
   logger.debug("删除文章ID:{}的索引...",contentId);
   logger.debug("共有索引{}个", indexWriter.numDocs());
   indexWriter.close();
   return true;
  } catch (CorruptIndexException e) {
   e.printStackTrace();
   logger.error("索引删除异常", e);
  } catch (LockObtainFailedException e) {
   e.printStackTrace();
   logger.error("索引删除异常", e);
  } catch (IOException e) {
   e.printStackTrace();
   logger.error("索引不存在", e);
  } catch (Exception e) {
   e.printStackTrace();
   logger.error("索引删除异常", e);
  } finally {
   if (indexWriter != null) {
    try {
     indexWriter.close();
    } catch (CorruptIndexException e) {
     e.printStackTrace();
     logger.error("索引关闭异常", e);
    } catch (IOException e) {
     e.printStackTrace();
     logger.error("索引关闭异常", e);
    }
    finally{
     try {
      if (d!=null&&IndexWriter.isLocked(d)) {    
       IndexWriter.unlock(d);  
      }
     } catch (IOException e) {
      e.printStackTrace();
      logger.error("解锁异常", e);
     }
    }
   }
  }
  return false;
 }

 
 public boolean saveIndex(Content c) {
  IndexWriter indexWriter = null;
  Directory d = null;
  try {
   d= FSDirectory.open(new File(FilePathSptUtil.LUCENE_INDEX));
   while(d!=null&&IndexWriter.isLocked(d)){//如果文件锁住,等待解锁
    Thread.sleep(1000);
    logger.error("索引已经锁住，正在等待....");
   }
   IndexWriterConfig conf = new IndexWriterConfig(Version.LUCENE_31, AnalyzerUtil.getIkAnalyzer());
   indexWriter = new IndexWriter(d, conf);
   Term term = new Term("id", c.getContentId());
   indexWriter.deleteDocuments(term);//不管更新与否，先删除原来的
   
   Document doc = getDocument(c);
   indexWriter.addDocument(doc);
   indexWriter.optimize();
   indexWriter.commit();
   logger.debug("更新索引，文章ID为{}",c.getContentId());
   logger.debug("共有索引{}个", indexWriter.numDocs());
   return true;
  }  catch (CorruptIndexException e) {
   e.printStackTrace();
   logger.error("索引添加异常", e);
  } catch (LockObtainFailedException e) {
   e.printStackTrace();
   logger.error("索引添加异常", e);
  } catch (IOException e) {
   e.printStackTrace();
   logger.error("索引不存在", e);
  } catch (Exception e) {
   e.printStackTrace();
   logger.error("索引添加异常", e);
  } finally {
   if (indexWriter != null) {
    try {
     indexWriter.close();
    } catch (CorruptIndexException e) {
     e.printStackTrace();
     logger.error("索引关闭异常", e);
    } catch (IOException e) {
     e.printStackTrace();
     logger.error("索引关闭异常", e);
    }
    finally{
     try {
      if (d!=null&&IndexWriter.isLocked(d)) {    
       IndexWriter.unlock(d);  
      }
     } catch (IOException e) {
      e.printStackTrace();
      logger.error("解锁异常", e);
     }
    }
   }
  }
  return false;
 }

 public synchronized boolean createIndexs(boolean isNew) {
  File file = new File(FilePathSptUtil.LUCENE_INDEX);
  if (file.exists() && isNew) {
   if(file.isFile()){
    file.delete();
   }
   else{
    File[] f = file.listFiles();
    for(int i=0;i<f.length;i++){
     f[i].delete();
    }
   }
  } else {
   file.mkdirs();
  }
  IndexWriter indexWriter = null;
  Directory d = null;
  try {
   d = FSDirectory.open(new File(FilePathSptUtil.LUCENE_INDEX));
   IndexWriterConfig conf = new IndexWriterConfig(Version.LUCENE_31, AnalyzerUtil.getIkAnalyzer());
   // 创建索引模式：CREATE，覆盖模式； APPEND，追加模式
   if (isNew) {
    conf.setOpenMode(IndexWriterConfig.OpenMode.CREATE);
   } else {
    conf.setOpenMode(IndexWriterConfig.OpenMode.APPEND);
   }
   indexWriter = new IndexWriter(d, conf);
   ContentBean bean = new ContentBean();
   bean.setContentStatus(DictionaryStaticValues.CONTENT_STATUS_PUBLISH);
   int count = contentDao.count(bean);
   int i = 0;
   Page<Content> page = new Page<Content>();
   page.setPageSize(maxIndexCount);
   List<Content> list = null;
   while (count > 0) {
    page.setPageNo(i++);
    list = contentDao.findByPage(page, bean);
    for (Content c : list) {
     Document doc = getDocument(c);
     indexWriter.addDocument(doc);
    }
    count = count - maxIndexCount;
    list.clear();
    contentDao.clear();
    logger.debug("当前共有索引{}个", indexWriter.numDocs());
    Thread.sleep(100);
   }
   logger.debug("索引结束,共有索引{}个", indexWriter.numDocs());
   // 自动优化合并索引文件
   indexWriter.optimize();
   indexWriter.commit();
   return true;
  } catch (CorruptIndexException e) {
   e.printStackTrace();
   logger.error("索引添加异常", e);
  } catch (LockObtainFailedException e) {
   e.printStackTrace();
   logger.error("索引添加异常", e);
  } catch (IOException e) {
   e.printStackTrace();
   logger.error("索引不存在", e);
  } catch (Exception e) {
   e.printStackTrace();
   logger.error("索引添加异常", e);
  } finally {
   if (indexWriter != null) {
    try {
     indexWriter.close();
    } catch (CorruptIndexException e) {
     e.printStackTrace();
     logger.error("索引关闭异常", e);
    } catch (IOException e) {
     e.printStackTrace();
     logger.error("索引关闭异常", e);
    }
    finally{
     try {
      if (d!=null&&IndexWriter.isLocked(d)) {    
       IndexWriter.unlock(d);  
      }
     } catch (IOException e) {
      e.printStackTrace();
      logger.error("解锁异常", e);
     }
    }
   }
  }
  return false;
 }

 /**
  * content转换为document
  *
  * @param c
  * @return
  */
 private Document getDocument(Content c) {
  Document doc = new Document();
  doc.add(new Field("id", c.getContentId(), Store.YES, Index.NOT_ANALYZED));
  doc.add(new Field("topicId", StringUtils.trimToEmpty(c.getTopic() != null ? c.getTopic().getTopicId() : ""), Store.YES, Index.NOT_ANALYZED));
  // 可将topic名称索引
  doc.add(new Field("categoryId", StringUtils.trimToEmpty(c.getCategory() != null ? c.getCategory().getCategoryId() : ""), Store.YES, Index.NOT_ANALYZED));
  // 可将category名称索引
  doc.add(new Field("contentTitle", StringUtils.trimToEmpty(c.getContentTitle()), Store.YES, Index.ANALYZED));
  doc.add(new Field("keywords", StringUtils.trimToEmpty(c.getKeywords()), Store.YES, Index.ANALYZED));
  doc.add(new Field("contentContext", HtmlUtil.getContentText(c.getContentContext()), Store.YES, Index.ANALYZED));
  doc.add(new Field("contentDescription", StringUtils.trimToEmpty(c.getContentDescription()), Store.YES, Index.ANALYZED));
  doc.add(new Field("contentAuthor", StringUtils.trimToEmpty(c.getContentAuthor()), Store.YES, Index.NOT_ANALYZED));
  if (c.getCreateTime() != null) {
   doc.add(new Field("createTime", DateTools.dateToString(c.getCreateTime(), Resolution.SECOND), Field.Store.YES, Field.Index.NOT_ANALYZED));
  } else {
   doc.add(new Field("createTime", DateTools.dateToString(new Date(), Resolution.SECOND), Field.Store.YES, Field.Index.NOT_ANALYZED));
  }
  if (c.getPublishTime() != null) {
   doc.add(new Field("publishTime", DateTools.dateToString(c.getPublishTime(), Resolution.SECOND), Field.Store.YES, Field.Index.NOT_ANALYZED));
  } else {
   doc.add(new Field("publishTime", DateTools.dateToString(new Date(), Resolution.SECOND), Field.Store.YES, Field.Index.NOT_ANALYZED));
  }
  doc.add(new Field("contentHits",  String.valueOf(c.getContentHits() != null ? c.getContentHits() : 0), Store.YES, Field.Index.NOT_ANALYZED));
  doc.add(new Field("isTop", c.getIsTop() != null &&c.getIsTop() ? "true" : "false", Field.Store.YES, Field.Index.NOT_ANALYZED));
  doc.add(new Field("contentSource", StringUtils.trimToEmpty(c.getContentSource()), Store.YES, Index.ANALYZED));
  doc.add(new Field("simpleTitle1", StringUtils.trimToEmpty(c.getSimpleTitle1()), Store.YES, Index.ANALYZED));
  doc.add(new Field("simpleTitle2", StringUtils.trimToEmpty(c.getSimpleTitle2()), Store.YES, Index.ANALYZED));
  doc.add(new Field("simpleTitle3", StringUtils.trimToEmpty(c.getSimpleTitle3()), Store.YES, Index.ANALYZED));
  return doc;
 }

 
 
 /**
  * 查询指定栏目下的文章
  *
  * @param word
  * @param category
  * @return
  * @throws InvalidTokenOffsetsException
  * @throws ParseException
  * @throws IOException
  * @throws CorruptIndexException
  */
 public List<Content> likeSearch(ContentBean content, Page<Content> page){
  try {
   BooleanQuery query = new BooleanQuery();
   IndexReader reader = IndexReader.open(FSDirectory.open(new File(FilePathSptUtil.LUCENE_INDEX)));
   IndexSearcher searcher = new IndexSearcher(reader);
   // 在索引器中使用IKSimilarity相似度评估器
   searcher.setSimilarity(new IKSimilarity());
   Query likequery = null;
   if (content.getKeyword() != null && content.getKeyword().length() > 0) {
    likequery = IKQueryParser.parseMultiField(fileds, content.getKeyword(), occurs);
   } else {
    likequery = MultiFieldQueryParser.parse(Version.LUCENE_31, "*:*", fileds, occurs, AnalyzerUtil.getIkAnalyzer());
   }
   
   query.add(likequery, Occur.MUST);
   //栏目搜索
   if(content.getCategoryId()!=null&&content.getCategoryId().length>0){
    BooleanQuery booleanquery = new BooleanQuery();
    for (String category : content.getCategoryId()) {
     Query termqquery = new TermQuery(new Term("categoryId", category));
     booleanquery.add(termqquery, Occur.SHOULD);
    }
    query.add(booleanquery, Occur.MUST);
   }
   
   if(StringUtils.isNotBlank(content.getNokeyword())){//不包含关键字
    likequery = IKQueryParser.parseMultiField(fileds, content.getNokeyword(), occurs);
    query.add(likequery,Occur.MUST_NOT);
   }
   
   //日期过滤
   if(content.getMaxPublishTime()!=null||content.getMinPublishTime()!=null){
    String start = null;
    String end = null;
    if(content.getMinPublishTime()!=null){
     start = DateTools.dateToString(content.getMinPublishTime(), Resolution.SECOND);
    }
    if(content.getMaxPublishTime()!=null){
     end = DateTools.dateToString(content.getMaxPublishTime(), Resolution.SECOND);
    }
    Query q = new TermRangeQuery("publishTime", start, end, true, true);
    query.add(q,Occur.MUST);
   }
   
   return getList(query, page, searcher);
  } catch (Exception e) {
   e.printStackTrace();
   logger.error("搜索异常", e);
   page.setResult(new ArrayList<Content>());
   return new ArrayList<Content>();
  }
 }

 /**
  * Content 转换
  *
  * @throws IOException
  * @throws CorruptIndexException
  * @throws InvalidTokenOffsetsException
  */
 private List<Content> getList(Query query, Page<Content> page, IndexSearcher searcher) throws CorruptIndexException, IOException, InvalidTokenOffsetsException {
  TopScoreDocCollector topCollector = TopScoreDocCollector.create(searcher.maxDoc(), false);
  // 多字段排序，设置在前面的会优先排序
  /*SortField[] sortFields = new SortField[3];
  //true:降序  false:升序
  SortField top = new SortField("isTop", SortField.INT, true);
  SortField hits = new SortField("contentHits", SortField.INT, true);
  SortField pubtime = new SortField("publishTime", SortField.LONG, true);
  sortFields[0] = top;
  sortFields[1] = hits;
  sortFields[2] = pubtime;
  Sort sort = new Sort(sortFields);*/
  searcher.search(query, topCollector);  
  SimpleHTMLFormatter simpleHtmlFormatter = new SimpleHTMLFormatter("<font color='red'>", "</font>");// 高亮
  Highlighter highlighter = new Highlighter(simpleHtmlFormatter, new QueryScorer(query));
  highlighter.setTextFragmenter(new SimpleFragmenter(100));
  page.setTotal(topCollector.getTotalHits());
  ScoreDoc[] docs = topCollector.topDocs((page.getPageNo() - 1) * page.getPageSize(), page.getPageSize()).scoreDocs;
  List<Content> list = new ArrayList<Content>();
  for (ScoreDoc scdoc : docs) {
   Document document = searcher.doc(scdoc.doc);
   TokenStream tokenStream = TokenSources.getAnyTokenStream(searcher.getIndexReader(), scdoc.doc, "contentContext", AnalyzerUtil.getIkAnalyzer());
   String contentContext = document.get("contentContext");
   String content = highlighter.getBestFragment(tokenStream, contentContext);
   Content c = new Content();
   c.setContentId(document.get("id"));
   Topic topic = new Topic();
   topic.setTopicId(document.get("topicId"));
   c.setTopic(topic);
   Category category = new Category();
   category.setCategoryId(document.get("categoryId"));
   c.setCategory(category);
   c.setContentTitle(document.get("contentTitle"));
   c.setKeywords(document.get("keywords"));
   if (StringUtils.isNotBlank(content)) {
    c.setContentContext(content);
   } else {
    c.setContentContext(contentContext.length() > 100 ? contentContext.substring(0, 100) : contentContext);
   }
   c.setContentDescription(document.get("contentDescription"));
   c.setContentAuthor(document.get("contentAuthor"));
   try {
    c.setCreateTime(DateTools.stringToDate(document.get("createTime")));
   } catch (java.text.ParseException e) {
    c.setCreateTime(new Date());
   }
   try {
    c.setPublishTime(DateTools.stringToDate(document.get("publishTime")));
   } catch (java.text.ParseException e) {
    c.setPublishTime(new Date());
   }
   c.setContentHits(Integer.valueOf(document.get("contentHits")));
   c.setIsTop(StringUtils.isNotBlank(document.get("isTop")) && Boolean.valueOf(document.get("isTop")));
   c.setContentSource(document.get("contentSource"));
   c.setSimpleTitle1(document.get("simpleTitle1"));
   c.setSimpleTitle2(document.get("simpleTitle2"));
   c.setSimpleTitle3(document.get("simpleTitle3"));
   
   list.add(c);
  }
  page.setResult(list);
  return list;
 }

}

 

 

 

 

Hibernate 与 Lucene 的整合框架详解
04-12
Hibernate 与 Lucene 的整合框架
Hibernate与Lucene集成
咖啡.编程.思考
08-11 2123
1. 注解领域模型首先，必须将一个持久类声明为 @Indexed:@Entity@Indexed(index="indexes/essays")public class Essay { ...}属性index是告诉Hibernate， Lucene索引信息所在的位置（你文件系统的某个目录）。 如果你想为所有的Lucene索引定义一个
Lucene的例子（hibernate实现）
草衣的博客
02-05 852
前期准备： （一）： 1.lucene 个版本jar包：http://blog.csdn.net/u013341688/article/details/50634443 2.hibernate相关的jar包 3.oracle数据库连接jar包 以下是我的本地Jar包： （二）： 1.建表Employee_info，构建实体类及其映射文件 实体类里包含em
Hibernate Lucene 的集成
fly.net.cn
05-07 135
Hibernate Lucene Integration Hibernate Lucene 的集成 Lucene is a high-performance Java search engine library available from the Apache Software Foundation. Hibernate Annotations includes a package of ann...
hibernate search 与 lucene 结合一点点总结.
安静
11-09 2145
例子:javaeye的例子http://wishlife.javaeye.com/blog/186873hibernate.cfg.xml配置:                             ....            ...                                                                        
Lucene Hibernate
10-08
将Lucene与Hibernate整合，可以使应用程序具备高级的全文搜索功能，同时保持对数据库操作的便利性。这种集成通常涉及以下几个关键步骤： 1. **数据索引**：首先，我们需要在Lucene中为Hibernate管理的对象创建索引...
Struts2.3.8整合Hibernate4.2,Spring3.2lucene 3 6 2 SSH整合1.0版
04-16
通过这样的整合，开发者可以利用SSH的优势，如Struts2的清晰的请求处理、Spring的依赖管理和事务控制、Hibernate的数据库操作便利性，以及Lucene的全文检索能力，构建出高效的企业级应用。 在这个1.0版的整合中，...
Search Lucene JavaEE WebApp Struts2 Hibernate.zip
最新发布
12-29
《构建基于JavaEE的搜索引擎应用：Lucene、Struts2与Hibernate的整合实践》 在当今信息化社会，数据量日益增长，高效的搜索功能成为Web应用程序不可或缺的部分。本项目"Search Lucene JavaEE WebApp Struts2 ...
springboot整合lucence完整代码
04-15
在Maven的`pom.xml`中，你需要引入如下的Lucene和Spring Data JPA依赖（假设我们同时整合了MySQL数据库）： ```xml <!-- Spring Boot Starter Data JPA --> <groupId>org.springframework.boot <artifactId>...
hibrnate和lucene的集成
zhaolei415的专栏
12-25 116
Lucene是一个高性能的java搜索引擎库，可以从 Apache软件基金组织获取。Hibernate Annotations包括一个注解包，它允许把任何域模型对象标记为可索引的，并且对任何经由Hibernate进行持续化的实例，Hibernate 都会为之维护一个对应的Lucene索引。 使用Lucene为实体建立索引 注解域模型 首先，必须将一个持久类声明为@Indexed:...
Java for Web学习笔记（一二四）：搜索（6）Lucene和Hibernate search
愷风（Wei）的专栏
05-29 725
LuceneLucene是很强大的检索工具，Hibernate Search将lucene core和JPA/Hibernate ORM结合起来，当我们通过JPA添加或者修改数据时，自动在Lucene中index了entity，在检索时采用lucene core搜索引起进行搜索，并返回JPA对象实体。&lt;dependency&gt; &lt;groupId&gt;org.hibern...
hibernate search 和lucene结合使用实例
kirk1127的专栏
12-04 150
以下的代码是根据api帮助文档作出的一个简单实例，在应用方面可以实现创建索引，搜索，过滤和高亮的功能。 整体的环境为：spring2.5.6，hibernate3.3.1，struts2.0.8，lucene2.4.1 第一步，首先是web.xml配置文件，由于使用了ssh2的架构，所以不得不在web.xml里配置一些东西 [code="java"]] ...
大数据量中的模糊查询优化方案
weixin_34138521的博客
09-19 1191
----------------------------------------------------------------------------------------------[版权申明：本文系作者原创，转载请注明出处]文章出处：http://blog.csdn.net/sdksdk0/article/details/52589761作者：...
在项目中的lucene与hibernate 3.2.5集成配置
steven cheng
05-24 172
hibernate3.2以后，好像对lucene集成这一块多了一个项目hibernate-search,现有网上中文的配置，与这个有点出入。 现将我的配置过程记录如下： spring中配置： 在sessionFactory的配置中加上     &lt;property name="configurationClass" value="org.hibernate.cfg.AnnotationConf...
lucene与hibernate 3.2.5集成配置
愁乐天的专栏
01-13 1322
lucene与hibernate 3.2.5集成配置 hibernate3.2以后，好像对lucene集成这一块多了一个项目hibernate-search,现有网上中文的配置，与这个有点出入。现将我的配置过程记录如下：spring中配置：在sessionFactory的配置中加上    <property name="c
关于Hibernate Search转载文章
cool_rain_man的专栏
05-16 1530
1、创建POJOpackage com.yehui;import javax.persistence.CascadeType;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Gene
hibernate的全文搜索（Lucene）
winnerlxh
09-27 246
1）文件全文搜索 首先导入三个核心包（hibernate-search.jar、hibernate-commons-annotations.jar和lucene-core.jar）和一个高亮的包（lucene-highlighter-2.0.0.jar）到web app里面； 创建索引数据库类： package com.golden.info.test; import java.io.Fi...
Lucene+hibernateSearch入门
一个菜鸟的博客
04-02 3201
目标： 通过hibernate search 创建 lucene全文索引原理： Hibernate Search是给Hibernate持久化模型架构来使用的一套全文检索工具，其全文检索依赖于Lucence引擎。全文搜索引擎（lucence）会将你要查询的这个字段的词语，进行分词，直接匹配分词。举例： 比如你要查询name字段的值（101张三丰），索引库中保存数据的时候，搜索引擎会自动将值（需要
Cannot load facet,unknow facet type web
winnieFighting
11-27 8142
昨晚还好好的，今天早上打开就这样子了。 查了一下资料，发现是需要设置一下web. 打开idea的setting，找到plugin，在已经安装的里边输入web查询。 看到下边的我都没有选上了，然后就都选上，再次尝试就可以了。可能是昨天idea没有正常关闭，破坏了它的配置？？？？ ...
HiberateSearch整合Lucene实战：创建索引的POJO示例
"这篇文章主要介绍了Hibernate与Lucene的整合框架，包括如何在Hibernate实体类上应用Lucene的索引注解以及使用HiberateSearch 3.0.0.GA版进行集成。" 在Java开发中，Hibernate是一个流行的ORM（对象关系映射）框架...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值