Compass入门指南(二)

最新推荐文章于 2024-07-28 02:46:19 发布
最新推荐文章于 2024-07-28 02:46:19 发布
阅读量128 收藏
点赞数
文章标签： lucene SSH Hibernate Eclipse 框架
本文介绍如何使用Compass框架对数据库进行索引，并演示了通过Java实现的书籍搜索应用。涉及Compass安装配置、实体注解定义及索引、搜索操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Compass框架的参考文档,Compass是在Lucene的基础上做了封装，支持索引事务控制和增量索引，同时也能够和主流的SSH框架完美地整合在一起,操作Compass类似于操作Hibernate，它们的类/方法等设计的非常相似。下面我们通过一个实例来看看Compass到底是怎样来索引数据库，操作索引库和实现搜索功能的。
步骤一：下载Compass，目前最新版本是2.2.0，可以到http://www.compass-project.org/上下载。
步骤二：在Eclipse中新建一个Java Project，解压compass-2.2.0-with-dependencies.zip，将dist目录下的compass-2.2.0.jar，commons-logging.jar和dist/lucene目录下的lucene-analyzers.jar，lucene-core.jar，lucene-highlighter.jar拷贝在工程的构建路径下.
步骤三：新建一个Book（书籍）类，这个类就是我们要搜索的对象，其完整代码如下：

Java代码 复制代码
  2. importorg.compass.annotations.Index;
  3. importorg.compass.annotations.Searchable;
  4. importorg.compass.annotations.SearchableId;
  5. importorg.compass.annotations.SearchableProperty;
  6. importorg.compass.annotations.Store;
  8. @Searchable
  9. publicclassBook{
  10. privateStringid;//编号
  11. privateStringtitle;//标题
  12. privateStringauthor;//作者
  13. privatefloatprice;//价格
  15. publicBook(){
  16. }
  18. publicBook(Stringid,Stringtitle,Stringauthor,floatprice){
  19. super();
  20. this.id=id;
  21. this.title=title;
  22. this.author=author;
  23. this.price=price;
  24. }
  26. @SearchableId
  27. publicStringgetId(){
  28. returnid;
  29. }
  31. @SearchableProperty(boost=2.0F,index=Index.TOKENIZED,store=Store.YES)
  32. publicStringgetTitle(){
  33. returntitle;
  34. }
  36. @SearchableProperty(index=Index.TOKENIZED,store=Store.YES)
  37. publicStringgetAuthor(){
  38. returnauthor;
  39. }
  41. @SearchableProperty(index=Index.NO,store=Store.YES)
  42. publicfloatgetPrice(){
  43. returnprice;
  44. }
  46. publicvoidsetId(Stringid){
  47. this.id=id;
  48. }
  50. publicvoidsetTitle(Stringtitle){
  51. this.title=title;
  52. }
  54. publicvoidsetAuthor(Stringauthor){
  55. this.author=author;
  56. }
  58. publicvoidsetPrice(floatprice){
  59. this.price=price;
  60. }
  62. @Override
  63. publicStringtoString(){
  64. return"["+id+"]"+title+"-"+author+"$"+price;
  65. }
  67. }
import org.compass.annotations.Index;
import org.compass.annotations.Searchable;
import org.compass.annotations.SearchableId;
import org.compass.annotations.SearchableProperty;
import org.compass.annotations.Store;

@Searchable
public class Book {
	private String id;//编号
	private String title;//标题
	private String author;//作者
	private float price;//价格

	public Book() {
	}

	public Book(String id, String title, String author, float price) {
		super();
		this.id = id;
		this.title = title;
		this.author = author;
		this.price = price;
	}

	@SearchableId
	public String getId() {
		return id;
	}

	@SearchableProperty(boost = 2.0F, index = Index.TOKENIZED, store = Store.YES)
	public String getTitle() {
		return title;
	}

	@SearchableProperty(index = Index.TOKENIZED, store = Store.YES)
	public String getAuthor() {
		return author;
	}

