码迷，mamicode.com
首页 > 其他好文 > 详细

solr5项目实战详解,分布式缓存,全文检索

时间：2016-05-19 21:27:56      阅读：396      评论：0      收藏：0      [点我收藏+]

标签：

说一下大体思路,电商类网站，由于老项目数据库设计很不合理，一些查询涉及的表过多，导致查询速度异常缓慢，在不修改架构设计和源码上，做了一下处理。

solr+eh ，使用eh缓存关联数据，再用solr查询速度，文章偏向小白文，大神见笑。很多设计不完善，实现功能为主。

一、配置缓存功能

结合我之前博文的eh文章配置，让项目启动后自动拉取数据存入缓存。

首先建立一个监听类，实现项目启动后调用。

StartupListener.java

public class StartupListener implements ApplicationListener<ContextRefreshedEvent> {
   
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
       //缓存数据
    }

公共容器xml配置添加

<bean id="startupListener" class="StartupListener类路径"></bean>

封装了EH工具类

EHUtil.java

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

public class EHUtil {
    
    private static final CacheManager manager = new CacheManager("src/main/resources/ehcache.xml");
    
    public static void setCache(String cacheName,String key,Object value){
        Cache cache = manager.getCache(cacheName);
        Element element = new Element(key,value); 
        cache.put(element);
    }
    
    public static Object getCache(String cacheName,String key){
        Cache cache = manager.getCache(cacheName);
        Element element = cache.get(key);
        if (element != null) {  
            return element.getValue();
        }
        return null;
    }
    
    public static boolean removeCache(String cacheName,String key){
        Cache cache = manager.getCache(cacheName);
        
        return cache.remove(key);
    }
    
    public static int getSize(String cacheName){
        Cache cache = manager.getCache(cacheName);
        
        return cache.getSize();
    }
    
    public static long getMemoryStoreSize(String cacheName){
        Cache cache = manager.getCache(cacheName);
        return cache.getMemoryStoreSize();
    }
}

 定义 getCache 返回类型为Object 如果需要返回javaBean，需要实现序列化

然后在项目Service内调用，保证操作dao层数据修改同步到EH缓存里，具体根据业务编写。

二、solr检索配置

创建solr工具类

 SolrUti.java

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

import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.impl.HttpSolrClient;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.client.solrj.response.UpdateResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.params.ModifiableSolrParams;

import com.penuel.mythopoetms.model.SolrCode;

public class SolrUtil {
    
    //填写你得solr服务器的core地址,例如: http://XXX/solr/db
    private static final String URL = Constants.get("SOLR_URL");
    
    private static HttpSolrClient server = null;
    
    static{
        server = new HttpSolrClient(URL);
    }
    
