Spring Boot应用之数据加密以及字段过滤

最新推荐文章于 2024-08-18 12:00:00 发布
最新推荐文章于 2024-08-18 12:00:00 发布
阅读量9.9k 收藏 10
点赞数
分类专栏： SpringBoot 文章标签： spring

1、应用背景

在使用Spring Boot开发基于restful类型的API时，对于返回的JSON数据我们经常需要对数据进行加密，有的时候我们还必须过滤掉一些对象字段的值来减少网络流量

2、解决方案

1）加密

对返回的数据进行加密，我们必须对spring boot返回json数据前对数据进行拦截和加密处理，为了方便api调用解析还原数据，我们采用双向加密的方式，因为客户端需要解密为明文，加密的使用java本身提供。重点在于在返回数据前进行拦截处理，这时我们可以实现spring boot中的ResponseBodyAdvice接口来打到目的。该接口有两个方法

public interface ResponseBodyAdvice<T> {
    boolean supports(MethodParameter var1, Class<? extends HttpMessageConverter<?>> var2);

    T beforeBodyWrite(T var1, MethodParameter var2, MediaType var3, Class<? extends HttpMessageConverter<?>> var4, ServerHttpRequest var5, ServerHttpResponse var6);
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5

从中可以看出我们着重需要对beforeBodyWrite这个方法进行实现，supports方法的话可以根据自己的需求来确定是否需要使用这个拦截处理

2）数据字段的过滤

对于数据字段的过滤我们这里有两种需求。第一是每个API返回某个对象的数据字段是相同的，比如User对象，每个API需要返回的都是去掉password这个字段，那这种情况我们可以采用JsonView的方式，具体网上可以找到解决方案。第二种需求是对于每一个API返回的某个对象的数据字段不一定相同，都可以通过配置的方式，简单而灵活的达到过滤数据的目的。这时我们的解决方案是在每一个API方法上自定义一个注解，可以配置返回的对象应该包含或者去除哪些字段 ，基于这样的思考我们也可以通过ResponseBodyAdvice中的beforeBodyWrite方法来实现

3、实施方案

1）新建maven项目，添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.cyxl</groupId>
    <artifactId>sprint-boot-responsebodyadvice</artifactId>
    <version>1.0-SNAPSHOT</version>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>


</project>
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

主要是添加spring boot的支持
2) 搭建基本框架
文件结构图

具体各个文件代码如下
User模型

package org.cyxl.model;

/**
 * Created by jeff on 15/10/23.
 */
public class User {
    private int id;
    private String email;
    private String password;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

Application启动类

package org.cyxl;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

/**
 * Created by jeff on 15/10/23.
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args){
        SpringApplication.run(Application.class, args);
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

UserController类

package org.cyxl.controller;

import org.cyxl.model.User;
import org.cyxl.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * Created by jeff on 15/10/23.
 */
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    UserService userService;

    @RequestMapping("/{id}")
    public User findUserById(@PathVariable("id")int id){
        return userService.getUserById(id);
    }

