compass spring hibernate 集成

我们在使用lucene管理document时，难免有些复杂，并且在做增量索引的时候会比较繁琐，现介绍compass如下：
compass对lucene的使用就如同Hibernate和对jdbc的使用。
Compass的使用步骤：
Hibernate的实现步骤是：
1 》设计实体
2 》配置映射元数据 (xml / 注解—Hibernate3才推出来的)
3 》利用Hibernate的api完成对实体的CURD
我们目前使用compass的操作步骤就与Hibernate的基本一样的：
Hibernate的第二步是映射到数据库，而compass是映射到收索引擎里面去。
1 》设计收索实体 – 就是一个普通的javabean
你要写这么一个实体，定义一些属性，好比产品的id、名称
2 》配置映射元数据 – 针对收索引擎映射-我们采用主注解的方式
我们使用@Searchable 标注映射为收索实体，映射到Lucene中的document
假设是采用注解的形式，我们就需要在实体和属性上面加上一些注解
@Entity （映射到数据库中的表）
@Searchable –> 这个注解把该类声明为搜索实体，映射到lucene中的document
Public class Product{
@Id （Hibernate用来表示实体的标识属性）
@SearchableId （compass标注为标识属性）
Private Integer id;
@Column （）
@SearchableProperty à 映射搜索属性
Private String name;
}
3 >利用compass api完成对实体的添/删/查操作
hibernate.cfg.xml / compass.cfg.xml 放在类路径下
hibernate: SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Compass: Compass compass = new CompassConfiguration().configure().buildCompass();
SessionFactory == Compass
hibernate: Session session = sessionFactory.openSession();
compass: CompassSession session = compass.openSession();
Session = CompassSession
Hibernate: session.beginTransaction();
compass: session.beginTransaction();
Hibernate: session.save(product)/persist();
compass: session.save(product)/create();
Hibernate: session.getTransaction().commit();
compass: session.getTransaction().commit();
session.close();
sessionFactory.close();
学习一下compass映射注解：常用的就5 个
@Searchable //告诉compass，将该类映射到lucene的Document
注意注解如果标注在属性上只能标注在get方法上面
@SearchableId //compass要求每个搜索实体类都要具有一个标识属性，这点和Hibernate相似
@SearchableProperty （index=Index.NOT_ANALYZED ,store=Store.YES） // store的默认值为Store.YES
类别id不需要分词，蛋需要索引并存储
Index。UN_TOKENIZED 不对该field进行分词，但是要索引，该属性已过时，建议产用NOT__ANALYZED替换
Index.TOKENIZED：先分词后索引。该属性已过时，建议采用ANALYZED替换
Inde.NOT_ANALYZED 不分词，但建立索引
Index.ANALYZED 分词并且建立索引
@SearchableId Property(boost= 2 ) //boost的默认值为1，用户设置属性在索引中的重要性
如下：
@Searchable //告诉compass,将该类映射到Lucene的Document
public class Product {
private Integer id;
private String name;
private String content;
private Float price;
private String note;
private Integer position;
private Integer typeid;
public Product(){}
public Product(Integer id) {
this .id = id;
}
public Product(Integer id, String name, String content, Float price,String note,Integer typeid,Integer position) {
this .id = id;
this .name = name;
this .content = content;
this .price = price;
this .note = note;
this .typeid = typeid;
this .position = position;
}
@SearchableId //compass要求每个搜索实体类都要具有一个标识属性,这点和Hibernate相似
public Integer getId() {
return id;
}
public void setId(Integer id) {
this .id = id;
}
//类别id不需要分词,但需要索引并储存
//Index.UN_TOKENIZED:不对该Field进行分词，但是要索引.该属性已过时,建议采用NOT_ANALYZED替换
//Index.TOKENIZED:先分词后索引。该属性已过时,建议采用ANALYZED替换
//Index.NOT_ANALYZED：不分词，但建立索引
//Index.ANALYZED ：分词并且建立索引
@SearchableComponent //关联的符合索引，专门用来标注复合类型
那么被标注的这个属性对应的类，我们也要标注一下为收索实体，但是这个搜索实体他不是单独存在的，他只是最为产品搜索实体的一部分
@Searchable (root= false )
@SearchableProperty (index=Index.NO ,store=Store.YES)
我们对他的主键不需要索引只需要存储
当你存在双向关系的时候，并且需要引用会对应的实体，反指引用
@SearchableReference
@SearchableProperty (index=Index.NOT_ANALYZED, store=Store.YES) //store的默认值为Store.YES
public Integer getTypeid() {
return typeid;
}
public void setTypeid(Integer typeid) {
this .typeid = typeid;
}
@SearchableProperty (boost= 2 ) //boost的默认值为1,用于设置属性在索引中的重要性
public String getName() {
return name;
}
public void setName(String name) {
this .name = name;
}
@SearchableProperty
public String getContent() {
return content;
}
public void setContent(String content) {
this .content = content;
}
//价格不需要进行搜索,但需要存储,如果没有存储,就需要从数据库中获取价格了
@SearchableProperty (index=Index.NO) //store的默认值为Store.YES
public Float getPrice() {
return price;
}
public void setPrice(Float price) {
this .price = price;
}
@SearchableProperty (store=Store.YES)
public String getNote() {
return note;
}
public void setNote(String note) {
this .note = note;
}
@SearchableProperty (index=Index.NOT_ANALYZED, store=Store.YES) //store的默认值为Store.YES
public Integer getPosition() {
return position;
}
public void setPosition(Integer position) {
this .position = position;
}
}
我们不集成spring的编程配置和使用方式如下：
import java.util.ArrayList;
import java.util.List;
import org.compass.annotations.config.CompassAnnotationsConfiguration;
import org.compass.core.Compass;
import org.compass.core.CompassException;
import org.compass.core.CompassHits;
import org.compass.core.CompassQueryBuilder;
import org.compass.core.CompassSession;
import org.compass.core.CompassTransaction;
import org.compass.core.CompassQuery.SortDirection;
import org.compass.core.CompassQuery.SortPropertyType;
import org.compass.core.config.CompassEnvironment;
import cn.itcast.bean.Product;
import cn.itcast.bean.QueryResult;
import cn.itcast.compass.service.ProductSearch;
public class ProductSearchBean implements ProductSearch {
private Compass compass = null ; //-->SessionFactory
public ProductSearchBean(){
try {
//编程式配置
compass = new CompassAnnotationsConfiguration()
.setSetting(CompassEnvironment.CONNECTION, "[url=file://indexfile]file://indexfile[/url]" )
//.setSetting(CompassEnvironment.CONNECTION, "ram://index")//在内存中建立索引
.setSetting("compass.engine.highlighter.default.formatter.simple.pre" , "" )
.setSetting("compass.engine.highlighter.default.formatter.simple.post" , "" )
.addScan("cn.itcast.bean" ).buildCompass();
} catch (Exception e) {
e.printStackTrace();
}
}
//compass支持增量索引,社会上很多公司,他们的产品都没有实现增量索引,1>lucene版本比较低,不支持增量索引,2>要增量索引,技术要求稍微有点高
//(晚上 2-3,定时器,把索引文件删除,重新生成索引)实时性不强,在索引文件更新的时候,用户是访问不了的
public void buildIndex(){
CompassSession session = null ;
CompassTransaction tx = null ;
try {
session = compass.openSession();
tx = session.beginTransaction();
Product p1 = new Product( 12 , "c瑜珈球" , "非常好的瑜珈球" ,12f, "www" , 2 , 12 );
session.create(p1);
Product p2 = new Product( 35 , "b瑜珈球" , "天花板瑜珈球,good" ,42f, "mmm" , 2 , 9 );
session.create(p2);
Product p3 = new Product( 8 , "a蓝球瑜珈球" , "蓝球小子" ,125f, "ppp" , 5 , 8 );
session.create(p3);
tx.commit();
} catch (CompassException e) {
e.printStackTrace();
tx.rollback();
}finally {
if (session!= null && !session.isClosed()) session.close();
}
}
public void deleteIndex(Product product) {
CompassSession session = null ;
CompassTransaction tx = null ;
try {
session = compass.openSession();
tx = session.beginTransaction();
session.delete(product);
tx.commit();
} catch (CompassException e) {
e.printStackTrace();
tx.rollback();
}finally {
if (session!= null && !session.isClosed()) session.close();
}
}
public void updateIndex(Product product) {
CompassSession session = null ;
CompassTransaction tx = null ;
try {
session = compass.openSession();
tx = session.beginTransaction();
session.delete(product);
session.save(product);
tx.commit();
} catch (CompassException e) {
e.printStackTrace();
tx.rollback();
}finally {
if (session!= null && !session.isClosed()) session.close();
}
}
public void destroy(){
compass.close();
}
public QueryResult<Product> search(String keyword, int firstIndex, int maxResult) {
QueryResult<Product> qr = new QueryResult<Product>();
CompassSession session = null ;
CompassTransaction tx = null ;
try {
session = compass.openSession();
tx = session.beginTransaction();
//对所有索引Field进行搜索,你也可以指定对某个Field搜索,如:"name:jack",如果想指定多个字段可以用空格和"+"隔开如"name:jack +content:xxx"
CompassHits hits = session.find(keyword);
List<Product> products = new ArrayList<Product>();
int length = firstIndex+ maxResult;
if (length>hits.length()) length = hits.length();
for ( int i=firstIndex; i<length; i++){
Product product = (Product)hits.data(i);
product.setContent(hits.highlighter(i).fragment("content" ));
products.add(product);
}
qr.setResultlist(products);
qr.setTotalrecord(hits.length());
hits.close();
} catch (CompassException e) {
e.printStackTrace();
tx.rollback();
}finally {
if (session!= null && !session.isClosed()) session.close();
}
return qr;
}
public QueryResult<Product> search(String keyword, Integer typeid, int firstIndex, int maxResult) {
QueryResult<Product> qr = new QueryResult<Product>();
CompassSession session = null ;
CompassTransaction tx = null ;
try {
session = compass.openSession();
tx = session.beginTransaction();
//查询指定类别的匹配记录，并按position降序排序
CompassQueryBuilder queryBuilder = session.queryBuilder();
CompassHits hits = queryBuilder.bool()
.addMust(queryBuilder.spanEq("typeid" , typeid))
.addMust(queryBuilder.queryString(keyword).toQuery())
.toQuery().addSort("position" , SortPropertyType.FLOAT, SortDirection.REVERSE)
.hits();//sql: typeid=1 and (xxxx like ?) order by positoin desc
List<Product> products = new ArrayList<Product>();
int length = firstIndex+ maxResult;
if (length>hits.length()) length = hits.length();
for ( int i=firstIndex; i<length; i++){
Product product = (Product)hits.data(i);
product.setContent(hits.highlighter(i).fragment("content" ));
products.add(product);
}
qr.setResultlist(products);
qr.setTotalrecord(hits.length());
hits.close();
} catch (CompassException e) {
e.printStackTrace();
tx.rollback();
}finally {
if (session!= null && !session.isClosed()) session.close();
}
return qr;
}
}

         //compass支持增量索引,社会上很多公司,他们的产品都没有实现增量索引,1>lucene版本比较低,不支持增量索引,2>要增量索引,技术要求稍微有点高
         //(晚上 2-3,定时器,把索引文件删除,重新生成索引)实时性不强,在索引文件更新的时候,用户是访问不了的

