扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >Spring Boot 接口加解密功能实现
  • 162

0
分享到

Spring Boot 接口加解密功能实现

Spring Boot 接口加解密Spring Boot 接口Spring Boot 加解密 2023-05-18 11:05:36 162人浏览 独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录介绍基础知识hutool-crypto加密解密工具request流只能读取一次的问题问题描述解决办法SpringBoot的参数校验validation自定义starterRequ

介绍

在我们日常的Java开发中，免不了和其他系统的业务交互，或者微服务之间的接口调用;如果我们想保证数据传输的安全，对接口出参加密，入参解密。但是不想写重复代码，我们可以提供一个通用starter，提供通用加密解密功能。

基础知识

hutool-crypto加密解密工具

hutool-crypto提供了很多加密解密工具，包括对称加密，非对称加密，摘要加密等等，这不做详细介绍。

request流只能读取一次的问题

问题描述

在接口调用链中，request的请求流只能调用一次，处理之后，如果之后还需要用到请求流获取数据，就会发现数据为空。

比如使用了filter或者aop在接口处理之前，获取了request中的数据，对参数进行了校验，那么之后就不能在获取request请求流了。

解决办法

继承httpservletRequestWrapper，将请求中的流copy一份，复写getInputStream和getReader方法供外部使用。每次调用后的getInputStream方法都是从复制出来的二进制数组中进行获取，这个二进制数组在对象存在期间一致存在。

使用Filter过滤器，在一开始，替换request为自己定义的可以多次读取流的request。

下面这样就实现了流的重复获取:
工具类(InputStreamHttpServletRequestWrapper)：

package com.mry.springboottools.validation;
import org.apache.commons.io.IOUtils;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamHttpServletRequestWrapper extends HttpServletRequestWrapper {
    
    private ByteArrayOutputStream cachedBytes;
    public InputStreamHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
    }
    @Override
    public ServletInputStream getInputStream() throws IOException {
        if (cachedBytes == null) {
            // 首次获取流时，将流放入 缓存输入流 中
            cacheInputStream();
        }
        // 从 缓存输入流 中获取流并返回
        return new CachedServletInputStream(cachedBytes.toByteArray());
    }
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }
    
    private void cacheInputStream() throws IOException {
        // 缓存输入流以便多次读取。为了方便, 我使用 org.apache.commons IOUtils
        cachedBytes = new ByteArrayOutputStream();
        IOUtils.copy(super.getInputStream(), cachedBytes);
    }
    
    public static class CachedServletInputStream extends ServletInputStream {
        private final ByteArrayInputStream input;
        public CachedServletInputStream(byte[] buf) {
            // 从缓存的请求正文创建一个新的输入流
            input = new ByteArrayInputStream(buf);
        }
        @Override
        public boolean isFinished() {
            return false;
        }
        @Override
        public boolean isReady() {
            return false;
        }
        @Override
        public void setReadListener(ReadListener listener) {
        }
        @Override
        public int read() throws IOException {
            return input.read();
        }
    }
}

Filter过滤器(HttpServletRequestInputStreamFilter)：

package com.mry.springboottools.validation;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import static org.springframework.core.Ordered.HIGHEST_PRECEDENCE;

@Component
@Order(HIGHEST_PRECEDENCE + 1)  // 优先级最高
public class HttpServletRequestInputStreamFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 转换为可以多次获取流的request
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        InputStreamHttpServletRequestWrapper inputStreamHttpServletRequestWrapper = new InputStreamHttpServletRequestWrapper(httpServletRequest);
        // 放行
        chain.doFilter(inputStreamHttpServletRequestWrapper, response);
    }
}

SpringBoot的参数校验validation

为了减少接口中，业务代码之前的大量冗余的参数校验代码

SpringBoot-validation提供了优雅的参数校验，入参都是实体类，在实体类字段上加上对应注解，就可以在进入方法之前，进行参数校验，如果参数错误，会抛出错误BindException，是不会进入方法的。

这种方法，必须要求在接口参数上加注解@Validated或者是@Valid

但是很多清空下，我们希望在代码中调用某个实体类的校验功能，所以需要如下工具类。

