day66_Solr学习笔记

<requestHandler name="/select" class="solr.SearchHandler">
    <!-- 设置默认的参数值，可以在请求地址中修改这些参数-->
    <lst name="defaults">
        <str name="echoParams">explicit</str>
        <int name="rows">10</int><!--显示数量-->
        <str name="wt">json</str><!--显示格式-->
        <str name="df">text</str><!--默认搜索字段-->
    </lst>
</requestHandler>

    <fieldType name="text_general" class="solr.TextField" positionIncrementGap="100">
      <analyzer type="index">
        <tokenizer class="solr.StandardTokenizerFactory"/>
        <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt" />
        <!-- in this example, we will only use synonyms at query time
        <filter class="solr.SynonymFilterFactory" synonyms="index_synonyms.txt" ignoreCase="true" expand="false"/>
        -->
        <filter class="solr.LowerCaseFilterFactory"/>
      </analyzer>
      <analyzer type="query">
        <tokenizer class="solr.StandardTokenizerFactory"/>
        <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt" />
        <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/>
        <filter class="solr.LowerCaseFilterFactory"/>
      </analyzer>
    </fieldType>

<?xml version="1.0" encoding="UTF-8" ?>  
<dataConfig>   
    <dataSource type="JdbcDataSource"   
                driver="com.mysql.jdbc.Driver"   
                url="jdbc:mysql://localhost:3306/solr"   
                user="root"   
                password="root"/>   
    <document>   
        <entity name="product" query="SELECT pid,name,catalog,catalog_name,price,description,picture FROM products ">
            <field column="pid" name="id"/> 
            <field column="name" name="product_name"/> 
            <field column="catalog" name="product_catalog"/>
            <field column="catalog_name" name="product_catalog_name"/> 
            <field column="price" name="product_price"/> 
            <field column="description" name="product_description"/> 
            <field column="picture" name="product_picture"/> 
        </entity>   
    </document>   
