solr配置hbase solr实战

项目需求

使用Solr模拟京东站内的商品搜索功能，要求满足如下需求：

1. 可以根据关键字搜索商品信息；
2. 可以根据商品分类和价格过滤搜索结果；
3. 可以根据价格排序
4. 如果你有精力的话，还可以实现基本的分页功能，但很遗憾的是这里暂不实现分页。

最后你要达成的界面效果如下图所示。

项目环境搭建

下面，我画出了该项目的系统架构图。

仔细看完上面这张系统架构图之后，问在该项目中是不是要整合Spring、SpringMVC以及MyBatis这三大框架？显然不是，因为此时并不需要去MySQL数据库中查询，而是发起一个检索请求去索引库中查询。其实，在该项目中，我们要整合的只是SpringMVC和SolrJ。但不管如何，我们都需要自己开发Controller层（即表现层）、Service层（即业务层）以及Dao层，每一层要做的事情如下列表所示。

接下来，我们就要开始搭建开发环境了。大家可以按如下步骤来一步一步搭建。

• 第一步：创建一个动态的web工程，例如jd。
• 第二步：向web工程中导入jar包。你不仅要问，应该导入哪些jar包呢？由于在该工程中，我们只需要整合SpringMVC和SolrJ，因此，首先导入与SpringMVC相关的jar包，然后再导入SolrJ核心jar包（即solr-solrj-8.4.0.jar）和该核心jar包所依赖的那些jar包。
• 第三步：在web工程的src目录下新建SpringMVC的核心配置文件，即springmvc.xml，该文件的内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 配置扫描基本包（主要是扫描类上的注解，例如@Controller、@Service、@Repository） -->
    <context:component-scan base-package="com.meimeixia" />
    
    <!-- 
        配置注解驱动，相当于同时使用了最新的处理器映射器和处理器适配器，须知处理器映射器和处理器适配器必须配套使用！
        注解驱动还能对json数据的响应提供支持。
    -->
    <mvc:annotation-driven />
    
    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    
    <!-- 配置SolrJ，供Dao层（即数据访问层）检索数据使用 -->
    <bean id="solrClient" class="org.apache.solr.client.solrj.impl.HttpSolrClient">
        <constructor-arg value="http://localhost:8080/solr/collection1" name="builder" />
    </bean>
</beans>

大家有没有看到SpringMVC整合SolrJ时，是像下面这样配置的。

<!-- 配置SolrJ，供Dao层（即数据访问层）检索数据使用 -->
<bean id="solrClient" class="org.apache.solr.client.solrj.impl.HttpSolrClient">
    <constructor-arg value="Solr Core的远程地址" name="builder" />
</bean>

而SpringMVC整合更早期版本的SolrJ（例如Solr 4.10.3），是像下面这样配置的。

<bean class="org.apache.solr.client.solrj.impl.HttpSolrServer" id="solrServer">
    <constructor-arg value="Solr Core的远程地址" />
</bean>

对比发现，由于Solr版本不断在更新，由Spring容器管理的HttpSolrServer变成了HttpSolrClient，而且之前的构造方法已经修改，以前的构造方法注入将不再适用，主要由一个静态类builder来构造，而builder需要一个baseUrl。

• 第四步：修改web.xml配置文件，将其修改成下面这样。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
    <display-name>jd</display-name>
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.html</welcome-file>
        <welcome-file>default.htm</welcome-file>
        <welcome-file>default.jsp</welcome-file>
    </welcome-file-list>
    <!-- 使用Spring提供的CharacterEncodingFilter过滤器解决post请求的中文乱码问题 -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- 配置前端控制器 -->
    <servlet>
        <servlet-name>jd</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 加载SpringMVC的核心配置文件 -->
        <init-param>
            <!-- 指定SpringMVC核心配置文件的路径。如果不指定，默认为/WEB-INF/${servlet-name}-servlet.xml -->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>jd</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>
</web-app>

从以上web.xml配置文件中可以看出，除了配置SpringMVC的前端控制器之外，还配置了一个Spring提供的CharacterEncodingFilter过滤器，以此来解决post请求的中文乱码问题。

• 第五步：拷贝样式文件和商品图片到该web工程中。你不仅就要问了，这些资源从哪儿获取呢？中下载。 有一点需要大家注意，由于商品图片非常的多，所以不要直接就将其拷贝到Eclipse开发工具下的web工程中，不然的话，极有可能会把Eclipse开发工具整崩溃掉。
  
  取而代之的是找到该web工程在本地存放的位置，然后再将商品图片和样式文件拷贝到该目录下。
  
  接着，在Eclipse开发工具中刷新一下该web工程，此时，商品图片和样式文件将会出现于该web工程下。这里咱们就先这样做，但我还得说一嘴，在实际开发中，将会有一个专门的服务器用于存储资源，例如图片。

前端实现

将从以上百度网盘地址下载下来的商品列表显示页面（即product_list.jsp）拷贝到工程的WebContent/WEB-INF/jsp目录下，没有该目录则自行创建。

