java：反射封装Slf4j日志工具类

最新推荐文章于 2024-08-13 23:55:51 发布
最新推荐文章于 2024-08-13 23:55:51 发布
阅读量1.4k 收藏 5
点赞数 1
分类专栏： Java 文章标签： java spring 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a232884c/article/details/128434553
版权

java：反射封装Slf4j日志工具类

1 前言

使用Slf4j时，针对日志打印进行工具类封装使用。

依赖如下：

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

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

    <!--  slf4j 日志门面  -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.32</version>
    </dependency>

    <!-- logback日志实现 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.5</version>
    </dependency>

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

    <!--  spring-boot 3.12.0  -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>

</dependencies>

2 使用

Slf4j日志工具类，反射封装：

LogUtils：

package com.xiaoxu.crawler.utils;

import com.xiaoxu.crawler.base.constant.PlaceholderConstant;
import org.apache.commons.lang3.ArrayUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;

import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Date;


/**
 * @author xiaoxu
 * @date 2022-11-21 10:52
 * crawlerJ:com.xiaoxu.crawler.utils.LogUtil
 */
public class LogUtils implements PlaceholderConstant {

    /* log日志时间pattern */
    private static final String logPattern = "yyyy-MM-dd HH:mm:ss.SSS";

    /* 日志方法stack层级 */
    private static final int logStackHierarchy = 6;

    public static <R> void logDetailInfo(Logger logger, String methodName, R requestPayload,
                                 long timeConsuming){
        String msg = logDetailCheck(methodName, timeConsuming);
        info(logger, msg, methodName, requestPayload, timeConsuming);
    }

    public static <R> void logDetailWarn(Logger logger, String methodName, R requestPayload,
                                         long timeConsuming){
        String msg = logDetailCheck(methodName, timeConsuming);
        warn(logger, msg, methodName, requestPayload, timeConsuming);
    }

    public static <R> void logDetailError(Logger logger, String methodName, R requestPayload,
                                         long timeConsuming){
        String msg = logDetailCheck(methodName, timeConsuming);
        error(logger, msg, methodName, requestPayload, timeConsuming);
    }

    private static String logDetailCheck(String methodName, long timeConsuming) {
        AssertUtils.assertTrue(timeConsuming >= 0, "日志耗时参数有误, 请检查");
        AssertUtils.assertNonEmpty(methodName, "日志请求方法参数有误, 请检查");
        return "调用"+squarePrefix+"{}"+squareSuffix+"方法, 请求参数:"+squarePrefix+"{}"+squareSuffix+", 耗时:"+squarePrefix+"{}"+squareSuffix+"ms.";
    }

    public static void info(Logger logger, String formatMsg, Object... objects){
        commLogExecute(logger, formatMsg, objects);
    }

    public static void warn(Logger logger, String formatMsg, Object... objects){
        commLogExecute(logger, formatMsg, objects);
    }

    public static void error(Logger logger, String formatMsg, Object... objects){
        commLogExecute(logger, formatMsg, objects);
    }

    private static void commLogExecute(Logger logger, String formatMsg, Object[] objects) {
        logCheck(logger, formatMsg, objects);
        ReflectExecuteLog(logger, formatMsg, objects);
    }