package com.mry.springboottools.validation;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

public class ValidationUtils {
    private static final Validator VALIDATOR = Validation.buildDefaultValidatorFactory().getValidator();
    
    public static void validate(Object object) throws CustomizeException {
        Set<ConstraintViolation<Object>> validate = VALIDATOR.validate(object);
        // 验证结果异常
        throwParamException(validate);
    }
    
    public static void validate(Object object, Class<?> ... groups) throws CustomizeException {
        Set<ConstraintViolation<Object>> validate = VALIDATOR.validate(object, groups);
        // 验证结果异常
        throwParamException(validate);
    }
    
    public static void validate(Object object, String propertyName) throws CustomizeException {
        Set<ConstraintViolation<Object>> validate = VALIDATOR.validateProperty(object, propertyName);
        // 验证结果异常
        throwParamException(validate);
    }
    
    public static void validate(Object object, String propertyName, Class<?> ... groups) throws CustomizeException {
        Set<ConstraintViolation<Object>> validate = VALIDATOR.validateProperty(object, propertyName, groups);
        // 验证结果异常
        throwParamException(validate);
    }
    
    private static void throwParamException(Set<ConstraintViolation<Object>> validate) throws CustomizeException {
        if (validate.size() > 0) {
            List<String> fieldList = new LinkedList<>();
            List<String> msgList = new LinkedList<>();
            for (ConstraintViolation<Object> next : validate) {
                fieldList.add(next.getPropertyPath().toString());
                msgList.add(next.getMessage());
            }
            throw new ParamException(fieldList, msgList);
        }
    }
}

自定义参数异常:

package com.mry.springboottools.validation;
import lombok.Getter;
import org.springframework.util.CollectionUtils;
import java.util.List;

@Getter
public class ParamException extends CustomizeException {
    private List<String> fieldList;
    private List<String> msgList;
    public ParamException(String message) {
        super(message);
    }
    public ParamException(String message, Throwable cause) {
        super(message, cause);
    }
    public ParamException(List<String> fieldList, List<String> msgList) throws CustomizeException {
        super(generatORMessage(fieldList, msgList));
        this.fieldList = fieldList;
        this.msgList = msgList;
    }
    public ParamException(List<String> fieldList, List<String> msgList, Exception ex) throws CustomizeException {
        super(generatorMessage(fieldList, msgList), ex);
        this.fieldList = fieldList;
        this.msgList = msgList;
    }
    private static String generatorMessage(List<String> fieldList, List<String> msgList) throws CustomizeException {
        if (CollectionUtils.isEmpty(fieldList) || CollectionUtils.isEmpty(msgList) || fieldList.size() != msgList.size()) {
            return "参数错误";
        }
        StringBuilder message = new StringBuilder();
        for (int i = 0; i < fieldList.size(); i++) {
            String field = fieldList.get(i);
            String msg = msgList.get(i);
            if (i == fieldList.size() - 1) {
                message.append(field).append(":").append(msg);
            } else {
                message.append(field).append(":").append(msg).append(",");
            }
        }
        return message.toString();
    }
}

自定义异常:

package com.mry.springboottools.validation;

public class CustomizeException extends Exception {
    public CustomizeException(String message, Throwable cause) {
        super(message, cause);
    }
    public CustomizeException(String message) {
        super(message);
    }
}

自定义starter

自定义starter步骤:
1.创建工厂，编写功能代码;
2.声明自动配置类，把需要对外提供的对象创建好，通过配置类统一向外暴露;
3.在resource目录下准备一个名为spring/spring.factories的文件，以org.springframework.boot.autoconfigure.EnableAutoConfiguration为key，自动配置类为value列表，进行注册;

RequestBodyAdvice和ResponseBodyAdvice

1.RequestBodyAdvice是对请求的JSON串进行处理， 一般使用环境是处理接口参数的自动解密;
2.ResponseBodyAdvice是对请求响应的json传进行处理，一般用于相应结果的加密;

功能介绍

接口数据的时候，返回的是加密之后的数据 接口入参的时候，接收的是解密之后的数据，但是在进入接口之前，加密的会自动解密，取得对应的数据。