	@SearchableProperty(index = Index.NO, store = Store.YES)
	public float getPrice() {
		return price;
	}

	public void setId(String id) {
		this.id = id;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

	public void setPrice(float price) {
		this.price = price;
	}

	@Override
	public String toString() {
		return "[" + id + "] " + title + " - " + author + " $ " + price;
	}

}


这里有几个要注意的地方：@Searchable表示该类的对象是可被搜索的；@SearchableId表示索引建立的id；@SearchableProperty表示此字段可以被索引、被检索；对于Index，Store在这里就不作介绍了，不熟悉的朋友可以去看看Lucene API。
步骤四：新建一个Searcher类，该类封装了对索引库的一些操作，包括新建索引，删除索引，重建索引，搜索等等。完整代码如下：

Java代码 复制代码
  1. importjava.util.ArrayList;
  2. importjava.util.Collections;
  3. importjava.util.List;
  5. importorg.compass.annotations.config.CompassAnnotationsConfiguration;
  6. importorg.compass.core.Compass;
  7. importorg.compass.core.CompassHits;
  8. importorg.compass.core.CompassSession;
  9. importorg.compass.core.CompassTransaction;
  11. publicclassSearcher
  12. {
  13. protectedCompasscompass;
  15. publicSearcher()
  16. {
  17. }
  19. /**
  20. *初始化Compass
  21. *@parampath
  22. */
  23. publicSearcher(Stringpath)
  24. {
  25. compass=newCompassAnnotationsConfiguration().setConnection(path).addClass(Book.class).setSetting("compass.engine.highlighter.default.formatter.simple.pre","<fontcolor='red'>").setSetting(
  26. "compass.engine.highlighter.default.formatter.simple.post","</font>").buildCompass();
  27. Runtime.getRuntime().addShutdownHook(newThread()
  28. {
  29. publicvoidrun()
  30. {
  31. compass.close();
  32. }
  33. });
  35. }
  37. /**
  38. *新建索引
  39. *@parambook
  40. */
  41. publicvoidindex(Bookbook)
  42. {
  43. CompassSessionsession=null;
  44. CompassTransactiontx=null;
  45. try
  46. {
  47. session=compass.openSession();
  48. tx=session.beginTransaction();
  49. session.create(book);
  50. tx.commit();
  51. }catch(RuntimeExceptione)
  52. {
  53. if(tx!=null)
  54. tx.rollback();
  55. throwe;
  56. }finally
  57. {
  58. if(session!=null)
  59. {
  60. session.close();
  61. }
  62. }
  63. }
  65. /**
  66. *删除索引
  67. *@parambook
  68. */
  69. publicvoidunIndex(Bookbook)
  70. {
  71. CompassSessionsession=null;
  72. CompassTransactiontx=null;
  73. try
  74. {
  75. session=compass.openSession();
  76. tx=session.beginTransaction();
  77. session.delete(book);
  78. tx.commit();
  79. }catch(RuntimeExceptione)
  80. {
  81. tx.rollback();
  82. throwe;
  83. }finally
  84. {
  85. if(session!=null)
  86. {
  87. session.close();
  88. }
  89. }
  90. }
  92. /**
  93. *重建索引
  94. *@parambook
  95. */
  96. publicvoidreIndex(Bookbook)
  97. {
  98. unIndex(book);
  99. index(book);
  100. }
  102. /**
  103. *搜索
  104. *@paramqueryString
  105. *@return
  106. */
  107. publicList<Book>search(StringqueryString)
  108. {
  109. CompassSessionsession=null;
  110. CompassTransactiontx=null;
  111. try
  112. {
  113. session=compass.openSession();
  114. tx=session.beginTransaction();
  115. CompassHitshits=session.find(queryString);
  116. intn=hits.length();
  117. if(0==n)
  118. {
  119. returnCollections.emptyList();
  120. }
  121. List<Book>books=newArrayList<Book>();
  122. for(inti=0;i<n;i++)
  123. {
  124. books.add((Book)hits.data(i));
  125. }
  126. hits.close();
  127. tx.commit();
  128. returnbooks;
  129. }catch(RuntimeExceptione)
  130. {
  131. tx.rollback();
  132. throwe;
  133. }finally
  134. {
  135. if(session!=null)
  136. {
  137. session.close();
  138. }
  139. }
  140. }
  141. }
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.compass.annotations.config.CompassAnnotationsConfiguration;
import org.compass.core.Compass;
import org.compass.core.CompassHits;
import org.compass.core.CompassSession;
import org.compass.core.CompassTransaction;

public class Searcher
{
	protected Compass compass;