打开该页面，你会发现它里面的内容非常多，导致无从看起。虽然如此，但你也要抓住一个重点，该重点就是如下这个表单。

可以清楚地看到前端提供的后端查询所需要的参数：

• 关键词，参数名为queryString
• 商品分类，参数名为catalog_name，在表单中是一个隐藏字段
• 商品价格，参数名为catalog_price，在表单中也是一个隐藏字段
• 价格排序，参数名为sort，在表单中同样也是一个隐藏字段

该页面中还有一个地方需要引起我们的重视，仔细查看商品列表显示的HTML代码，可以知道后端需要返回给前端页面一个商品的集合（列表）。

前端页面我也只能分析到此了，感觉用语言无法完整地阐述我要表达的意思，可能需要你自己慢慢去体会。要是你不想废脑子，直接拷贝该页面到工程中就行了，开箱即可食用！

后台实现

Dao层

由于需要将从索引库中查询出来的商品信息封装到一个对象中，所以要创建一个商品对象模型。于是，在src目录下新建一个名为com.meimeixia.jd.pojo的包，并在该包下新建如下一个实体类，该类就表示一个商品对象模型。

package com.meimeixia.jd.pojo;

/**
 * 商品对象模型
 * @author liayun
 *
 */
public class ProductModel {
	// 商品编号
	private String pid;
	// 商品名称
	private String name;
	// 商品分类名称
	private String catalog_name;
	// 价格
	private float price;
	// 商品描述
	private String description;
	// 图片名称
	private String picture;
	
	get/set方法...
	
}

接着，我们就要正式开始编写Dao层的实现代码了。前面我就已经讲过，Dao层所要做的事情，即Dao层的功能就是接收Service层传递过来的参数，根据参数查询索引库，并返回查询结果，很明显查询结果是一个商品列表（即List<ProductModel>）。

既然知道了Dao层的功能，那么就很容易写出该层的实现代码了。首先，在src目录下新建一个名为com.meimeixia.jd.dao的包，并在该包下新建一个接口，例如JdDao.java。

package com.meimeixia.jd.dao;

import java.util.List;

import com.meimeixia.jd.pojo.ProductModel;

public interface JdDao {
	
	// 通过Service层传递过来的参数来查询对应的商品结果集
	public List<ProductModel> selectProductModelListByQuery(String queryString, String catalog_name, String price,
		String sort) throws Exception;
	
}

然后，再在该包下新建以上接口的一个实现类，例如JdDaoImpl.java。

package com.meimeixia.jd.dao;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrQuery.ORDER;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.meimeixia.jd.pojo.ProductModel;

@Repository
public class JdDaoImpl implements JdDao {
	
	// 查询索引库
	@Autowired
	private SolrClient solrClient;

	// 通过Service层传递过来的参数来查询对应的商品结果集
	public List<ProductModel> selectProductModelListByQuery(String queryString, String catalog_name, 
			String price, String sort) throws Exception {
		SolrQuery solrQuery = new SolrQuery(); 
		// 设置查询条件
		solrQuery.setQuery(queryString);
		// 过滤条件（即根据商品分类进行过滤）
		if (null != catalog_name && !"".equals(catalog_name)) {
			solrQuery.set("fq", "product_catalog_name:" + catalog_name);
		}
		// 过滤条件（即按价格区间进行搜索）
		if (null != price && !"".equals(price)) {
			// 传递过来的price参数的值有可能是"0-9"或者"50-*"(50以上)
			String[] p = price.split("-");
			solrQuery.set("fq", "product_price:[" + p[0] + " TO " + p[1] + "]");
		}
		// 如果传递过来的sort参数的值为1，那么按照价格进行降序排序
		if ("1".equals(sort)) {
			solrQuery.addSort("product_price", ORDER.desc); // 其实，这句代码也可以写成solrQuery.addSort("product_price desc")这样
		} else {
			solrQuery.addSort("product_price", ORDER.asc);
		}
		// 分页
		solrQuery.setStart(0); // 从第几条记录开始
		solrQuery.setRows(16); // 返回结果最多有多少条记录
		// 指定默认搜索域（复制域）
		solrQuery.set("df", "product_keywords");
		// 指定只查询指定域（你不是有5、6个域吗，但是我只想要2个域，行不行？）
		solrQuery.set("fl", "id,product_name,product_price,product_picture");
		// 高亮
		// 1. 首先开启高亮开关
		solrQuery.setHighlight(true);
		// 2. 指定高亮的域
		solrQuery.addHighlightField("product_name");
		// 3. 设置高亮前缀
		solrQuery.setHighlightSimplePre("<span style='color:red'>");
		// 4. 设置高亮后缀
		solrQuery.setHighlightSimplePost("</span>");
		
		// 执行查询
		QueryResponse response = solrClient.query(solrQuery); // query方法中需要传入的参数是一个SolrParams抽象类，
                                                              // 而SolrQuery就是其一个实现子类，所以，这里传入一个SolrQuery对象
		// 获取文档结果集
		SolrDocumentList docs = response.getResults();
		
		// 获取高亮显示的结果集，高亮显示的结果集和查询结果集是分开放的
		Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();
		// 第一个Map：key为id，value为Map 
		// 第二个Map：key为域名，value为List 
		// List里面可以多个，但本次是一个，即list.get(0)
		
		// 总条数
		long numFound = docs.getNumFound();
		
		List<ProductModel> productModels = new ArrayList<ProductModel>();
		// 遍历
		for (SolrDocument doc : docs) {
			ProductModel productModel = new ProductModel();
			productModel.setPid((String) doc.get("id"));
			productModel.setPrice((Float) doc.get("product_price"));
			productModel.setPicture((String) doc.get("product_picture"));
			
			// 商品名称需要高亮显示
			String productName = "";
			Map<String, List<String>> map = highlighting.get(doc.get("id"));
			List<String> list = map.get("product_name");
			if (null != list && list.size() > 0) {
				productName = list.get(0);
			} else {
				productName = (String) doc.get("product_name");
			}
			productModel.setName(productName);
			productModels.add(productModel);
		}
		
		return productModels;
	}
	
}