    private static void ReflectExecuteLog(Logger logger, String formatMsg, Object[] objects) {
        IfElseUtils.executeBothSide(ArrayUtils.isNotEmpty(objects), new IfElseUtils.ActionCallBack() {
            @Override
            public void actionTrue() {
                /* logger.info(buildWrapMessage(formatMsg), objects); */
                Method logMethodByName = getReflectLogMethod("执行actionTrue失败,日志方法未匹配到!{0}");
                try {
                    if(null != logMethodByName){
                        logMethodByName.invoke(logger, buildWrapMessage(formatMsg, logMethodByName.getName()), objects);
                    }
                } catch (IllegalAccessException | InvocationTargetException e) {
                    ExcpUtils.throwExp(MessageFormat.format("反射执行logger方法失败!{0}",e.getMessage()));
                }
            }

            @Override
            public void actionFalse() {
                /* logger.info(buildWrapMessage(formatMsg)); */
                Method logMethodByName = getReflectLogMethod("执行actionFalse失败,日志方法未匹配到!{0}");
                try {
                    if(null != logMethodByName){
                        logMethodByName.invoke(logger,buildWrapMessage(formatMsg, logMethodByName.getName()), null);
                    }
                } catch (IllegalAccessException | InvocationTargetException e) {
                    ExcpUtils.throwExp(MessageFormat.format("反射执行logger方法失败!{0}",e.getMessage()));
                }
            }

            private Method getReflectLogMethod(String msg) {
                Method logMethodByName = LogMethods.getLogMethodByName(Thread.currentThread().getStackTrace()[logStackHierarchy].getMethodName());
                AssertUtils.assertNonNull(logMethodByName, MessageFormat
                        .format(msg,
                                Thread.currentThread().getStackTrace()[logStackHierarchy].getMethodName()));
                return logMethodByName;
            }
        });
    }

    /* 日志方法映射枚举 */
    enum LogMethods implements LogConstant{

        /* 日志方法枚举映射 */
        INFO(LogConstant.INFO,
                handleEnumerationExp(LogConstant.INFO)),
        WARN(LogConstant.WARN,
                handleEnumerationExp(LogConstant.WARN)),
        ERROR(LogConstant.ERROR,
                handleEnumerationExp(LogConstant.ERROR));

        private String logMethodName;
        private Method logMethod;

        LogMethods(String logMethodName, Method logMethod){
            this.logMethodName = logMethodName;
            this.logMethod = logMethod;
            AssertUtils.assertTrue(null != logMethodName && logMethodName.equals(logMethod.getName()), "初始化日志名与日志方法失败!!不匹配.");
        }

        private static Method handleEnumerationExp(String logMethodName){
            Method method = null;
            try {
                method = Logger.class.getMethod(logMethodName, String.class, Object[].class);
            } catch (NoSuchMethodException e) {
                ExcpUtils.throwExp(MessageFormat.format("NoSuchMethod:日志枚举方法初始化异常!!!{0},日志枚举方法名称:{1}.",
                        e.getMessage(), logMethodName));
            } catch (Throwable tx){
                ExcpUtils.throwExp(MessageFormat.format("Throwable:日志枚举方法初始化未知异常!!!{0},日志枚举方法名称:{1}.",
                        tx.getMessage(), logMethodName));
            }
            return method;
        }

        public String getLogMethodName() {
            return logMethodName;
        }

        public void setLogMethodName(String logMethodName) {
            this.logMethodName = logMethodName;
        }

        public Method getLogMethod() {
            return logMethod;
        }

        public void setLogMethod(Method logMethod) {
            this.logMethod = logMethod;
        }

        public static Method getLogMethodByName(String logMethodName){
            if(!StringUtils.hasLength(logMethodName)){
                ExcpUtils.throwExp("请求日志枚举方法getLogMethodByName的logMethodName不能为空");
            }
            for (LogMethods value : LogMethods.values()) {
                if(value.getLogMethodName().equals(logMethodName)){
                    return value.getLogMethod();
                }
            }
            return null;
        }

    }

    interface LogConstant{
        /* 日志级别  */
        String INFO = "info";
        String WARN = "warn";
        String ERROR = "error";
    }

    @SuppressWarnings(value = "all")
    private static String buildWrapMessage(final String msg, final String methodName){
        /* 日志打印补充公共信息 */
        StringBuffer sb = new StringBuffer();
        final String concat = " " + horizontalLineConcat + " ";
        sb.append(squarePrefix);
        sb.append(DateUtils.formatDate(new Date(), logPattern));
        sb.append(concat).append(methodName);
        sb.append(squareSuffix).append(" ");
        sb.append(msg);
        return sb.toString();
    }