	public Searcher()
	{
	}

	/**
	 * 初始化Compass
	 * @param path
	 */
	public Searcher(String path)
	{
		compass = new CompassAnnotationsConfiguration().setConnection(path).addClass(Book.class).setSetting("compass.engine.highlighter.default.formatter.simple.pre", "<font color='red'>").setSetting(
				"compass.engine.highlighter.default.formatter.simple.post", "</font>").buildCompass();
		Runtime.getRuntime().addShutdownHook(new Thread()
		{
			public void run()
			{
				compass.close();
			}
		});

	}

	/**
	 * 新建索引
	 * @param book
	 */
	public void index(Book book)
	{
		CompassSession session = null;
		CompassTransaction tx = null;
		try
		{
			session = compass.openSession();
			tx = session.beginTransaction();
			session.create(book);
			tx.commit();
		} catch (RuntimeException e)
		{
			if(tx!=null)
				tx.rollback();
			throw e;
		} finally
		{
			if (session != null)
			{
				session.close();
			}
		}
	}

	/**
	 * 删除索引
	 * @param book
	 */
	public void unIndex(Book book)
	{
		CompassSession session = null;
		CompassTransaction tx = null;
		try
		{
			session = compass.openSession();
			tx = session.beginTransaction();
			session.delete(book);
			tx.commit();
		} catch (RuntimeException e)
		{
			tx.rollback();
			throw e;
		} finally
		{
			if (session != null)
			{
				session.close();
			}
		}
	}

	/**
	 * 重建索引
	 * @param book
	 */
	public void reIndex(Book book)
	{
		unIndex(book);
		index(book);
	}

