[lucene第三季]Lucene那点事儿-总结篇_this.luceneservice.delete undefined-优快云博客

本文介绍了一个基于Lucene的小型搜索引擎的实现，支持多种条件组合搜索和分页功能，并详细解释了如何通过缓存提高首页加载速度及如何进行精确索引更新。

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

前面两篇文章，简单尝试了lucene的一些应用，还是再回头想想我们的需求吧，我们希望能够开发一个淘宝一样的针对商品的搜索服务，提供多种条件的组合搜索，并且对于性能提出了一定的要求。同时我们希望这个小型的搜索引擎具有一定的通用性，也就是在可以预见的将来，我们可能用它进行店铺等信息的搜索，所以在我们的搜索代码中，不能织入特定的业务逻辑代码，而应该进行一定的抽象，抽离出一个通用的模型。

我们的需求很简单：

1、单值搜索

2、单值分页搜索

3、组合条件搜索

4、组合条件分页搜索

5、系统对于性能有一定要求，诸如首页的信息不能有太久的加载时间

6、搜索引擎索引的更新需要有一定的精确性，由于数据量的问题不能通过删除全部再新建的方式来完成

7、自动定时刷新功能

索引的精确刷新和自动刷新在之前的文章中已经讲解，这里不再赘述，可以直接看最下面的代码。

关于首页等这些页面渲染加载便进行搜索的情况，我们采用缓存来缓和一下搜索频率，我们在缓存中缓存3页单值搜索，比如首页加载的时候并未输入搜索条件，我们会默认的针对自己的营销数据分析来设置默认的搜索值，执行搜索。然后缓存3页有效期5分钟。对于组合查询，由于组合条件千变万化，无法通过有效的缓存来减少搜索次数，而且搜索频率将远远低于默认的单值搜索，所以不再使用缓存。

首先说单值搜索和组合搜索的问题，单值搜索和组合条件搜索其实都可以通过BooleanQuery来满足，只是单值搜索的条件下只有一个BooleanQuery条件而已，但是这里我们更愿意使用QueryParse进行分词，然后自动去搜索每一个索引，最后组装结果，而不是在外部的调用代码中通过多次的set操作来手动的对应索引的名称组装查询Map。这种情况比较适用于类似于淘宝首页最大的那个搜索框的情况，输入一个字符串可以匹配多个字段是否符合，比如标题，摘要信息，品牌信息等。

/** * 单字符串搜索 - 使用默认的相似度分值排序 * @param keywords 搜索字符串 * @return 搜索结果 */ public List<Map<String, String>> search(String keywords);

/* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#search(java.lang.String) */ public List<Map<String, String>> search(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; } try { // 搜索执行器 IndexSearcher indexSearcher = new IndexSearcher(defaultIndexDir); // 分词器 Analyzer analyzer = new StandardAnalyzer(); // 关键字列表 List<String> keyWordsList = getKeyWordsList(); // 单次搜索重复结果过滤字段 DuplicateFilter duplicateFilter = getDuplicateFilter(); // 执行搜索 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(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; }

对于单值的分页查询，查询了官方的相关资料，发现没有一个类似于数据库limit操作的直接分页操作，而是需要手动进行分页，通过对查询结果的截取来获取需要的区间。我们使用之前开发的分页器来作为返回值：

/** * 分页单字符串搜索 - 使用默认的相似度分值排序 * @param keywords 搜索字符串 * @param pageNum 页号 * @param pageSize 分页大小 * @return 搜索结果 */ public Paginal<Map<String, String>> searchPaging(String keywords, int pageNum, int pageSize);

/* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#searchPaging(java.lang.String, int, int) */ @SuppressWarnings("unchecked") public Paginal<Map<String, String>> searchPaging(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(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; }

对于组合查询，我们采用BooleanQuery来组装查询query，这里要注意的问题是，对于组合查询查询条件可以分成两部分：

确定的查询条件和不确定的查询条件。

所谓的确定查询条件，即类似于页面查询表单中勾选的商品类型，商品品牌等信息，这类信息是与固定的字段进行匹配的，这类的查询条件与其他的条件之间是AND关系。

所谓的不确定查询条件与上述的单值搜索类似，即输入的字符串与多个字段进行匹配，多个字段之间是OR的关系。

为了满足这个需求，我们设计如下的方法，来使用不同的map保存不同关系的查询，有三种即 OR关系 AND关系 BETWEEN关系，具体的请看方法签名

/** * 根据组合条件执行搜索 - 使用默认的相似度分值排序，如果干扰排序，则需要谨慎考虑综合相似度分值和排序字段 * * ~~~~支持：多个字段的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，同时与其他条件为交集搜索 * * * @param equalOrSearchkeywordsMap 搜索条件OR关系集合 * @param equalAndSearchKeyWordsMap 搜索条件AND关系集合 * @param betweensearchkeywordsMap 搜索条件区间关系集合 List<String> 长度不限制，但是有效长度最大为2，超出2的数据将不被处理 * @return */ public List<Map<String, String>> searchWithCondition( Map<String, List<String>> equalOrSearchkeywordsMap, Map<String, List<String>> equalAndSearchKeyWordsMap, Map<String, List<String>> betweensearchkeywordsMap);

/* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#searchWithCondition(java.util.Map, java.util.Map, java.util.Map) */ public List<Map<String, String>> searchWithCondition( 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; } try { // 关键字列表 List<String> keyWordsList = getKeyWordsList(); // 搜索执行器 IndexSearcher indexSearcher = new IndexSearcher(defaultIndexDir); // 组合查询 BooleanQuery bq = new BooleanQuery(); // 单次搜索重复结果过滤字段 DuplicateFilter duplicateFilter = getDuplicateFilter(); /********************************************************************************* * 组装条件模糊匹配条件 * * · 一个字段可以有多个模糊值，多个值之间是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(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; }

同样的，对于分页，我们采用相同的逻辑：

/** * 分页综合条件搜索 - 使用默认的相似度分值排序 * @see com.normandy.position.common.LuceneSearcherService#searchWithCondition(java.util.Map, java.util.Map, java.util.Map) * @return */ public Paginal<Map<String, String>> searchWithConditionPaging( Map<String, List<String>> equalOrSearchkeywordsMap, Map<String, List<String>> equalAndSearchKeyWordsMap, Map<String, List<String>> betweensearchkeywordsMap,int pageNum,int pageSize);

/* * (non-Javadoc) * @see com.normandy.position.common.LuceneSearcherService#searchWithConditionPaging(java.util.Map, java.util.Map, java.util.Map, int, int) */ public Paginal<Map<String, String>> searchWithConditionPaging( 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(equalOrSearchkeywordsMap,equalAndSearchKeyWordsMap,betweensearchkeywordsMap); /**************************************************** * 处理分页 ***************************************************/ Paginal<Map<String, String>> paginal = getPaginalFromResultList(resultList,pageNum,pageSize); return paginal; }

再贴一遍分页器的代码：

package com.normandy.position.common; import java.io.Serializable; import java.util.List; /** * 分页器 * * mysql的分页机制：limit offset,pagesize [] 从0开始计数偏移offset位的pagesize条数据 * 比如： * pagesize = 10; * ------------------------------------------------- * | 页号 | 起始地址 | 结束地址 | 包含记录ID |offset| * ------------------------------------------------- * | 1 | 0 | 9 |0,1,2...9 | 0 | * | 2 | 10 | 19 |10,11,12...19 | 10 | * | 3 | 20 | 29 |20,22,23...29 | 20 | * -------------------------------------------------- * * 用法示例： * limit getOffset(),pagesize; * * @author quzishen * @param <T> 查询结果的具体类型 */ public class Paginal<T extends Object> implements Serializable{ private static final long serialVersionUID = -5159256681785242925L; // 分页大小 private int pageSize; // 页号，从1开始 private int pageNomber; // 总记录数 private int totalCount; // 总页数 private int pageNum; // 查询对象列表 private List<T> resultList; /** * 获取当前页的起始地址 * @return 起始地址 */ protected int getBeginIndex(){ return (pageNomber - 1)*pageSize; } /** * 获取当前页的结束地址 - 通常提供给列表的sublist方法使用 * @return 结束地址 */ protected int getEndIndex(){ return (pageNomber*pageSize) > totalCount ? (totalCount):(pageNomber*pageSize); } /** * 获取当前页的偏移量 * @return 偏移量 */ protected int getOffset(){ if(pageNomber == 1){ return 0; } else { return (pageNomber-1)*pageSize; } } /** * 根据总记录数和分页大小设置总页数 * @param totalCount 总记录数 * @param pagesize 分页大小 */ public void setPageNum(int totalCount,int pagesize){ int num = totalCount / pagesize; if(0 != totalCount % pagesize){ num += 1; } pageNum = num; } public int getPageSize() { return pageSize; } public void setPageSize(int pageSize) { this.pageSize = pageSize; } public int getPageNomber() { return pageNomber; } public void setPageNomber(int pageNomber) { this.pageNomber = pageNomber; } public int getTotalCount() { return totalCount; } public void setTotalCount(int totalCount) { this.totalCount = totalCount; } public int getPageNum() { return pageNum; } public void setPageNum(int pageNum) { this.pageNum = pageNum; } public List<T> getResultList() { return resultList; } public void setResultList(List<T> resultList) { this.resultList = resultList; } }

在前面的文章中，我们已经实现了一种精确刷新搜索引擎索引的方法，这里不再赘述，直接看代码：

package com.normandy.position.common; import java.lang.reflect.Method; 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的拦截器 * * 对于修改或者新增方法，将其ID加入到lucene的更新列表中，以便于lucene的精确更新 * 本拦截器拦截的是被拦截对象的方法，通常被拦截对象方法内部才会调用抽象父类的相关数据库修改更新等操作 * 所以常规的调用下，内部的调用将不会被拦截，所以在子类中调用抽象父类的方法必须要采用获取代理对象的方式 * 如： * if(null != AopContext.currentProxy()){ * ((NorQuickNewsDAO)AopContext.currentProxy()).method2(); * }else{ * method2(); * } * * 特别注意：本拦截器的实现将增加数据库操作压力 * * * @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 LuceneSearcher luceneSearcher; /** ~~~ 本地缓存服务 */ private LocalCacheService localCacheService; /** ~~~ 当前数据库的最后一条数据的ID，用于在进行完批量插入后的定时更新 */ private static String LAST_ID_NOW = "1"; /** ~~~ 使用搜索引擎提供的针对待更新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); } } /** * 执行拦截 * * 拦截器将执行：对特定方法所影响到的数据库的数据，获取其ID，并放入待更新列表中以提供给搜索引擎更新之用途 * 目前该拦截器与封装的AbstractBaseDAO紧耦合，我们采用AbstractBaseDAO作为统一的底层数据库操作模型 * */ 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(); // 添加IDS luceneSearcher.addOneIdToSet(DEFAULT_ID_LIST_KEY,returnValue.longValue()); // 更新lasted ID数值，需要线程同步 synchronized(LAST_ID_NOW){ LAST_ID_NOW = returnValue.intValue() > Integer.parseInt(LAST_ID_NOW) ? returnValue.intValue()+"":LAST_ID_NOW; } 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]; // 渲染sql @SuppressWarnings("static-access") String buildsql = abstractBaseDAO.getSqlFromPlaceHolder(sql, params); // 组装查询ID的语句 String queryIdSql = buildSlqByDelSql(buildsql); // 执行查询和保存 saveIdByWholeSQLwithoutObjectClass(queryIdSql); } else { // 参数个数异常 logger.error("deleteBySqlWithPlaceHolder method does not have two arguments! Interceptor execute failed!"); return; } } /** * 增加ID到搜索引擎中 -- 根据ID删除触发 * * 根据传入的参数获取其中的ID参数并保存 * * @param arguments 拦截方法参数 */ private void addIdByDelById(Object[] arguments){ // 判断参数 if(AbsDaoInterceptorMethodNameEnum.DELETE_BY_ID_METHOD.argumentsNum == arguments.length){ Long id = (Long) arguments[0]; luceneSearcher.addOneIdToSet(DEFAULT_ID_LIST_KEY, id); } else { // 参数个数异常 logger.error("deleteById method does not have two arguments! Interceptor execute failed!"); return; } } /** * 增加ID到搜索引擎中 -- 批量更新触发 * * 根据传入的批量列表遍历获取其中的ID参数并保存 * * @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)); } } // 增加到搜索引擎中 luceneSearcher.addSetsToSet(DEFAULT_ID_LIST_KEY, ids); } else { // 参数个数异常 logger.error("batchUpdate method does not have two arguments! Interceptor execute failed!"); return; } } /** * 增加ID到搜索引擎中--批量插入触发 * * 根据ID获取新增的所有的ID，set到搜索引擎中，插入方法不涉及重复性，不需要使用缓存 * * @param arguments 拦截方法的参数 */ private void addIdByBatchInsert(Object[] arguments){ // 判断参数 if(AbsDaoInterceptorMethodNameEnum.BATCH_INSERT_METHOD.argumentsNum == arguments.length){ @SuppressWarnings("rawtypes") Class objectClass = (Class) arguments[1]; // 组装查询sql String queryIdSql = buildSqlByBeginId(objectClass, LAST_ID_NOW); // 执行查询和保存 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(AbsDaoInterceptorMethodNameEnum.UPDATE_OBJECT_METHOD.keyValue,conditions); // 从缓存中取值 Set<Long> idset = getIdsFromCache(key); // 缓存中未取到 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(AbsDaoInterceptorMethodNameEnum.UPDATE_OBJECT_METHOD.keyValue,conditions); // 从缓存中取值 Set<Long> idset = getIdsFromCache(key); // 缓存中未取到 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 += ","; } // 增加到搜索引擎的待更新列表中 luceneSearcher.addSetsToSet(DEFAULT_ID_LIST_KEY, idset); returnValue = returnValue.substring(0, returnValue.length() - 1); return returnValue; } /** * 根据组装好的sql查询ID并且保存，直接使用sql查询，不需要使用对象类型封装结果 * @param queryIdSql 封装好的sql * @return */ @SuppressWarnings("unchecked") protected String saveIdByWholeSQLwithoutObjectClass(String queryIdSql){ 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); } luceneSearcher.addSetsToSet(DEFAULT_ID_LIST_KEY, 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_FROM + " "+ abstractBaseDAO.DEFAULT_ID_NAME + " "+ querySql; return querySql; } /** * 从缓存中获取id并放入搜索引擎中 * 公共方法 * @param key 缓存key * @return id集合 */ protected Set<Long> getIdsFromCache(String key){ //~~~ 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] + "")); } // 保存到搜索引擎 luceneSearcher.addSetsToSet(DEFAULT_ID_LIST_KEY, idset); } return idset; } /** * 获取方法在缓存中的key值 * 通用方法 * @param methodName 方法名称 * @param arguments 方法参数数组 * @return key值 */ protected String getMethodCacheKey(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 key+")"; } // ~~~~~~~~~~~ private setter && getter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ public static Set<String> getMethodNeedsIntercepted() { return methodNeedsIntercepted; } public static void setMethodNeedsIntercepted( Set<String> methodNeedsIntercepted) { LuceneMethodInterceptor.methodNeedsIntercepted = methodNeedsIntercepted; } public void setLuceneSearcher(LuceneSearcher luceneSearcher) { this.luceneSearcher = luceneSearcher; } 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",2); // ~~~ 方法名称 String keyValue; // ~~~ 参数个数 int argumentsNum; private AbsDaoInterceptorMethodNameEnum(String keyValue,int argumentsNum) { this.keyValue = keyValue; this.argumentsNum = argumentsNum; } }

缓存的代码

package com.normandy.position.common; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import org.apache.commons.lang.StringUtils; import org.apache.commons.lang.time.DateUtils; /** * 本地缓存服务 * * 提供内存的本地缓存，最大缓存数据5000条,默认的缓存时间为5分钟 * * @author quzishen */ public class LocalCacheService { /** ~~~ 缓存 */ protected Map<String, Object> cacheMap = new HashMap<String, Object>(); /** ~~~ 缓存时间戳 */ private Map<String, Long> cacheTimeMap = new HashMap<String, Long>(); /** ~~~ 默认的缓存大小 */ private static final long MAX_CACHE_SIZE = 20000; /** ~~~ 缓存的有效期 ,默认5分钟 */ private static final long MAX_LIFE_TIME_OF_CACHE = DateUtils.MILLIS_PER_MINUTE * 5; /** * 增加一个内容缓存 * * @param key * @param value */ public synchronized void addCache(String key, Object value) { if (cacheMap.size() > MAX_CACHE_SIZE) { clearExpiredCache(); } if(StringUtils.isBlank(key) || null == value){ return; } // 放入缓存 cacheMap.put(key, value); // 更新时间戳 cacheTimeMap.put(key, System.currentTimeMillis()); } /** * 清理过期的缓存内容 */ public synchronized void clearExpiredCache() { Iterator<String> index = cacheMap.keySet().iterator(); while (index.hasNext()) { String key = index.next(); if(cacheTimeMap.containsKey(key)){ // 计算过期时间，如果过期则删除 long existTime = System.currentTimeMillis() - cacheTimeMap.get(key).longValue(); if(existTime > MAX_LIFE_TIME_OF_CACHE){ cacheTimeMap.remove(key); cacheMap.remove(key); } } else { // 脏数据，不存在时间戳，为了安全删除 cacheMap.remove(key); } } } /** * 获取一个内容缓存 * * @param key * @return */ public Object getCache(String key) { if (cacheMap.containsKey(key)) { // 获取时间戳 long putTime = cacheTimeMap.get(key) == null ? 0 : cacheTimeMap.get(key).longValue(); // 判断是否过期并返回 return (System.currentTimeMillis() - putTime) > MAX_LIFE_TIME_OF_CACHE ? null : cacheMap.get(key); } else { return null; } } /** * 删除一个内容缓存 * * @param key */ public synchronized void removeCache(String key) { if (cacheMap.containsKey(key)) { cacheMap.remove(key); cacheTimeMap.remove(key); } } }

DAO相关的文件请参加前面的文章，或者联系邮箱发送，我们使用的是hi自己封装jdbcTemplate的DAO操作层，代码较多，这里不再贴出。