solr服务器搭建

Solr中国网址

http://www.solr.cc/blog/?page_id=1267

http://www.cnblogs.com/hoojo/archive/2011/10/21/2220431.html

 

Solr搜索服务器搭建

一、Solr环境搭建

1.首先下载jdk1.7.0_25和apache-tomcat-7.0.42（版本只做参考），下载solr。solr下载地址：http://mirror.bit.edu.cn/apache/lucene/solr/4.10.2/

2.安装配置jdk，tomcat，此处不再赘述。

3.解压出solr-4.10.2。解压目录为D:\solr-4.10.2

4.复制D:\solr-4.10.2\example\webapps中的solr.war文件到tomcat安装目录webapps文件下D:\apache-tomcat-7.0.42\webapps

5.运行tomcat。（忽略怎么运行tomcat），tomcat会自动解压solr.war文件

6.关闭tomcat，删除solr.war文件。（不然每次启动tomcat都会发布一次）。

7.回到tomcat的webapps目录下，记事本打开solr\WEB-INF\web.xml文件。加入如下代码：在<web-app />节点内的最后。

<env-entry> 

   <env-entry-name>solr/home</env-entry-name> 

   <env-entry-value>D:\solrhome</env-entry-value> 

   <env-entry-type>java.lang.String</env-entry-type> 

</env-entry>

如上代码，需要在D盘新建一个文件夹：solrhome

8.回到解压的solr-4.10.2目录，打开文件夹：solr-4.10.2\example\solr，复制所有内容到D:\solrhome

9.打开文件夹：solr-4.10.2\example\lib\ext，复制所有jar包到tomcat的webapps\solr\WEB-INF\lib下。

10.运行web：http://localhost:8080/solr，将看到如下画面

 

 

11.在D:\solrhome目录下，新建一个mycore文件夹。

12.在解压的solr-4.10.2\example\multicore目录中，复制core0文件夹中的全部内容到D:\solrhome\mycore中。

13.在D:\solrhome中新建一个文件夹：mydocs

14.复制解压的solr-4.10.2\example\exampledocs下的post.jar到D:\solrhome\mydocs中。

15.复制解压的solr-4.10.2\example\multicore\exampledocs下的ipod_other.xml文件到D:\solrhome\mydocs中。

16.在solr web page中新建core。

 

新建完成后如图：

 

17.重启tomcat。（如何重启，忽略）。

18.打开CMD，切换到D:\solrhome\mydocs，输入命令：

java -Durl=http://localhost:8080/solr/mycore/update -Ddata=files -jar post.jar ipod_other.xml

运行如图所示：

 

19.在solr web中选择core。

 

 

20.查询测试。

 

21.也可以直接使用URL查询：

http://localhost:8080/solr/mycore/select?q=*%3A*&wt=json&indent=true

返回json.

 

 

 

 

 

{

  "responseHeader":{

    "status":0,

    "QTime":20},

  "response":{"numFound":2,"start":0,"docs":[

      {

        "id":"F8V7067-APL-KIT",

        "name":"Belkin Mobile Power Cord for iPod w/ Dock",

        "_version_":1485082387330105344},

      {

        "id":"IW-02",

        "name":"iPod & iPod Mini USB 2.0 Cable",

        "_version_":1485082387511508992}]

  }}

 

22.到此搭建环境全部完成。

二、IKAnalyzer分词加入。

1、下载IK Analyzer中文分词器：

http://ik-analyzer.googlecode.com/files/IK%20Analyzer%202012FF_hf1.zip

2、解压出zip文件，将IKAnalyzer2012FF_u1.jar复制到tomcat中的solr\WEB-INF\lib目录中。

3、在tomcat的solr\WEB-INF目录中，新建一个classes文件夹，将解压出的zip文件中的IKAnalyzer.cfg.xml和stopword.dic复制到classes中。

4、用记事本打开D:\solrhome\mycore\conf\schema.xml文件，加入这句话到<schema/>节点内：

    <fieldType name="text_general" class="solr.TextField">

        <analyzer type="index" class="org.wltea.analyzer.lucene.IKAnalyzer" />

        <analyzer type="query" class="org.wltea.analyzer.lucene.IKAnalyzer" />

</fieldType>

5、启动或重启tomcat.

6、进入solr web: http://localhost:8080/solr

    输入：一直以来,我都这样轻轻的走着

结果：

 

三、数据库数据导入

1.先在mysql中建一个表：TRADE_ORDERVOLUME,并插入几条测试数据。

 

 

 

2.用记事本打solrconfig.xml文件，在solrhome文件夹中。D:\solrhome\mycore\conf\solrconfig.xml。加入这个节点：

    <requestHandler name="/dataimport" class="org.apache.solr.handler.dataimport.DataImportHandler">

        <lst name="defaults">

            <str name="config">data-config.xml</str>

        </lst>

</requestHandler>

 

3.新建一个data-config.xml文件，与solrconfig.xml同一个目录下。内容为:

<dataConfig>

    <dataSource type="JdbcDataSource"

              driver="com.mysql.jdbc.Driver"

              url="jdbc:mysql://localhost/test"

              user="root"

              password="root" />

    <document>

        <entity name="solr_test" transformer="DateFormatTransformer"

            query="SELECT id, subject, content, last_update_time FROM solr_test WHERE id >= ${dataimporter.request.id}">

            <field column='last_update_time' dateTimeFormat='yyyy-MM-dd HH:mm:ss' />

        </entity>

    </document>

</dataConfig>

说明：这里使用了一个${dataimporter.request.id}，这个是参数，后面在做数据导入时，会使用到，以此条件为基准读数据。

4.复制解压出的solr jar包solr-dataimporthandler-4.10.0.jar和solr-dataimporthandler-extras-4.10.0.jar到tomcat solr webapp的WEB-INF\lib目录下。

当然，也包括mysql的jdbc jar包：mysql-connector-java-5.1.7-bin.jar

（还有一种方法是在solrconfig.xml中加入lib节点，然后把jar包放到solrhome下，这样可以不在WEB-INF\lib中加入jar包）

5.用记事本打solrconfig.xml文件，在solrhome文件夹中。D:\solrhome\mycore\conf\schema.xml修改内容为：

<?xml version="1.0" ?>

<schema name="my core" version="1.1">

 

    <fieldtype name="string"  class="solr.StrField" sortMissingLast="true" omitNorms="true"/>

    <fieldType name="long" class="solr.TrieLongField" precisionStep="0" positionIncrementGap="0"/>

    <fieldType name="date" class="solr.TrieDateField" precisionStep="0" positionIncrementGap="0"/>

    <fieldType name="text_cn" class="solr.TextField">

        <analyzer type="index" class="org.wltea.analyzer.lucene.IKAnalyzer" />

        <analyzer type="query" class="org.wltea.analyzer.lucene.IKAnalyzer" />

    </fieldType>

    

    <!-- general -->

    <field name="id" type="string" indexed="true" stored="true" multiValued="false" required="true"/>

    <field name="subject" type="text_cn" indexed="true" stored="true" />

    <field name="content" type="text_cn" indexed="true" stored="true" />

    <field name="last_update_time" type="date" indexed="true" stored="true" />

    <field name="_version_" type="long" indexed="true" stored="true"/>

 

     <!-- field to use to determine and enforce document uniqueness. -->

     <uniqueKey>id</uniqueKey>

 

     <!-- field for the QueryParser to use when an explicit fieldname is absent -->

     <defaultSearchField>subject</defaultSearchField>

 

     <!-- SolrQueryParser configuration: defaultOperator="AND|OR" -->

     <solrQueryParser defaultOperator="OR"/>

</schema>

6.打开solr web.

http://localhost:8080/solr/#/mycore/dataimport///dataimport

 

说明：

Custom Parameters填入id=1，这是在第4点中设置的参数。

Clean选项，是指是否删除未匹配到的数据。也就是在数据库select结果中没有，而solr索引库中存在，则删除。

也可以使用这个地址直接访问：

http://localhost:8899/solr/mycore/dataimport?command=full-import&clean=true&commit=true&wt=json&indent=true&entity=solr_test&verbose=false&optimize=false&debug=false&id=1

7.测试查询

 

当然，dataimport可以加入参数命令，让其重新加载data-config.xml

http://localhost:8899/solr/#/mycore/dataimport/command=reload-config

到此数据导入成功。

四、Solr索引数据修改和删除

1.更新索引数据，如图：

 

 再次查询solr对比结果。

 

 

对比索引和数据库我们发现，索引中的值改变了，数据库的值并没有改变。

2.删除索引数据

删除solr索引数据，使用XML有两种写法：

第一种：

<delete><id>1</id></delete>

<commit/>

第二种：

<delete><query>id:1</query></delete>

<commit/>

删除所有的索引，这样写就可以了：

<delete><query>*:*</query></delete>

<commit/>

注意：这个<commit/>节点不能少，否则删除动作的事务不会提交。

删除索引管理界面运行：

 

查询solr索引，我们发现第四条记录已经被我们删除了，但是数据库的肯定会存在，就不解释了。

 

也可以使用POST数据到这个URL方式运行：http://localhost:8899/solr/mycore/update?wt=json

POST数据为：

<add commitWithin="1000" overwrite="true">

    <delete>

        <query>id:1</query>

    </delete>

    <commit></commit>

</add>

五、使用SolrJ进行对Solr的增、删、查功能。

1、在Eclipse中新建一个项目：TestSolrJ

 

2、其中SorlJ的Lib包包括：

 

3、代码：