以上基本都为讲解，下面是具体的开发步骤：
步骤一：
导jar：compass的两个文件，疑问logging文件一般我们已经存在了，lucene的六个文件
步骤二：
配置映射元数据：
设计实体，我们实体已经存在了，所以不用设计了，直接加注解
我们映射产品：
首先我们要加上搜索id
然后我们要分析一下那些是需要搜索的，哪些是不需要搜索的，但是需要显示在搜索结果中的。如果不需要显示也不需要索引就不管他
         第三步：
         我们对索引进行填、删、查
         我们对产品进行保存的时候，我们就应该把索引也保持进去。
         方式一：我们可以重写我们servicebean的保持方法。添加一个保存到索引里面去的方法。这样我们就存在一个问题，两个保存，有一个保存失败了，另一个保存就无法执行。就导致了数据不同，无法保证两种保存在同一个事物中
         方式二：把compass集成到spring中，让他使用spring的事物管理功能。
在我们的spring中添加代码如下：

Java代码

<bean id= "compass" class = "org.compass.spring.LocalCompassBean" >
<property name="classMappings" >
<list>
<value>cn.itcast.bean.product.ProductInfo</value>
<value>cn.itcast.bean.product.Brand</value>
<value>cn.itcast.bean.product.ProductStyle</value>
<value>cn.itcast.bean.product.ProductType</value>
</list>
</property>
<property name="compassSettings" >
<props>
<prop key="compass.engine.analyzer.default.type" >net.paoding.analysis.analyzer.PaodingAnalyzer</prop>
<prop key="compass.engine.connection" >file: //d:/index</prop>
<!-- 在内存中建立索引
<prop key="compass.engine.connection" >ram: //index</prop>
-->
<prop key="compass.engine.highlighter.default.formatter.simple.pre" ><![CDATA[]]></prop>
<prop key="compass.engine.highlighter.default.formatter.simple.post" ><![CDATA[]]></prop>
<prop key="compass.transaction.factory" >org.compass.spring.transaction.SpringSyncTransactionFactory</prop>
</props>
</property>
<property name="transactionManager" ref= "transactionManager" />
</bean>

