Solr全文检索（一）

╰+攻爆jí腚メ 2023-06-13 13:28 6阅读 0赞

# 什么是Solr： #

Solrj是什么？

1.1使用Solrj更新索引库

1.2   Solrj删除索引库

1.3： 使用Solrj进行索引库的查询操作：

2.4： Solrj实现查询结果的封装

封装所需要的实体类：

查询结果的封装（

DocumentObjectBinder binder=new DocumentObjectBinder();

//binder.getBean(clazz, solrDoc)

）

2.5  Solrj 实现索引库的更新优化：

实战：Solr  项目JD

3.1创建JD项目（war）

3.2添加项目依赖

3.3配置Spring

3.3.1创建application-dao.xml

3.3.2创建application-service.xml

3.3.3创建springmvc.xml

3.4配置web.xml

3.5功能实现

3.5.1创建Product实体类

3.5.2创建ProductDao接口

3.5.3创建ProductDaoImpl实现类

3.5.4创建ProductService接口

3.5.5创建ProductServiceImpl实现类

3.5.6创建ProductController

--------------------

# 什么是Solr： #

Solr是一个企业级数据检索的服务器，是一个开源的javaee项目。

Http请求给检索服务器提交数据（xml或者json字符串），检索服务器可以把客户端提交的数据进行整理。建立出一个目录索引。

也可以根据客户端的Get请求得到XML或者JSON字符串格式的返回数据

非结构化数据中提取出的然后重新组织的信息，我们称之**索引**

**这便是Solr使用与工作原理：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70][]

# Solrj是什么？ #

Solrj就是访问Solr的API

##    1.1使用Solrj更新索引库 ##

/**
    	 * 更新索引库
    	 */
    	@Test
    	public void updateIndex() {
    		try {
    			//建立和solr服务的链接
    			HttpSolrServer server=new 
    				HttpSolrServer("http://localhost:8080/solr/solrCore");
    			
    			//创建SolrInputDocument对象
    			SolrInputDocument doc=new SolrInputDocument();
    			//给doc对象赋值，封装数据
    			doc.addField("id",999999);
    			doc.addField("product_name", "双11销售女朋友,送男朋友");
    			doc.addField("product_catalog", 44);
    			doc.addField("product_catalog_name", "数码");
    			doc.addField("product_price", 123456.00);
    			doc.addField("product_picture", "1.png");
    			doc.addField("product_description", "买一送一.....");
    			
    			//将文档对象添加索引库
    			server.add(doc);
    			//提交http请求
    			server.commit();
    		} catch (Exception e) {
    			// TODO: handle exception
    			e.printStackTrace();
    		}
    	}

##  1.2   Solrj删除索引库 ##

/****
    	 * 删除索引库
    	 */
    	@Test
    	public void deleteIndex() {
    		try {
    			//建立和solr服务的链接
    			HttpSolrServer server=new 
    				HttpSolrServer("http://localhost:8080/solr/solrCore");
    			//根据id删除
    			server.deleteById("999999");
    			
    			server.commit();
    		} catch (Exception e) {
    			// TODO: handle exception
    		}
    	}

## 1.3： 使用Solrj进行索引库的查询操作： ##

