[lucene那点事儿]想说爱你很容易

内容提要：

---------------------目录开始--------------------

1、索引精确刷新问题

2、利用缓存提高索引批量更新拦截器的性能

3、针对不同的数据来源建立不同的索引并分域存放

4、引入xml配置文件的方式实现索引建立的动态配置

5、单值搜索、组合条件搜索等多种搜索功能的实现

6、其他以及单元测试

 ------------------------目录完-------------------

part1、索引的精确刷新以及利用缓存提高索引批量更新拦截器的性能

使用lucene建立的搜索服务，搜索结果的准确性很大程度上依赖于索引，尤其是针对于数据库数据建立的索引，一旦数据库的数据改变，而索引中的数据则成为脏数据，需要执行刷新操作以保持最新的状态。通常而言，这个过程由一个单独的任务启动一个线程来完成。而本篇要讲，即如何只去精确的刷新那些被修改过的数据，而不是全部的索引重新建立的方式去刷新。

如果要精确的只刷新那些被修改的数据，那么需要知道，两次定时任务之间，哪些数据被修改了，记录下来并在下一次的定时任务中执行刷新。通常而言，这个过程可以有多种方式，但是这里我们针对的是前面的文章中讲述的针对spring的jdbcTemplate进行的日常API的封装，

（在后续的开发过程中，所有的DAO都将继承于这个类），并且我们希望能够尽可能减少业务代码的交织，能够采用一种通用的方式，使得多个继承于abstractBaseDAO的子类的这些更新方法，只要是我们希望去获取的，都能够被自动获取，而不是每次针对不同的子类DAO编码相关的获取代码。所以很自然的，我们需要将这个获取代码往底层抽象，我们的目标就是减少业务代码的交织，提高代码的通用性，实现底层向上的服务。

所以最直接的，就是在底层操作数据库的时候，动态获取，这个获取方式，我们采用拦截器的方式。即当外部调用增加删除修改方法的时候，能够自动的拦截相关的调用并获取本次操作影响到的数据记录的ID，然后记录下来，并且不同的子类DAO可以对应不同的ID列表。

 

举个例子：我们有两个DAO，一个是商品相关的DAO，一个是相关的交易流水的DAO。

对于我们的网站搜索功能而言，我们提供的是针对于商品的搜索，而不会提供搜索交易流水。所以当商品DAO子类调用父类AbstractBaseDAO的相关的数据库修改方法的时候，需要执行拦截，记录相关的影响到的记录的ID，而交易流水DAO子类调用的时候，则不需要被拦截。

 

比如我们现在希望去拦截网站商品相关信息修改的操作，配置一个拦截子类DAO的拦截器：

<bean id="luceneMethodInterceptor" class="com.normandy.position.common.LuceneMethodInterceptor"></bean> <!-- 配置interceptor --> <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="exposeProxy"> <value>true</value> </property> <property name="beanNames"> <list> <value>norGoodsDAO</value> </list> </property> <property name="interceptorNames"> <list> <value>luceneMethodInterceptor</value> </list> </property> </bean>

 

这里遇到一个问题：如上述例子而言，我们在子类dao中会调用抽象父类abstractBaseDAO的数据库操作通用方法，而且我们希望的拦截的，也就是父类的这些操作方法，但是通常而言，拦截器涉及两个对象，即代理对象和原始对象，拦截器执行的是代理对象，子类调用父类方法，这种调用属于方法的内部调用，已经执行在原始对象中而不是代理对象中，所以这种内部调用无法被拦截。

比如类A提供了一个method1，类B继承类A，在method2方法中调用类A的method1，那么在拦截的过程中，只会拦截类B的method2，而不会去拦截父类的method1；

所以需要我们处理的是，如何去触发二次拦截的问题。

在前面的文章中，我们采用了一种AopContext.currentProxy()来获取代理对象再调用以触发拦截的方式，在本篇中，我们依然采用这种方式，但是对于代码进行了重构，我们不希望每个子类DAO都去编写这些重复的工作，所以我们采用如下的方式：

    方法内部调用，虽然通过AopContext.currentProxy()可以触发拦截，但是有一个前提条件就是，如果是面向接口的编程，即如果DAO是具有一个interface的，那么父类的这个方法，必须也存在于当前DAO接口的方法声明中。否则，应该存在于子类中。因为代理对象代理的是子类而不是父类。

这个包含的工作是一个重复性的，针对于我们封装的jdbcTemplate的AbstractBaseDAO，我们采用一个抽象父接口的形式，来降低这部分工作的重复

package com.normandy.position.common; import java.util.List; import java.util.Map; /** * 代理模式下的需被拦截的数据库修改相关操作的定义接口 * <p> * 使用AbstractBaseDAO的增加、删除、修改等相关方法，如果希望调用这些方式的时候能够被拦截器所拦截， * 则目标DAO接口必须继承于本接口，同时进行增删查改的时候需要使用AbstractBaseDAO提供的以ToBeIntercepted * 结尾的方法。 * 本接口的功能即向DAO子类接口中增加AbsctactBaseDAO中的增删改方法的声明，以便于方法拦截器能够执行拦截。 * 无需做其他的额外的开发。 * </p> * @author quzishen * */ public abstract interface AbsBaseDAOMethIntercepDefine { /** * 使用代理模式增加一条记录，如果上下文不存在可用代理，则使用内部调用方式 * @param object * @return * @throws RuntimeException */ public int insertObject(Object object) throws RuntimeException; /** * 使用代理模式批量增加记录，如果上下文不存在可用代理，则使用内部调用方式 * @param updateList * @param objectClass * @param moreThanOnce * @throws RuntimeException */ public void batchInsert(List<? extends Object> updateList,@SuppressWarnings("rawtypes") Class objectClass,boolean moreThanOnce) throws RuntimeException; /** * 使用代理模式根据ID删除记录，如果上下文不存在可用代理，则使用内部调用方式 * @param id * @param objectClass * @return */ public int deletebyId(long id,@SuppressWarnings("rawtypes") Class objectClass); /** * 使用代理模式根据Sql删除记录，如果上下文不存在可用代理，则使用内部调用方式 * @param sql * @param params * @return */ public int deleteBySqlWithPlaceHolder(String sql,Map<String,Object> params); /** * 使用代理模式更新对象记录，如果上下文不存在可用代理，则使用内部调用方式 * @param object * @param conditions * @return * @throws RuntimeException */ public int updateObject(Object object,Map<String,Object> conditions) throws RuntimeException; /** * 使用代理模式更新字段记录，如果上下文不存在可用代理，则使用内部调用方式 * @param params * @param conditions * @param objectClass * @return * @throws RuntimeException */ public int updateField(Map<String,Object> params,Map<String,Object> conditions,@SuppressWarnings("rawtypes") Class objectClass) throws RuntimeException; /** * 使用代理模式根据占位符的sql更新记录，如果上下文不存在可用代理，则使用内部调用方式 * @param sql * @param conditions * @param objectClass * @return */ public int updateFieldBySqlWithPlaceHolder(String sql,Map<String,Object> conditions,@SuppressWarnings("rawtypes") Class objectClass); }

这样其他的子类DAO的接口只要继承于这个父接口皆可以在本接口中增加父类中相关操作的声明，以便于拦截。

public interface NorGoodsDAO extends AbsBaseDAOMethIntercepDefine

同时，虽然解决了包含的工作，还有一个很重要的事情，就是在调用父类代码的时候，需要先判断上下文线程中是否有代理，如果存在代理，那就使用代理外调用，如果不存在代理，那就是用普通的内部调用。代码如下：

