SpringBoot-Solr教程

转x33g5p2x  于2021-09-22 转载在 Spring  
字(43.5k)|赞(0)|评价(0)|浏览(474)

安装solr教程

使用docker安装

docker pull solr

启动容器

docker run --name blog-solr -d -p 8983:8983 solr   #创建容器

docker update --restart=always blog-solr    #自动启动

创建ik分词器 (核心)

docker exec -it --user=solr blog-solr bin/solr create_core -c Ik_core

出现 Created new core ‘Ik_core’ 即创建成功
1.
浏览器访问

浏览器输入 IP:8983 访问 我这里是服务器上搭建的 我的ip是49.232.169.170

http://49.232.169.170:8983/

访问成功后显示

solr配置中文分词器 5.2 下载Ik文件

注意以下步骤 每一步都要小心翼翼的 慢慢来 否则一不留神 就完蛋

链接：https://pan.baidu.com/s/1lg7biZdb2ZsKSOdkDzHaTQ
提取码：1234

创建个目录

mkdir -p /mnt/Ik/
cd /mnt/Ik/

使用工具将下载的Ik文件放在这里 然后进行解压

unzip  solr-lib.zip

我们先进入到solr 里看看到底是什么版本的

docker exec -it  blog-solr  /bin/bash
pwd    #路径   /opt/solr-8.7.0

exit   #退出

然后将文件复制到docker 里的solr 里 注意把下面全部的 /opt/solr-8.7.0 改为你的路径

docker cp ik-analyzer-8.3.0.jar blog-solr:/opt/solr-8.7.0/server/solr-webapp/webapp/WEB-INF/lib/
docker cp ik-analyzer-solr7-7.x.jar blog-solr:/opt/solr-8.7.0/server/solr-webapp/webapp/WEB-INF/lib/
   docker cp solr-dataimporthandler-8.4.0.jar blog-solr:/opt/solr-8.7.0/server/solr-webapp/webapp/WEB-INF/lib/
   docker cp solr-dataimporthandler-extras-8.4.0.jar blog-solr:/opt/solr-8.7.0/server/solr-webapp/webapp/WEB-INF/lib/

然后在 /mnt/Ik/ 下面创建 IKAnalyzer.cfg.xml

cd   /mnt/Ik/ 
vi  IKAnalyzer.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
 
<properties>
    <comment>IK Analyzer 扩展配置</comment>
     <!--用户可以在这里配置自己的扩展字典 -->
    <entry key="ext_dict">ext.dic;</entry>
     <!--用户可以在这里配置自己的扩展停止词字典-->
    <entry key="ext_stopwords">stopword.dic;</entry>
</properties>

进入solr容器创建文件夹

docker exec -it --user=root blog-solr /bin/bash

cd  /opt/solr-8.7.0/server/solr-webapp/webapp/WEB-INF 

mkdir classes

exit

docker cp IKAnalyzer.cfg.xml blog-solr:/opt/solr-8.7.0/server/solr-webapp/webapp/WEB-INF/classes/

修改managed-schema

docker exec -it --user=root blog-solr /bin/bash

在修改之前需要安装vim

cd /etc/apt && mv /etc/apt/sources.list /etc/apt/sources.list.bak
echo "deb http://mirrors.163.com/debian/ stretch main non-free contrib" >> /etc/apt/sources.list
    echo "deb http://mirrors.163.com/debian/ stretch-updates main non-free contrib" >> /etc/apt/sources.list
    echo "deb http://mirrors.163.com/debian/ stretch-backports main non-free contrib" >> /etc/apt/sources.list
    echo "deb-src http://mirrors.163.com/debian/ stretch main non-free contrib" >> /etc/apt/sources.list
    echo "deb-src http://mirrors.163.com/debian/ stretch-updates main non-free contrib" >> /etc/apt/sources.list
    echo "deb-src http://mirrors.163.com/debian/ stretch-backports main non-free contrib" >> /etc/apt/sources.list
    echo "deb http://mirrors.163.com/debian-security/ stretch/updates main non-free contrib" >> /etc/apt/sources.list
 echo "deb-src http://mirrors.163.com/debian-security/ stretch/updates main non-free contrib" >> /etc/apt/sources.list
apt-get update
apt-get install libtinfo5

然后有可能会提示问你是否继续 不要直接回车 和 yue 而是这句话 Yes, do as I say!

apt-get install vim

之后在执行下面的命令

cp /opt/solr-8.7.0/contrib/analysis-extras/lucene-libs/lucene-analyzers-smartcn-8.7.0.jar /opt/solr-8.7.0/server/solr-webapp/webapp/WEB-INF/lib/

cd /var/solr/data/Ik_core/conf

vim  managed-schema

在 <schema> </schema> 内最下面添加: 如果无法使用鼠标右键那么 set mouse-=a 之后就可以了

<fieldType name="text_ik" class="solr.TextField">
	 <analyzer type="index">
		 <tokenizer class="org.wltea.analyzer.lucene.IKTokenizerFactory" useSmart="false" conf="ik.conf"/>
		 <filter class="solr.LowerCaseFilterFactory"/>
	 </analyzer>
	 <analyzer type="query">
		 <tokenizer class="org.wltea.analyzer.lucene.IKTokenizerFactory" useSmart="true" conf="ik.conf"/>
		 <filter class="solr.LowerCaseFilterFactory"/>
	 </analyzer>
 </fieldType>

 <fieldType name="text_cn" class="solr.TextField" positionIncrementGap="100">

	 <analyzer type="index">
		 <tokenizer class="org.apache.lucene.analysis.cn.smart.HMMChineseTokenizerFactory"/>
	 </analyzer>
	 <analyzer type="query">
 	 <tokenizer class="org.apache.lucene.analysis.cn.smart.HMMChineseTokenizerFactory"/>
	 </analyzer>
 </fieldType>
cd /var/solr/data/Ik_core/conf

vi  solrconfig.xml

修改solrconfig.xml 在<config> </config>最下面添加

<requestHandler name="/dataimport" class="org.apache.solr.handler.dataimport.DataImportHandler"> 
    <lst name="defaults">
  <str name="config">db-data-config.xml</str> 
    </lst> 
</requestHandler>

重启solr

exit
   