/***
 	 * 索引库查询操作
 	 */
 	@Test
 	public void searchIndex() {
 		try {
 			//建立和solr服务的链接
 			HttpSolrServer server=new 
 				HttpSolrServer("http://localhost:8080/solr/solrCore");
 			
 			//创建SolrQuery对象
 			SolrQuery params=new SolrQuery();
 			
 			//params对象中峰查询参数
 			
 			//封装关键字查询条件q查询
 			//params.set("q", "product_name:花儿朵朵彩色金属门后挂");
 			params.setQuery("花儿朵朵彩色金属门后挂");
 			
 			//封装过滤查询条件，按照商品的类型过滤
 			params.addFilterQuery("product_catalog_name:幽默杂货");
 			//封装过滤查询条件，按照价格区间过滤
 			params.addFilterQuery("product_price:[10 TO 20]");
 			
 			//封装查询结果排序参数
 			params.setSort("product_price",ORDER.desc);
 			
 			//封装分页查询参数
 			params.setStart(8);
 			params.setRows(4);
 			
 			//字段投影(指定需要查询的字段)
 			//params.setFields("id","product_name");
 		
 			//指定默认查询字段
 			params.set("df","product_name");
 			
 			//打开高亮显示效果
 			params.setHighlight(true);
 			//指定需要显示的高亮字段
 			params.addHighlightField("product_name");
 			//指定高亮显示的前缀和后缀
 			params.setHighlightSimplePre("");
 			params.setHighlightSimplePost("");
 			
 			//查询索引库，返回响应结果
 			QueryResponse response=server.query(params);
 			
 			//获得查询到的文档对象集合
 			SolrDocumentList results=response.getResults();
 			
 			//获得高亮数据的集合
 			Map<String, Map<String, List<String>>> 
 				htls = response.getHighlighting();
 			
 			//获得查询到的商品总数
 			long total = results.getNumFound();
 			System.out.println("total="+total);
 			//遍历文档对象集合
 			for(SolrDocument doc:results) {
 				String id=String.valueOf(doc.get("id"));
 				System.out.println(id);
 				
 				String product_name=String.valueOf(doc.get("product_name"));
 				
 				//获取某个商品对应的高亮数据
 				Map<String, List<String>> hls=htls.get(id);
 				//获得某个商品中某个字段对应的高亮数据
 				List<String> lts=hls.get("product_name");
 				if(lts!=null && lts.size()>0) {
 					product_name=lts.get(0);
 				}
 				System.out.println(product_name);
 				System.out.println(doc.get("product_catalog"));
 				System.out.println(doc.get("product_catalog_name"));
 				System.out.println(doc.get("product_price"));
 				System.out.println(doc.get("product_picture"));
 				//System.out.println(doc.get("product_description"));
 				
 				System.out.println("==================================");
 				
 			}
 		} catch (Exception e) {
 			// TODO: handle exception
 			e.printStackTrace();
 		}
 	}

## 2.4： Solrj实现查询结果的封装 ##

### 封装所需要的实体类： ###

package com.bjsxt.pojo;
    
    import org.apache.solr.client.solrj.beans.Field;
    
    /***
     * 商品的实体类
     * @author EDZ
     *
     */
    public class Product {
    
    	@Field
    	private String id;
    	@Field
    	private String product_name;
    	@Field
    	private Integer product_catalog;
    	@Field
    	private String product_catalog_name;
    	@Field
    	private Double product_price;
    	@Field
    	private String product_picture;
    	@Field
    	private String product_description;
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public String getProduct_name() {
    		return product_name;
    	}
    	public void setProduct_name(String product_name) {
    		this.product_name = product_name;
    	}
    	public Integer getProduct_catalog() {
    		return product_catalog;
    	}
    	public void setProduct_catalog(Integer product_catalog) {
    		this.product_catalog = product_catalog;
    	}
    	public String getProduct_catalog_name() {
    		return product_catalog_name;
    	}
    	public void setProduct_catalog_name(String product_catalog_name) {
    		this.product_catalog_name = product_catalog_name;
    	}
    	public Double getProduct_price() {
    		return product_price;
    	}
    	public void setProduct_price(Double product_price) {
    		this.product_price = product_price;
    	}
    	public String getProduct_picture() {
    		return product_picture;
    	}
    	public void setProduct_picture(String product_picture) {
    		this.product_picture = product_picture;
    	}
    	public String getProduct_description() {
    		return product_description;
    	}
    	public void setProduct_description(String product_description) {
    		this.product_description = product_description;
    	}
    	
    	
    	
    }

### 查询结果的封装（ ###

###                DocumentObjectBinder binder=**new** DocumentObjectBinder(); ###

###                 //binder.getBean(clazz, solrDoc) ###

### ） ###

/****
 	 * 实现查询结果的封装
 	 */
 	@Test
 	public void searchIndex2() {
 		try {
 			//建立和solr服务的链接
 			HttpSolrServer server=new 
 				HttpSolrServer("http://localhost:8080/solr/solrCore");
 			
 			//创建SolrQuery对象
 			SolrQuery params=new SolrQuery();
 			
 			//params对象中峰查询参数
 			
 			//封装关键字查询条件q查询
 			//params.set("q", "product_name:花儿朵朵彩色金属门后挂");
 			params.setQuery("花儿朵朵彩色金属门后挂");
 			params.set("df", "product_name");
 			
 		 
 			
 			//打开高亮显示效果
 			params.setHighlight(true);
 			//指定需要显示的高亮字段
 			params.addHighlightField("product_name");
 			//指定高亮显示的前缀和后缀
 			params.setHighlightSimplePre("");
 			params.setHighlightSimplePost("");
 			
 			//查询索引库，返回响应结果
 			QueryResponse response=server.query(params);
 			
 			//获得高亮数据的集合
 			Map<String, Map<String, List<String>>> 
 				htls = response.getHighlighting();
 			
 			//获得查询到的文档对象集合
 			SolrDocumentList results=response.getResults();
 			
 			//创建DocumentObjectBinder对象，实现文档对象绑定
 			DocumentObjectBinder binder=new DocumentObjectBinder();
 			//binder.getBean(clazz, solrDoc)
 			//将文档对象集合转化为实体类对象的集合
 			List<Product> list = binder.getBeans(Product.class, results);
 			for(Product p:list) {
 				String id = p.getId();
 				//获得某个商品对应的高亮数据
 				Map<String, List<String>> hts = htls.get(id);
 				//获得某个商品的某个字段的高亮数据
 				List<String> lts = hts.get("product_name");
 				if(lts!=null&&lts.size()>0) {
 					p.setProduct_name(lts.get(0));
 				}
 				//System.out.println(p.getId());
 				System.out.println(p.getProduct_name());
 				/*System.out.println(p.getProduct_catalog_name());
 				System.out.println(p.getProduct_price());
 				System.out.println(p.getProduct_picture());*/
 				
 			}
 			
 			//list集合中商品对象的name属性是否包含高亮数据
 			//return list;
 			
 			//将文档对象的集合results转化为Product对象的集合
 			/*for(SolrDocument doc:results) {
 				//1 
 				//2
 				//3
 			}*/
 			
 			 
 		} catch (Exception e) {
 			// TODO: handle exception
 			e.printStackTrace();
 		}
 	}

