Springboot 三分钟接入MeiliSearch

已于 2023-07-07 11:43:09 修改
阅读量2.9w 收藏 6
点赞数 2
分类专栏： SpringBoot 文章标签： spring boot spring java 后端 搜索引擎
于 2023-03-05 09:05:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaddCSDN/article/details/129342365
版权

优势

  1. 仅需要500M内存即可使用
  2. ms级响应
  3. 简单易上手的Api &快速启动。

部署

docker run -it --rm \
  -p 7700:7700 \
  -e MEILI_MASTER_KEY='秘钥'\
  -v $(pwd)/meili_data:/meili_data \
  getmeili/meilisearch:v1.0

Ui 访问地址 http://ip:7700

接入

        <!-- meilisearch 轻量级搜索       -->
        <!-- https://mvnrepository.com/artifact/com.meilisearch.sdk/meilisearch-java -->
        <dependency>
            <groupId>com.meilisearch.sdk</groupId>
            <artifactId>meilisearch-java</artifactId>
            <version>0.10.0</version>
        </dependency>

代码（直接复制）

MSIndex --索引注解

package com.aurora.annotation;

import java.lang.annotation.*;

/**
 * @author cgy
 */
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MSIndex {

    /**
     * 索引
     */
    String uid() default "";

    /**
     * 主键
     */
    String primaryKey() default "";

    /**
     * 分类最大数量
     */
    int maxValuesPerFacet() default 100;

    /**
     *  单次查询最大数量
     */
    int maxTotalHits() default 1000;
}

MSFiled --索引字段注解

package com.aurora.annotation;

import java.lang.annotation.*;

/**
 * MeiliSearch 字段注解
 */
@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MSFiled {

    /**
     * 是否开启过滤
     */
    boolean openFilter() default false;

    /**
     * 是否不展示
     */
    boolean noDisplayed() default false;

    /**
     * 是否开启排序
     */
    boolean openSort() default false;


    /**
     *  处理的字段名
     */
    String key() ;
}

MeiliSearchAutoConfiguration

package com.aurora.meilisearch.config;

import com.meilisearch.sdk.Client;
import com.meilisearch.sdk.Config;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author cgy
 * 2020/1/15 15:53
 */
@Data
@Configuration
public class MeiliSearchAutoConfiguration {

    @Value("${meiliSearch.hostUrl}")
    private String hostUrl;
    @Value("${meiliSearch.apiKey}")
    private String apiKey;

    @Bean
    @ConditionalOnMissingBean(Client.class)
    Client client() {
        return new Client(config());
    }

    @Bean
    @ConditionalOnMissingBean(Config.class)
    Config config() {
        return new Config(hostUrl, apiKey);
    }

}

MeilisearchRepository -索引初始化&增删改查

package com.aurora.meilisearch.service;

import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSON;
import com.aurora.annotation.MSFiled;
import com.aurora.annotation.MSIndex;
import com.aurora.meilisearch.json.JsonHandler;
import com.aurora.meilisearch.json.SearchResult;
import com.meilisearch.sdk.*;
import com.meilisearch.sdk.model.*;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.*;

/**
 * @author cgy
 */
public class MeilisearchRepository<T> implements InitializingBean, DocumentOperations<T> {

    private Index index;
    private Class<T> tClass;
    private JsonHandler jsonHandler = new JsonHandler();

    @Resource
    private Client client;


