SpringBoot+logback日志打印脱敏，正常获取对象不受影响

转载作者：撒哈拉更新时间：2024-12-10 16:25:15

添加依赖

注意：springboot版本2.7.0 。

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.36</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
        </dependency>

自定义枚举值

/**
 * 脱敏枚举值
 */
public enum SensitiveType {
    DEFAULT,    // 默认规则（部分隐藏）
    PHONE,      // 手机号
    ID_CARD,    // 身份证号
    EMAIL,       // 邮箱
    ADDRESS,     //地址
    USER_NAME,  //用户名
    NUMBER;     //数字，直接全脱敏
}

自定义注解

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

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Sensitive {
    SensitiveType type() default SensitiveType.DEFAULT;
}

重写ClassicConverter

import ch.qos.logback.classic.pattern.ClassicConverter;
import ch.qos.logback.classic.spi.ILoggingEvent;
import com.ybchen.log.Sensitive;
import com.ybchen.log.SensitiveType;
import org.slf4j.helpers.MessageFormatter;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * @description: 敏感日志转换器
 * @author: 陈彦斌
 * @create: 2024-12-09 18:55
 */
public class SensitiveLogConverter extends ClassicConverter {

    @Override
    public String convert(ILoggingEvent event) {
        Object[] args = event.getArgumentArray();
        if (args == null || args.length == 0) {
            return event.getFormattedMessage();
        }
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            if (arg != null) {
                args[i] = desensitize(arg);
            }
        }
        return MessageFormatter.arrayFormat(event.getMessage(), args).getMessage();
    }

    private Object desensitize(Object obj) {
        if (obj == null) {
            return null;
        }
        try {
            Class<?> clazz = obj.getClass();
            // 如果对象是集合类型
            if (obj instanceof List) {
                List<?> list = (List<?>) obj;
                List<Object> newList = new ArrayList<>();
                for (Object item : list) {
                    newList.add(desensitize(item)); // 递归处理列表中的每个对象
                }
                return newList;
            }
            // 如果对象是普通类型，直接返回
            if (isPrimitiveOrWrapper(clazz) || clazz == String.class) {
                return obj;
            }
            // 创建新实例
            Object newObj = clazz.getDeclaredConstructor().newInstance();
            // 遍历字段
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                field.setAccessible(true);
                Object fieldValue = field.get(obj); // 获取原字段值
                if (fieldValue == null){
                    continue;
                }
                if (field.isAnnotationPresent(Sensitive.class)) {
                    // 处理标注为 @Sensitive 的字段
                    if (fieldValue instanceof String) {
                        Sensitive sensitive = field.getAnnotation(Sensitive.class);
                        SensitiveType type = sensitive.type();
                        field.set(newObj, applyDesensitization((String) fieldValue, type));
                    }else if (
                            fieldValue instanceof Integer
                                    || fieldValue instanceof Long
                                    || fieldValue instanceof BigDecimal
                                    || fieldValue instanceof Byte
                                    || fieldValue instanceof Short
                                    || fieldValue instanceof Float
                                    || fieldValue instanceof Double
                    ){
                        //数字直接脱敏
                        field.set(newObj, null);
                    }else if (fieldValue instanceof List) {
                        // 如果字段是 List 类型，递归处理其内部元素
                        List<?> list = (List<?>) fieldValue;
                        List<Object> newList = new ArrayList<>();
                        for (Object item : list) {
                            newList.add(desensitize(item));
                        }
                        field.set(newObj, newList);
                    } else {
                        // 对其他非字符串类型的字段，递归脱敏
                        field.set(newObj, desensitize(fieldValue));
                    }
                } else {
                    // 未标注 @Sensitive 的字段直接复制
                    field.set(newObj, fieldValue);
                }
            }
            return newObj; // 返回脱敏后的新对象
        } catch (Exception e) {
            e.printStackTrace();
            return obj; // 异常情况下返回原对象
        }
    }


    private String applyDesensitization(String value, SensitiveType type) {
        if (value==null || "".equals(value)){
            return "";
        }
        switch (type) {
            case DEFAULT:
                return value.replaceAll("^(.{3}).*$", "$1*****");
            case PHONE:
                if (value.length()<11||value.length()>11){
                    return value.replaceAll("^(.{5}).*$", "$1*****");
                }
                return value.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
            case ID_CARD:
                if (value.length()<18){
                    return value.replaceAll("^(.{5}).*$", "$1*****");
                }
                return value.replaceAll("(\\d{4})\\d{10}(\\d{4})", "$1**********$2");
            case EMAIL:
                if (!value.contains("@")){
                    return value.replaceAll("^(.{5}).*$", "$1*****");
                }
                return value.replaceAll("(?<=^.{3}).*(?=@)", "*****");
            case ADDRESS:
                if (value.length() <= 9) {
                    return value.replaceAll("(.)(.*)(..)", "$1*$2$3");
                }
                return value.replaceAll("(.{3}).*(.{3})", "$1*****$2");
            case USER_NAME:
                return value.replaceAll("(\\S)\\S(\\S*)", "$1*$2");
            default:
                return value;
        }
    }

    private boolean isPrimitiveOrWrapper(Class<?> clazz) {
        return clazz.isPrimitive() || clazz == Boolean.class || clazz == Integer.class ||
                clazz == Long.class || clazz == Double.class || clazz == Float.class ||
                clazz == Byte.class || clazz == Short.class || clazz == BigDecimal.class || clazz == Character.class;
    }
}

logback-spring.xml配置

<configuration>
    <conversionRule conversionWord="sensitive" converterClass="com.ybchen.config.SensitiveLogConverter" />

    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %sensitive{%msg}%n</pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