建一个Item Entity

 

4、测试代码：

 

5、运行结果。

 

去web solr页面查看对比一下，数据新增成功。如图：

public class ItemIndex extends AbstractDTO
{

    private static final long serialVersionUID = 5196140126588067948L;

    @Field
    private Long id;                                                            // 商品索引id
    @Field
    private String appResourceId;                                                // 平台资源id
    @Field
    private String appId;                                                        // 应用平台id
    @Field
    private String businessCode;                                                // 业务代码
    @Field
    private String firstCategoryCode;                                            // 一级品种编码
    @Field
    private String firstCategoryName;                                            // 一级品种名称
    @Field
    private String secondCategoryCode;                                            // 二级品种编码
    @Field
    private String secondCategoryName;                                            // 二级品种名称
    @Field
    private String thirdCategoryCode;                                            // 三级品种编码
    @Field
    private String thirdCategoryName;                                            // 三级品种名称
    @Field
    private String categoryCode;                                                // 品种编码
    @Field
    private String categoryName;                                                // 品种名称
   。。。。。。。。。。。。。。。

}

package com.banksteel.mall.itemindex.service;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.annotation.PostConstruct;

import org.apache.log4j.Logger;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.impl.LBHttpSolrServer;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import cn.mysteel.employee.entity.Employee;
import cn.mysteel.employee.service.EmployeeService;
import cn.mysteel.util.NumberUtils;

import com.alibaba.dubbo.common.utils.CollectionUtils;
import com.banksteel.mall.item.domain.SteelItem;
import com.banksteel.mall.item.service.SteelItemService;
import com.banksteel.mall.itemindex.constant.ItemIndexConstant;
import com.banksteel.mall.itemindex.constant.ItemIndexFilterConstant;
import com.banksteel.mall.itemindex.domain.ItemIndex;
import com.banksteel.mall.itemindex.entity.ItemIndexQueryParam;
import com.banksteel.mall.itemindex.entity.ItemIndexQueryResult;
import com.banksteel.mall.itemindex.entity.ItemIndexSortParam;
import com.banksteel.mall.itemindex.utils.SolrStatementUtils;

/**
 * @description: 商品明细索引组合服务实现
 * @projectName：banksteel-mall-item-index-service
 * @className：ItemIndexFacadeImpl.java
 * @see: com.banksteel.mall.itemindex.service
 * @author： wangchong
 * @createTime：2016年1月5日 下午5:20:48
 * @version 3.0.0
 */
@Service("itemIndexService")
public class ItemIndexServiceImpl implements ItemIndexService
{
    private static final Logger logger = Logger.getLogger(ItemIndexServiceImpl.class);
    private LBHttpSolrServer queryServer;
    private LBHttpSolrServer writeServer;

    @Autowired
    private SteelItemService steelItemService;
    @Autowired
    private EmployeeService employeeService;

    /**
     * 初始化方法
     */
    @PostConstruct
    public void init()
    {
        Properties prop = new Properties();

        InputStream ins = this.getClass().getResourceAsStream("/solr.properties");

        try
        {
            prop.load(ins);

            queryServer = new LBHttpSolrServer();
            writeServer = new LBHttpSolrServer();

            if (prop.get(ItemIndexConstant.QUERYSERVER_1) != null && StringUtils.hasText(prop.get(ItemIndexConstant.QUERYSERVER_1).toString()))
            {
                queryServer.addSolrServer(prop.get(ItemIndexConstant.QUERYSERVER_1).toString());
            }
            if (prop.get(ItemIndexConstant.QUERYSERVER_2) != null && StringUtils.hasText(prop.get(ItemIndexConstant.QUERYSERVER_2).toString()))
            {
                queryServer.addSolrServer(prop.get(ItemIndexConstant.QUERYSERVER_2).toString());
            }
            if (prop.get(ItemIndexConstant.WRITERSERVER) != null && StringUtils.hasText(prop.get(ItemIndexConstant.WRITERSERVER).toString()))
            {
                writeServer.addSolrServer(prop.get(ItemIndexConstant.WRITERSERVER).toString());
            }
        }
        catch (IOException e)
        {
            logger.error("初始化记载查询索引服务器失败！");
            e.printStackTrace();
        }
        logger.info("********************初始化加载查询索引服务器成功!********************");
    }

    private void createOrModifyItemIndexList(List<ItemIndex> itemIndexs)
    {
        boolean isHasNull = false;

        if(CollectionUtils.isNotEmpty(itemIndexs))
        {
            for(ItemIndex itemIndex : itemIndexs)
            {
                if(itemIndex == null || (itemIndex != null && itemIndex.getId() == null))
                {
                    isHasNull = true;
                }
            }

            if(!isHasNull)
            {
                try
                {
                    writeServer.addBeans(itemIndexs);
                    writeServer.commit();
        
                } catch (SolrServerException | IOException e)
                {
                    logger.error("更新或修改资源索引失败！");
                    e.printStackTrace();
                }
            }
            else
            {
                logger.error("更新或修改明细索引时不存在ItemIndex或者ID为空，未进行更新或修改操作！");
            }
        }
    }

    @Override
    public ItemIndexQueryResult queryItemIndex(ItemIndexQueryParam itemIndexQueryParam, List<ItemIndexSortParam> itemIndexSortParams, Long pageSize, Long pageNo)
    {
        Assert.notNull(itemIndexQueryParam);
        ItemIndexQueryResult itemIndexQueryResult = null;
        List<ItemIndex> itemIndexs = null;

        SolrQuery solrQuery = assembleQuery(itemIndexQueryParam,itemIndexSortParams);

        Integer row = pageSize.intValue();
        Integer page = pageNo.intValue();
        Integer start = ((page != 0 ? page : 1) - 1) * row;
        solrQuery.setStart(start);
        solrQuery.setRows(row);

        try
        {
            QueryResponse queryResponse = queryServer.query(solrQuery);
            itemIndexs = queryResponse.getBeans(ItemIndex.class);
            long numFound =  queryResponse.getResults().getNumFound();

            itemIndexQueryResult = new ItemIndexQueryResult();
            itemIndexQueryResult.setTotalCount(numFound);
            itemIndexQueryResult.setItemIndexs(itemIndexs);
            
        } catch (SolrServerException e)
        {
            logger.error("根据查询条件查询资源索引失败！");
            e.printStackTrace();
        }

        return itemIndexQueryResult;
    }

    @Override
    public void createOrModifyItemIndexIds(List<Long> ids)
    {
        Assert.notNull(ids);

        List<ItemIndex> itemIndexs = new ArrayList<ItemIndex>();

        for (Long itId : ids)
        {
            SteelItem steelItem = steelItemService.findItemById(itId);

            if(steelItem != null)
            {
                ItemIndex itemIndex = itemTransferToItemIndex(steelItem);
                itemIndexs.add(itemIndex);
            }
        }
        //创建或更新索引
        createOrModifyItemIndexList(itemIndexs);
    }

    @Override
    public void removeItemIndexByIdList(List<Long> ids)
    {
        Assert.notNull(ids);

        List<String> newIds = new ArrayList<String>(ids.size());

        for (Long id : ids)
        {
            if(id != null && id > 0L)
            {
                newIds.add(id.toString());
            }
        }

        if(CollectionUtils.isNotEmpty(newIds))
        {
            try
            {
                writeServer.deleteById(newIds);
                writeServer.commit();
                
            } catch (SolrServerException | IOException e)
            {
                logger.error("根据ID删除资源索引失败！");
                e.printStackTrace();
            }
        }
    }

    @Override
    public void setOutDate()
    {
        String queryStatement = SolrStatementUtils.generateBaseMatchStatement(ItemIndexFilterConstant.ISOUTDATE, "1");

        if(queryStatement != null)
        {
            try
            {
                writeServer.deleteByQuery(queryStatement);
                writeServer.commit();
                String statementStr = SolrStatementUtils.generateBaseMatchStatement(ItemIndexFilterConstant.ISOUTDATE, "0");
                SolrQuery solrQuery = new SolrQuery(statementStr);
                solrQuery.setStart(0);
                solrQuery.setRows(100);
                QueryResponse queryResponse = writeServer.query(solrQuery);
                List<ItemIndex> itemIndexs = queryResponse.getBeans(ItemIndex.class);

                while (CollectionUtils.isNotEmpty(itemIndexs))
                {
                    List<ItemIndex> itemIns = new ArrayList<ItemIndex>();
    
                    for(ItemIndex item : itemIndexs)
                    {
                        item.setIsOutDate(1L);
                        itemIns.add(item);
                    }

                    createOrModifyItemIndexList(itemIns);
                    itemIns.clear();
                    itemIndexs.clear();
                    QueryResponse newqueryResponse = writeServer.query(solrQuery);
                    itemIndexs = newqueryResponse.getBeans(ItemIndex.class);
                }
                logger.info("*********************[将当前的资源全部更新为过期的资源]************************");
                
            }
            catch (IOException | SolrServerException e)
            {
                logger.error("设置索引过期失败  ！");
                e.printStackTrace();
            }
        }
    }