功能细节

加密解密使用对称加密的AES算法，使用hutool-crypto模块进行实现

所有的实体类提取一个公共父类，包含属性时间戳，用于加密数据返回之后的实效性，如果超过60分钟，那么其他接口将不进行处理。

如果接口加了加密注解EncryptionAnnotation，并且返回统一的json数据Result类，则自动对数据进行加密。如果是继承了统一父类RequestBase的数据，自动注入时间戳，确保数据的时效性。

如果接口加了解密注解DecryptionAnnotation，并且参数使用RequestBody注解标注，传入json使用统一格式RequestData类，并且内容是继承了包含时间长的父类RequestBase，则自动解密，并且转为对应的数据类型。

功能提供Springboot的starter，实现开箱即用。

代码实现

项目结构

在这里插入图片描述

crypto-common

在这里插入图片描述

crypto-spring-boot-starter 代码结构

在这里插入图片描述

核心代码

crypto.properties AES需要的参数配置

# \u6A21\u5F0F cn.hutool.crypto.Mode
crypto.mode=CTS
# \u8865\u7801\u65B9\u5F0F cn.hutool.crypto.Mode
crypto.padding=PKCS5Padding
# \u79D8\u94A5
crypto.key=tesTKEy123456789
# \u76D0
crypto.iv=testiv1234567890

spring.factories 自动配置文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.mry.crypto.config.AppConfig

CryptConfig AES需要的配置参数

package com.mry.crypto.config;
import cn.hutool.crypto.Mode;
import cn.hutool.crypto.Padding;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import java.io.Serializable;

@Configuration
@ConfigurationProperties(prefix = "crypto")
@PropertySource("classpath:crypto.properties")
@Data
@EqualsAndHashCode
@Getter
public class CryptConfig implements Serializable {
    private Mode mode;
    private Padding padding;
    private String key;
    private String iv;
}

AppConfig 自动配置类

package com.mry.crypto.config;
import cn.hutool.crypto.symmetric.AES;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
import java.NIO.charset.StandardCharsets;

@Configuration
public class AppConfig {
    @Resource
    private CryptConfig cryptConfig;
    @Bean
    public AES aes() {
        return new AES(cryptConfig.getMode(), cryptConfig.getPadding(), cryptConfig.getKey().getBytes(StandardCharsets.UTF_8), cryptConfig.getIv().getBytes(StandardCharsets.UTF_8));
    }
}
package com.mry.crypto.config;
import cn.hutool.crypto.symmetric.AES;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;

@Configuration
public class AppConfig {
    @Resource
    private CryptConfig cryptConfig;
    @Bean
    public AES aes() {
        return new AES(cryptConfig.getMode(), cryptConfig.getPadding(), cryptConfig.getKey().getBytes(StandardCharsets.UTF_8), cryptConfig.getIv().getBytes(StandardCharsets.UTF_8));
    }
}

DecryptRequestBodyAdvice 请求自动解密

package com.mry.crypto.advice;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mry.crypto.annotation.DecryptionAnnotation;
import com.mry.crypto.common.exception.ParamException;
import com.mry.crypto.constant.CryptoConstant;
import com.mry.crypto.entity.RequestBase;
import com.mry.crypto.entity.RequestData;
import com.mry.crypto.util.AESUtil;
import lombok.SneakyThrows;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.WEB.bind.annotation.ControllerAdvice;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.lang.reflect.Type;

