统一接口解密封装校验参数

最新推荐文章于 2022-10-24 11:54:50 发布
最新推荐文章于 2022-10-24 11:54:50 发布
阅读量468 收藏 1
点赞数 1
分类专栏： 默认分类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28807077/article/details/109784065
版权

需求

  最近做了一个跟合作方数据同步的接口，接口是HTTP post请求，加密方法是将json字符串AES加密然后转成base64字符串。有两种情况，一种是Content-type=text/plain，这时，整个body是一个经过加密的json字符串，另一种情况是Content-type=multipart/form-data，这时候，每一个表单字段都是独立加密，每个文件的每一行是单独加密的json字符串。

思路

  • 定义注解@Decrypt，写在controller层的方法上，类似于spring的@RequestMapping，表示这个方法需要解码
  • 定义注解@DecryptPojo，@DecryptSimple，写在方法的参数上，类似于spring的@RequestParam，表示参数需要解码，@DecryptPojo表示把参数解密封装到pojo，pojo的字段名和参数名必须相同，@DecryptSimple表示把参数解密并赋值到同名参数上
  • 通过springAOP拦截带有@Decrypt的方法，处理参数

代码实现

aop拦截器

package com.aaa.bbb.aspect;

import java.io.BufferedReader;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.http.HttpHeaders;
import org.aspectj.lang.reflect.CodeSignature;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.alibaba.fastjson.JSONObject;
import com.aaa.bbb.annotation.Decrypt;
import com.aaa.bbb.annotation.DecryptPojo;
import com.aaa.bbb.annotation.DecryptSimple;
import com.aaa.bbb.annotation.Valid;
import com.aaa.bbb.exception.DecryptException;
import com.aaa.bbb.stream.DecryptLineInputStream;
import com.aaa.bbb.utils.ValidationUtil;

import cn.hutool.core.convert.Convert;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.AES;

@Aspect
@Component
public class DecryptAspect{
 	private final ServletFileUpload servletFileUpload;

    @Autowired
    public DecryptAspect(ServletFileUpload servletFileUpload) {
        this.servletFileUpload = servletFileUpload;
    }

	@Around("@annotation(decryptAnnotation)")
	public Object doBefore(ProceedingJoinPoint joinPoint, Decrypt decryptAnnotation) throws Throwable {
		HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
                .getRequest();
        Object[] params = joinPoint.getArgs();//所有参数
        String[] paramNames = ((CodeSignature) joinPoint.getSignature()).getParameterNames();//所有参数名
        Class<?>[] parameterTypes = ((CodeSignature) joinPoint.getSignature()).getParameterTypes();//所有参数的类型
        if (params.length == 0) {
            return joinPoint.proceed(params);
        }
        //获取方法，此处可将signature强转为MethodSignature
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        //参数注解，1维是参数，2维是注解
        Annotation[][] annotations = method.getParameterAnnotations();
        Optional<AES> aesOptional = Optional.ofNullable(SecureUtil.aes(StrUtil.utf8Bytes("passwordpassword")));
        if (aesOptional.isEmpty()) {
            throw new DecryptException();
        }
        JSONObject parseObject = new JSONObject();//把解密的参数缓存到jsonObject
        /*
        解密参数
         */
        if (ServletFileUpload.isMultipartContent(request)) {
            List<FileItem> itemList = servletFileUpload.parseRequest(request);
            for (FileItem fileItem : itemList) {
                if (fileItem.isFormField()) {
                    //表单字段
                    String value;
                    try {
                        value = aesOptional.get().decryptStr(IoUtil.readUtf8(fileItem.getInputStream()));
                    } catch (Exception e) {
                        throw new DecryptException();
                    }
                    parseObject.put(fileItem.getFieldName(), value);
                } else {
                    //文件
                    DecryptLineInputStream decryptLineInputStream = new DecryptLineInputStream(fileItem.getInputStream(), aesOptional.get());
                    parseObject.put(fileItem.getFieldName(), decryptLineInputStream);
                }
            }
        } else {
            BufferedReader utf8Reader = IoUtil.getUtf8Reader(request.getInputStream());
            String s = utf8Reader.readLine();
            if (StrUtil.isBlank(s)) {
                return joinPoint.proceed(params);
            }
            String decryptStr;
            try {
                decryptStr = aesOptional.get().decryptStr(s);
            } catch (Exception exception) {
                throw new DecryptException();
            }
            parseObject = JSONObject.parseObject(decryptStr);
        }
        /*
        绑定参数
         */
        for (int i = 0; i < annotations.length; i++) {
            Annotation[] paramAnn = annotations[i];
            //该参数没有注解，直接下一个参数
            if (paramAnn.length == 0) {
                continue;
            }
            for (Annotation annotation : paramAnn) {
                //annotation就是参数上的注解
                if (annotation.annotationType().equals(DecryptPojo.class)) {
                    params[i] = parseObject.toJavaObject(params[i].getClass());
                } else if (annotation.annotationType().equals(DecryptSimple.class)) {
                    params[i] = Convert.convert(parameterTypes[i], parseObject.get(paramNames[i]));
                }
            }
        }
        /*
        校验参数
         */
        for (int i = 0; i < annotations.length; i++) {
            Annotation[] paramAnn = annotations[i];
            //该参数没有注解，直接下一个参数
            if (paramAnn.length == 0) {
                continue;
            }
            for (Annotation annotation : paramAnn) {
                //annotation就是参数上的注解
                if (annotation.annotationType().equals(Valid.class)) {
                    List<String> validate = ValidationUtil.validate(params[i]);
                    if (!validate.isEmpty()) {
                        throw new BusinessException(String.join("；", validate));
                    }
                }
            }
        }
        return joinPoint.proceed(params);
	}
}

