精华内容
下载资源
问答
  • SpringBoot整合Solr

    2019-12-08 21:01:42
    文章目录SpringBoot整合Solr【一】创建项目【二】添加maven依赖【三】配置yml【四】创建Bean4.1 创建Bean4.2 添加字段索引【五】service5.1 StudentService5.2 StudentServiceImpl【六】controller【七】链接 ...

    SpringBoot整合Solr

    【一】创建项目

    创建springboot项目,可以跟着创建项目一步一步地走

    在这里插入图片描述

    【二】添加maven依赖

    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.2.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
        <groupId>com.feng</groupId>
        <artifactId>springboot-solr</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>springboot-solr</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <!--整合solr-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-solr</artifactId>
            </dependency>
    
            <!--web-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <!--lombok简化-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
    
            <!--测试-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-logging</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            <!-- 引入log4j日志依赖 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-log4j</artifactId>
                <version>1.3.8.RELEASE</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    
    

    【三】配置yml

    在yml添加配置,当前的路径保证服务器上已经安装solr

    ps:如果服务器上海没有安装好solr请先安装好solr:https://blog.csdn.net/wenge1477/article/details/103446992

    spring:
      data:
        solr:
          host: http://192.168.183.129:8080/solr
    

    【四】创建Bean

    4.1 创建Bean

    package com.feng.springbootsolr.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.apache.solr.client.solrj.beans.Field;
    
    import java.io.Serializable;
    
    /**
     * @Description 学生
     * @Author fengwen
     * @Date 2019/12/8 19:43
     * @Version V1.0
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Student implements Serializable {
    
        private static final long serialVersionUID = -2221755230808487993L;
    
        /**
         * 学生id
         */
        @Field("id")
        private String id;
    
        /**
         * 学生姓名
         */
        @Field("studentName")
        private String studentName;
    
        /**
         * 学生年龄
         */
        @Field("studentAge")
        private Integer studentAge;
    
        /**
         * 学生性别
         */
        @Field("studentGrander")
        private Integer studentGrander;
    
    }
    
    

    4.2 添加字段索引

    其中@Field为solr服务器上创建的字段索引,需要去solr配置文件中添加字段索引

    到服务器上的solr的配置文件中进行设置:
    
    vim /usr/local/solr-4.10.3/example/solr/collection1/conf/schema.xml
    

    配置文件中添加字段

    <!-- Student start -->
     <field name="studentName" type="text_ik" indexed="true" stored="true" required="false" multiValued="false" />
     <field name="studentAge" type="int" indexed="true" stored="true" required="false" multiValued="false" />
     <field name="studentGrander" type="int" indexed="true" stored="true" required="false" multiValued="false" />
    <!-- student end -->
    
    

    ps: 其中type="text_ik"意思是使用中文分割器

    【五】service

    5.1 StudentService

    package com.feng.springbootsolr.service;
    
    import com.feng.springbootsolr.pojo.Student;
    import java.util.List;
    
    /**
     * @Description
     * @Author fengwen
     * @Date 2019/12/8 19:48
     * @Version V1.0
     */
    public interface StudentService {
    
        /**
         * 保存学生
         * @param student
         * @return
         */
        boolean saveStudent(Student student);
    
        /**
         * 根据条件查询学生
         * @param param
         * @param pagerNum
         * @param pageSize
         * @param sort
         * @return
         */
        List<Student> queryStudent(String param,int pagerNum ,int pageSize,String sort);
    
        /**
         * 通过id查询学生
         * @param id
         * @return
         */
        Student queryById(String id);
    
    }
    
    

    5.2 StudentServiceImpl

    package com.feng.springbootsolr.service.impl;
    
    import com.feng.springbootsolr.pojo.Student;
    import com.feng.springbootsolr.service.StudentService;
    import lombok.extern.slf4j.Slf4j;
    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.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    
    /**
     * @Description
     * @Author fengwen
     * @Date 2019/12/8 19:49
     * @Version V1.0
     */
    @Service
    @Slf4j
    public class StudentServiceImpl implements StudentService {
    
        /**
         * 调用solr的api查询学生
         */
        @Autowired
        private SolrClient solrClient;
    
    
        /**
         * 保存学生信息
         *
         * @param student
         * @return
         */
        @Override
        public boolean saveStudent(Student student) {
            try {
                solrClient.addBean(student);
                solrClient.commit();
            } catch (Exception e) {
                e.printStackTrace();
                log.error("保存学生信息出错:{}", student);
                return false;
            }
            return true;
        }
    
        @Override
        public List<Student> queryStudent(String param, int pagerNum, int pageSize, String sort) {
            SolrQuery query = new SolrQuery();
            query.set("q", param);
            query.set("start", (pagerNum - 1) * pageSize);
            query.set("rows", pageSize);
            query.set("sort", sort);
    
            List<Student> studentList = null;
            try {
                QueryResponse response = solrClient.query(query);
                studentList = response.getBeans(Student.class);
            } catch (Exception e) {
                log.error("查询学生信息出错:{}、{}、{}、{}", param, pagerNum, pageSize, sort);
            }
            return studentList;
        }
    
        @Override
        public Student queryById(String id) {
            SolrQuery query = new SolrQuery();
            String param = "id:" + id;
            query.set("q", param);
    
            List<Student> studentList = null;
            try {
                QueryResponse response = solrClient.query(query);
                studentList = response.getBeans(Student.class);
                if (studentList != null && studentList.size() > 0) {
                    return studentList.get(0);
                }
            } catch (Exception e) {
                e.printStackTrace();
                log.error("查询学生信息出错:{}", id);
            }
            return null;
        }
    }
    
    

    【六】controller

    package com.feng.springbootsolr.controller;
    
    import com.feng.springbootsolr.pojo.Student;
    import com.feng.springbootsolr.service.StudentService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    
    /**
     * @Description
     * @Author fengwen
     * @Date 2019/12/8 19:48
     * @Version V1.0
     */
    @RestController
    @RequestMapping("student")
    @Slf4j
    public class StudentController {
    
        @Autowired
        private StudentService studentService;
    
        /**
         * 保存学生
         *
         * @param student
         * @return
         */
        @PostMapping("save")
        public String saveStudent(Student student) {
            boolean result = studentService.saveStudent(student);
            if (!result) {
                return "保存失败";
            }
            return "保存成功";
        }
    
        /**
         * 通过id查询学生
         *
         * @param id
         * @return
         */
        @GetMapping("{id}")
        public Student getById(@PathVariable("id") String id) {
            Student student = studentService.queryById(id);
            return student;
        }
    
        /**
         * 通过条件查询学生
         *
         * @param param
         * @param pageNum
         * @param pageSize
         * @param sort
         * @return
         */
        @GetMapping("query")
        public List<Student> queryStudent( String param,
                                          @RequestParam(required = false,defaultValue = "1") Integer pageNum,
                                          @RequestParam(required = false,defaultValue = "5") Integer pageSize,
                                          @RequestParam(required = false,defaultValue = "id desc") String sort) {
            List<Student> studentList = studentService.queryStudent(param, pageNum, pageSize, sort);
            return studentList;
        }
    }
    
    

    在这里插入图片描述
    项目github地址:https://github.com/fengsri/springboot-solr

    【七】链接

    展开全文
  • springboot整合solr

    2019-07-22 14:54:35
    springboot整合solr 搭建solr服务器 solr就相当于是一个数据库 第一步:创建一个空的文件夹testsolr,为了方便管理tomcat、solr以及solr的数据源管理; 第二步、安装下载Tomcat8.5.9、solr8.1.1,并创建一个空...

    springboot整合solr

    搭建solr服务器 solr就相当于是一个数据库

    第一步:创建一个空的文件夹testsolr,为了方便管理tomcat、solr以及solr的数据源管理;
    在这里插入图片描述

    第二步、安装下载Tomcat8.5.9、solr8.1.1,并创建一个空的文件夹solrHome(solr 数据源)
    solr8.1.1下载地址https://lucene.apache.org/solr/guide/8_1/installing-solr.html 一般下载zip格式就行
    第三步:把solr-8.1.1安装包中的server→solr-webApp→webApp下的文件拷贝一份到apache-tomcat-8.5.9→webApp下创建的solr文件夹中:
    在这里插入图片描述
    在这里插入图片描述
    第四步:将solr-8.1.1安装包中的server→ext 文件夹下的jar、server文件夹下的jar文件、拷贝到tomcat→webApp→solr→WEB_INF→lib文件夹中(网上很多教程一般只会拷贝server→ext 文件夹下的jar但是启动tomcat并访问时会报404。个人建议全拷)
    在这里插入图片描述
    第五步:配置apache-tomcat-8.5.9→webApp→solr→WEB_INF下的web.xm
    1、添加配置(指定solr数据源的位置):

      <!--配置solr 数据源-->
    	<env-entry>  
             <env-entry-name>solr/home</env-entry-name>  
             <env-entry-value>D:\testsolr\solrHome</env-entry-value>  
             <env-entry-type>java.lang.String</env-entry-type>  
        </env-entry>
    
    

    2、注释一下配置(目的是防止tomcat 403问题)

     <!-- Get rid of error message -->
     <!-- <security-constraint>
        <web-resource-collection>
          <web-resource-name>Disable TRACE</web-resource-name>
          <url-pattern>/</url-pattern>
          <http-method>TRACE</http-method>
        </web-resource-collection>
        <auth-constraint/>
      </security-constraint>
      <security-constraint>
        <web-resource-collection>
          <web-resource-name>Enable everything but TRACE</web-resource-name>
          <url-pattern>/</url-pattern>
          <http-method-omission>TRACE</http-method-omission>
        </web-resource-collection>
      </security-constraint>-->
    

    第六步:把solr-8.1.1安装包中的server→resources文件下的配置文件拷贝到apache-tomcat-8.0.47→webApp→solr→WEB_INF→classes文件夹下(如果没有classes文件夹,请先创建)
    在这里插入图片描述
    在这里插入图片描述
    需要分别修改log4j2的两个配置文件,需要把所有${sys:solr.log.dir}修改为自己的指定的真是路径。
    在这里插入图片描述
    ${sys:solr.log.dir}本机存放solr日志的文件夹
    第七步:启动tomcat,访问 http://localhost:8080/solr/index.html验证是否配置成功。
    完了有可能报404是因为jar不全
    在这里插入图片描述
    Solr server lib 和ext的jar都需要拷到tomcat solr web-inf lib下面
    **

    sorl搭建成功操作solrweb端

    **

    第一步创建solrCore
    目前solrHome目录是空的,我们创建一个空文件夹core1,这个就是我们的一个域(相当于项目对应的库),然后把solr-8.1.1/server/solr/configsets/sample_techproducts_configs/conf/ 这个文件复制到solrHome/core1中。
    在这里插入图片描述
    在这里插入图片描述
    把solr5.5/server/solr/solr.xml复制到solrHome目录下。
    第二步在solr的管理控制台界面,添加一个core1
    在这里插入图片描述
    这下就创建成功了一个域core1 请注意我打码的部分,需要先执行第一步创建solrCore操作,否则的话,会无法创建solr core,也就是会有错误信息,这是solr的一个bug,但是至今没有修复
    第三步 准备好ik分词器的jar包,可以自己编译,也可以下载我生成的。
    然后把它复制到tomcat/webapp/solr/WEB-INF/lib里面。(千万不要复制到tomcat/lib中,这样会找不到lucene的类)
    打开solrHome/core1/conf/managed-schema文件,在最下方,追加如下配置

    <fieldType name="text_ik" class="solr.TextField">
        <analyzer type="index" useSmart="false"
            class="org.wltea.analyzer.lucene.IKAnalyzer" />
        <analyzer type="query" useSmart="true"
            class="org.wltea.analyzer.lucene.IKAnalyzer" />
    </fieldType>
    

    启动tomcat,即可看到text_ik分词
    在这里插入图片描述
    中文分词器安装成功

    第四步配置自定义字段域 这个相当于数据库中的字段

    	<!--自定义字段域-->
        <field name="typeName"  type="string" indexed="true" stored="true"  multiValued="false"/>
    	<field name="docName"  type="text_ik" indexed="true" stored="true"  multiValued="false"/>
    	<field name="introduction"  type="text_ik" indexed="true" stored="true"  multiValued="false"/>
    	<field name="keyPackage"  type="text_ik" indexed="true" stored="true"  multiValued="false"/>
    	<field name="uploadBy"  type="text_ik" indexed="true" stored="true"  multiValued="false"/>
    	<field name="uploadTime"  type="text_ik" indexed="true" stored="true"  multiValued="false"/>
    	<field name="downloadNumber"  type="plong" indexed="true" stored="true"  multiValued="false"/>
    	<field name="writeDate"  type="pdate" indexed="true" stored="true"  multiValued="false"/>
    	<field name="jh"  type="text_ik" indexed="true" stored="true"  multiValued="false"/>
    	<!--复制域(solr的搜索优化功能,将多个字段域复制到一个域里面,提高查询的效率)-->
    	<field name="doc_keywords"  type="text_ik" indexed="true" stored="false"  multiValued="true"/>
    	<copyField source="typeName"  dest="doc_keywords"/>
    	<copyField source="docName"  dest="doc_keywords"/>
    	<copyField source="introduction"  dest="doc_keywords"/>
    	<copyField source="keyPackage"  dest="doc_keywords"/>
    	<copyField source="uploadBy"  dest="doc_keywords"/>
    	<copyField source="uploadTime"  dest="doc_keywords"/>
    	<copyField source="downloadNumber"  dest="doc_keywords"/>
    	<copyField source="author"  dest="doc_keywords"/>
    	<copyField source="writeDate"  dest="doc_keywords"/>
    	<copyField source="jh"  dest="doc_keywords"/>
    

    增删改
    添加数据
    在这里插入图片描述
    根据id删除
    在这里插入图片描述

    根据条件删除 左边时域 右边时字段域
    在这里插入图片描述
    solr查询
    在这里插入图片描述

    条件查询
    在这里插入图片描述

    solr复制域的查询
    在这里插入图片描述

    设置高亮
    在这里插入图片描述

    创建springboot项目

    **
    第一步创建字段域对应的实体 SearchResult

    package com.shiwen.yitihui.domain;
    
    import java.io.Serializable;
    import java.util.Date;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.ForeignKey;
    import javax.persistence.JoinColumn;
    import javax.persistence.ManyToOne;
    import javax.persistence.Table;
    import javax.persistence.Temporal;
    import javax.persistence.TemporalType;
    
    /**
    * @author wangjie:
    * @version 创建时间:2019年8月20日 下午4:48:41
    * @Description 类描述:solr查询实体
    */
    
    @Entity
    @Table(name="B_DOCUMENT_FILE")
    public class SearchResult extends AbstractEntity {
    	
    	private static final long serialVersionUID = -8052339972799799652L;
    	
    	@ManyToOne
    	@JoinColumn(name="docType")
    	private DocType  docType;
    	
    	@Column(name="doc_name")
    	private String  docName;
    	
    	@Column(name="introduction")
    	private String  introduction;
    	
    	@Column(name="key_package")
    	private String  keyPackage;
    	
    	@Column(name="upload_by")
    	private String  uploadBy;
    	
    	private Date uploadTime = new Date();
    	
    	@Column(name="download_number")
    	private Long downloadNumber;
    	
    	@Column(name="author")
    	private String  author;
    	
    	private Date writeDate;
    	
    	@Column(name="jh")
    	private String  jh;
    
    	public DocType getDocType() {
    		return docType;
    	}
    
    	public void setDocType(DocType docType) {
    		this.docType = docType;
    	}
    
    	public String getDocName() {
    		return docName;
    	}
    
    	public void setDocName(String docName) {
    		this.docName = docName;
    	}
    
    	public String getIntroduction() {
    		return introduction;
    	}
    
    	public void setIntroduction(String introduction) {
    		this.introduction = introduction;
    	}
    
    	public String getKeyPackage() {
    		return keyPackage;
    	}
    
    	public void setKeyPackage(String keyPackage) {
    		this.keyPackage = keyPackage;
    	}
    
    	public String getUploadBy() {
    		return uploadBy;
    	}
    
    	public void setUploadBy(String uploadBy) {
    		this.uploadBy = uploadBy;
    	}
    
    	public Date getUploadTime() {
    		return uploadTime;
    	}
    
    	public void setUploadTime(Date uploadTime) {
    		this.uploadTime = uploadTime;
    	}
    
    	public Long getDownloadNumber() {
    		return downloadNumber;
    	}
    
    	public void setDownloadNumber(Long downloadNumber) {
    		this.downloadNumber = downloadNumber;
    	}
    
    	public String getAuthor() {
    		return author;
    	}
    
    	public void setAuthor(String author) {
    		this.author = author;
    	}
    
    	public Date getWriteDate() {
    		return writeDate;
    	}
    
    	public void setWriteDate(Date writeDate) {
    		this.writeDate = writeDate;
    	}
    
    	public String getJh() {
    		return jh;
    	}
    
    	public void setJh(String jh) {
    		this.jh = jh;
    	}
    }
    
    

    第二部创建solr搜索的接口

    public interface SearchSolrService {
    	
    	public List<SearchResult> getList();
    	
    	public List<SearchResult> getListBySearchKey(String searchKey,Integer page, Integer row);
    
    }
    

    第三步pom文件添加solr依赖

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

    第三步实现SearchService接口
    发现solr引擎查询,需要有数据才能查,因此需要将数据库中的数据放入到solr引擎中(及solr初始化)

    spring:
      application:
        name: solr
      data:
        solr:
          host: http://127.0.0.1:8080/solr/core1
    

    第四步solr的增删改
    (1) solr的增加在这里插入图片描述
    删除solr
    在这里插入图片描述
    solr初始化

    	/**
    	 * solr初始化
    	 */
    	@RequestMapping("/init")
    	public void initDocument() {
    		// 查询数据库的信息
    		List<SearchResult> searchResults = searchSolrService.getList();
    		for (SearchResult result : searchResults) {
    			// 创建solr文档对象
    			SolrInputDocument docunment = new SolrInputDocument();
    			docunment.addField("id", result.getId());
    			docunment.addField("docType", result.getDocType());
    			docunment.addField("docName", result.getDocName());
    			docunment.addField("introduction", result.getIntroduction());
    			docunment.addField("keyPackage", result.getKeyPackage());
    			docunment.addField("uploadBy", result.getUploadBy());
    			docunment.addField("uploadTime", result.getUploadTime());
    			docunment.addField("downloadNumber", result.getDownloadNumber());
    			docunment.addField("author", result.getAuthor());
    			docunment.addField("writeDate", result.getWriteDate());
    			docunment.addField("jh", result.getJh());
    			// 添加solr文档对象到solr服务引擎中
    			try {
    				solrClient.add(docunment);
    				solrClient.commit();
    			} catch (SolrServerException | IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    
    	}
    

    solr查询

    	/**
    	 * solr查询
    	 */
    	@RequestMapping("/getList")
    	public Map<String, Object> queryAllSolr(@RequestParam String value) throws IOException, SolrServerException {
    		Map<String, Object> mp = new HashMap<String, Object>();
    		try {
    			ModifiableSolrParams params =new ModifiableSolrParams();
    			if(value == null || value.equals(null)) {
    				//params.add("q", "*:*");
    				params.add("q","id:* or docName:* or introduction:* or keyPackage:* or uploadTime:* or author:* or author_s:*");
    			}else {
    				//params.add("q", "*:*"+value);
    				//params.add("q","*:*"+value+"*");
    				params.add("q","id:*"+value+"* or docName:*"+value+"* or introduction:*"+value+"* or keyPackage:*"+value+"* or uploadTime:*"+value+"* or author:*"+value+"* or author_s:*"+value+"*");
    			}
                params.add("start","0");
                params.add("rows","100");
                QueryResponse query = solrClient.query(params);
                mp.put("list", query.getResults());
            }catch (Exception e){
                e.printStackTrace();
            }
    		return mp;
     
    	}
    

    查询对应的前段页面

    <!-- 使用solr进行全文索引 -->
    <div class="panel panel-default">
        <div class="panel-heading">
            <form class="form-horizontal">
                <div style="float:left;">
                    <input ng-model="searchContent" class="form-control ng-pristine ng-untouched ng-valid ng-empty"
                        style="width:560px;height: 34px" type="text" ng-keyup="enterEvent($event)">
                </div>
                <div style="float:left;width:50px;"><span class="input-group-addon"
                        style="border-color: #1e293d; background-color: #1e293d;height: 34px" ng-click="solrSearch()">搜索</span>
                </div>
            </form>
        </div>
    </div>
    ``
    对应请求后台的js这个是使用anglarjs写的
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20190822105208386.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA2MjM4NA==,size_16,color_FFFFFF,t_70)
    
    展开全文
  • SpringBoot整合 solr

    千次阅读 2018-05-23 12:12:43
    接下来,介绍SpringBoot整合solr,那么闲话不多说,直接开始吧~一:在SpringBoot项目中引入依赖关系,在pom.xml中加入: &lt;properties&gt; &lt;spring.data.solr.version&gt;2.1.1.RE...

    引言:solr想必我们都已经很熟悉了吧,solr服务器搭建好,数据导入之后。在我们实际项目开发中,该怎么整合solr呢?

    接下来,介绍SpringBoot整合solr,那么闲话不多说,直接开始吧~

    一:在SpringBoot项目中引入依赖关系,在pom.xml中加入:

     <properties>
            <spring.data.solr.version>2.1.1.RELEASE</spring.data.solr.version>
        </properties>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.data</groupId>
                    <artifactId>spring-data-solr</artifactId>
                    <version>${spring.data.solr.version}</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <dependencies>  
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-solr</artifactId>
            </dependency>
    
            <!-- 默认 starter 会加载 solrj 进来, 下面这个可不引-->
            <dependency>
                <groupId>org.apache.solr</groupId>
                <artifactId>solr-solrj</artifactId>
                <version>6.6.2</version>
            </dependency>
        </dependencies>

    二:solr配置文件,application.properties(solr配置信息我是在这个配置文件,当然还有其他的配置方法,根据你们习惯)

    spring.data.solr.host=http://10.0.2.42:8983/solr/

    如果指定具体的Core(core我理解为集合)话,可以写成

    spring.data.solr.host=http://10.0.2.42:8983/solr/collectionname

    collectionname是core的名字,可以在core  admin选项中进行配置

    我们可以把collectingname理解为数据库的概念,在操作时,如果有多个core,就可以切换core


    三:solr的controller类

    import org.apache.solr.client.solrj.SolrClient;
    import org.apache.solr.client.solrj.SolrQuery;
    import org.apache.solr.client.solrj.response.QueryResponse;
    import org.apache.solr.common.SolrDocument;
    import org.apache.solr.common.SolrDocumentList;
    import org.apache.solr.common.SolrInputDocument;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    import java.util.Map;
    import java.util.UUID;
    
    @RestController
    @RequestMapping("solr")
    public class SolrController {
    
        @Autowired
        private SolrClient client;
    
        /**
         * 新增/修改 索引
         * 当 id 存在的时候, 此方法是修改(当然, 我这里用的 uuid, 不会存在的), 如果 id 不存在, 则是新增
         * @return
         */
        @RequestMapping("add")
        public String add() {
            String uuid = UUID.randomUUID().toString().replaceAll("-", "");
            try {
                SolrInputDocument doc = new SolrInputDocument();
                doc.setField("id", uuid);
                doc.setField("content_ik", "我是中国人, 我爱中国");
    
                /* 如果spring.data.solr.host 里面配置到 core了, 那么这里就不需要传 collection1 这个参数
                 * 下面都是一样的
                 */
    
                client.add("collection1", doc);
                //client.commit();
                client.commit("collection1");
                return uuid;
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return "error";
        }
    
        /**
         * 根据id删除索引
         * @param id
         * @return
         */
        @RequestMapping("delete")
        public String delete(String id)  {
            try {
                client.deleteById("collection1",id);
                client.commit("collection1");
    
                return id;
            } catch (Exception e) {
                e.printStackTrace();
            }
    
    
            return "error";
        }
    
        /**
         * 删除所有的索引
         * @return
         */
        @RequestMapping("deleteAll")
        public String deleteAll(){
            try {
    
                client.deleteByQuery("collection1","*:*");
                client.commit("collection1");
    
                return "success";
            } catch (Exception e) {
                e.printStackTrace();
            }
            return "error";
        }
    
        /**
         * 根据id查询索引
         * @return
         * @throws Exception
         */
        @RequestMapping("getById")
        public String getById() throws Exception {
            SolrDocument document = client.getById("collection1", "536563");
            System.out.println(document);
            return document.toString();
        }
    
        /**
         * 综合查询: 在综合查询中, 有按条件查询, 条件过滤, 排序, 分页, 高亮显示, 获取部分域信息
         * @return
         */
        @RequestMapping("search")
        public Map<String, Map<String, List<String>>> search(){
    
            try {
                SolrQuery params = new SolrQuery();
    
                //查询条件, 这里的 q 对应 下面图片标红的地方
                params.set("q", "手机");
    
                //过滤条件
                params.set("fq", "product_price:[100 TO 100000]");
    
                //排序
                params.addSort("product_price", SolrQuery.ORDER.asc);
    
                //分页
                params.setStart(0);
                params.setRows(20);
    
                //默认域
                params.set("df", "product_title");
    
                //只查询指定域
                params.set("fl", "id,product_title,product_price");
    
                //高亮
                //打开开关
                params.setHighlight(true);
                //指定高亮域
                params.addHighlightField("product_title");
                //设置前缀
                params.setHighlightSimplePre("<span style='color:red'>");
                //设置后缀
                params.setHighlightSimplePost("</span>");
    
                QueryResponse queryResponse = client.query(params);
    
                SolrDocumentList results = queryResponse.getResults();
    
                long numFound = results.getNumFound();
    
                System.out.println(numFound);
    
           //获取高亮显示的结果, 高亮显示的结果和查询结果是分开放的
                Map<String, Map<String, List<String>>> highlight = queryResponse.getHighlighting();
    
                for (SolrDocument result : results) {
                    System.out.println(result.get("id"));
                    System.out.println(result.get("product_title"));
                    //System.out.println(result.get("product_num"));
                    System.out.println(result.get("product_price"));
                    //System.out.println(result.get("product_image"));
    
                    Map<String, List<String>> map = highlight.get(result.get("id"));
                    List<String> list = map.get("product_title");
                    System.out.println(list.get(0));
    
                    System.out.println("------------------");
                    System.out.println();
                }
                return highlight;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
    }

    希望能够帮到您,完!


    展开全文
  • Springboot整合Solr详细讲解

    万次阅读 2020-07-28 14:33:44
    SpringBoot整合Solr 1、添加整合依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-solr</artifactId> </dependency> ...

    搭建Solr环境

    SpringBoot整合Solr

    1、添加整合依赖

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

    2、配置application.yml
    在这里插入图片描述
    3、注入Solr对象,实现crud

    @RunWith(SpringRunner.class)
    @SpringBootTest
    class ShopSearchApplicationTests {
        @Autowired
        private SolrClient solrClient;
        /*
        * 添加  id 不同为新增
        * 修改  id 相同为修改
        * */
        @Test
        public void add() throws IOException, SolrServerException {
            //创建document对象
            SolrInputDocument document=new SolrInputDocument();
            //添加的时候,必须加上id属性,否则报错
            //属性值为object类型,传入的属性如果是BigDecimal等其他非Object类型的,需要转为Object类型,否则报错
            document.addField("id",2);
            document.addField("gname","苹果手机");
            document.addField("gimage","http://www.iphone.com");
            document.addField("ginfo","外国手机");
            document.addField("gprice",6999.88);
            document.addField("gsave",3232);
            solrClient.add(document);
            solrClient.commit();
        }
    
        @Test
        public void query() throws IOException, SolrServerException {
            SolrQuery solrQuery=new SolrQuery();
            //查询的属性必须在solr库中有定义 ,否则会报错:
            //Error from server at http://192.168.65.128:8080/solr: undefined field gnames
            //只针对于gname属性进行查询
            //solrQuery.setQuery("gname:苹果手机");
            //针对多属性进行查询(注意多条件连接时,之间要有空格)
            //solrQuery.setQuery("gname:手机 || ginfo:苹果");
            String keyword="手机";
            solrQuery.setQuery("gname:"+keyword+" || ginfo:"+keyword);
            QueryResponse queryResponse = solrClient.query(solrQuery);
            SolrDocumentList results = queryResponse.getResults();
            for (SolrDocument document:results) {
                String id= (String) document.get("id");
                String gname= (String) document.get("gname");
                String gimage= (String) document.get("gimage");
                String ginfo= (String) document.get("ginfo");
                float gprice= (float) document.get("gprice");
                int gsave= (int) document.get("gsave");
                System.out.println(id+"  "+gname+"  "+gimage+"  "+ginfo+"  "+gprice+"  "+gsave);
            }
        }
        @Test
        public void delete() {
            try {
                //根据id进行删除
                //solrClient.deleteById("7");
                //根据查询后的结果进行删除
                solrClient.deleteByQuery("gname:安定");
                solrClient.commit();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    

    4、添加对象到索引库

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @TableName("goods")
    public class Goods implements Serializable {
        //mybatisPlus默认开启了主键回填策略,只需要在实体类中,指明主键id即可
        @TableId(type = IdType.AUTO)
        private int id ;
        private String gname;
        private BigDecimal gprice;
        private int gsave;
        private String ginfo;
        private String gimage;
        private int status;
        @TableField("create_time")
        private Date createTime=new Date();
        private int tid;
    }
     /*
        * 添加商品时,将商品添加到搜索库中
        * */
        @Override
        public int insert(Goods goods) {
            SolrInputDocument solrInputDocument=new SolrInputDocument();
            solrInputDocument.addField("id",goods.getId());
            solrInputDocument.addField("gname",goods.getGname());
            solrInputDocument.addField("gimage",goods.getGimage());
            solrInputDocument.addField("ginfo",goods.getGinfo());
            solrInputDocument.addField("gsave",goods.getGsave());
            //不能传入BigDecimal类型
            solrInputDocument.addField("gprice",goods.getGprice().doubleValue());
            try {
                solrClient.add(solrInputDocument);
                solrClient.commit();
                return 1;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return 0;
        }
    

    5、搜索关键字高亮显示

    @Autowired
    private SolrClient solrClient;
    @Override
    public List<Goods> searchGoodsByKeyword(String keyword) {
        SolrQuery solrQuery=new SolrQuery();
        if (keyword==null){
            //搜索全部商品
            solrQuery.setQuery("*:*");
        }else{
            //根据条件搜索(注意多条件连接时,之间要有空格)
            solrQuery.setQuery("gname:"+keyword+" || ginfo:"+keyword);
        }
    
        //设置高亮
        solrQuery.setHighlight(true);
        solrQuery.setHighlightSimplePre("<font color='red'>");
        solrQuery.setHighlightSimplePost("</font>");
       //添加需要高亮的字段
        solrQuery.addHighlightField("gname");
    
        try {
            QueryResponse results = solrClient.query(solrQuery);
    
            //获得高亮的结果
            //Map<id,Map<Field,List<String>>>
            //id:有高亮的商品id    Field:当前商品有高亮的字段   List:高亮的内容
            Map<String, Map<String, List<String>>> highlighting = results.getHighlighting();
    
            SolrDocumentList documents = results.getResults();
            List<Goods> goodsList=new ArrayList<>();
            for (SolrDocument document:documents) {
                Goods goods=new Goods();
                goods.setId(Integer.parseInt(document.get("id")+""));
                goods.setGname(document.get("gname")+"");
                goods.setGimage(document.get("gimage")+"");
                goods.setGprice(BigDecimal.valueOf(Double.parseDouble(document.get("gprice")+"")));
                goods.setGsave(Integer.parseInt(document.get("gsave")+""));
                goodsList.add(goods);
    
                //判断当前商品是否有高亮     根据商品id进行判断
                if (highlighting.containsKey(goods.getId()+"")){
                    //获取有高亮的内容
                    Map<String, List<String>> map = highlighting.get(goods.getId() + "");
                    //获取高亮的内容
                    String gname = map.get("gname").get(0);
                    //将高亮的内容替换到对象中
                    goods.setGname(gname);
                }
            }
            return goodsList;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    

    6、thymeleaf页面加载高亮显示的属性
    ——th:utext(以html的方式解析) 、th:text(以文本的方式解析)

     <li th:each="good :${goods}">
        <dl>
            <dt><a ><img th:src="|http://192.168.65.128/${#strings.setSplit(good.gimage,'|')[0]}|"/></a></dt>
            <dd class="title"><a th:utext="${good.gname}">OCIAIZO春装水洗做旧短外套复古磨白短款牛仔外套春01C1417</a></dd>
            <dd class="content">
                <span class="goods_jiage"><strong th:text="${#numbers.formatCurrency(good.gprice)}">249.00</strong></span>
                <span class="goods_chengjiao">库存:<a th:text="${good.gsave}"></a></span>
            </dd>
        </dl>
    </li>
    

    既然看到这里了,不妨点个赞,加个关注把。。。

    展开全文
  • 主要介绍了springboot整合solr的方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Springboot整合Solr

    千次阅读 2019-01-23 16:29:19
    一、Solr概述 什么是Solr Solr 是Apache下的一个顶级开源项目,采用Java开发,它是基于Lucene的全文搜索服务器。Solr提供了比Lucene更为丰富的查询语言,同时实现了可配置、可扩展,并对索引、搜索性能进行了优化...
  • springboot 整合 solr

    2019-09-16 23:42:06
    一、下载 solr 下载地址 ,选择你想要下载的版本 http://archive.apache.org/dist/lucene/solr/7.5.0/ 下载解压 二、启动 solr solr 的启动方式有多种,可以结合 tomcat,新版本的 solr 可以直...
  • Springboot整合solr+thymeleaf
  • springBoot整合solr

    千次阅读 2018-05-14 09:24:09
    --solr--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.data&lt;/groupId&gt; &lt;artifactId&gt;spring-data-solr&lt;/artifactId&gt; &lt;...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 217
精华内容 86
关键字:

springboot整合solr

spring 订阅