码迷，mamicode.com
首页 > 编程语言 > 详细

java所搜引擎slor学习笔记(一)

时间：2014-10-28 00:23:55      阅读：332      评论：0      收藏：0      [点我收藏+]

标签：Lucene   style   blog   http   io   color   os   ar   使用   

java搜索引擎有很多，比较熟悉的就是slor和lucene。

luncene：

概念：全文检索是计算机程序通过扫描文章中的每一个词，对每一个词建立一个索引，指明该词在文章中出现的次数和位置。当用户查询时根据建立的索引查找，类似于通过字典的检索字表查字的过程 

luncene入门:

全文检索（Full-Text Retrieval）是指以文本作为检索对象，找出含有指定词汇的文本。全面、准确和快速是衡量全文检索系统的关键指标。 关于全文检索，我们要知道：

1，只处理文本。

2，不处理语义。

3，搜索时英文不区分大小写。

4，结果列表有相关度排序。 在信息检索工具中，全文检索是最具通用性和实用性的。

全文检索应用场景：

我们使用Lucene，主要是做站内搜索，即对一个系统内的资源进行搜索。如BBS、BLOG中的文章搜索，网上商店中的商品搜索等。使用Lucene的项目有Eclipse、Jira等。一般不做互联网中资源的搜索，因为不易获取与管理海量资源（专业搜索方向的公司除外）。

全文检索不同于数据库检索

全文检索不同于数据库的SQL查询。（他们所解决的问题不一样，解决的方案也不一样，所以不应进行对比）。在数据库中的搜索就是使用SQL，如：SELECT * FROM t WHERE content like ‘%ant%’。这样会有如下问题：

1、匹配效果：如搜索ant会搜索出planting。这样就会搜出很多无关的信息。

2、相关度排序：查出的结果没有相关度排序，不知道我想要的结果在哪一页。我们在使用百度搜索时，一般不需要翻页，为什么？因为百度做了相关度排序：为每一条结果打一个分数，这条结果越符合搜索条件，得分就越高，叫做相关度得分，结果列表会按照这个分数由高到低排列，所以第1页的结果就是我们最想要的结果。

3、全文检索的速度大大快于SQL的like搜索的速度。这是因为查询方式不同造成的，以查字典举例：数据库的like就是一页一页的翻，一行一行的找，而全文检索是先查目录，得到结果所在的页码，再直接翻到这一页。

准备Lucene的开发环境:

搭建Lucene的开发环境只需要加入Lucene的Jar包，要加入的jar包至少要有:

lucene-core-3.0.1.jar（核心包）

contrib\analyzers\common\lucene-analyzers-3.0.1.jar（分词器）

contrib\highlighter\lucene-highlighter-3.0.1.jar（高亮）

contrib\memory\lucene-memory-3.0.1.jar（高亮）

全文检索程序工作流程

bubuko.com,布布扣

操作索引库的方法

bubuko.com,布布扣

下面是一个luncene的hello world

public class Article {
private Integer id;   //id
private String title; //标题
private String content; //内容
}

建立索引库

@Test
public void testCreateIndex() throws Exception {
Article article = new Article();
article.setId(1); // 通过设置id的值模拟一个已保存到数据库中的数据
article.setTitle("Lucene是全文检索框架");
article.setContent("全文检索（Full-Text Retrieval）是指以文本作为检索对象，找出含有指定词汇的文本。");

// 建立索引 
Directory directory = FSDirectory.open(new File("./indexDir/")); // 索引库目录
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30); // 分词器

// >> 把Aritcle转为Document
Document doc = new Document();
doc.add(new Field("id", article.getId().toString(), Store.YES, Index.NOT_ANALYZED)); // 要把id转为String型
doc.add(new Field("title", article.getTitle(), Store.NO, Index.ANALYZED));
doc.add(new Field("content", article.getContent(), Store.YES, Index.ANALYZED));

// >> 保存到索引库中
IndexWriter indexWriter = new IndexWriter(directory, analyzer, MaxFieldLength.LIMITED);//MaxFieldLength.LIMITED:表示限定分词，不超过10000
indexWriter.addDocument(doc);
indexWriter.close();
}
// 搜索
@Test
public void testSearch() throws Exception {
// 搜索条件
String queryString = "lucene";
Directory directory = FSDirectory.open(new File("./indexDir/")); // 索引库目录
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30); // 分词器

// 1，把查询字符串转为Query对象（只在title中查询）
QueryParser queryParser = new QueryParser(Version.LUCENE_30, "title", analyzer);
Query query = queryParser.parse(queryString);

// 2，执行搜索，得到中间结果
IndexSearcher indexSearcher = new IndexSearcher(directory);
TopDocs topDocs = indexSearcher.search(query, 100); //100 返回查询出来的前n条结果

