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(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

时间： 2024-07-29 10:03:05

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

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

Cocos2d-x手机游戏开发与项目实践详解_随书代码

机器学习Spark Mllib算法源码及实战详解进阶与提高视频教程

《iOS 7 应用开发实战详解》

Scala 深入浅出实战经典第78讲：Type与Class实战详解

Scala 深入浅出实战经典第53讲：Scala中结构类型实战详解

开源项目MultiChoiceAdapter详解（五）——可扩展的MultiChoiceBaseAdapter

开源项目MultiChoiceAdapter详解（六）——GridView和MultiChoiceBaseAdapter配合使用

Dream------scala--类的属性和对象私有字段实战详解

第131讲：Hadoop集群管理工具均衡器Balancer 实战详解学习笔记