    /**
     * @description: 基础类item转换成ItemIndex类
     * @param item
     * @return
     * @author： wangchong
     * @createTime：2016年1月6日 上午10:20:27
     */
    private ItemIndex itemTransferToItemIndex(SteelItem item)
    {
        ItemIndex itemIndex = null;

        if (item != null)
        {
            itemIndex = new ItemIndex();
            itemIndex.setAdminId(item.getAdminId());
            itemIndex.setAdminName(item.getAdminName());
            itemIndex.setAppId(item.getAppId());
            itemIndex.setAppResourceId(item.getAppResourceId());
            itemIndex.setAreaCode(item.getAreaCode());
            itemIndex.setAreaName(item.getAreaName());
            itemIndex.setAverageQty(item.getAverageQty());
            itemIndex.setBusinessCode(item.getBusinessCode());
            itemIndex.setCategoryAlias(item.getCategoryAlias());
            itemIndex.setCreateTime(item.getCreateTime());
            itemIndex.setCreatorId(item.getCreatorId());
            itemIndex.setCreatorName(item.getCreatorName());
            itemIndex.setFactoryAlias(item.getFactoryAlias());
            itemIndex.setFactoryCode(item.getFactoryCode());
            itemIndex.setFactoryName(item.getFactoryName());
            itemIndex.setFirstCategoryName(item.getFirstCategoryName());
            itemIndex.setFirstCategoryCode(item.getFirstCategoryCode());
            itemIndex.setGoodsMemberId(item.getGoodsMemberId());
            itemIndex.setId(item.getId());
            itemIndex.setMaterialAlias(item.getMaterialAlias());
            itemIndex.setMaterialCode(item.getMaterialCode());
            itemIndex.setMaterialName(item.getMaterialName());
            itemIndex.setNum(item.getNum());
            itemIndex.setPackNo(item.getPackNo());
            itemIndex.setPrice(item.getPrice());
            itemIndex.setPublishType(item.getPublishType());
            itemIndex.setQty(item.getQty());
            itemIndex.setQualityGrade(item.getQualityGrade());
            itemIndex.setQualityParentRemark(item.getQualityParentRemark());
            itemIndex.setQualityRemark(item.getQualityRemark());
            itemIndex.setQuantityUnit(item.getQuantityUnit());
            itemIndex.setRemark(item.getRemark());
            itemIndex.setSecondCategoryCode(item.getSecondCategoryCode());
            itemIndex.setSecondCategoryName(item.getSecondCategoryName());
            itemIndex.setSellMemberId(item.getSellMemberId());
            itemIndex.setSellMemberName(item.getSellMemberName());
            itemIndex.setShopId(item.getShopId());
            itemIndex.setShopName(item.getShopName());
            itemIndex.setSpecAlias(item.getSpecAlias());
            itemIndex.setSpecCode(item.getSpecCode());
            itemIndex.setSummaryCode(item.getSummaryCode());
            itemIndex.setSupplierId(item.getSupplierId());
            itemIndex.setSupplierName(item.getSupplierName());
            itemIndex.setThirdCategoryCode(item.getThirdCategoryCode());
            itemIndex.setThirdCategoryName(item.getThirdCategoryName());
            itemIndex.setWarehouseAlias(item.getWarehouseAlias());
            itemIndex.setWarehouseCode(item.getWarehouseCode());
            itemIndex.setWarehouseName(item.getWarehouseName());
            itemIndex.setWeightUnit(item.getWeightUnit());
            itemIndex.setWeightWay(item.getWeightWay());

            if(item.getAdminId()!= null && item.getAdminId()>0)
            {
                Employee employee = employeeService.getEmployeeById(item.getAdminId());

                if(employee != null)
                {
                    itemIndex.setAdminMobile(employee.getMobile());
                    itemIndex.setAdminPhone(employee.getPhone());
                    itemIndex.setAdminQQ(employee.getQq());
                }
            }

            String specName = item.getSpecName();
            if (StringUtils.hasText(specName))
            {
                // 存在不同的Ф
                if (specName.contains("Ф") || specName.contains("φ"))
                {
                    item.setSpecName(item.getSpecName().replaceAll("Ф", "Φ").replaceAll("φ", "Φ"));
                }
                specName.replaceAll("Ф", "").replaceAll("Φ", "").replaceAll("φ", "");
                // 规格中有*0结尾的 置换成*c
                StringBuffer sb = new StringBuffer(specName);
                if (specName.endsWith("*0"))
                {
                    // 只替换最后结尾的两个字符
                    item.setSpecName(sb.replace(specName.length() - 2, specName.length(), "*C").toString());
                }
                specName = sb.toString();
            }
            // 解析规格，根据不同形式进行匹配,暂时将格式当中的前三个数字进行保存
            if (StringUtils.hasText(specName))
            {
                Pattern pattern = Pattern.compile("[0-9]+(\\.[0-9]+)?");
                Matcher match = pattern.matcher(specName);
                for (int j = 0; match.find() && j <= 2; j++)
                {
                    String value = match.group();
                    if (value != null && SolrStatementUtils.checkTextToNum(value))
                    {
                        double num = Double.parseDouble(value);
                        if (j == 0)
                        {
                            itemIndex.setThickness(NumberUtils.parseDouble(SolrStatementUtils.formatNumber(Double.parseDouble(value), SolrStatementUtils.NUMBER_PATTERN_1)));
                        }
                        if (j == 1)
                        {
                            itemIndex.setWidth(NumberUtils.parseDouble(SolrStatementUtils.formatNumber(Double.parseDouble(value), SolrStatementUtils.NUMBER_PATTERN_1)));
                        }
                        if (j == 2)
                        {
                            itemIndex.setLength(NumberUtils.parseDouble(SolrStatementUtils.formatNumber(Double.parseDouble(value), SolrStatementUtils.NUMBER_PATTERN_1)));
                        }
                        specName = specName.replace(value, SolrStatementUtils.formatDecNumber(num, "####.##"));
                    }
                }

                // 将specName如果开头是字符的全部转化为空，用来作为辅助查询
                String specSearchName = item.getSpecName();

                if (StringUtils.hasText(specSearchName))
                {
                    specSearchName = specSearchName.replaceAll("^[^0-9]+", "");
                }
                itemIndex.setSpecSearchName(specSearchName);
            }

            itemIndex.setSpecName(specName);

            if(StringUtils.hasText(item.getWarehouseName()))
            {
                String warehouse = item.getWarehouseName();

                if (warehouse.contains("(") && warehouse.contains(")") )
                {
                    warehouse = warehouse.replace("(", "").replace(")", "");
                }
                else
                {
                    if (warehouse.contains("（") && warehouse.contains("）"))
                    {
                        warehouse = warehouse.replace("（", "").replace("）", "");
                    }
                }

                itemIndex.setWarehouseSearchName(warehouse);
            }

            itemIndex.setIsOutDate(0L);
            // 关键字查询
            String keyword = (StringUtils.hasText(item.getCategoryAlias()) ? item.getCategoryAlias() : "") + ","
                    +(StringUtils.hasText(item.getFirstCategoryName()) ? item.getFirstCategoryName() : "") + ","
                    +(StringUtils.hasText(item.getSecondCategoryName()) ? item.getSecondCategoryName() : "") + ","
                    +(StringUtils.hasText(item.getThirdCategoryName()) ? item.getThirdCategoryName() : "") + ","
                    +(StringUtils.hasText(item.getSpecName()) ? item.getSpecName() : "") + ","
                    +(StringUtils.hasText(item.getMaterialName()) ? item.getMaterialName() : "") + ","
                    +(StringUtils.hasText(item.getFactoryName()) ? item.getFactoryName() : "") + ","
                    +(StringUtils.hasText(item.getSellMemberName()) ? item.getSellMemberName() : "") + ","
                    +(StringUtils.hasText(item.getAreaName()) ? item.getAreaName() : "") + ","
                    +(StringUtils.hasText(item.getShopName()) ? item.getShopName() : "") + ","
                    +(StringUtils.hasText(item.getWarehouseName()) ? item.getWarehouseName() : "") + ","
                    +(StringUtils.hasText(item.getRemark()) ? item.getRemark() : "");

            itemIndex.setKeyword(keyword);
            itemIndex.setCategoryCode(item.getCategoryCode());
            itemIndex.setCategoryName(item.getCategoryName());
        }

        return itemIndex;
    }