docker restart blog-solr

查看日志看看有没有报错

docker logs blog-solr

测试 查看分词器是否配置成功

测试分词器是否能够正常分词 (以后我们就在这里查看分词的结果)

测试搜索功能 我们先添加doc

一次添加一个

{"id":"201701","title":"这是第一个索引","category":"solr学习"}
{"id":"201702","title":"这是第二个索引","category":"solr学习"}

注意:因为id是主键,所以是唯一的

现在我们查询一下刚刚创建的索引,先查询所有/*😗

可以看到刚刚我们已经建立的索引.

现在我们对对title字段进行搜索 查询title 里包含一 的

到此solr 安装测试完毕 我们接下来就在代码中实现

我们来说一说这些参数是干嘛的

q:代表查询操作 。

fq:相当于二级过滤 满足q的同时要满足fq。

sort：排序字段 可以多个 。

start – 返回第一条记录在完整找到结果中的偏移位置，0开始，一般分页用。
rows – 指定返回结果最多有多少条记录，配合start来实现分页。

fl- field作为逗号分隔的列表指定文档结果中应返回的 Field 集。默认为 “/*”，指所有的字段。

df – 默认的查询字段，一般默认指定(可以不用管)

其他的都不用管 默认就行

q: 查询里的符号 我们最常用的就是:

符号意义
“:”指定字段查指定值，如返回所有值/*😗
“?”表示单个任意字符的通配
“/*”表示多个任意字符的通配（不能在检索的项开始使用/*或者?符号）
“~”表示模糊检索，如检索拼写类似于”roam”的项这样写：roam将找到形如foam和roams的单词；roam0.8，检索返回相似度在0.8以上的记录。
AND ||布尔操作符
OR、&&布尔操作符
NOT、!、-（排除操作符不能单独与项使用构成查询）
“+”存在操作符，要求符号”+”后的项必须在文档相应的域中存在²
( )用于构成子查询
[]包含范围检索，如检索某时间段记录，包含头尾，date:[201507 TO 201510]
{}不包含范围检索，如检索某时间段记录，不包含头尾date:{201507 TO 201510}

手动创建核心(表)

我们之前是通过docker 创建容器时候创建了一个核心Ik_core (可以把它比作数据库的表) 但是我们不可能一直用这一个表把 所以需要我们会进行手动创建核心

第一步 需要手动先在solr 的 /var/solr/data/ 下面创建一个目录这个目录名称就是核心名称

docker exec -it --user=root blog-solr /bin/bash

mkdir -p /var/solr/data/new_core

然后将Ik_core 里的配置文件考入new_core目录里

cp   -r /var/solr/data/Ik_core/conf  /var/solr/data/new_core

重启 solr

docker restart blog-solr

然后在solr中进行创建核心

java使用solr

其实无非就是 增 删 改 查 分页 排序 高亮 这些 好了 下面就开始进入正题

需要的maven

<dependency>
            <groupId>org.apache.solr</groupId>
            <artifactId>solr-solrj</artifactId>
            <version>4.10.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>provided</scope>
        </dependency>


    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

配置文件 solrs.properties

#solr 的 ip地址:端口号/solr是固定的
solr_url=http://49.232.169.170:8983/solr
# 核心
solr_core=Ik_core
# solr最大连接数
defaultMaxConnectionsPerHost=1000
# solr所有最大连接数
maxTotalConnections=10000
# 设置连接超时时间（单位毫秒）
connectionTimeout=60000
# 设置读数据超时时间(单位毫秒)
soTimeout=60000
# 遵循从定向
followRedirects=true
# 允许压缩
allowCompression=true

实体类BlogCore

package cn.solr;

import org.apache.solr.client.solrj.beans.Field;

import java.util.Date;

public class BlogCore {
    @Field
    private String blogId;
    @Field
    private String blogTitle;
    @Field
    private String blogContent;
    @Field
    private Date createTime;

    public String getBlogId() {
        return blogId;
    }

    public void setBlogId(String blogId) {
        this.blogId = blogId;
    }

    public String getBlogTitle() {
        return blogTitle;
    }

    public void setBlogTitle(String blogTitle) {
        this.blogTitle = blogTitle;
    }

    public String getBlogContent() {
        return blogContent;
    }

    public void setBlogContent(String blogContent) {
        this.blogContent = blogContent;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }


    @Override
    public String toString() {
        return "BlogCore{" +
                "blogId='" + blogId + '\'' +
                ", blogTitle='" + blogTitle + '\'' +
                ", blogContent='" + blogContent + '\'' +
                ", createTime=" + createTime +
                '}';
    }
}

注意 实体类没有id 可能会说 blogId不是id吗 no 这不是 这是你自己定义的字段 而不是solr里的默认id主键

也就是说solr会自动随机生成id 如果想要保证数据的唯一那么 需要你自己添加id值

之后在插入数据时候如果id值相同那么就会覆盖原来id的内容

@Id
    @Field
    private  String id;

工具类SolrUtils

package cn.solr;

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.impl.XMLResponseParser;
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.SolrDocumentList;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.*;

//不要想着 使用 * ~ ...这些通配 其实没什么卵用 分词器都给你分词好了 直接使用 : 就行了
//如果涉及到 区间的话 可以使用 []
//比如 name:[* TO 100] 查询name小于等于100 name:[100 TO *] 查询name值大于等于100
//我们也可以用来 查询时间段或者价格区间 name:[ 时间1 TO 时间2] 查询name里时间是 时间1 到 时间2之间的数据
//比如 [2021-01-01T10:52:25Z TO 2021-02-8T10:52:25Z] 注意在Sorl中时间格式 加T 和 Z的
//注意 liunx 要慢8小时

public class SolrUtils {

    private static HttpSolrServer server = null;

    static {
        Properties properties=new Properties();
        try {
            InputStream resources = SolrUtils.class.getClassLoader().getResourceAsStream("solrs.properties");
            properties.load( resources);
            if (server == null) {
                String  baseUrl="";
                String solr_url = properties.getProperty("solr_url");
                String solr_core = properties.getProperty("solr_core");
                baseUrl=solr_url+"/"+solr_core;

                server = new HttpSolrServer(baseUrl);
                //解析查询出来的内容
                XMLResponseParser xmlResponseParser=new XMLResponseParser();
                server.setParser(xmlResponseParser);
                String defaultMaxConnectionsPerHost = properties.getProperty("defaultMaxConnectionsPerHost");
                server.setDefaultMaxConnectionsPerHost(Integer.parseInt(defaultMaxConnectionsPerHost));
                String maxTotalConnections = properties.getProperty("maxTotalConnections");
                server.setMaxTotalConnections(Integer.parseInt(maxTotalConnections));
                String connectionTimeout = properties.getProperty("connectionTimeout");
                server.setConnectionTimeout(Integer.parseInt(connectionTimeout));
                String soTimeout = properties.getProperty("soTimeout");
                server.setSoTimeout(Integer.parseInt(soTimeout));
                String followRedirects = properties.getProperty("followRedirects");
                server.setFollowRedirects(Boolean.parseBoolean(followRedirects));
                String allowCompression = properties.getProperty("allowCompression");
                server.setAllowCompression(Boolean.parseBoolean(allowCompression));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /** * 查询全部 返回的是json [{},{},{}] 用的时候转为map就行了 * */
    public static List<Map<String,String>> soleAll() {
        List<Map<String,String>> list=new ArrayList<>();
        SolrQuery query = new SolrQuery("*:*");
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        SolrDocumentList results = resp.getResults();

        for (int i = 0; i <results.size()  ; i++) {
            Map<String,String> map=new HashMap<>();
            for (Map.Entry<String, Object> entry : resp.getResults().get(i).entrySet()) {
                map.put(entry.getKey(),entry.getValue().toString());

            }
            list.add(map);
        }
        return list;
    }

    // soleAll() 演示
    @Test
    public void soleAll0_test(){
        List<Map<String, String>> list = soleAll();
        System.out.println(list);
    }

    // 查询所有指定字段 所匹配的值 满足条件的 所有内容 (也可以称为关键字 我们使用的是ik分词器)
    public static List<Map<String,String>> soleAll(String name,String keyword) {
        List<Map<String,String>> list=new ArrayList<>();
        SolrQuery query = new SolrQuery(name+":"+keyword);
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        SolrDocumentList results = resp.getResults();

        for (int i = 0; i <results.size()  ; i++) {
            Map<String,String> map=new HashMap<>();
            for (Map.Entry<String, Object> entry : resp.getResults().get(i).entrySet()) {
                map.put(entry.getKey(),entry.getValue().toString());

            }
            list.add(map);
        }

        return list;
    }

    // soleAll() 演示
    @Test
    public void soleAll1_test(){
        List<Map<String, String>> list = soleAll("blogTitle","龙头");
        System.out.println("数量"+list.size());
        System.out.println(list);
    }



    // 查询所有指定字段的值
    public static List<String> soleFieldAll(String name){
        List<String> list=new ArrayList<>();
        SolrQuery query = new SolrQuery(name+":*");  //查询全部内容
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        SolrDocumentList documents =  resp.getResults();
// 获取指定字段 内容
        for (SolrDocument doc : documents) {
            list.add(doc.get(name).toString());
        }

        return list;
    }

    // soleAll(String name) 演示
    @Test
    public void soleFieldAll0_test(){
        List<String> list = soleFieldAll("blogTitle");
        System.out.println(list);
    }

    // 查询所有指定字段 的 匹配值 (也可以称为关键字 我们使用的是ik分词器)
    public static List<String> soleFieldAll(String name,String keyword){
        List<String> list=new ArrayList<>();
        SolrQuery query = new SolrQuery(name+":"+keyword);  //查询全部内容
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        SolrDocumentList documents =  resp.getResults();
// 获取指定字段 内容
        for (SolrDocument doc : documents) {
            list.add(doc.get(name).toString());
        }

        return list;
    }
    // soleAll(String name) 演示
    @Test
    public void soleFieldAll1_test(){
        List<String> list = soleFieldAll("blogTitle","龙头");
        System.out.println(list);
    }


    // 查询高亮

    /** * * @param name 查询的字段 * @param keyword 查询的条件 * ----------分页 * @param start 开始 * @param rows 结束 * ----------排序 * @param sort 按照什么字段进行排序查询 * ----------需要显示高亮的字段 * * @param fields 查询成功后 需要进行高亮的字段 * * */
    public static  List<Map<String, String>> soleHighlighting(String name ,String keyword,int start,int rows,String sort,String... fields){
        SolrQuery query = new SolrQuery();
        // 设置查询条件
        query.setQuery(name+":"+ keyword);
        // 设置分页信息
        query.setStart( start);  //开始
        query.setRows(rows);  //结束
        // 按照blogId字段进行排序查询
        query.setSort(sort, SolrQuery.ORDER.desc);   //desc降序 asc升序
        // 只查询显示哪些字段
        StringBuilder stringBuilder=new  StringBuilder();
        for (String field : fields) {
            stringBuilder.append(field+",");
        }
        stringBuilder.append("id");
        query.setFields(stringBuilder.toString().split(","));
        // 设置高亮信息
        query.setHighlight(true);
        for (String field : fields) {
            query.addHighlightField(field );//设置高亮字段
        }

        query.setHighlightSimplePre("<font color='red'>"); //设置高亮的前缀
        query.setHighlightSimplePost("</font>"); //设置高亮的后缀
        // 执行查询
        QueryResponse response = null;
        try {
            response = server.query(query);
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        // 获取doc文档
        SolrDocumentList documents = response.getResults();

        // 获取高亮显示信息
        Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();

        List<Map<String, String>> list=new ArrayList<>();
// 获取指定字段高亮后的内容
        for (SolrDocument doc : documents) {
            LinkedHashMap<String,String> map=new LinkedHashMap<>();//保证顺序

            for (String field : fields) {
                List<String> hightDocs = highlighting.get(doc.get("id")).get(field );
                if (hightDocs != null)
                    map.put(field,hightDocs.get(0));
                else {
                    map.put(field,doc.get(field).toString());
                }

            }

            list.add(map);

        }

        return  list;
    }

    @Test
    public void soleHighlighting_test(){

        //需要显示的字段
        String[] fields={"blogContent", "blogTitle","blogId"};

        List<Map<String, String>> list = soleHighlighting("blogTitle", "龙头", 0, 50, "blogId",  fields);

        System.out.println(list );

    }



    // 删除全部数据

    public static void  deleteDocumentAll(){
        //删除所有的索引
        try {
            server.deleteByQuery("*:*");
            //提交修改
            server.commit();

        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }

    }

    @Test
    public void deleteDocument_test1() throws Exception {
        deleteDocumentAll();
    }

    // 按照 字段匹配 删除
    public static void  deleteDocument(String id){
        //删除所有的索引
        try {
            server.deleteById(id);  //删除指定 id 的文档
            //提交修改
            server.commit();
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }

    }

    @Test
    public void deleteDocument_test2() throws Exception {
        deleteDocument("dd3eea7a-36eb-4f14-b546-d52ab0137420");
    }
      //删除指定字段 的所有匹配数据
    public static void  deleteDocument(String name,String keyword){

        try {
            server.deleteByQuery(name+":"+ keyword);
            //提交修改
            server.commit();
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }

    }


    @Test
    public void deleteDocument_test3() throws Exception {
        deleteDocument("blogTitle","xxx");
    }




    //添加数据
    /** * 添加 id是唯一的 但是 如果你实体类中没有指定id 那么solr 会自动给你分配 比如:91dc8523-324c-4fa1-944d-fb7e100da857 * 我说的id是名称完全一样 id=id */

    public void soleAdd(Object object){
        try {

            server.addBean(object);
            UpdateResponse updateResponse = server.commit();//提交请求
            if (updateResponse.getStatus()!=0){
                throw new Exception("添加失败");
            }      //返回0 添加成功

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void solrAdd_test(){
        // 实体类
        BlogCore blog = new BlogCore();
        blog.setBlogId("9");
        blog.setBlogTitle("超越业x龙xxx头xxx");
        blog.setBlogContent("达摩院一定也必须要超越英特尔，必须超越微软，必须超越IBM，因为我们生于二十一世纪，我们是有机会后发优势的1。");
        blog.setCreateTime(new Date());

        soleAdd(blog);
    }




    //多线程 并发测试
    public static void main(String[] args) {

        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //需要显示的字段
                    String[] fields={"blogContent", "blogTitle","blogId"};

                    List<Map<String, String>> list = soleHighlighting("blogTitle", "龙头", 0, 50, "blogId",  fields);

                    System.out.println(list );
                }
            }).start();
        }
    }

}