@ControllerAdvice
public class DecryptRequestBodyAdvice implements RequestBodyAdvice {
    @Autowired
    private ObjectMapper objectMapper;
    
    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return methodParameter.hasMethodAnnotation(DecryptionAnnotation.class);
    }
    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        return inputMessage;
    }
    
    @SneakyThrows
    @Override
    public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        // 获取request
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) requestAttributes;
        if (servletRequestAttributes == null) {
            throw new ParamException("request错误");
        }
        HttpServletRequest request = servletRequestAttributes.getRequest();
        // 获取数据
        ServletInputStream inputStream = request.getInputStream();
        RequestData requestData = objectMapper.readValue(inputStream, RequestData.class);
        if (requestData == null || StringUtils.isBlank(requestData.getText())) {
            throw new ParamException("参数错误");
        }
        // 获取加密的数据
        String text = requestData.getText();
        // 放入解密之前的数据
        request.setAttribute(CryptoConstant.INPUT_ORIGINAL_DATA, text);
        // 解密
        String decryptText = null;
        try {
            decryptText = AESUtil.decrypt(text);
        } catch (Exception e) {
            throw new ParamException("解密失败");
        }
        if (StringUtils.isBlank(decryptText)) {
            throw new ParamException("解密失败");
        }
        // 放入解密之后的数据
        request.setAttribute(CryptoConstant.INPUT_DECRYPT_DATA, decryptText);
        // 获取结果
        Object result = objectMapper.readValue(decryptText, body.getClass());
        // 强制所有实体类必须继承RequestBase类，设置时间戳
        if (result instanceof RequestBase) {
            // 获取时间戳
            Long currentTimeMillis = ((RequestBase) result).getCurrentTimeMillis();
            // 有效期 60秒
            long effective = 60*1000;
            // 时间差
            long expire = System.currentTimeMillis() - currentTimeMillis;
            // 是否在有效期内
            if (Math.abs(expire) > effective) {
                throw new ParamException("时间戳不合法");
            }
            // 返回解密之后的数据
            return result;
        } else {
            throw new ParamException(String.format("请求参数类型：%s 未继承：%s", result.getClass().getName(), RequestBase.class.getName()));
        }
    }
    
    @SneakyThrows
    @Override
    public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        String typeName = targetType.getTypeName();
        Class<?> bodyClass = Class.forName(typeName);
        return bodyClass.newInstance();
    }
}

EncryptResponseBodyAdvice 相应自动加密

package com.mry.crypto.advice;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mry.crypto.annotation.DecryptionAnnotation;
import com.mry.crypto.common.exception.ParamException;
import com.mry.crypto.constant.CryptoConstant;
import com.mry.crypto.entity.RequestBase;
import com.mry.crypto.entity.RequestData;
import com.mry.crypto.util.AESUtil;
import lombok.SneakyThrows;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.lang.reflect.Type;

@ControllerAdvice
public class DecryptRequestBodyAdvice implements RequestBodyAdvice {
    @Autowired
    private ObjectMapper objectMapper;
    
    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return methodParameter.hasMethodAnnotation(DecryptionAnnotation.class);
    }
    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        return inputMessage;
    }
    
    @SneakyThrows
    @Override
    public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        // 获取request
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) requestAttributes;
        if (servletRequestAttributes == null) {
            throw new ParamException("request错误");
        }
        HttpServletRequest request = servletRequestAttributes.getRequest();
        // 获取数据
        ServletInputStream inputStream = request.getInputStream();
        RequestData requestData = objectMapper.readValue(inputStream, RequestData.class);
        if (requestData == null || StringUtils.isBlank(requestData.getText())) {
            throw new ParamException("参数错误");
        }
        // 获取加密的数据
        String text = requestData.getText();
        // 放入解密之前的数据
        request.setAttribute(CryptoConstant.INPUT_ORIGINAL_DATA, text);
        // 解密
        String decryptText = null;
        try {
            decryptText = AESUtil.decrypt(text);
        } catch (Exception e) {
            throw new ParamException("解密失败");
        }
        if (StringUtils.isBlank(decryptText)) {
            throw new ParamException("解密失败");
        }
        // 放入解密之后的数据
        request.setAttribute(CryptoConstant.INPUT_DECRYPT_DATA, decryptText);
        // 获取结果
        Object result = objectMapper.readValue(decryptText, body.getClass());
        // 强制所有实体类必须继承RequestBase类，设置时间戳
        if (result instanceof RequestBase) {
            // 获取时间戳
            Long currentTimeMillis = ((RequestBase) result).getCurrentTimeMillis();
            // 有效期 60秒
            long effective = 60*1000;
            // 时间差
            long expire = System.currentTimeMillis() - currentTimeMillis;
            // 是否在有效期内
            if (Math.abs(expire) > effective) {
                throw new ParamException("时间戳不合法");
            }
            // 返回解密之后的数据
            return result;
        } else {
            throw new ParamException(String.format("请求参数类型：%s 未继承：%s", result.getClass().getName(), RequestBase.class.getName()));
        }
    }
    
    @SneakyThrows
    @Override
    public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        String typeName = targetType.getTypeName();
        Class<?> bodyClass = Class.forName(typeName);
        return bodyClass.newInstance();
    }
}

