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

Posted 茫洋

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了solr5项目实战详解,分布式缓存,全文检索相关的知识,希望对你有一定的参考价值。

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

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(StringUtils.isBlank(key)){
            if(StringUtils.isBlank(key2))
                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项目实战详解,分布式缓存,全文检索的主要内容,如果未能解决你的问题,请参考以下文章

python3.4.4+solr5.5+hadoop2.6.3

mybatis二级缓存详解

Hibernate ehcache缓存配置详解+实战

亿级流量电商详情页系统实战-缓存架构+高可用服务架构+微服务架构第二版视频教程

Solr5.5.4+Zookeeper3.4.6+Tomcat8搭建SolrCloud集群

Solr简介和使用(二期)