	/**
	 * 搜索
	 * @param queryString
	 * @return
	 */
	public List<Book> search(String queryString)
	{
		CompassSession session = null;
		CompassTransaction tx = null;
		try
		{
			session = compass.openSession();
			tx = session.beginTransaction();
			CompassHits hits = session.find(queryString);
			int n = hits.length();
			if (0 == n)
			{
				return Collections.emptyList();
			}
			List<Book> books = new ArrayList<Book>();
			for (int i = 0; i < n; i++)
			{
				books.add((Book) hits.data(i));
			}
			hits.close();
			tx.commit();
			return books;
		} catch (RuntimeException e)
		{
			tx.rollback();
			throw e;
		} finally
		{
			if (session != null)
			{
				session.close();
			}
		}
	}
}


步骤五：新建一个测试类进行测试.完整源码如下：

Java代码 复制代码
  1. importjava.io.BufferedReader;
  2. importjava.io.InputStreamReader;
  3. importjava.util.ArrayList;
  4. importjava.util.List;
  5. importjava.util.UUID;
  7. publicclassMain
  8. {
  9. staticList<Book>db=newArrayList<Book>();
  10. staticSearchersearcher=newSearcher("E:/index");
  12. publicstaticvoidmain(String[]args)
  13. {
  14. add(newBook(UUID.randomUUID().toString(),"ThinkinginJava","Bruce",109.0f));
  15. add(newBook(UUID.randomUUID().toString(),"EffectiveJava","Joshua",12.4f));
  16. add(newBook(UUID.randomUUID().toString(),"JavaThreadPrograming","Paul",25.8f));
  17. intn;
  18. do
  19. {
  20. n=displaySelection();
  21. switch(n)
  22. {
  23. case1:
  24. listBooks();
  25. break;
  26. case2:
  27. addBook();
  28. break;
  29. case3:
  30. deleteBook();
  31. break;
  32. case4:
  33. searchBook();
  34. break;
  35. case5:
  36. return;
  37. }
  38. }while(n!=0);
  39. }
  41. staticintdisplaySelection()
  42. {
  43. System.out.println("\n==select==");
  44. System.out.println("1.Listallbooks");
  45. System.out.println("2.Addbook");
  46. System.out.println("3.Deletebook");
  47. System.out.println("4.Searchbook");
  48. System.out.println("5.Exit");
  49. intn=readKey();
  50. if(n>=1&&n<=5)
  51. returnn;
  52. return0;
  53. }
  55. /**
  56. *增加一本书到数据库和索引中
  57. *@parambook
  58. */
  59. privatestaticvoidadd(Bookbook)
  60. {
  61. db.add(book);
  62. searcher.index(book);
  63. }
  65. /**
  66. *打印出数据库中的所有书籍列表
  67. */
  68. publicstaticvoidlistBooks()
  69. {
  70. System.out.println("==Database==");
  71. intn=1;
  72. for(Bookbook:db)
  73. {
  74. System.out.println(n+")"+book);
  75. n++;
  76. }
  77. }
  79. /**
  80. *根据用户录入，增加一本书到数据库和索引中
  81. */
  82. publicstaticvoidaddBook()
  83. {
  84. Stringtitle=readLine("Title:");
  85. Stringauthor=readLine("Author:");
  86. Stringprice=readLine("Price:");
  87. Bookbook=newBook(UUID.randomUUID().toString(),title,author,Float.valueOf(price));
  88. add(book);
  89. }
  91. /**
  92. *删除一本书，同时删除数据库，索引库中的
  93. */
  94. publicstaticvoiddeleteBook()
  95. {
  96. listBooks();
  97. System.out.println("Bookindex:");
  98. intn=readKey();
  99. Bookbook=db.remove(n-1);
  100. searcher.unIndex(book);
  101. }
  103. /**
  104. *根据输入的关键字搜索书籍
  105. */
  106. publicstaticvoidsearchBook()
  107. {
  108. StringqueryString=readLine("Enterkeyword:");
  109. List<Book>books=searcher.search(queryString);
  110. System.out.println("====searchresults:"+books.size()+"====");
  111. for(Bookbook:books)
  112. {
  113. System.out.println(book);
  114. }
  115. }
  117. publicstaticintreadKey()
  118. {
  119. BufferedReaderreader=newBufferedReader(newInputStreamReader(System.in));
  120. try
  121. {
  122. intn=reader.read();
  123. n=Integer.parseInt(Character.toString((char)n));
  124. returnn;
  125. }catch(Exceptione)
  126. {
  127. thrownewRuntimeException();
  128. }
  129. }
  131. publicstaticStringreadLine(Stringpropt)
  132. {
  133. System.out.println(propt);
  134. BufferedReaderreader=newBufferedReader(newInputStreamReader(System.in));
  135. try{
  136. returnreader.readLine();
  137. }catch(Exceptione)
  138. {
  139. thrownewRuntimeException();
  140. }
  141. }
  142. }
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class Main
{
	static List<Book> db = new ArrayList<Book>();
	static Searcher searcher = new Searcher("E:/index");

	public static void main(String[] args)
	{
		add(new Book(UUID.randomUUID().toString(), "Thinking in Java", "Bruce", 109.0f));
		add(new Book(UUID.randomUUID().toString(), "Effective Java", "Joshua", 12.4f));
		add(new Book(UUID.randomUUID().toString(), "Java Thread Programing", "Paul", 25.8f));
		int n;
		do
		{
			n = displaySelection();
			switch (n)
			{
			case 1:
				listBooks();
				break;
			case 2:
				addBook();
				break;
			case 3:
				deleteBook();
				break;
			case 4:
				searchBook();
				break;
			case 5:
				return;
			}
		} while (n != 0);
	}

	static int displaySelection()
	{
		System.out.println("\n==select==");
		System.out.println("1. List all books");
		System.out.println("2. Add book");
		System.out.println("3. Delete book");
		System.out.println("4. Search book");
		System.out.println("5. Exit");
		int n = readKey();
		if (n >= 1 && n <= 5)
			return n;
		return 0;
	}

	/**
	 * 增加一本书到数据库和索引中
	 * @param book
	 */
	private static void add(Book book)
	{
		db.add(book);
		searcher.index(book);
	}

	/**
	 * 打印出数据库中的所有书籍列表
	 */
	public static void listBooks()
	{
		System.out.println("==Database==");
		int n =1;
		for (Book book :db)
		{
			System.out.println(n+")"+book);
			n++;
		}
	}

	/**
	 * 根据用户录入，增加一本书到数据库和索引中
	 */
	public static void addBook()
	{
		String title = readLine(" Title: ");
		String author = readLine(" Author: ");
		String price = readLine(" Price: ");
		Book book = new Book(UUID.randomUUID().toString(),title,author,Float.valueOf(price));
		add(book);
	}

	/**
	 * 删除一本书，同时删除数据库，索引库中的
	 */
	public static void deleteBook()
	{
		listBooks();
		System.out.println("Book index: ");
		int n = readKey();
		Book book = db.remove(n-1);
		searcher.unIndex(book);
	}

	/**
	 * 根据输入的关键字搜索书籍
	 */
	public static void searchBook()
	{
		String queryString = readLine(" Enter keyword: ");
		List<Book> books = searcher.search(queryString);
		System.out.println(" ====search results:"+books.size()+"====");
		for (Book book :books)
		{
			System.out.println(book);
		}
	}

	public static int readKey()
	{
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		try
		{
			int n = reader.read();
			n=Integer.parseInt(Character.toString((char)n));
			return n;
		}catch(Exception e)
		{
			throw new RuntimeException();
		}
	}
	
	public static String readLine(String propt)
	{
		System.out.println(propt);
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		try{
			return reader.readLine();
		}catch(Exception e)
		{
			throw new RuntimeException();
		}
	}
}
iteye_20309
关注
Compass 2.0M2 DocumenTation(API) chm英文版
02-03
Compass是第一个实现java搜索引擎的开源框架,它是基于Lucene之上的，提供更简单的搜索引擎API，事务支持，对象到搜索引擎映射（Annotations
Compass2.0.2自带例子解析
白强
09-05 369
Compass2.0.2自带例子解析： 下面的代码来自compass自带的例子 代码如下： Author.java 1. package com.tutorial; 2. 3. import java.util.ArrayList; 4. import java.util.Date; 5. import java.util.List; 6. 7. public cla...
Compass原理深入学习笔记
09-05
Compass原理深入学习笔记，对于compass知识的一个梳理，希望对大家有用
重拾Compass之Compass2.0.2版本自带例子分析
【昆山人在上海】
10-29 1673
接上例：http://blog.youkuaiyun.com/kunshan_shenbin/archive/2008/10/28/3168079.aspx先看看compass的技术资料：http://www.compass-project.org/docs/2.0.2/reference/html/老实说，从我第一次接触她，就有一种熟悉的感觉，因为他跟Hibernate的API真的是太像了。下面
compass入门指南
01-16
### Compass入门指南：深入理解与实战应用 #### 核心概念解析 **1.1 Annotation vs. XML配置文件** 在Compass中，开发者可以选择使用Annotation或XML配置文件来进行配置。这两种方式各有优劣： - **Annotation...
Compass_入门指南
01-25
Compass 入门指南 Compass 是一个搜索引擎框架，旨在提供高效、可扩展的搜索解决方案。以下是 Compass 入门指南，涵盖了 Compass 的核心概念、配置文件、注解方式、核心 API、与 Spring 集成等方面。 Compass 的...
Compass入门指南：简化Lucene使用
"Compass使用详解 - 一种简化Lucene使用的框架" Compass是一个基于Java的搜索引擎框架，它为开发者提供了一种类似于Hibernate的方式来管理和操作Lucene索引。它旨在简化在应用程序中集成全文搜索引擎的过程，使得...
Foundation与Compass入门指南及快速升级方法
本文档旨在为开发者提供一个简便的入门指南，包含基础的安装和使用指南，以及项目升级的说明。" 知识点详细说明: 1. Foundation框架： Foundation是一个响应式前端框架，它由ZURB开发。它允许开发者快速构建跨...
MIT Beekeepers：快速掌握Foundation和Compass入门指南
2. Foundation + Compass入门：Foundation是一个响应式前端框架，它提供了一系列CSS和JavaScript组件，可以快速地帮助开发者构建出美观、现代化的网页界面。Compass是一个开源的CSS扩展框架，可以与Sass协同工作，...
compass-2.2.0.zip
03-03
compass-2.2.0.zip，Compass是第一个实现java搜索引擎的开源框架,它是基于Lucene之上的，提供更简单的搜索引擎API，事务支持，对象到搜索引擎映射
Compass2.2.0-Api (Chm)
01-25
根据HTML页面压缩的可查询的Compass最新API,是个人 压缩成Chm的,支持索引和搜索功能,3分应该不贵吧.
compass-2.2.1.jar
03-30
compass 最新的compass，值得下载
搜索引擎第五讲 从Lucene版的CRUD来理解Compass的原理
speadrace的专栏
11-12 611
 索引的CRUD与数据库的CRUD比较CRUD代码理解 涉及到的相关类的理解 CMD文件不同与数据库的地方，以及为什么它是这样的？
地磁传感器_磁感应计_电子罗盘(compass)原理
hjwang1的专栏
04-10 8711
ref: http://www.360doc.com/content/14/0724/23/9152906_396847920.shtml https://wenku.baidu.com/view/8fcb6f94284ac850ad024244.html
mongodbCompass连接数据库
最新发布
weixin_37060366的博客
07-28 343
数据库,go相关学习资料：https://edu.51cto.com/video/655.htmlhttps://edu.51cto.com/video/4196.htmlMongoDB Compass连接数据库指南 作为一名经验丰富的开发者，我很高兴能帮助你了解如何使用MongoDB Compass连接数据库。Mon...
Compass的一个简单例子
tommy小屋
11-27 260
Compass的一个简单例子 Compass是一个封装了Lucene的框架。使用Compass的API可以非常方便地建立索引、删除索引、实现检索。Compass非常像Hibernate，Compass封装了Lucene就像Hibernate封装了JDBC操作一样，通过简单的API就能实现底层的操作。 但是，初次接触Compass，并不像想象的那样，我想，在以后的不断学习中，会一点点地...
Compass2.0.2版本自带例子解析
fengdongming168的专栏
12-27 441
<br />下面的代码来自compass自带的例子 代码如下： <br />Author.java <br />   1. package com.tutorial; <br />   2. <br />   3. import java.util.ArrayList; <br />   4. import java.util.Date; <br />   5. import java.util.List; <br />   6. <br />   7. public class Author implem
全文检索Lucene（四）---Compass框架
一个无限死循环的博客
07-12 1078
Compass是一个强大的,事务的,高性能的对象/搜索引擎映射(OSEM:object/search engine mapping)与一个Java持久层框架。 Compass之于Lucene，就像Hibernate之于JDBC，Compass就是把Lucene封装了一层。 Compass目前版本是2.2.0，已经很久没有更新与维护。Compass2.2的版本所对应的Lucene2.4.1。下载地
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值