使用SpringBoot自定义starter完成接口的加密解密

最新推荐文章于 2024-10-08 22:00:00 发布
最新推荐文章于 2024-10-08 22:00:00 发布
阅读量695 收藏
点赞数 22
文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/JavaMyDream/article/details/136954125
版权

声明: 这里加密解密只是简单使用了一个base64操作的,主要是提供功能案例,具体的根据需要改

maven依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.18</version>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.15</version>
        </dependency>
    </dependencies>

请求参数解密类

package luck.spring.boot.starter.encrypt.demo.advice;

import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.StrUtil;
import lombok.RequiredArgsConstructor;
import luck.spring.boot.starter.encrypt.demo.anno.Decrypt;
import luck.spring.boot.starter.encrypt.demo.config.LuckEncryptProperties;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJacksonInputMessage;
import org.springframework.util.Base64Utils;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.lang.reflect.Type;

@ControllerAdvice
@RequiredArgsConstructor
public class LuckDecryptBodyAdvice implements RequestBodyAdvice {

    private final LuckEncryptProperties luckEncryptProperties;

    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return methodParameter.hasMethodAnnotation(Decrypt.class) && luckEncryptProperties.isDecryptEnable() && methodParameter.hasParameterAnnotation(RequestBody.class);
    }

    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        byte[] bytes = IoUtil.readBytes(inputMessage.getBody());
        byte[] decrypt = Base64Utils.decode(bytes);
        return new MappingJacksonInputMessage(new ByteArrayInputStream(decrypt), inputMessage.getHeaders());
    }

    @Override
    public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return body;
    }

    @Override
    public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return StrUtil.EMPTY_JSON;
    }
}

请求响应加密类

package luck.spring.boot.starter.encrypt.demo.advice;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import lombok.RequiredArgsConstructor;
import luck.spring.boot.starter.encrypt.demo.anno.Encrypt;
import luck.spring.boot.starter.encrypt.demo.config.LuckEncryptProperties;
import luck.spring.boot.starter.encrypt.demo.inter.LuckResultHandler;
import luck.spring.boot.starter.encrypt.demo.util.LuckSpringUtil;
import luck.spring.boot.starter.encrypt.demo.util.Result;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.stereotype.Controller;
import org.springframework.util.Base64Utils;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

import java.nio.charset.StandardCharsets;
import java.util.List;

@ControllerAdvice
@RequiredArgsConstructor
public class LuckEncryptBodyAdvice implements ResponseBodyAdvice<Object> {
    private final LuckEncryptProperties luckEncryptProperties;

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        Class<?> declaringClass = returnType.getDeclaringClass();
        return declaringClass.isAnnotationPresent(RestController.class)
                || (declaringClass.isAnnotationPresent(Controller.class) && returnType.getMethod().isAnnotationPresent(ResponseBody.class));

    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        Object result = body;
        List<LuckResultHandler> beans = LuckSpringUtil.getBeans(LuckResultHandler.class);
        if (CollUtil.isNotEmpty(beans)) {
            for (LuckResultHandler handler : beans) {
                if (!handler.support(body.getClass())) {
                    continue;
                }
                result = handler.handle(body);
            }
        }
        if (luckEncryptProperties.isStandardResultEnable()) {
            if (!(result instanceof Result)) {
                result = Result.OK(result);
            }
            if (returnType.hasMethodAnnotation(Encrypt.class) && luckEncryptProperties.isEncryptEnable()) {
                Result<Object> res = (Result<Object>) result;
                Object data = res.getData();
                if (ObjectUtil.isNotEmpty(data)) {
                    if (!(data instanceof String) || !JSONUtil.isTypeJSON(data.toString())) {
                        data = JSONUtil.toJsonStr(data);
                    }
                    String encrypt = Base64Utils.encodeToString(data.toString().getBytes(StandardCharsets.UTF_8));
                    res.setData(encrypt);
                }
            }
        }
        return result;
    }
}

加密解密注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Decrypt {
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Encrypt {
}

自动配置属性类

@ConfigurationProperties(prefix = "luck.encrypt")
@Data
public class LuckEncryptProperties {
    private boolean encryptEnable;
    private boolean decryptEnable;
    private boolean standardResultEnable;
}

处理响应结果使用的消息转换器

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(0, new MappingJackson2HttpMessageConverter());
    }
}