    @Override
    public T get(String identifier) {
        T document;
        try {
            document = index.getDocument(identifier, tClass);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return document;
    }

    @Override
    public List<T> list() {
        List<T> documents;
        try {
            documents = Optional.ofNullable(index.getDocuments(tClass))
                    .map(indexDocument -> indexDocument.getResults())
                    .map(result -> Arrays.asList(result))
                    .orElse(new ArrayList<>());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return documents;
    }

    @Override
    public List<T> list(int limit) {
        List<T> documents;
        try {
            DocumentsQuery query = new DocumentsQuery();
            query.setLimit(limit);
            documents = Optional.ofNullable(index.getDocuments(query, tClass))
                    .map(indexDocument -> indexDocument.getResults())
                    .map(result -> Arrays.asList(result))
                    .orElse(new ArrayList<>());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return documents;
    }

    @Override
    public List<T> list(int offset, int limit) {
        List<T> documents;
        try {
            DocumentsQuery query = new DocumentsQuery();
            query.setLimit(limit);
            query.setOffset(offset);
            documents = Optional.ofNullable(index.getDocuments(query, tClass))
                    .map(indexDocument -> indexDocument.getResults())
                    .map(result -> Arrays.asList(result))
                    .orElse(new ArrayList<>());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return documents;
    }

    @Override
    public int add(T document) {
        List<T> list = Collections.singletonList(document);
        return add(list);
    }

    @Override
    public int update(T document) {
        List<T> list = Collections.singletonList(document);
        return update(list);
    }

    @Override
    public int add(List documents) {
        int taskId;
        try {
            taskId = index.addDocuments(JSON.toJSONString(documents)).getTaskUid();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return taskId;
    }

    @Override
    public int update(List documents) {
        int updates;
        try {
            updates = index.updateDocuments(JSON.toJSONString(documents)).getTaskUid();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return updates;
    }


    @Override
    public int delete(String identifier) {
        int taskId;
        try {
            taskId = index.deleteDocument(identifier).getTaskUid();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return taskId;
    }

    @Override
    public int deleteBatch(String... documentsIdentifiers) {
        int taskId;
        try {
            taskId = index.deleteDocuments(Arrays.asList(documentsIdentifiers)).getTaskUid();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return taskId;
    }

    @Override
    public int deleteAll() {
        int taskId;
        try {
            taskId = index.deleteAllDocuments().getTaskUid();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return taskId;
    }


    @Override
    public SearchResult<T> search(String q) {
        String result;
        try {
            result = JSON.toJSONString(index.search(q));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return jsonHandler.resultDecode(result, tClass);
    }

    @Override
    public SearchResult<T> search(String q, int offset, int limit) {
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.setQ(q);
        searchRequest.setOffset(offset);
        searchRequest.setLimit(limit);
        return search(searchRequest);
    }

    @Override
    public SearchResult<T> search(SearchRequest sr) {
        String result;
        try {
            result = JSON.toJSONString(index.search(sr));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return jsonHandler.resultDecode(result, tClass);
    }

    @Override
    public Settings getSettings() {
        try {
            return index.getSettings();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public TaskInfo updateSettings(Settings settings) {
        try {
            return index.updateSettings(settings);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public TaskInfo resetSettings() {
        try {
            return index.resetSettings();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Task getUpdate(int updateId) {
        try {
            return index.getTask(updateId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        initIndex();
    }

    public Index getIndex() {
        return index;
    }

    /**
     * 初始化索引信息
     *
     * @throws Exception
     */
    private void initIndex() throws Exception {
        Class<? extends MeilisearchRepository> clazz = getClass();
        tClass = (Class<T>) ((ParameterizedType) clazz.getGenericSuperclass()).getActualTypeArguments()[0];
        MSIndex annoIndex = tClass.getAnnotation(MSIndex.class);
        String uid = annoIndex.uid();
        String primaryKey = annoIndex.primaryKey();
        if (StringUtils.isEmpty(uid)) {
            uid = tClass.getSimpleName().toLowerCase();
        }
        if (StringUtils.isEmpty(primaryKey)) {
            primaryKey = "id";
        }
        int maxTotalHit=1000;
        int maxValuesPerFacet=100;
        if (Objects.nonNull(annoIndex.maxTotalHits())){
            maxTotalHit=annoIndex.maxTotalHits();
        }
        if (Objects.nonNull(annoIndex.maxValuesPerFacet())){
            maxValuesPerFacet=100;
        }

        List<String> filterKey = new ArrayList<>();
        List<String> sortKey = new ArrayList<>();
        List<String> noDisPlay = new ArrayList<>();
        //获取类所有属性
        for (Field field : tClass.getDeclaredFields()) {
            //判断是否存在这个注解
            if (field.isAnnotationPresent(MSFiled.class)) {
                MSFiled annotation = field.getAnnotation(MSFiled.class);
                if (annotation.openFilter()) {
                    filterKey.add(annotation.key());
                }

                if (annotation.openSort()) {
                    sortKey.add(annotation.key());
                }
                if (annotation.noDisplayed()) {
                    noDisPlay.add(annotation.key());
                }
            }
        }
        Results<Index> indexes = client.getIndexes();
        Index[] results = indexes.getResults();
        Boolean isHaveIndex=false;
        for (Index result : results) {
            if (uid.equals(result.getUid())){
                isHaveIndex=true;
                break;
            }
        }

        if (isHaveIndex){
            client.updateIndex(uid,primaryKey);
        }else {
            client.createIndex(uid, primaryKey);
        }
        this.index = client.getIndex(uid);
        Settings settings = new Settings();
        settings.setDisplayedAttributes(noDisPlay.size()>0?noDisPlay.toArray(new String[noDisPlay.size()]):new String[]{"*"});
        settings.setFilterableAttributes(filterKey.toArray(new String[filterKey.size()]));
        settings.setSortableAttributes(sortKey.toArray(new String[sortKey.size()]));
        index.updateSettings(settings);
    }
}

继承MeilisearchRepository 即可 T 是你要做存储的文档实体类 我这里用的是 **ArticleCardDTO
**

import com.aurora.meilisearch.service.MeilisearchRepository;
import org.springframework.stereotype.Repository;

@Repository
public  class MeiliSearchMapper  extends MeilisearchRepository<T> {
}

使用方法

配置

实体类配置

package com.aurora.dto;

import com.aurora.annotation.MSFiled;
import com.aurora.annotation.MSIndex;
import com.aurora.entity.Tag;
import com.aurora.entity.UserInfo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

import java.util.List;

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@MSIndex(uid="articles",primaryKey="id")
public class ArticleCardDTO {
    private Integer id;
    private String articleCover;

    @MSFiled(openFilter = true,key="articleTitle")
    private String articleTitle;
    private String articleSubheading;
    private String articleContent;
    @MSFiled(openFilter = true,key="isTop")
    private Integer isTop;

    @MSFiled(openFilter = true,key="isFeatured")
    private Integer isFeatured;

    @MSFiled(openFilter = true,key="isDelete")
    private Integer isDelete;

    @MSFiled(openFilter = true,key="categoryId")
    private Integer categoryId;
    private UserInfo author;
    private String categoryName;

    @MSFiled(openFilter = true,key="tags.id")
    private List<Tag> tags;

    @MSFiled(openFilter = true,key="status")
    private Integer status;

    @Field(type = FieldType.Long)
    @MSFiled(openSort = true,key="createTime")
    private Long createTime;

    @MSFiled(openSort = true,key = "updateTime")
    @Field(type = FieldType.Long)
    private Long updateTime;
}

配置文件配置

meiliSearch:
  hostUrl: 访问地址
  apiKey: 启动的时候设置的秘钥

使用

简单查询（首页的搜索-根据关键字查询文章）

        StringBuffer sb=new StringBuffer();
        StringBuffer articleTitle = sb
                .append("status=1")
                .append(" AND ")
                .append("isDelete=0");

        SearchRequest searchRequest=new SearchRequest()
                .setFilter(new String[]{articleTitle.toString()})
                .setQ(keywords)
                .setLimit(10);
        SearchResult<ArticleCardDTO> search = meiliSearchMapper.
                search(searchRequest);

多条件查询（查询置顶和推荐）

        SearchRequest searchRequest=new SearchRequest();
        searchRequest.setFilter(new String[]{"(isFeatured =1 AND (status=1 AND isDelete=0) ) OR ( isTop=1 AND (status=1 AND isDelete=0)) "});
        searchRequest.setLimit(10);
        SearchResult<ArticleCardDTO> search = meiliSearchMapper.search(searchRequest);

分页查询全部文章并创建时间倒序

        SearchRequest searchRequest = new SearchRequest();
        searchRequest.setLimit(PageUtils.getSize().intValue());
        searchRequest.setOffset(PageUtils.getCurrent().intValue() == 0 ? PageUtils.getCurrent().intValue() : (PageUtils.getCurrent().intValue() - 1) * PageUtils.getSize().intValue());
        searchRequest.setFilter(new String[]{"status =1 AND isDelete=0"});
        searchRequest.setSort(new String[]{"createTime:desc"});
        SearchResult<ArticleCardDTO> search = meiliSearchMapper.search(searchRequest);

根据类目分页查询文章

        SearchRequest searchRequest = new SearchRequest();
        searchRequest.setLimit(PageUtils.getSize().intValue());
        searchRequest.setOffset(PageUtils.getCurrent().intValue() == 0 ? PageUtils.getCurrent().intValue() : (PageUtils.getCurrent().intValue() - 1) * PageUtils.getSize().intValue());
        StringBuffer sb = new StringBuffer();
        sb.append("status =1 AND isDelete=0").append(" AND ").append("categoryId =").append(categoryId);
        searchRequest.setFilter(new String[]{sb.toString()});
        searchRequest.setSort(new String[]{"createTime:desc"});
        SearchResult<ArticleCardDTO> search = meiliSearchMapper.search(searchRequest);

根据标签分页查询文章

        SearchRequest searchRequest = new SearchRequest();
        searchRequest.setLimit(PageUtils.getSize().intValue());
        searchRequest.setSort(new String[]{"createTime:desc"});
        searchRequest.setOffset(PageUtils.getCurrent().intValue() == 0 ? PageUtils.getCurrent().intValue() : (PageUtils.getCurrent().intValue() - 1) * PageUtils.getSize().intValue());
        searchRequest.setFilter(new String[]{"tags.id=" + tagId + " AND status=1 AND isDelete=0"});
        SearchResult<ArticleCardDTO> search = meiliSearchMapper.search(searchRequest);

保存Or编辑文章

meiliSearchMapper.add(articleCardDTOS)>0?Boolean.TRUE:Boolean.FALSE;

删除文章

 meiliSearchMapper.delete(String.valueOf(id));

最终效果

ui效果

image.png

展示效果

![在这里插入图片描述](https://img-blog.csdnimg.cn/4dce7e51d331485bb9d8e3171ef6b41b.png

更多教程

请关注针芒科技

北创开源
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
meilisearch-java:MeiliSearch的Java客户端
03-10
MeiliSearch Java | | | :high_voltage: 为Java编写的MeiliSearch API客户端 :hot_beverage: MeiliSearch Java是Java开发人员的MeiliSearch API客户端。 MeiliSearch是一个开源搜索引擎。 目录 :open_book: 文献资料 请参阅我们的或我们的。 :wrench: 安装 可从JCentral官方存储库中获得meilisearch-java 。 为了能够导入此程序包，请将其声明为项目中的依赖项： 玛文 将以下代码添加到项目的<dependencies>部分： < dependency> < groupId>com.meilisearch.sdk</ groupId> < artifactId>meilisearch-java</ artifactId> < version>0.2.0</ versio
三分钟把ChatGPT接入Siri
04-28
三分钟把ChatGPT接入Siri
ES代替品：轻量级搜索引擎MeiliSearch
天明的博客
03-19 2067
总的来说，对于数据量不是很大的中小型企业来说（几百万到几千万的数据），都可以使用 MeiliSearch 搜索引擎。同时，它的使用场景基本可以覆盖当前主流的平台和技术，如管理后台搜索、小程序搜索等场景中。是一款真正轻量级安装部署、搜索速度快到极致，名副其实的轻量级且美丽搜索引擎。
探索Meilisearch Java：为您的Java应用注入智能搜索
gitblog_00094的博客
06-03 371
探索Meilisearch Java：为您的Java应用注入智能搜索 项目地址:https://gitcode.com/meilisearch/meilisearch-java 在当今数据驱动的时代，高效准确的搜索功能已成为提升用户体验的关键。今天，我们将深入探讨一个开源瑰宝——Meilisearch Java，一款专为Java开发者打造的高性能搜索引擎客户端库。 项目介绍 Meilisearch...
springboot整合MeiliSearch轻量级搜索引擎
qq_29653373的博客
09-22 6875
点击进入官网了解，本文主要从小微型公司业务出发，选择meilisearch来作为项目的全文搜索引擎，还可以当成来。2.2、集成starter里边的mapper对milisearch进行基本操作。1、引入starter依赖（没有版本统一管理的要把version加上）10、项目有统一版本管理的设置下版本管理。3、yml参数读取代码参考。2.1、建立索引(宽表)二、starter封装。4、自动配置类代码参考。6、自定义注解代码参考。9、指定自动配置类所在。7、基础操作接口封装。
Spring Boot 系统启动初始化任务
斗战圣佛91的博客
06-10 377
Spring Boot 定义系统启动任务，你会几种方式？ Spring Boot 2019年 04月15日 在 Servlet/Jsp 项目中，如果涉及到系统任务，例如在项目启动阶段要做一些数据初始化操作，这些操作有一个共同的特点，只在项目启动时进行，以后都不再执行，这里，容易想到web基础中的三大组件（ Servlet、Filter、Listener ）之一 Listener ，这种情况下，一般定义一个 ServletContextListener，然后就可以监听到项目启动和销毁，进而做出相...
springboot进阶(6):自定义memcached-spring-boot-starter
不积跬步，无以至千里
04-02 1872
文章目录前言准备工作如何自定义memcached-spring-boot-starter一、定义memcached-spring-boot-autoconfigure模块二、定义memcached-spring-boot-starter模块三、测试引用 前言 memcached 是非常简单的缓存组件，是简化版的redis，常用于缓存数据。 准备工作 安装memcached:Memcached 教程 推荐使用docker安装: docker run --name memcached -p 11211:1121
Grails4 封装MeiliSearch搜索引擎
斗战圣佛91的博客
11-02 414
1、build.gradle引入 repositories { maven { url "https://repo.grails.org/grails/core" } maven { url "https://dl.bintray.com/zhangjiayu139/plugins" } } compile 'middolmeilisearch:middolMeiliSearch:0.1' 2、编写MeiliSearchUtils工具类 package middol....
SimSearch：一个轻量级的springboot项目索引构建工具，实现快速模糊搜索
Huoyo
12-08 1055
一个轻量级的springboot项目索引构建工具，实现快速模糊搜索，相比于搜索引擎派系,这是一种轻量级的实现方式
MeiliSearch 文档、介绍、安装及HTTP请求测试
漏网之鱼
05-11 4042
介绍 MeiliSearch是一个功能强大，快速，开源，易于使用和部署的搜索引擎。搜索和索引都是高度可定制的。允许输入、过滤器和同义词等特性都是开箱即用的。是近两年开源的项目，同样也支持中文分词，在小数据规模下可以实现比ElasticSearch更加快速和易用的搜索体验。更多安装、配置、使用等细节请参考官方文档或交友网站 HTTP方式操作索引 创建索引 POST http://192.144.228.170:7700/indexes { "uid" : "product", "primaryK
三分钟看懂ChatGPT
02-14
ChatGPT，全名是Chat-based Generative Pre-trained Transformer，是由美国知名的人工智能研究实验室OpenAI在2022年11月30日推出的一款创新性聊天机器人程序。这款程序基于先进的自然语言处理技术，旨在模拟人类的...
MeiliSearch：快如闪电，超相关且具有错字率的搜索引擎
02-04
MeiliSearch：快如闪电，超相关且具有错字率的搜索引擎
meilisearch-php:MeiliSearch API 的 PHP 包装器
08-04
美丽搜索 PHP | | | | | :high_voltage: 为 PHP 编写的 Meil​​iSearch API 客户端 :elephant: MeiliSearch PHP是面向 PHP 开发人员的 Meil​​iSearch API 客户端。 MeiliSearch是一个开源搜索引擎。 目录 文档 :wrench: 安装 :rocket: 入门 :robot: 与美丽搜索的兼容性 :light_bulb: 了解更多 :toolbox: HTTP 客户端兼容性自定义您的 HTTP 客户端 :gear: 开发工作流和贡献 :open_book: 文档 请参阅我们的文档或我们的API 参考。 :wrench: 安装 要开始，只需使用Composer要求项目。 您还需要安装“提供” psr/http-client-implementation和psr/http-factory-implementation软件包。 可以在php-http.org上找到兼容 HTTP 客户端和客户端适配器的列表。 如果您不知道要使用哪
三分钟读懂超级结MOSFET
01-20
基于超级结技术的功率MOSFET已成为高压开关转换器领域的业界规范。它们提供更低的RDS(on)，同时具有更少的栅极和和输出电荷，这有助于在任意给定频率下保持更高的效率。在超级结MOSFET出现之前，高压器件的主要设计...
springboot用户注册、找回密码的邮箱验证码存入redis，三分钟有效
01-03
1.首先配置redis，笔者...3.使用随机数生成四位随机数，当作验证码，并且设置失效时间为三分钟， String emailReg = ^([a-zA-Z0-9_\\-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([a-zA-Z0-9\\-]+\\.)+
Kotlin 编程三分钟入门
08-30
【Kotlin编程三分钟入门】 Kotlin是一种现代的、面向对象的编程语言，设计时考虑了开发者体验，尤其强调简洁性和可读性。它由JetBrains公司开发，初衷是为了提高开发效率，尤其针对Android开发。Kotlin在Java虚拟机...
Docker安装MeiliSearch教程
猿小白的博客
05-20 2017
MeiliSearch是一款开源的全文搜索引擎，它使用Rust编写，具有高效、快速、易用的特点。MeiliSearch支持多种语言，可以轻松地集成到任何应用程序中。它可以处理大量的文本数据，并能够快速地搜索和返回相关的结果。MeiliSearch还提供了一些高级功能，如自定义排名、拼写纠正和同义词处理等，可以帮助用户更好地定制和优化搜索体验。MeiliSearch的API设计简单，易于使用，可以快速地构建和部署搜索功能。
meilisearch的Managing API keys，自己趟过的坑
最新发布
专注于后端开发，时常接触大数据 、人工智能等
06-12 215
Elasticsearch 做为老牌搜索引擎，功能基本满足，但复杂，重量级，适合大数据量。MeiliSearch 设计目标针对数据在 500GB 左右的搜索需求，极快，单文件，超轻量。所以，对于中小型项目来说，我们可以考虑另一种搜索引擎：MeiliSearch。
SpringBoot 整合 Elasticsearch （超详细）
热门推荐
06-10 1万+
为了完成 Spring Boot 与 Elasticsearch 整合需要安装下面工具 1.1 Elasticsearch 安装 🔗 Elasticsearch 官网 🔗 Elasticsearch 6.4.3 下载链接 1.2 Elasticsearch ik 安装 🔗 Elasticsearch ik 官网下载地址🔗 Elasticserch ik 6.4.3 版本下载地址 1.3 postman 安装 🔗 Postman 官网下载链接 3. SpingBoot 整合 Elasticsea...
springboot项目一般怎么随机生成密钥key，三分钟有效
06-10
在Spring Boot项目中，可以使用Java的SecureRandom类生成随机数，并将其转换为字符串作为密钥key。同时，可以使用Java的Timer类创建一个计时器，在三分钟后自动将密钥key设置为null，以达到三分钟有效的目的。 以下是一个示例代码： ```java import java.security.SecureRandom; import java.util.Timer; import java.util.TimerTask; public class KeyGenerator { private static String key = null; public static String generateKey() { SecureRandom random = new SecureRandom(); byte[] bytes = new byte[16]; random.nextBytes(bytes); key = bytes.toString(); Timer timer = new Timer(); timer.schedule(new TimerTask() { @Override public void run() { key = null; } }, 180000); // 180000毫秒为3分钟 return key; } } ``` 可以在需要生成密钥key的地方调用`KeyGenerator.generateKey()`方法来获取一个随机生成的密钥key，该密钥key在三分钟后会自动失效。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值