### 2.5  Solrj 实现索引库的更新优化： ###

/***
 	 * 索引库更新优化
 	 */
 	@Test
 	public void updateIndex2() {
 		try {
 			//select * from product where dataupdate between 当前系统日期-24 and 当前系统日期
 			
 			
 			//查询数据库的操作（jdbc，mybatis）
 			//数据库查询到的数据是实体类对象的集合
 			List<Product> list=new ArrayList<Product>();
 			Product p1=new Product();
 			p1.setId("999999");
 			p1.setProduct_name("java高手葵花宝典");
 			p1.setProduct_description("高手训练手册....");
 			p1.setProduct_price(1234.00);
 			p1.setProduct_picture("1.png");
 			
 			
 			Product p2=new Product();
 			p2.setId("777777");
 			p2.setProduct_name("java高手葵花宝典 java高手葵花宝典");
 			p2.setProduct_description("高手训练手册....java高手葵花宝典");
 			p2.setProduct_price(1234.00);
 			p2.setProduct_picture("1.png");
 			
 			list.add(p1);
 			list.add(p2);
 			
 			
 			
 			//建立和solr服务的链接
 			HttpSolrServer server=new 
 				HttpSolrServer("http://localhost:8080/solr/solrCore");
 			 
 			for(Product p:list) {
 				server.addBean(p);
 				//提交http请求
 				server.commit();
 			}
 			
 			
 		} catch (Exception e) {
 			// TODO: handle exception
 			e.printStackTrace();
 		}
 	}

--------------------

# **实战：Solr  项目JD** #

### 3.1创建JD项目（war） ###

## **3.2添加项目依赖** ##

<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">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.bjsxt.jd</groupId>
 <artifactId>jd</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>war</packaging>
 
 	<dependencies>
 		
 		<dependency>
 			<groupId>javax.servlet</groupId>
 			<artifactId>jstl</artifactId>
 			<version>1.2</version>
 		</dependency>
 		
 		<dependency>
 			<groupId>javax.servlet.jsp</groupId>
 			<artifactId>jsp-api</artifactId>
 			<version>2.2</version>
 			
 			<scope>provided</scope>
 		</dependency>
 		
 		<dependency>
 			<groupId>javax.servlet</groupId>
 			<artifactId>servlet-api</artifactId>
 			<version>2.5</version>
 			<scope>provided</scope>
 		</dependency>
 
 		
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-webmvc</artifactId>
 			<version>4.3.18.RELEASE</version>
 		</dependency>
 		
 	 	<dependency>
 	 		<groupId>org.apache.solr</groupId>
 	 		<artifactId>solr-solrj</artifactId>
 	 		<version>4.10.4</version>
 	 	</dependency>
 	 	
 	 	<dependency>
 	 		<groupId>commons-logging</groupId>
 			<artifactId>commons-logging</artifactId>
 			<version>1.2</version>
 	 	</dependency>
 	</dependencies>
 	
 	<build>
 		<plugins>
 			
 			<plugin>
 				<artifactId>tomcat7-maven-plugin</artifactId>
 				<groupId>org.apache.tomcat.maven</groupId>
 				<version>2.2</version>
 				<configuration>
 					
 					<port>8081</port>
 					
 					<path>/</path>
 				</configuration>
 			</plugin>
 		</plugins>
 	</build>
 </project>