    /**
     * @description: 封装查询条件
     * @param itemIndexQueryParams
     * @return
     * @author： wangchong
     * @createTime：2016年1月6日 下午2:12:46
     */
    private SolrQuery assembleQuery(ItemIndexQueryParam itemIndexQueryParams,List<ItemIndexSortParam> itemIndexSortParams)
    {
        List<String> queryList = new ArrayList<String>();
        List<String> filterQueryList = new ArrayList<String>();

        if (itemIndexQueryParams != null)
        {
            if (itemIndexQueryParams.getId() != null && itemIndexQueryParams.getId() > 0)
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.ID, itemIndexQueryParams.getId());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (StringUtils.hasText(itemIndexQueryParams.getAppResourceId()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement( ItemIndexFilterConstant.APPRESOURCEID, itemIndexQueryParams.getAppResourceId().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (StringUtils.hasText(itemIndexQueryParams.getAppId()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.APPID, itemIndexQueryParams.getAppId().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (StringUtils.hasText(itemIndexQueryParams.getBusinessCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.BUSSINESSCODE, itemIndexQueryParams.getBusinessCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getFirstCategoryCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.FIRSTCATEGORYCODE, itemIndexQueryParams.getFirstCategoryCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getFirstCategoryCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.FIRSTCATEGORYCODE, itemIndexQueryParams.getFirstCategoryCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getSecondCategoryCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.SECONDCATEGORYCODE, itemIndexQueryParams.getSecondCategoryCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getSecondCategoryCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.SECONDCATEGORYCODE, itemIndexQueryParams.getSecondCategoryCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getThirdCategoryCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.THIRDCATEGORYCODE, itemIndexQueryParams.getThirdCategoryCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getThirdCategoryCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.THIRDCATEGORYCODE, itemIndexQueryParams.getThirdCategoryCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getSpecCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.SPECCODE, itemIndexQueryParams.getSpecCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getCategoryName()))
            {
                List<String> statementList = new ArrayList<String>();
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.FIRSTCATEGORYNAME, itemIndexQueryParams.getCategoryName()));
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.SECONDCATEGORYNAME, itemIndexQueryParams.getCategoryName()));
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.THIRDCATEGORYNAME, itemIndexQueryParams.getCategoryName()));
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.CATEGORYALIAS, itemIndexQueryParams.getCategoryName()));

                String queryStatement = SolrStatementUtils.generateOrQueryByList(statementList);
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if(CollectionUtils.isNotEmpty(itemIndexQueryParams.getCategoryNames()))
            {
                List<String> statementList = new ArrayList<String>();

                for(String categoryName : itemIndexQueryParams.getCategoryNames())
                {
                    if(StringUtils.hasText(categoryName))
                    {
                        statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.FIRSTCATEGORYNAME, categoryName));
                        statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.SECONDCATEGORYNAME, categoryName));
                        statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.THIRDCATEGORYNAME, categoryName));
                        statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.CATEGORYALIAS, categoryName));
                    }
                }

                String queryStatement = SolrStatementUtils.generateOrQueryByList(statementList);
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getSpecName()))
            {
                List<String> statementList = new ArrayList<String>();
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.SPECNAME, itemIndexQueryParams.getSpecName()));
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.SPECALIAS, itemIndexQueryParams.getSpecName()));
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.SPECNAME, itemIndexQueryParams.getSpecName().replace("Φ", "")));
                statementList.add(SolrStatementUtils.generateBaseMatchStatement(ItemIndexFilterConstant.SPECSEARCHNAME, itemIndexQueryParams.getSpecName().replace("Φ", "") + "*"));
                String queryStatement = SolrStatementUtils.generateOrQueryByList(statementList);
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getSpecCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.SPECCODE, itemIndexQueryParams.getSpecCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getSpecNames()))
            {
                List<String> specNames = new ArrayList<String>();

                for(String specName : itemIndexQueryParams.getSpecNames())
                {
                    if(StringUtils.hasText(specName))
                    {
                        specNames.add(specName);
                        specNames.add(specName.replace("Φ", ""));
                    }
                }

                String queryStatement = SolrStatementUtils.generateOrQueryByBlurValues(ItemIndexFilterConstant.SPECNAME, specNames);
                if (StringUtils.hasText(queryStatement))
                {
                    queryList.add(queryStatement);
                }
            }
            if((itemIndexQueryParams.getStartThickness() != null && itemIndexQueryParams.getStartThickness() > 0 )|| (itemIndexQueryParams.getEndThickness() != null && itemIndexQueryParams.getEndThickness() > 0))
            {
                Double startThickness = null;
                Double endThickness = null;

                if(itemIndexQueryParams.getStartThickness() != null && itemIndexQueryParams.getStartThickness() > 0)
                {
                    startThickness = itemIndexQueryParams.getStartThickness();
                }

                if(itemIndexQueryParams.getEndThickness() != null && itemIndexQueryParams.getEndThickness() > 0)
                {
                    endThickness = itemIndexQueryParams.getEndThickness();
                }
                String queryStatement = SolrStatementUtils.generateRangeMatchStatement(ItemIndexFilterConstant.THICKNESS, startThickness, endThickness);
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if((itemIndexQueryParams.getStartWidth() != null &&itemIndexQueryParams.getStartWidth() >0) || (itemIndexQueryParams.getEndWidth() != null && itemIndexQueryParams.getEndWidth() >0 ))
            {
                Double startWidth = null;
                Double endwidth = null;

                if(itemIndexQueryParams.getStartWidth() != null &&itemIndexQueryParams.getStartWidth() >0)
                {
                    startWidth = itemIndexQueryParams.getStartWidth();
                }

                if(itemIndexQueryParams.getEndWidth()!= null && itemIndexQueryParams.getEndWidth() > 0)
                {
                    endwidth = itemIndexQueryParams.getEndWidth();
                }
                String queryStatement = SolrStatementUtils.generateRangeMatchStatement(ItemIndexFilterConstant.WIDTH, startWidth, endwidth);
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if((itemIndexQueryParams.getStartLength() != null && itemIndexQueryParams.getStartLength() > 0) || (itemIndexQueryParams.getEndLength() != null && itemIndexQueryParams.getEndLength() > 0))
            {
                Double startLength = null;
                Double endLength = null;

                if(itemIndexQueryParams.getStartLength() != null && itemIndexQueryParams.getStartLength() > 0)
                {
                    startLength = itemIndexQueryParams.getStartLength();
                }

                if(itemIndexQueryParams.getEndLength() != null && itemIndexQueryParams.getEndLength() > 0)
                {
                    endLength = itemIndexQueryParams.getEndLength();
                }
                String queryStatement = SolrStatementUtils.generateRangeMatchStatement(ItemIndexFilterConstant.LENGTH, startLength, endLength);
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if((itemIndexQueryParams.getStartPrice()!= null && itemIndexQueryParams.getStartPrice() > 0)|| (itemIndexQueryParams.getEndPrice() != null && itemIndexQueryParams.getEndPrice() > 0))
            {
                Long startPrice = null;
                Long endPrice = null;

                if(itemIndexQueryParams.getStartPrice()!= null && itemIndexQueryParams.getStartPrice() > 0)
                {
                    startPrice = itemIndexQueryParams.getStartPrice();
                }

                if(itemIndexQueryParams.getEndPrice()!= null && itemIndexQueryParams.getEndPrice() > 0)
                {
                    endPrice = itemIndexQueryParams.getEndPrice();
                }

                String queryStatement = SolrStatementUtils.generateLongRangeMatchStatement(ItemIndexFilterConstant.PRICE, startPrice, endPrice);
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getMaterialCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.MATERIALCODE, itemIndexQueryParams.getMaterialCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getMaterialName()))
            {
                String queryStatement = SolrStatementUtils .generateBlurMatchStatement(ItemIndexFilterConstant.MATERIALNAME, itemIndexQueryParams.getMaterialName().trim());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getMaterialCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.MATERIALCODE, itemIndexQueryParams.getMaterialCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getMaterialNames()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByBlurValues(ItemIndexFilterConstant.MATERIALNAME, itemIndexQueryParams.getMaterialNames());
                if (StringUtils.hasText(queryStatement))
                {
                    queryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getFactoryCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.FACTORYCODE, itemIndexQueryParams.getFactoryCode());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getFactoryName()))
            {
                String queryStatement = SolrStatementUtils .generateBlurMatchStatement(ItemIndexFilterConstant.FACTORYNAME, itemIndexQueryParams.getFactoryName());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getFactoryCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.FACTORYCODE, itemIndexQueryParams.getFactoryCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getFactoryNames()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.FACTORYNAME, itemIndexQueryParams.getFactoryNames());
                if (StringUtils.hasText(queryStatement))
                {
                    queryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getAreaCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.AREACODE, itemIndexQueryParams.getAreaCode());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getAreaName()))
            {
                String queryStatement = SolrStatementUtils .generateBlurMatchStatement(ItemIndexFilterConstant.AREANAME, itemIndexQueryParams.getAreaName());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getWarehouseCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.WAREHOUSECODE, itemIndexQueryParams.getWarehouseCode());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getWarehouseName()))
            {
                String warehouseName = itemIndexQueryParams.getWarehouseName();

                if (warehouseName.contains("(") && warehouseName.contains(")"))
                {
                    warehouseName = warehouseName.replace("(", "").replace(")", "");
                }
                else
                {
                    if (warehouseName.contains("（") && warehouseName.contains("）"))
                    {
                        warehouseName = warehouseName.replace("（", "").replace("）", "");
                    }
                }

                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.WAREHOUSESEARCHNAME, warehouseName.trim());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getWarehouseCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.WAREHOUSECODE, itemIndexQueryParams.getWarehouseCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getWarehouseNames()))
            {
                List<String> warehouseNames = new ArrayList<String>();

                for(String warehouseName : warehouseNames)
                {
                    if (warehouseName.contains("(") && warehouseName.contains(")"))
                    {
                        warehouseName = warehouseName.replace("(", "").replace(")", "");
                    }
                    else
                    {
                        if (warehouseName.contains("（") && warehouseName.contains("）"))
                        {
                            warehouseName = warehouseName.replace("（", "").replace("）", "");
                        }
                        else
                        {
                            warehouseName = SolrStatementUtils.generateBlurValue(warehouseName);
                        }
                    }

                    warehouseNames.add(warehouseName);
                }

                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.WAREHOUSESEARCHNAME, warehouseNames);
                if (StringUtils.hasText(queryStatement))
                {
                    queryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getSummaryCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.SUMMARYCODE, itemIndexQueryParams.getSummaryCode());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getPackNo()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.PACKNO, itemIndexQueryParams.getPackNo());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getSellMemberName()))
            {
                String queryStatement = SolrStatementUtils .generateBlurMatchStatement(ItemIndexFilterConstant.SELLMEMBERNAME, itemIndexQueryParams.getSellMemberName());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if(itemIndexQueryParams.getSellMemberId() != null)
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.SELLMEMBERID, itemIndexQueryParams.getSellMemberId());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getShopName()))
            {
                String queryStatement = SolrStatementUtils .generateBlurMatchStatement(ItemIndexFilterConstant.SHOPNAME, itemIndexQueryParams.getShopName());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if(itemIndexQueryParams.getShopId() != null)
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.SHOPID, itemIndexQueryParams.getShopId());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(itemIndexQueryParams.getIsOutDate() != null)
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.ISOUTDATE, itemIndexQueryParams.getIsOutDate());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            //关键字匹配
            if(StringUtils.hasText(itemIndexQueryParams.getKeyword()))
            {
                Map<String, String> caseMap = new HashMap<String, String>();
                caseMap.put(ItemIndexFilterConstant.FIRSTCATEGORYNAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.SECONDCATEGORYNAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.THIRDCATEGORYNAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.SPECNAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.MATERIALNAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.WAREHOUSENAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.KEYWORD, itemIndexQueryParams.getKeyword());

                String queryStatement = SolrStatementUtils.generateOrMatchStatement(caseMap);
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
        }

        String queryStatement = SolrStatementUtils .generateAndQueryByList(queryList);
        SolrQuery solrQuery = new SolrQuery(queryStatement);

        for (String filterQuery : filterQueryList)
        {
            solrQuery.addFilterQuery(filterQuery);
        }

        if (CollectionUtils.isNotEmpty(itemIndexSortParams))
        {
            for (ItemIndexSortParam itemsort : itemIndexSortParams)
            {
                if (itemsort != null)
                {
                    long sortType = itemsort.getSortType().getValue();

                    if (sortType == 2)
                    {
                        solrQuery.addSortField(itemsort.getSortField().getFieldName(), SolrQuery.ORDER.desc);
                    }
                    else
                    {
                        solrQuery.addSortField(itemsort.getSortField().getFieldName(), SolrQuery.ORDER.asc);
                    }
                }
            }
        }

        return solrQuery;
    }
}