starter提供给外部的响应结果处理类接口

package luck.spring.boot.starter.encrypt.demo.inter;

public interface LuckResultHandler<P, T, R> {
    R handle(P p);

    default boolean support(Class<?> clazz) {
        if (clazz == null) {
            return false;
        }
        Class<T> type = getType();
        if (type == null) {
            return false;
        }
        return clazz.equals(type);
    }

    Class<T> getType();
}

Spring容器操作的工具类

package luck.spring.boot.starter.encrypt.demo.util;

import cn.hutool.core.collection.CollUtil;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.OrderComparator;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

import java.util.*;

@Component
public class LuckSpringUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;
    private static Environment environment;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        LuckSpringUtil.applicationContext = applicationContext;
        LuckSpringUtil.environment = applicationContext.getEnvironment();
    }

    public static <T> T getBean(Class<T> tClass) {
        return applicationContext.getBean(tClass);
    }

    public static <T> List<T> getBeans(Class<T> tClass) {
        Collection<T> collection = Optional.ofNullable(getBeansMap(tClass))
                .filter(CollUtil::isNotEmpty)
                .map(Map::values)
                .orElseGet(ArrayList::new);
        return CollUtil.sort(collection, OrderComparator.INSTANCE);
    }

    public static <T> Map<String, T> getBeansMap(Class<T> tClass) {
        return applicationContext.getBeansOfType(tClass);
    }


    public static String getProperty(String key) {
        return environment.getProperty(key);
    }

    public static <T> T getProperty(String key, Class<T> tClass) {
        return environment.getProperty(key, tClass);
    }
}

统一响应结果类

package luck.spring.boot.starter.encrypt.demo.util;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;


/**
 * @author anti
 */