### 3.3配置Spring ###

### 3.3.1创建application-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:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xsi:schemaLocation=" 
 http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd 
 http://www.springframework.org/schema/context 
 http://www.springframework.org/schema/context/spring-context.xsd 
 ">
  
 	<bean id="server" class="org.apache.solr.client.solrj.impl.HttpSolrServer">
 		
 		<constructor-arg name="baseURL" 
 			value="http://localhost:8080/solr/solrCore"></constructor-arg>
 	</bean> 
 	
 	
 	<context:component-scan base-package="com.bjsxt.dao.impl"></context:component-scan>
 </beans>

### **3.3.2创建application\-service.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:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xsi:schemaLocation=" 
 http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd 
 http://www.springframework.org/schema/context 
 http://www.springframework.org/schema/context/spring-context.xsd 
 ">
 
 <context:component-scan base-package="com.bjsxt.service.impl"></context:component-scan> 
 
 
 
 </beans>

### **3.3.3创建springmvc.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:mvc="http://www.springframework.org/schema/mvc" 
 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.xsd 
 http://www.springframework.org/schema/context 
 http://www.springframework.org/schema/context/spring-context.xsd 
 http://www.springframework.org/schema/mvc 
 http://www.springframework.org/schema/mvc/spring-mvc.xsd 
 ">
 
 
 <context:component-scan base-package="com.bjsxt.controller"></context:component-scan>
 
 
 <mvc:annotation-driven></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>
 
 
 <mvc:resources location="/images/" mapping="/images/**"></mvc:resources>
 <mvc:resources location="/resource/" mapping="/resource/**"></mvc:resources>
 
 </beans>

### **3.4配置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" 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>
 
 
 <context-param>
 	<param-name>contextConfigLocation</param-name>
 	<param-value>classpath:application-*.xml</param-value>
 </context-param>
 
 <listener>
 	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>
 
 <servlet>
 	<servlet-name>springmvc</servlet-name>
 	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 	<init-param>
 		<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>springmvc</servlet-name>
 	<url-pattern>/</url-pattern>
 </servlet-mapping>
 
 <filter>
 	<filter-name>charset</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>charset</filter-name>
 	<url-pattern>/*</url-pattern>
 </filter-mapping>
 </web-app>

## 3.5功能实现 ##

### **3.5.1创建Product实体类** ###

### **3.5.2创建ProductDao接口** ###

package com.bjsxt.dao;
    
    import org.apache.solr.client.solrj.SolrQuery;
    import org.apache.solr.client.solrj.response.QueryResponse;
    
    public interface ProductDao {
    
    	/***
    	 * 实现商品数据的检索
    	 */
    	public QueryResponse loadProductDao(SolrQuery params);
    }

### **3.5.3创建ProductDaoImpl实现类** ###