crypto-test 代码结构

在这里插入图片描述

核心代码

application.yml 配置文件

spring:
  mvc:
    format:
      date-time: yyyy-MM-dd HH:mm:ss
      date: yyyy-MM-dd
  # 日期格式化
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
server:
  port: 9999

Teacher 实体类

package com.mry.crypto.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.Range;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
public class Teacher extends RequestBase implements Serializable {
    @NotBlank(message = "姓名不能为空")
    private String name;
    @NotNull(message = "年龄不能为空")
    @Range(min = 0, max = 150, message = "年龄不合法")
    private Integer age;
    @NotNull(message = "生日不能为空")
    private Date birthday;
}

TestController 测试Controller

package com.mry.crypto.controller;
import com.mry.crypto.annotation.DecryptionAnnotation;
import com.mry.crypto.annotation.EncryptionAnnotation;
import com.mry.crypto.common.entity.Result;
import com.mry.crypto.common.entity.ResultBuilder;
import com.mry.crypto.entity.Teacher;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController implements ResultBuilder {
    
    @PostMapping("/get")
    public ResponseEntity<Result<?>> get(@Validated @RequestBody Teacher teacher) {
        return success(teacher);
    }
    
    @PostMapping("/encrypt")
    @EncryptionAnnotation
    public ResponseEntity<Result<?>> encrypt(@Validated @RequestBody Teacher teacher) {
        return success(teacher);
    }
    
    @PostMapping("/encrypt1")
    @EncryptionAnnotation
    public Result<?> encrypt1(@Validated @RequestBody Teacher teacher) {
        return success(teacher).getBody();
    }
    
    @PostMapping("/decrypt")
    @DecryptionAnnotation
    public ResponseEntity<Result<?>> decrypt(@Validated @RequestBody Teacher teacher) {
        return success(teacher);
    }
}

验证

加密：

在这里插入图片描述

解密：

在这里插入图片描述

到此这篇关于Spring Boot 接口加解密的文章就介绍到这了,更多相关Spring Boot 接口加解密内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: Spring Boot 接口加解密功能实现

