springboot整合solr

@TOC

1、配置solr整合项目

1.1、整合依赖

 <!-- solr -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-solr</artifactId>
        </dependency>

1.2、配置

server:
  port: 8080

spring:
  data:
    solr:
      host: http://localhost:8983/solr/new_core

如何查找solr的核心

去掉#号

2、配置数据库

2.1、在solr创建数据库/导入（分词器）

2.2、启动MySQL

3、具体代码示例

3.1、solrClient（整合jar包提供的对象）

    @Autowired
    protected SolrClient solrClient;//spring整合jar包提供的一个对象，可以进行注入

运行机制：先去读yml文件提供的URL访问路径host: http://localhost:8983/solr/new_core，然后此路径为基础去实例一个solr的对象，然后此对象可以做一些增删改查

3.2、代码

BaseSolrDao.java

package com.dao;

import com.bean.User;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.client.solrj.response.UpdateResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrInputDocument;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.IOException;
import java.util.List;

/**
 * 基础solr数据处理父类
 * @param <T>
 */
public class BaseSolrDao<T> {

    @Autowired
    protected SolrClient solrClient;//spring整合jar包提供的一个对象，可以进行注入

    public void insert(SolrInputDocument document) throws IOException, SolrServerException {
        solrClient.add(document);
        //提交
        solrClient.commit();
    }

    /**
     * 添加或修改，修改的时候先删除在修改避免数据重复
     * @param t
     */
    public void update(T t) throws IOException, SolrServerException {
        solrClient.addBean(t);
        //提交
        solrClient.commit();
    }

    /**
     * 删除
     * @param query
     * @return
     */
    public void delete(String query) throws IOException, SolrServerException {

        solrClient.deleteByQuery(query);
        //提交
        solrClient.commit();
    }

    /**
     * 查询
     * @param solrQuery
     * @param clazz
     * @return
     */
    public List<T> select(SolrQuery solrQuery, Class<T> clazz) throws IOException, SolrServerException {

        //查询
        QueryResponse queryResponse = solrClient.query(solrQuery);
        //将查询结果转换指定元素类型的集合
        List<T> list = queryResponse.getBeans(clazz);

        return list;

    }
}

UserVo.java

package com.bean.vo;

import java.io.Serializable;

public class UserVo implements Serializable {

    private Integer gender;
    private Integer maxAge;
    private Integer minAge;
    private String content;

    public UserVo() {
    }

    public UserVo(Integer gender, Integer maxAge, Integer minAge, String content) {
        this.gender = gender;
        this.maxAge = maxAge;
        this.minAge = minAge;
        this.content = content;
    }

    @Override
    public String toString() {
        return "UserVo{" +
                "gender=" + gender +
                ", maxAge=" + maxAge +
                ", minAge=" + minAge +
                ", content='" + content + '\'' +
                '}';
    }

    public Integer getGender() {
        return gender;
    }

    public void setGender(Integer gender) {
        this.gender = gender;
    }

    public Integer getMaxAge() {
        return maxAge;
    }

    public void setMaxAge(Integer maxAge) {
        this.maxAge = maxAge;
    }

    public Integer getMinAge() {
        return minAge;
    }