对于以上实现类中的代码，我不再进行过多的阐述，你看得懂也好，看不懂也罢，那是你自己的事情。不懂，说明你没有仔细看我前面写的博客！

Service层

还记得前面我所讲的Service层要做的事情吗？即接收Controller层传递过来的参数，根据参数拼装一个查询条件，然后调用Dao层方法，查询商品列表并返回。

你想一想，是不是应该像这样编写Service层的实现代码。首先，在src目录下新建一个名为com.meimeixia.jd.service的包，并在该包下新建一个接口，例如JdService.java。

package com.meimeixia.jd.service;

import java.util.List;

import com.meimeixia.jd.pojo.ProductModel;

public interface JdService {

	// 通过Controller层传递过来的参数来查询对应的商品结果集
	public List<ProductModel> selectProductModelListByQuery(String queryString, String catalog_name, String price,
			String sort) throws Exception;

}

然后，再在该包下新建以上接口的一个实现类，例如JdServiceImpl.java。

package com.meimeixia.jd.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.meimeixia.jd.dao.JdDao;
import com.meimeixia.jd.pojo.ProductModel;

@Service
public class JdServiceImpl implements JdService {
	
	@Autowired
	private JdDao jdDao;

	@Override
	public List<ProductModel> selectProductModelListByQuery(String queryString, String catalog_name, String price,
			String sort) throws Exception {
		return jdDao.selectProductModelListByQuery(queryString, catalog_name, price, sort);
	}
	
}

可以看到Service层也就调用了一下Dao层就完成了查询商品列表的功能。

Controller层

还记得前面我所讲的Controller层要做的事情吗？即接收页面传递过来的参数，然后调用Service层查询商品列表，最后将查询结果返回给jsp页面，并且还需要回显查询参数。

那么Controller层的实现代码又该怎样写呢？你想一想，是不是应该像这样写。在src目录下新建一个名为com.meimeixia.jd.controller的包，并在该包下新建一个类，例如JdController.java。

package com.meimeixia.jd.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import com.meimeixia.jd.pojo.ProductModel;
import com.meimeixia.jd.service.JdService;

/**
 * 查询商品列表
 * @author liayun
 *
 */
@Controller
public class JdController {
	
	@Autowired
	private JdService jdService;
	
	// 查询商品列表
	@RequestMapping(value = "list")
	public String list(String queryString, String catalog_name, String price,
			String sort, Model model) throws Exception {
		// 通过页面传递过来的参数来查询对应的商品结果集
		List<ProductModel> productModels = jdService.selectProductModelListByQuery(queryString, catalog_name, price, sort);
		model.addAttribute("productModels", productModels);
		// 回显查询参数
		model.addAttribute("queryString", queryString);
		model.addAttribute("catalog_name", catalog_name);
		model.addAttribute("price", price);
		model.addAttribute("sort", sort);
		return "product_list";
	}
	
}

测试

工程开发好之后，就要进行测试了。测试时，要注意一个问题，那就是要保证部署Solr服务的Tomcat服务器和检索Solr服务中数据的Tomcat服务器（也就是部署工程的Tomcat服务器），它们俩的端口号不能发生冲突，否则就会出现端口冲突的问题，工程也就运行不起来了。

从下图可以看出，本人这里部署Solr服务的Tomcat服务器的端口号是8080。

也就是说，如果要将工程部署在Tomcat服务器上，那么就不能再占用8080这个端口号了。所以，当我们将工程部署在本地Tomcat服务器上时，需要修改端口号，以避免端口号占用冲突的问题。大家可以按照下图所示的步骤借助Eclipse开发工具来修改端口号。

至此，启动部署工程的Tomcat服务器，在Google Chrome浏览器地址栏中输入http://localhost:8083/jd/list.action这样的url地址进行访问，然后在搜索框中以"台灯"为关键字进行搜索，你大概就能看到如下图所示的效果了。

当然了，你还可以按照商品类别、商品价格进行过滤，甚至按照商品价格进行排序。但在这里，我就不演示了，大概都是好使的！