int count = topDocs.totalHits; // 总结果数
ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 前n条结果的信息

}
@Test
public void testSearch() throws Exception {
// 3，处理结果
List<Article> list = new ArrayList<Article>();
for (int i = 0; i < scoreDocs.length; i++) {
ScoreDoc scoreDoc = scoreDocs[i];
System.out.println("得分：" + scoreDoc.score);

// 根据内部编号取出真正的Document数据
int docId = scoreDoc.doc;
System.out.println("docId内部编号="+docId);
Document doc = indexSearcher.doc(docId);

// 把Document转为Article
Article article = new Article();
article.setId(Integer.parseInt(doc.get("id"))); // 要转型
article.setTitle(doc.get("title"));
article.setContent(doc.get("content")); // doc.getField("content").stringValue()
list.add(article);
}
indexSearcher.close();

// 显示结果
System.out.println("总结果数：" + count);
for (Article article : list) {
System.out.println("---------> id = " + article.getId());
System.out.println("title  = " + article.getTitle());
System.out.println("content= " + article.getContent());
}
}

索引库内部结构分析（创建）

1、把原始数据内容存储到数据的缓存区，会自动生成内部编号

2、在更新目录，会使用分词器

Store参数：

YES：存储本字段的原始值

NO：不存储本字段的原始值，这时，获取到信息字段为null

Index参数：

NO：不更新目录

ANALYZED：把本字段的值分词后更新到目录

NOT_ANALYZED不分词，而是把本字段的值当成一个词更新到目录

注意：一般情况下数据的唯一标识符使用不分词索引 如ID，Path，URL或是姓名、日期、数字

Store：能不能按照这个字段搜索到这个结果 Index：如果不更新目录，则不能按照本字段搜索到结果

 

lucene索引库操作CRUD

保持索引库和数据库状态一致

bubuko.com,布布扣

所有的数据（对象），我们都要存到数据库中。对于要进行搜索的数据，还要存到索引库中，以供搜索。一份数据同时存到数据库与索引库中（格式不同），就要想办法保证他们的状态一致。否则，就会影响搜索结果。

Article和Document之间的转换

/**
 * 把Article转为Document
*/
public static Document articleToDocument(Article article) {
Document doc = new Document();
String idStr = article.getId().toString(); // 把Integer转为String型
doc.add(new Field("id", idStr, Store.YES, Index.NOT_ANALYZED));
doc.add(new Field("title", article.getTitle(), Store.YES, Index.ANALYZED));
doc.add(new Field("content", article.getContent(), Store.YES, Index.ANALYZED));
return doc;
}
/**
 * 把Document转为Article
*/
public static Article documentToArticle(Document doc) {
Article article = new Article();
Integer id = Integer.parseInt(doc.get("id")); // 把String型转为Integer型
article.setId(id);
article.setTitle(doc.get("title"));
article.setContent(doc.get("content"));
return article;
}
public class Configuration {
private static Directory directory;
private static Analyzer analyzer;
static {
// 初始化所有配置，应通过读取配置文件得到配置的值
try {
directory = FSDirectory.open(new File("./indexDir/"));
analyzer = new StandardAnalyzer(Version.LUCENE_30);
} catch (Exception e) {
         throw new RuntimeException(e);
}
}

public static Directory getDirectory() {
    return directory;
}

public static Analyzer getAnalyzer() {
    return analyzer;
}
}
public void save(Article article) {
// 1，把对象转为Document
Document doc = ArticleDocumentUtils.articleToDocument(article);
IndexWriter indexWriter = null;
// 2，添加到索引库中
try {
indexWriter = new IndexWriter(Configuration.getDirectory(),Configuration.getAnalyzer(),MaxFieldLength.LIMITED);
indexWriter.addDocument(doc);
} catch (Exception e) {
    throw new RuntimeException(e);
} finally{
try {
if(indexWriter!=null){
indexWriter.close();
}
} catch (Exception e) {
         throw new RuntimeException(e);
}
}

}
public void delete(Integer id) {
IndexWriter indexWriter = null;
try {
//term：某个字段的一个关键词
Term term = new Term("id", id.toString());
indexWriter = new IndexWriter(Configuration.getDirectory(),Configuration.getAnalyzer(),MaxFieldLength.LIMITED);
indexWriter.deleteDocuments(term);
} catch (Exception e) {
    throw new RuntimeException(e);
} finally{
try {
if(indexWriter!=null){
    indexWriter.close();
}
} catch (Exception e) {
         throw new RuntimeException(e);
}
}
}
public void update(Article article) {
IndexWriter indexWriter = null;
try {
//term：某个字段的一个关键词
Term term = new Term("id", article.getId().toString());
Document doc = ArticleDocumentUtils.articleToDocument(article);
indexWriter = new IndexWriter(Configuration.getDirectory(),Configuration.getAnalyzer(),MaxFieldLength.LIMITED);
//indexWriter.updateDocument(term, doc);
// 更新就是先删除再创建
 indexWriter.deleteDocuments(term);
 indexWriter.addDocument(doc);
} catch (Exception e) {
    throw new RuntimeException(e);
} finally{
try {
if(indexWriter!=null){
indexWriter.close();
}
} catch (Exception e) {
         Throw new RuntimeException(e);
}
}
}