</dataConfig>

    /**
     * 使用solr添加\修改索引
     * @throws Exception
     */
    @Test
    public void insertAndUpdateIndex() throws Exception {
        // 1、创建HttpSolrServer对象，通过它和solr服务器建立连接。 
        HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/"); // 参数：是solr服务器的访问地址
        // 2、创建SolrInputDocument对象，然后通过它来添加域。
        SolrInputDocument document = new SolrInputDocument();
        // 第一个参数：域的名称，域的名称必须是已经在schema.xml中定义过的
        // 第二个参数：域的值
        // 注意：id的域不能少
        document.addField("id", "c001");
        document.addField("name", "hello solr");
        // 3、通过HttpSolrServer对象将SolrInputDocument添加到索引库。 
        server.add(document);
        // 4、提交。 
        server.commit();
    }

    /**
     * 使用solr根据指定ID来删除索引
     * @throws Exception
     */
    @Test
    public void deleteIndexById() throws Exception {
        // 1、创建HttpSolrServer对象，通过它和solr服务器建立连接。 
        HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/"); // 参数：是solr服务器的访问地址
        // 2、根据指定ID来删除索引
        server.deleteById("c001");
        // 3、提交。 
        server.commit();
    }

    /**
     * 使用solr根据指定条件来删除索引
     * @throws Exception
     */
    @Test
    public void deleteIndexByCondition() throws Exception {
        // 1、创建HttpSolrServer对象，通过它和solr服务器建立连接。 
        HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/"); // 参数：是solr服务器的访问地址
        // 2、根据指定条件来删除索引
        server.deleteByQuery("id:c001");
        // 删除全部（慎用）
        // server.deleteByQuery("*:*");
        // 3、提交。 
        server.commit();
    }

    /**
     * 简单查询
     * @throws Exception
     */
    @Test
    public void queryIndex01() throws Exception {
        // 1、创建HttpSolrServer对象，通过它和solr服务器建立连接。 
        HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/"); // 参数：是solr服务器的访问地址
        // 2、创建SolrQuery对象
        SolrQuery query = new SolrQuery();

        // 设置查询条件，名称"q"是固定的且必须的！
        query.set("q", "product_name:小黄人");

        // 3、调用server的查询方法，查询索引库
        QueryResponse response = server.query(query);
        // 4、获取查询结果
        SolrDocumentList results = response.getResults();
        // 5、处理查询结果
        long count = results.getNumFound();
        System.out.println("查询结果总数为:" + count);
        for (SolrDocument solrDocument : results) {
            System.out.println(solrDocument.get("id"));
            System.out.println(solrDocument.get("product_name"));
            System.out.println(solrDocument.get("product_price"));
            System.out.println(solrDocument.get("product_catalog_name"));
            System.out.println(solrDocument.get("product_picture"));
            System.out.println("--------------------");
        }
    }

    /**
     * 复杂查询
     * @throws Exception
     */
    @Test
    public void queryIndex02() throws Exception {
        // 1、创建HttpSolrServer对象，通过它和solr服务器建立连接。 
        HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/"); // 参数：是solr服务器的访问地址
        // 2、创建SolrQuery对象
        SolrQuery query = new SolrQuery();

        // 设置查询条件
        // query.set("q", "product_name:小黄人");
        query.setQuery("product_name:小黄人");
        // 设置过滤条件，如果设置多个过滤条件的话，需要使用query.addFilterQuery(fq);
        query.setFilterQueries("product_price:[1 TO 20]");
        // 设置排序
        query.setSort("product_price", ORDER.desc);
        // 设置分页信息（使用默认的）
        query.setStart(0);
        query.setRows(10);
        // 设置显示的field的域集合
        query.setFields("id,product_name,product_catalog,product_price,product_picture");
        // 设置默认域
        query.set("df", "product_keywords");
        // 设置高亮信息
        query.setHighlight(true);
        query.addHighlightField("product_name");
        query.setHighlightSimplePre("<span color='red'>");
        query.setHighlightSimplePost("</span>");

        // 3、调用server的查询方法，查询索引库
        QueryResponse response = server.query(query);
        // 4、获取查询结果
        SolrDocumentList results = response.getResults();
        // 5、处理查询结果
        long count = results.getNumFound();
        System.out.println("查询结果总数为:" + count);

        // 获取高亮列表
        Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();
        for (SolrDocument solrDocument : results) {
            System.out.println(solrDocument.get("id"));

            String productName = (String) solrDocument.get("product_name");
            // 获取本文档的高亮信息
            List<String> list = highlighting.get(solrDocument.get("id")).get("product_name");
            // 如果有高亮信息，则把商品名称赋值为有高亮的那个名称
            if (list != null) {
                productName = list.get(0); // 本例中list只有一条记录
            }
            System.out.println(productName);

            System.out.println(solrDocument.get("product_price"));
            System.out.println(solrDocument.get("product_catalog_name"));
            System.out.println(solrDocument.get("product_picture"));
            System.out.println("--------------------");
        }
    }

public class Product {
    // 商品编号
    private String pid;
    // 商品名称
    private String name;
    // 商品分类名称
    private String catalog_name;
    // 价格
    private float price;
    // 商品描述
    private String description;
    // 图片名称
    private String picture;

    // getter和setter
}

public class ResultModel {
    // 商品列表
    private List<Product> productList;
    // 商品总数
    private Long recordCount;
    // 总页数
    private int pageCount;
    // 当前页
    private int currentPage;

    // getter和setter
}

@Repository
public class ProductDaoImpl implements ProductDao {

    // 依赖注入HttpSolrServer
    @Autowired
    private HttpSolrServer server;

    /**
     * 接收service层传递过来的参数，根据参数查询索引库，返回查询结果。
     * 查询商品信息，包括分页信息。
     */
    public ResultModel queryProduct(SolrQuery query) throws Exception {
        ResultModel result = new ResultModel();
        // 通过server查询索引库
        QueryResponse response = server.query(query);
        // 获得查询结果
        SolrDocumentList documentList = response.getResults();

        // 把查询结果的总数设置到ResultModel中去
        result.setRecordCount(documentList.getNumFound());

        List<Product> productList = new ArrayList<Product>();

        Product product = null;
        // 获取高亮信息
        Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();
        for (SolrDocument solrDocument : documentList) {
            product = new Product();
            // 设置商品ID
            product.setPid((String) solrDocument.get("id"));

            // 设置商品名称
            String prodName = (String) solrDocument.get("product_name");
            List<String> list = highlighting.get(solrDocument.get("id")).get("product_name");
            if (list != null) {
                prodName = list.get(0);
            }
            product.setName(prodName);

            // 设置商品分类名称
            product.setCatalog_name((String) solrDocument.get("product_catalog_name"));
            // 设置商品价格
            product.setPrice((Float) solrDocument.get("product_price"));
            // 设置商品图片地址
            product.setPicture((String) solrDocument.get("product_picture"));

            // 把商品添加到商品列表集合中
            productList.add(product);
        }

        // 把商品列表放到ResultMap中
        result.setProductList(productList);

        return result;
    }
}