汇总索引：

package com.banksteel.mall.itemindex.service;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.annotation.PostConstruct;

import org.apache.log4j.Logger;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.impl.LBHttpSolrServer;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import cn.mysteel.employee.entity.Employee;
import cn.mysteel.employee.service.EmployeeService;
import cn.mysteel.util.NumberUtils;

import com.alibaba.dubbo.common.utils.CollectionUtils;
import com.banksteel.mall.item.domain.SteelItem;
import com.banksteel.mall.item.service.SteelItemService;
import com.banksteel.mall.itemindex.constant.ItemIndexConstant;
import com.banksteel.mall.itemindex.constant.ItemIndexFilterConstant;
import com.banksteel.mall.itemindex.domain.SummaryItemIndex;
import com.banksteel.mall.itemindex.entity.ItemIndexQueryParam;
import com.banksteel.mall.itemindex.entity.ItemIndexSortParam;
import com.banksteel.mall.itemindex.entity.SummaryItemIndexQueryResult;
import com.banksteel.mall.itemindex.utils.SolrStatementUtils;

/**
 * @description: 汇总索引组合服务实现
 * @projectName：banksteel-mall-item-index-service
 * @className：SummaryItemIndexFacadeImpl.java
 * @see: com.banksteel.mall.itemindex.service
 * @author： zhaiang
 * @createTime：2016年1月5日 下午5:26:40
 * @version 3.0.0
 */
@Service("summaryItemIndexService")
public class SummaryItemIndexServiceImpl implements SummaryItemIndexService
{
    private static final Logger logger = Logger.getLogger(SummaryItemIndexServiceImpl.class);
    private LBHttpSolrServer querySummaryServer;
    private LBHttpSolrServer writeSummaryServer;
    private LBHttpSolrServer writeServer;

    @Autowired
    private SteelItemService steelItemService;
    @Autowired
    private EmployeeService employeeService;

    /**
     * 初始化方法
     */
    @PostConstruct
    public void init()
    {
        Properties properties = new Properties();

        InputStream inps = this.getClass().getResourceAsStream( "/solr.properties");

        try
        {
            properties.load(inps);

            querySummaryServer = new LBHttpSolrServer();
            writeSummaryServer = new LBHttpSolrServer();
            writeServer = new LBHttpSolrServer();

            if(properties.get(ItemIndexConstant.QUERYSUMMARYSERVER1) != null && StringUtils.hasText(properties.get(ItemIndexConstant.QUERYSUMMARYSERVER1).toString()))
            {
                querySummaryServer.addSolrServer(properties.get(ItemIndexConstant.QUERYSUMMARYSERVER1).toString());
            }
            if(properties.get(ItemIndexConstant.QUERYSUMMARYSERVER2) != null && StringUtils.hasText(properties.get(ItemIndexConstant.QUERYSUMMARYSERVER2).toString()))
            {
                querySummaryServer.addSolrServer(properties.get(ItemIndexConstant.QUERYSUMMARYSERVER2).toString());
            }
            if(properties.get(ItemIndexConstant.WRITERSUMMARYSERVER) != null && StringUtils.hasText(properties.get(ItemIndexConstant.WRITERSUMMARYSERVER).toString()))
            {
                writeSummaryServer.addSolrServer(properties.get(ItemIndexConstant.WRITERSUMMARYSERVER).toString());
            }
            if (properties.get(ItemIndexConstant.WRITERSERVER) != null && StringUtils.hasText(properties.get(ItemIndexConstant.WRITERSERVER).toString()))
            {
                writeServer.addSolrServer(properties.get(ItemIndexConstant.WRITERSERVER).toString());
            }

        } catch (IOException e)
        {
            logger.error("初始化记载查询索引服务器失败！");
            e.printStackTrace();
        }
        logger.info("**************************初始化加载查询索引服务器成功!********************");
    }

    @Override
    public SummaryItemIndexQueryResult querySummaryItemIndex(ItemIndexQueryParam itemIndexQueryParam, List<ItemIndexSortParam> itemIndexSortParams, Long pageSize, Long pageNo)
    {
        Assert.notNull(itemIndexQueryParam);
        SummaryItemIndexQueryResult summaryItemIndexQueryResult = null;
        List<SummaryItemIndex> summaryItemIndexs = null;

        SolrQuery solrQuery = assembleQuery(itemIndexQueryParam,itemIndexSortParams);

        Integer row = (pageSize == null ? 0 : pageSize.intValue());
        Integer page = (pageNo == null ? 0 : pageNo.intValue());
        Integer start = ((page != 0 ? page : 1) - 1) * row;
        solrQuery.setStart(start);
        solrQuery.setRows(row);

        try
        {
            QueryResponse queryResponse = querySummaryServer.query(solrQuery);
            summaryItemIndexs = queryResponse.getBeans(SummaryItemIndex.class);
            long numFound  = queryResponse.getResults().getNumFound();

            summaryItemIndexQueryResult = new SummaryItemIndexQueryResult();
            summaryItemIndexQueryResult.setTotalCount(numFound);
            summaryItemIndexQueryResult.setSummaryItemIndexs(summaryItemIndexs);

        } catch (SolrServerException e)
        {
            logger.error("查询汇总资源索引失败！");
            e.printStackTrace();
        }

        return summaryItemIndexQueryResult;
    }