    private static void logCheck(Logger logger, String formatMsg, Object... objects){
        AssertUtils.assertNonNull(logger, "log should not be null");
        AssertUtils.assertNonEmpty(formatMsg, "log's format message should not be null or empty");
        if(matchCount(formatMsg, placeholderPrefix, formatMsg, placeholderSuffix)){
            if(StrUtils.getMatchCount(formatMsg, placeholderPrefix) > 0){
                /* slf4j占位符打印日志 */
                AssertUtils.assertTrue(
                        countAndObjLenMatch(StrUtils.getMatchCount(formatMsg, placeholderPrefix), objects),"log's objects should match placeholders.");
            }else{
                AssertUtils.assertTrue(ArrayUtils.isEmpty(objects), "when no placeholders, objects should be null or empty array.");
            }
        }else{
            ExcpUtils.throwExp("please check placeholder's left should match right.");
        }
    }

    private static boolean countAndObjLenMatch(int counts, Object... objects){
        AssertUtils.assertTrue(counts > 0, "countAndObjLenMatch's counts may be wrong.");
        return ArrayUtils.isNotEmpty(objects) && objects.length == counts;
    }

    private static boolean matchCount(final String str1, final String subStr1, final String str2, final String subStr2){
        AssertUtils.assertNonEmpty(str1, "matchCount's str1 should not be null or empty.");
        AssertUtils.assertNonEmpty(str1, "matchCount's subStr1 should not be null or empty.");
        AssertUtils.assertNonEmpty(str1, "matchCount's str2 should not be null or empty.");
        AssertUtils.assertNonEmpty(str1, "matchCount's subStr2 should not be null or empty.");
        return StrUtils.getMatchCount(str1, subStr1) == StrUtils.getMatchCount(str2, subStr2);
    }

    public static void main(String[] args) {
//        info(LoggerFactory.getLogger(LogUtils.class),"今天星期是","1","2");
//        info(LoggerFactory.getLogger(LogUtils.class),"今天星期是{}","1","2");
//        info(LoggerFactory.getLogger(LogUtils.class),"今天星期是{}{","1","2");
        info(LoggerFactory.getLogger(LogUtils.class),"今天星期是{}{}","1","2");
        info(LoggerFactory.getLogger(LogUtils.class),"今天星期是",  new Array[]{});
        warn(LoggerFactory.getLogger(LogUtils.class),"空指针异常!{}",  "please check");
        error(LoggerFactory.getLogger(LogUtils.class),"严重错误!!!{},{}",  "参数:","123");
        logDetailInfo(LoggerFactory.getLogger(LogUtils.class), "getYou", 123,2121);
        logDetailWarn(LoggerFactory.getLogger(LogUtils.class), "getYou", 123,2121);
        logDetailError(LoggerFactory.getLogger(LogUtils.class), "getYou", 123,2121);
        info(LoggerFactory.getLogger(LogUtils.class), "成功！！");
    }

}

PlaceholderConstant：

package com.xiaoxu.crawler.base.constant;

/**
 * @author xiaoxu
 * @date 2022-11-21 12:04
 * crawlerJ:com.xiaoxu.crawler.base.constant.PlaceholderConstant
 */
public interface PlaceholderConstant {

    String placeholderPrefix = "{";

    String placeholderSuffix = "}";

    String squarePrefix = "[";

    String squareSuffix = "]";

    String horizontalLineConcat = "-";

}

DateUtils：

package com.xiaoxu.crawler.utils;

import org.springframework.util.StringUtils;

import java.text.MessageFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;

/**
 * @author xiaoxu
 * @date 2022-11-22 0:00
 * crawlerJ:com.xiaoxu.crawler.utils.DateUtils
 */
public class DateUtils {

    private static final Object lockObj = new Object();

    private static volatile Map<String, ThreadLocal<SimpleDateFormat>> timeLocalMaps = new HashMap<>();


    public static String formatDate(Date date, String pattern){
        AssertUtils.assertNonNull(date, "日期不能为null");
        String format = null;
        try {
            format = getSDF(pattern).format(date);
        } catch (IllegalArgumentException ie) {
            ExcpUtils.throwExp(MessageFormat.format("日期格式化出现无效参数异常!{0}",
                    ie.getMessage()));
        } catch (Throwable th) {
            ExcpUtils.throwExp(MessageFormat.format("日期格式化出现未知异常!{0}",
                    th.getMessage()));
        }
        return format;
    }