    @RequestMapping("/all")
    public List<User> findAllUser(){
        return userService.getAllUser();
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

UserService类

package org.cyxl.service;

import org.cyxl.model.User;
import org.cyxl.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * Created by jeff on 15/10/23.
 */
@Service
public class UserService {
    @Autowired
    UserRepository userRepository;

    public User getUserById(int id){
        return userRepository.getUserById(id);
    }

    public List<User> getAllUser(){
        return userRepository.getAllUser();
    }
}

  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

UserRepository类

package org.cyxl.repository;

import org.cyxl.model.User;
import org.springframework.stereotype.Repository;

import javax.jws.soap.SOAPBinding;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by jeff on 15/10/23.
 */
@Repository
public class UserRepository {
    //模仿数据
    private static  List<User> users = new ArrayList<User>();

    static {
        //初始化User数据
        for (int i=0;i<10;i++){
            User user = new User();
            user.setId(i);
            user.setEmail("email" + i);
            user.setPassword("password" + i);

            users.add(user);
        }
    }
    public User getUserById(int id){
        for (User user : users){
            if(user.getId() == id){
                return user;
            }
        }
        return  null;
    }


    public List<User> getAllUser(){
        return users;
    }
}

  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

此处没有用数据库，采用模拟数据

当前访问http://localhost:8080/user/2的结果是

{"id":2,"email":"email2","password":"password2"}
  
  
  • 1

访问http://localhost:8080/user/all的结果是

[{"id":0,"email":"email0","password":"password0"},{"id":1,"email":"email1","password":"password1"},{"id":2,"email":"email2","password":"password2"},{"id":3,"email":"email3","password":"password3"},{"id":4,"email":"email4","password":"password4"},{"id":5,"email":"email5","password":"password5"},{"id":6,"email":"email6","password":"password6"},{"id":7,"email":"email7","password":"password7"},{"id":8,"email":"email8","password":"password8"},{"id":9,"email":"email9","password":"password9"}]
  
  
  • 1

3）数据加密及过滤

实现自定义注解SerializedField

package org.cyxl.annotation;

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

/**
 * Created by jeff on 15/10/23.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SerializedField {
    /**
     * 需要返回的字段
     * @return
     */
    String[] includes() default {};

    /**
     * 需要去除的字段
     * @return
     */
    String[] excludes() default {};

    /**
     * 数据是否需要加密
     * @return
     */
    boolean encode() default true;
}


  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

实现ResponseBodyAdvice接口的MyResponseBodyAdvice

package org.cyxl;

import org.cyxl.annotation.SerializedField;
import org.cyxl.util.Helper;
import org.springframework.core.MethodParameter;
import org.springframework.core.annotation.Order;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

import java.lang.reflect.Field;
import java.util.*;

/**
 * Created by jeff on 15/10/23.
 */
@Order(1)
@ControllerAdvice(basePackages = "org.cyxl.controller")
public class MyResponseBodyAdvice implements ResponseBodyAdvice {
    //包含项
    private String[] includes = {};
    //排除项
    private String[] excludes = {};
    //是否加密
    private boolean encode = true;

    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        //这里可以根据自己的需求
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        //重新初始化为默认值
        includes = new String[]{};
        excludes = new String[]{};
        encode = true;

        //判断返回的对象是单个对象，还是list，活着是map
        if(o==null){
            return null;
        }
        if(methodParameter.getMethod().isAnnotationPresent(SerializedField.class)){
            //获取注解配置的包含和去除字段
            SerializedField serializedField = methodParameter.getMethodAnnotation(SerializedField.class);
            includes = serializedField.includes();
            excludes = serializedField.excludes();
            //是否加密
            encode = serializedField.encode();
        }

        Object retObj = null;
        if (o instanceof List){
            //List
            List list = (List)o;
            retObj = handleList(list);
        }else{
            //Single Object
            retObj = handleSingleObject(o);
        }
        return retObj;
    }

    /**
     * 处理返回值是单个enity对象
     *
     * @param o
     * @return
     */
    private Object handleSingleObject(Object o){
        Map<String,Object> map = new HashMap<String, Object>();

        Field[] fields = o.getClass().getDeclaredFields();
        for (Field field:fields){
            //如果未配置表示全部的都返回
            if(includes.length==0 && excludes.length==0){
                String newVal = getNewVal(o, field);
                map.put(field.getName(), newVal);
            }else if(includes.length>0){
                //有限考虑包含字段
                if(Helper.isStringInArray(field.getName(), includes)){
                    String newVal = getNewVal(o, field);
                    map.put(field.getName(), newVal);
                }
            }else{
                //去除字段
                if(excludes.length>0){
                    if(!Helper.isStringInArray(field.getName(), excludes)){
                        String newVal = getNewVal(o, field);
                        map.put(field.getName(), newVal);
                    }
                }
            }

        }
        return map;
    }

    /**
     * 处理返回值是列表
     *
     * @param list
     * @return
     */
    private List handleList(List list){
        List retList = new ArrayList();
        for (Object o:list){
            Map map = (Map) handleSingleObject(o);
            retList.add(map);
        }
        return retList;
    }