VO类

@Data
public class UserVO {
    @Sensitive(type = SensitiveType.USER_NAME)
    private String userName;
    @Sensitive(type = SensitiveType.EMAIL)
    private String email;
    @Sensitive(type = SensitiveType.PHONE)
    private String phone;
    @Sensitive(type = SensitiveType.ID_CARD)
    private String idCard;
    @Sensitive(type = SensitiveType.ADDRESS)
    private String address;
    @Sensitive
    private Integer age;
    @Sensitive
    private BigDecimal money;
    @Sensitive
    private String content;
}

打印日志

    @PostMapping("test")
    public Object test(@RequestBody List<UserVO> userList){
        UserVO vo=new UserVO();
        vo.setUserName("张三");
        vo.setAddress("广东省广州市天河区xxxxxx号");
        vo.setAge(18);
        log.info("日志脱敏----info：\r\n{}\r\n{}", userList,vo);
        log.info("\r\n");
        log.error("日志脱敏----error：\r\n{}\r\n{}", userList,vo);
        System.out.println("正常获取脱敏数据 userName："+vo.getUserName());
        System.out.println("正常获取脱敏数据 address："+vo.getAddress());
        return userList;
    }

效果

。

最后此篇关于SpringBoot+logback日志打印脱敏，正常获取对象不受影响的文章就讲到这里了,如果你想了解更多关于SpringBoot+logback日志打印脱敏，正常获取对象不受影响的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐： kubeadm部署k8s

文章推荐： k8s实战4----副本集

文章推荐：禁用SAPHana错误密码锁定用户功能

java - 对象 a = 对象 b；对象 a 会发生什么？
我的一位教授给了我们一些考试练习题，其中一个问题类似于下面(伪代码): a.setColor(blue); b.setColor(red); a = b; b.setColor(purple); b
JavaScript 测试(对象 && 对象 !== "null"&& 对象 !== "undefined")
我似乎经常使用这个测试 if( object && object !== "null" && object !== "undefined" ){ doSomething(); } 在对象上，我
C#对象/对象
C# Object/object 是值类型还是引用类型？我检查过它们可以保留引用，但是这个引用不能用于更改对象。 using System; class MyClass { public s
javascript - 通过ajax发送json - 对象 - 对象
我在通过 AJAX 发送 json 时遇到问题。 var data = [{"name": "Will", "surname": "Smith", "age": "40"},{"name": "Wil
javascript - 如何获取值[对象][对象]
当我尝试访问我的 View 中的对象 {{result}} 时(我从 Express js 服务器发送该对象)，它只显示 [object][object]有谁知道如何获取 JSON 格式的值吗？这是
java - 对象...对象[] 和格式
我有不同类型的数据(可能是字符串、整数......)。这是一个简单的例子: public static void main(String[] args) { before("one"); }
javascript - 如何修复[对象，对象]
嗨，我是 json 和 javascript 的新手。我在这个网站找到了使用json数据作为表格的方法。我很好奇为什么当我尝试使用 json 数据作为表时，我得到 [Object,Object]
JavaScript [对象][对象] 调试
已关闭。此问题需要 debugging details 。目前不接受答案。编辑问题以包含 desired behavior, a specific problem or error, and the
java - 对象==空或空==对象？
我听别人说 null == object 比 object == null check 例如: void m1(Object obj ) { if(null == obj) // Is thi
VBS教程：对象-Match 对象
Match 对象提供了对正则表达式匹配的只读属性的访问。说明 Match 对象只能通过 RegExp 对象的 Execute 方法来创建，该方法实际上返回了 Match 对象的集合。所有的
VBS教程：对象-Class 对象
Class 对象使用 Class 语句创建的对象。提供了对类的各种事件的访问。说明不允许显式地将一个变量声明为 Class 类型。在 VBScript 的上下文中，“类对象”一词指的是用
VBS教程：对象-Folder 对象
Folder 对象提供对文件夹所有属性的访问。说明以下代码举例说明如何获得 Folder 对象并查看它的属性： Function ShowDateCreated(f
VBS教程：对象-File 对象
File 对象提供对文件的所有属性的访问。说明以下代码举例说明如何获得一个 File 对象并查看它的属性： Function ShowDateCreated(fil
VBS教程：对象-Drive 对象
Drive 对象提供对磁盘驱动器或网络共享的属性的访问。说明以下代码举例说明如何使用 Drive 对象访问驱动器的属性： Function ShowFreeSpac
VBS教程：对象-FileSystemObject 对象
FileSystemObject 对象提供对计算机文件系统的访问。说明以下代码举例说明如何使用 FileSystemObject 对象返回一个 TextStream 对象，此对象可以被读
对象
我是 javascript OOP 的新手，我认为这是一个相对基本的问题，但我无法通过搜索网络找到任何帮助。我是否遗漏了什么，或者我只是以错误的方式解决了这个问题？这是我的示例代码: functio
对象
我可以很容易地创造出很多不同的对象。例如像这样: var myObject = { myFunction: function () { return ""; } };
对象
function Person(fname, lname) { this.fname = fname, this.lname = lname, this.getName = function()
javascript - JSON 返回(对象，对象)
任何人都可以向我解释为什么下面的代码给出 (object, Object) 吗？ (console.log(dope) 给出了它应该的内容，但在 JSON.stringify 和 JSON.parse
javascript - 返回 [对象，对象] 的工具提示
我正在尝试完成散点图 exercise来自免费代码营。然而，我现在只自己学习了 d3 几个小时，在遵循 lynda.com 的教程后，我一直在尝试确定如何在工具提示中显示特定数据。 This code

撒哈拉

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城