里面有配套到测试

Spring使用solr

简单来说就是把 HttpSolrServer 注册到容器里就行了

需要的Maven

<dependencies>

        <!--Spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.apache.solr</groupId>
            <artifactId>solr-solrj</artifactId>
            <version>4.10.2</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

需要的配置文件 spring-solr.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" xmlns:http="http://www.springframework.org/schema/c" 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="cn.solr"/>

    <!--定义solr的server-->
    <bean id="httpSolrServer" class="org.apache.solr.client.solrj.impl.HttpSolrServer">
        <constructor-arg index="0" value="http://49.232.169.170:8983/solr/Ik_core"/>
        <!-- 设置响应解析器 -->
        <property name="parser">
            <bean class="org.apache.solr.client.solrj.impl.XMLResponseParser"/>
        </property>
        <!-- 设置重试次数-->
        <property name="maxRetries" value="2"/>
        <!-- 建立连接的最长时间 -->
        <property name="connectionTimeout" value="60000"/>
        <!-- solr最大连接数-->
        <property name="defaultMaxConnectionsPerHost" value="1000"/>
<!-- # solr所有最大连接数-->
        <property name="maxTotalConnections" value="10000"/>
<!-- # 设置读数据超时时间(单位毫秒)-->
        <property name="soTimeout" value="10000"/>