本文链接: https://lsjlt.com/news/211994.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Spring Boot 接口加解密功能实现
    目录介绍基础知识hutool-crypto加密解密工具request流只能读取一次的问题问题描述解决办法SpringBoot的参数校验validation自定义starterRequ...
    99+
    2023-05-18
    Spring Boot 接口加解密 Spring Boot 接口 Spring Boot 加解密
  • 怎么实现 Spring Boot 接口参数加密解密
    本篇内容主要讲解“怎么实现 Spring Boot 接口参数加密解密”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“怎么实现 Spring Boot 接口参数加密解密”吧!加密解密本身并不是难事，...
    99+
    2023-06-17
  • Spring Boot 接口参数加密解密的实现方法
    目录1.开发加解密 starter2.打包发布2.1 安装到本地仓库2.2 发布到线上3.应用4.小结因为有小伙伴刚好问到这个问题，松哥就抽空撸一篇文章和大家聊聊这个话题。 加密解密...
    99+
    2024-04-02
  • 如何实现Spring Boot接口参数的加密解密操作
    这篇文章主要介绍如何实现Spring Boot接口参数的加密解密操作，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！加密解密本身并不是难事，问题是在何时去处理？定义一个过滤器，将请求和响应分别拦截下来进行处理也是一个办...
    99+
    2023-06-14
  • Spring Boot 功能整合的实现
    目录前言数据库持久化支持Swagger 文档支持参数校验 JSR303跨域解决整合MongoDB实现文件上传下载删除前言 如果根据之前做的 Nest.js 后端项目功能为标准的话，...
    99+
    2024-04-02
  • vue+spring boot实现校验码功能
    本文实例为大家分享了vue+spring boot实现校验码功能的具体代码，供大家参考，具体内容如下 用vue写了一个校验码来玩玩，样子如下： 1.img标签 <img ...
    99+
    2024-04-02
  • SpringCloud Gateway实现API接口加解密
    目录接口范围启用禁用/版本加密算法报文格式网关实现细节代码filter过滤器请求配置和请求方式分发Get请求参数解密包装 ServerHttpRequestDecorato...
    99+
    2024-04-02
  • Spring Boot怎么实现接口自动幂等
    今天小编给大家分享一下Spring Boot怎么实现接口自动幂等的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我...
    99+
    2024-04-02
  • spring boot动态生成接口怎么实现
    本篇内容主要讲解“spring boot动态生成接口怎么实现”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“spring boot动态生成接口怎么实现”吧!在某些业务场景中，我...
    99+
    2023-06-21
  • golang实现aes-cbc-256加密解密功能
    目录我为什么吃撑了要实现go的aes-cbc-256加密解密功能？1：面临两个问题1：go秘钥长度必须是16/24/322：go根本不支持256位的aes-cbc加密解密3：想用go...
    99+
    2023-05-18
    go aes加密解密 go 256加密解密
  • 详解spring中的Aware接口功能
    目录一，ApplicationContextAware二、ApplicationEventPublisherAware在spring中有很多以XXXAware命名的接口，很多人也不清...
    99+
    2024-04-02
  • 详解Spring中InitializingBean接口的功能
    Spring的InitializingBean接口有很好的用处,位于spring beans中,它只提供一个方法afterPropertiesSet(),当你实现了该方法后,spri...
    99+
    2024-04-02
  • SpringBoot详解整合Spring Boot Admin实现监控功能
    目录监控监控的意义可视化监控平台监控原理自定义监控指标监控 ​ 在说监控之前，需要回顾一下软件业的发展史。最早的软件完成一些非常简单的功能，代码不多，错误也少。随着软件功能的逐步完善...
    99+
    2024-04-02
  • 如何在ASP存储接口shell中实现数据加密功能？
    ASP是一种被广泛使用的服务器端脚本语言，常用于动态网站的开发。在ASP存储接口shell中，为了保证数据的安全性，我们通常需要对数据进行加密。本篇文章将介绍如何在ASP存储接口shell中实现数据加密功能。 一、加密方式的选择 在ASP存...
    99+
    2023-11-06
    存储 接口 shell
  • vue+spring boot如何实现校验码功能
    这篇文章将为大家详细讲解有关vue+spring boot如何实现校验码功能，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。用vue写了一个校验码来玩玩，样子如下：img标签<img &nb...
    99+
    2023-06-15
  • Spring Boot简单实现文件上传功能
    目录前言后端处理物理路径和虚拟路径映射前言 前端处理 通过form表单来上传文件提交方式为postenctype格式为"multipart/form-data"i...
    99+
    2024-04-02
  • 如何在spring boot中使用spring-kafka实现一个接收消息功能
    本篇文章为大家展示了如何在spring boot中使用spring-kafka实现一个接收消息功能，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。实现方法pom.xml文件如下<&#63...
    99+
    2023-05-31
    springboot spring-kafka
  • Spring Boot常用功能Profile详解
    入口 相关逻辑的入口是listener类：ConfigFileApplicationListener，当容器广播器触发ApplicationEnvironmentPreparedEv...
    99+
    2024-04-02
  • spring boot对敏感信息进行加解密的项目实现
    我们使用jasypt最新版本对敏感信息进行加解密。 1.在项目pom文件中加入如下依赖： <dependency> <groupId&...
    99+
    2023-05-17
    springboot敏感信息加解密 springboot敏感信息加密
  • Java实现文件的加密解密功能示例
    本文实例讲述了Java实现文件的加密解密功能分享给大家供大家参考，具体如下：package com.copy.encrypt;import java.io.File;import java.io.FileInputStream;import...
    99+
    2023-05-31
    java 文件 加密
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作