    public static Date getDateByStr(String dateStr, String pattern){
        AssertUtils.assertNonEmpty(dateStr, "dateStr should not be null or empty.");
        AssertUtils.assertNonEmpty(pattern, "pattern should not be null or empty.");
        AssertUtils.assertTrue(judgeStrLength(dateStr, pattern), "日期格式或者pattern格式有误!" );
        Date parse = null;
        try {
            parse = getSDF(pattern).parse(dateStr);
        } catch (ParseException th) {
            ExcpUtils.throwExp(MessageFormat.format("日期解析有误!{0}",
                    th.getMessage()));
        } catch (Throwable th) {
            ExcpUtils.throwExp(MessageFormat.format("日期解析未知异常!{0}",
                    th.getMessage()));
        }
        return parse;
    }

    private static boolean judgeStrLength(String str1, String str2){
        if(StringUtils.hasLength(str1) && StringUtils.hasLength(str2)){
            return str1.trim().length() > 0
                    && str1.trim().length() == str2.trim().length();
        }
        return false;
    }

    private static SimpleDateFormat getSDF(String pattern){
        AssertUtils.assertNonEmpty(pattern, "time pattern should not be null or empty.");
        ThreadLocal<SimpleDateFormat> local = timeLocalMaps.get(pattern);
        /* 双重检测锁，为timeLocalMaps增加volatile标识，
         * 禁止指令重排 */
        if(null == local){
            synchronized (lockObj){
                local = timeLocalMaps.get(pattern);
                if(null == local){
                    local = ThreadLocal.withInitial(()->new SimpleDateFormat(pattern));
                    timeLocalMaps.put(pattern, local);
                }
            }
        }
        return local.get();
    }

    private void testDate(){
        long start  = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(100000);
        for (int i = 0; i < 1000; i++) {
            for(int j = 0; j<100; j++) {
                new Thread(() -> {
                    try {
                        // 每个子线程单独创建sdf变量
                        SimpleDateFormat sdf = DateUtils.getSDF("yyyy-MM-dd");
                        Date parse = null;
                        try {
                            parse = sdf.parse("2022-11-10");
                        } catch (Exception e) {
                            System.out.println("错误！！！！");
                            throw new RuntimeException(e);
                        }
                        System.out.println("日期是" + parse);
                    } finally {
                        countDownLatch.countDown();
                    }
                }, "thread-" + j).start();
            }
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        long end = System.currentTimeMillis();
        System.out.println("总耗时:"+(end - start)+"ms");
    }

    public static void main(String[] args) {
        Date dateByStr = getDateByStr("2022-11-20", "yyyy-MM-dd");
        System.out.println(dateByStr);
        String s = formatDate(new Date(), "yyyy-MM-dd HH:mm:ss.SSS");
        System.out.println(s);
        String s1 = formatDate(new Date(), "yyyy-MM-dd HH:mm:ss.fff");
        System.out.println(s1);
    }
}

IfElseUtils：

package com.xiaoxu.crawler.utils;

/**
 * @author xiaoxu
 * @date 2022-11-24 0:51
 * crawlerJ:com.xiaoxu.crawler.utils.IfElseUtils
 */
public class IfElseUtils {

    /* if-else void-template */
    public static void executeBothSide(boolean flag, ActionCallBack callBack){
        if(flag){
            callBack.actionTrue();
        }else{
            callBack.actionFalse();
        }
    }

    /* if-else T-value-template */
    public static <T> T executeBothSideWithValue(boolean flag, ActionCallBackWithValue<T> callBack){
        if(flag){
            return callBack.actionTrue();
        }else{
            return callBack.actionFalse();
        }
    }

    public interface ActionCallBackWithValue<T>{
        /* 为真时 */
        T actionTrue();
        /* 为假时 */
        T actionFalse();
    }