引自：http://osacar.iteye.com/blog/1050977 多谢

我们在使用lucene管理document时，难免有些复杂，并且在做增量索引的时候会比较繁琐，现介绍compass如下：
compass对lucene的使用就如同Hibernate和对jdbc的使用。
Compass的使用步骤：
Hibernate的实现步骤是：
1 》设计实体
2 》配置映射元数据 (xml / 注解—Hibernate3才推出来的)
3 》利用Hibernate的api完成对实体的CURD
我们目前使用compass的操作步骤就与Hibernate的基本一样的：
Hibernate的第二步是映射到数据库，而compass是映射到收索引擎里面去。
1 》设计收索实体 – 就是一个普通的javabean
你要写这么一个实体，定义一些属性，好比产品的id、名称
2 》配置映射元数据 – 针对收索引擎映射-我们采用主注解的方式
我们使用@Searchable 标注映射为收索实体，映射到Lucene中的document
假设是采用注解的形式，我们就需要在实体和属性上面加上一些注解
@Entity （映射到数据库中的表）
@Searchable –> 这个注解把该类声明为搜索实体，映射到lucene中的document
Public class Product{
@Id （Hibernate用来表示实体的标识属性）
@SearchableId （compass标注为标识属性）
Private Integer id;
@Column （）
@SearchableProperty à 映射搜索属性
Private String name;
}
3 >利用compass api完成对实体的添/删/查操作
hibernate.cfg.xml / compass.cfg.xml 放在类路径下
hibernate: SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Compass: Compass compass = new CompassConfiguration().configure().buildCompass();
SessionFactory == Compass
hibernate: Session session = sessionFactory.openSession();
compass: CompassSession session = compass.openSession();
Session = CompassSession
Hibernate: session.beginTransaction();
compass: session.beginTransaction();
Hibernate: session.save(product)/persist();
compass: session.save(product)/create();
Hibernate: session.getTransaction().commit();
compass: session.getTransaction().commit();
session.close();
sessionFactory.close();
学习一下compass映射注解：常用的就5 个
@Searchable //告诉compass，将该类映射到lucene的Document
注意注解如果标注在属性上只能标注在get方法上面
@SearchableId //compass要求每个搜索实体类都要具有一个标识属性，这点和Hibernate相似
@SearchableProperty （index=Index.NOT_ANALYZED ,store=Store.YES） // store的默认值为Store.YES
类别id不需要分词，蛋需要索引并存储
Index。UN_TOKENIZED 不对该field进行分词，但是要索引，该属性已过时，建议产用NOT__ANALYZED替换
Index.TOKENIZED：先分词后索引。该属性已过时，建议采用ANALYZED替换
Inde.NOT_ANALYZED 不分词，但建立索引
Index.ANALYZED 分词并且建立索引
@SearchableId Property(boost= 2 ) //boost的默认值为1，用户设置属性在索引中的重要性
如下：
@Searchable //告诉compass,将该类映射到Lucene的Document
public class Product {
private Integer id;
private String name;
private String content;
private Float price;
private String note;
private Integer position;
private Integer typeid;
public Product(){}
public Product(Integer id) {
this .id = id;
}
public Product(Integer id, String name, String content, Float price,String note,Integer typeid,Integer position) {
this .id = id;
this .name = name;
this .content = content;
this .price = price;
this .note = note;
this .typeid = typeid;
this .position = position;
}
@SearchableId //compass要求每个搜索实体类都要具有一个标识属性,这点和Hibernate相似
public Integer getId() {
return id;
}
public void setId(Integer id) {
this .id = id;
}
//类别id不需要分词,但需要索引并储存
//Index.UN_TOKENIZED:不对该Field进行分词，但是要索引.该属性已过时,建议采用NOT_ANALYZED替换
//Index.TOKENIZED:先分词后索引。该属性已过时,建议采用ANALYZED替换
//Index.NOT_ANALYZED：不分词，但建立索引
//Index.ANALYZED ：分词并且建立索引
@SearchableComponent //关联的符合索引，专门用来标注复合类型
那么被标注的这个属性对应的类，我们也要标注一下为收索实体，但是这个搜索实体他不是单独存在的，他只是最为产品搜索实体的一部分
@Searchable (root= false )
@SearchableProperty (index=Index.NO ,store=Store.YES)
我们对他的主键不需要索引只需要存储
当你存在双向关系的时候，并且需要引用会对应的实体，反指引用
@SearchableReference
@SearchableProperty (index=Index.NOT_ANALYZED, store=Store.YES) //store的默认值为Store.YES
public Integer getTypeid() {
return typeid;
}
public void setTypeid(Integer typeid) {
this .typeid = typeid;
}
@SearchableProperty (boost= 2 ) //boost的默认值为1,用于设置属性在索引中的重要性
public String getName() {
return name;
}
public void setName(String name) {
this .name = name;
}
@SearchableProperty
public String getContent() {
return content;
}
public void setContent(String content) {
this .content = content;
}
//价格不需要进行搜索,但需要存储,如果没有存储,就需要从数据库中获取价格了
@SearchableProperty (index=Index.NO) //store的默认值为Store.YES
public Float getPrice() {
return price;
}
public void setPrice(Float price) {
this .price = price;
}
@SearchableProperty (store=Store.YES)
public String getNote() {
return note;
}
public void setNote(String note) {
this .note = note;
}
@SearchableProperty (index=Index.NOT_ANALYZED, store=Store.YES) //store的默认值为Store.YES
public Integer getPosition() {
return position;
}
public void setPosition(Integer position) {
this .position = position;
}
}
我们不集成spring的编程配置和使用方式如下：
import java.util.ArrayList;
import java.util.List;
import org.compass.annotations.config.CompassAnnotationsConfiguration;
import org.compass.core.Compass;
import org.compass.core.CompassException;
import org.compass.core.CompassHits;
import org.compass.core.CompassQueryBuilder;
import org.compass.core.CompassSession;
import org.compass.core.CompassTransaction;
import org.compass.core.CompassQuery.SortDirection;
import org.compass.core.CompassQuery.SortPropertyType;
import org.compass.core.config.CompassEnvironment;
import cn.itcast.bean.Product;
import cn.itcast.bean.QueryResult;
import cn.itcast.compass.service.ProductSearch;
public class ProductSearchBean implements ProductSearch {
private Compass compass = null ; //-->SessionFactory
public ProductSearchBean(){
try {
//编程式配置
compass = new CompassAnnotationsConfiguration()
.setSetting(CompassEnvironment.CONNECTION, "[url=file://indexfile]file://indexfile[/url]" )
//.setSetting(CompassEnvironment.CONNECTION, "ram://index")//在内存中建立索引
.setSetting("compass.engine.highlighter.default.formatter.simple.pre" , "" )
.setSetting("compass.engine.highlighter.default.formatter.simple.post" , "" )
.addScan("cn.itcast.bean" ).buildCompass();
} catch (Exception e) {
e.printStackTrace();
}
}
//compass支持增量索引,社会上很多公司,他们的产品都没有实现增量索引,1>lucene版本比较低,不支持增量索引,2>要增量索引,技术要求稍微有点高
//(晚上 2-3,定时器,把索引文件删除,重新生成索引)实时性不强,在索引文件更新的时候,用户是访问不了的
public void buildIndex(){
CompassSession session = null ;
CompassTransaction tx = null ;
try {
session = compass.openSession();
tx = session.beginTransaction();
Product p1 = new Product( 12 , "c瑜珈球" , "非常好的瑜珈球" ,12f, "www" , 2 , 12 );
session.create(p1);
Product p2 = new Product( 35 , "b瑜珈球" , "天花板瑜珈球,good" ,42f, "mmm" , 2 , 9 );
session.create(p2);
Product p3 = new Product( 8 , "a蓝球瑜珈球" , "蓝球小子" ,125f, "ppp" , 5 , 8 );
session.create(p3);
tx.commit();
} catch (CompassException e) {
e.printStackTrace();
tx.rollback();
}finally {
if (session!= null && !session.isClosed()) session.close();
}
}
public void deleteIndex(Product product) {
CompassSession session = null ;
CompassTransaction tx = null ;
try {
session = compass.openSession();
tx = session.beginTransaction();
session.delete(product);
tx.commit();
} catch (CompassException e) {
e.printStackTrace();
tx.rollback();
}finally {
if (session!= null && !session.isClosed()) session.close();
}
}
public void updateIndex(Product product) {
CompassSession session = null ;
CompassTransaction tx = null ;
try {
session = compass.openSession();
tx = session.beginTransaction();
session.delete(product);
session.save(product);
tx.commit();
} catch (CompassException e) {
e.printStackTrace();
tx.rollback();
}finally {
if (session!= null && !session.isClosed()) session.close();
}
}
public void destroy(){
compass.close();
}
public QueryResult<Product> search(String keyword, int firstIndex, int maxResult) {
QueryResult<Product> qr = new QueryResult<Product>();
CompassSession session = null ;
CompassTransaction tx = null ;
try {
session = compass.openSession();
tx = session.beginTransaction();
//对所有索引Field进行搜索,你也可以指定对某个Field搜索,如:"name:jack",如果想指定多个字段可以用空格和"+"隔开如"name:jack +content:xxx"
CompassHits hits = session.find(keyword);
List<Product> products = new ArrayList<Product>();
int length = firstIndex+ maxResult;
if (length>hits.length()) length = hits.length();
for ( int i=firstIndex; i<length; i++){
Product product = (Product)hits.data(i);
product.setContent(hits.highlighter(i).fragment("content" ));
products.add(product);
}
qr.setResultlist(products);
qr.setTotalrecord(hits.length());
hits.close();
} catch (CompassException e) {
e.printStackTrace();
tx.rollback();
}finally {
if (session!= null && !session.isClosed()) session.close();
}
return qr;
}
public QueryResult<Product> search(String keyword, Integer typeid, int firstIndex, int maxResult) {
QueryResult<Product> qr = new QueryResult<Product>();
CompassSession session = null ;
CompassTransaction tx = null ;
try {
session = compass.openSession();
tx = session.beginTransaction();
//查询指定类别的匹配记录，并按position降序排序
CompassQueryBuilder queryBuilder = session.queryBuilder();
CompassHits hits = queryBuilder.bool()
.addMust(queryBuilder.spanEq("typeid" , typeid))
.addMust(queryBuilder.queryString(keyword).toQuery())
.toQuery().addSort("position" , SortPropertyType.FLOAT, SortDirection.REVERSE)
.hits();//sql: typeid=1 and (xxxx like ?) order by positoin desc
List<Product> products = new ArrayList<Product>();
int length = firstIndex+ maxResult;
if (length>hits.length()) length = hits.length();
for ( int i=firstIndex; i<length; i++){
Product product = (Product)hits.data(i);
product.setContent(hits.highlighter(i).fragment("content" ));
products.add(product);
}
qr.setResultlist(products);
qr.setTotalrecord(hits.length());
hits.close();
} catch (CompassException e) {
e.printStackTrace();
tx.rollback();
}finally {
if (session!= null && !session.isClosed()) session.close();
}
return qr;
}
}

Java代码

<bean id= "compass" class = "org.compass.spring.LocalCompassBean" >
<property name="classMappings" >
<list>
<value>cn.itcast.bean.product.ProductInfo</value>
<value>cn.itcast.bean.product.Brand</value>
<value>cn.itcast.bean.product.ProductStyle</value>
<value>cn.itcast.bean.product.ProductType</value>
</list>
</property>
<property name="compassSettings" >
<props>
<prop key="compass.engine.analyzer.default.type" >net.paoding.analysis.analyzer.PaodingAnalyzer</prop>
<prop key="compass.engine.connection" >file: //d:/index</prop>
<!-- 在内存中建立索引
<prop key="compass.engine.connection" >ram: //index</prop>
-->
<prop key="compass.engine.highlighter.default.formatter.simple.pre" ><![CDATA[]]></prop>
<prop key="compass.engine.highlighter.default.formatter.simple.post" ><![CDATA[]]></prop>
<prop key="compass.transaction.factory" >org.compass.spring.transaction.SpringSyncTransactionFactory</prop>
</props>
</property>
<property name="transactionManager" ref= "transactionManager" />
</bean>

compass spring hibernate 集成

猜你喜欢