try{ if (null != AopContext.currentProxy()) { id = ((AbsBaseDAOMethIntercepDefine) AopContext.currentProxy()) .insertObject(object);// 必须是接口中的方法，无法转换成Impl类 } } catch (java.lang.IllegalStateException e) { if(logger.isDebugEnabled()){ logger.debug("can not find proxy in the aop context,so use the insertObject()."); } id = insertObject(object); }

在AbstractBaseDAO中提供的数据库修改方法，在需要进行拦截的子类中调用的时候，都要采用如此的方式去调用，可以看其中的代码其实并不是跟业务相关的，我们采用AbsBaseDAOMethIntercepDefine接受线程上下文中的拦截对象，这个拦截对象其实是一个子类实例，由于我们的子类DAO的interface已经继承了AbsBaseDAOMethIntercepDefine，所以，这里可以直接使用AbsBaseDAOMethIntercepDefine接受，它相当于是一个处于最上层的父类AbsBaseDAOMethIntercepDefine。

所以，这部分代码我们需要抽取出来，我们采用新建一个抽象父类：

public abstract class AbsBaseDAOMethIntercepted extends AbstractBaseDAO implements AbsBaseDAOMethIntercepDefine{​

它处于AbstractBaseDAO和子类DAO之间，提供的是针对于那些需要执行拦截的子类的执行增加、删除、修改等操作的API。它的内部完成了上述的操作，这样如果子类的数据库操作需要被拦截，那么只要替换继承AbstractBaseDAO而继承于它即可。

它完整的代码：

package com.normandy.position.common; import java.util.List; import java.util.Map; import org.springframework.aop.framework.AopContext; /** * AbstractBaseDAO代理类 * <p> * 对于使用代理访问AbstractBaseDAO的场景，如果希望方法的内部调用AbstractBaseDAO的方式时候 * 能够同样被拦截，则继承本类替代AbstractBaseDAO类。 * </p> * @author quzishen */ public abstract class AbsBaseDAOMethIntercepted extends AbstractBaseDAO implements AbsBaseDAOMethIntercepDefine{ /**************************************///public use proxy method begin /*******************************/ /** * 增加一条记录，如果上下文中存在代理，则使用代理模式，否则使用内部调用模式 * @param object 插入对象 * @return ID */ public int insertObjectToBeIntercepted(Object object) throws RuntimeException { int id = -1; try{ if (null != AopContext.currentProxy()) { id = ((AbsBaseDAOMethIntercepDefine) AopContext.currentProxy()) .insertObject(object);// 必须是接口中的方法，无法转换成Impl类 } } catch (java.lang.IllegalStateException e) { if(logger.isDebugEnabled()){ logger.debug("can not find proxy in the aop context,so use the insertObject()."); } id = insertObject(object); } return id; } /** * 批量增加记录，如果上下文中存在代理，则使用代理模式，否则使用内部调用模式 * @param updateList * @param objectClass * @param moreThanOnce * @throws RuntimeException */ @SuppressWarnings("rawtypes") public void batchInsertToBeIntercepted(List<? extends Object> updateList,Class objectClass,boolean moreThanOnce) throws RuntimeException{ try{ if (null != AopContext.currentProxy()) { ((AbsBaseDAOMethIntercepDefine) AopContext.currentProxy()) .batchInsert(updateList,objectClass,moreThanOnce); } } catch (java.lang.IllegalStateException e) { if(logger.isDebugEnabled()){ logger.debug("can not find proxy in the aop context,so use the batchInsert()."); } batchInsert(updateList,objectClass,moreThanOnce); } } /** * 删除记录，如果上下文中存在代理，则使用代理模式，否则使用内部调用模式 * @param id * @param objectClass * @return */ public int deletebyIdToBeIntercepted(long id,@SuppressWarnings("rawtypes") Class objectClass){ int num = -1; try{ if (null != AopContext.currentProxy()) { num = ((AbsBaseDAOMethIntercepDefine) AopContext.currentProxy()) .deletebyId(id,objectClass); } } catch (java.lang.IllegalStateException e) { if(logger.isDebugEnabled()){ logger.debug("can not find proxy in the aop context,so use the deletebyId()."); } num = deletebyId(id,objectClass); } return num; } /** * 根据sql删除，如果上下文中存在代理，则使用代理模式，否则使用内部调用模式 * @param sql * @param params * @return */ public int deleteBySqlWithPlaceHolderToBeIntercepted(String sql,Map<String,Object> params){ int num = -1; try{ if (null != AopContext.currentProxy()) { num = ((AbsBaseDAOMethIntercepDefine) AopContext.currentProxy()) .deleteBySqlWithPlaceHolder(sql,params); } } catch (java.lang.IllegalStateException e) { if(logger.isDebugEnabled()){ logger.debug("can not find proxy in the aop context,so use the deleteBySqlWithPlaceHolder()."); } num = deleteBySqlWithPlaceHolder(sql,params); } return num; } /** * 更新对象，如果上下文中存在代理，则使用代理模式，否则使用内部调用模式 * @param object * @param conditions * @return * @throws RuntimeException */ public int updateObjectToBeIntercepted(Object object,Map<String,Object> conditions) throws RuntimeException{ int num = -1; try{ if (null != AopContext.currentProxy()) { num = ((AbsBaseDAOMethIntercepDefine) AopContext.currentProxy()) .updateObject(object,conditions); } } catch (java.lang.IllegalStateException e) { if(logger.isDebugEnabled()){ logger.debug("can not find proxy in the aop context,so use the updateObject()."); } num = updateObject(object,conditions); } return num; } /** * 更新字段，如果上下文中存在代理，则使用代理模式，否则使用内部调用模式 * @param params * @param conditions * @param objectClass * @return * @throws RuntimeException */ public int updateFieldToBeIntercepted(Map<String,Object> params,Map<String,Object> conditions,@SuppressWarnings("rawtypes") Class objectClass) throws RuntimeException{ int num = -1; try{ if (null != AopContext.currentProxy()) { num = ((AbsBaseDAOMethIntercepDefine) AopContext.currentProxy()) .updateField(params,conditions,objectClass); } } catch (java.lang.IllegalStateException e) { if(logger.isDebugEnabled()){ logger.debug("can not find proxy in the aop context,so use the updateField()."); } num = updateField(params,conditions,objectClass); } return num; } /** * 通过sql更新，如果上下文中存在代理，则使用代理模式，否则使用内部调用模式 * @param sql * @param conditions * @param objectClass * @return */ public int updateFieldBySqlWithPlaceHolderToBeIntercepted(String sql,Map<String,Object> conditions,@SuppressWarnings("rawtypes") Class objectClass){ int num = -1; try{ if (null != AopContext.currentProxy()) { num = ((AbsBaseDAOMethIntercepDefine) AopContext.currentProxy()) .updateFieldBySqlWithPlaceHolder(sql,conditions,objectClass); } } catch (java.lang.IllegalStateException e) { if(logger.isDebugEnabled()){ logger.debug("can not find proxy in the aop context,so use the updateField()."); } num = updateFieldBySqlWithPlaceHolder(sql,conditions,objectClass); } return num; } }

上述解决了拦截代码的通用性问题，之后需要增加新的拦截DAO子类，只需要按照上述的步骤，来完成配置即可。剩下要做的，就是开发拦截器。

在前面文章中，我们已经完成了这个工作，这里我们进行了重构，使其可以拦截多个方法，将当前数据库操作所涉及的记录的ID获取出来并且发送给搜索引擎，由搜索引擎保存并将有定时刷新任务刷新。由于当前的系统可能有多种索引，导致拦截器拦截的DAO子类将有多个，所以，拦截器获取到ID后发送给搜索引擎的ID需要带有一个标记性的KEY，这些ID列表在搜索引擎中是使用一个map来保存的，其key值即唯一性的标记，特别注意的是，这里我们采用的是DO的名称字符串，value为对应的待更新id列表。

看看他的代码：

package com.normandy.position.common; import java.lang.reflect.Method; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; import org.apache.commons.lang.StringUtils; import org.apache.log4j.Logger; import org.springframework.beans.factory.InitializingBean; import org.springframework.jdbc.core.JdbcTemplate; /** * 针对于DAO的拦截器 * <p> * 对于修改或者新增方法，将其ID加入到lucene的更新列表中，以便于lucene的精确更新 * 本拦截器拦截的是被拦截对象的方法，通常被拦截对象方法内部才会调用抽象父类的相关数据库修改更新等操作 * 所以常规的调用下，内部的调用将不会被拦截，所以在子类中调用抽象父类的方法必须要采用获取代理对象的方式 * 如： * if(null != AopContext.currentProxy()){ * ((NorQuickNewsDAO)AopContext.currentProxy()).method2();//必须是接口中的方法，无法转换成Impl类 * }else{ * method2(); * } * * 特别注意：本拦截器的实现将增加数据库操作压力 * </p> * * @author quzishen */ public class LuceneMethodInterceptor implements InitializingBean,MethodInterceptor{ protected final Logger logger = Logger.getLogger(LuceneMethodInterceptor.class); /** ~~~ 默认的需要进行拦截的方法 */ private static Set<String> methodNeedsIntercepted = new HashSet<String>(); /** ~~~ 搜索引擎 */ private LuceneSearcherService luceneSearcherService; /** ~~~ 本地缓存服务 */ private LocalCacheService localCacheService; /** ~~~ 当前数据库的最后一条数据的ID，用于在进行完批量插入后的定时更新 */ private static Map<String,String> LAST_ID_MAP = new HashMap<String,String>(); /** ~~~ 使用搜索引擎提供的针对待更新set在man中的默认名称 */ private static final String DEFAULT_ID_LIST_KEY = null; /** ~~~ 默认的DAO*/ private AbstractBaseDAO abstractBaseDAO; /** ~~~ 特别针对于匿名内部类提供的操作jdbc模板 */ private JdbcTemplate jdbcTemplate; /** ~~~ 默认的sql中写法 */ private final static String SQL_FROM = " from "; private final static String SQL_SELECT = " select "; private final static String SQL_WHERE = " where "; private LuceneMethodInterceptor() { super(); } /** * 初始化匿名内部类 */ public void afterPropertiesSet() throws Exception { // 匿名内部类 abstractBaseDAO = new AbstractBaseDAO() { }; abstractBaseDAO.setJdbcTemplate(jdbcTemplate); // 初始化需要拦截的方法set AbsDaoInterceptorMethodNameEnum[] enumArray = AbsDaoInterceptorMethodNameEnum.values(); for(int i = 0;i < enumArray.length;i++){ methodNeedsIntercepted.add(enumArray[i].keyValue); } } /** * 执行拦截 * <p> * 拦截器将执行：对特定方法所影响到的数据库的数据，获取其ID，并放入待更新列表中以提供给搜索引擎更新之用途 * 目前该拦截器与封装的AbstractBaseDAO紧耦合，我们采用AbstractBaseDAO作为统一的底层数据库操作模型 * </p> */ public Object invoke(MethodInvocation methodInvocation) throws Throwable { // 获取执行方法 Method method = methodInvocation.getMethod(); // 获取执行方法的参数 Object[] arguments = methodInvocation.getArguments(); // 获取方法名称 String methodName = method.getName(); if (methodNeedsIntercepted.contains(methodName)) { /** * 判断当前执行的方法，并使用不同的策略去获取更新过的数据的ID，放入搜索引擎的待更新列表中 * 对于那些对拦截方法的返回结果没有依赖的方法，那么首先执行完被拦截方法然后再进行操作，这样可以避免出现拦截方法执行失败导致的诸多问题 * 如果拦截方法执行完毕，本地的获取代码不能对拦截方法产生影响，即不能随意抛出异常等问题 */ if (StringUtils.equalsIgnoreCase(methodName,AbsDaoInterceptorMethodNameEnum.INSERT_METHOD.keyValue)) { // 增加方法 if (logger.isDebugEnabled()) { logger.debug("intercepte the insert method!"); } /** ~~~~~~~~~ run the method ~~~~~~~~ */ Integer returnValue = (Integer) methodInvocation.proceed(); // 更新lasted ID数值，需要线程同步 Object insertObject = arguments[0]; String idKey = insertObject.getClass().getName(); // 添加IDS luceneSearcherService.addOneIdToSet(idKey,returnValue.longValue()); String lastId = LAST_ID_MAP.get(idKey); if(StringUtils.isEmpty(lastId)){ LAST_ID_MAP.put(idKey, returnValue.toString()); } else { synchronized(lastId){ lastId = returnValue.intValue() > Integer.parseInt(lastId) ? returnValue.intValue()+"":lastId; LAST_ID_MAP.put(idKey, lastId); } } return returnValue; } else if (StringUtils.equalsIgnoreCase(methodName,AbsDaoInterceptorMethodNameEnum.UPDATE_OBJECT_METHOD.keyValue)) { // 更新对象方法，先执行更新方法然后再获取id if (logger.isDebugEnabled()) { logger.debug("intercepte the updateObject method!"); } /** ~~~~~~~~~ run the method ~~~~~~~~ */ Integer returnValue = (Integer) methodInvocation.proceed(); if (0 >= returnValue.intValue()) { return returnValue; } // 添加IDS addIdByUpdateObject(arguments); return returnValue; } else if (StringUtils.equalsIgnoreCase(methodName,AbsDaoInterceptorMethodNameEnum.UPDATE_FIELD_METHOD.keyValue)) { // 更新字段方法 if (logger.isDebugEnabled()) { logger.debug("intercepte the updateField method!"); } /** ~~~~~~~~~ run the method ~~~~~~~~ */ Integer returnValue = (Integer) methodInvocation.proceed(); if (0 >= returnValue.intValue()) { return returnValue; } // 添加IDS addIdByUpdateField(arguments); return returnValue; } else if (StringUtils.equalsIgnoreCase(methodName,AbsDaoInterceptorMethodNameEnum.UPDATE_FIELD_BYSQL_WITH_PLACEHOLDER_METHOD.keyValue)) { // 通过sql更新方法，这里特别需要注意的是多表联合操作以及sql中具有表别名的问题 if (logger.isDebugEnabled()) { logger.debug("intercepte the updateFieldBySqlWithPlaceHolder method!"); } /** ~~~~~~~~~ run the method ~~~~~~~~ */ Integer returnValue = (Integer) methodInvocation.proceed(); if (0 >= returnValue.intValue()) { return returnValue; } // 添加IDS addIdByUpdateSQL(arguments); return returnValue; } else if (StringUtils.equalsIgnoreCase(methodName,AbsDaoInterceptorMethodNameEnum.BATCH_INSERT_METHOD.keyValue)) { /** ~~~~~~~~~ run the method ~~~~~~~~ */ methodInvocation.proceed(); // 添加IDS addIdByBatchInsert(arguments); return null; } else if (StringUtils.equalsIgnoreCase(methodName,AbsDaoInterceptorMethodNameEnum.BATCH_UPDATE_METHOD.keyValue)) { /** ~~~~~~~~~ run the method ~~~~~~~~ */ methodInvocation.proceed(); // 添加到IDS addIdByBatchUpdate(arguments); return null; } else if (StringUtils.equalsIgnoreCase(methodName,AbsDaoInterceptorMethodNameEnum.DELETE_BY_ID_METHOD.keyValue)) { /** ~~~~~~~~~ run the method ~~~~~~~~ */ Integer returnValue = (Integer) methodInvocation.proceed(); if (0 >= returnValue.intValue()) { return returnValue; } // 添加IDS addIdByDelById(arguments); return returnValue; } else if (StringUtils.equalsIgnoreCase(methodName,AbsDaoInterceptorMethodNameEnum.DELETE_BYSQL_WITH_PLACEHOLDER_METHOD.keyValue)) { // 先执行拦截再删除，防止删除后就无法获取ID addIdByDelBySql(arguments); /** ~~~~~~~~~ run the method ~~~~~~~~ */ return methodInvocation.proceed(); } else { return methodInvocation.proceed(); } } else { return methodInvocation.proceed(); } } // ~~~~~~~~~~~ private method begin ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~// /** * 增加ID到搜索引擎中 -- 根据sql删除触发 */ @SuppressWarnings({ "unchecked", "rawtypes" }) private void addIdByDelBySql(Object[] arguments){ // 参数判断 if(AbsDaoInterceptorMethodNameEnum.DELETE_BYSQL_WITH_PLACEHOLDER_METHOD.argumentsNum == arguments.length){ String sql = (String) arguments[0]; Map<String,Object> params= (Map) arguments[1]; Class objectClass = (Class)arguments[1]; // 渲染sql @SuppressWarnings("static-access") String buildsql = abstractBaseDAO.getSqlFromPlaceHolder(sql, params); // 组装查询ID的语句 String queryIdSql = buildSlqByDelSql(buildsql); // 执行查询和保存 saveIdByWholeSQLwithoutObjectClass(queryIdSql,objectClass); } else { // 参数个数异常 logger.error("deleteBySqlWithPlaceHolder method does not have two arguments! Interceptor execute failed!"); return; } } /** * 增加ID到搜索引擎中 -- 根据ID删除触发 * <p> * 根据传入的参数获取其中的ID参数并保存 * </p> * @param arguments 拦截方法参数 */ private void addIdByDelById(Object[] arguments){ // 判断参数 if(AbsDaoInterceptorMethodNameEnum.DELETE_BY_ID_METHOD.argumentsNum == arguments.length){ Long id = (Long) arguments[0]; @SuppressWarnings("rawtypes") Class objectClass = (Class) arguments[1]; luceneSearcherService.addOneIdToSet(getLuceneKeyFromClassName(objectClass.getName()), id); } else { // 参数个数异常 logger.error("deleteById method does not have two arguments! Interceptor execute failed!"); return; } } /** * 增加ID到搜索引擎中 -- 批量更新触发 * <p> * 根据传入的批量列表遍历获取其中的ID参数并保存 * </p> * @param arguments 参数 */ @SuppressWarnings("rawtypes") private void addIdByBatchUpdate(Object[] arguments){ // 判断参数 if(AbsDaoInterceptorMethodNameEnum.BATCH_UPDATE_METHOD.argumentsNum == arguments.length){ // 获取参数中list参数 List list = (List) arguments[0]; // 用来保存id Set<Long> ids = new HashSet<Long>(); // 迭代器 Iterator iterator = list.iterator(); while(iterator.hasNext()){ // 遍历获取对象 Object object = iterator.next(); // 获取ID String id = abstractBaseDAO.getValueByName(object, abstractBaseDAO.DEFAULT_ID_NAME); if(!StringUtils.isBlank(id)){ ids.add(Long.parseLong(id)); } } // 增加到搜索引擎中 Class objectClass = (Class) arguments[1]; luceneSearcherService.addSetsToSet(getLuceneKeyFromClassName(objectClass.getName()), ids); } else { // 参数个数异常 logger.error("batchUpdate method does not have two arguments! Interceptor execute failed!"); return; } } /** * 增加ID到搜索引擎中--批量插入触发 * <p> * 根据ID获取新增的所有的ID，set到搜索引擎中，插入方法不涉及重复性，不需要使用缓存 * </p> * @param arguments 拦截方法的参数 */ private void addIdByBatchInsert(Object[] arguments){ // 判断参数 if(AbsDaoInterceptorMethodNameEnum.BATCH_INSERT_METHOD.argumentsNum == arguments.length){ @SuppressWarnings("rawtypes") Class objectClass = (Class) arguments[1]; // 组装查询sql String idKey = objectClass.getName(); String lastId = StringUtils.isEmpty(LAST_ID_MAP.get(idKey))? "1":LAST_ID_MAP.get(idKey); String queryIdSql = buildSqlByBeginId(objectClass, lastId); // 执行查询和保存 saveIdByWholeSQL(queryIdSql,objectClass); return; } else { // 参数个数异常 logger.error("batchInsert method does not have two arguments! Interceptor execute failed!"); return; } } /** * 增加ID到搜索引擎中--更新对象触发 * @param arguments 拦截方法的参数 */ @SuppressWarnings("unchecked") private void addIdByUpdateObject(Object[] arguments) { // 判断参数个数 if (AbsDaoInterceptorMethodNameEnum.UPDATE_OBJECT_METHOD.argumentsNum == arguments.length) { Object object = arguments[0]; Map<String, Object> conditions = (Map<String, Object>) arguments[1]; // 保存ID saveIdsByCondition(object.getClass(),conditions); } else { // 参数个数异常 logger.error("updateObject method does not have two arguments! Interceptor execute failed!"); return; } } /** * 通过更新字段方法获取ID并设置到搜索引擎中 -- 更新对象触发 * 专有方法 * @param arguments 拦截方法的参数 */ private void addIdByUpdateField(Object[] arguments){ if(AbsDaoInterceptorMethodNameEnum.UPDATE_FIELD_METHOD.argumentsNum == arguments.length){ @SuppressWarnings("unchecked") Map<String,Object> conditions = (Map<String,Object>)arguments[1]; @SuppressWarnings("rawtypes") Class objectClass = (Class)arguments[2]; // 保存ID saveIdsByCondition(objectClass,conditions); } else { // 参数个数异常 logger.error("updateField method does not have two arguments! Interceptor execute failed!"); return; } } /** * 通过sql更新方法获取ID并设置到搜索引擎中 -- 根据sql更新触发 * @param arguments 参数 */ private void addIdByUpdateSQL(Object[] arguments){ if(AbsDaoInterceptorMethodNameEnum.UPDATE_FIELD_BYSQL_WITH_PLACEHOLDER_METHOD.argumentsNum == arguments.length){ @SuppressWarnings("unchecked") Map<String,Object> conditions = (Map<String,Object>)arguments[1]; @SuppressWarnings("rawtypes") Class objectClass = (Class)arguments[2]; String sql = (String)arguments[0]; // 保存ID saveIdsBySQL(sql,objectClass,conditions); }else { // 参数个数异常 logger.error("updateFieldBySqlWithPlaceHolder method does not have two arguments! Interceptor execute failed!"); return; } } /** * 保存ID * 适用于API中自动组装sql的情况 * @param objectClass 对象类型 * @param conditions 查询条件 */ protected void saveIdsByCondition(@SuppressWarnings("rawtypes") Class objectClass,Map<String,Object> conditions){ // 缓存key值 String key = getMethodCacheKey(objectClass,AbsDaoInterceptorMethodNameEnum.UPDATE_OBJECT_METHOD.keyValue,conditions); // 从缓存中取值 Set<Long> idset = getIdsFromCache(key,objectClass); // 缓存中未取到 if (0 < idset.size()) { // 增加ID到搜索引擎的列表中 String ids = addIdByObjectClassFromDB(objectClass, conditions); if(StringUtils.isBlank(ids)){ return; } // 更新到缓存 localCacheService.addCache(key, ids); } } /** * 根据更新条件拼装sql从数据库中获取修改的ID，并设置到搜索引擎的待更新列表中 * 公共方法- 适用于拼装sql的API * @param object 更新对象 */ protected String addIdByObjectClassFromDB(@SuppressWarnings("rawtypes") Class objectClass,Map<String, Object> conditions) { // return value String returnValue = ""; // 获取sql的条件部分，如 where condition ... @SuppressWarnings("static-access") String sql = abstractBaseDAO.getSqlCondition("", conditions, true); if(StringUtils.isBlank(sql)){ return returnValue; } // 组装获取ID的sql select id from table where condition ..... String queryIdSql = buildSelectSqlByConditionSql(objectClass,sql); // 执行查询和保存 returnValue = saveIdByWholeSQL(queryIdSql,objectClass); return returnValue; } /** * 保存ID * 适用于API中使用外部传入sql的情况 * @param objectClass 对象类型 * @param conditions 查询条件 */ protected void saveIdsBySQL(String sql,@SuppressWarnings("rawtypes") Class objectClass,Map<String,Object> conditions){ // 缓存key值 String key = getMethodCacheKey(objectClass,AbsDaoInterceptorMethodNameEnum.UPDATE_OBJECT_METHOD.keyValue,conditions); // 从缓存中取值 Set<Long> idset = getIdsFromCache(key,objectClass); // 缓存中未取到 if (0 < idset.size()) { // 渲染sql，将占位符替换成具体值 @SuppressWarnings("static-access") String updasql = abstractBaseDAO.getSqlFromPlaceHolder(sql, conditions); // 增加ID到搜索引擎的列表中 String ids = addIdObjectClassAndSqlFromDB(updasql,objectClass); if(StringUtils.isBlank(ids)){ return; } // 更新到缓存 localCacheService.addCache(key, ids); } } /** * 根据更新sql拼装查询sql获取ID并设置到搜索引擎的待更新列表中 * 公共方法-适用于API中使用外部sql具有sql参数的情况 * @param sql 完整的更新sql * @param objectClass 对象类型 * @param conditions 查询条件 * @return */ protected String addIdObjectClassAndSqlFromDB(String sql,@SuppressWarnings("rawtypes") Class objectClass){ // return value String returnValue = ""; // 根据更新sql组装查询sql String queryIdSql = buildSelectSqlByUpdateSql(sql); // 执行查询和保存 returnValue = saveIdByWholeSQL(queryIdSql,objectClass); return returnValue; } /** * 根据组装好的sql查询ID并且保存 * @param queryIdSql 完整的sql * @param objectClass 对象类型 * @return ID串，以逗号隔开 */ protected String saveIdByWholeSQL(String queryIdSql,@SuppressWarnings("rawtypes") Class objectClass){ if(StringUtils.isBlank(queryIdSql) || null == objectClass){ return null; } // return value String returnValue = ""; // 执行查询 List<Map<String, Object>> ids = abstractBaseDAO.queryFieldsListBySql(queryIdSql, null, objectClass); if(null == ids){ return returnValue; } // 获取ID Iterator<Map<String, Object>> idsIndex = ids.iterator(); Set<Long> idset = new HashSet<Long>(); while (idsIndex.hasNext()) { Map<String, Object> map = idsIndex.next(); String id = map.get(abstractBaseDAO.DEFAULT_ID_NAME) + ""; idset.add(Long.parseLong(id)); returnValue += Long.parseLong(id); returnValue += ","; } // 增加到搜索引擎的待更新列表中 luceneSearcherService.addSetsToSet(getLuceneKeyFromClassName(objectClass.getName()), idset); returnValue = returnValue.substring(0, returnValue.length() - 1); return returnValue; } /** * 根据组装好的sql查询ID并且保存，直接使用sql查询，不需要使用对象类型封装结果 * @param queryIdSql 封装好的sql * @return */ @SuppressWarnings("unchecked") protected String saveIdByWholeSQLwithoutObjectClass(String queryIdSql,@SuppressWarnings("rawtypes") Class objectClass){ if(StringUtils.isBlank(queryIdSql)){ return null; } // return value String returnValue = ""; List<Object> ids = abstractBaseDAO.queryListBySql(queryIdSql); if(null == ids){ return returnValue; } Iterator<Object> idIndex = ids.iterator(); Set<Long> idSet = new HashSet<Long>(); while(idIndex.hasNext()){ Object value = idIndex.next(); if(null == value){ continue; } Long longValue = Long.parseLong(value.toString()); idSet.add(longValue); } luceneSearcherService.addSetsToSet(getLuceneKeyFromClassName(objectClass.getName()), idSet); return returnValue; } /** * 根据更新sql拼装查询sql * @param sql * @return */ private String buildSelectSqlByUpdateSql(String sql){ String selectSql = ""; int updateIndexBegin = sql.indexOf("update"); int updateIndexEnd = updateIndexBegin + 5; int setIndexBegin = sql.indexOf("set"); String tables = sql.substring(updateIndexEnd+1, setIndexBegin); int whereBegin = sql.indexOf("where"); String condition = sql.substring(whereBegin, sql.length()); selectSql = SQL_SELECT + " "+abstractBaseDAO.DEFAULT_ID_NAME + " "+ SQL_FROM + tables + condition; return selectSql; } /** * 根据条件sql获取查询ID的sql * * @param objectClass * @param conditionSql 如where name='quzishen' and address='hangzhou' * @return */ private String buildSelectSqlByConditionSql(@SuppressWarnings("rawtypes") Class objectClass,String conditionSql){ // 获取表名 String tableName = abstractBaseDAO.getTableConfigName(objectClass); abstractBaseDAO.setTableName(tableName); // 组装获取ID的sql select id from table where condition ..... String queryIdSql = SQL_SELECT + " "+ abstractBaseDAO.DEFAULT_ID_NAME + " "+ SQL_FROM + tableName + conditionSql; return queryIdSql; } /** * 组装sql-根据其实ID获取所有的大于其实ID的ID * @param objectClass 类型 * @param id 起始ID * @return */ private String buildSqlByBeginId(@SuppressWarnings("rawtypes") Class objectClass, String id){ // 获取表名 String tableName = abstractBaseDAO.getTableConfigName(objectClass); abstractBaseDAO.setTableName(tableName); // 组装sql : select Id from table where id > 10 String queryIdSql = SQL_SELECT + " "+ abstractBaseDAO.DEFAULT_ID_NAME + " "+ SQL_FROM + tableName + SQL_WHERE + abstractBaseDAO.DEFAULT_ID_NAME + ">" + id; return queryIdSql; } /** * 根据删除sql封装查询sql * @param sql 删除sql * @return */ private String buildSlqByDelSql(String sql){ String querySql = ""; if(StringUtils.isBlank(sql)){ return querySql; } int beginIndex = sql.indexOf(SQL_FROM); querySql = sql.substring(beginIndex); querySql = SQL_SELECT + " "+ abstractBaseDAO.DEFAULT_ID_NAME + " "+ querySql; return querySql; } /** * 获取当前的索引在搜索引擎中对应的key-限定为DO类的短类名 * @param className * @return */ private String getLuceneKeyFromClassName(String className){ int index = className.lastIndexOf("."); String key = className.substring(index+1, className.length()); return StringUtils.isBlank(key)? DEFAULT_ID_LIST_KEY:key; } /** * 从缓存中获取id并放入搜索引擎中 * 公共方法 * @param key 缓存key * @return id集合 */ protected Set<Long> getIdsFromCache(String key,@SuppressWarnings("rawtypes") Class objectClass){ //~~~ return value Set<Long> idset = new HashSet<Long>(); // 从缓存中获取 Object cacheObject = localCacheService.getCache(key); if (null != cacheObject) { // 缓存中的id的记录格式是以逗号","隔开的，所以需要解析出来，并转成long型放入set String ids = cacheObject.toString(); String[] idsarray = StringUtils.split(ids, ","); for (int k = 0; k < idsarray.length; k++) { idset.add(Long.parseLong(idsarray[k] + "")); } // 保存到搜索引擎 luceneSearcherService.addSetsToSet(getLuceneKeyFromClassName(objectClass.getName()), idset); } return idset; } /** * 获取方法在缓存中的key值 * 通用方法 * @param methodName 方法名称 * @param arguments 方法参数数组 * @return key值 */ protected String getMethodCacheKey(@SuppressWarnings("rawtypes") Class objectClass,String methodName, Map<String, Object> conditions) { // 先从缓存中获取 String key = methodName+"("; Iterator<String> mapKeys = conditions.keySet().iterator(); while (mapKeys.hasNext()) { String indexkey = mapKeys.next(); Object value = conditions.get(indexkey); key += (indexkey + "=" + value); } return objectClass.getName()+key+")"; } // ~~~~~~~~~~~ private setter && getter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ public static Set<String> getMethodNeedsIntercepted() { return methodNeedsIntercepted; } public static void setMethodNeedsIntercepted( Set<String> methodNeedsIntercepted) { LuceneMethodInterceptor.methodNeedsIntercepted = methodNeedsIntercepted; } public void setLuceneSearcherService(LuceneSearcherService luceneSearcherService) { this.luceneSearcherService = luceneSearcherService; } public void setLocalCacheService(LocalCacheService localCacheService) { this.localCacheService = localCacheService; } public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; } } /** ~~~ 以下为默认的静态的数据库操作方法的方法名称 - 目前AbstractBaseDAO紧耦合 */ enum AbsDaoInterceptorMethodNameEnum { // [1] INSERT_METHOD("insertObject",1), // [2] UPDATE_OBJECT_METHOD("updateObject",2), // [3] UPDATE_FIELD_METHOD("updateField",3), // [4] UPDATE_FIELD_BYSQL_WITH_PLACEHOLDER_METHOD("updateFieldBySqlWithPlaceHolder",3), // [5] BATCH_INSERT_METHOD("batchInsert",3), // [6] BATCH_UPDATE_METHOD("batchUpdate",2), // [7] DELETE_BY_ID_METHOD("deletebyId",2), // [8] DELETE_BYSQL_WITH_PLACEHOLDER_METHOD("deleteBySqlWithPlaceHolder",3); // ~~~ 方法名称 String keyValue; // ~~~ 参数个数 int argumentsNum; private AbsDaoInterceptorMethodNameEnum(String keyValue,int argumentsNum) { this.keyValue = keyValue; this.argumentsNum = argumentsNum; } }

实时的拦截可能会导致对重复方法的频繁拦截，所以在执行完一次拦截之后，我们会将本次执行拦截的方法名称和参数都放入缓存中，有效时间为5分钟，这样保证5分钟内的重复拦截都将被过滤掉，减轻系统压力。

我们设置一个key值，其公式为：调用DAO涉及的DO的类型字符串+方法名称+（参数=值）

通常而言，理想的做法是通过DAO类型字符串加方法和参数的方式来判断，但是这里场景是，当二次拦截进入方法的时候，这里拦截类的类型是AbstractBaseDAO，而不是具体的某个子类DAO。所以，无法获取某个具体子类dao的类型。

这样，在缓存中唯一性的标记某个DAO的操作，注意我们是通过DO类型来判断，我们严格的遵守每个DAO 原子性的操作一个数据对象的原则，当然，这里也支持一个DAO操作不同的Do的操作。

缓存的执行代码很简单，前面的文章中已经有相关代码，此处省略。注意的是，它可以存放任何数据，而不仅限制于当前场景下的索引ID数据。

 

part2，引入xml配置文件的方式实现索引建立的动态配置，同时实现针对不同的数据来源建立不同的索引并分域存放

我们会在系统中建立多个索引，比如商品的索引，会员的索引，我们希望能够以一种简便的方式，来配置相应的需要建立索引的数据源和建立索引的字段以及索引存放的路径等信息。在拦截器中，使用的是一个set来保存的，这里自然的我们也可以采用一个List来保存，但是对于配置方面，我们希望能够有一种简洁而清晰的方式，而不是每次新增需要建立索引的内容的时候都去找到这个搜索bean然后修改其property的部分。

自然的，我们将采用xml配置文件的方式，类似如下：

<?xml version="1.0" encoding="GBK"?> <lucene> <rule> <className>com.normandy.position.domain.NorQuickNews</className> <fields>id,prop1,prop2,prop3,prop4,prop5 </fields> <indexDir>c:/luceneIndex/goods</indexDir> </rule> </lucene>

我们配置了需要建立索引的类型名称，需要建立索引的字段，以及索引存放的位置，这样的配置清晰而易于管理，以后的扩展性也很方便。相应的，我们的搜索引擎需要修改，首先看其配置：

<!-- 配置 service bean --> <bean id="luceneSearcherService" class="com.normandy.position.common.LuceneMultiSearcher" depends-on="jdbcTemplate"> <property name="defaultIndexDir"> <value>${lucene.index.dir}</value> </property> <property name="configureFilePath" value="WEB-INF/luceneConfig.xml"/> </bean>

我们制定了配置文件的路径，那么在搜索引擎中，我们通过装配一个list，来保存当前系统中需要建立索引的配置信息。

/** ~~~ 系统配置的需要执行搜索操作的配置*/ private static List<SearchConfigure> indexList = new ArrayList<SearchConfigure>();

// 解析xml文件，封装索引列表 Digester digester = new Digester(); digester.setValidating(false); digester.addObjectCreate("lucene", "java.util.ArrayList"); digester.addSetProperties("lucene"); digester.addObjectCreate("lucene/rule", SearchConfigure.class.getName()); digester.addSetProperties("lucene/rule"); digester.addBeanPropertySetter("lucene/rule/className"); digester.addBeanPropertySetter("lucene/rule/fields"); digester.addBeanPropertySetter("lucene/rule/indexDir"); digester.addSetNext("lucene/rule", "add",SearchConfigure.class.getName()); indexList = (List<SearchConfigure>)digester.parse(configureFilePath);

其中涉及到一个配置对象类：

package com.normandy.position.common; /** * lucene配置文件解析定义 * @author quzishen * */ public class SearchConfigure { /**~~~ 配置的KEY值，用于唯一性区分，使用DO的短名称，定义性的要求，不需要外部配置，自动解析className生成*/ private String key; /**~~~ 建立索引的DO类名，全路径*/ private String className; /**~~~ 需要建立索引的字段串，以","分割*/ private String fields; /**~~~ 索引存放的位置*/ private String indexDir; public String getKey() { return key; } public void setKey(String key) { this.key = key; } public String getClassName() { return className; } public void setClassName(String className) { this.className = className; int index = className.lastIndexOf("."); this.key = className.substring(index+1, className.length()); } public String getIndexDir() { return indexDir; } public void setIndexDir(String indexDir) { this.indexDir = indexDir; } public String getFields() { return fields; } public void setFields(String fields) { this.fields = fields; } }

这样我们完成了配置，在后续的索引建立，搜索等过程中，我们将一直以配置来作为依据，比如索引存放位置，索引的名称等等。

看看重构后我们的搜索服务：

package com.normandy.position.common; import java.util.List; import java.util.Map; import java.util.Set; /** * lucene 搜索服务 * @author quzishen * @version 1.0 */ public interface LuceneSearcherService { /** * 初始化索引文件-适用于系统首次启动或者索引文件丢失 * @throws RuntimeException */ public void initIndex() throws RuntimeException; /** * 删除所有的索引文件-适用于系统索引文件出现紊乱导致搜索结果不正确，需要重新建立索引文件之前 * @throws RuntimeException */ public void removeLuceneIndex() throws RuntimeException; /** * 刷新索引文件 - 适用于系统运行过程中数据变更导致的索引过期问题处理 - 单独线程处理 - 已控制同步 * @throws RuntimeException */ public void refreshIndex() throws RuntimeException; /** * 单字符串搜索 - 使用默认的相似度分值排序 * @param keywords 搜索字符串 * @return 搜索结果 */ public List<Map<String, String>> search(String indexKey,String keywords); /** * 分页单字符串搜索 - 使用默认的相似度分值排序 * @param keywords 搜索字符串 * @param pageNum 页号 * @param pageSize 分页大小 * @return 搜索结果 */ public Paginal<Map<String, String>> searchPaging(String indexKey,String keywords, int pageNum, int pageSize); /** * 根据组合条件执行搜索 - 使用默认的相似度分值排序，如果干扰排序，则需要谨慎考虑综合相似度分值和排序字段 * <p> * ~~~~支持：多个字段的OR-AND组合，某个字段的Between区间值判断搜索以及多种条件的组合搜索 * * ~~~~针对参数的说明： * equalOrSearchkeywordsMap ：用于存放多个模糊匹配相等搜索条件，彼此之间是OR的关系，同时一个key可以对应多个value，彼此之间也是OR的关系。 * 如：<key1,<1,2>> <key2,<1,2,3>> --> (key1=1 or key1=2) OR (key2=1 or key2=2 or key2=3) * * equalAndSearchKeyWordsMap ：用于存放多个模糊匹配相等搜索条件，彼此之间是AND的关系，同时一个key可以对应多个value，注意彼此之间是OR的关系。 * 如：<key1,<1,2>> <key2,<2,3>> --> (key1=1 or key1=2) AND (key2=2 or key2=3) * * betweensearchkeywordsMap ：用于存放多个区间搜索条件，彼此之间是AND关系，同时一个key最多可以对应两个value，超出的数据不会被处理，无效。 * 如：<key1,<1,5>> <key2,<'',3>> <key3,<2,7,9>> <key4,<4>> * --> (key1 >= 1 and key1 <=5) AND (key2 >=Integer.MIN_VALUE and key2 <= 3) AND (key3>=2 and key3<=7) AND (key4>=4 and key4<=Integer.MAX_VALUE) * * ~~~~应用场景举例： * 搜索框中对应的搜索应该放入equalOrSearchkeywordsMap，表示多个字段都可能与之匹配，与其他的条件为并集搜索 * 精确选择如类型等的搜索应该放入equalAndSearchKeyWordsMap，表示特定字段匹配同时与其他条件为交集搜索 * 关于价格等区间判断应该放入betweensearchkeywordsMap，同时与其他条件为交集搜索 * * </p> * @param String indexKey 搜索的索引域名称 * @param equalOrSearchkeywordsMap 搜索条件OR关系集合 * @param equalAndSearchKeyWordsMap 搜索条件AND关系集合 * @param betweensearchkeywordsMap 搜索条件区间关系集合 List<String> 长度不限制，但是有效长度最大为2，超出2的数据将不被处理 * @return */ public List<Map<String, String>> searchWithCondition( String indexKey, Map<String, List<String>> equalOrSearchkeywordsMap, Map<String, List<String>> equalAndSearchKeyWordsMap, Map<String, List<String>> betweensearchkeywordsMap); /** * 分页综合条件搜索 - 使用默认的相似度分值排序 * @see com.normandy.position.common.LuceneSearcherService#searchWithCondition(java.lang.String,java.util.Map, java.util.Map, java.util.Map) * @return */ public Paginal<Map<String, String>> searchWithConditionPaging( String indexKey, Map<String, List<String>> equalOrSearchkeywordsMap, Map<String, List<String>> equalAndSearchKeyWordsMap, Map<String, List<String>> betweensearchkeywordsMap,int pageNum,int pageSize); /** * 增加一个ID到待更新列表 * @param keyName * @param id */ public void addOneIdToSet(String keyName, Long id); /** * 增加ID列表到待更新列表 * @param keyName * @param ids */ public void addSetsToSet(String keyName, Set<Long> ids); }

 

part3、搜索引擎的实现：

对于多种索引的存在，在搜索的过程中，我们需要指定使用其中的哪一种来进行搜索。索引种类的名称采用一个默认的规则：DO类型的名称，这个对应于拦截器进行设置待更新ID列表的时候，用于指定当前需要更新的列表对应于哪种索引。

package com.normandy.position.common; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.commons.digester.Digester; import org.apache.commons.lang.StringUtils; import org.apache.log4j.Logger; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.index.CorruptIndexException; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.IndexReader.FieldOption; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.index.Term; import org.apache.lucene.queryParser.ParseException; import org.apache.lucene.queryParser.QueryParser; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanClause.Occur; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.DuplicateFilter; import org.apache.lucene.search.Hits; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; import org.apache.lucene.search.RangeQuery; import org.apache.lucene.search.TermQuery; import org.apache.lucene.store.LockObtainFailedException; import org.springframework.beans.factory.InitializingBean; import org.springframework.jdbc.core.JdbcTemplate; /** * 使用lucene进行搜索服务 * <p> * 适用于数据量不大的单机搜索服务，对于数据量较大的搜索，建议使用分布式搜索 * 提供了组合搜索、单值搜索等 * </p> * * @author quzishen * @version 1.0 */ public class LuceneMultiSearcher implements Runnable, InitializingBean,LuceneSearcherService { protected final Logger logger = Logger.getLogger(LuceneMultiSearcher.class); /** ~~~ 开关 */ private boolean useSearchEngin = true; /** ~~~ 系统配置的需要执行搜索操作的配置*/ private static List<SearchConfigure> indexList = new ArrayList<SearchConfigure>(); /** ~~~ lucene配置文件路径*/ private String configureFilePath; /** ~~~ 默认的索引存放目录 */ private String defaultIndexDir = "c:/index/"; /** ~~~ 配置中需要索引字段的默认分隔符 */ private static final String DEFAULT_KEY_FIELD_SPLIT = ","; /** ~~~ 默认的标记符名称，如果fieldsStr中含有主键，则使用主键名称 */ private static final String DEFAULT_ID = "id"; /** ~~~ 是否每次重新建立索引 */ private boolean IS_REBUILD_INDEX = true; /** ~~~ 默认的建立索引的最大数目 */ private int DEFAULT_MAX_INDEX_NUMS = Integer.MAX_VALUE; /** ~~~ 默认的索引名称*/ private static final String NEEDS_UPDATE_ID_LIST_KEY = "needsUpdateIdListKey"; /** ~~~ 特别针对于匿名内部类提供的操作jdbc模板 */ private JdbcTemplate jdbcTemplate; /** ~~~ 用来进行数据库操作的匿名内部类 */ private AbstractBaseDAO abstractBaseDAO; /** ~~~ 本地缓存服务*/ private LocalCacheService localCacheService; /** ~~~ 需要更新的内容map */ protected static Map<String, Set<Long>> needsUpdateIdList = new HashMap<String, Set<Long>>(); /** ~~~ 分页搜索下，进行缓存的页数，从1开始计数，通常用于提高首页的加载速度*/ private static final int NEED_CACHE_PAGE_NUM = 3; @SuppressWarnings("unchecked") public void afterPropertiesSet() throws Exception { // 匿名内部类 abstractBaseDAO = new AbstractBaseDAO() { }; abstractBaseDAO.setJdbcTemplate(jdbcTemplate); // 解析xml文件，封装索引列表 Digester digester = new Digester(); digester.setValidating(false); digester.addObjectCreate("lucene", "java.util.ArrayList"); digester.addSetProperties("lucene"); digester.addObjectCreate("lucene/rule", SearchConfigure.class.getName()); digester.addSetProperties("lucene/rule"); digester.addBeanPropertySetter("lucene/rule/className"); digester.addBeanPropertySetter("lucene/rule/fields"); digester.addBeanPropertySetter("lucene/rule/indexDir"); digester.addSetNext("lucene/rule", "add",SearchConfigure.class.getName()); indexList = (List<SearchConfigure>)digester.parse(configureFilePath); } /* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#initIndex() */ public void initIndex() throws RuntimeException { if (!useSearchEngin) { logger.info("can not use lucene search because it has been closed."); return; } if (null==indexList || 0 == indexList.size()) { throw new RuntimeException( "can not build the index by null value of field and className."); } long beginTime = System.currentTimeMillis(); if (logger.isInfoEnabled()) { logger.info("begin to build the lucene index..."); } Iterator<SearchConfigure> searchConfigureIndex = indexList.iterator(); while(searchConfigureIndex.hasNext()){ SearchConfigure searchConfigure = searchConfigureIndex.next(); buildIndexByConfig(searchConfigure); } long endTime = System.currentTimeMillis(); if (logger.isInfoEnabled()) { logger.info("end to build the lucene index...,use time :" + (endTime - beginTime) + "ms."); } } /** * 根据配置生成索引 * @param searchConfigure */ private void buildIndexByConfig(SearchConfigure searchConfigure){ try { String floder = getFloder(searchConfigure); Analyzer analyzer = new StandardAnalyzer(); IndexWriter indexWriter = new IndexWriter(floder, analyzer, IS_REBUILD_INDEX); // 控制写入一个新的segment前在内存中保存的最大的document数目 indexWriter.setMaxBufferedDocs(500); // 控制多个segment合并的频率 indexWriter.setMaxMergeDocs(100); buildIndex(searchConfigure, indexWriter); indexWriter.optimize(); indexWriter.close(); } catch (IOException e) { logger.error("create index failed!check the authentation!", e); throw new RuntimeException( "create index failed!check the authentation!", e); } } /* * (non-Javadoc) * @see java.lang.Runnable#run() */ public void run() { if (logger.isDebugEnabled()) { logger.debug("rebuild the index for lucene start..."); } long begin = System.currentTimeMillis(); Iterator<SearchConfigure> searchConfigureIndex = indexList.iterator(); while(searchConfigureIndex.hasNext()){ SearchConfigure s = searchConfigureIndex.next(); refreshOneIndex(s); } long end = System.currentTimeMillis(); if (logger.isDebugEnabled()) { logger.debug("rebuild the index for lucene end..." + (end - begin) + "ms."); } } /* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#refreshIndex() */ public void refreshIndex() throws RuntimeException { if (!useSearchEngin) { logger.info("can not use lucene search because it has been closed."); return; } new Thread(this).start(); } /* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#removeLuceneIndex() */ public void removeLuceneIndex(){ Iterator<SearchConfigure> index = indexList.iterator(); while(index.hasNext()){ SearchConfigure s = index.next(); removeAllIndex(s); } } /* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#search(java.lang.String) */ public List<Map<String, String>> search(String indexKey,String keywords) { if (!useSearchEngin) { logger.info("can not use lucene search because it has been closed."); return null; } // ~~~ return value List<Map<String, String>> result = new ArrayList<Map<String, String>>(); if(StringUtils.isBlank(keywords)){ return result; } // 获取相关配置 SearchConfigure searchConfigure = getSearchConfigureByName(indexKey); // 获取索引的位置 String floder = getFloder(searchConfigure); try { // 搜索执行器 IndexSearcher indexSearcher = new IndexSearcher(floder); // 分词器 Analyzer analyzer = new StandardAnalyzer(); // 关键字列表 List<String> keyWordsList = getKeyWordsList(searchConfigure); // 单次搜索重复结果过滤字段 DuplicateFilter duplicateFilter = getDuplicateFilter(searchConfigure); // 执行搜索 for (String indexName : keyWordsList) { QueryParser queryParser = new QueryParser(indexName, analyzer); Query query = queryParser.parse(keywords); /** ~~~~ run the search YEAH YEAH YEAH ~~~ */ Hits hits = indexSearcher.search(query,duplicateFilter); if (logger.isDebugEnabled()) { logger.debug("search result count:" + hits.length()); } // 处理结果 result = getResultListFromHits(searchConfigure,keyWordsList, hits, result); } } catch (CorruptIndexException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (LockObtainFailedException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (IOException e) { logger.error("create index failed!check the authentation!", e); throw new RuntimeException("create index failed!", e); } catch (ClassNotFoundException e) { logger.error("class not found!", e); throw new RuntimeException("create index failed!", e); } catch (ParseException e) { logger.error("parse keyword exception!", e); throw new RuntimeException("parse keyword exception!", e); } return result; } /* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#searchPaging(java.lang.String, java.lang.String, int, int) */ @SuppressWarnings("unchecked") public Paginal<Map<String, String>> searchPaging(String indexKey,String keywords, int pageNum, int pageSize) { if (!useSearchEngin) { logger.info("can not use lucene search because it has been closed."); return null; } String cacheKey = "searchPaging("+keywords.trim()+","+pageNum+","+pageSize+")"; // ~~~ 首先从缓存中获取，如果获取不到再从搜索引擎中获取 if(StringUtils.isNotBlank(keywords) && isNeedCache(pageNum)){ Object object = localCacheService.getCache(cacheKey); if(null != object){ return (Paginal<Map<String, String>>)object; } } // 执行搜索 List<Map<String, String>> resultList = search(indexKey,keywords); if (null == resultList || 0 == resultList.size()) { return null; } // ~~~~ return value Paginal<Map<String, String>> paginal = getPaginalFromResultList(resultList,pageNum,pageSize); // ~~~ 将结果缓存起来 if(isNeedCache(pageNum)){ localCacheService.addCache(cacheKey, paginal); } return paginal; } /* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#searchWithCondition(java.lang.String, java.util.Map, java.util.Map, java.util.Map) */ public List<Map<String, String>> searchWithCondition( String indexKey, Map<String, List<String>> equalOrSearchkeywordsMap, Map<String, List<String>> equalAndSearchKeyWordsMap, Map<String, List<String>> betweensearchkeywordsMap) { if (!useSearchEngin) { logger.info("can not use lucene search because it has been closed."); return null; } // ~~~ return value List<Map<String, String>> result = new ArrayList<Map<String, String>>(); // check the parameters if (chechMapEmpty(equalOrSearchkeywordsMap) && chechMapEmpty(equalAndSearchKeyWordsMap) && chechMapEmpty(betweensearchkeywordsMap)) { return result; } // 获取相关配置 SearchConfigure searchConfigure = getSearchConfigureByName(indexKey); // 获取索引的位置 String floder = getFloder(searchConfigure); try { // 关键字列表 List<String> keyWordsList = getKeyWordsList(searchConfigure); // 搜索执行器 IndexSearcher indexSearcher = new IndexSearcher(floder); // 组合查询 BooleanQuery bq = new BooleanQuery(); // 单次搜索重复结果过滤字段 DuplicateFilter duplicateFilter = getDuplicateFilter(searchConfigure); /********************************************************************************* * 组装条件模糊匹配条件 * * · 一个字段可以有多个模糊值，多个值之间是OR的关系。 如 name='quzishen' or * name='nigolasi' or name='chenlin' * · 多个字段可以有一个相似的模糊值，多个字段之间是OR关系 * 。如 name='quzishen' or nikename='quzishen' * · 多个字段的不同模糊值，彼此之间为AND关系。如( name='quzishen' or name='chenlin') and * (type=1 or type=2 or type=3) *********************************************************************************/ bq = getBooleanQueryByConditionMap(bq, equalOrSearchkeywordsMap, keyWordsList, BooleanClause.Occur.SHOULD); bq = getBooleanQueryByConditionMap(bq, equalAndSearchKeyWordsMap, keyWordsList, BooleanClause.Occur.MUST); /********************************************************************************* * 组装区间查询条件-多个区间条件彼此之间为AND关系，交集 *********************************************************************************/ bq = getRangeQueryByConditionMap(bq, betweensearchkeywordsMap, keyWordsList, BooleanClause.Occur.MUST); /********************************************************************************* * 执行搜索~~~~ run the search YEAH YEAH YEAH ~ *********************************************************************************/ Hits hits = indexSearcher.search(bq,duplicateFilter); /********************************************************************************* * 搜索结果封装 *********************************************************************************/ result = getResultListFromHits(searchConfigure,keyWordsList, hits, result); } catch (CorruptIndexException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (LockObtainFailedException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (IOException e) { logger.error("create index failed!check the authentation!", e); throw new RuntimeException("create index failed!", e); } catch (ClassNotFoundException e) { logger.error("class not found!", e); throw new RuntimeException("create index failed!", e); } return result; } /* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#searchWithConditionPaging(java.lang.String, java.util.Map, java.util.Map, java.util.Map, int, int) */ public Paginal<Map<String, String>> searchWithConditionPaging( String indexKey, Map<String, List<String>> equalOrSearchkeywordsMap, Map<String, List<String>> equalAndSearchKeyWordsMap, Map<String, List<String>> betweensearchkeywordsMap,int pageNum,int pageSize){ if (!useSearchEngin) { logger.info("can not use lucene search because it has been closed."); return null; } /**************************************************** * 执行搜索 ***************************************************/ List<Map<String, String>> resultList = searchWithCondition(indexKey,equalOrSearchkeywordsMap,equalAndSearchKeyWordsMap,betweensearchkeywordsMap); /**************************************************** * 处理分页 ***************************************************/ Paginal<Map<String, String>> paginal = getPaginalFromResultList(resultList,pageNum,pageSize); return paginal; } /** * 增加一个id到对应的set * * @param keyName * 对应的key的名称,必须是DO的名字 * @param id * 增加的ID */ public void addOneIdToSet(String keyName, Long id) { if (StringUtils.isBlank(keyName)) { keyName = NEEDS_UPDATE_ID_LIST_KEY; } if (needsUpdateIdList.containsKey(keyName)) { needsUpdateIdList.get(keyName).add(id); } else { Set<Long> ids = new HashSet<Long>(); ids.add(id); needsUpdateIdList.put(keyName, ids); } } /** * 批量增加ID到set中 * * @param keyName 必须是DO的名字 * @param ids */ public void addSetsToSet(String keyName, Set<Long> ids) { if (StringUtils.isBlank(keyName) || (null == ids || 0 == ids.size())) { keyName = NEEDS_UPDATE_ID_LIST_KEY; } if (needsUpdateIdList.containsKey(keyName)) { needsUpdateIdList.get(keyName).addAll(ids); } else { needsUpdateIdList.put(keyName, ids); } } /** * 从id对应的set中删除一个id * * @param keyName * 对应的key的名称 * @param id * 增加的ID */ public void removeOneIdFromSet(String keyName, Long id) { if (needsUpdateIdList.containsKey(keyName)) { needsUpdateIdList.get(keyName).remove(id); } } // ~~~~~~~~~~~~~~~~~~~~private method begin ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~// /** * 获取重复过滤器 * @return * @throws ClassNotFoundException */ private DuplicateFilter getDuplicateFilter(SearchConfigure searchConfigure) throws ClassNotFoundException{ String duplicateString = getKeyName(searchConfigure); DuplicateFilter duplicateFilter = new DuplicateFilter(duplicateString); return duplicateFilter; } /** * 根据结果获取分页器对象 * @param resultList 搜索结果列表 * @param pageNum 页号 * @param pageSize 分页大小 * @return */ private Paginal<Map<String, String>> getPaginalFromResultList(List<Map<String, String>> resultList,int pageNum, int pageSize){ // ~~~~ return value Paginal<Map<String, String>> paginal = new Paginal<Map<String, String>>(); // 初始化分页器 paginal.setPageNomber(pageNum); paginal.setPageSize(pageSize); // check result list if(null == resultList || 0==resultList.size()){ paginal.setResultList(new ArrayList<Map<String,String>>()); paginal.setTotalCount(0); paginal.setPageNum(0, 0); return paginal; } paginal.setTotalCount(resultList.size()); paginal.setPageNum(paginal.getTotalCount(), pageSize); int beginIndex = paginal.getBeginIndex(); int endIndex = paginal.getEndIndex(); resultList = resultList.subList(beginIndex, endIndex); paginal.setResultList(resultList); return paginal; } /** * 根据指定的条件获取搜索对象 * * @param bq BooleanQuery对象 * @param equalSearchkeyWordsMap 搜索key-values * @param keyWordsList 搜索关键字 * @param occur 多个条件之间关系，如AND 或者 OR * @return */ private BooleanQuery getBooleanQueryByConditionMap(BooleanQuery bq, Map<String, List<String>> equalSearchkeyWordsMap, List<String> keyWordsList, Occur occur) { if (null == bq) { bq = new BooleanQuery(); } // 默认的条件关系为 AND occur = null == occur ? BooleanClause.Occur.MUST : occur; // 遍历并组装条件 for (String searchkey : equalSearchkeyWordsMap.keySet()) { if (keyWordsList.contains(searchkey)) { BooleanQuery subbq = new BooleanQuery(); // 包含在列表中，建立搜索条件，多个值之间是OR的关系 List<String> values = equalSearchkeyWordsMap.get(searchkey); for (String value : values) { TermQuery tq = new TermQuery(new Term(searchkey, value)); subbq.add(tq, BooleanClause.Occur.SHOULD); } bq.add(subbq, occur); } } return bq; } /** * 根据区间搜索条件组装BooleanQuery * * @param bq * @param betweensearchkeywordsMap * @param keyWordsList * @param occur * @return */ private BooleanQuery getRangeQueryByConditionMap(BooleanQuery bq, Map<String, List<String>> betweensearchkeywordsMap, List<String> keyWordsList, Occur occur) { if (null == bq) { bq = new BooleanQuery(); } // 默认的条件关系为 AND occur = null == occur ? BooleanClause.Occur.MUST : occur; for (String betweenKey : betweensearchkeywordsMap.keySet()) { if (keyWordsList.contains(betweenKey)) { List<String> values = betweensearchkeywordsMap.get(betweenKey); // ~~~ check value if (null == values || 0 == values.size()) { continue; } // ~~~ 获取起始值，如果列表中的值为空串，那么取整数的最小值 String beginValue = StringUtils.isBlank(values.get(0)) ? "" + Integer.MIN_VALUE : values.get(0); Term beginterm = new Term(betweenKey, beginValue); // ~~~ 获取结束值，如果不存在第二个最大值，那么取整数的最大值 String endValue = values.size() >= 2 ? (StringUtils .isBlank(values.get(1)) ? "" + Integer.MAX_VALUE : values.get(1)) : "" + Integer.MAX_VALUE; Term endterm = new Term(betweenKey, endValue); // ~~~ 加入查询条件 RangeQuery rq = new RangeQuery(beginterm, endterm, true);// 临界条件也加入 bq.add(rq, occur);// 与其他条件应该是交集，要注意 } } return bq; } /** * 处理搜索结果，将Hits转换成map列表 * * @param keyWordsList * @param hits * @param result * @return * @throws CorruptIndexException * @throws IOException */ private List<Map<String, String>> getResultListFromHits( SearchConfigure searchConfigure, List<String> keyWordsList, Hits hits, List<Map<String, String>> result) throws CorruptIndexException, IOException, ClassNotFoundException { if(null == hits){ return result; } // 获取当前列表中id集合 Set<String> ids = getIdsFromListMap(searchConfigure,result); for (int i = 0; i < hits.length(); i++) { Document document = hits.doc(i); Map<String, String> resultMap = new HashMap<String, String>(); for (String field : keyWordsList) { if (StringUtils.isBlank(field)) { continue; } // 获取值 String value = document.get(field); // 检查是否是重复的 if(chechIsKey(searchConfigure,field) && StringUtils.isNotBlank(value)){ if(ids.contains(value.trim())){ break; }else { ids.add(value.trim()); } } resultMap.put(field, value); } if(0 == resultMap.size()){ continue; } result.add(resultMap); } return result; } /** * 获取结果列表中的id集合，用于保证结果的唯一性 * @param result * @return * @throws ClassNotFoundException */ private Set<String> getIdsFromListMap(SearchConfigure searchConfigure,List<Map<String, String>> result) throws ClassNotFoundException{ Set<String> idset = new HashSet<String>(); if(null == result || 0 == result.size()){ return idset; } String key = getKeyName(searchConfigure); Iterator<Map<String,String>> index = result.iterator(); while(index.hasNext()){ Map<String,String> map = index.next(); String value = map.get(key); if(StringUtils.isBlank(value)){ continue; } idset.add(value.trim()); } return idset; } /** * 从数据库中取出数据，建立索引用于全文检索 * <P> * 适用于系统首次启动的索引建立场景 * </P> * * @param fieldList * 建立索引的字段列表 * @param indexWriter * @throws RuntimeException */ @SuppressWarnings("unchecked") private void buildIndex(SearchConfigure searchConfigure, IndexWriter indexWriter) throws RuntimeException { if (!useSearchEngin) { logger.info("can not use lucene search because it has been closed."); return; } try { // 获取需要建立索引的域 List<String> fieldList = getKeyWordsList(searchConfigure); String className = searchConfigure.getClassName(); // 获取类型 Class<? extends Object> objectClass = Class.forName(className); // 获取记录总数 int totalCount = abstractBaseDAO.queryCount(null, objectClass); // 修正分页总数，如果搜索结果总数超过最大值，则使用最大值 totalCount = totalCount > DEFAULT_MAX_INDEX_NUMS ? DEFAULT_MAX_INDEX_NUMS : totalCount; @SuppressWarnings("rawtypes") Paginal pagePaginal = new Paginal(); // 通过设置自动计算 pagePaginal.setPageNum(totalCount, 1000);// 每次1000条记录获取 // 需要分页的数目 int pageNum = pagePaginal.getPageNum(); // 循环从数据库分页读取数据 for (int i = 1; i <= pageNum; i++) { // 分页查询 Paginal<? extends Object> paginal = abstractBaseDAO.queryFieldsListForPaging(objectClass, null, fieldList, i, 1000); // 查询结果列表 List<? extends Object> resultList = paginal.getResultList(); Iterator<? extends Object> resultIndex = resultList.iterator(); while (resultIndex.hasNext()) { // 每一个新建document，防止field重名覆盖 Document document = new Document(); Object object = resultIndex.next(); Iterator<String> fieldIndex = fieldList.iterator(); while (fieldIndex.hasNext()) { // 获取需要分页的域 String field = fieldIndex.next(); // 过滤空白 if (StringUtils.isBlank(field)) { continue; } // 获取值 Object value = ((Map<String, Object>) object) .get(field); // 写入doc document.add(new Field(field, value.toString(), Field.Store.YES, Field.Index.TOKENIZED)); } // 写入索引文件 indexWriter.addDocument(document); }// while }// for } catch (CorruptIndexException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (LockObtainFailedException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (IOException e) { logger.error("create index failed!check the authentation!", e); throw new RuntimeException("create index failed!", e); } catch (ClassNotFoundException e) { logger.error("class not found!", e); throw new RuntimeException("create index failed!", e); } } /** * 根据配置刷新一个索引 * @param searchConfigure */ private void refreshOneIndex(SearchConfigure searchConfigure){ try { String key = searchConfigure.getKey(); String className = searchConfigure.getClassName(); List<String> keys = getKeyWordsList(searchConfigure); String floder = getFloder(searchConfigure); // 获取待更新列表 Set<Long> ids = needsUpdateIdList.get(key); if (null == ids || 0 == ids.size()) { return; } // 用来保存待更新列表拷贝 Set<Long> idscopy = new HashSet<Long>(); // 控制线程同步的目的是为了防止多线程下索引的重复更新问题 synchronized (ids) { // 拷贝一份出来执行 idscopy.addAll(ids); ids.clear(); // 从安全角度讲，重新设置一个进去 needsUpdateIdList.put(key, idscopy); } // 读取索引 IndexReader indexReader = IndexReader.open(floder); // 获取需要建立索引的主键ID String keyName = getKeyName(searchConfigure); // 获取所有的索引名称集合 @SuppressWarnings("unchecked") Collection<String> indexs = indexReader .getFieldNames(FieldOption.INDEXED); indexReader.flush(); indexReader.close(); // 判断索引中是否包含这个字段 if (!indexs.contains(keyName)) { return; } // 获取类型 Class<? extends Object> objectClass = Class.forName(className); // 迭代器 Iterator<Long> idIndex = idscopy.iterator(); // 用于保存每次分页的id List<Long> idspagin = new ArrayList<Long>(); while (idIndex.hasNext()) { Long id = idIndex.next(); idspagin.add(id); // 从待更新列表中删除出去 idIndex.remove(); // 200个一次获取，或者最后部分不足200个，直接获取 if (200 == idspagin.size() || !idIndex.hasNext()) { // 将这一批次更新 rebuildIndexByList(searchConfigure,keys,idspagin, objectClass); // 清空列表 idspagin.clear(); } } } catch (CorruptIndexException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (LockObtainFailedException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (IOException e) { logger.error("create index failed!check the authentation!", e); throw new RuntimeException("create index failed!", e); } catch (ClassNotFoundException e) { logger.error("class not found!", e); throw new RuntimeException("create index failed!", e); } } /** * 删除某个配置所有的索引 * @param searchConfigure * @throws RuntimeException */ @SuppressWarnings("unchecked") private void removeAllIndex(SearchConfigure searchConfigure) throws RuntimeException { if (!useSearchEngin) { logger.info("can not use lucene search because it has been closed."); return; } try { // 获取索引的位置 String floder = getFloder(searchConfigure); // reader IndexReader indexReader = IndexReader.open(floder); Analyzer analyzer = new StandardAnalyzer(); IndexWriter indexWriter = new IndexWriter(floder, analyzer); // 获取所有的索引名称集合 Collection<String> indexs = indexReader .getFieldNames(FieldOption.INDEXED); // 检查是否包含主键 String keyName = getKeyName(searchConfigure); if (!indexs.contains(keyName)) { indexWriter.close(); indexReader.close(); return; } // 遍历并删除 int maxDocNum = indexReader.maxDoc(); for (int k = 0; k < maxDocNum; k++) { Document document = indexReader.document(k); String value = document.get(keyName); Term term = new Term(keyName, value); indexWriter.deleteDocuments(term); if (logger.isDebugEnabled()) { logger.debug("delete the index of [" + keyName + "," + value + "]"); } logger.error("delete the index of [" + keyName + "," + value + "]"); } indexWriter.optimize(); indexWriter.close(); indexReader.flush(); indexReader.close(); } catch (CorruptIndexException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (LockObtainFailedException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (IOException e) { logger.error("create index failed!check the authentation!", e); throw new RuntimeException("create index failed!", e); } catch (ClassNotFoundException e) { logger.error("class not found!", e); throw new RuntimeException("create index failed!", e); } } /** * 根据结果列表更新索引 * <p> * 适用于系统已经启动的索引更新场景 * 索引更新可以分为3种：值修改、新增、删除。这里对于索引的更新采用的操作时先删除后新建的方式，用于将那些需要删除的索引删除。 * </p> * * @param resultList 结果列表 */ private void rebuildIndexByList(SearchConfigure searchConfigure,List<String> keys,List<Long> idspagin, Class<? extends Object> objectClass) { if (null == idspagin || 0 == idspagin.size()) { return; } String floder = getFloder(searchConfigure); try { Analyzer analyzer = new StandardAnalyzer(); IndexWriter indexWriter = new IndexWriter(floder, analyzer); String keyName = getKeyName(searchConfigure); String sqlIds = ""; for (Long id : idspagin) { Term term = new Term(keyName, id + ""); // 删除旧索引 indexWriter.deleteDocuments(term); // 组装sql sqlIds += id; sqlIds += ","; } sqlIds = sqlIds.substring(0, sqlIds.length() - 1); String sql = buildIdsQuerySql(searchConfigure,objectClass, sqlIds); // 重新获取数据 List<Map<String, Object>> resultList = abstractBaseDAO .queryFieldsListBySql(sql, null, objectClass); // 重新建立索引 for (Map<String, Object> map : resultList) { Document document = new Document(); for (String key : keys) { Object value = map.get(key); if (null == value) { continue; } // 建立字段 document.add(new Field(key, value + "", Field.Store.YES, Field.Index.TOKENIZED)); } // 写入索引 indexWriter.addDocument(document); } indexWriter.optimize(); // 关闭写入流 indexWriter.close(); } catch (CorruptIndexException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (LockObtainFailedException e) { logger.error("create index failed!", e); throw new RuntimeException("create index failed!", e); } catch (IOException e) { logger.error("create index failed!check the authentation!", e); throw new RuntimeException("create index failed!", e); } catch (ClassNotFoundException e) { logger.error("class not found!", e); throw new RuntimeException("create index failed!", e); } } /** * 获取配置的主键名称 */ @SuppressWarnings({ "rawtypes", "unchecked" }) private String getKeyName(SearchConfigure searchConfigure) throws ClassNotFoundException { String className = searchConfigure.getClassName(); Class objectClass = Class.forName(className); Table table = (Table) objectClass.getAnnotation(Table.class); String keyName = table.keyField(); return StringUtils.isBlank(keyName) ? DEFAULT_ID : keyName .toLowerCase(); } /** * 检查是否在缓存页数范围内 * @param pageNum * @return */ private boolean isNeedCache(int pageNum){ return pageNum <= NEED_CACHE_PAGE_NUM; } /** * 判断字段是否是主键 - 不区分大小写 * @param cloumn 待判断列名称 * @return * @throws ClassNotFoundException */ private boolean chechIsKey(SearchConfigure searchConfigure,String cloumn) throws ClassNotFoundException{ String key = getKeyName(searchConfigure).trim(); if(StringUtils.equalsIgnoreCase(key, cloumn)){ return true; } return false; } /** * 建立根据ID列表查询fields的sql语句 * * @param objectClass * @param sqlIds * @return */ private String buildIdsQuerySql(SearchConfigure searchConfigure, @SuppressWarnings("rawtypes") Class objectClass, String sqlIds) { @SuppressWarnings("unchecked") Table table = (Table) objectClass.getAnnotation(Table.class); String tableName = table.tableName(); String sql = "select " + (StringUtils.isBlank(searchConfigure.getFields())? "*":searchConfigure.getFields().toLowerCase()) + " from " + tableName + " where " + abstractBaseDAO.DEFAULT_ID_NAME + " in (" + sqlIds + ")"; return sql; } /** * 根据配置的关键字串获取关键字列表，自动补全主键 */ private List<String> getKeyWordsList(SearchConfigure searchConfigure) throws ClassNotFoundException { // 获取需要建立索引的域 String[] fields = StringUtils.split(searchConfigure.getFields().toLowerCase(), DEFAULT_KEY_FIELD_SPLIT); // 转换成列表形式 List<String> fieldList = Arrays.asList(fields); // 上述的固定长度列表需转成可变长度的 List<String> dynamiticfieldList = new ArrayList<String>(); dynamiticfieldList.addAll(fieldList); // 如果配置的索引字段串不包含主键，则手动添加主键，也就是主键必须创建索引用于标示doc String keyName = getKeyName(searchConfigure); if (!dynamiticfieldList.contains(keyName)) { dynamiticfieldList.add(keyName); } return dynamiticfieldList; } /** * 根据名称获取配置 * @param name * @return */ private SearchConfigure getSearchConfigureByName(String name){ Iterator<SearchConfigure> index = indexList.iterator(); while(index.hasNext()){ SearchConfigure s = index.next(); if(StringUtils.equalsIgnoreCase(s.getKey(), name)){ return s; } } return null; } /** * 获取索引文件夹，如果不存在，使用默认配置 * @param searchConfigure * @return */ private String getFloder(SearchConfigure searchConfigure){ String floder = StringUtils.isEmpty(searchConfigure.getIndexDir())? defaultIndexDir:searchConfigure.getIndexDir(); return floder; } /** * 检查map是否为空 * @param map * @return */ private boolean chechMapEmpty(@SuppressWarnings("rawtypes") Map map){ return null==map? true:(0 == map.size() ? true:false); } // ~~~~~~~~~~~~~~~~~~~~~getter && setter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~// public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; } public void setDefaultIndexDir(String defaultIndexDir) { this.defaultIndexDir = defaultIndexDir; } public static Map<String, Set<Long>> getNeedsUpdateIdList() { return needsUpdateIdList; } public static void setNeedsUpdateIdList( Map<String, Set<Long>> needsUpdateIdList) { LuceneMultiSearcher.needsUpdateIdList = needsUpdateIdList; } public void setUseSearchEngin(boolean useSearchEngin) { this.useSearchEngin = useSearchEngin; } public void setLocalCacheService(LocalCacheService localCacheService) { this.localCacheService = localCacheService; } public void setConfigureFilePath(String configureFilePath) { this.configureFilePath = configureFilePath; } }

 

part4、其他
这个搜索引擎模型，我们使用到了如下的几个核心类：

AbstractBaseDAO：针对于spring的jdbcTemplate封装的API，提供了30多个日常数据库操作常用的API，用于提高开发效率，降低业务代码的耦合性同时提高代码的通用性。前面已经有专门的章节讲述。

AbsBaseDAOMethIntercepDefine：定义了上述的AbstractBaseDAO需要被拦截的方法，被拦截的DAO的接口只要继承于当前的接口，就在DAO子类接口中增加上述AbstractBaseDAO需要拦截的方法声明，以便于拦截器针对于方法内部调用的二次拦截。

AbsBaseDAOMethIntercepted：抽象了通过判断上下文中是否存在代理以选择采用何种方式调用父类方法的接口，如果上下文线程中存在代理，则使用代理去执行，以触发拦截器的拦截，如果不含有，则使用普通的内部调用的方式，这个与直接调用效果相同。

LuceneMethodInterceptor：对AbstractBaseDAO中修改数据库记录的相关方法进行拦截的拦截器，拦截器拦截的是AbstractBaseDAO的子类，但是真正执行拦截过程的，是在子类通过代理去调用父类方法以再次触发的时候。

SearchConfigure：对应于搜索引擎索引xml配置文件的模型。用于保存解析后的结果。

LuceneSearcherService：搜索引擎对外服务接口。

LuceneMultiSearcher：搜索接口实现类，搜索引擎最重要的方法

LocalCacheService：本地缓存，用于缓存部分可延时的信息以减少数据库操作提升性能。比如拦截器拦截的方法执行结果，缓存5分钟以减少5分钟内的重复数据库操作。

RemoteCacheService：远程分布式缓存，memcache本地客户端

 

代码较多，单元测试昝略，请查看后续提交的工程。

---------------------华丽丽的分割

在这过程中，有很多问题是自己没有想到过的，比如如何去确定一个唯一性的key在缓存中，而且这个key还可以便于定位索引，最终确定方案为DO类的名称，但是如何去获取DO类型的名称就成为下一个难题，总之这个过程中，遇到的大部分问题都是自己在前期设计过程中没有想到的，包括后续采用xml配置方式去管理索引种类的问题，多种索引并存的问题，索引建立和搜索过程，都变得十分复杂，将单种类型的索引代码重构的过程中很折磨，这个过程对于我自己而言，是一个修炼的过程，写习惯了业务代码，这种稍微隔离具体业务较低层的代码，在方法签名设计等方面都是一个思维转换的过程，希望这个工作能够继续下去，不管是往下还是往上继续发展，收获，都是在路上……