Apache Common Upload配置

package com.aaa.bbb.config;

import cn.hutool.core.io.FileUtil;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.FileCleanerCleanup;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.File;
import java.nio.charset.StandardCharsets;

@Configuration
public class BeanConfig {

    @Bean
    public ServletListenerRegistrationBean<FileCleanerCleanup> resourceCleanupBean() {
        return new ServletListenerRegistrationBean<>(new FileCleanerCleanup());
    }

    @Bean
    public ServletFileUpload servletFileUpload() {
        DiskFileItemFactory factory = new DiskFileItemFactory();
        factory.setRepository(FileUtil.mkdir(FileUtil.getTmpDirPath() + File.separator + "uploadTemp"));
        factory.setDefaultCharset(StandardCharsets.UTF_8.name());
        ServletFileUpload servletFileUpload = new ServletFileUpload(factory);
        servletFileUpload.setFileSizeMax(52428800L);//#最大上传大小50MB，单位Byte
        return servletFileUpload;
    }

}

注解

package com.aaa.bbb.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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


package com.aaa.bbb.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

package com.aaa.bbb.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DecryptSimple {
	String value() default "";
}

package com.aaa.bbb.annotation;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * CharSequence (length of character sequence is evaluated)
 * Collection (collection size is evaluated)
 * Map (map size is evaluated)
 * Array (array length is evaluated)
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NotEmpty {
    String message() default "";
}

package com.aaa.bbb.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NotNull {
    String message() default "";
}

package com.aaa.bbb.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Valid {
}

封装带解密校验功能的输入流

package com.aaa.bbb.stream;

import cn.hutool.core.io.IoUtil;
import cn.hutool.crypto.symmetric.AES;
import com.alibaba.fastjson.JSONObject;
import com.aaa.bbb.exception.DecryptException;
import com.aaa.bbb.utils.ValidationUtil;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.util.Optional;

public class DecryptLineInputStream extends InputStream {
    private final BufferedReader bufferedReader;
    private final AES aes;

    public DecryptLineInputStream(InputStream inputStream, AES aes) {
        bufferedReader = IoUtil.getUtf8Reader(inputStream);
        this.aes = aes;
    }

    @Override
    public int read() {
        throw new RuntimeException("请使用其他read方法");
    }

    public String readLine() throws IOException {
        String line = bufferedReader.readLine();
        Optional<String> optional = Optional.ofNullable(line);
        String result = null;
        if (optional.isPresent()) {
            try {
                result = aes.decryptStr(line);
            } catch (Exception exception) {
                throw new DecryptException();
            }
        }
        return result;
    }

    public JSONObject readJsonLine() throws IOException {
        String line = readLine();
        Optional<String> optional = Optional.ofNullable(line);
        return optional.isPresent() ? JSONObject.parseObject(line) : null;
    }

    public <T> T readJavaObjLine(Class<T> clazz) throws IOException {
        JSONObject jsonObject = readJsonLine();
        Optional<JSONObject> optional = Optional.ofNullable(jsonObject);
        return optional.isPresent() ? jsonObject.toJavaObject(clazz) : null;
    }