    public interface ActionCallBack{
        /* 为真时 */
        void actionTrue();
        /* 为假时 */
        void actionFalse();
    }
}

ExcpUtils：

package com.xiaoxu.crawler.utils;

import com.xiaoxu.crawler.excp.AccessParamException;
import com.xiaoxu.crawler.excp.CrawlerForJException;
import org.springframework.util.StringUtils;

/**
 * @author xiaoxu
 * @date 2022-11-06 16:04
 * crawlerJ:com.xiaoxu.crawler.utils.ExcpUtils
 */
public class ExcpUtils {

    /* 不为true则抛出异常 */
    public static void throwExpIfFalse(boolean result,String msg){
        if(StringUtils.hasLength(msg)&&!result){
            throw new CrawlerForJException(msg);
        }else if(!StringUtils.hasLength(msg)){
            throw new AccessParamException(
                    String.format(
                            "调用throwExpIfFalse方法的msg不能为空:%s",msg));
        }
    }

    /* 抛出异常的工具方法 */
    public static void throwExp(String message){
        if(StringUtils.hasLength(message)){
            throw new CrawlerForJException(message);
        }else{
            throw new AccessParamException(
                    String.format("方法%s的参数不能为空:%s",
                            ExcpUtils.class.getSimpleName()
                                    +Thread.currentThread().getStackTrace()[1].getMethodName(),
                            message));
        }
    }
}

StrUtils：

package com.xiaoxu.crawler.utils;

import org.springframework.util.StringUtils;

import java.text.MessageFormat;

/**
 * @author xiaoxu
 * @date 2022-11-19 21:52
 * crawlerJ:com.xiaoxu.crawler.utils.StringUtils
 */
public class StrUtils {

    public static boolean equals(String a, String b){
        if(null == a){
            return null == b;
        }
        return a.equals(b);
    }

    public static int getMatchCount(String str, String subStr){
        if(!StringUtils.hasLength(str) || !StringUtils.hasLength(subStr)){
            ExcpUtils.throwExp(
                    MessageFormat.format("getMatchCount's str and subStr should not be null or empty:{0},{1}.",
                            str, subStr));
        }
        return StringUtils.countOccurrencesOf(str, subStr);
    }

}

AssertUtils：

package com.xiaoxu.crawler.utils;

import com.xiaoxu.crawler.excp.CrawlerForJException;
import org.apache.commons.lang3.ArrayUtils;

/**
 * @author xiaoxu
 * @date 2022-11-06 15:50
 * crawlerJ:com.xiaoxu.crawler.utils.AssertUtils
 */
public class AssertUtils {
    /* 校验为真 */
    public static void assertTrue(boolean res, String errorMsg){
        handlerError(res, errorMsg);
    }

    /* 校验非空 */
    public static <T> void assertNonNull(T obj, String errorMsg){
        handlerError(null != obj, errorMsg);
    }

    /* 校验非null非empty字符串 */
    public static <T> void assertNonEmpty(String str, String errorMsg){
        handlerError(null != str && !str.isEmpty(), errorMsg);
    }

    /* 校验非空Array */
    public static <T> void assertNonEmptyArray(T[] array, String errorMsg){
        handlerError(!ArrayUtils.isEmpty(array), errorMsg);
    }

