Java对日志文件进行加密

最新推荐文章于 2023-12-21 04:55:12 发布
最新推荐文章于 2023-12-21 04:55:12 发布
阅读量1k 收藏 2
点赞数
分类专栏： Java 文章标签： java logback
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CROSSFIT/article/details/131798945
版权

最近碰到了一个新的需求，生产环境中Java程序部署的服务器会定期清理数据，需要将保存在程序所在服务器上的日志文件挂载到网盘上，但又不想让用户看到日志文件中的信息，因此需要对日志文件中的内容进行加密。
这里，并不是对日志文件中的敏感信息进行加密，而是对所有数据都进行加密。上网查了一圈资料之后，最终到了解决方案：自定义Appender，使用AES进行加密。下面贴出具体代码。
AES加密解密工具类

package com.lg.coding.util;

import java.io.*;
import java.security.Key;
import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESUtil {
    private static final String ALGORITHM = "AES";
    private static int offset = 16;
    private static final String transformation = "AES/CBC/PKCS5Padding";

    /**
     * AES加密字符串
     * @param password  密钥
     * @param value 待加密字符串
     */
    public static String encrypt(String password, String value) {
        try {
            Key key = generateKey(password);
            //创建初始向量iv用于指定密钥偏移量
            IvParameterSpec iv = new IvParameterSpec(password.getBytes(), 0, offset);
            Cipher cipher = Cipher.getInstance(transformation);
            cipher.init(Cipher.ENCRYPT_MODE, key, iv);
            byte[] encryptedByteValue = cipher.doFinal(value.getBytes("utf-8"));
            String encryptedValue64 = Base64.getEncoder().encodeToString(encryptedByteValue);
            return encryptedValue64;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * AES解密字符串
     * @param password  密钥
     * @param value 待解密字符串
     * @return
     */
    public static String decrypt(String password, String value) {
        try {
            Key key = generateKey(password);
            //创建初始向量iv用于指定密钥偏移量
            IvParameterSpec iv = new IvParameterSpec(password.getBytes(), 0, offset);
            Cipher cipher = Cipher.getInstance(transformation);
            cipher.init(Cipher.DECRYPT_MODE, key, iv);
            byte[] decryptedValue64 = Base64.getDecoder().decode(value);
            byte[] decryptedByteValue = cipher.doFinal(decryptedValue64);
            String decryptedValue = new String(decryptedByteValue,"utf-8");
            return decryptedValue;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * AES解密文件
     * @param password 密钥
     * @param inputFilePath 待解密文件路径
     * @param outputFilePath 输出文件路径
     */
    public static void decryptFile(String password, String inputFilePath, String outputFilePath) {
        InputStream inputStream = null;
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            inputStream = new FileInputStream(inputFilePath);
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            bufferedWriter = new BufferedWriter(new FileWriter(outputFilePath));
            String s;
            while ((s = bufferedReader.readLine()) != null) {
                bufferedWriter.write(decrypt(password, s));
                bufferedWriter.newLine();
                bufferedWriter.flush();
            }
        } catch (FileNotFoundException e) {
            System.out.println("找不到指定文件！");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("文件读取错误！");
            e.printStackTrace();
        } finally {
            try {
                inputStream.close();
                bufferedReader.close();
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 生成key
     * @param password
     * @return
     * @throws Exception
     */
    private static Key generateKey(String password) {
        Key key = new SecretKeySpec(password.getBytes(),ALGORITHM);
        return key;
    }
}

在这里，加密操作和解密操作都是针对字符串进行的，在自定义Appender类中，重写subAppend方法，在执行输出文件操作之前对内容进行字符串加密；解密时，逐行读取文件内容后再进行字符串解密。
自定义Appender类

package com.lg.coding.util;

import ch.qos.logback.core.FileAppender;
import ch.qos.logback.core.Layout;
import ch.qos.logback.core.rolling.RollingPolicy;
import ch.qos.logback.core.rolling.RollingPolicyBase;
import ch.qos.logback.core.rolling.RolloverFailure;
import ch.qos.logback.core.rolling.TriggeringPolicy;
import ch.qos.logback.core.rolling.helper.CompressionMode;
import ch.qos.logback.core.rolling.helper.FileNamePattern;
import ch.qos.logback.core.spi.DeferredProcessingAware;
import ch.qos.logback.core.status.ErrorStatus;
import ch.qos.logback.core.util.ContextUtil;
import org.slf4j.event.LoggingEvent;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;

public class CustomRollingFileAppender<E> extends FileAppender<E> {
    File currentlyActiveFile;
    TriggeringPolicy<E> triggeringPolicy;
    RollingPolicy rollingPolicy;
    private static String RFA_NO_TP_URL = "http://logback.qos.ch/codes.html#rfa_no_tp";
    private static String RFA_NO_RP_URL = "http://logback.qos.ch/codes.html#rfa_no_rp";
    private static String COLLISION_URL = "http://logback.qos.ch/codes.html#rfa_collision";
    private static String RFA_LATE_FILE_URL = "http://logback.qos.ch/codes.html#rfa_file_after";

    public CustomRollingFileAppender() {
    }

    public void start() {
        if (this.triggeringPolicy == null) {
            this.addWarn("No TriggeringPolicy was set for the RollingFileAppender named " + this.getName());
            this.addWarn("For more information, please visit " + RFA_NO_TP_URL);
        } else if (!this.triggeringPolicy.isStarted()) {
            this.addWarn("TriggeringPolicy has not started. RollingFileAppender will not start");
        } /*else if (this.checkForCollisionsInPreviousRollingFileAppenders()) {
            this.addError("Collisions detected with FileAppender/RollingAppender instances defined earlier. Aborting.");
            this.addError("For more information, please visit " + COLLISION_WITH_EARLIER_APPENDER_URL);
        }*/ else {
            if (!this.append) {
                this.addWarn("Append mode is mandatory for RollingFileAppender. Defaulting to append=true.");
                this.append = true;
            }

            if (this.rollingPolicy == null) {
                this.addError("No RollingPolicy was set for the RollingFileAppender named " + this.getName());
                this.addError("For more information, please visit " + RFA_NO_RP_URL);
            } /*else if (this.checkForFileAndPatternCollisions()) {
                this.addError("File property collides with fileNamePattern. Aborting.");
                this.addError("For more information, please visit " + COLLISION_URL);
            }*/ else {
                if (this.isPrudent()) {
                    if (this.rawFileProperty() != null) {
                        this.addWarn("Setting \"File\" property to null on account of prudent mode");
                        this.setFile((String)null);
                    }

                    if (this.rollingPolicy.getCompressionMode() != CompressionMode.NONE) {
                        this.addError("Compression is not supported in prudent mode. Aborting");
                        return;
                    }
                }

                this.currentlyActiveFile = new File(this.getFile());
                this.addInfo("Active log file name: " + this.getFile());
                super.start();
            }
        }
    }

    /*private boolean checkForFileAndPatternCollisions() {
        if (this.triggeringPolicy instanceof RollingPolicyBase) {
            RollingPolicyBase base = (RollingPolicyBase)this.triggeringPolicy;
            FileNamePattern fileNamePattern = base.fileNamePattern;
            if (fileNamePattern != null && this.fileName != null) {
                String regex = fileNamePattern.toRegex();
                return this.fileName.matches(regex);
            }
        }

        return false;
    }

    private boolean checkForCollisionsInPreviousRollingFileAppenders() {
        boolean collisionResult = false;
        if (this.triggeringPolicy instanceof RollingPolicyBase) {
            RollingPolicyBase base = (RollingPolicyBase)this.triggeringPolicy;
            FileNamePattern fileNamePattern = base.fileNamePattern;
            boolean collisionsDetected = this.innerCheckForFileNamePatternCollisionInPreviousRFA(fileNamePattern);
            if (collisionsDetected) {
                collisionResult = true;
            }
        }

        return collisionResult;
    }*/

    private boolean innerCheckForFileNamePatternCollisionInPreviousRFA(FileNamePattern fileNamePattern) {
        boolean collisionsDetected = false;
        Map<String, FileNamePattern> map = (Map)this.context.getObject("RFA_FILENAME_PATTERN_COLLISION_MAP");
        if (map == null) {
            return collisionsDetected;
        } else {
            Iterator var4 = map.entrySet().iterator();

            while(var4.hasNext()) {
                Map.Entry<String, FileNamePattern> entry = (Map.Entry)var4.next();
                if (fileNamePattern.equals(entry.getValue())) {
                    this.addErrorForCollision("FileNamePattern", ((FileNamePattern)entry.getValue()).toString(), (String)entry.getKey());
                    collisionsDetected = true;
                }
            }

            if (this.name != null) {
                map.put(this.getName(), fileNamePattern);
            }

            return collisionsDetected;
        }
    }

    public void stop() {
        super.stop();
        if (this.rollingPolicy != null) {
            this.rollingPolicy.stop();
        }

        if (this.triggeringPolicy != null) {
            this.triggeringPolicy.stop();
        }

        Map<String, FileNamePattern> map = ContextUtil.getFilenamePatternCollisionMap(this.context);
        if (map != null && this.getName() != null) {
            map.remove(this.getName());
        }

    }

    public void setFile(String file) {
        if (file != null && (this.triggeringPolicy != null || this.rollingPolicy != null)) {
            this.addError("File property must be set before any triggeringPolicy or rollingPolicy properties");
            this.addError("For more information, please visit " + RFA_LATE_FILE_URL);
        }

        super.setFile(file);
    }

    public String getFile() {
        return this.rollingPolicy.getActiveFileName();
    }

    public void rollover() {
        this.lock.lock();

        try {
            this.closeOutputStream();
            this.attemptRollover();
            this.attemptOpenFile();
        } finally {
            this.lock.unlock();
        }

    }

    private void attemptOpenFile() {
        try {
            this.currentlyActiveFile = new File(this.rollingPolicy.getActiveFileName());
            this.openFile(this.rollingPolicy.getActiveFileName());
        } catch (IOException var2) {
            this.addError("setFile(" + this.fileName + ", false) call failed.", var2);
        }

    }

    private void attemptRollover() {
        try {
            this.rollingPolicy.rollover();
        } catch (RolloverFailure var2) {
            this.addWarn("RolloverFailure occurred. Deferring roll-over.");
            this.append = true;
        }

    }

    protected void subAppend(E event) {
        if (this.isStarted()) {
            try {
                if (event instanceof DeferredProcessingAware) {
                    ((DeferredProcessingAware)event).prepareForDeferredProcessing();
                }
                byte[] byteArray = this.encoder.encode(event);
                //加密前数据
                String originalString = new String(byteArray, "UTF-8");
                //加密后数据
                String encryptedString = AESUtil.encrypt("Sanyuan123456789", originalString);
                this.writeBytes((encryptedString + "\n").getBytes());
            } catch (IOException var3) {
                this.started = false;
                this.addStatus(new ErrorStatus("IO failure in appender", this, var3));
            }

        }
    }

    private void writeBytes(byte[] byteArray) throws IOException {
        if (byteArray != null && byteArray.length != 0) {
            this.lock.lock();

            try {
                this.getOutputStream().write(byteArray);
                if (this.isImmediateFlush()) {
                    this.getOutputStream().flush();
                }
            } finally {
                this.lock.unlock();
            }

        }
    }

    public RollingPolicy getRollingPolicy() {
        return this.rollingPolicy;
    }

    public TriggeringPolicy<E> getTriggeringPolicy() {
        return this.triggeringPolicy;
    }

    public void setRollingPolicy(RollingPolicy policy) {
        this.rollingPolicy = policy;
        if (this.rollingPolicy instanceof TriggeringPolicy) {
            this.triggeringPolicy = (TriggeringPolicy)policy;
        }

    }

    public void setTriggeringPolicy(TriggeringPolicy<E> policy) {
        this.triggeringPolicy = policy;
        if (policy instanceof RollingPolicy) {
            this.rollingPolicy = (RollingPolicy)policy;
        }

    }
}

这里是直接复制RollingFileAppender类的代码，对subAppend方法进行重写，在调用writeBytes()方法之前进行加密操作，将加密后的数据输出到本地。
本系统用的日志框架为SpringBoot内置的日志处理框架Logback。将logback-spring.xml文件中系统日志输出对应的Appender标签，class属性改为自定义Appender类的全路径：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    <springProperty scope="context" name="logDir" source="logging.path"/>
    <!-- 日志存放路径 -->
    <property name="log.path" value="${logDir}" />
    <!-- 日志输出格式 -->
<!--    <property name="log.pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />-->
    <property name="log.pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />

    <!-- 控制台输出 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <charset>utf8</charset>
            <pattern>${log.pattern}</pattern>
        </encoder>
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>${log.pattern}</pattern>
        </layout>
    </appender>

    <!-- 系统日志输出 -->
    <appender name="file_info" class="com.lg.coding.util.CustomRollingFileAppender">
        <file>${log.path}/coding-info.log</file>
        <!-- 循环政策：基于时间创建日志文件 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 日志文件名格式 -->
            <fileNamePattern>${log.path}/coding-info.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <!-- 日志最大的历史 60天 -->
            <maxHistory>60</maxHistory>
            <maxFileSize>10MB</maxFileSize>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
            <charset>utf8</charset>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 过滤的级别 只会打印debug不会有info日志-->
            <!--            <level>DEBUG</level>-->
            <!-- 匹配时的操作：接收（记录） -->
            <onMatch>ACCEPT</onMatch>
            <!-- 不匹配时的操作：拒绝（不记录） -->
            <onMismatch>DENY</onMismatch>
            <level>INFO</level>
        </filter>
    </appender>

    <appender name="file_error" class="com.lg.coding.util.CustomRollingFileAppender">
        <file>${log.path}/coding-error.log</file>
        <!-- 循环政策：基于时间创建日志文件 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志文件名格式 -->
            <fileNamePattern>coding/.%d{yyyy-MM-dd-HH:mm:ss}.gz</fileNamePattern>
            <fileNamePattern>${log.path}/coding-error.%d{yyyy-MM-dd-HH}.log</fileNamePattern>
            <!-- 日志最大的历史 60天 -->
            <maxHistory>60</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
            <charset>utf8</charset>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 过滤的级别 -->
            <level>ERROR</level>
            <!-- 匹配时的操作：接收（记录） -->
            <onMatch>ACCEPT</onMatch>
            <!-- 不匹配时的操作：拒绝（不记录） -->
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <appender name="file_debug" class="com.lg.coding.util.CustomRollingFileAppender">
        <file>${log.path}/coding-debug.log</file>
        <!-- 循环政策：基于时间创建日志文件 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 日志文件名格式 -->
            <fileNamePattern>${log.path}/coding-debug.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <!-- 日志最大的历史 60天 -->
            <maxHistory>60</maxHistory>
            <maxFileSize>10MB</maxFileSize>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
            <charset>utf8</charset>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 过滤的级别 只会打印debug不会有info日志-->
            <!--            <level>DEBUG</level>-->
            <!-- 匹配时的操作：接收（记录） -->
            <onMatch>ACCEPT</onMatch>
            <!-- 不匹配时的操作：拒绝（不记录） -->
            <onMismatch>DENY</onMismatch>
            <level>DEBUG</level>
        </filter>
    </appender>

    <!-- 用户访问日志输出  -->
    <appender name="sys-user" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.path}/sys-user.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 按天回滚 daily -->
            <fileNamePattern>${log.path}/sys-user.%d{yyyy-MM-dd}.log</fileNamePattern>
            <!-- 日志最大的历史 60天 -->
            <maxHistory>60</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
        </encoder>
    </appender>

    <!-- 系统模块日志级别控制  -->
    <logger name="com.example" level="debug" />
    <!-- Spring日志级别控制  -->
    <logger name="org.springframework" level="warn" />

    <root level="info">
        <appender-ref ref="console" />
    </root>

    <!--系统操作日志-->
    <root level="info">
        <appender-ref ref="console" />
        <appender-ref ref="file_info" />
        <appender-ref ref="file_error" />
        <appender-ref ref="file_debug" />
    </root>

    <!--系统用户操作日志-->
    <logger name="sys-user" level="info">
        <appender-ref ref="sys-user"/>
    </logger>
</configuration>

此时，启动项目，查看系统本地日志文件：
在这里插入图片描述
可以看到，日志文件的内容已成功加密。
再写一个文件解密接口：

	@ApiOperation(value = "aes文件解密测试")
    @PostMapping("/aesFileDecrypteTest")
    public void aesFileDecrypteTest(String fileInputPath, String fileOutputPath) {
        String key = "Sanyuan123456789";
        AESUtil.decryptFile(key, fileInputPath, fileOutputPath);
    }

其中，fileInputPath和fileOutputPath两个参数分别为待解密文件所在路径和解密后的文件所在路径，接口调用中输入对应参数：
在这里插入图片描述
调用接口，可以看到，指定路径下生成了一个名为“解密日志.log”的文件， 打开文件，查看内容：
在这里插入图片描述
可以看到，内容已被成功解密。

L一刀G_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
logback打印日志字段脱敏加密
Breaking_xu的博客
09-27 2295
logback自定义转换器，不需要修改原来代码，是在日志打印时对其参数进行加密处理，拓展性强。创建自定义转换类MySampleConverter, 继承MessageConverter类,并实现convert方法。}}让我们来看一下event里面是什么这个时候长得帅的小伙伴们都反应过来了，介不就是格式化后的日志吗！长得不那么帅的小伙伴就会问了，接下来呐！怎么办啊！当然是为所欲为了
java实现文件的加密
qq_42991138的博客
08-17 6597
java实现文件的加密 1. 用输入缓冲字节流读取文件内容到缓冲区内，再用字节数组输出缓冲流写到一个字节数组内 代码块 // 第一步文件的加密 // 先用字节缓冲流读取文件 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(“你要加密的文件全路径”)); ...
接口日志与加密(SpringBoot)
小调寄与❤
11-04 405
在实际开发中，我们可能有如下需求： 记录请求/响应的参数，记录日志； 接口做加密防爬。即前后端约定好加密方式，前端传加密参数，后端获取到密文然后解密，处理完后再加密响应给前端。 一、记录请求/响应的参数 Spring 已经提供好类可以使用：ContentCachingRequestWrapper和ContentCachingResponeWrapper。使用方式如下： @Component @WebFilter(filterName = "ContentCacheFilter", urlPatterns
利用 AES 对 log4j 日志文件加密
WeekDragon
08-13 7898
本文简要介绍了 AES 算法加密的方式，以及如何利用 AES 对 log4j 输出的日志进行加密。
linux服务器日志打印加密怎么办
weixin_55181056的博客
09-29 322
linux服务器日志打印加密怎么办
Java Slf4j日志框架
letterljhx的博客
10-22 475
Java Slf4j日志框架
34.加密&日志&模块安装&包介绍
清风
11-29 553
文章目录1.加密模块1.1加密1.2碰撞理论1.3加盐处理1.4hashlib1.5md方法1.6加密使用1.7分段传入1.8碰撞破密1.9加盐处理2.文件校验2.1检验文件一致性2.2大文件md5校验3.比特流技术概念4.日志模块4.1日志级别4.2详解 1.加密模块 1.1加密 加密:将明文数据通过一系列算法变成密文的数据,以此保证数据的安全性. 在IT互联网没有绝对的安全,只有更加的安全. 涉及到密码存储:存储的是密文,只有用户自己知道明文. 用户输入的明文经过前/后端程序转为密文进行存储. 1.
Java practice 文件加密
yooppa的博客
09-29 132
准备一个文本文件(非二进制)，其中包含ASCII码的字符和中文字符。 加密算法： 数字： 如果不是9的数字，在原来的基础上加1，比如5变成6, 3变成4 如果是9的数字，变成0 字母字符： 如果是非z字符，向右移动一个，比如d变成e, G变成H 如果是z，z->a, Z-A。 字符需要保留大小写 非字母字符 比如’,&^ 保留不变，中文也保留不变 package le; import java.io.File; import java.io.FileReader; import java.io
ClassFinal是一款java class文件安全加密工具
05-23
ClassFinal是一款java class文件安全加密工具，支持直接加密jar包或war包，无需修改任何项目代码，兼容spring-framework；可避免源码泄漏或字节码被反编译
JAVA_API1.6文档（中文）
04-12
java.util.logging 提供 JavaTM 2 平台核心日志工具的类和接口。 java.util.prefs 此包允许应用程序存储并获取用户和系统首选项和配置数据。 java.util.regex 用于匹配字符序列与正则表达式指定模式的类。 java....
java实现文件移动并打印日志
07-03
用java将一个目录内的所有文件移动到另一个目录，默认只移动文件最后修改时间一小时以上的并且名为data_in, data_out,log三个文件夹内的文件，自定义下可移动所有文件，也可以将时间限制修改为0。最后打印操作日志。
LogUtil:Android日志上传使用服务通过HTTP或E-MAIL方式，压缩文件上传，支持加密
03-07
日志文件大小超过设置缓存大小，自动删除最前面一天的日志 自定义上传文件内容 默认崩溃信息，您可以选择自定义的信息 自定义日志保存路径 默认保存在Android / data / com.xxxx.xxxx / log中 支持多种上传方式 目前...
java文件操作之java写文件简单示例
09-04
Java文件操作是Java编程中非常基础且重要的一个部分，它允许开发者将数据持久化到磁盘上，以便后续使用或存储。在这个简单的示例中，我们主要关注的是如何使用Java来读写文件，特别是针对Android环境下的文件操作。...
缺乏对日志数据的加密和保护
ZOMO的博客
12-21 841
在网络安全领域，日志数据是一个重要且敏感的数据类型，它记录了网络连接、请求和响应等关键信息。然而，在实际的网络安全环境中，许多企业或组织并未对他们的日志数据进行有效的保护，这可能会导致严重的数据泄露风险。本文旨在讨论这一问题，并为解决这一问题提供一些建议和方法。
logback自定义日志脱敏规则及脱敏开关（动态控制日志加密方式以及加密开关）
qq_39189120的博客
08-20 864
正则表达式实现日志脱敏。并实现日志脱敏开关，日志脱敏方式。
日志组件slf4j介绍及配置详解
weixin_34292402的博客
05-12 269
1 基本介绍 每一个Java程序员都知道日志对于任何一个Java应用程序，尤其是服务端程序是至关重要的，而很多程序员也已经熟悉各种不同的日志库如java.util.logging、Apache log4j、logback。但如果你还不知道SLF4J（Simple logging facade for Java）的话，那么是时候去在你项...
Log4j2自定义插件实现自定义日志打印功能（脱敏/加密）
一名小码农的博客
08-26 3315
*** log4j1.x重写log4j的PatternLayout，实现日志信息中敏感信息的编码或加密* log4j2.x重写log4j的AbstractStringLayout，实现日志信息中敏感信息的编码或加密*/*** 常用正则表达式：https://cloud.tencent.com/developer/article/1751120* 手机号正则匹配式* 实测雪花算法生成的Id可能会被手机号正则匹配到，故加了关键正则过滤：* (?......
【logback日志掩盖敏感信息】
u012632105的博客
09-24 223
logback日志掩盖敏感信息
迭代器Iterator基本用法--集合遍历
CROSSFIT的博客
08-19 5954
欢迎使用Markdown编辑器写博客 本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I...
java 微服务架构设计文档
最新发布
01-22
Java 微服务架构设计文档是指一份详细描述Java 微服务架构设计方案和规范的文档。该文档主要用于指导开发人员和架构师在设计和实现Java 微服务架构时的相关工作。在文档中通常包括以下内容： 1. 微服务架构概述：介绍微服务架构的概念、原则和优势，以及适用场景和不适用场景。 2. 技术选型：包括Java 微服务框架、数据库、消息队列、缓存、日志、监控等相关技术的选型和使用原则。 3. 微服务拆分和设计：根据业务模块进行微服务拆分和设计，包括服务边界的划分、服务接口的设计、服务之间的通信机制、数据一致性等。 4. 安全和权限设计：包括微服务间的安全通信、用户认证和授权，以及敏感数据的加密和存储。 5. 高可用和容错设计：包括微服务的部署模式、负载均衡、容错机制、故障转移和恢复机制。 6. 性能和扩展设计：包括服务调用的性能优化、并发控制、扩展性设计和性能监控。 7. 日志和监控设计：包括微服务的日志收集、分析和存储，以及微服务的监控和告警机制。 8. 部署和运维：包括微服务的部署流程、自动化部署、持续集成和持续交付，以及运维和故障排查流程。 总之，Java 微服务架构设计文档是一份包括架构设计、技术选型、安全设计、性能设计、日志监控等方方面面内容的指导性文档，能够帮助开发团队高效、规范地完成Java 微服务架构的设计和实施工作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值