	public <T> T readJavaObjLineWithValid(Class<T> clazz, StringBuilder failMsg) {
        T javaObj = readJavaObjLine(clazz);
        Optional<T> optional = Optional.ofNullable(javaObj);
        boolean present = optional.isPresent();
        if (present) {
            List<String> validate = ValidationUtil.validate(javaObj);
            for (String s : validate) {
                failMsg.append(s);
            }
            return javaObj;
        } else {
            return null;
        }
    }
}

AES解密异常

package com.aaa.bbb.exception;

public class DecryptException extends RuntimeException {
}

校验工具

package com.aaa.bbb.utils;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import com.aaa.bbb.annotation.NotEmpty;
import com.aaa.bbb.annotation.NotNull;

import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.*;

public class ValidationUtil {

    @SuppressWarnings("ConstantConditions")
    public static List<String> validate(Object obj) {
        List<String> result = new LinkedList<>();
        Field[] fields = ReflectUtil.getFields(obj.getClass());
        for (Field field : fields) {
            Annotation[] annotations = field.getAnnotations();
            for (Annotation annotation : annotations) {
                if (Objects.equals(annotation.annotationType(), NotEmpty.class)) {
                    Object fieldValue = ReflectUtil.getFieldValue(obj, field);
                    String msg = ((NotEmpty) annotation).message();
                    if (Objects.isNull(fieldValue)) {
                        result.add(msg);
                    }
                    if (StrUtil.isEmpty(msg)) {
                        msg = StrUtil.format("{}不能为空", field.getName());
                    }
                    if (fieldValue instanceof String) {
                        if (StrUtil.isEmpty((String) fieldValue)) {
                            result.add(msg);
                        }
                    } else if (fieldValue instanceof Collection) {
                        if (CollUtil.isEmpty((Collection<?>) fieldValue)) {
                            result.add(msg);
                        }
                    } else if (fieldValue instanceof Map) {
                        if (MapUtil.isEmpty((Map<?, ?>) fieldValue)) {
                            result.add(msg);
                        }
                    } else if (fieldValue instanceof Array) {
                        if (ArrayUtil.isEmpty((Object[]) fieldValue)) {
                            result.add(msg);
                        }
                    }
                } else if (Objects.equals(annotation.annotationType(), NotNull.class)) {
                    Object fieldValue = ReflectUtil.getFieldValue(obj, field);
                    String msg = ((NotNull) annotation).message();
                    if (StrUtil.isEmpty(msg)) {
                        msg = StrUtil.format("{}不能为空", field.getName());
                    }
                    if (Objects.isNull(fieldValue)) {
                        result.add(msg);
                    }
                }
            }
        }
        return result;
    }
}

pojo

package com.aaa.bbb.pojo;

import com.aaa.bbb.stream.DecryptLineInputStream;
import com.aaa.bbb.annotation.NotEmpty;
import com.aaa.bbb.annotation.NotNull;
import lombok.Data;

@Data
public class UserPojo {
	@NotEmpty
    private String name;
    @NotEmpty
    private String age;
    @NotNull
    private DecryptLineInputStream file;
}

测试

text/plain测试用例E6i/TvyevlNqxtmEBsXJbdb9yHjgyWTAG5eveQbd5CY=
multipart/form-data测试文件：https://download.csdn.net/download/qq_28807077/16658608

	@PostMapping("/testAes")
    @Decrypt
    public String testAes(@DecryptSimple String name, @DecryptSimple(type = Integer.class) Integer age, @DecryptPojo UserPojo userPojo) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", name);
        jsonObject.put("age", age);
        jsonObject.put("userPojo", userPojo);
        System.out.println(jsonObject);
        return "ok";
    }

    @PostMapping("/testMultipart")
    @Decrypt
    public String testMultipart(@DecryptSimple String name, @DecryptSimple String age, @DecryptPojo UserPojo userPojo) throws IOException {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", name);
        jsonObject.put("age", age);
        jsonObject.put("userPojo", userPojo);
        DecryptLineInputStream inputStream = userPojo.getFile();
        String line;
        while ((line = inputStream.readLine()) != null) {
            jsonObject.put(IdUtil.objectId(), line);
        }
        System.out.println(jsonObject);
        return "ok";
    }