    /* 统一异常处理 */
    private static void handlerError(boolean flag, String message){
        if(!flag){
            /* 使用公共异常处理 */
            throw new CrawlerForJException(message);
        }
    }
}

执行结果如下：

12:46:16.779 [main] INFO com.xiaoxu.crawler.utils.LogUtils - [2022-12-25 12:46:16.744 - info] 今天星期是12
12:46:16.782 [main] INFO com.xiaoxu.crawler.utils.LogUtils - [2022-12-25 12:46:16.782 - info] 今天星期是
12:46:16.782 [main] WARN com.xiaoxu.crawler.utils.LogUtils - [2022-12-25 12:46:16.782 - warn] 空指针异常!please check
12:46:16.782 [main] ERROR com.xiaoxu.crawler.utils.LogUtils - [2022-12-25 12:46:16.782 - error] 严重错误!!!参数:,123
12:46:16.782 [main] INFO com.xiaoxu.crawler.utils.LogUtils - [2022-12-25 12:46:16.782 - info] 调用[getYou]方法, 请求参数:[123], 耗时:[2121]ms.
12:46:16.782 [main] WARN com.xiaoxu.crawler.utils.LogUtils - [2022-12-25 12:46:16.782 - warn] 调用[getYou]方法, 请求参数:[123], 耗时:[2121]ms.
12:46:16.782 [main] ERROR com.xiaoxu.crawler.utils.LogUtils - [2022-12-25 12:46:16.782 - error] 调用[getYou]方法, 请求参数:[123], 耗时:[2121]ms.
12:46:16.782 [main] INFO com.xiaoxu.crawler.utils.LogUtils - [2022-12-25 12:46:16.782 - info] 成功！！
小徐也要努力鸭
关注
专栏目录
28个java常用的工具类.rar
10-12
10. **日志记录**：日志在软件开发中扮演着关键角色，工具类可能包含对日志框架（如Log4j、SLF4J）的封装，简化日志的输出。 11. **对象克隆与序列化**：对象的复制和序列化在某些场景下必不可少，工具类可能提供了...
实现Log4j和Logback的统一日志封装与动态日志级别调整
热门推荐
Mirson - 多一些分享, 多一些进步
10-23 3万+
一、背景 项目中使用日志的地方非常广泛， 如果要做统一的处理，比如调整格式， 增加信息打印， 要修改很多地方，难以维护，所以需要能够将日志做一个统一的封装， 便于扩展使用；同时想做到动态调整日志级别，在生产环境修改日志级别， 将开销降到最低， 在出现故障时， 又可以重新调整日志级别而不需要重新启动服务， 便于问题的排查定位。 二、统一日志的封装 如果实现统一日志， 需要自己封装一层实现，但在实际日志打印中，往往会打印出所封装的类信息， 而并非实际调用的类信息， 该如何解决这个问题？ 网上有很资料， 一般都是
java 日志系统学习
belusoi的博客
04-21 446
java 日志系统学习 一、 日志系统 1.JUL（java util logging）日志封装 JUL、logback、log4j、log4j2 2.JCL (jakarta Commons Logging) 日志接口 slf4j、JCL 二、JUL 学习 JUL 全称 java util Logging 是java 原生的日志框架，使用时不需要引入第三方类库。 2.1 框架介绍 Logger : 记录器，应用程序通过获取Logger对象，调用其API 来发布日志信息。Logger
SLF4j的介绍与使用+SpringBoot日志配置
最新发布
weixin_44823875的博客
08-13 1194
slf4j，simple logging facade for java的缩写，翻译为java的简单日志外观。slf4j(simple logging facade for java)不是一个真正的日志实现，而是一个抽象层（ abstraction layer），也可以理解为一个接口，它是一种适配器的实现方式，它本身不具有输出日志的功能，输出日志还是由log4j、logback等这样的日志组件来进行输出。
Java日志框架（第五章）
至尊充电宝的博客
11-10 312
个人学习Java日志框架备忘笔记
slf4j工具类封装
qq_27731043的博客
12-17 1605
通用日志工具类，对slf4j进行了一层封装。直接用静态方法调用，能准确获取行号和调用类 import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.slf4j.spi.LocationAwareLogger; /** * */ public final class Loggers { private st...
log4j自定义日志等级；数据库缓冲池存储到数据库；数据库和输出到文件终端分离；发送邮件
LANGZI7758521的专栏
11-03 1546
1.继承logj的level类，定义一个自己的日志级别： package com.panda.core.log.impl; import org.apache.log4j.Level; /** * 自定义日志等级 * * Created by Lovell on 03/11/2016. */ /* @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
java高效开发26个工具类
11-27
9. **日志记录**：封装Log4j、SLF4J等日志框架，简化日志打印。 10. **异常处理**：统一异常处理，提供自定义异常类，便于捕获和处理错误。 11. **校验工具**：数据验证，如空值检查、类型检查、格式验证等。 12....
Java实现操作JSON的便捷工具类完整实例【重写Google的Gson】
10-19
此外，内容中还提到了一些与日志记录相关的依赖包，如`slf4j-api-1.6.0.jar`、`slf4j-log4j12-1.6.0.jar`和`log4j-1.2.15.jar`，这些依赖包的引入意味着工具类具备日志记录能力。开发者可以通过这些日志记录库来跟踪...
Java工具类项目，Java-Commons.zip
01-14
11. **日志记录**：日志记录对于调试和问题追踪至关重要，项目可能封装了主流的日志库，如Log4j或SLF4J，提供统一的API。 12. **验证工具**：可能包含输入验证、对象校验等工具，确保数据的正确性和安全性。 13. *...
common:日常工具类
07-06
8. **日志记录**：日志库如`Log4j`或`SLF4J`用于记录程序运行过程中的信息，方便调试和问题定位。 9. **异常处理**：`Exception`类及其子类用于处理程序运行时可能出现的错误。良好的异常处理可以提高代码的健壮性...
封装Logger日志工具类
qq_34589867的博客
03-28 414
但是我们实际写代码的过程中,很可能会忘记加上Sentry上报的逻辑,所以我们需要自己封装一个Logger工具类, 在工具类中增加上报Sentry逻辑, 对比了很多工具类, 大部分工具类是无法打印通过反射调用的方法的实际调用路径, 具体可以在以下代码中的堆栈信息中判断。原文链接: https://blog.csdn.net/qq_40663357/article/details/103498837。
日志工具包
风生的博客
03-25 828
在Java项目中常见的日志工具包:Log4j：Apache推出的日志工具。与2012年5月发布1.2.17版本后停止更新。Logback:属于Log4j的继承者。Spring Boot默认日志文件支持类型。Log4j2：属于Log4j升级版，同时里面还包含了Logback的很多改进。commons-logging:Apache早期基于门面（Facade）设计模式的日志包，提供了日志解构能力，按照顺序寻找当前项目日志接口实现、Log4j、JDK Log、SimpleLog。
log4j配置解释&反射的使用
Java新生代
05-09 884
log4j配置文件详解 反射的使用
SpringBoot-3：集成SLF4J+logback进行日志记录
云深不知处
09-01 2万+
SLF4J+logback进行日志记录1 yml配置文件2 logback.xml常用配置详解2.1 根节点（configuration）2.1.1 读取配置文件：springProperty2.1.2 设置上下文名称：contextName2.1.3 设置变量：property2.2 appender节点2.2.1 控制台输出2.2.1 rollingPolicy2.2.2 filter2.3 ...
log4j日志、反射、枚举、克隆
DeepSea2015的博客
08-11 658
一、log4j 1、导包 1.1、项目中建立一个lib目录 1.2、把jar包复制到lib目录下。 1.3、选中所有的jar包，右键在选择Build Path 》》 add to Build Path 2、建立总配置文件，在src下面建立一个log4j.properties。 3、了解log的5个级别 4、在程序中应用 //通过日志工厂类获得日志对象
封装SLF4J/Log4j，不再处处定义logger变量
weixin_34050389的博客
08-01 649
自从开始使用日志组件后， 每个类都是这样子的结构: publicclassA{ publicstaticfinalLoggerlogger=LoggerFactory.getLogger(A.class); } 这是一件相当烦人事，必须对他进行封装，使得我们能够通过这样的方法来调用： publiccla...
Java中日志的使用
qq_55538458的博客
10-25 2831
Java中日志的使用
为什么要使用SLF4J而不是Log4J
wakeUpJava
12-02 1331
每一个Java程序员都知道日志对于任何一个Java应用程序，尤其是服务端程序是至关重要的，而很多程序员也已经熟悉各种不同的日志库如java.util.logging、Apache log4j、logback。但如果你还不知道SLF4J（Simple logging facade for Java）的话，那么是时候去在你项目中学习使用SLF4J了。 在这篇文章中，我们将学习为什么使用SLF4J
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值