package com.bjsxt.dao.impl;
    
    import org.apache.solr.client.solrj.SolrQuery;
    import org.apache.solr.client.solrj.SolrServerException;
    import org.apache.solr.client.solrj.impl.HttpSolrServer;
    import org.apache.solr.client.solrj.response.QueryResponse;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Repository;
    
    import com.bjsxt.dao.ProductDao;
    @Repository
    public class ProductDaoImpl implements ProductDao {
    
    	//注入HttpSolrServer对象
    	@Autowired
    	private HttpSolrServer server;
    	
    	
    	@Override
    	public QueryResponse loadProductDao(SolrQuery params) {
    		// TODO Auto-generated method stub
    		try {
    			return server.query(params);
    		} catch (SolrServerException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    }

### **3.5.4创建ProductService接口** ###

package com.bjsxt.service;
 
 import java.util.Map;
 
 import com.bjsxt.pojo.ProductVo;
 
 public interface ProductService {
 	
 	/***
 	 * 实现商品信息检索
 	 */
 	public Map<String,Object> loadProductListService(ProductVo pvo,
 			Integer page,Integer rows);
 
 }

### **3.5.5创建ProductServiceImpl实现类** ###

package com.bjsxt.service.impl;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import org.apache.solr.client.solrj.SolrQuery;
 import org.apache.solr.client.solrj.SolrQuery.ORDER;
 import org.apache.solr.client.solrj.beans.DocumentObjectBinder;
 import org.apache.solr.client.solrj.response.QueryResponse;
 import org.apache.solr.common.SolrDocumentList;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 
 import com.bjsxt.dao.ProductDao;
 import com.bjsxt.pojo.Product;
 import com.bjsxt.pojo.ProductVo;
 import com.bjsxt.service.ProductService;
 
 
 @Service	
 public class ProductServiceImpl implements ProductService {
 
 	//注入dao对象
 	@Autowired
 	private ProductDao productDao;
 	@Override
 	public Map<String, Object> loadProductListService(ProductVo pvo,
 			Integer page,Integer rows) {
 		// TODO Auto-generated method stub
 		
 		//创建SolrQuery对象
 		SolrQuery params=new SolrQuery();
 				
 				
 		//获得查询的关键字,实现关键字查询
 		String product_name=pvo.getProduct_name();
 		if(!StringUtils.isEmpty(product_name)) {
 			params.set("df", "product_name");
 			params.setQuery(product_name);
 		}else {
 			//查询所有商品信息
 			params.set("q", "*:*");
 		}
 		
 		//商品类目过滤查询
 		String product_catalog_name=pvo.getProduct_catalog_name();
 		if(!StringUtils.isEmpty(product_catalog_name)) {
 			params.addFilterQuery("product_catalog_name:"+product_catalog_name);
 		}
 		
 		//商品的价格区间过滤器查询
 		Double min=pvo.getMin();
 		Double max=pvo.getMax();
 		if(min!=null) {
 			if(max.equals(-1.0)) {
 				max=Double.MAX_VALUE;
 			}
 			
 			params.addFilterQuery("product_price:["+min+" TO "+max+"]");
 		}
 		
 		/***
 		 * 价格排序
 		 */
 		Integer sort=pvo.getSort();
 		if(sort.equals(0)) {
 			params.setSort("product_price", ORDER.asc);
 		}else {
 			params.setSort("product_price", ORDER.desc);
 		}
 		
 		/***
 		 * 指定分页查询参数
 		 */
 		Integer start=(page-1)*rows;
 		params.setStart(start);
 		params.setRows(rows);
 		
 		/****
 		 * 打开高亮显示
 		 */
 		params.setHighlight(true);
 		params.addHighlightField("product_name");
 		params.setHighlightSimplePre("");
 		params.setHighlightSimplePost("");
 		
 		//查询索引库
 		QueryResponse response = productDao.loadProductDao(params);
 		
 		//获得高亮显示的数据
 		Map<String, Map<String, List<String>>> htls = response.getHighlighting();
 		//获得查询到的文档对象的集合
 		SolrDocumentList results = response.getResults();
 		
 		//将results集合，转化Product对象的集合
 		DocumentObjectBinder binder=new DocumentObjectBinder();
 		List<Product> beans = binder.getBeans(Product.class, results);
 		
 		//遍历beans集合
 		for(Product p:beans) {
 			/***
 			 * 处理高亮数据
 			 */
 			String id=p.getId();
 			Map<String, List<String>> lts = htls.get(id);
 			//获得某个商品特征字段对应的高亮数据
 			List<String> lst = lts.get("product_name");
 			
 			if(lst!=null&&lst.size()>0) {
 				p.setProduct_name(lst.get(0));
 			}
 		}
 		
 		 
 		//查询到的商品总数
 		long total = results.getNumFound();
 		//计算获得最大页
 		long mpage=total%rows==0?total/rows:(total/rows)+1;
 		
 		
 		
 		//将文档对象results转化为
 		Map<String, Object> map=new HashMap<String, Object>();
 		map.put("results", beans);
 		map.put("total", total);
 		map.put("mpage", mpage);
 		
 		return map;
 	}
 
 }

### **3.5.6创建ProductController** ###

package com.bjsxt.controller;
 
 import java.util.Map;
 
 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 org.springframework.web.bind.annotation.RequestParam;
 
 import com.bjsxt.pojo.ProductVo;
 import com.bjsxt.service.ProductService;
 
 @Controller
 public class ProductController {
 
 	@Autowired
 	private ProductService productService;
 	/***
 	 * 实现页面跳转
 	 */
 	@RequestMapping("/")
 	public String loadPage() {
 		return "index";
 	}
 	
 	/***
 	 * 处理商品检索的请求
 	 */
 	@RequestMapping("/loadProduct")
 	public String loadProduct(ProductVo pvo,
 			@RequestParam(defaultValue="1")Integer page,
 			@RequestParam(defaultValue="16")Integer rows,
 			Model model) {
 		Map<String, Object> result 
 			= productService.loadProductListService(pvo, page, rows);
 		//作用用户封装数据
 		model.addAttribute("list", result.get("results"));
 		model.addAttribute("total", result.get("total"));
 		model.addAttribute("mpage", result.get("mpage"));
 		model.addAttribute("page", page);
 		model.addAttribute("vo", pvo);
 		
 		return "index";
 	}
 }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191117175238998.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0,size_16,color_FFFFFF,t_70