`

【转】基于Lucene框架 Compass 的使用例子

 
阅读更多

Compass 资源下载地址：

http://sourceforge.net/projects/compass/files/compass/2.2.0/compass-2.2.0-with-dependencies.zip/download

选取三个jar包：commons-logging.jar, compass-2.2.0.jar, lucene-core.jar.

使用OSEM(Object/SearchEngine Mapping)映射方案

 

映射的实体对象Book.java：

 

01 package com.sse.first;
02  
03 import org.compass.annotations.Index;
04 import org.compass.annotations.Searchable;
05 import org.compass.annotations.SearchableId;
06 import org.compass.annotations.SearchableProperty;
07 import org.compass.annotations.Store;
08  
09 @Searchable
10 public class Book {
11  
12 private String id;
13 private String title;
14 private String author;
15 private float price;
16  
17 public Book(){}
18  
19 public Book(String id, String title, String author, float price){
20 this.id = id;
21 this.title = title;
22 this.author = author;
23 this.price = price;
24 }
25  
26 @SearchableId
27 public String getId() {
28 return id;
29 }
30 public void setId(String id) {
31 this.id = id;
32 }
33  
34 @SearchableProperty(boost=2.0F, index=Index.TOKENIZED, store=Store.YES)
35 public String getTitle() {
36 return title;
37 }
38 public void setTitle(String title) {
39 this.title = title;
40 }
41  
42 @SearchableProperty(index=Index.TOKENIZED, store=Store.YES)
43 public String getAuthor() {
44 return author;
45 }
46 public void setAuthor(String author) {
47 this.author = author;
48 }
49  
50 @SearchableProperty(index=Index.NO, store=Store.YES)
51 public float getPrice() {
52 return price;
53 }
54 public void setPrice(float price) {
55 this.price = price;
56 }
57  
58 @Override
59 public String toString() {
60 return "[ "+ id +" ] " + title +" -- " + author + " $ " + price;
61 }
62  
63  
64 }

 

主搜索服务Searcher.java:

package com.sse.first;

001 import java.util.ArrayList;
002 import java.util.Collections;
003 import java.util.List;
004  
005 import org.compass.annotations.config.CompassAnnotationsConfiguration;
006 import org.compass.core.Compass;
007 import org.compass.core.CompassException;
008 import org.compass.core.CompassHits;
009 import org.compass.core.CompassSession;
010 import org.compass.core.CompassTransaction;
011  
012 public class Searcher {
013  
014 private Compass compass;
015  
016 /**
017 * 初始化检索器
018 * @param path
019 */
020 public Searcher(String path){
021 compass = new CompassAnnotationsConfiguration()
022 .setConnection(path)
023 .addClass(Book.class)
024 .setSetting("compass.engine.highlighter.default.formatter.simple.pre", "<b>")
025 .setSetting("compass.engine.highlighter.default.formatter.simple.post", "</b>")
026 .buildCompass();
027  
028 Runtime.getRuntime().addShutdownHook(new Thread(){
029 public void run(){
030 compass.close();
031 }
032 });
033 }
034  
035 /**
036 * 建立数据索引
037 * @param book
038 */
039 public void index(Book book){
040 System.out.println("index book : " + book);
041 CompassSession session = null;
042 CompassTransaction tx = null;
043  
044 try {
045 session = compass.openSession();
046 tx = session.beginTransaction();
047  
048 session.create(book);
049 tx.commit();
050 } catch (CompassException e) {
051 tx.rollback();
052 e.printStackTrace();
053 } finally{
054 if ( session != null )
055 session.close();
056 }
057  
058 }
059  
060 /**
061 * 删除索引
062 * @param book
063 */
064 public void unIndex(Book book){
065 CompassSession session = null;
066 CompassTransaction tx = null;
067  
068 try {
069 session = compass.openSession();
070 tx = session.beginTransaction();
071  
072 session.delete(book);
073 tx.commit();
074 } catch (CompassException e) {
075 tx.rollback();
076 e.printStackTrace();
077 } finally{
078 if ( session != null )
079 session.close();
080 }
081  
082 }
083  
084 /**
085 * 重置对象索引
086 * @param book
087 */
088 public void reIndex(Book book){
089 unIndex(book);
090 index(book);
091 }
092  
093 /**
094 * 查询
095 * @param q
096 * @return
097 */
098 @SuppressWarnings("unchecked")
099 public List<Book> search(String q){
100 CompassSession session = null;
101 CompassTransaction tx = null;
102  
103 try {
104 session = compass.openSession();
105 tx = session.beginTransaction();
106 CompassHits hits = session.find(q);
107  
108 int n = hits.length();
109 if ( n == 0 )
110 return Collections.EMPTY_LIST;
111  
112 List<Book> books = new ArrayList<Book>(n);
113 for (int i = 0; i < n; i++)
114 books.add((Book)hits.data(i));
115  
116 hits.close();
117 tx.commit();
118 return books;
119 } catch (CompassException e) {
120 tx.rollback();
121 e.printStackTrace();
122 }
123 return Collections.EMPTY_LIST;
124 }
125 }

 

 

测试主入口main.java:

001 package com.sse.first;
002  
003 import java.io.BufferedReader;
004 import java.io.File;
005 import java.io.InputStreamReader;
006 import java.util.ArrayList;
007 import java.util.Iterator;
008 import java.util.List;
009 import java.util.UUID;
010  
011 import com.Const;
012  
013 //import javax.swing.JOptionPane;
014  
015 public class Main {
016  
017 static List<Book> db = new ArrayList<Book>();
018 static Searcher search = new Searcher(Const.indexPath);
019  
020 public static void main(String[] args) {
021 // deleteAllBooks();
022  
023 add(new Book(UUID.randomUUID().toString(), "Thinking in Java", "Bruce", 10.9f));
024 add(new Book(UUID.randomUUID().toString(), "Effective Java", "Joshua", 12.4f));
025 add(new Book(UUID.randomUUID().toString(), "Java Thread Programming", "Pail", 25.6f));
026  
027 Runtime.getRuntime().addShutdownHook(new Thread(){
028 public void run(){
029 deleteAllIndex(null);
030 }
031 });
032  
033 int n;
034 do{
035 n = displaySelection();
036 switch(n){
037 case 1 :
038 listBooks();
039 break;
040 case 2 :
041 addBook();
042 break;
043 case 3 :
044 deleteBook();
045 break;
046 case 4 :
047 searchBook();
048 break;
049 case 5 :
050 return;
051 }
052 }while ( n != 0 );
053 }
054  
055 private static int displaySelection() {
056 System.out.println("\n=====select index ======= ");
057 System.out.println("1. List all books ");
058 System.out.println("2. Add new book");
059 System.out.println("3. Delete book");
060 System.out.println("4. Search book");
061 System.out.println("5. Exit");
062 int n = readKey();
063 if ( n >= 1 && n <= 5 )
064 return n;
065 return 0;
066 }
067  
068 /**
069 * 从控制台读数字作为参数
070 * @return
071 */
072 private static int readKey() {
073 // String ss=JOptionPane.showInputDialog("","Select Index :");
074 // try{
075 // return Integer.parseInt(ss);
076 // }catch(Exception e){
077 // System.out.println("输入的数据类型不对，程序将退出");
078 // System.exit(0);
079 // }
080  
081 System.out.println("Select Index :");
082 BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
083 try{
084 return Integer.parseInt(reader.readLine());
085 }catch(Exception e){
086 throw new RuntimeException();
087 }
088 }
089  
090 /**
091 * 从控制台读字符串作为参数
092 * @param prompt
093 * @return
094 */
095 private static String readLine(String prompt) {
096 // return JOptionPane.showInputDialog("" , prompt);
097 System.out.println(prompt);
098 BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
099 try{
100 return reader.readLine();
101 }catch(Exception e){
102 throw new RuntimeException();
103 }
104 }
105  
106 /**
107 * 检索数据
108 */
109 private static void searchBook() {
110 String q = readLine("Enter keyword: ");
111 List<Book> books = search.search(q);
112 System.out.println("============ Search Results: " + books.size() + " ======== ");
113 for (Book book : books ) {
114 System.out.println(book);
115 }
116  
117 }
118  
119 /**
120 * 删除数据，并删除索引
121 */
122 private static void deleteBook() {
123 listBooks();
124 System.out.println("Book Index: ");
125 int n = readKey();
126 Book book = db.remove(n - 1 );
127 search.unIndex(book);
128 }
129  
130 // private static void deleteAllBooks(){
131 // for (Book book : db ){
132 // db.remove(book);
133 // search.unIndex(book);
134 // }
135 // }
136  
137 /**
138 * 删除所有的索引文件
139 * @param file
140 */
141 private static void deleteAllIndex(File file){
142 if ( file == null)
143 file = new File(Const.indexPath);
144  
145 if ( file.exists() ){
146 if ( file.isFile() )
147 file.delete();
148 else if ( file.isDirectory() ){
149 File files[] = file.listFiles();
150 for (File temp : files){
151 deleteAllIndex(temp);
152 }
153 }
154 }
155 }
156  
157 /**
158 * 添加新的数据
159 */
160 private static void addBook() {
161 String title = readLine(" Title: ");
162 String author = readLine("Author: ");
163 String price = readLine(" Price: ");
164  
165 Book book = new Book(UUID.randomUUID().toString(), title, author,Float.parseFloat(price));
166 add(book);
167 }
168  
169 /**
170 * 列出所有的数据
171 */
172 private static void listBooks(){
173 System.out.println(" =======DataBase=========");
174 for (Iterator<Book> iterator = db.iterator(); iterator.hasNext();) {
175 Book book = (Book) iterator.next();
176 System.out.println(book.toString());
177 }
178 }
179  
180 /**
181 * 添加数据并建立索引
182 * @param book
183 */
184 private static void add(Book book){
185 db.add(book);
186 search.index(book);
187 }
188  
189 }
分享到：
| 【转】UML建模之业务处理模型（Business P ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    基于lucene的compass框架

    Compass将lucene、Spring、Hibernate三者的起来，以很低很低的成本快速实现企业应用中的搜索功能。 ... 下面是compass在spring中的简明配

    基于Lucene的搜索引擎框架Compass教程

    **基于Lucene的搜索引擎框架Compass教程** 在信息爆炸的时代，如何快速、准确地检索到所需数据成为了一个关键问题。Lucene，一个强大的全文搜索引擎库，为开发者提供了强大的索引和搜索功能。然而，直接使用Lucene...

    Lucene+compass学习资料

    Compass是一个基于Lucene的全文搜索引擎框架，它将Lucene的功能与对象关系映射（ORM）框架相结合，如Hibernate和JPA。通过Compass，开发者可以方便地在数据库中的实体对象上实现全文搜索。Compass提供了元数据管理、...

    基于lucene框架开发的全文搜索引擎含源代码

    本系统是基于lucene框架开发的全文搜索引擎，能实现txt、doc、pdf、excel、ppt等常见文档的全文检索，可以直接部署到tomcat下即可运行，需要研究lucene或实际应用lucene框架的朋友，欢迎下载。

    一个基于LUCENE搜索引擎项目例子

    **基于LUCENE的搜索引擎项目详解** Apache Lucene是一个高性能、全文本搜索库，它为开发者提供了构建全文搜索引擎所需要的基础工具。在这个项目例子中，我们将深入探讨如何利用Lucene进行索引构建、查询处理以及...

    使用compass+lucene实现简单的全文检索功能

    Compass 是基于 Lucene 构建的一个高级搜索引擎框架，它简化了 Lucene 的使用，并且提供了更多的特性，如自动索引、ORM 集成（Object-Relational Mapping）以及对多种持久化技术的支持，如 JPA、Hibernate 和 ...

    lucene 搜索引擎 compass

    而Compass则是一个基于Lucene的搜索引擎框架，它为Lucene提供了更高级别的抽象和更方便的使用方式，让开发更加高效便捷。 Lucene的核心功能包括文档的索引和查询。在示例中，`lucene.html`展示了一个简单的HTML表单...

    Lucene+compass+spring+jdbc+庖丁的一个例子

    2. **Compass**: Compass是基于Lucene的一个开源搜索引擎框架，它简化了在Java应用中集成Lucene的过程。Compass提供了一种ORM（对象关系映射）的方式来处理Lucene索引，允许开发者直接对对象进行搜索，而无需关心...

    基于lucene的全文检索系统

    **基于Lucene的全文检索系统** Lucene是一个高性能、全文本搜索库，由Apache软件基金会开发，被广泛应用于各种搜索引擎的构建。它提供了一个简单但功能强大的API，可以帮助开发者快速地在大量文档中实现高效的全文...

    基于Luncene的compass框架详解-java

    基于Lucene的Compass框架详解-Java 一、Compass框架概述 Compass是一个高性能的开源Java搜索引擎框架，旨在简化应用程序与搜索引擎之间的集成过程。它不仅利用了顶级的Lucene搜索引擎的强大功能，还融合了诸如...

    基于Lucene的搜索引擎

    **基于Lucene的搜索引擎** Lucene是一个开源的全文检索库，由Apache软件基金会开发并维护。它是Java编写的一个高性能、可扩展的信息检索库，为开发者提供了构建搜索功能的基础框架。这个课程设计创建了一个简单的...

    基于Lucene的搜索引擎的研究与应用

    文章主要研究和应用了基于Lucene的搜索引擎，其特点是利用开源网络爬虫工具抓取互联网信息，并通过Lucene的API对特定信息进行索引和搜索。下面详细介绍相关知识点。 1. Lucene基础 Lucene是由Apache软件基金会提供...

    基于Lucene的小型搜索引擎

    《基于Lucene的小型搜索引擎构建详解》 在信息爆炸的时代，如何快速、准确地找到所需信息成为了一项挑战。搜索引擎作为解决这一问题的关键工具，其技术实现也引起了广泛关注。本篇将详细介绍一个基于Apache Lucene...

    基于JavaLuncene的compass框架说明使用技术文档.doc

    Compass 是一个基于 Java 的搜索引擎框架，它充分利用了 Apache Lucene 的强大功能，并与流行的框架如 Hibernate 和 Spring 集成，使得在 Java 应用中集成全文搜索变得简单高效。该框架的主要目的是减少开发者的编码...

    基于Lucene的中型搜索引擎(C#)

    **基于Lucene的中型搜索引擎(C#)** 在IT领域，搜索引擎是不可或缺的一部分，它们能够高效地处理海量数据，帮助用户快速找到所需信息。本文将深入探讨一个基于Apache Lucene的中型搜索引擎实现，该实现是由...

    LUCENE的搜索引擎例子

    1. **索引创建**：这是搜索引擎的第一步，我们需要遍历要索引的数据源（例如文件系统、数据库等），读取内容，并使用Lucene的Analyzer进行分词，然后创建Term（词项）和Document（文档）。Analyzer是负责文本分析的...

    基于lucene技术的增量索引

    **基于Lucene技术的增量索引** 在信息技术领域，全文搜索引擎是处理大量数据查询的关键工具。Apache Lucene是一个开源的全文检索库，被广泛应用于构建高效、可扩展的搜索功能。本文将深入探讨如何利用Lucene实现...

    compass2.1.4包+所用lucene包+中文分词器

    Compass 是一个基于 Lucene 的全文检索框架，它提供了一种高级的、面向对象的方式来管理和集成搜索引擎到你的应用程序中。在“compass2.1.4包”中，包含了 Compass 框架的版本 2.1.4，这个版本可能包含了性能优化、...

    基于Lucene的全文检索系统

    【标题】：“基于Lucene的全文检索系统” 【描述】提到的“在学校教育网上搜的 不知道帮助大不大 看看吧 也许会用得到 好多个 可能有重复”暗示了资源可能包含多个关于Lucene全文检索系统的PDF文档，这些文档可能...

Magicbox
Global site tag (gtag.js) - Google Analytics