基于solr实现商品信息的全文检索（windwons）

搭建环境

windows下tomcat+solr

相关软件准备

1.安装JDK

2.下载tomcat

3.下载solr-4.10.3.tgz.tgz

4.下载IK分词器(IKAnalyzer2012FF_hf1.rar)

安装步骤

1.解压solr-4.10.3.tgz.tgz

2.复制example\webapps下的solr.war到tomcat\webapp下

3.解压solr.war，然后删除solr.war（要在tomcat停止的情况下进行操作）

4.创建solr_home,修改solr\WEB-INF\web.xml,配置如下

   <env-entry>
       <env-entry-name>solr/home</env-entry-name>
       <env-entry-value>D:/qjw/apache-tomcat-7.0.91-windows-x64/solr_home</env-entry-value>
       <env-entry-type>java.lang.String</env-entry-type>
    </env-entry>

<env-entry-value>为sorl_home的路径

5.解压IKAnalyzer2012FF_hf1.rar

6.在solr\WEB-INF下创建classes

7.复制IKAnalyzer.cfg.xml，ext_stopword.dic，mydict.dic到classes文件中

8.启动tomcat，在浏览器中输入http://localhost:8080/solr进入solr的web界面,solr会对做solr_home初始化操作

使用solr（配置schema.xml）

1.进入solr_home\collection1\conf中

2.编辑schema.xml

在文件最后加入如下配置

<fieldType name="text_ik" class="solr.TextField">
    <analyzer class="org.wltea.analyzer.lucene.IKAnalyzer"/>
</fieldType>
<field name="item_title" type="text_ik" indexed="true" stored="true"/>
<field name="item_sell_point" type="text_ik" indexed="true" stored="true"/>
<field name="item_price"  type="long" indexed="true" stored="true"/>
<field name="item_image" type="string" indexed="false" stored="true" />
<field name="item_category_name" type="string" indexed="true" stored="true" />
<field name="item_desc" type="text_ik" indexed="true" stored="false" />
 

<field name="item_keywords" type="text_ik" indexed="true" stored="false" multiValued="true"/>
<copyField source="item_title" dest="item_keywords"/>
<copyField source="item_sell_point" dest="item_keywords"/>
<copyField source="item_category_name" dest="item_keywords"/>
<copyField source="item_desc" dest="item_keywords"/>

编程实现

1.架构图

架构图

2.建立java pojo属性对应copyField中的属性

3.利用solrj 接口实现基本的操作

package com.jcstool.solr;

import com.jcstool.solr.callback.FieldSetCallback;
import com.jcstool.solr.callback.HighlightCallback;
import com.jcstool.solr.callback.QueryCallback;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServer;
import org.apache.solr.client.solrj.SolrServerException;
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 java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

/**
 * solr 辅助类
 */
public class SolrHelper<T,PK>{
    private SolrServer solrServer = null;


    public SolrHelper(SolrServer solrServer) {
        this.solrServer = solrServer;
    }

    /**
     * 添加一个实体
     * @param t 实体
     * @param properties 属性列表
     */
    public void add(T t,List<String> properties){
        List<T> list = new ArrayList<T>();
        list.add(t);
        add(list,properties);
    }
    public void add(T t,FieldSetCallback callback){
        List<T> list = new ArrayList<T>();
        list.add(t);
        add(list,callback);
    }