@NoArgsConstructor
@Data
@Accessors(chain = true)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Result<T> {

    @JsonProperty(index = 0)
    private int code;

    @JsonProperty(index = 1)
    private String message;

    @JsonProperty(index = 2)
    private T data;


    public Result(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public Result(int code, String message, T data) {
        this(code, message);
        this.data = data;
    }

    public static <T> Result<T> OK() {
        return new Result<>(200, "success");
    }


    public static <T> Result<T> OK(String message) {
        return new Result<>(200, message);
    }

    public static <T> Result<T> OK(String message, T data) {
        return new Result<>(200, message, data);
    }

    public static <T> Result<T> OK(T data) {
        return OK("请求成功", data);
    }


    public static <T> Result<T> FAIL() {
        return FAIL(500, "fail");
    }

    public static <T> Result<T> FAIL(String message) {
        return FAIL(500, message);
    }

    public static <T> Result<T> FAIL(int code, String message) {
        return FAIL(code, message, null);
    }

    public static <T> Result<T> FAIL(int code, String message, T data) {
        return new Result<>(code, String.format("请求失败,原因为:%s", message), data);
    }
}

对外暴露的,写在spring.factories文件的配置类


@ComponentScan("luck.spring.boot.starter.encrypt.demo")
@EnableConfigurationProperties(LuckEncryptProperties.class)
public class LuckEncryptConfig {
}

resources文件下,META-INF目录下的spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
luck.spring.boot.starter.encrypt.demo.expose.LuckEncryptConfig

到此,starter已经完成了,需要使用maven:install安装到仓库,开始使用starter

 maven依赖

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>luck.spring.boot.starter.encrypt.demo</groupId>
            <artifactId>luck-spring-boot-starter-encrypt-demo</artifactId>
            <version>1.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

接口

@RestController
public class LuckController {
    @PostMapping("/test")
    @Encrypt
    @Decrypt
    public String test(@RequestBody Map<String, Object> map) {
        return JSONUtil.toJsonStr(map);
    }
}

自定义starter提供的扩展接口,可以处理统一结果集

这就是简单的案例,告知怎么使用,下面做的其实没啥意义,真实根据业务来处理

package luck.spring.boot.handler;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import luck.spring.boot.starter.encrypt.demo.inter.LuckResultHandler;
import luck.spring.boot.starter.encrypt.demo.util.Result;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
public class ResultHandler implements LuckResultHandler<Object, String, Result> {
    @Override
    public Result handle(Object result) {
        if ((result instanceof Result)) {
            return (Result) result;
        }
        if (ObjectUtil.isEmpty(result)) {
            return Result.OK(result);
        }
        if (result instanceof String && JSONUtil.isTypeJSON(result.toString())) {
            result = JSONUtil.toBean(result.toString(), Map.class);
        }
        return Result.OK(result);
    }

    @Override
    public Class<String> getType() {
        return String.class;
    }
}

启动类

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

安缇吖
关注
Spring Boot快速入门 -＞ 自定义一个Starter，实现在分布式系统环境下进行请求调用链路追踪（Spring Boot + log4j2 + 雪花算法 + 消息摘要算法整合）（四）
静心泽明的博客
07-17 549
Spring Boot Starter简介自定义日志启动器整合spring boot + log4j2测试代码链接 简介 Spring Boot项目的快速发展，很大程度依赖于Starter的出现。通过Starter，可以获取到所需相关技术的一站式支持，比如：相关依赖丶相关自动配置文件和相关Bean，无需通过代码和复制粘贴。例如当我们需要Spring Web支持的时候，我们只需要引入spring-boot-starter-web这个依赖即可，轻松快捷，而且它还内嵌了Tomcat，自动帮我们开启Spring W
SpringBoot自定义注解使用AOP实现请求参数解密以及响应数据加密
Agger的博客
12-06 6650
SpringBoot自定义注解使用AOP实现请求参数解密以及响应数据加密 一、前言 本篇文章将依托与SpringBoot平台，自定义注解用来标识接口请求是否实现加密解密。使用AOP切面来具体操作解密加密，实现对源代码的低耦合，不在原基础上做很大的改动。 本篇文章的所有示例，都上传到我的github中，欢迎大家拉取测试，欢迎star github 实现要求： 自定义一个注解@Secret，用来...
前后端API交互如何保证数据安全性？
weixin_34009794的博客
06-04 7316
前言 前后端分离的开发方式，我们以接口为标准来进行推动，定义好接口，各自开发自己的功能，最后进行联调整合。无论是开发原生的APP还是webapp还是PC端的软件,只要是前后端分离的模式，就避免不了调用后端提供的接口来进行业务交互。 网页或者app，只要抓下包就可以清楚的知道这个请求获取到的数据，这样的接口对爬虫工程师来说是一种福音，要抓你的数据简直轻而易举。 数据的安全性非常重要，特别是用户相关的...
SpringBoot 接口加密解密，新姿势！
qq_22343483的博客
04-13 3811
在我们日常的Java开发中，免不了和其他系统的业务交互，或者微服务之间的接口调用如果我们想保证数据传输的安全，对接口出参加密，入参解密。但是不想写重复代码，我们可以提供一个通用starter，提供通用加密解密功能自定义starter步骤创建工厂，编写功能代码声明自动配置类，把需要对外提供的对象创建好，通过配置类统一向外暴露。
SpringBoot Starter 通用接口加密组件
weixin_58097295的博客
11-12 270
通用接口加密组件
SpringBoot 接口如何加密解密
hymuuuu的博客
07-03 833
自定义starter步骤创建工厂，编写功能代码声明自动配置类，把需要对外提供的对象创建好，通过配置类统一向外暴露在resource目录下准备一个名为的文件，以为key，自动配置类为value列表，进行注册接口相应数据的时候，返回的是加密之后的数据 接口入参的时候，接收的是解密之后的数据，但是在进入接口之前，会自动解密，取得对应的数据。
SpringBoot配置文件密码加密与解密
05-28 1720
SpringBoot配置文件密码加密与解密
SpringBoot 接口层统一加密解密
mxt51220的博客
11-18 710
自定义starter步骤创建工厂，编写功能代码声明自动配置类，把需要对外提供的对象创建好，通过配置类统一向外暴露在resource目录下准备一个名为spring/spring.factories的文件，以org.springframework.boot.autoconfigure.EnableAutoConfiguration为key，自动配置类为value列表，进行注册。
SpringBoot 接口加密解密，新姿势
mxt51220的博客
12-17 1054
自定义starter步骤创建工厂，编写功能代码声明自动配置类，把需要对外提供的对象创建好，通过配置类统一向外暴露在resource目录下准备一个名为的文件，以为key，自动配置类为value列表，进行注册。
新姿势,Spring Boot 接口加解密!
2301_76936922的博客
04-23 329
然而，为了避免重复编写代码，我们可以提供一个通用starter，其中包含了通用的加密和解密功能。除此之外，我们还可以对该starter进行进一步的优化，比如增加对HTTP请求的拦截和处理、加入其他安全机制等，以更好地保护我们的系统和数据安全。接口相应数据的时候，返回的是加密之后的数据 接口入参的时候，接收的是解密之后的数据，但是在进入接口之前，会自动解密，取得对应的数据。提供了优雅的参数校验，入参都是实体类，在实体类字段上加上对应注解，就可以在进入方法之前，进行参数校验，如果参数错误，会抛出错误。
【开源项目】SpringBoot实现接口加密解密
秋装什么的博客
04-17 917
【开源项目】SpringBoot实现接口加密解密
接口安全防线加解密：springboot 全局-指定接口解密（同时支持参数在body和param）
最新发布
ZL_1618的博客
10-08 1213
1.application/json 加密参数在body2.application/x-www-form-urlencoded 支持参数在body或者在param/***/@Override@Override=null){}else{/***/try {= null) {} else {= null) {try {= null) {try {@Override@Override@Override。
springboot实现对RESTful API接口进行统一加解密
weixin_42034623的博客
03-14 1773
值也是hex值，key是base64的则加密后的值也是base64值,其中AES、DES、SM4是对称加密，加解密直接设置key值，publicKey和privateKey值不用设置，非对称加密RSA、SM2需要设置公私钥，key不用设置。加密key的生成使用Sm2Utils.java、Sm4Utils.java、RsaUtils.java、AesUtils.java、DesUtils.java生成,生成的key转base64或hex值，key是hex值的加密后的。拦截请求前后，所以请求参数必须有。
徒手撸一个Spring Boot中的starter，解密自动化配置
ITMuch的专栏
02-05 218
点击上方IT牧场，选择置顶或者星标技术干货每日送达！starter背景Spring Boot目前已经变成了后端开发这必备技能之一，其中一个主要原因是Spring Boot中有个非常重...
springboot2.X手册：防抓包？快速实现API接口数据加密
程序员闪充宝
11-20 4330
有没有遇到这样子的接口，放到互联网上面去，谁都可以调用，谁都可以访问，完全就是公开的，这样子的接口，如果只是普通的数据，其实可以考虑，只是可以考虑，但是，一般情况下，我们是不允许这样子做...
SpringBoot集成国产加密SM4
qq_36592394的博客
08-04 903
【代码】SpringBoot集成国产加密SM4。
SpringBoot实现国密SM4加密、解密
山不见我，我自见山
09-04 6982
SM4.0（原名SMS4.0）是中华人民共和国政府采用的一种分组密码标准，由国家密码管理局于2012年3月21日发布。相关标准为“GM/T 0002-2012《SM4分组密码算法》（原SMS4分组密码算法）”。在商用密码体系中，SM4主要用于数据加密，其算法公开，分组长度与密钥长度均为128bit，加密算法与密钥扩展算法都采用32轮非线性迭代结构，S盒为固定的8比特输入8比特输出。
springboot接口统一加密解密
HLH_2021的博客
02-04 7588
文章目录1. 介绍2. 前置知识2.1 hutool-crypto加密解密工具2.2 request流只能读取一次的问题2.2.1 问题：2.2.2 解决办法2.3 SpringBoot的参数校验validation2.5 自定义starter2.6 RequestBodyAdvice和ResponseBodyAdvice3. 功能介绍4. 功能细节5. 代码实现5.1 项目结构5.2 crypto-common5.2.1 结构5.3 crypto-spring-boot-starter5.3.1 接口5.
SpringBoot接口加密解密实战：通用Starter与安全传输
"这篇文档是关于在SpringBoot应用中实现接口加密解密的教程，主要关注如何通过创建一个通用的starter来提供加密解密功能，同时解决了request流只能读取一次的问题。" 在SpringBoot应用中，接口的安全性至关重要，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值