更新索引库

索引文件的检索与维护，更新是先删除后创建

维护倒排索引有三个操作：添加、删除和更新文档。但是更新操作需要较高的代价。因为文档修改后（即使是很小的修改），就可能会造成文档中的很多的关键词的位置都发生了变化，这就需要频繁的读取和修改记录，这种代价是相当高的。因此，一般不进行真正的更新操作，而是使用“先删除，再创建”的方式代替更新操作。

public SearchResult<Article> search(String queryString, int firstResult, int maxResults) {
       IndexSearcher indexSearcher = null;
       try {
            // 1，把查询字符串转为Query对象
            // QueryParser queryParser = new QueryParser(Version.LUCENE_30, "title",Configuration.getAnalyzer()); // 默认只在title中查询
           QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_30, new String[] { "title", "content" }, Configuration.getAnalyzer()); // 默认在多个字段中查询
           Query query = queryParser.parse(queryString);
           // 2，执行查询，得到中间结果
           indexSearcher = new IndexSearcher(Configuration.getDirectory());
           TopDocs topDocs = indexSearcher.search(query, firstResult + maxResults); // 最多返回前n条结果
            int count = topDocs.totalHits; // 总记录数
           ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 前n条结果的信息
           // 3，处理结果
           List<Article> list = new ArrayList<Article>();
           int endIndex = Math.min(firstResult + maxResults, scoreDocs.length);

           for (int i = firstResult; i < endIndex; i++) { // 只取一段数据
                  // 根据内部编号取出Document数据
                  Document doc = indexSearcher.doc(scoreDocs[i].doc);
                  // 把Document转为Article
                  Article article = ArticleDocumentUtils.documentToArticle(doc);
                  list.add(article);
          } 
           return new SearchResult<Article>(count,list); // 返回                                                                                         
     } catch (Exception e) {
           throw new RuntimeException(e);
     } finally{
           if(indexSearcher!=null){
           try {
                  indexSearcher.close();
           } catch (IOException e) {
                  throw new RuntimeException(e);
           }
     }
}
 
public class SearchResult<T> {
private int count;
private List<T> list;

public SearchResult(int count, List<T> list) {
this.count = count;
this.list = list;
}
//提供set和get方法
}
private ArticleIndexDao1 indexDao1 = new ArticleIndexDao1();
@Test
public void testSave_1() {
// 模拟了一个已保存到数据库中的数据
Article article = new Article();
article.setId(1);
article.setTitle("Lucene全文检索的说明");
article.setContent("全文检索（Full-Text Retrieval）是指以文本作为检索对象，找出含有指定词汇的文本。");
indexDao1.save(article);
}
@Test
public void testSave_25() {
for(int i=1;i<=25;i++){
// 模拟了一个已保存到数据库中的数据
Article article = new Article();
article.setId(i);
article.setTitle("Lucene全文检索的说明");
article.setContent("全文检索（Full-Text Retrieval）是指以文本作为检索对象，找出含有指定词汇的文本。");
indexDao1.save(article);
}
}
private ArticleIndexDao1 indexDao1 = new ArticleIndexDao1();
@Test
public void testDelete() {
Integer id = 1;
indexDao1.delete(id);
}

@Test
public void testUpdate() {
// 模拟了一个已保存到数据库中的数据
Article article = new Article();
article.setId(1);
article.setTitle("Lucene全文检索的说明123");
article.setContent("这是更新后的数据123");
indexDao1.update(article);
}
private ArticleIndexDao1 indexDao1 = new ArticleIndexDao1();
@Test
public void testSearch() {
String queryString = "lucene";
//SearchResult<Article> queryResult = indexDao1.search(queryString, 0, 10000);
//SearchResult<Article> queryResult = indexDao1.search(queryString, 0, 10);
//SearchResult<Article> queryResult = indexDao1.search(queryString, 10, 10);
SearchResult<Article> queryResult = indexDao1.search(queryString, 20, 10);
System.out.println("总记录数是："+ queryResult.getCount());
for(Article article: queryResult.getList()){
System.out.println("-----------> id = " + article.getId());
System.out.println("title  = " + article.getTitle());
System.out.println("content= " + article.getContent());
}
}
IndexWriter indexWriter = new IndexWriter(Configuration.getDirectory(),Configuration.getAnalyzer(),MaxFieldLength.LIMITED);
//indexWriter.close();

IndexWriter indexWriter2 = new IndexWriter(Configuration.getDirectory(),Configuration.getAnalyzer(),MaxFieldLength.LIMITED);
//indexWriter2.close();

 

java所搜引擎slor学习笔记(一)

标签：Lucene   style   blog   http   io   color   os   ar   使用   

原文地址：http://www.cnblogs.com/guhao123/p/4055429.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！