<!-- # 遵循从定向-->
        <property name="followRedirects" value="true"/>
<!-- # 允许压缩-->
        <property name="allowCompression" value="true"/>
    </bean>

</beans>

创建 cn.solr 包 然后在下面创建

实体类BlogCore

package cn.solr;

import org.apache.solr.client.solrj.beans.Field;

import java.util.Date;

public class BlogCore {

    @Field
    private String blogId;
    @Field
    private String blogTitle;
    @Field
    private String blogContent;
    @Field
    private Date createTime;

    public String getBlogId() {
        return blogId;
    }

    public void setBlogId(String blogId) {
        this.blogId = blogId;
    }

    public String getBlogTitle() {
        return blogTitle;
    }

    public void setBlogTitle(String blogTitle) {
        this.blogTitle = blogTitle;
    }

    public String getBlogContent() {
        return blogContent;
    }

    public void setBlogContent(String blogContent) {
        this.blogContent = blogContent;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }


    @Override
    public String toString() {
        return "BlogCore{" +
                "blogId='" + blogId + '\'' +
                ", blogTitle='" + blogTitle + '\'' +
                ", blogContent='" + blogContent + '\'' +
                ", createTime=" + createTime +
                '}';
    }
}

工具类 SolrServerUtlis (我们使用注解的方式 注入到容器里了 )

package cn.solr;

import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServer;
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.SolrDocumentList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.io.IOException;
import java.util.*;

//不要想着 使用 * ~ ...这些通配 其实没什么卵用 分词器都给你分词好了 直接使用  :  就行了
//如果涉及到 区间的话 可以使用 []
//比如  name:[* TO 100]  查询name小于等于100   name:[100 TO *] 查询name值大于等于100
//我们也可以用来 查询时间段或者价格区间      name:[ 时间1 TO 时间2]   查询name里时间是 时间1 到 时间2之间的数据
//比如 [2021-01-01T10:52:25Z TO 2021-02-8T10:52:25Z]     注意在Sorl中时间格式 加T 和 Z的
//注意 liunx 要慢8小时

@Repository("SolrServerUtlis")
public class SolrServerUtlis {

    @Autowired
   private SolrServer server;