    /**
     * 获取加密后的新值
     *
     * @param o
     * @param field
     * @return
     */
    private String getNewVal(Object o, Field field){
        String newVal = "";
        try {
            field.setAccessible(true);
            Object val = field.get(o);

            if(val!=null){
                if(encode){
                    newVal = Helper.encode(val.toString());
                }else{
                    newVal = val.toString();
                }
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return newVal;
    }
}


  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145

在beforeBodyWrite方法中，我们对拦截的数据根据配置文件进行是否加密和字段过滤。在类上面的注解Order是指定这个拦截器（切确的说是切入点，我们姑且叫做拦截器）的执行优先顺序，ControllerAdvice中的basePackages是指定哪些类需要使用该拦截器，这个很重要。

代码中用到两个工具类Helper和DesUtil这里也贴一下代码
Helper

package org.cyxl.util;

import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

/**
 * Created by jeff on 15/10/23.
 */
public class Helper {
    private static String key = "wow!@#$%";

    public static boolean isStringInArray(String str, String[] array){
        for (String val:array){
            if(str.equals(val)){
                return true;
            }
        }
        return false;
    }

    public static String encode(String str){
        String enStr = "";
        try {
            enStr = DesUtil.encrypt(str, key);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return enStr;
    }

    public static String decode(String str) {
        String deStr = "";
        try {
            deStr = DesUtil.decrypt(str, key);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return deStr;
    }
}

  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

DesUtil

package org.cyxl.util;

import java.io.IOException;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class DesUtil {

    private final static String DES = "DES";

    public static void main(String[] args) throws Exception {
        String data = "123 456";
        String key = "wow!@#$%";
        System.err.println(encrypt(data, key));
        System.err.println(decrypt(encrypt(data, key), key));

    }

    /**
     * Description 根据键值进行加密
     * @param data
     * @param key  加密键byte数组
     * @return
     * @throws Exception
     */
    public static String encrypt(String data, String key) throws Exception {
        byte[] bt = encrypt(data.getBytes(), key.getBytes());
        String strs = new BASE64Encoder().encode(bt);
        return strs;
    }

    /**
     * Description 根据键值进行解密
     * @param data
     * @param key  加密键byte数组
     * @return
     * @throws IOException
     * @throws Exception
     */
    public static String decrypt(String data, String key) throws IOException,
            Exception {
        if (data == null)
            return null;
        BASE64Decoder decoder = new BASE64Decoder();
        byte[] buf = decoder.decodeBuffer(data);
        byte[] bt = decrypt(buf,key.getBytes());
        return new String(bt);
    }

    /**
     * Description 根据键值进行加密
     * @param data
     * @param key  加密键byte数组
     * @return
     * @throws Exception
     */
    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
        // 生成一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密钥数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);

        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);

        // Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance(DES);

        // 用密钥初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

        return cipher.doFinal(data);
    }


    /**
     * Description 根据键值进行解密
     * @param data
     * @param key  加密键byte数组
     * @return
     * @throws Exception
     */
    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
        // 生成一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密钥数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);

        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);

        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance(DES);

        // 用密钥初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

        return cipher.doFinal(data);
    }
}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111

这里采用DES算法进行加密，可以设置自己的加密算法

接下来看看我们如何使用自定义注解和配置过滤字段，在UserController中的两个API我们的变化为

@RequestMapping("/{id}")
    @SerializedField(includes = {"id", "email"}, encode = false)
    public User findUserById(@PathVariable("id")int id){
        return userService.getUserById(id);
    }

    @RequestMapping("/all")
    @SerializedField(excludes = {"id","password"})
    public List<User> findAllUser(){
        return userService.getAllUser();
    }
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

查找单个user对象的api我们配置了应该包含id和email两个字段并不加密，访问http://localhost:8080/user/1得到的结果为

{"id":"1","email":"email1"}
  
  
  • 1

可以看出结果中只有配置的两个字段id和email。

在查找所有user对象api中我们配置了去除id和password两个字段，加密使用默认的配置true，访问http://localhost:8080/user/all得到的结果为

[{"email":"VF+mPHf1EuI="},{"email":"EOJMFSFgsps="},{"email":"f4R+0CfsxMw="},{"email":"Yc9Q0i1HgII="},{"email":"/LByd7J+cF0="},{"email":"sZgJ3ylyxg0="},{"email":"hjYKo1ceg6U="},{"email":"l3TMFt0j+Kw="},{"email":"lkQICJp377U="},{"email":"/eSKhBhKP8w="}]
  
  
  • 1

可以看出返回的数据中只有user的email字段，并且数据已经经过加密

最后来一张整体的文件结构图
这里写图片描述

所有代码均已在文中出现，包括一些注释

源代码地址： git://code.csdn.net/CYXLZZS/sprint-boot-responsebodyadvice.git

原文地址：http://blog.csdn.net/cyxlzzs/article/details/49357197