spring framework xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:task="http://www.springframework.org/schema/task"
	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
           http://www.springframework.org/schema/task 
           http://www.springframework.org/schema/task/spring-task.xsd
           http://www.springframework.org/schema/mvc 
           http://www.springframework.org/schema/mvc/spring-mvc.xsd 
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd
           http://www.springframework.org/schema/aop    
		   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"
	xmlns:tx="http://www.springframework.org/schema/tx">

	<aop:aspectj-autoproxy expose-proxy="true"></aop:aspectj-autoproxy>
	<context:component-scan base-package="com.aaa.bbb" />
</beans>

maven配置

spring framework版

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>5.2.9.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>cn.hutool</groupId>
			<artifactId>hutool-all</artifactId>
			<version>5.6.1</version>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.9.6</version>
		</dependency>
		<dependency>
			<groupId>aopalliance</groupId>
			<artifactId>aopalliance</artifactId>
			<version>1.0</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.74</version>
		</dependency>
		<dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

springboot版

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.6.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

可能会遇到的问题

  如果是springboot，默认的上传机制会导致Apache Commons FileUpload servletFileUpload.parseRequest(request)返回的List长度为0，关闭springboot默认上传机制即可。

spring:
  servlet:
    multipart:
      enabled: false
我是你亲爱的航哥
关注
专栏目录
常用加密解密函数封装----AES加解密
wangweiruning的博客
12-09 219
常用加密解密函数封装----AES加解密！
SpringBoot 接口层统一加密解密
最新发布
mxt51220的博客
11-18 546
自定义starter步骤创建工厂，编写功能代码声明自动配置类，把需要对外提供的对象创建好，通过配置类统一向外暴露在resource目录下准备一个名为spring/spring.factories的文件，以org.springframework.boot.autoconfigure.EnableAutoConfiguration为key，自动配置类为value列表，进行注册。
统一接口解密封装校验参数测试用例
04-13
统一接口解密封装校验参数测试用例
spring 统一再处理接口返回的json数据
01-14
最近公司项目出现这样一个问题，公司的项目部署在政务云服务器，而政务云服务器所在网络是电信提供的，如果用户通过手机的非电信4G网络访问项目资源，比如MP4等，则会被电信拦截，导致访问极慢无法正常提供服务。为了解决这个问题需要用cdn服务来提供资源，以前的资源都是存在服务器上，因此需要做最小的调整切换cdn服务。 解决方案： 在spring框架下，可以利用ResponseBodyAdvice接口，实现该接口则能够在声明了ResponseBody注解的controller返回json数据前，统一对json数据做处理，将资源地址的url统一替换为cdn资源url。
参数加密/解密
if_else1的博客
06-04 1314
依赖 <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.3.7</version> </dependency> import cn.hutool.crypto.SecureUtil; import cn.hutool.crypto.symmetric.AES;
jfinal js 拦截_JFinal 参数校验插件扩展，让后台参数校验像js一样方式好用
weixin_34096885的博客
01-14 89
一、插件实现插件的功能就是加载校验规则，实现代码如下 package com.nmtx.plugins.validation; import java.util.Properties; import com.jfinal.core.Const; import com.jfinal.kit.Prop; import com.jfinal.kit.PropKit; import com.jfinal....
微信小程序接口封装、原生接口封装、request、params封装
06-10
在封装过程中，还可以添加数据校验功能，确保传入的参数符合预期，从而减少因参数问题导致的错误。 5. 小程序方法封装： 除了接口和请求的封装，我们还可以对小程序中的其他方法进行封装，如页面事件处理、数据操作...
Java实现RSA加密解密签名校验
02-14
Java实现RSA加密解密签名校验是信息安全领域中常见的任务，尤其在数据传输和网络通信中，RSA算法因其非对称性的特点，被广泛应用于数据的加密、解密以及数字签名。下面将详细介绍RSA算法的基本原理，以及如何使用...
java注解加密参数,如何优雅的实现 Spring Boot 接口参数加密解密？
weixin_40006965的博客
03-22 905
因为有小伙伴刚好问到这个问题，松哥就抽空撸一篇文章和大家聊聊这个话题。加密解密本身并不是难事，问题是在何时去处理？定义一个过滤器，将请求和响应分别拦截下来进行处理也是一个办法，这种方式虽然粗暴，但是灵活，因为可以拿到一手的请求参数和响应数据。不过 SpringMVC 中给我们提供了 ResponseBodyAdvice 和 RequestBodyAdvice，利用这两个工具可以对请求和响应进行预处...
springboot接口统一加密解密
HLH_2021的博客
02-04 7304
文章目录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.
java实现sm2、sm3、sm4国密算法，完美实现，轻松调用
10-15
国密是咱大中国的国家密码局认定和颁发的密码算法标准，SM 是一个系列，常用的包括SM1、SM2、SM3、SM4。 一般说商密是指商用密码。更多是我们更加耳熟能详的的密码学标准。诸如AES、DAS、RSA、ECC椭圆曲线系列等加密算法。 为什么有了商密还要国密。主要原因可能包括： 1、一部分商密的设计中涉及到的一些具体步骤主要是老美的一些强力部门负责的。里面是不是有个什么漏洞啊、后门啊什么的不清楚。 2、国密是自己人弄的，对于原理和实现细节一清二楚。用起来放心。 目前国密主要是对国内的产品，有些特殊的产品国家会强制使用。
java中实现接口统一加解密
qq_41132384的博客
10-24 2913
可以直接落地的java统一接口加解密方案
SpringBoot中接口加密解密统一处理
热门推荐
熊诗言的博客
07-27 4万+
项目参见https://gitee.com/xxssyyyyssxx/affect-inoutput 我们与客户端的接口交互中，为了更高的安全性，我们可能需要对接口加密（请求参数加密，服务端解密）、返回信息加密（服务端加密，客户端解密），但是也不是所有的接口都这样，有些接口可能不需要，我们可以使用注解来轻松达到此要求。 将接口参数的加密解密和返回信息的加密解密分开，分别定义注解，利用C...
spring mvc 自定义注解ResponseEncryptBody、RequestDecryptBody统一处理加密、解密数据，供移动端使用的rest服务
nobody
10-30 8705
spring mvc 自定义注解ResponseEncryptBody、RequestDecryptBody统一处理加密、解密数据，供移动端使用的rest服务 自定义两个注解： /** * 类似spring注解作用，会做加密处理 * 支持返回类型：map、自定义对象类型 * * @author sdcuike 2016年10月25日 */ @Target(Element
7hutool实战FileUtil 文件工具类(100多个文件常用操作方法)
web15870359587的博客
03-03 1万+
技术活，该赏 关注+一键三连（点赞，评论，收藏）再看，养成好习惯 hutool实战（带你掌握里面的各种工具）目录 用途：文件工具类(文件常用操作) 使用场景 提供100多个文件常用操作方法，包含并不局限于：判断文件或文件夹是否为空、判断file是否为文件或文件夹、递归文件夹里的所有文件、获取指定文件夹的所有文件名、获取临时文件夹或临时文件的内容或者路径、计算文件夹或文件的总大小、创建文件或文件夹、创建临时文件或临时文件夹、删除文件或文件夹、修改文件名或文件夹名、复制文件或文件夹、移动文件或文件夹、清空文件
FileUtil：获取jar所在目录
capslk的专栏
12-14 823
最近做一个企业应用，需要在项目打包后，生成的jar包所在目录生成一个临时目录。 开始，直接取了user.dir，可打包后发现出不对：user.dir为用户工作目录。 那么只能从class loading入手了，从加载资源class计算URL得到一个该目录（这样能得到结果，就是不知道有什么风险？我在windows和linux上测试过）。 我的FileUtil代码如下： public clas...
SpringBoot接口统一签名校验实践
明平姚的博客
11-16 4837
本文实现了接口请求签名校验，时间戳判断，响应数据返回签名等内容。 这个签名校验，和返回签名可以用多种方法实现。 本文通过aop 方式去实现 自定义注解体 /** * @author xxx */ @Retention(value = RetentionPolicy.RUNTIME) public @interface SignatureValidation { } aop实现 /** * @author xxx */ @Aspect @Component publi.
学习加密(四)spring boot 使用RSA+AES混合加密,前后端传递参数加解密(方式一)
huangxingjie的博客
05-19 630
参考地址：https://blog.csdn.net/baidu_38990811/article/details/83540404
Java全平台加密解密工具详解及示例
在`EncryptDecrypt`类中，可能包含如`generateAESKey`方法，通过`KeyGenerator`接口生成一个`SecretKey`，用于后续的`Cipher`对象操作。`doAES`方法则用于实际的加密和解密过程，调用`Cipher`的`doFinal`方法，可能...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值