    public static void addDoc(SolrInputDocument doc){
        try {
            UpdateResponse response = server.add(doc);
            // 提交
            server.commit();
//            System.out.println("########## Query Time :" + response.getQTime());
//            System.out.println("########## Elapsed Time :" + response.getElapsedTime());
//            System.out.println("########## Status :" + response.getStatus());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void addDocs(Object key,List<Object> objs){
        List<SolrInputDocument> docs = new ArrayList<SolrInputDocument>();
        
        for(Object obj:objs ){
            SolrInputDocument doc = new SolrInputDocument();
            
            doc.addField(SolrCode.id.code, key);
            doc.addField(SolrCode.title.code, obj);
            
            docs.add(doc);
        }
        
        try {
            server.add(docs);
            // 提交
            server.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void byAddDocs(List<SolrInputDocument> docs){
        try {
            server.add(docs);
            // 提交
            server.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
        
    
    public static void removeDoc(String key){
        try {
            server.deleteById(key);
            server.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void removeQuery(String key){
        try {
            server.deleteByQuery(key);
            server.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static SolrDocumentList queryPage(ModifiableSolrParams params){
        
        try {
            QueryResponse response = server.query(params);
            SolrDocumentList list = response.getResults();
            
//            System.out.println("########### 总共 ： " + list.getNumFound() + "条记录");
//            System.out.println("########### 总共 ： " + response.getQTime()+ "毫秒");
//            
//            for (SolrDocument doc : list) {
//                System.out.println("######### id : " + doc.get("id") + "  title : " + doc.get("title"));
//            }
            
            return list;
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    public static SolrDocument queryById(ModifiableSolrParams params){
        
        try {
            QueryResponse response = server.query(params);
            SolrDocumentList list = response.getResults();
            if(list.size()>0){
                return list.get(0);
            }
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    public static String getIds(SolrDocumentList list){
        StringBuffer sb = new StringBuffer();
        for(SolrDocument doc:list){
            String sss = ((String) doc.get("id")).replaceAll("\\D+", "");
            if(sb.length()==0){
                sb.append(sss);
                continue;
            }
            sb.append(","+sss);
        }
        return sb.toString();
    }
}

---------------------------------------------------------------------------------------------------------------------------------------------------------------------

配置完成,现在理顺一下项目业务，

例：获取一个商品列表，商品名和设计师名，两个字段需要检索，然后提供根据更新时间排序，并实现分页。

分析：前面说了，数据库设计结构为 （A表 B表 AB表）一但这种表多起来， 查询会很慢。

数据库设计解决：A： 商品表，B：设计师表，C:分类，D:品牌。 可见设计库设计的不合理，在不修改原架构上进行处理。

1.建立缓存。把 AB,AC,AD,B,C,D 等表 建立缓存。

配置统一标准规则key来主键查询缓存，如（XXX+A表的id）这样就可以根据A表id直接提取缓存数据。

创建枚举类

CacheCode.java

public enum CacheCode {
    Cache("myCache"),designer("designerKEY"),brand("brandKEY")
    ,designerI("designerIKEY"),brandI("brandIKEY")
    ,cate("cateKEY"),cateI("cateIKEY");
    
    public String code;  
    private CacheCode(String code){  
        this.code=code;  
    }  
}

创建好后按照规则 启动拉取数据存入缓存，修改之前的监听类

 StartupListener.java

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

import org.apache.solr.common.SolrInputDocument;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Service;

import com.penuel.mythopoetms.model.Brand;
import com.penuel.mythopoetms.model.CacheCode;
import com.penuel.mythopoetms.model.Category;
import com.penuel.mythopoetms.model.Designer;
import com.penuel.mythopoetms.model.Item;
import com.penuel.mythopoetms.model.ItemBrand;
import com.penuel.mythopoetms.model.ItemCate;
import com.penuel.mythopoetms.model.ItemDesigner;
import com.penuel.mythopoetms.model.ItemOther;
import com.penuel.mythopoetms.service.BrandService;
import com.penuel.mythopoetms.service.CategoryService;
import com.penuel.mythopoetms.service.DesignerService;
import com.penuel.mythopoetms.service.ItemBrandService;
import com.penuel.mythopoetms.service.ItemCateService;
import com.penuel.mythopoetms.service.ItemDesignerService;
import com.penuel.mythopoetms.service.ItemHelpService;
import com.penuel.mythopoetms.service.ItemOtherService;
import com.penuel.mythopoetms.service.ItemService;

@Service
public class StartupListener implements ApplicationListener<ContextRefreshedEvent> {
    
    @Autowired
    private DesignerService designerService;
    @Autowired
    private BrandService brandService;
    @Autowired
    private ItemDesignerService itemDesignerService;
    @Autowired
    private ItemBrandService itemBrandService;
    @Autowired
    private CategoryService categoryService;
    @Autowired
    private ItemCateService itemCateService;
    @Autowired
    private ItemService itemService;
    
    
    
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        try {
            //设计师关联表
            List<ItemDesigner> idList = itemDesignerService.list();
            if(idList!=null&&idList.size()>0){
                for(ItemDesigner idr:idList){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.designerI.code+idr.getItemId(), idr.getDesignerId());
                }
            }
            
            //设计师
            List<Designer> dlist = designerService.listDesigners();
            if(dlist!=null&&dlist.size()>0){
                for(Designer designer:dlist){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.designer.code+designer.getId(), designer);
                }
            }
            
            //品牌关联表
            List<ItemBrand> ibList = itemBrandService.list();
            if(ibList!=null&&ibList.size()>0){
                for(ItemBrand ib:ibList){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.brandI.code+ib.getItemId(), ib.getBrandId());
                }
            }
            
            //品牌
            List<Brand> blist = brandService.listBrands();
            if(blist!=null&&blist.size()>0){
                for(Brand brand:blist){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.brand.code+brand.getId(), brand);
                }
            }
            
            //标签关联
            List<ItemCate> icList = itemCateService.list();
            if(icList!=null&&icList.size()>0){
                for(ItemCate ic:icList){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.cateI.code+ic.getItemId(), ic.getCateId());
                }
            }
            
            //标签
            List<Category> cList = categoryService.listCategories();
            if(cList!=null&&cList.size()>0){
                for(Category category:cList){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.cate.code+category.getId(), category);
                }
            }    
    }
}

 

Service自行添加编写，不做描述。

下面开始solr相关配置

2.编写业务工具类，用于增删改查 solr 索引，

首先，设计好solr索引库要存的字段。前面讲过：获取一个商品列表，商品名和设计师名，两个字段需要检索，然后提供根据更新时间排序，并实现分页

所以solr存储数据的格式应该是这样的

[‘ltime:‘更新时间‘,id:‘itemId+商品ID‘,‘title:‘商品名称‘,‘name‘:‘设计师名字‘]

其中id为 唯一，相同id会覆盖操作，这里不懂solr配置的可看我前面的文章配置，包括中文分词。

先从建立索引开始入手。同样建立solr的枚举类统一key规则

SolrCode.java

public enum SolrCode {
    id("id"),title("title"),ltime("last_modified"),name("name");
    
    
    public String code;  
    private SolrCode(String code){  
        this.code=code;  
    }  
}

 编写业务类建立索引

ItemHelpService.java

import java.io.IOException;
import java.io.StringReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.params.ModifiableSolrParams;
import org.wltea.analyzer.core.IKSegmenter;
import org.wltea.analyzer.core.Lexeme;

import com.penuel.mythopoetms.model.CacheCode;
import com.penuel.mythopoetms.model.Designer;
import com.penuel.mythopoetms.model.Item;
import com.penuel.mythopoetms.model.SolrCode;
import com.penuel.mythopoetms.utils.EHUtil;
import com.penuel.mythopoetms.utils.SolrUtil;

public class ItemHelpService {
    
    
    /**
     * @param date 时间
     * @param strs 多个参数
     * @return
     * @throws ParseException
     */
    public static SolrInputDocument addDocsHelp(Date date,String ...strs) throws ParseException{
        SimpleDateFormat format =  new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); 
        
        SolrInputDocument doc = new SolrInputDocument();
        
        doc.addField(SolrCode.ltime.code,date);
        doc.addField(SolrCode.id.code, strs[0]);
        doc.addField(SolrCode.title.code, strs[1]);
        doc.addField(SolrCode.name.code, strs[2]);
        
        return doc;
    }
    
}

编写完成后 修改 StartupListener 启动项目并建立索引

StartupListener.java

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

import org.apache.solr.common.SolrInputDocument;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Service;

import com.penuel.mythopoetms.model.Brand;
import com.penuel.mythopoetms.model.CacheCode;
import com.penuel.mythopoetms.model.Category;
import com.penuel.mythopoetms.model.Designer;
import com.penuel.mythopoetms.model.Item;
import com.penuel.mythopoetms.model.ItemBrand;
import com.penuel.mythopoetms.model.ItemCate;
import com.penuel.mythopoetms.model.ItemDesigner;
import com.penuel.mythopoetms.model.ItemOther;
import com.penuel.mythopoetms.service.BrandService;
import com.penuel.mythopoetms.service.CategoryService;
import com.penuel.mythopoetms.service.DesignerService;
import com.penuel.mythopoetms.service.ItemBrandService;
import com.penuel.mythopoetms.service.ItemCateService;
import com.penuel.mythopoetms.service.ItemDesignerService;
import com.penuel.mythopoetms.service.ItemHelpService;
import com.penuel.mythopoetms.service.ItemOtherService;
import com.penuel.mythopoetms.service.ItemService;

@Service
public class StartupListener implements ApplicationListener<ContextRefreshedEvent> {
    
    @Autowired
    private DesignerService designerService;
    @Autowired
    private BrandService brandService;
    @Autowired
    private ItemDesignerService itemDesignerService;
    @Autowired
    private ItemBrandService itemBrandService;
    @Autowired
    private CategoryService categoryService;
    @Autowired
    private ItemCateService itemCateService;
    @Autowired
    private ItemOtherService itemOtherService;
    @Autowired
    private ItemService itemService;
    
    
    
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        try {
            //设计师关联表
            List<ItemDesigner> idList = itemDesignerService.list();
            if(idList!=null&&idList.size()>0){
                for(ItemDesigner idr:idList){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.designerI.code+idr.getItemId(), idr.getDesignerId());
                }
            }
            
            //设计师
            List<Designer> dlist = designerService.listDesigners();
            if(dlist!=null&&dlist.size()>0){
                for(Designer designer:dlist){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.designer.code+designer.getId(), designer);
                }
            }
            
            //品牌关联表
            List<ItemBrand> ibList = itemBrandService.list();
            if(ibList!=null&&ibList.size()>0){
                for(ItemBrand ib:ibList){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.brandI.code+ib.getItemId(), ib.getBrandId());
                }
            }
            
            //品牌
            List<Brand> blist = brandService.listBrands();
            if(blist!=null&&blist.size()>0){
                for(Brand brand:blist){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.brand.code+brand.getId(), brand);
                }
            }
            
            //标签关联
            List<ItemCate> icList = itemCateService.list();
            if(icList!=null&&icList.size()>0){
                for(ItemCate ic:icList){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.cateI.code+ic.getItemId(), ic.getCateId());
                }
            }
            
            //标签
            List<Category> cList = categoryService.listCategories();
            if(cList!=null&&cList.size()>0){
                for(Category category:cList){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.cate.code+category.getId(), category);
                }
            }
            //商品url
            List<ItemOther> ioList = itemOtherService.list();
            if(ioList!=null&&ioList.size()>0){
                for(ItemOther io:ioList){
                    EHUtil.setCache(CacheCode.Cache.code, CacheCode.otherI.code+io.getItemId(), io.getUrlDetail());
                }
            }
            
            //商品or设计师索引
            //[‘ltime:‘更新时间‘,id:‘itemId+商品ID‘,‘title:‘商品名称‘,‘name‘:‘设计师名字‘]
            List<SolrInputDocument> docs = new ArrayList<SolrInputDocument>();
            List<Item> iList = itemService.listItems();
            for(Item item:iList){
                Designer dir =(Designer)EHUtil.getCache(CacheCode.Cache.code,CacheCode.designer.code+ 
                        EHUtil.getCache(CacheCode.Cache.code, CacheCode.designerI.code+item.getId()));
                if(dir==null)
                    continue;
                docs.add(ItemHelpService.addDocsHelp(item.getUtime(),"itemId"+item.getId(),item.getName(),
                        dir.getName()));
            }
            SolrUtil.byAddDocs(docs);
        
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Service 主要为数据拉取，可自行编写。

现在索引建立完成，可以开始进行搜索了。

这里需要中文分词器，配合solr的查询功能。方法如下。

ItemHelpService.java

import java.io.IOException;
import java.io.StringReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.params.ModifiableSolrParams;
import org.wltea.analyzer.core.IKSegmenter;
import org.wltea.analyzer.core.Lexeme;

import com.penuel.mythopoetms.model.CacheCode;
import com.penuel.mythopoetms.model.Designer;
import com.penuel.mythopoetms.model.Item;
import com.penuel.mythopoetms.model.SolrCode;
import com.penuel.mythopoetms.utils.EHUtil;
import com.penuel.mythopoetms.utils.SolrUtil;

public class ItemHelpService {
    
    /**
     * @param date 时间
     * @param strs 多个参数
     * @return
     * @throws ParseException
     */
    public static SolrInputDocument addDocsHelp(Date date,String ...strs) throws ParseException{
        SimpleDateFormat format =  new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); 
        
        SolrInputDocument doc = new SolrInputDocument();
        
        doc.addField(SolrCode.ltime.code,date);
        doc.addField(SolrCode.id.code, strs[0]);
        doc.addField(SolrCode.title.code, strs[1]);
        doc.addField(SolrCode.name.code, strs[2]);
        
        return doc;
    }
    
    /**
     * @param key  商品名
     * @param key2  设计师
     * @param sort 排序
     * @param start 起始位
     * @param rows 显示页数
     * @return
     */
    public static String[] queryCount(String key,String key2,String sort,int start,int rows){
        ModifiableSolrParams params = new ModifiableSolrParams();
        
        if(key.equals("*")){
            if(key2.equals(""))
                params.set("q", "*:*");
            else
                params.set("q", "name:"+key2+"*");
        }else{
            if(key.length()<2)
                params.set("q", "title:"+key+"*");
            else
                params.set("q", "title:"+key);
            
            params.set("fq", toDismantle(key,key2));
        }
        
        params.set("sort", sort);
        params.set("start", start);
        params.set("rows", rows);
        
        String [] str = new String[2];
        SolrDocumentList list = SolrUtil.queryPage(params);
        
        str[0]=SolrUtil.getIds(list);
        str[1]=Long.toString(list.getNumFound());
        
        return str;
    }
    
    /**
     * @param text 商品名
     * @param text2 设计师名
     * @return
     */
    public static String[] toDismantle(String text,String text2){
        List<String> list = new ArrayList<String>();
        if(text.length()<2){
            list.add("title:"+text+"*");
        }else{
            StringReader sr=new StringReader(text);  
            IKSegmenter ik=new IKSegmenter(sr, true);  
            Lexeme lex=null;  
            ModifiableSolrParams params = new ModifiableSolrParams();
            params.set("q", "title:"+text);
            try {
                while((lex=ik.next())!=null){  
                    list.add("title:"+lex.getLexemeText()+"*");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }  
        }
        if(StringUtils.isNotBlank(text2)){
            list.add("name:"+text2+"*");
        }
        String[] arr = (String[])list.toArray(new String[list.size()]);
        return arr;
    }
}

这里可能看不太懂，

现讲一下 queryCount方法

key=商品名称，key2=设计师名称，sort=指定字段排序，start=起始位，rows=搜索数量

key默认值为 "*", key2 默认值为 空串即 ""

toDismantle方法 

主要针对 key 值 做中文分词（IK2012版本），设计师不需要分词，因为设计师需要单字匹配，但是商品不可以，举一个例子 就会明白

例如，

查询: （"q","title:男士灰色"）

不做分词处理的话，数据就会是这样的

输出 "男士灰色XXXX","女士灰色XXXX"

因为 不做分词处理。灰色为同性词，很多不相关的数据会掺杂进来。

做分词处理的效果：

查询: （"q","title:男士灰色"）

分词处理并添加条件 （"fq",["title:男士*",title:灰色*]）

数据就会过滤掉 不相关的词，比如"女士"等，

还有一处为查询字段长度判断，

if(key.length()<2)
      params.set("q", "title:"+key+"*");

如果用户搜索单个词。

例如

查询（"q","title:男"）

solr的分词器 会自动匹配 "男" 的索引 而不是模糊查询 所以要在后边加上* 来匹配模糊查询。

sort值为排序用，书写规则为 "字段 desc" 或者 "字段 asc"

start,rows。 最常见的分页功能，

start 值为：(当前页- 1) * 显示数量

rows 值为：显示数量

 

queryCount方法，是一个数组，

[0] 储存的是 查询出来的所有商品ID

[1]储存的是 商品条数

得到这些数据  

，使用 sql select *  from A表 where id in (数组[0])  来获取商品列表数据。

然后遍历商品列表，根据其ID值 自动匹配 缓存里存储的 B表 C表 D表 等等数据。

 

最终效率从最开始的 3秒 到 现在的首次查询仅0.3秒左右,之后，平均查询占0.02秒。

 

讲到这里基本上是结束了，集体索引的更新操作和缓存操作基本一样，保持缓存 索引和 数据库同步即可。

配置方面可查询之前文章

EH集群：http://www.cnblogs.com/mangyang/p/5481713.html

solr配置：http://www.cnblogs.com/mangyang/p/5500852.html

solr5中文分词：http://www.cnblogs.com/mangyang/p/5502773.html

solr5项目实战详解,分布式缓存,全文检索

标签：

原文地址：http://www.cnblogs.com/mangyang/p/5509646.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！