    /**
     * 查询全部  返回的是json   [{},{},{}]   用的时候转为map就行了
     *
     */
    public  List<Map<String,String>> soleAll() {
        List<Map<String,String>> list=new ArrayList<>();
        SolrQuery query = new SolrQuery("*:*");
        QueryResponse resp = null;
        try {

            resp = server.query(query);
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        SolrDocumentList results = resp.getResults();

        for (int i = 0; i <results.size()  ; i++) {
            Map<String,String> map=new HashMap<>();
            for (Map.Entry<String, Object> entry : resp.getResults().get(i).entrySet()) {
                String s = entry.getValue().toString();

                    map.put(entry.getKey(),s);
            }
            list.add(map);
        }
        return list;
    }

    // 查询所有指定字段 所匹配的值   满足条件的  所有内容    (也可以称为关键字  我们使用的是ik分词器)
    public  List<Map<String,String>> soleAll(String name,String keyword) {
        List<Map<String,String>> list=new ArrayList<>();
        SolrQuery query = new SolrQuery(name+":"+keyword);
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        SolrDocumentList results = resp.getResults();

        for (int i = 0; i <results.size()  ; i++) {
            Map<String,String> map=new HashMap<>();
            for (Map.Entry<String, Object> entry : resp.getResults().get(i).entrySet()) {
                String s = entry.getValue().toString();
                map.put(entry.getKey(),s);

            }
            list.add(map);
        }

        return list;
    }



    // 查询所有指定字段的值
    public  List<String> soleFieldAll(String name){
        List<String> list=new ArrayList<>();
        SolrQuery query = new SolrQuery(name+":*");  //查询全部内容
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        SolrDocumentList documents =  resp.getResults();
//     获取指定字段 内容
        for (SolrDocument doc : documents) {
            String s = doc.get(name).toString();
            list.add(s);
        }
        return list;
    }


    // 查询所有指定字段 的 匹配值   (也可以称为关键字 我们使用的是ik分词器)
    public  List<String> soleFieldAll(String name,String keyword){
        List<String> list=new ArrayList<>();
        SolrQuery query = new SolrQuery(name+":"+keyword);  //查询全部内容
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        SolrDocumentList documents =  resp.getResults();
//     获取指定字段 内容
        for (SolrDocument doc : documents) {
            String s = doc.get(name).toString();
            list.add(s);
        }
        return list;
    }


    // 查询高亮

    /**
     *
     * @param name 查询的字段
     * @param keyword  查询的条件
     *              ----------分页
     * @param  start 开始
     * @param rows  结束
     *              ----------排序
     * @param sort  按照什么字段进行排序查询
     *              ----------需要显示高亮的字段
     *
     * @param fields  查询成功后 需要进行高亮的字段
     *
     *
     */
    public   List<Map<String, String>> soleHighlighting(String name ,String keyword,int start,int rows,String sort,String... fields){
        SolrQuery query = new SolrQuery();
        // 设置查询条件
        query.setQuery(name+":"+ keyword);
        // 设置分页信息
        query.setStart( start);  //开始
        query.setRows(rows);  //结束
        // 按照blogId字段进行排序查询
        query.setSort(sort, SolrQuery.ORDER.desc);   //desc降序    asc升序
        // 只查询显示哪些字段
        StringBuilder stringBuilder=new  StringBuilder();
        for (String field : fields) {
            stringBuilder.append(field+",");
        }
        stringBuilder.append("id");
        query.setFields(stringBuilder.toString().split(","));
        // 设置高亮信息
        query.setHighlight(true);
        for (String field : fields) {
            query.addHighlightField(field );//设置高亮字段
        }

        query.setHighlightSimplePre("<font  color='red'>"); //设置高亮的前缀
        query.setHighlightSimplePost("</font>"); //设置高亮的后缀
        // 执行查询
        QueryResponse response = null;
        try {
            response = server.query(query);
        } catch (SolrServerException e) {
            e.printStackTrace();
        }
        // 获取doc文档
        SolrDocumentList documents = response.getResults();

        // 获取高亮显示信息
        Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();

        List<Map<String, String>> list=new ArrayList<>();
//     获取指定字段高亮后的内容
        for (SolrDocument doc : documents) {
            LinkedHashMap<String,String> map=new LinkedHashMap<>();//保证顺序

            for (String field : fields) {
                List<String> hightDocs = highlighting.get(doc.get("id")).get(field );
                if (hightDocs != null)
                    map.put(field,hightDocs.get(0));
                else {
                    map.put(field,doc.get(field).toString());
                }

            }

            list.add(map);

        }

        return  list;
    }



    // 删除全部数据

    public  void  deleteDocumentAll(){
        //删除所有的索引
        try {
            server.deleteByQuery("*:*");
            //提交修改
            server.commit();

        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }

    }



    //    按照 字段匹配 删除
    public  void  deleteDocument(String id){
        //删除所有的索引
        try {
            server.deleteById(id);  //删除指定 id 的文档
            //提交修改
            server.commit();
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }

    }


     //删除指定字段 的所有匹配数据
    public  void  deleteDocument(String name,String keyword){

        try {
            server.deleteByQuery(name+":"+ keyword);
            //提交修改
            server.commit();
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }

    }


    //添加数据
    /**
     * 添加   id是唯一的  但是 如果你实体类中没有指定id   那么solr 会自动给你分配 比如:91dc8523-324c-4fa1-944d-fb7e100da857
     * 我说的id是名称完全一样  id=id
     */

    public void soleAdd(Object object){
        try {

            server.addBean(object);
            UpdateResponse updateResponse = server.commit();//提交请求
            if (updateResponse.getStatus()!=0){
                throw new Exception("添加失败");
            }      //返回0 添加成功
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

测试

package cn.solr;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Date;
import java.util.List;
import java.util.Map;

public class test {

    @Test
    public void soleAll0(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-solr.xml");
        SolrServerUtlis  httpSolrServer =(SolrServerUtlis) context.getBean("SolrServerUtlis");
        List<Map<String, String>> list = httpSolrServer.soleAll();
        System.out.println(list);
    }

    @Test
    public void soleAll1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-solr.xml");
        SolrServerUtlis  httpSolrServer =(SolrServerUtlis) context.getBean("SolrServerUtlis");
        List<Map<String, String>> list = httpSolrServer.soleAll("blogTitle","龙头");
        System.out.println(list);
    }

    @Test
    public void soleFieldAll0(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-solr.xml");
        SolrServerUtlis  httpSolrServer =(SolrServerUtlis) context.getBean("SolrServerUtlis");
        List<String> list1 = httpSolrServer.soleFieldAll("blogTitle");
        System.out.println(list1);
    }
    @Test
    public void soleFieldAll1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-solr.xml");
        SolrServerUtlis  httpSolrServer =(SolrServerUtlis) context.getBean("SolrServerUtlis");
        List<String> list1 = httpSolrServer.soleFieldAll("blogTitle","龙头");
        System.out.println(list1);
    }

    @Test
    public void soleHighlighting(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-solr.xml");
        SolrServerUtlis  httpSolrServer =(SolrServerUtlis) context.getBean("SolrServerUtlis");

        //需要显示的字段
        String[] fields={"blogContent", "blogTitle","blogId"};

        List<Map<String, String>> list = httpSolrServer.soleHighlighting("blogTitle", "龙头", 0, 50, "blogId", fields);
        System.out.println(list );
    }

    @Test
    public void deleteDocumentAll() throws Exception {
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-solr.xml");
        SolrServerUtlis  httpSolrServer =(SolrServerUtlis) context.getBean("SolrServerUtlis");
        httpSolrServer.deleteDocumentAll();
    }

    @Test
    public void deleteDocument0() throws Exception {
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-solr.xml");
        SolrServerUtlis  httpSolrServer =(SolrServerUtlis) context.getBean("SolrServerUtlis");
        httpSolrServer.deleteDocument("dd3eea7a-36eb-4f14-b546-d52ab0137420");
    }
    @Test
    public void deleteDocument1() throws Exception {
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-solr.xml");
        SolrServerUtlis  httpSolrServer =(SolrServerUtlis) context.getBean("SolrServerUtlis");
        httpSolrServer.deleteDocument("blogTitle","xxx");
    }

    @Test
    public void soleAdd(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-solr.xml");
        SolrServerUtlis  httpSolrServer =(SolrServerUtlis) context.getBean("SolrServerUtlis");

        // 实体类
        BlogCore blog = new BlogCore();
        blog.setBlogId("1");
        blog.setBlogTitle("超越业x龙xxx头xxx");
        blog.setBlogContent("达摩院一定也必须要超越英特尔，必须超越微软，必须超越IBM，因为我们生于二十一世纪，我们是有机会后发优势的1。");
        blog.setCreateTime(new Date());

        httpSolrServer.soleAdd(blog);
    }

    //多线程 并发测试
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-solr.xml");
        SolrServerUtlis  httpSolrServer =(SolrServerUtlis) context.getBean("SolrServerUtlis");

        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //需要显示的字段
                    String[] fields={"blogContent", "blogTitle","blogId"};

                    List<Map<String, String>> list =  httpSolrServer.soleHighlighting("blogTitle", "龙头", 0, 50, "blogId",  fields);

                    System.out.println(list );
                }
            }).start();
        }
    }

}