    public void setMinAge(Integer minAge) {
        this.minAge = minAge;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

UserDao.java

package com.dao;

import com.bean.User;
import org.springframework.stereotype.Repository;

/**
 *  user solr数据处理对象
 */
@Repository
public class UserDao extends BaseSolrDao<User> {
}

UserService.java

package com.service;

import com.bean.User;
import com.bean.vo.UserVo;
import org.apache.solr.client.solrj.SolrServerException;

import java.io.IOException;
import java.util.List;

/**
 *  用户solr业务逻辑接口
 */
public interface UserService {

    void save(User user) throws IOException, SolrServerException;
    void update(User user) throws IOException, SolrServerException;
    void remove(String query) throws IOException, SolrServerException;
    List<User> query(UserVo userVo, int start, int size) throws IOException, SolrServerException;
}

UserServiceImpl.java
== solrQuery.addFilterQuery(“user_content:”+userVo.getContent().trim());==

package com.service.impl;

import com.bean.User;
import com.bean.vo.UserVo;
import com.dao.UserDao;
import com.service.UserService;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.common.SolrInputDocument;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.List;

/**
 *  user业务逻辑实现
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public void save(User user) throws IOException, SolrServerException {
        SolrInputDocument document = new SolrInputDocument();

        document.addField("user_id", user.getUserId());
        document.addField("user_userName", user.getUserName());
        document.addField("user_password", user.getPassword());
        document.addField("user_content", user.getContent());

        userDao.insert(document);
    }

    @Override
    public void update(User user) throws IOException, SolrServerException {
        userDao.update(user);
    }

    @Override
    public void remove(String query) throws IOException, SolrServerException {
        userDao.delete(query);
    }

    @Override
    public List<User> query(UserVo userVo, int start, int size) throws IOException, SolrServerException {

        SolrQuery solrQuery = new SolrQuery("*:*");

        //添加普通条件
        //不加，说明输出的是toString方法，加上，说明输出的content的字段的值
        if (userVo.getContent() != null && !userVo.getContent().trim().equals("")){
            solrQuery.addFilterQuery("user_content:"+userVo.getContent().trim());
        }
        if (userVo.getGender() != null){
            solrQuery.addFilterQuery("user_gender:"+userVo.getGender());
        }
        //添加范围条件
        if (userVo.getMaxAge() != null){
            solrQuery.addFilterQuery("user_age:[* TO " + userVo.getMaxAge() + "]");
        }
        if (userVo.getMinAge() != null){
            solrQuery.addFilterQuery("user_age:[" + userVo.getMinAge() + " TO *]");
        }

        //添加排序
//        solrQuery.addSort("user_age", SolrQuery.ORDER.desc);
        solrQuery.addSort("user_age", SolrQuery.ORDER.asc);

        //添加分页
        solrQuery.setStart(start);
        solrQuery.setRows(size);

        return userDao.select(solrQuery, User.class);
    }
}

UserController.java

package com.controller;

import com.bean.User;
import com.bean.dto.Dto;
import com.bean.vo.UserVo;
import com.service.UserService;
import com.util.PageAssistant;
import org.apache.solr.client.solrj.SolrServerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.io.IOException;
import java.util.List;

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("query")
    @ResponseBody
    public Dto query(UserVo userVo, PageAssistant<User> pa){

        System.out.println(">>>> query");
        System.out.println(userVo);

        List<User> userList = null;
        try {
            userList = userService.query(userVo, pa.getStart(), pa.getPageSize());
        } catch (IOException e) {
            e.printStackTrace();
            return new Dto("false", "查询失败!", "3001");
        } catch (SolrServerException e) {
            e.printStackTrace();
            return new Dto("false", "查询失败!", "3002");
        }

        return new Dto(userList);
    }

    @RequestMapping("add")
    @ResponseBody
    public Dto add(User user){
        System.out.println(">>>> add");
        System.out.println(user);

        try {
            userService.save(user);
        } catch (IOException e) {
            e.printStackTrace();
            return new Dto("false", "添加失败!", "2001");
        } catch (SolrServerException e) {
            e.printStackTrace();
            return new Dto("false", "添加失败!", "2002");
        }

        return new Dto("添加成功!", null);
    }

    @RequestMapping("remove")
    @ResponseBody
    public Dto remove(User user){
        System.out.println(">>>> remove");
        System.out.println(user);

        try {
            userService.remove("user_id:"+user.getUserId());
        } catch (IOException e) {
            e.printStackTrace();
            return new Dto("false", "删除失败!", "4001");
        } catch (SolrServerException e) {
            e.printStackTrace();
            return new Dto("false", "删除失败!", "4002");
        }

        return new Dto("删除成功!", null);
    }

    @RequestMapping("modify")
    @ResponseBody
    public Dto modify(User user){
        System.out.println(">>>> modify");
        System.out.println(user);

        try {
            userService.update(user);
        } catch (IOException e) {
            e.printStackTrace();
            return new Dto("false", "修改失败!", "5001");
        } catch (SolrServerException e) {
            e.printStackTrace();
            return new Dto("false", "修改失败!", "5002");
        }

        return new Dto("修改成功!", null);
    }
}

查询所有