    @Override
    public void createOrModifySummaryItemIndexSummaryCodes( List<String> summaryCodes)
    {
        Assert.notNull(summaryCodes);

        List<SummaryItemIndex> summaryItemIndexs = new ArrayList<SummaryItemIndex>();
        List<String> deletesummaryCodes = new ArrayList<String>();

        for (String summaryCode : summaryCodes)
        {
            if(StringUtils.hasText(summaryCode))
            {
                //先删除汇总资源下的明细有过期的资源
                String queryStatement = SolrStatementUtils.generateBaseMatchStatement(ItemIndexFilterConstant.ISOUTDATE, "1");

                if(queryStatement != null)
                {
                    try
                    {
                        writeServer.deleteByQuery(queryStatement);
                        writeServer.commit();
                    }
                    catch (SolrServerException | IOException e)
                    {
                        logger.error("删除汇总资源下的明细有过期的资源失败！");
                        e.printStackTrace();
                    }
                }

                List<SteelItem> steelItems = steelItemService.queryItemBySummaryCode(summaryCode);

                if(CollectionUtils.isNotEmpty(steelItems))
                {
                    SummaryItemIndex summaryItemIndex = new SummaryItemIndex();

                    SteelItem steelIte = steelItems.get(0);

                    if(steelIte != null)
                    {
                        summaryItemIndex.setSummaryCode(steelIte.getSummaryCode());
                        summaryItemIndex.setFirstCategoryCode(steelIte.getFirstCategoryCode());
                        summaryItemIndex.setFirstCategoryName(steelIte.getFirstCategoryName());
                        summaryItemIndex.setSecondCategoryCode(steelIte.getSecondCategoryCode());
                        summaryItemIndex.setSecondCategoryName(steelIte.getSecondCategoryName());
                        summaryItemIndex.setThirdCategoryCode(steelIte.getThirdCategoryCode());
                        summaryItemIndex.setThirdCategoryName(steelIte.getThirdCategoryName());
                        summaryItemIndex.setSpecCode(steelIte.getSpecCode());
                        summaryItemIndex.setSpecName(steelIte.getSpecName());
                        summaryItemIndex.setCategoryCode(steelIte.getCategoryCode());
                        summaryItemIndex.setCategoryName(steelIte.getCategoryName());
                        summaryItemIndex.setMaterialCode(steelIte.getMaterialCode());
                        summaryItemIndex.setMaterialName(steelIte.getMaterialName());
                        summaryItemIndex.setFactoryCode(steelIte.getFactoryCode());
                        summaryItemIndex.setFactoryName(steelIte.getFactoryName());
                        summaryItemIndex.setAreaCode(steelIte.getAreaCode());
                        summaryItemIndex.setAreaName(steelIte.getAreaName());
                        summaryItemIndex.setWarehouseCode(steelIte.getWarehouseCode());
                        summaryItemIndex.setWarehouseName(steelIte.getWarehouseName());

                        String specName = steelIte.getSpecName();
                        if (StringUtils.hasText(specName))
                        {
                            // 存在不同的Ф
                            if (specName.contains("Ф") || specName.contains("φ"))
                            {
                                steelIte.setSpecName(steelIte.getSpecName().replaceAll("Ф", "Φ").replaceAll("φ", "Φ"));
                            }
                            specName.replaceAll("Ф", "").replaceAll("Φ", "").replaceAll("φ", "");
                            // 规格中有*0结尾的 置换成*c
                            StringBuffer sb = new StringBuffer(specName);
                            if (specName.endsWith("*0"))
                            {
                                // 只替换最后结尾的两个字符
                                steelIte.setSpecName(sb.replace(specName.length() - 2, specName.length(), "*C").toString());
                            }
                            specName = sb.toString();
                        }
                        // 解析规格，根据不同形式进行匹配,暂时将格式当中的前三个数字进行保存
                        if (StringUtils.hasText(specName))
                        {
                            Pattern pattern = Pattern.compile("[0-9]+(\\.[0-9]+)?");
                            Matcher match = pattern.matcher(specName);
                            for (int j = 0; match.find() && j <= 2; j++)
                            {
                                String value = match.group();
                                if (value != null && SolrStatementUtils.checkTextToNum(value))
                                {
                                    double num = Double.parseDouble(value);
                                    if (j == 0)
                                    {
                                        summaryItemIndex.setThickness(NumberUtils.parseDouble(SolrStatementUtils.formatNumber(Double.parseDouble(value), SolrStatementUtils.NUMBER_PATTERN_1)));
                                    }
                                    if (j == 1)
                                    {
                                        summaryItemIndex.setWidth(NumberUtils.parseDouble(SolrStatementUtils.formatNumber(Double.parseDouble(value), SolrStatementUtils.NUMBER_PATTERN_1)));
                                    }
                                    if (j == 2)
                                    {
                                        summaryItemIndex.setLength(NumberUtils.parseDouble(SolrStatementUtils.formatNumber(Double.parseDouble(value), SolrStatementUtils.NUMBER_PATTERN_1)));
                                    }
                                    specName = specName.replace(value, SolrStatementUtils.formatDecNumber(num, "####.##"));
                                }
                            }
                            
                            // 将specName如果开头是字符的全部转化为空，用来作为辅助查询
                            String specSearchName = steelIte.getSpecName();

                            if (StringUtils.hasText(specSearchName))
                            {
                                specSearchName = specSearchName.replaceAll("^[^0-9]+", "");
                            }
                            summaryItemIndex.setSpecSearchName(specSearchName);
                        }

                        summaryItemIndex.setSpecName(specName);

                        if(StringUtils.hasText(steelIte.getWarehouseName()))
                        {
                            String warehouse = steelIte.getWarehouseName();

                            if (warehouse.contains("(") && warehouse.contains(")") )
                            {
                                warehouse = warehouse.replace("(", "").replace(")", "");
                            }
                            else
                            {
                                if (warehouse.contains("（") && warehouse.contains("）"))
                                {
                                    warehouse = warehouse.replace("（", "").replace("）", "");
                                }
                            }

                            summaryItemIndex.setWarehouseSearchName(warehouse);
                        }

                        // 关键字查询
                        String keyword = (StringUtils.hasText(steelIte.getCategoryAlias()) ? steelIte.getCategoryAlias() : "") + ","
                                +(StringUtils.hasText(steelIte.getFirstCategoryName()) ? steelIte.getFirstCategoryName() : "") + ","
                                +(StringUtils.hasText(steelIte.getSecondCategoryName()) ? steelIte.getSecondCategoryName() : "") + ","
                                +(StringUtils.hasText(steelIte.getThirdCategoryName()) ? steelIte.getThirdCategoryName() : "") + ","
                                +(StringUtils.hasText(steelIte.getSpecName()) ? steelIte.getSpecName() : "") + ","
                                +(StringUtils.hasText(steelIte.getMaterialName()) ? steelIte.getMaterialName() : "") + ","
                                +(StringUtils.hasText(steelIte.getFactoryName()) ? steelIte.getFactoryName() : "") + ","
                                +(StringUtils.hasText(steelIte.getSellMemberName()) ? steelIte.getSellMemberName() : "") + ","
                                +(StringUtils.hasText(steelIte.getAreaName()) ? steelIte.getAreaName() : "") + ","
                                +(StringUtils.hasText(steelIte.getShopName()) ? steelIte.getShopName() : "") + ","
                                +(StringUtils.hasText(steelIte.getWarehouseName()) ? steelIte.getWarehouseName() : "") + ","
                                +(StringUtils.hasText(steelIte.getRemark()) ? steelIte.getRemark() : "");

                        summaryItemIndex.setIsOutDate(0L);
                        summaryItemIndex.setKeyword(keyword);
                        summaryItemIndex.setPrice(steelIte.getPrice());
                    }

                    Long count = 0L;
                    Long sumNum = 0L;
                    Long sumQty = 0L;
                    String categoryAlias ="";
                    String specAlias ="";
                    String materialAlias ="";
                    String factoryAlias ="";
                    String warehouseAlias ="";
                    String remark ="";

                    for(SteelItem steelItem : steelItems)
                    {
                        if(steelItem != null)
                        {
                            
                            if (steelItem.getNum() == 0)
                            {
                                continue;
                            }
                            if (steelItem.getNum() > 0)
                            {
                                count++;
                            }
                            sumNum = sumNum + steelItem.getNum();
                            sumQty = sumQty + steelItem.getQty();
                            
                            if(StringUtils.hasText(steelItem.getCategoryAlias()))
                            {
                                if(!StringUtils.hasText(categoryAlias))
                                {
                                    categoryAlias = steelItem.getCategoryAlias();
                                }
                                else
                                {
                                    categoryAlias = categoryAlias + "," + steelItem.getCategoryAlias();
                                }
                            }
                            if(StringUtils.hasText(steelItem.getSpecAlias()))
                            {
                                if(!StringUtils.hasText(specAlias))
                                {
                                    specAlias = steelItem.getSpecAlias();
                                }
                                else
                                {
                                    specAlias = specAlias + "," + steelItem.getSpecAlias();
                                }
                            }
                            if(StringUtils.hasText(steelItem.getMaterialAlias()))
                            {
                                if(!StringUtils.hasText(materialAlias))
                                {
                                    materialAlias = steelItem.getMaterialAlias();
                                }
                                else
                                {
                                    materialAlias = materialAlias + "," + steelItem.getMaterialAlias();
                                }
                            }
                            if(StringUtils.hasText(steelItem.getFactoryAlias()))
                            {
                                if(!StringUtils.hasText(factoryAlias))
                                {
                                    factoryAlias = steelItem.getFactoryAlias();
                                }
                                else
                                {
                                    factoryAlias = factoryAlias + "," + steelItem.getFactoryAlias();
                                }
                            }
                            if(StringUtils.hasText(steelItem.getWarehouseAlias()))
                            {
                                if(!StringUtils.hasText(warehouseAlias))
                                {
                                    warehouseAlias = steelItem.getWarehouseAlias();
                                }
                                else
                                {
                                    warehouseAlias = warehouseAlias + "," + steelItem.getWarehouseAlias();
                                }
                            }
                            if(StringUtils.hasText(steelItem.getRemark()))
                            {
                                if(!StringUtils.hasText(remark))
                                {
                                    remark = steelItem.getRemark();
                                }
                                else
                                {
                                    remark = remark + "," + steelItem.getRemark();
                                }
                            }
                        }
                    }

                    summaryItemIndex.setNum(sumNum);
                    summaryItemIndex.setQty(sumQty);

                    if(sumNum > 0)
                    {
                        Double averageQty = NumberUtils.div(sumQty.doubleValue(), sumNum.doubleValue());
                        summaryItemIndex.setAverageQty(averageQty.longValue());
                    }

                    summaryItemIndex.setItemNum(count);

                    if(count == 1)
                    {
                        summaryItemIndex.setItemId(steelIte.getId());
                        summaryItemIndex.setAppResourceId(steelIte.getAppResourceId());
                        summaryItemIndex.setAppId(steelIte.getAppId());
                        summaryItemIndex.setBusinessCode(steelIte.getBusinessCode());
                        summaryItemIndex.setPackNo(steelIte.getPackNo());
                        summaryItemIndex.setWeightWay(steelIte.getWeightWay());
                        summaryItemIndex.setWeightUnit(steelIte.getWeightUnit());
                        summaryItemIndex.setQuantityUnit(steelIte.getQuantityUnit());
                        summaryItemIndex.setQualityGrade(steelIte.getQualityGrade());
                        summaryItemIndex.setQualityRemark(steelIte.getQualityRemark());
                        summaryItemIndex.setQualityParentRemark(steelIte.getQualityParentRemark());
                        summaryItemIndex.setGoodsMemberId(steelIte.getGoodsMemberId());
                        summaryItemIndex.setSellMemberId(steelIte.getSellMemberId());
                        summaryItemIndex.setSellMemberName(steelIte.getSellMemberName());
                        summaryItemIndex.setShopId(steelIte.getShopId());
                        summaryItemIndex.setShopName(steelIte.getShopName());
                        summaryItemIndex.setSupplierId(steelIte.getSupplierId());
                        summaryItemIndex.setSupplierName(steelIte.getSupplierName());
                        summaryItemIndex.setAdminId(steelIte.getAdminId());
                        summaryItemIndex.setAdminName(steelIte.getAdminName());

                        if(steelIte.getAdminId()!= null && steelIte.getAdminId()>0)
                        {
                            Employee employee = employeeService.getEmployeeById(steelIte.getAdminId());

                            if(employee != null)
                            {
                                summaryItemIndex.setAdminMobile(employee.getMobile());
                                summaryItemIndex.setAdminPhone(employee.getPhone());
                                summaryItemIndex.setAdminQQ(employee.getQq());
                            }
                        }

                        summaryItemIndex.setPublishType(steelIte.getPublishType());
                        summaryItemIndex.setCreatorId(steelIte.getCreatorId());
                        summaryItemIndex.setCreatorName(steelIte.getCreatorName());
                        summaryItemIndex.setCreateTime(steelIte.getCreateTime());
                    }

                    summaryItemIndexs.add(summaryItemIndex);
                }
                else
                {
                    deletesummaryCodes.add(summaryCode);
                }
            }
        }

        //删除不存在明细的汇总索引
        removeSummaryItemIndexBySummaryCodeList(deletesummaryCodes);
        //添加汇总
        createOrModifySummaryItemIndexList(summaryItemIndexs);
    }