如果在Spring+SpringMVC模式的话 无须使用ApplicationContext 直接

@Autowired
    private  SolrServerUtlis serverUtlis

就能使用了

SpringBoot使用solr

注意在SpringBoot中测试需要启动主程序入口后才能进行测试 应为配置solr的配置都在springboot里

需要的Maven

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>

    <dependencies>

        <!-- 开发 web 项目必须添加的-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>


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

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

需要的application.yml

server:
  port: 8511

spring:
  data:
    solr:
      host: http://49.232.169.170:8983/solr/Ik_core

创建 cn.solr 包然后在此包下添加如下:

启动类SolrApplication

package cn.solr;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SolrApplication {
    public static void  main(String[] args) {
        SpringApplication.run(SolrApplication.class,args);
    }
}

创建cn.solr.utils 包然后在此包下添加如下:

Springboot_SolrUtils (工具类)

package cn.solr.utils;

import cn.solr.entity.BlogCore;
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.SolrDocumentList;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.io.IOException;
import java.util.*;

//不要想着 使用 * ~ ...这些通配 其实没什么卵用 分词器都给你分词好了 直接使用 : 就行了
//如果涉及到 区间的话 可以使用 []
//比如 name:[* TO 100] 查询name小于等于100 name:[100 TO *] 查询name值大于等于100
//我们也可以用来 查询时间段或者价格区间 name:[ 时间1 TO 时间2] 查询name里时间是 时间1 到 时间2之间的数据
//比如 [2021-01-01T10:52:25Z TO 2021-02-8T10:52:25Z] 注意在Sorl中时间格式 加T 和 Z的
//注意 liunx 要慢8小时

@Repository("Springboot_SolrUtils")
public class Springboot_SolrUtils {

    @Autowired
    private SolrClient server;

  

    /** * 查询全部 返回的是json [{},{},{}] 用的时候转为map就行了 * */
    public  List<Map<String,String>> soleAll() {
        List<Map<String,String>> list=new ArrayList<>();
        SolrQuery query = new SolrQuery("*:*");
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }
        SolrDocumentList results = resp.getResults();

        for (int i = 0; i <results.size()  ; i++) {
            Map<String,String> map=new HashMap<>();
            for (Map.Entry<String, Object> entry : resp.getResults().get(i).entrySet()) {
                String s = entry.getValue().toString();
                map.put(entry.getKey(),s.substring(1,s.length()-1));

            }
            list.add(map);
        }
        return list;
    }


    // 查询所有指定字段 所匹配的值 满足条件的 所有内容 (也可以称为关键字 我们使用的是ik分词器)
    public  List<Map<String,String>> soleAll(String name,String keyword) {
        List<Map<String,String>> list=new ArrayList<>();
        SolrQuery query = new SolrQuery(name+":"+keyword);
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }
        SolrDocumentList results = resp.getResults();

        for (int i = 0; i <results.size()  ; i++) {
            Map<String,String> map=new HashMap<>();
            for (Map.Entry<String, Object> entry : resp.getResults().get(i).entrySet()) {
                String s = entry.getValue().toString();
                map.put(entry.getKey(),s.substring(1,s.length()-1));
            }
            list.add(map);
        }

        return list;
    }



    // 查询所有指定字段的值
    public  List<String> soleFieldAll(String name){
        List<String> list=new ArrayList<>();
        SolrQuery query = new SolrQuery(name+":*");  //查询全部内容
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }
        SolrDocumentList documents =  resp.getResults();