@Service
public class ProductServiceImpl implements ProductService {

    @Autowired
    private ProductDao dao;

    /**
     * 接收action传递过来的参数，根据参数拼装一个查询条件，调用dao层方法，查询商品列表。
     * 接收dao返回的商品列表和商品的总数量，根据每页显示的商品数量计算总页数。
     * @throws Exception 
     */
    public ResultModel queryProduct(String queryString, String catalogName, String price, 
            String sort, Integer currentPage) throws Exception {
        // 创建SolrQuery对象
        SolrQuery query = new SolrQuery();

        // 设置查询条件：输入关键字
        if (queryString != null && !"".equals(queryString)) {
            query.setQuery(queryString);
        } else {
            query.setQuery("*:*");
        }

        // 设置商品类别过滤条件：product_catalog_name:幽默杂货
        if (catalogName != null && !"".equals(catalogName)) {
            query.addFilterQuery("product_catalog_name:" + catalogName);
        }

        // 设置商品价格区间过滤条件：product_price:[10 TO 20]
        if (price != null && !"".equals(price)) {
            // 传过来的price的值：0-9  10-19  20-29
            String[] strings = price.split("-");
            if (strings.length == 2) {
                query.addFilterQuery("product_price:[" + strings[0] + " TO " + strings[1] + "]");
            }
        }

        // 设置排序：传过来1或0，1表示降序，0表示升序。
        if ("1".equals(sort)) {
            query.setSort("product_price", ORDER.desc);
        } else {
            query.setSort("product_price", ORDER.asc);
        }

        // 设置分页信息
        if (currentPage == null) {
            currentPage = 1;
        }
        query.setStart((currentPage - 1) * 20);
        query.setRows(20);

        // 设置默认搜索域
        // query.set("df", "product_keywords");

        // 设置高亮信息
        query.setHighlight(true);
        query.addHighlightField("product_name");
        query.setHighlightSimplePre("<font style=\"color:red\">");
        query.setHighlightSimplePost("</font>");

        ResultModel resultModel = dao.queryProduct(query);
        // 设置当前页
        resultModel.setCurrentPage(currentPage);
        // 设置总页数
        Long recordCount = resultModel.getRecordCount();
        int pageCount = (int) (recordCount / 20);
        if (recordCount % 20 > 0) {
            pageCount++;
        }
        resultModel.setPageCount(pageCount);

        return resultModel;
    }
}

@Controller
public class ProductController {

    @Autowired
    private ProductService service;

    @RequestMapping("list")
    public String list(String queryString, String catalog_name, String price, 
            String sort, Integer page, Model model) throws Exception {

        ResultModel resultModel = service.queryProduct(queryString, catalog_name, price, sort, page);
        // 将查询结果放到result域中
        model.addAttribute("result", resultModel);

        // 简单类型的数据回显
        model.addAttribute("queryString", queryString);
        model.addAttribute("caltalog_name", catalog_name);
        model.addAttribute("price", price);
        model.addAttribute("sort", sort);
        model.addAttribute("page", page);
        return "product_list";
    }
}

<?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" 
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    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>day66_Solr_02_JD</display-name>
    <!-- SpringMVC配置 -->
    <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>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>
    <filter>
        <filter-name>characterEncoding</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>characterEncoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

<?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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.1.xsd 
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-3.1.xsd 
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-3.1.xsd ">
    <!-- 配置扫描包 -->
    <context:component-scan base-package="com.itheima" />
    <!-- 配置注解驱动 -->
    <mvc:annotation-driven />
    <!-- jsp视图解析器 -->
    <bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>
    <!-- 配置solr服务：HttpSolrServer -->
    <bean class="org.apache.solr.client.solrj.impl.HttpSolrServer">
        <constructor-arg value="http://localhost:8080/solr/"></constructor-arg>
    </bean>
</beans>