Solr学习(一)Solr服务器的搭建与使用

曾经终败给现在 2022-04-12 05:09 425阅读 0赞

# 1、什么是solr #

Solr是apache的顶级开源项目，它是使用java开发 ，基于lucene的全文检索服务器。Solr比lucene提供了更多的查询语句，而且它可扩展、可配置，同时它对lucene的性能进行了优化。

*Solr是如何实现全文检索的呢？*

***索引流程**：solr客户端（浏览器、java程序）可以向solr服务端发送POST请求，请求内容是包含Field等信息的一个xml文档，通过该文档，solr实现对索引的维护（增删改）*

***搜索流程**：solr客户端（浏览器、java程序）可以向solr服务端发送GET请求，solr服务器返回一个xml文档。*

**Solr和lucene的区别**

*Lucene是一个全文检索引擎工具包，它只是一个jar包，不能独立运行，对外提供服务。solr是一个全文检索服务器，它可以单独运行在servlet容器，可以单独对外提供搜索和索引功能。Solr比lucene在开发全文检索功能时，更快捷、更方便。*

# 2、Solr服务搭建 #

## 2.1 Solr的环境 ##

①Solr是java开发，需要安装jdk

②安装环境Linux

③安装Tomcat运行Solr

## 2.2 搭建步骤 ##

第一步：把solr 的压缩包上传到Linux系统；（下载链接：[Solr官网下载链接][Solr]）

第二步：解压solr（使用tar -zxvf命令）

第三步：安装tomcat，解压缩即可

第四步：把solr-4.10.3/example/webapps/solr.war部署到Tomcat的webapps目录下

![20181201154022751.png][]

第五步：解压缩war包,启动Tomcat解压,之后将war包删除

第六步：把solr-4.10.3/example/lib/ext目录下的所有的jar包，添加到solr工程,WEB-INF/lib中

[root@localhost ext]# pwd
    
    /root/solr-4.10.3/example/lib/ext
    
    [root@localhost ext]# cp * /usr/local/solr/tomcat/webapps/solr/WEB-INF/lib/

第七步：创建一个solrhome

solr-4.10.3/example/solr目录就是一个solrhome，复制此目录到/usr/local/solr/solrhome

[root@localhost example]# pwd
    
    /root/solr-4.10.3/example
    
    [root@localhost example]# cp -r solr /usr/local/solr/solrhome
    
    [root@localhost example]#

solrhome目录中的内容：

![20181201153658336.png][]

第八步：关联solr及solrhome。需要修改solr工程的web.xml文件。  
![2018120115391580.png][]

第九步：启动Tomcat，访问solr管理页面

[http://192.168.25.154:8080/solr][http_192.168.25.154_8080_solr]

linux中的配置方法和windows下的配置完全一样。

## 2.3 配置业务域 ##

创建对应的业务域。需要制定中文分析器。

创建步骤：

第一步：把中文分析器添加到工程中。

1.  把IKAnalyzer2012FF\_u1.jar添加到solr工程的lib目录下
2.  把扩展词典（ext.dic）、停用词典（stopword.dic）、配置文件（IKAnalyzer.cfg.xml）放到solr工程的WEB-INF/classes目录下。

IKAnalyzer.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd"> 
    <properties> 
           <comment>IK Analyzer 扩展配置</comment>
           
           <entry key="ext_dict">ext.dic;</entry>
           
           <entry key="ext_stopwords">stopword.dic;</entry>
    </properties>

Stopword.dic:遇到如下的单词中文分词器就会忽略，因为这些词语没有什么意义

a
    an
    and
    are
    as
    at
    be
    but
    by
    for
    if
    in
    into
    is
    it
    no
    not
    of
    on
    or
    such
    that
    the
    their
    then
    there
    these
    they
    this
    to
    was
    will
    with

ext.dic：中文分词器遇到下面的特殊词汇，不会进行分词，而是当做一个整体，因此在这个文件中配置一些特殊词汇

全文搜索
    刘周健

第二步：配置一个FieldType，制定使用IKAnalyzer

修改/solrhome/collection1/conf的schema.xml文件，添加FieldType：

第三步：配置业务域，type制定使用自定义的FieldType。

设置业务系统Field

第四步：重启tomcat

第五步：验证是否配置正确

选择->collection1->Analysis

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3VqaWFuX0xpdQ_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3VqaWFuX0xpdQ_size_16_color_FFFFFF_t_70 1][]

可以看到之前配置的中文分词器和Field都生效了！

# 3 将数据库中的数据导入solr服务器 #

第一种方式：配置dataimport插件

第二种方式：采用solrJ导入（推荐）

这里采用第二种方式将数据库中的数据导入solr服务器

①创建Maven项目，在pom文件中导入SolrJ