// 获取指定字段 内容
        for (SolrDocument doc : documents) {
            String s = doc.get(name).toString();
            list.add(s.substring(1,s.length()-1));
        }

        return list;
    }

  

    // 查询所有指定字段 的 匹配值 (也可以称为关键字 我们使用的是ik分词器)
    public  List<String> soleFieldAll(String name,String keyword){
        List<String> list=new ArrayList<>();
        SolrQuery query = new SolrQuery(name+":"+keyword);  //查询全部内容
        QueryResponse resp = null;
        try {
            resp = server.query(query);
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }
        SolrDocumentList documents =  resp.getResults();
// 获取指定字段 内容
        for (SolrDocument doc : documents) {
            String s = doc.get(name).toString();
            list.add(s.substring(1,s.length()-1));
        }

        return list;
    }



    // 查询高亮

    /** * * @param name 查询的字段 * @param keyword 查询的条件 * ----------分页 * @param start 开始 * @param rows 结束 * ----------排序 * @param sort 按照什么字段进行排序查询 * ----------需要显示高亮的字段 * * @param fields 查询成功后 需要进行高亮的字段 * * */
    public   List<Map<String, String>> soleHighlighting(String name ,String keyword,int start,int rows,String sort,String... fields){
        SolrQuery query = new SolrQuery();
        // 设置查询条件
        query.setQuery(name+":"+ keyword);
        // 设置分页信息
        query.setStart( start);  //开始
        query.setRows(rows);  //结束
        // 按照blogId字段进行排序查询
        query.setSort(sort, SolrQuery.ORDER.desc);   //desc降序 asc升序
        // 只查询显示哪些字段
        StringBuilder stringBuilder=new  StringBuilder();
        for (String field : fields) {
            stringBuilder.append(field+",");
        }
        stringBuilder.append("id");
        query.setFields(stringBuilder.toString().split(","));
        // 设置高亮信息
        query.setHighlight(true);
        for (String field : fields) {
            query.addHighlightField(field );//设置高亮字段
        }

        query.setHighlightSimplePre("<font color='red'>"); //设置高亮的前缀
        query.setHighlightSimplePost("</font>"); //设置高亮的后缀
        // 执行查询
        QueryResponse response = null;
        try {
            response = server.query(query);
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }
        // 获取doc文档
        SolrDocumentList documents = response.getResults();

        // 获取高亮显示信息
        Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();

        List<Map<String, String>> list=new ArrayList<>();
// 获取指定字段高亮后的内容
        for (SolrDocument doc : documents) {
            LinkedHashMap<String,String> map=new LinkedHashMap<>();//保证顺序

            for (String field : fields) {
                List<String> hightDocs = highlighting.get(doc.get("id")).get(field );
                if (hightDocs != null)
                    map.put(field,hightDocs.get(0));
                else {
                    map.put(field,doc.get(field).toString());
                }

            }

            list.add(map);

        }

        return  list;
    }


    // 删除全部数据

    public  void  deleteDocumentAll(){
        //删除所有的索引
        try {
            server.deleteByQuery("*:*");
            //提交修改
            server.commit();

        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }

    }

  

    // 按照 字段匹配 删除
    public  void  deleteDocument(String id){
        //删除所有的索引
        try {
            server.deleteById(id);  //删除指定 id 的文档
            //提交修改
            server.commit();
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }

    }

  
    
        //删除指定字段 的所有匹配数据
    public  void  deleteDocument(String name,String keyword){

        try {
            server.deleteByQuery(name+":"+ keyword);
            //提交修改
            server.commit();
        } catch (SolrServerException | IOException e) {
            e.printStackTrace();
        }

    }


  


    //添加数据
    /** * 添加 id是唯一的 但是 如果你实体类中没有指定id 那么solr 会自动给你分配 比如:91dc8523-324c-4fa1-944d-fb7e100da857 * 我说的id是名称完全一样 id=id */

    public void soleAdd(Object object){
        try {

            server.addBean(object);
            UpdateResponse updateResponse = server.commit();//提交请求
            if (updateResponse.getStatus()!=0){
                throw new Exception("添加失败");
            }      //返回0 添加成功

        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    //多线程 并发测试
    public  void main(String[] args) {

        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //需要显示的字段
                    String[] fields={"blogContent", "blogTitle","blogId"};

                    List<Map<String, String>> list = soleHighlighting("blogTitle", "龙头", 0, 50, "blogId",  fields);

                    System.out.println(list );
                }
            }).start();
        }
    }

}

创建 cn.solr.entity 包然后在此包下添加如下:

BlogCore(实体类)

package cn.solr.entity;

import org.apache.solr.client.solrj.beans.Field;

import java.util.Date;


public class BlogCore {

    @Field
    private String blogId;
    @Field
    private String blogTitle;
    @Field
    private String blogContent;
    @Field
    private Date createTime;

    public String getBlogId() {
        return blogId;
    }

    public void setBlogId(String blogId) {
        this.blogId = blogId;
    }

    public String getBlogTitle() {
        return blogTitle;
    }

    public void setBlogTitle(String blogTitle) {
        this.blogTitle = blogTitle;
    }

    public String getBlogContent() {
        return blogContent;
    }

    public void setBlogContent(String blogContent) {
        this.blogContent = blogContent;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }


    @Override
    public String toString() {
        return "BlogCore{" +
                "blogId='" + blogId + '\'' +
                ", blogTitle='" + blogTitle + '\'' +
                ", blogContent='" + blogContent + '\'' +
                ", createTime=" + createTime +
                '}';
    }
}

创建cn.solr.controller 在此包下添加如下:

SolrController (控制器)

package cn.solr.controller;

import cn.solr.entity.BlogCore;
import cn.solr.utils.Springboot_SolrUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/solr")
public class SolrController {

    @Autowired
   private Springboot_SolrUtils server;

    // http://localhost:8511/solr/soleAll0
    @GetMapping("/soleAll0")
    public  List<Map<String, String>> soleAll0(){
        List<Map<String, String>> list = server.soleAll();
        return list;
    }

    // http://localhost:8511/solr/soleAll1
    @GetMapping("/soleAll1")
    public  List<Map<String, String>> soleAll1(){
        List<Map<String, String>> list = server.soleAll("blogTitle","龙头");
        return list;
    }