    /**
     * 批量添加
     * @param list 实体集合
     * @param callback
     */
    public void add(List<T> list, FieldSetCallback callback){
        if(null == list || list.size() == 0 ) {
            return;
        }
        List<SolrInputDocument> docs = new ArrayList<SolrInputDocument>();
        List<Field> fields = ReflectUtil.getAllFields(list.get(0).getClass());
        for (T obj : list) {
            SolrInputDocument doc = new SolrInputDocument();
            callback.setFiled(obj,doc);
            docs.add(doc);
        }
        try {
            solrServer.add(docs);
            solrServer.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 批量添加
     * @param list 实体集合
     * @param properties 属性列表
     */
    public void add(List<T> list, List<String> properties){
        if(null == list || list.size() == 0 ) {
            return;
        }
        List<SolrInputDocument> docs = new ArrayList<SolrInputDocument>();
        List<Field> fields = ReflectUtil.getAllFields(list.get(0).getClass());
        for (T obj : list) {
            SolrInputDocument doc = new SolrInputDocument();
            for (Field field : fields) {
                for (String property : properties) {
                    if(property.equals(field.getName())) {
                        doc.addField(property, ReflectUtil.invokeGetter(obj,property));
                    }
                }
            }
            docs.add(doc);
        }
        try {
            solrServer.add(docs);
            solrServer.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public   void add(T obj) {
        try {
            this.solrServer.addBean(obj);
            this.solrServer.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 添加多个索引对象
     *
     */
    public  <T> void addBeans(List<T> list) {
        try {
            this.solrServer.addBeans(list);
            this.solrServer.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }



    /**
     * 根据ID删除
     * @param pk
     * @return
     * @throws IOException
     * @throws SolrServerException
     */
    public UpdateResponse deleteById(String pk) throws IOException, SolrServerException {
        UpdateResponse rsp = solrServer.deleteById(pk);
        solrServer.commit();
        return rsp;
    }

    /**
     * 清空数据
     * @return
     */
    public UpdateResponse clear(){
        return deleteByQuery("*:*");
    }

    /**
     * 根据查询语句删除索引
     * @param query
     * @return
     */
    public  UpdateResponse deleteByQuery(String query) {
        try {
            UpdateResponse rsp = solrServer.deleteByQuery(query);
            solrServer.commit();
            return rsp;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public T queryById(String id, Class<?> entityClass) {
        T obj = null;
        try {
            obj = (T) entityClass.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        SolrQuery query = new SolrQuery();
        query.setQuery("id:" + id);
        QueryResponse response = null;
        try {
            response = solrServer.query(query);
        } catch (Exception e) {
            e.printStackTrace();
        }
        SolrDocumentList docs = response.getResults();
        if(null == docs || docs.size() == 0) {
            return null;
        }
        SolrDocument doc = docs.get(0);
        List<Field> fields = ReflectUtil.getAllFields(obj.getClass());
        for (Field field : fields) {
            String propertyName = field.getName();
            Object propertyValue =  doc.getFieldValue(propertyName);
            Class<?> propertyClass = field.getType();
            if(propertyClass.equals(Integer.class)) {
                ReflectUtil.setFieldValue(obj,propertyClass,propertyName,propertyValue);
            } else {
                ReflectUtil.setFieldValue(obj,propertyClass,propertyName,propertyValue);
            }
        }
        return obj;
    }

    public SolrQuery createQuery(String queryString){
        //根据查询条件拼装查询对象
        //创建一个SolrQuery对象
        SolrQuery query = new SolrQuery();
        //设置查询条件
        query.setQuery(queryString);
        return query;
    }

    public  <T> Page<T> query(Page<T> page, SolrQuery solrQuery, Class<?> entityClass) {
        return query(page, solrQuery, entityClass, new HighlightCallback<T>(){
            public T set(T t, QueryResponse queryResponse, SolrDocument doc) {
                return t;
            }
        });
    }
    /**
     * solr获取的分页对象
     * @param page
     * @param solrQuery
     * @param entityClass
     * @param <T>
     * @return
     */
    public  <T> Page<T> query(Page<T> page, SolrQuery solrQuery, Class<?> entityClass, HighlightCallback callback) {
        solrQuery.setStart(page.getStartOfPage());//开始索引
        solrQuery.setRows(page.getPageSize());//分页的数量
        QueryResponse queryResponse = null;
        try {
            queryResponse = solrServer.query(solrQuery);
        } catch (Exception e) {
            e.printStackTrace();
        }
        SolrDocumentList docs = queryResponse.getResults();
        List<T> list = new ArrayList<T>(0);



        for(SolrDocument doc : docs){
            T obj = null;
            try {
                obj =  (T) entityClass.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            List<Field> fields = ReflectUtil.getAllFields(obj.getClass());
            for (Field field : fields) {
                String propertyName = field.getName();
                Object propertyValue =  doc.getFieldValue(propertyName);
                Class<?> propertyClass = field.getType();
                if(propertyClass.equals(Integer.class)) {
                    ReflectUtil.setFieldValue(obj, propertyClass, propertyName, propertyValue);
                } else {
                    ReflectUtil.setFieldValue(obj, propertyClass, propertyName, propertyValue);
                }

            }
            callback.set(obj,queryResponse,doc);
            list.add(obj);
        }
        page.setTotalRecord(docs.size());
        page.setResults(list);
        return page;
    }


}

4.将数据库中的数据导入到solr中

说明:后面的java操作实现查询功能就不提供代码了，根据架构图实现就好了。

第一次要讲数据库中的数据全部导入到solr中，以后导入数据的话，可以使用mq或其他的消息中间件去实现有数据添加到数据库时，同时导入solr

windows下配置好的solr server 下载

基于solr实现商品信息的全文检索（windwons）

猜你喜欢