    /**
    * @description: 添加或更新索引
    * @param summaryItemIndexs
    * @author：wangchong
    * @createTime：2016年1月21日 上午9:16:02
    */
    private void createOrModifySummaryItemIndexList( List<SummaryItemIndex> summaryItemIndexs)
    {
        boolean isHasNull = false;

        if(CollectionUtils.isNotEmpty(summaryItemIndexs))
        {
            for(SummaryItemIndex suItemIndex : summaryItemIndexs)
            {
                if(suItemIndex == null || (suItemIndex != null && suItemIndex.getSummaryCode() == null))
                {
                    isHasNull = true;
                }
            }

            if(!isHasNull)
            {
                try
                {
                    writeSummaryServer.addBeans(summaryItemIndexs);
                    writeSummaryServer.commit();

                } catch (SolrServerException | IOException e)
                {
                    logger.error("更新或修改汇总资源索引失败！");
                    e.printStackTrace();
                }
            }
            else
            {
                logger.error("更新或修改汇总索引时不存在SummaryIndex或者SummaryCode为空，未进行更新或修改操作！");
            }
        }
    }

    /**
    * @description: 删除汇总索引
    * @param summaryCodes
    * @author：wangchong
    * @createTime：2016年1月21日 上午9:16:10
    */
    private void removeSummaryItemIndexBySummaryCodeList( List<String> summaryCodes)
    {
        if(CollectionUtils.isNotEmpty(summaryCodes))
        {
            try
            {
                writeSummaryServer.deleteById(summaryCodes);
                writeSummaryServer.commit();
            } catch (SolrServerException | IOException e)
            {
                logger.error("删除汇总资源索引失败！");
                e.printStackTrace();
            }
        }
    }

    @Override
    public void setOutDate()
    {
        String queryStatement = SolrStatementUtils.generateBaseMatchStatement(ItemIndexFilterConstant.ISOUTDATE, "1");

        if(queryStatement != null)
        {
            try
            {
                writeSummaryServer.deleteByQuery(queryStatement);
                writeSummaryServer.commit();
                String statementStr = SolrStatementUtils.generateBaseMatchStatement(ItemIndexFilterConstant.ISOUTDATE, "0");
                SolrQuery solrQuery = new SolrQuery(statementStr);
                solrQuery.setStart(0);
                solrQuery.setRows(100);
                QueryResponse queryResponse = writeSummaryServer.query(solrQuery);
                List<SummaryItemIndex> summaryItemIndexs = queryResponse.getBeans(SummaryItemIndex.class);

                while (CollectionUtils.isNotEmpty(summaryItemIndexs))
                {
                    List<SummaryItemIndex> summaryItemIn = new ArrayList<SummaryItemIndex>();
    
                    for(SummaryItemIndex summaryitem : summaryItemIndexs)
                    {
                        summaryitem.setIsOutDate(1L);
                        summaryItemIn.add(summaryitem);
                    }

                    createOrModifySummaryItemIndexList(summaryItemIn);
                    summaryItemIn.clear();
                    summaryItemIndexs.clear();
                    QueryResponse newqueryResponse = writeSummaryServer.query(solrQuery);
                    summaryItemIndexs = newqueryResponse.getBeans(SummaryItemIndex.class);
                }
                logger.info("*********************[将当前的资源全部更新为过期的资源]************************");
                
            }
            catch (IOException | SolrServerException e)
            {
                logger.error("根据汇总查询资源索引失败！");
                e.printStackTrace();
            }
        }
    }
    /**
     * @description: 封装查询条件
     * @param itemIndexQueryParams
     * @return
     * @author： wangchong
     * @createTime：2016年1月6日 下午2:12:46
     */
    private SolrQuery assembleQuery(ItemIndexQueryParam itemIndexQueryParams,List<ItemIndexSortParam> itemIndexSortParams)
    {
        List<String> queryList = new ArrayList<String>();
        List<String> filterQueryList = new ArrayList<String>();

        if (itemIndexQueryParams != null)
        {
            if (StringUtils.hasText(itemIndexQueryParams.getAppResourceId()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement( ItemIndexFilterConstant.APPRESOURCEID, itemIndexQueryParams.getAppResourceId().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (StringUtils.hasText(itemIndexQueryParams.getAppId()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.APPID, itemIndexQueryParams.getAppId().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (StringUtils.hasText(itemIndexQueryParams.getBusinessCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.BUSSINESSCODE, itemIndexQueryParams.getBusinessCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getFirstCategoryCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.FIRSTCATEGORYCODE, itemIndexQueryParams.getFirstCategoryCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getFirstCategoryCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.FIRSTCATEGORYCODE, itemIndexQueryParams.getFirstCategoryCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getSecondCategoryCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.SECONDCATEGORYCODE, itemIndexQueryParams.getSecondCategoryCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getSecondCategoryCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.SECONDCATEGORYCODE, itemIndexQueryParams.getSecondCategoryCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getThirdCategoryCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.THIRDCATEGORYCODE, itemIndexQueryParams.getThirdCategoryCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getThirdCategoryCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.THIRDCATEGORYCODE, itemIndexQueryParams.getThirdCategoryCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getSpecCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.SPECCODE, itemIndexQueryParams.getSpecCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getCategoryName()))
            {
                List<String> statementList = new ArrayList<String>();
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.FIRSTCATEGORYNAME, itemIndexQueryParams.getCategoryName()));
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.SECONDCATEGORYNAME, itemIndexQueryParams.getCategoryName()));
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.THIRDCATEGORYNAME, itemIndexQueryParams.getCategoryName()));
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.CATEGORYALIAS, itemIndexQueryParams.getCategoryName()));