Scnu_wang
关注
专栏目录
Spring Boot集成ShardingSphere实现数据加密及数据脱敏 | Spring Cloud 48
gmHappy
05-11 1万+
利用ShardingSphere实现： - 数据加密 - 数据脱敏
在SpringBoot项目中，自定义注解+拦截器优雅的实现敏感数据的加解密！
Java知音
04-11 2151
作者：CoderTanzJblog.csdn.net/bbcckkl/article/details/104069487在实际生产项目中，经常需要对如身份证信息、手机号、真实姓名等的敏感数...
springboot实现敏感字段加密存储，解密显示
灰太狼
02-20 3753
springboot实现敏感字段加密存储，解密显示，通过mybatis,自定义注解+AOP切面，Base64加解密方式实现功能。 1.代码实现： 创建springboot项目 添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId&g
Spring Boot 接口加密解密：新姿势
最新发布
java专栏
08-18 934
通过今天的讲解，相信你已经掌握了如何在 Spring Boot 中实现接口加密解密的方法。从选择加密算法到具体实现，再到密钥管理和性能优化，我们一步步探索了接口加密解密的奥秘。加密解密就像是给你的数据穿上了一层保护衣，让别人看不懂里面的内容，即使数据在路上被“偷窥”，也不会泄露你的秘密。本文尽可能详尽地介绍了 Spring Boot 中接口加密解密的基本概念和技术细节，希望能帮助你更好地掌握接口加密解密的使用技巧。别急，咱们一步一步来！密钥管理是加密解密过程中非常重要的一环，我们需要确保密钥的安全性。
springboot过滤字段_Spring Boot使用过滤器Filter过程解析
weixin_39912368的博客
12-22 537
这篇文章主要介绍了Spring Boot使用过滤器Filter过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下首先我们说说什么是过滤器，过滤器是对数据进行过滤，预处理过程，当我们访问网站时，有时候会发布一些敏感信息，发完以后有的会用*替代，还有就是登陆权限控制等，一个资源，没有经过授权，肯定是不能让用户随便访问的，这个时候，也可以用到过滤器...
spring boot 自定义注解过滤返回字段
神秘的凯
04-03 2545
启动类 package com.fuhang.mall; import org.mybatis.spring.annotation.MapperScan; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.cli...
spring boot rest api，控制返回json数据，过滤部分字段
qq_32352777的博客
03-23 5771
前言 spirng boot：2.4.5 fastjson：1.2.7 当我们使用spring boot作为web服务端，接口采用restful api时，需要控制前端请求api的json数据格式，同时也需要控制服务端响应的json数据内容，可能出现以下场景： json中某些属性，请求api和api响应中都需要忽略 json中某些属性，请求api时忽略接收，api响应时需要携带 json中某些属性，请求api时接收，api响应时忽略 json中某些null值的属性，在api响应中忽略 j
mongodb-field-level-encryption:使用Spring Boot 2在MongoDB中设置字段级加密
03-28
通过以上步骤，我们可以在Spring Boot 2应用中实现MongoDB的字段级加密，从而为敏感数据提供额外的保护层。这种加密策略允许我们在不牺牲应用程序功能的情况下，确保关键信息的安全。然而，务必注意，虽然字段级加密...
Spring Boot 中密码加密的两种方法
09-07
Spring Boot 是一个流行的Java开发框架，它简化了创建独立、生产级别的基于Spring的应用程序。在Spring Boot中，处理用户密码的安全性是至关重要的。本文将详细介绍两种密码加密的方法，以帮助开发者更好地理解和...
在Spring Boot中使用Jackson过滤不必要字段
yanhanhui1的博客
07-16 2045
在开发接口的时候，我们通常想要过滤一些字段不返回给前端。 例如前端需要查询一个用户，但是用户User类中通常有密码字段，我们不想返回密码字段给前端，应当怎么办呢？使用Jackson依赖即可完美解决。 不过首先我们需要了解一些基本知识。 1，什么是序列化/反序列化 我们前后端交互的对象都需要使用Serializable接口，表示这个类的实例是可以序列化和反序列化的。 Java的实例一般存在于内存里面，如果想要把这个对象在网络上传输或者是存放到本地，那么必须要使这个对象序列化，也就是说序列化把一个内存
SpringBoot控制器统一的响应体加密与请求体解密的注解处理方式
08-08
SpringBoot控制器统一的响应体加密与请求体解密的注解处理方式，支持MD5/SHA/AES/DES/RSA
spring-boot-basic-auth：使用基本身份验证的安全Spring Boot REST API
02-04
Spring Boot简化了创建独立、生产级别的基于Spring的应用程序，并且Spring Security是Spring生态系统的安全模块，提供了丰富的功能来保护我们的应用程序。 首先，让我们了解什么是基本身份验证。基本身份验证是一种...
参数有空格_使用SpringBoot使用过滤器去除@RequestBody参数两端的空格
weixin_39676633的博客
12-24 699
使用SpringBoot使用过滤器去除@RequestBody参数两端的空格使用SpringBoot使用过滤器去除@RequestBody参数两端的空格；一般我们去普通的请求我们都会对请求参数进行验证。Java也提供了@notNull和@notBlank这种验证方式，但是对@RequestBody 这种只能验证是不是非空，对数据两端的空格未进行处理，同时大家也不想遍历一遍参数然后再处理再...
springboot aop方式实现敏感数据自动加解密
qq_42077317的博客
08-23 826
也就是脱敏，比如像手机号、身份证号等信息。如果我们只是在接口返回后再去做替换处理，则代码会显得非常冗余，那么实际可以通过注解的方式实现数据脱敏。在实际项目开发中，可能会涉及到一些敏感信息，那么我们就需要对这些敏感信息进行加密处理，3.定义一个在字段上，且有值的注解。4.定义一个在字段上，且有值的注解。1.定义一个标记于方法上的注解。2.定义一个数据解密的注解。5.定义用户返回的实体类。6.定义AOP注解实现。8.接着就可以测试了。
spring boot对敏感信息进行加解密
yhj198927的博客
04-18 679
我们使用jasypt最新版本对敏感信息进行加解密。
Spring Boot整合Jasypt 库实现配置文件和数据库字段敏感数据的加解密
傲泣龙腾的博客
06-05 7384
在我们日常开发中，很多时候为了保证数据的安全，在处理敏感数据前后端数据传输数据库敏感数据入库等，数据的加密和解密是不可忽视的重要环节，特别是一些政企项目这点就尤为重要，避免每一次安全审计后反复的调整，所以在系统设计之初我们就应当把数据安全的问题考虑进去！今天博主就给大家详细介绍的功能，并展示如何在项目中实现各种加解密操作Jasypt（Java Simplified Encryption）是一个用于加密和解密数据的Java库。它提供了简单易用的API，可以轻松地将加密功能集成到Java应用程序中。
spring-boot切面来实现敏感字段加解密【转载】
t194978的博客
02-17 1313
可以通过自定义注解和spring-boot切面来实现敏感字段加解密。 用法大致如下： 1、自定义注解 package com.zzz.yyy.annotation; import org.springframework.core.Ordered; import org.sprin...
springboot sqlite
08-19
在使用Spring Boot中连接SQLite数据库时，需要在配置文件中进行相应的配置。首先，需要引入SQLite的依赖项，可以在pom.xml文件中添加以下依赖项： ```xml <!-- sqlite --> <dependency> <groupId>org.xerial</groupId> <artifactId>sqlite-jdbc</artifactId> <version>3.21.0.1</version> </dependency> <!-- mybatis --> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.3.2</version> </dependency> ``` 然后，在配置文件中配置数据库和Mapper.xml文件的路径信息。对于SQLite文件的路径，可以根据不同的场景选择不同的配置方式。其中，相对路径基准目录根据运行环境的不同而有所区别。具体的配置如下： ```properties # SQLite数据库配置 # 一、sqlite文件在resources目录下（仅适合只读的场景，不推荐使用） # 1.在IDEA中运行时，sqlite文件会被复制到target下的相对路径（target/classes/dbs/MySqlite.db），修改数据时，修改的是target下的sqlite文件; # 2.用jar包运行时，sqlite文件会被复制到缓存目录，修改的也是缓存目录下的db文件（在window 10下的缓存路径是C:\Users\${用户名}\AppData\Local\Temp\sqlite-jdbc-tmp-xxxxxxxx.db）。 spring.datasource.url=jdbc:sqlite::resource:dbs/MySqlite.db # 二、sqlite文件为相对路径 # 1.在IDEA中运行时，相对路径基准目录为当前项目的目录（也就是跟src的同级目录）； # 2.用jar包运行时，相对路径基准目录为jar包所在目录。 spring.datasource.url=jdbc:sqlite:dbs/MySqlite.db # 三、sqlite文件为绝对路径 spring.datasource.url=jdbc:sqlite:F:/dbs/MySqlite.db # mapper.xml文件路径 mybatis.mapper-locations=classpath:mappers/*.xml # spring的jdbc可以根据spring.datasource.url的前缀判断driver-class-name，所以spring.datasource.driver-class-name该配置可以不写 spring.datasource.driver-class-name=org.sqlite.JDBC # sqlite默认不支持设置用户名和密码，一般是通过对sqlite文件加密进行数据保护，所以这两个配置先不配置 # spring.datasource.username= # spring.datasource.password= ``` 以上是在Spring Boot中配置连接SQLite数据库的相关信息。具体的配置根据实际情况进行选择，并根据注释中的说明进行相应的修改。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [SpringBoot整合SQLite](https://blog.csdn.net/u014644574/article/details/127677122)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [Spring Boot连接SQLite数据库](https://blog.csdn.net/java_t_t/article/details/125650096)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值