`
longgangbai
  • 浏览: 7325746 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

compass的开发應用JPA+Compass整合

阅读更多

查询结果的高亮显示:

 

采用的是JPA的注解方式,

首先看实体类:User.java

package com.compass.model;

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 User {

private Integer id;
private String userName;
private String sex;
private Integer age;
private String address;

public User() {
}

public User(Integer id) {
   this.id = id;
}

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

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

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

public void setUserName(String userName) {
   this.userName = userName;
}

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

public void setSex(String sex) {
   this.sex = sex;
}

@SearchableProperty(index = Index.TOKENIZED, store = Store.YES)
public Integer getAge() {
   return age;
}

public void setAge(Integer age) {
   this.age = age;
}

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

public void setAddress(String address) {
   this.address = address;
}

@Override
public int hashCode() {
   final int prime = 31;
   int result = 1;
   result = prime * result + ((id == null) ? 0 : id.hashCode());
   return result;
}

@Override
public boolean equals(Object obj) {
   if (this == obj)
    return true;
   if (obj == null)
    return false;
   if (getClass() != obj.getClass())
    return false;
   final User other = (User) obj;
   if (id == null) {
    if (other.id != null)
          return false;
   } else if (!id.equals(other.id))
       return false;
   return true;
}

@Override
public String toString() {
    return "id=" + id + ", userName=" + userName + ", sex=" + sex
        + ", age=" + age + ", address=" + address;
}
}

然后查询管理类,里面高亮什么的都设置这个里面

SearchManager.java

package com.compass.model;

import java.util.ArrayList;
import java.util.List;

import org.compass.core.Compass;
import org.compass.core.CompassCallback;
import org.compass.core.CompassException;
import org.compass.core.CompassHits;
import org.compass.core.CompassQuery;
import org.compass.core.CompassQueryBuilder;
import org.compass.core.CompassSession;
import org.compass.core.CompassTemplate;
import org.compass.core.CompassTransaction;
import org.compass.core.config.CompassConfiguration;

public class SearchManager {

protected Compass compass;

/**
* 初始化
*/
public void init() {
   CompassConfiguration cfg = new CompassConfiguration();
   cfg.setConnection("e:/test");
   cfg.setSetting(
     "compass.engine.highlighter.default.formatter.simple.pre",
     "<font color='red'>");
   cfg.setSetting(
     "compass.engine.highlighter.default.formatter.simple.post",
     "</font>");
   cfg.addClass(User.class);
   compass = cfg.buildCompass();
}

/**
* 创建索引
*/
public void createIndex(User user) {
   CompassSession session = compass.openSession();
   CompassTransaction tx = null;
   try {
   
   
    CompassQueryBuilder queryBuilder = session.queryBuilder();
    CompassHits hits = queryBuilder.bool()
       .addMust( queryBuilder.term("name", "jack") )
       .addMustNot( queryBuilder.term("familyName", "london") )
     .toQuery()
       .addSort("familyName", CompassQuery.SortPropertyType.STRING)
       .addSort("birthdate", CompassQuery.SortPropertyType.INT)
     .hits();
   
    tx = session.beginTransaction();
    session.create(user);
    tx.commit();
   } catch (Exception e) {
    if (tx != null) {
     tx.rollback();
    }
   } finally {
    if (session != null) {
     session.close();
    }
   }
}

/**
* 删除一条索引记录
*/
public void delete(User user) {
   CompassTemplate ct = new CompassTemplate(compass);
   ct.delete(user);
}

/**
* 更新(重新创建)一条索引记录
*/
public void update(final User user) {
   CompassTemplate ct = new CompassTemplate(compass);
   CompassCallback<Object> action = new CompassCallback<Object>() {

    public Object doInCompass(CompassSession session)
      throws CompassException {
     session.delete(user);
     session.create(user);
     return null;
    }
   };
   ct.execute(action);
}

/**
* 查询
*/

public List<User> find(final String key) {
   CompassTemplate ct = new CompassTemplate(compass);
   return ct.execute(new CompassCallback<List<User>>() {

    public List<User> doInCompass(CompassSession session)
      throws CompassException {

     List<User> result = new ArrayList<User>();

     CompassHits hits = session.find(key);

     for (int i = 0; i < hits.length(); i++) {
      User user = (User) hits.data(i);
      result.add(user);
     }
     return result;
    }
   });

}

/**
* 含有高亮的查询
*/
public List<User> find(final String key, final int start, final int end) {
   CompassTemplate ct = new CompassTemplate(compass);
   return ct.execute(new CompassCallback<List<User>>() {

    public List<User> doInCompass(CompassSession session)
      throws CompassException {

     List<User> result = new ArrayList<User>();

     CompassHits hits = session.find(key);
     int max=0;
     if(end<hits.length()){
      max=end;
     }else{
      max=hits.length();
     }
     for (int i = start; i < max; i++) {
      User user = (User) hits.data(i);

      String hit = hits.highlighter(i).fragment("userName");
      if (hit != null) {
       user.setUserName(hit);
      }
      String hc = hits.highlighter(i).fragment("address");
      if (hc != null) {
       user.setAddress(hc);
      }
      String hx = hits.highlighter(i).fragment("sex");
      if (hx != null) {
       user.setSex(hx);
      }
      result.add(user);
     }
     return result;
    }
   });

}
}

 

最后就是测试类TestMain.java

package com.compass.model;

import java.util.List;

import org.compass.core.CompassHits;
import org.compass.core.CompassQuery;
import org.compass.core.CompassQueryBuilder;
import org.junit.Test;

public class TestMain {

/**
* @param args
*/

private SearchManager searchManager;

public void setup() {
   searchManager = new SearchManager();
   searchManager.init();
}

public void insert() {
   User user = new User();
   user.setId(1);
   user.setUserName("吴琼");
   user.setAge(20);
   user.setSex("女");
   user.setAddress("北京");

   User user2 = new User();
   user2.setId(2);
   user2.setUserName("张舒");
   user2.setAge(20);
   user2.setSex("女");
   user2.setAddress("北京");

   searchManager.createIndex(user);
   searchManager.createIndex(user2);
}

@Test
public void insert2() {
   User user = new User();
   user.setId(1);
   user.setUserName("吴琼");
   user.setAge(20);
   user.setSex("女");
   user.setAddress("北京");

   User user2 = new User();
   user2.setId(2);
   user2.setUserName("张舒");
   user2.setAge(20);
   user2.setSex("女");
   user2.setAddress("哈尔滨");

   User user3 = new User();
   user3.setId(2);
   user3.setUserName("张舒");
   user3.setAge(20);
   user3.setSex("女");
   user3.setAddress("哈尔滨");

   searchManager.createIndex(user);
   searchManager.createIndex(user2);
   searchManager.createIndex(user3);
}

@Test
public void delete() {
   User user = new User(1);
   searchManager.delete(user);
}

@Test
public void search() {
   String key = "女";
   List<User> users = searchManager.find(key, 0,3);
   for (User user : users) {
    System.out.println(user.toString());
   }
}
public static void main(String[] args) {

   TestMain t = new TestMain();
   t.setup();
   t.insert();
   t.insert2();
   t.search();
   System.out.println("it's over...");
}

}

输出结果是:

2009-3-9 0:12:45 org.compass.core.config.CompassConfiguration addClass
信息: Mapping class [class com.compass.model.User]
2009-3-9 0:12:45 org.compass.core.lucene.engine.highlighter.LuceneHighlighterManager configure
信息: Building highlighter [default]
2009-3-9 0:12:46 org.compass.core.lucene.engine.optimizer.LuceneSearchEngineOptimizerManager start
信息: Starting scheduled optimizer [class org.compass.core.lucene.engine.optimizer.AdaptiveOptimizer] with period [10000ms]
2009-3-9 0:12:46 org.compass.core.lucene.engine.manager.DefaultLuceneSearchEngineIndexManager start
信息: Starting scheduled index manager with period [60000ms]
2009-3-9 0:12:46 org.compass.core.lucene.engine.manager.DefaultLuceneSearchEngineIndexManager start
信息: Starting scheduled refresh cache with period [5000ms]
i看到输出的没,是把标签给输出来了,如果到页面上就会高亮了

 

 

Spring +hibernate+compass 注解整合

和整合Spring+JPA+compass整合一样不同点如下:

 hibernate的注解的配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:p="http://www.springframework.org/schema/p"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
      
 <!-- support annotation config -->
 <context:annotation-config/>
 <context:component-scan base-package="cn.com.unutrip.compass.search">
  <context:include-filter type="regex" expression=".model..*"/>
  <context:include-filter type="regex" expression=".dao..*"/>
  <context:include-filter type="regex" expression=".services..*"/>
  <context:include-filter type="regex" expression=".facade..*"/>
 </context:component-scan>

      
      
 <bean id="datasource"
  class="org.apache.commons.dbcp.BasicDataSource">
  <property name="driverClassName"
   value="com.mysql.jdbc.Driver">
  </property>
  <property name="url"
   value="jdbc:mysql://localhost:3306/search">
  </property>
  <property name="username" value="root"></property>
  <property name="password" value="123456"></property>
 </bean>
 <bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
  <property name="dataSource">
   <ref bean="datasource" />
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">
     org.hibernate.dialect.MySQLDialect
    </prop>
    <!--设置二级缓冲-->
    <prop key="hibernate.cache.provider_class">
     org.hibernate.cache.EhCacheProvider
    </prop>
    <!--设置二级缓冲,打开查询缓冲-->
    <prop key="hibernate.cache.use_query_cache">true</prop>
    <!--设置显示Hibernate操作的SQL语句-->
    <prop key="hibernate.show_sql">true</prop>
   </props>
  </property>
  <property name="annotatedClasses">
   <list>
    <value>cn.com.unutrip.compass.search.model.Blog</value>
   </list>
  </property>
 </bean>
 <!-- 配置事务管理器 --> 
 <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory">
   <ref local="sessionFactory"/>
  </property>
 </bean>
    <!-- 配置事务特性 ,配置add、delete和update开始的方法,事务传播特性为required-->      
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
     <tx:attributes>
      <tx:method name="insert*" propagation="REQUIRED"/>
      <tx:method name="delete*" propagation="REQUIRED"/>
      <tx:method name="update*" propagation="REQUIRED"/>
      <tx:method name="*" read-only="true"/>
     </tx:attributes>
    </tx:advice>
   
 

</beans>

sping-search.xml配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation=" http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"
 default-lazy-init="true">
 <bean id="annotationConfiguration"
  class="org.compass.annotations.config.CompassAnnotationsConfiguration">
 </bean>
 <bean id="compass" class="org.compass.spring.LocalCompassBean">
  <property name="resourceDirectoryLocations">
   <list>
    <value>
     classpath:cn/com/unutrip/compass/search/model
    </value>
   </list>
  </property>
  <property name="classMappings">
   <list>
    <value>cn.com.unutrip.compass.search.model.Blog</value>
   </list>
  </property>
  <property name="compassConfiguration"
   ref="annotationConfiguration" />
  <property name="compassSettings">
   <props>
    <prop key="compass.transaction.factory">
     org.compass.spring.transaction.SpringSyncTransactionFactory
    </prop>
    <prop
     key="compass.engine.analyzer.MMAnalyzer.CustomAnalyzer">
     org.mira.lucene.analysis.IK_CAnalyzer
    </prop>
    <!-- 定义索引的存储位置  -->
    <prop key="compass.engine.connection">d:/compass</prop>
   </props>
  </property>
  <property name="transactionManager" ref="transactionManager" />
 </bean>

 <bean id="hibernateGpsDevice"
  class="org.compass.spring.device.hibernate.dep.SpringHibernate3GpsDevice">
  <property name="name">
   <value>hibernateDevice</value>
  </property>
  <property name="sessionFactory" ref="sessionFactory" />
  <property name="mirrorDataChanges">
   <value>true</value>
  </property>
 </bean>

 <!-- 同步更新索引 -->
 <bean id="compassGps" class="org.compass.gps.impl.SingleCompassGps"
  init-method="start" destroy-method="stop">
  <property name="compass">
   <ref bean="compass" />
  </property>
  <property name="gpsDevices">
   <list>
    <ref bean="hibernateGpsDevice" />
   </list>
  </property>
 </bean>
 <bean id="compassTemplate"
  class="org.compass.core.CompassTemplate">
  <property name="compass" ref="compass" />
 </bean>

 <!-- 定时重建索引(利用quartz)或随Spring ApplicationContext启动而重建索引 -->
 <bean id="compassIndexBuilder"
  class="cn.com.unutrip.compass.search.utils.CompassIndexBuilder"
  lazy-init="false">
  <property name="compassGps" ref="compassGps" />
  <property name="buildIndex" value="true" />
  <property name="lazyTime" value="10" />
 </bean>
</beans>

 

其他各类一样:compass和其他框架整合不同点:XXX3GpsDevice不同和管理器模板對象不同

分享到:
评论

相关推荐

    Struts+Hibernate+spring+jpa+lucene+jbpm+compass配置文件

    3. **Spring**:Spring 是一个全面的企业级应用开发框架,提供依赖注入、事务管理、AOP(面向切面编程)等功能。Spring的核心配置通常在`applicationContext.xml`中,它可以管理和协调其他组件,如Struts、Hibernate...

    spring+hibernate+jpa+struts1+struts2+springmvc+jquery+freemaker 学习笔记 案例.rar

    spring+hibernate+jpa+struts1+struts2+springmvc+jquery+freemaker 学习笔记 Compass将lucene、Spring、Hibernate三者结合

    Spring ,JPA,Compass使用注解开发的博客站内搜索

    首先,Spring框架是企业级Java应用开发的基石,它提供了依赖注入(DI)、面向切面编程(AOP)以及一系列工具支持,包括数据访问、事务管理、远程服务等。在本项目中,Spring将作为整个系统的基础架构,负责管理组件(如...

    Lucene+compass学习资料

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

    compass+lucene

    在实际应用中,`compass+lucene`的组合使得开发者可以轻松地在Java应用中添加全文搜索功能,而无需深入了解搜索引擎的复杂细节。通过 Compass 的 ORM 集成,开发者可以直接在存储在数据库中的对象上执行全文搜索,这...

    Compass 的java代码

    4. **事务支持**:由于Compass与ORM框架(如Hibernate和JPA)的集成,它可以支持事务性搜索,确保数据的一致性。 5. **多域搜索**:Compass支持多域搜索,允许你在不同字段上执行复杂的查询,提高了查询的灵活性。 ...

    S2SH+compass (实现站内全文检索)

    这种组合常见于Java Web开发中,用于构建复杂、高性能的企业级应用。 Struts2是MVC(模型-视图-控制器)设计模式的一个实现,它提供了处理HTTP请求、展现逻辑和业务逻辑分离的能力。Spring框架则是一个全面的后端...

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

    Compass 和 Lucene 是两个在 Java 开发环境中广泛使用的全文搜索引擎工具。它们可以帮助开发者构建高效、强大的文本搜索功能。本文将详细介绍如何使用 Compass 和 Lucene 实现一个简单的全文检索功能。 首先,...

    整合compass2.0 spring hibernate示例源程序

    标题 "整合compass2.0 spring hibernate示例源程序" 提供了我们即将探讨的核心内容:一个集成Compass 2.0、Spring和Hibernate的示例应用。这是一份源代码,旨在帮助开发者理解如何在实际项目中有效地将这三个关键...

    Compass全文检索完整实例,可运行

    在本实例中,我们有一个可直接运行的Compass全文检索系统,已经集成了SSH(Struts、Spring、Hibernate)框架,这是一个常见的企业级应用开发组合。 首先,让我们深入了解一下Compass。Compass是一个开源项目,它的...

    基于Java+Hibernate Spring JPA Compass实现的图书商城项目源码.zip

    本项目是一个基于Java技术栈,整合了Hibernate、Spring JPA以及Compass的图书商城系统,提供了全面的功能,适合用于课程设计、大作业、毕业设计、项目练习或学习演示。下面将详细阐述该项目所涉及的技术点及其重要性...

    Compass全文检索系列之一:Compass入门

    Compass不仅提供了与ORM框架(如Hibernate、JPA等)的无缝集成,还支持动态索引更新,使得实时数据检索成为可能。 首先,我们来了解什么是Compass。Compass是基于Apache Lucene的一个高级全文搜索引擎,它将Lucene...

    Compass.rar

    这个名为"Compass.rar"的压缩包包含了用于在Eclipse开发环境中测试Compass的应用程序。Eclipse是一款广泛使用的开源集成开发环境(IDE),特别适合Java开发者。接下来,我们将深入探讨Compass和Eclipse中的测试应用...

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

    Compass不仅支持对关系数据库中的数据进行索引,还能与ORM框架如Hibernate、JPA等无缝集成,使得索引和搜索的数据可以与业务数据保持一致。 **二、Compass的核心特性** 1. **ORM集成**:Compass能够自动跟踪和更新...

    compass-2.2.0.zip

    Compass的出现就是为了降低这个门槛,使得开发人员可以更加专注于业务逻辑,而无需过多关注搜索引擎的实现细节。 Compass的核心特性包括: 1. **搜索引擎API**:Compass提供了一个简单易用的API,使得开发者可以...

    compass对象搜索引擎

    由于Compass与数据库紧密集成,它支持JTA和JPA事务管理,确保在复杂的应用环境中,搜索操作与其他数据库操作能够一致性和原子性。 7. **多语言支持** Compass除了支持英文,还提供了对其他语言的分词支持,如中文...

    compass 全文搜索

    1. **ORM集成**:Compass支持多种对象关系映射(ORM)框架,如Hibernate、JPA和iBatis等,使得你可以直接在数据库中的对象上进行全文搜索,无需额外的索引存储。 2. **实时索引**:当数据库中的数据发生变化时,...

    compass内部分享

    - **Compass GPS**:用于整合不同的ORM框架(如Hibernate、JPA、JDO等),使开发者可以在不直接使用Compass API的情况下使用全文检索功能。 - **Compass Spring**:用于集成Spring框架,支持Spring AOP等功能,简化...

    简单的compass示例源码

    Compass的核心是构建在Apache Lucene之上,Lucene是一个强大的文本搜索库,而Compass则在其基础上添加了对ORM(对象关系映射)框架的支持,如Hibernate和JPA。这个压缩包中的"简单的compass示例源码"是为了帮助...

Global site tag (gtag.js) - Google Analytics