                String queryStatement = SolrStatementUtils.generateOrQueryByList(statementList);
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if(CollectionUtils.isNotEmpty(itemIndexQueryParams.getCategoryNames()))
            {
                List<String> statementList = new ArrayList<String>();

                for(String categoryName : itemIndexQueryParams.getCategoryNames())
                {
                    if(StringUtils.hasText(categoryName))
                    {
                        statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.FIRSTCATEGORYNAME, categoryName));
                        statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.SECONDCATEGORYNAME, categoryName));
                        statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.THIRDCATEGORYNAME, categoryName));
                        statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.CATEGORYALIAS, categoryName));
                    }
                }

                String queryStatement = SolrStatementUtils.generateOrQueryByList(statementList);
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getSpecName()))
            {
                List<String> statementList = new ArrayList<String>();
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.SPECNAME, itemIndexQueryParams.getSpecName()));
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.SPECALIAS, itemIndexQueryParams.getSpecName()));
                statementList.add(SolrStatementUtils.generateBlurMatchStatement(ItemIndexFilterConstant.SPECNAME, itemIndexQueryParams.getSpecName().replace("Φ", "")));
                statementList.add(SolrStatementUtils.generateBaseMatchStatement(ItemIndexFilterConstant.SPECSEARCHNAME, itemIndexQueryParams.getSpecName().replace("Φ", "") + "*"));
                String queryStatement = SolrStatementUtils.generateOrQueryByList(statementList);
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getSpecCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.SPECCODE, itemIndexQueryParams.getSpecCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getSpecNames()))
            {
                List<String> specNames = new ArrayList<String>();

                for(String specName : itemIndexQueryParams.getSpecNames())
                {
                    if(StringUtils.hasText(specName))
                    {
                        specNames.add(specName);
                        specNames.add(specName.replace("Φ", ""));
                    }
                }

                String queryStatement = SolrStatementUtils.generateOrQueryByBlurValues(ItemIndexFilterConstant.SPECNAME, specNames);
                if (StringUtils.hasText(queryStatement))
                {
                    queryList.add(queryStatement);
                }
            }
            if((itemIndexQueryParams.getStartThickness() != null && itemIndexQueryParams.getStartThickness() > 0 )|| (itemIndexQueryParams.getEndThickness() != null && itemIndexQueryParams.getEndThickness() > 0))
            {
                Double startThickness = null;
                Double endThickness = null;

                if(itemIndexQueryParams.getStartThickness() != null && itemIndexQueryParams.getStartThickness() > 0)
                {
                    startThickness = itemIndexQueryParams.getStartThickness();
                }

                if(itemIndexQueryParams.getEndThickness() != null && itemIndexQueryParams.getEndThickness() > 0)
                {
                    endThickness = itemIndexQueryParams.getEndThickness();
                }
                String queryStatement = SolrStatementUtils.generateRangeMatchStatement(ItemIndexFilterConstant.THICKNESS, startThickness, endThickness);
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if((itemIndexQueryParams.getStartWidth() != null &&itemIndexQueryParams.getStartWidth() >0) || (itemIndexQueryParams.getEndWidth() != null && itemIndexQueryParams.getEndWidth() >0 ))
            {
                Double startWidth = null;
                Double endwidth = null;

                if(itemIndexQueryParams.getStartWidth() != null &&itemIndexQueryParams.getStartWidth() >0)
                {
                    startWidth = itemIndexQueryParams.getStartWidth();
                }

                if(itemIndexQueryParams.getEndWidth()!= null && itemIndexQueryParams.getEndWidth() > 0)
                {
                    endwidth = itemIndexQueryParams.getEndWidth();
                }
                String queryStatement = SolrStatementUtils.generateRangeMatchStatement(ItemIndexFilterConstant.WIDTH, startWidth, endwidth);
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if((itemIndexQueryParams.getStartLength() != null && itemIndexQueryParams.getStartLength() > 0) || (itemIndexQueryParams.getEndLength() != null && itemIndexQueryParams.getEndLength() > 0))
            {
                Double startLength = null;
                Double endLength = null;

                if(itemIndexQueryParams.getStartLength() != null && itemIndexQueryParams.getStartLength() > 0)
                {
                    startLength = itemIndexQueryParams.getStartLength();
                }

                if(itemIndexQueryParams.getEndLength() != null && itemIndexQueryParams.getEndLength() > 0)
                {
                    endLength = itemIndexQueryParams.getEndLength();
                }
                String queryStatement = SolrStatementUtils.generateRangeMatchStatement(ItemIndexFilterConstant.LENGTH, startLength, endLength);
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if((itemIndexQueryParams.getStartPrice()!= null && itemIndexQueryParams.getStartPrice() > 0)|| (itemIndexQueryParams.getEndPrice() != null && itemIndexQueryParams.getEndPrice() > 0))
            {
                Long startPrice = null;
                Long endPrice = null;

                if(itemIndexQueryParams.getStartPrice()!= null && itemIndexQueryParams.getStartPrice() > 0)
                {
                    startPrice = itemIndexQueryParams.getStartPrice();
                }

                if(itemIndexQueryParams.getEndPrice()!= null && itemIndexQueryParams.getEndPrice() > 0)
                {
                    endPrice = itemIndexQueryParams.getEndPrice();
                }

                String queryStatement = SolrStatementUtils.generateLongRangeMatchStatement(ItemIndexFilterConstant.PRICE, startPrice, endPrice);
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getMaterialCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.MATERIALCODE, itemIndexQueryParams.getMaterialCode().trim());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getMaterialName()))
            {
                String queryStatement = SolrStatementUtils .generateBlurMatchStatement(ItemIndexFilterConstant.MATERIALNAME, itemIndexQueryParams.getMaterialName().trim());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getMaterialCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.MATERIALCODE, itemIndexQueryParams.getMaterialCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getMaterialNames()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByBlurValues(ItemIndexFilterConstant.MATERIALNAME, itemIndexQueryParams.getMaterialNames());
                if (StringUtils.hasText(queryStatement))
                {
                    queryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getFactoryCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.FACTORYCODE, itemIndexQueryParams.getFactoryCode());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getFactoryName()))
            {
                String queryStatement = SolrStatementUtils .generateBlurMatchStatement(ItemIndexFilterConstant.FACTORYNAME, itemIndexQueryParams.getFactoryName());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getFactoryCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.FACTORYCODE, itemIndexQueryParams.getFactoryCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getFactoryNames()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.FACTORYNAME, itemIndexQueryParams.getFactoryNames());
                if (StringUtils.hasText(queryStatement))
                {
                    queryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getAreaCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.AREACODE, itemIndexQueryParams.getAreaCode());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getAreaName()))
            {
                String queryStatement = SolrStatementUtils .generateBlurMatchStatement(ItemIndexFilterConstant.AREANAME, itemIndexQueryParams.getAreaName());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getWarehouseCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.WAREHOUSECODE, itemIndexQueryParams.getWarehouseCode());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getWarehouseName()))
            {
                String warehouseName = itemIndexQueryParams.getWarehouseName();

                if (warehouseName.contains("(") && warehouseName.contains(")"))
                {
                    warehouseName = warehouseName.replace("(", "").replace(")", "");
                }
                else
                {
                    if (warehouseName.contains("（") && warehouseName.contains("）"))
                    {
                        warehouseName = warehouseName.replace("（", "").replace("）", "");
                    }
                }

                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.WAREHOUSESEARCHNAME, warehouseName.trim());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getWarehouseCodes()))
            {
                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.WAREHOUSECODE, itemIndexQueryParams.getWarehouseCodes());
                if (StringUtils.hasText(queryStatement))
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if (CollectionUtils.isNotEmpty(itemIndexQueryParams.getWarehouseNames()))
            {
                List<String> warehouseNames = new ArrayList<String>();

                for(String warehouseName : warehouseNames)
                {
                    if (warehouseName.contains("(") && warehouseName.contains(")"))
                    {
                        warehouseName = warehouseName.replace("(", "").replace(")", "");
                    }
                    else
                    {
                        if (warehouseName.contains("（") && warehouseName.contains("）"))
                        {
                            warehouseName = warehouseName.replace("（", "").replace("）", "");
                        }
                        else
                        {
                            warehouseName = SolrStatementUtils.generateBlurValue(warehouseName);
                        }
                    }

                    warehouseNames.add(warehouseName);
                }

                String queryStatement = SolrStatementUtils.generateOrQueryByValues(ItemIndexFilterConstant.WAREHOUSESEARCHNAME, warehouseNames);
                if (StringUtils.hasText(queryStatement))
                {
                    queryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getSummaryCode()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.SUMMARYCODE, itemIndexQueryParams.getSummaryCode());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getPackNo()))
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.PACKNO, itemIndexQueryParams.getPackNo());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getSellMemberName()))
            {
                String queryStatement = SolrStatementUtils .generateBlurMatchStatement(ItemIndexFilterConstant.SELLMEMBERNAME, itemIndexQueryParams.getSellMemberName());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if(itemIndexQueryParams.getSellMemberId() != null)
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.SELLMEMBERID, itemIndexQueryParams.getSellMemberId());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(StringUtils.hasText(itemIndexQueryParams.getShopName()))
            {
                String queryStatement = SolrStatementUtils .generateBlurMatchStatement(ItemIndexFilterConstant.SHOPNAME, itemIndexQueryParams.getShopName());
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
            if(itemIndexQueryParams.getShopId() != null)
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.SHOPID, itemIndexQueryParams.getShopId());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            if(itemIndexQueryParams.getIsOutDate() != null)
            {
                String queryStatement = SolrStatementUtils .generateBaseMatchStatement(ItemIndexFilterConstant.ISOUTDATE, itemIndexQueryParams.getIsOutDate());
                if (queryStatement != null)
                {
                    filterQueryList.add(queryStatement);
                }
            }
            //关键字匹配
            if(StringUtils.hasText(itemIndexQueryParams.getKeyword()))
            {
                Map<String, String> caseMap = new HashMap<String, String>();
                caseMap.put(ItemIndexFilterConstant.FIRSTCATEGORYNAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.SECONDCATEGORYNAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.THIRDCATEGORYNAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.SPECNAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.MATERIALNAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.WAREHOUSENAME, itemIndexQueryParams.getKeyword());
                caseMap.put(ItemIndexFilterConstant.KEYWORD, itemIndexQueryParams.getKeyword());

                String queryStatement = SolrStatementUtils.generateOrMatchStatement(caseMap);
                if (queryStatement != null)
                {
                    queryList.add(queryStatement);
                }
            }
        }

        String queryStatement = SolrStatementUtils .generateAndQueryByList(queryList);
        SolrQuery solrQuery = new SolrQuery(queryStatement);

        for (String filterQuery : filterQueryList)
        {
            solrQuery.addFilterQuery(filterQuery);
        }

        if (CollectionUtils.isNotEmpty(itemIndexSortParams))
        {
            for (ItemIndexSortParam itemsort : itemIndexSortParams)
            {
                if (itemsort != null)
                {
                    long sortType = itemsort.getSortType().getValue();

                    if (sortType == 2)
                    {
                        solrQuery.addSortField(itemsort.getSortField().getFieldName(), SolrQuery.ORDER.desc);
                    }
                    else
                    {
                        solrQuery.addSortField(itemsort.getSortField().getFieldName(), SolrQuery.ORDER.asc);
                    }
                }
            }
        }

        return solrQuery;
    }
}

 

学习过程中，非常感谢http://www.cnblogs.com/HD/p/3977799.html博客，很大内容实例都有参照，非常滴感谢。

http://www.cnblogs.com/ibook360/archive/2011/11/02/2232875.html 

http://www.cnblogs.com/luxiaoxun/p/4442770.html  关于solr的网址