<dependency>
                <groupId>org.apache.solr</groupId>
                <artifactId>solr-solrj</artifactId>
                <version>4.10.3</version>
    </dependency>

pom文件如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>taotao-search</artifactId>
            <groupId>com.taotao</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>taotao-search-service</artifactId>
        <packaging>war</packaging>
        <dependencies>
             
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jms</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.apache.solr</groupId>
                <artifactId>solr-solrj</artifactId>
                <version>${solrj.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
            </dependency>
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper</artifactId>
                <version>5.1.2</version>
            </dependency>
        </dependencies>
        
        <build>
            <resources>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.properties</include>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>false</filtering>
                </resource>
                
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*.properties</include>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>false</filtering>
                </resource>
            </resources>
        </build>
    </project>

在父工程中定义了Spring的版本：

<spring.version>4.2.4.RELEASE</spring.version>

②创建mapper层,将数据库中的数据取出来

pojo:实现序列化结果可以在网络中传输

public class SearchItem implements Serializable {
        private String id;
        private String title;
        private String sell_point;
        private long price;
        private String image;
        private String category_name;
        private String item_desc;
        getters and setters...

接口：

public interface SearchItemMapper {
    	/**
    	 * 获取索引信息
    	 * @return
    	 */
    	public List<SearchItem> getSearchItemList();
    }

mapper文件：

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    <mapper namespace="com.taotao.search.mapper.SearchItemMapper" >
    	<select id="getSearchItemList" resultType="com.taotao.common.pojo.SearchItem">
    		SELECT
    			tb_item.id id,
    			title,
    			sell_point,
    			price,
    			image,
    			NAME category_name,
    			item_desc
    		FROM
    			tb_item,
    			tb_item_cat,
    			tb_item_desc
    		WHERE
    			cid = tb_item_cat.id
    		AND tb_item.id = tb_item_desc.item_id
    		AND tb_item.`status` = 1
    	</select>
    </mapper>

③service层业务：将数据库中的数据查询出来，再通过solrInputDocument将数据添加到Solr服务器中

@Service
    public class SearchItemServiceImpl implements SearchItemService {
        @Autowired
        private SearchItemMapper searchItemMapper;
        @Autowired
        private SolrServer solrServer;
    
        @Override
        public TaotaoResult importAllItems() throws Exception{
            // 1、查询所有商品数据。
            List<SearchItem> itemList = searchItemMapper.getSearchItemList();
            // 2、创建一个SolrServer对象。
            // 3、为每个商品创建一个SolrInputDocument对象。
            for (SearchItem searchItem : itemList) {
                SolrInputDocument document = new SolrInputDocument();
                // 4、为文档添加域
                document.addField("id", searchItem.getId());
                document.addField("item_title", searchItem.getTitle());
                document.addField("item_sell_point", searchItem.getSell_point());
                document.addField("item_price", searchItem.getPrice());
                document.addField("item_image", searchItem.getImage());
                document.addField("item_category_name", searchItem.getCategory_name());
                document.addField("item_desc", searchItem.getItem_desc());
                // 5、向索引库中添加文档。
                solrServer.add(document);
            }
            //提交修改
            solrServer.commit();
            // 6、返回TaotaoResult。
            return TaotaoResult.ok();
        }
    
    }

④controller层

@Controller
    public class SearchItemController {
    
        @Autowired
        private SearchItemService searchItemService;
    
        @RequestMapping("/index/import")
        @ResponseBody
        public TaotaoResult importAllItems() {
            try{
                TaotaoResult taotaoResult = searchItemService.importAllItems();
                return taotaoResult;
            } catch (Exception e) {
                e.printStackTrace();
                return TaotaoResult.build(500, "导入数据失败！");
            }
        }
    }

依赖的配置文件：

mybatis/SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
    		PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    		"http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    	
    	<plugins>
    		<plugin interceptor="com.github.pagehelper.PageInterceptor">
    			
    			
    			
    		</plugin>
    	</plugins>
    </configuration>

resources/db.properties

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/taotao?characterEncoding=utf-8
    jdbc.username=root
    jdbc.password=123

spring/applicationContent-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
    	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
    	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">
    	
    	
    	
    	<context:property-placeholder location="classpath:properties/*.properties" />
    	
    	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
    		destroy-method="close">
    		<property name="url" value="${jdbc.url}" />
    		<property name="username" value="${jdbc.username}" />
    		<property name="password" value="${jdbc.password}" />
    		<property name="driverClassName" value="${jdbc.driver}" />
    		<property name="maxActive" value="10" />
    		<property name="minIdle" value="5" />
    	</bean>
    	
    	
    	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    		
    		<property name="dataSource" ref="dataSource" />
    		
    		<property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml" />
    	</bean>
    	
    	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    		<property name="basePackage" value="com.taotao.mapper, com.taotao.search.mapper" />
    	</bean>
    	
    </beans>

applicationContent-service.xml

<context:component-scan base-package="com.taotao.search"/>

applicationContent-solr.xml:

<bean id="solrServer" class="org.apache.solr.client.solrj.impl.HttpSolrServer">
    		<constructor-arg name="baseURL" value="http:/192.156.25.154:8080/solr"></constructor-arg>
    	</bean>

# 4 从solr服务器中查询数据 #

pojo:

public class SearchResult implements Serializable {
        private List<SearchItem> itemList;
        private long recordCount;
        private long pageCount;
     ...
    }

searchDao

**
     * 从索引库中取出数据
     */
    @Repository
    public class SearchDao {
    
        @Autowired
        private SolrServer solrServer;
    
        public SearchResult search(SolrQuery query) throws Exception {
            //根据query对象查询索引库
            QueryResponse response = solrServer.query(query);
            //取商品列表
            SolrDocumentList solrDocumentList = response.getResults();
            //商品列表
            List<SearchItem> itemList = new ArrayList<>();
            for (SolrDocument solrDocument : solrDocumentList) {
                SearchItem item = new SearchItem();
                item.setId((String) solrDocument.get("id"));
                item.setCategory_name((String) solrDocument.get("item_category_name"));
                item.setImage((String) solrDocument.get("item_image"));
                item.setPrice((long) solrDocument.get("item_price"));
                item.setSell_point((String) solrDocument.get("item_sell_point"));
                //取高亮显示
                Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();
                List<String> list = highlighting.get(solrDocument.get("id")).get("item_title");
                String itemTitle = "";
                //有高亮显示的内容时。
                if (list != null && list.size() > 0) {
                    itemTitle = list.get(0);
                } else {
                    itemTitle = (String) solrDocument.get("item_title");
                }
                item.setTitle(itemTitle);
                //添加到商品列表
                itemList.add(item);
            }
            SearchResult result = new SearchResult();
            //商品列表
            result.setItemList(itemList);
            //总记录数
            result.setRecordCount(solrDocumentList.getNumFound());
    
            return result;
        }
    }

service

@Service
    public class SearchServiceImpl implements SearchService {
    
        @Autowired
        private SearchDao searchDao;
    
        @Override
        public SearchResult search(String queryString, int page, int rows) throws Exception {
            // 1、创建一个SolrQuery对象。
            SolrQuery query = new SolrQuery();
            // 2、设置查询条件
            query.setQuery(queryString);
            // 3、设置分页条件
            query.setStart((page - 1) * rows);
            query.setRows(rows);
            // 4、需要指定默认搜索域。
            query.set("df", "item_title");
            // 5、设置高亮
            query.setHighlight(true);
            query.addHighlightField("item_title");
            query.setHighlightSimplePre("<em style=\"color:red\">");
            query.setHighlightSimplePost("</em>");
            // 6、执行查询，调用SearchDao。得到SearchResult
            SearchResult result = searchDao.search(query);
            // 7、需要计算总页数。
            long recordCount = result.getRecordCount();
            long pageCount = recordCount / rows;
            if (recordCount % rows > 0) {
                pageCount++;
            }
            result.setPageCount(pageCount);
            // 8、返回SearchResult
            return result;
        }
    }

controller

@Controller
    public class SearchController {
    
        @Value("${SEARCH_PAGE_ROWS}")  //60
        private Integer ROWS;
    
        @Autowired
        private SearchService searchService;
    
        @RequestMapping("/search")
        public String search(@RequestParam(value = "q") String queryString,
                             @RequestParam(defaultValue = "1") Integer page, Model model) throws Exception {
           //对查询条件进行转码
            queryString = new String(queryString.getBytes("iso8859-1"), "utf-8");
    
            SearchResult result = searchService.search(queryString, page, ROWS);
            //传递给页面
            model.addAttribute("query", queryString);
            model.addAttribute("totalPages", result.getPageCount());
            model.addAttribute("itemList", result.getItemList());
            model.addAttribute("page", page);
    
            return "search";
        }
    
    
    }

[Solr]: http://archive.apache.org/dist/lucene/solr/
[20181201154022751.png]: /images/20220412/3e110b5eafe24edfbf626fafcf8da785.png
[20181201153658336.png]: /images/20220412/b770f1e822ab47fcb0aa7b44abb98a0f.png
[2018120115391580.png]: /images/20220412/019f23b78db844ef924defea50bc60e0.png
[http_192.168.25.154_8080_solr]: http://192.168.25.154:8080/solr/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3VqaWFuX0xpdQ_size_16_color_FFFFFF_t_70]: /images/20220412/2b30d8a761284ed2bc58a772a16dacb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3VqaWFuX0xpdQ_size_16_color_FFFFFF_t_70 1]: /images/20220412/4717e8ebeee64b2a982340678798d2f0.png