    // http://localhost:8511/solr/soleFieldAll0
    @GetMapping("/soleFieldAll0")
    public  List<String> soleFieldAll0(){
        List<String> list = server.soleFieldAll("blogTitle");
        return list;
    }
    // http://localhost:8511/solr/soleFieldAll1
    @GetMapping("/soleFieldAll1")
    public   List<String>  soleFieldAll1(){
        List<String> list = server.soleFieldAll("blogTitle", "龙头");
        return list;
    }

    // http://localhost:8511/solr/soleHighlighting
    @GetMapping("/soleHighlighting")
    public   List<Map<String, String>> soleHighlighting(){
        //需要显示的字段
        String[] fields={"blogContent", "blogTitle","blogId"};
        List<Map<String, String>> list = server.soleHighlighting("blogTitle", "龙头", 0, 50, "blogId", fields);
        return list;
    }

    // http://localhost:8511/solr/deleteDocumentAll
    @GetMapping("/deleteDocumentAll")
    public   String deleteDocumentAll(){
        try {
            server.deleteDocumentAll();

        } catch (Exception e) {
            e.printStackTrace();
            return "false";
        }
        return "true";
    }

    // http://localhost:8511/solr/deleteDocumentAll
    @GetMapping("/deleteDocument0")
    public   String deleteDocument0(){
        try {
            server.deleteDocument("dd3eea7a-36eb-4f14-b546-d52ab0137420");

        } catch (Exception e) {
            e.printStackTrace();
            return "false";
        }
        return "true";
    }
    // http://localhost:8511/solr/deleteDocument1
    @GetMapping("/deleteDocument1")
    public   String deleteDocument1(){
        try {
            server.deleteDocument("blogTitle","xxx");

        } catch (Exception e) {
            e.printStackTrace();
            return "false";
        }
        return "true";
    }

    // http://localhost:8511/solr/soleAdd
    @GetMapping("/soleAdd")
    public  String soleAdd(){
        // 实体类
        BlogCore blog = new BlogCore();
        blog.setBlogId("1");
        blog.setBlogTitle("超越业x龙xxx头xxx");
        blog.setBlogContent("达摩院一定也必须要超越英特尔，必须超越微软，必须超越IBM，因为我们生于二十一世纪，我们是有机会后发优势的1。");
        blog.setCreateTime(new Date());

        try {
        server.soleAdd(blog);
        } catch (Exception e) {
            e.printStackTrace();
            return "false";
        }
        return "true";
    }

}

然后自己测试访问的 url 在每一个方法上面都写了

使用solr和Elasticsearch的选择

  1. 随着数据量的增加，Solr的搜索效率会变得更低，而Elasticsearch却没有明显的变化
  2. Solr的架构不适合实时搜索的应用。
  3. 当单纯的对已有数据进行搜索时，Solr更快

…这里就不说了 直接告诉你

个人博客 小型网站 都使用Solr就行 因为涉及到搜索和使用的频率都比较小 而且Solr对硬件没有什么要求

也没必要搭建集群了 如果查询量和数据量大时候 换Elasticsearch就行了

商城 , 类似百度搜索引擎 , 等查询较多的业务使用频率还特别大而且数据量也特别多的时候使Elasticsearch

使用Elasticsearch对硬件最低配置 不能低于8g 否则性能就适得其反 最大不能超过64g

最少1个cpu 2核 使用的硬盘必须是SSD的

0, 50, “blogId”, fields);
return list;
}

// http://localhost:8511/solr/deleteDocumentAll
@GetMapping("/deleteDocumentAll")
public   String deleteDocumentAll(){
    try {
        server.deleteDocumentAll();

    } catch (Exception e) {
        e.printStackTrace();
        return "false";
    }
    return "true";
}

// http://localhost:8511/solr/deleteDocumentAll
@GetMapping("/deleteDocument0")
public   String deleteDocument0(){
    try {
        server.deleteDocument("dd3eea7a-36eb-4f14-b546-d52ab0137420");

    } catch (Exception e) {
        e.printStackTrace();
        return "false";
    }
    return "true";
}
// http://localhost:8511/solr/deleteDocument1
@GetMapping("/deleteDocument1")
public   String deleteDocument1(){
    try {
        server.deleteDocument("blogTitle","xxx");

    } catch (Exception e) {
        e.printStackTrace();
        return "false";
    }
    return "true";
}

// http://localhost:8511/solr/soleAdd
@GetMapping("/soleAdd")
public  String soleAdd(){
    // 实体类
    BlogCore blog = new BlogCore();
    blog.setBlogId("1");
    blog.setBlogTitle("超越业x龙xxx头xxx");
    blog.setBlogContent("达摩院一定也必须要超越英特尔，必须超越微软，必须超越IBM，因为我们生于二十一世纪，我们是有机会后发优势的1。");
    blog.setCreateTime(new Date());

    try {
    server.soleAdd(blog);
    } catch (Exception e) {
        e.printStackTrace();
        return "false";
    }
    return "true";
}
}

然后自己测试访问的 url 在每一个方法上面都写了

使用solr和Elasticsearch的选择

  1. 随着数据量的增加，Solr的搜索效率会变得更低，而Elasticsearch却没有明显的变化
  2. Solr的架构不适合实时搜索的应用。
  3. 当单纯的对已有数据进行搜索时，Solr更快

.....................这里就不说了 直接告诉你

个人博客 小型网站 都使用Solr就行 因为涉及到搜索和使用的频率都比较小 而且Solr对硬件没有什么要求

也没必要搭建集群了 如果查询量和数据量大时候 换Elasticsearch就行了

商城 , 类似百度搜索引擎 , 等查询较多的业务使用频率还特别大而且数据量也特别多的时候使Elasticsearch

使用Elasticsearch对硬件最低配置 不能低于8g 否则性能就适得其反 最大不能超过64g

最少1个cpu 2核 使用的硬盘必须是SSD的

也就是说 不能在低配机器上使用 也不能在高配机器上使用 而是在中配置机器上使用 然后搭建多节点 这样效率最好

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_45203607/article/details/120249272

内容来源于网络，如有侵权，请联系作者删除！

Javaspring bootdockersolr

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备2022004421号-2 NULL123 https://www.null123.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com