精华内容
下载资源
问答
  • 日志级别
    千次阅读
    2022-03-27 19:04:04

    先介绍一下日志的作用:方便自己与他人查看问题和定位问题

    在python中引入logging标准库即可使用 --- import logging

    一、日志级别

    1、DEBUG 10 调试信息,一些额外的信息

    2、INFO 20 主体功能信息、做了些什么

    3、WARNING 30 警告,下次可能要出错了

    4、ERROR 40 报错,违法的

    5、CRITICAL 50 极其严重的

    日志顺序:DEBUG<INFO<WARNING<ERROR<CRITICAL

    import logging  # 引入

    logging.debug("记录调试信息")

    logging.info("记录功能做了什么")

    logging.warning("记录警告")

    logging.error("记录错误")

    logging.critical("记录致命信息")

    例:下个版本需要用写的方法进行warning警告

    def old_function():

            try:

                    1/0

                    logging.info("代码没有问题")

            except Exception as e:   # 抛出异常

                    logging.error(e)

            logging.waring("这个方法在下一个版本中会废掉,请用新的function")

            return 'hello'

    if __name__ =='__main__':

            print(old_function())

    二、设置等级

    import logging

    # 初始化日志收集器logger,添加一个收集器的名字

    logger = logging.getLogger('log_test')

    # 设置收集器级别

    logger.setLevel('DEBUG')

    # TODO:处理器级别默认是warning,默认是使用控制台输出

    # 放到一个文件中使用FileHandler('文件名')

    handler = logging.FileHandler('log.txt', enconding='utf-8')    # 不加enconding日志有文中会乱码

    # 设置处理器级别

    handler.setLevel('DEBUG')

    # 添加handler

    logger.addHandler(handler)

    # handler设置格式:文件名、行号、logger名  等级 信息 --- 可参考python官网

    fmt = logging.Formatter('%(filename)s-%(lineno)d-%(name)s-%(levelname)s-%(message)s')

    logger.debug('这是debug级别')

    logger.info('hello')

    logger.warning('word!')

    更多相关内容
  • 日志级别

    千次阅读 2018-11-23 13:36:30
    日志一共分成5个等级,从低到高分别是: DEBUG INFO WARNING ERROR CRITICAL 说明: DEBUG:详细的信息,通常只出现在诊断问题上 INFO:确认一切按预期运行 WARNING:一个迹象表明,一些意想不到事情发生了或...

     

    日志一共分成5个等级,从低到高分别是:

    • DEBUG
    • INFO
    • WARNING
    • ERROR
    • CRITICAL

    说明:

    • DEBUG:详细的信息,通常只出现在诊断问题上
    • INFO:确认一切按预期运行
    • WARNING:一个迹象表明,一些意想不到事情发生了或表明一些问题在不久将来列如(磁盘空间低),这个软件还能按预期工作
    • ERROR:更严重的问题,软件没能执行一些功能
    • CRITICAL:一个严重的错误,这表明程序本身可能无法继续运行

    这5个等级,也分别对应5种打日志的方法:debug,info,warning,error,critical,默认的是warning,当在warning或之上时才被跟踪。

    2、日志输出

    有两种方式记录跟踪 ,一种输出控制台,另一种是记录到文件中,如日志文件。

    2.1、将日志输出到控制台

    比如:log1.py如下:

    __author__ = 'Administrator'
    import logging
    
    
    """
    将日志信息向终端打印信息
    """
    logging.basicConfig(level=logging.WARNING,format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    
    logging.debug("这是 logging debug message")
    logging.info("这是 logging info message")
    logging.warning("这是 logging warning messgae")
    logging.error("这是 logging error messgae")
    logging.critical("这是 logging critical message")
    
    

    比如:log2.py如下:

    __author__ = 'Administrator'
    import logging
    
    """
    将日志信息输出到文件
    """
    logging.basicConfig(level=logging.WARNING,
                        filename ="./log.txt",
                        filemode="w",
                        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    
    logging.debug("这是 logging debug message")
    logging.info("这是 logging info message")
    logging.warning("这是 logging warning messgae")
    logging.error("这是 logging error messgae")
    logging.critical("这是 logging critical message")

    比如log.py

    __author__ = 'Administrator'
    import logging
    
    
    
    """
    将日志信息即可是输出到终端也可以输出到文件
    """
    # 第一步 创建一个日志器logger并设置其日志级别为INFO
    logger = logging.getLogger("rxz")
    logger.setLevel(logging.INFO) #log等级总开关
    
    #第二步 创建一个 handler ,用于写入日志文件
    logfile = "./log.txt"
    fh = logging.FileHandler(logfile,mode="a",encoding='utf-8') #用open的打开模式这里可以进行参考
    fh.setLevel(logging.DEBUG) #输出到file的Log等级的开关
    
    #第三步,在创建一个handler,用于输出到控制台
    ch = logging.StreamHandler()
    ch.setLevel(logging.WARNING) #输出到console的Log等级的开关
    
    #第四步,定义handler输出格式
    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    fh.setFormatter(formatter)
    ch.setFormatter(formatter)
    
    #第五步,将logger添加到handler里面
    logger.addHandler(fh)
    logger.addHandler(ch)
    
    # 日志输出
    logger.debug('这是 debug message')
    logger.info('这是 info message')
    logger.warn('这是 warn message')
    logger.error('这是 error message')
    logger.critical('这是 critical message')
    

    三、详解python之配置日志的几种方式

    作为开发者,我们可以通过以下3中方式来配置logging:

    1)使用Python代码显式的创建loggers, handlers和formatters并分别调用它们的配置函数;

    2)创建一个日志配置文件,然后使用fileConfig()函数来读取该文件的内容;

    3)创建一个包含配置信息的dict,然后把它传递个dictConfig()函数;

    需要说明的是,logging.basicConfig()也属于第一种方式,它只是对loggers, handlers和formatters的配置函数进行了封装。另外,第二种配置方式相对于第一种配置方式的优点在于,它将配置信息和代码进行了分离,这一方面降低了日志的维护成本,同时还使得非开发人员也能够去很容易地修改日志配置。

    一、使用Python代码实现日志配置

    __author__ = 'rxz'
    import sys
    import logging
    
    
    # 创建一个日志器logger并设置其日志级别为DEBUG
    logger = logging.getLogger()
    logger.setLevel(logging.DEBUG)
    
    # 创建一个流处理器handler并设置其日志级别为DEBUG
    console_handler = logging.StreamHandler(sys.stdout)
    console_handler.setLevel(logging.DEBUG)
    filename="./log.txt"
    file_handler = logging.FileHandler(filename,mode="a",encoding="utf-8")
    file_handler.setLevel(logging.DEBUG)
    
    # 创建一个格式器formatter并将其添加到处理器handler
    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    console_handler.setFormatter(formatter)
    file_handler.setFormatter(formatter)
    
    # 为日志器logger添加上面创建的处理器handler
    logger.addHandler(console_handler)
    logger.addHandler(file_handler)
    
    #日志输出
    logger.info('info message')
    logger.warn('warn message')
    logger.error('error message')
    logger.critical('critical message')

    二、使用配置文件和fileConfig()函数实现日志配置

    现在我们通过配置文件的方式来实现与上面同样的功能:

    配置文件logging.conf内容如下:

    [loggers]
    keys=root,simpleExample
     
    [handlers]
    keys=fileHandler,consoleHandler
     
    [formatters]
    keys=simpleFormatter
     
    [logger_root]
    level=DEBUG
    handlers=fileHandler
     
    [logger_simpleExample]
    level=DEBUG
    #handlers (选择是终端输出还是文件输出) 运行时把这个注释去掉 
    #或者propagate=1就是终端和文件输出都打开,默认0只打开你选择的哪一端
    #handlers=consoleHandler
    handlers=fileHandler
    qualname=simpleExample
    propagate=0
     
    [handler_consoleHandler]
    class=StreamHandler
    args=(sys.stdout,)
    level=DEBUG
    formatter=simpleFormatter
     
    [handler_fileHandler]
    class=FileHandler
    args=('logging.log', 'a')
    level=DEBUG
    formatter=simpleFormatter
     
    [formatter_simpleFormatter]
    format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
    datefmt=

    主代码:

    __author__ = 'rxz'
    import logging
    import logging.config
    
    
    # 读取日志配置文件内容
    logging.config.fileConfig('logging.conf')
    
    # 创建一个日志器logger
    logger = logging.getLogger('simpleExample')
    
    # 日志输出
    logger.debug('debug message')
    logger.warn('warn message')
    logger.error('error message')
    logger.critical('critical message')
    
    

    1.关于fileConfig()函数的说明:

    该函数实际上是对configparser模块的封装,关于configparser模块的介绍请参考<。

    函数定义:

    该函数定义在loging.config模块下:
              logging.config.fileConfig(fname, defaults=None, disable_existing_loggers=True)

    参数:

    1. fname:表示配置文件的文件名或文件对象
    2. defaults:指定传给ConfigParser的默认值
    3. disable_existing_loggers:这是一个布尔型值,默认值为True(为了向后兼容)表示禁用已经存在的logger,除非它们或者它们的祖先明确的出现在日志配置中;如果值为False则对已存在的loggers保持启动状态。

     

    2. 配置文件格式说明:

    上面提到过,fileConfig()函数是对ConfigParser/configparser模块的封装,也就是说fileConfig()函数是基于ConfigParser/configparser模块来理解日志配置文件的。换句话说,fileConfig()函数所能理解的配置文件基础格式是与ConfigParser/configparser模块一致的,只是在此基础上对文件中包含的sectionoption做了一下规定和限制,比如:

    1)配置文件中一定要包含loggers、handlers、formatters这些section,它们通过keys这个option来指定该配置文件中已经定义好的loggers、handlers和formatters,多个值之间用逗号分隔;另外loggers这个section中的keys一定要包含root这个值;

    2)loggers、handlers、formatters中所指定的日志器、处理器和格式器都需要在下面以单独的section进行定义。seciton的命名规则为[logger_loggerName]、[formatter_formatterName]、[handler_handlerName]

    3)定义logger的section必须指定level和handlers这两个option,level的可取值为DEBUG、INFO、WARNING、ERROR、CRITICAL、NOTSET,其中NOTSET表示所有级别的日志消息都要记录,包括用户定义级别;handlers的值是以逗号分隔的handler名字列表,这里出现的handler必须出现在[handlers]这个section中,并且相应的handler必须在配置文件中有对应的section定义;

    4)对于非root logger来说,除了level和handlers这两个option之外,还需要一些额外的option,其中qualname是必须提供的option,它表示在logger层级中的名字,在应用代码中通过这个名字得到logger;propagate是可选项,其默认是为1,表示消息将会传递给高层次logger的handler,通常我们需要指定其值为0,这个可以看下下面的例子;另外,对于非root logger的level如果设置为NOTSET,系统将会查找高层次的logger来决定此logger的有效level。

    5)定义handler的section中必须指定class和args这两个option,level和formatter为可选option;class表示用于创建handler的类名,args表示传递给class所指定的handler类初始化方法参数,它必须是一个元组(tuple)的形式,即便只有一个参数值也需要是一个元组的形式;level与logger中的level一样,而formatter指定的是该处理器所使用的格式器,这里指定的格式器名称必须出现在formatters这个section中,且在配置文件中必须要有这个formatter的section定义;如果不指定formatter则该handler将会以消息本身作为日志消息进行记录,而不添加额外的时间、日志器名称等信息;

    6)定义formatter的sectioin中的option都是可选的,其中包括format用于指定格式字符串,默认为消息字符串本身;datefmt用于指定asctime的时间格式,默认为'%Y-%m-%d %H:%M:%S';class用于指定格式器类名,默认为logging.Formatter;

    说明:

    配置文件中的class指定类名时,该类名可以是相对于logging模块的相对值,如:FileHandlerhandlers.TimeRotatingFileHandler;也可以是一个绝对路径值,通过普通的import机制来解析,如自定义的handler类mypackage.mymodule.MyHandler,但是mypackage需要在Python可用的导入路径中--sys.path。

    3. 对于propagate属性的说明

    实例1:

    我们把logging.conf中simpleExample这个handler定义中的propagate属性值改为1,或者删除这个option(默认值就是1):

    ?

    1

    2

    3

    4

    5

    [logger_simpleExample]

    level=DEBUG

    handlers=consoleHandler

    qualname=simpleExample

    propagate=1

    现在来执行同样的代码:

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    # 读取日志配置文件内容

    logging.config.fileConfig('logging.conf')

     

    # 创建一个日志器logger

    logger = logging.getLogger('simpleExample')

     

    # 日志输出

    logger.debug('debug message')

    logger.info('info message')

    logger.warn('warn message')

    logger.error('error message')

    logger.critical('critical message')

    我们会发现,除了在控制台有输出信息时候,在logging.log文件中也有内容输出:

    ?

    1

    2

    2017-05-15 16:06:25,366 - simpleExample - ERROR - error message

    2017-05-15 16:06:25,367 - simpleExample - CRITICAL - critical message

    这说明simpleExample这个logger在处理完日志记录后,把日志记录传递给了上级的root logger再次做处理,所有才会有两个地方都有日志记录的输出。通常,我们都需要显示的指定propagate的值为0,防止日志记录向上层logger传递。

    实例2:

    现在,我们试着用一个没有在配置文件中定义的logger名称来获取logger:

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    # 读取日志配置文件内容

    logging.config.fileConfig('logging.conf')

     

    # 用一个没有在配置文件中定义的logger名称来创建一个日志器logger

    logger = logging.getLogger('simpleExample1')

     

    # 日志输出

    logger.debug('debug message')

    logger.info('info message')

    logger.warn('warn message')

    logger.error('error message')

    logger.critical('critical message')

    运行程序后,我们会发现控制台没有任何输出,而logging.log文件中又多了两行输出:

    ?

    1

    2

    2017-05-15 16:13:16,810 - simpleExample1 - ERROR - error message

    2017-05-15 16:13:16,810 - simpleExample1 - CRITICAL - critical message

    这是因为,当一个日志器没有被设置任何处理器是,系统会去查找该日志器的上层日志器上所设置的日志处理器来处理日志记录。simpleExample1在配置文件中没有被定义,因此logging.getLogger(simpleExample1)这行代码这是获取了一个logger实例,并没有给它设置任何处理器,但是它的上级日志器--root logger在配置文件中有定义且设置了一个FileHandler处理器,simpleExample1处理器最终通过这个FileHandler处理器将日志记录输出到logging.log文件中了。

     

     

     

    展开全文
  • 一个简单的例子slf4j实现热加载日志级别
  • Spring Boot动态修改日志级别

    千次阅读 2022-02-20 15:48:53
    运行在生产环境的应用通常将日志设置为INFO级别,需要调整日志级别时可以通过这几种方式实现: 1 修改配置文件,重新打包发布应用; 2 不修改配置文件,重启应用并增加启动参数(--logging.level=debug); 上面...

    运行在生产环境的应用通常将日志设置为INFO级别,需要调整日志级别时可以通过这几种方式实现:

    1 修改配置文件,重新打包发布应用;

    2 不修改配置文件,重启应用并增加启动参数(--logging.level=debug);

    上面两种方式是日常开发调试常用的,都需要重启应用。

    3 通过LoggingSystem对象操作应用日志级别;

    借助Spring Boot的日志系统对象可以实现日志级别动态调整,摘取Spring Boot文档中一段话:

    从最后一句话可以得到Spring Boot的日志配置是通过LoggingSystem这个接口实现的,所以我们可以借助这个接口类修改日志级别。

    3.2 LoggingSystem + 接口;

    @Resource
    private LoggingSystem loggingSystem;
    
    @PostMapping("/updateLoggingLevel")
    public void updateLoggingLevel(String level) {
        loggingSystem.setLogLevel("ROOT", LogLevel.valueOf(level));
    }

    需要修改日志级别时直接使用接口请求实现。

    3.1 LoggingSystem + Nacos 动态配置;

    @Resource
    private LoggingSystem loggingSystem;
    
    @NacosValue(value = "${logging.level.name:org.logging.test}",autoRefreshed = true)
    private String loggerName;
    @NacosValue(value = "${logging.level:info}",autoRefreshed = true)
    private String loggerLevel;
    
    @NacosConfigListener(dataId = "DATA_ID",groupId = "GROUP_ID")
    public void onChangeValue(String value) throws BaseException {
        log.info("received changed value = {}", value);
        LogLevel logLevel = LogLevel.valueOf(loggerLevel.toUpperCase());
        loggingSystem.setLogLevel(loggerName, logLevel);
        log.info("changed {} logging level to:{}", loggerName, loggerLevel);
    }

    增加一个nacos配置监听器,监听日志日别相关的配置值,配置值发生变化时通过LoggingSystem接口更新。

    展开全文
  • SpringBoot不重启修改日志级别【Slf4jj动态日志级别】 前言 需求: 线上日志级别高,而定位问题时需要低级别日志便于分析问题 功能:不重启服务器,提供设置页,手动触发Slf4j 项目日志级别变化 扩展:可将此功能放...

    SpringBoot不重启修改日志级别【Slf4j、Logback动态日志级别】

    前言

    需求: 线上日志级别高,而定位问题时需要低级别日志便于分析问题

    功能:不重启服务器,提供设置页,手动触发Slf4j 项目日志级别变化

    扩展:可将此功能放入后台管理系统中,管理员只需,点选日志级别即可切换服务器的日志级别。

    栗子 Like this:

    在这里插入图片描述
    或者使用命令行

    curl 项目访问地址/sys/log/level/error
    curl 项目访问地址/sys/log/level/warn
    curl 项目访问地址/sys/log/level/info
    curl 项目访问地址/sys/log/level/debug
    curl 项目访问地址/sys/log/level/trace
    

    查看日志状态

    在这里插入图片描述

    懒人如何实现?请copy如下代码 - _ -

    Controller.java

    import ch.qos.logback.classic.Level;
    import ch.qos.logback.classic.Logger;
    import ch.qos.logback.classic.LoggerContext;
    
    import lombok.extern.slf4j.Slf4j;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Arrays;
    import java.util.Objects;
    
    /**
     * @ IDE    :IntelliJ IDEA.
     * @ Date   :2019/11/6  19:40
     * @ Desc   :动态修改系统日志等级。
     */
    @Slf4j
    @RestController
    @RequestMapping("/sys/log/level")
    public class SysLogLevelController {
    
        LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    
        //日志等级常量
        //    final String[] levels = {"ERROR","WARN","INFO","DEBUG","TRACE"};
        final String[] levels = {"OFF","FATAL","ERROR","WARN","INFO","DEBUG","TRACE","ALL"};
    
        /**
         * 修改 根目录 日志级别
         * @param level                 日志级别
         * @return Result               返回结果
         * 栗子:
         *  curl [baseUrl]/sys/log/level/info
         *  curl [baseUrl]/sys/log/level/debug
         */
        @GetMapping("/{level}")
        public Result changeLevel(@PathVariable String level) {
            return Result.getMsgResult(setLogger("root",level));
        }
    
        /**
         * 修改 指定包 日志级别
         * @param level                 日志级别
         * @return Result               返回结果
         * 栗子:
         *  curl [baseUrl]/sys/log/level/info/[包名]
         *  curl [baseUrl]/sys/log/level/debug/[包名]
         */
        @GetMapping("/{level}/{packageName}")
        public Result changeLevel(@PathVariable String level,@PathVariable String packageName) {
            return Result.getMsgResult(setLogger(packageName,level));
        }
    
        /**
         * 测试当前日志等级
         * @param packageName           包名
         * @return Result               返回结果
         * 栗子:
         *  curl [baseUrl]/sys/log/level/test
         *  curl [baseUrl]/sys/log/level/test?packageName=[包名]
         */
        @GetMapping("/test")
        public Result testLevel(String packageName){
            log.trace("trace");
            log.debug("debug");
            log.info("info");
            log.warn("warn");
            log.error("error");
    
            StringBuilder msg = new StringBuilder();
            //全局日志等级 + 项目日志等级 + 具体包的日志等级
            msg.append(getLogger("root"));
            msg.append(getLogger(【SpringBoot启动类】.class.getPackage().getName()));
    
            if (!StringUtils.isEmpty(packageName)){
                msg.append(getLogger(packageName));
            }
            return Result.getMsgResult(msg.toString());
        }
    
    
        //--------------------------------------依赖方法------------------------------
        /**
         * 获取指定包日志级别             封装[设置日志级别+封装返回值信息]
         * @param packageName           包名
         * @return String               日志级别信息
         */
        private String getLogger(String packageName){
            return  packageName + "日志等级为:" + getLevel(packageName);
        }
    
        /**
         * 设置指定包日志级别             封装[日志级别检测+设置日志级别+封装返回值信息]
         * @param packageName           包名
         * @return String               日志级别信息
         */
        private String setLogger(String packageName,String level){
            boolean isAllowed = isAllowed(level);
            if (isAllowed){
                setLevel(packageName,level);
            }
            return isAllowed
                    ? packageName+"日志等级更改为:"+level
                    : packageName+"日志等级修改失败,可用值[ERROR,WARN,INFO,DEBUG,TRACE]";
        }
    
        /**
         * 获取制定包的日志级别
         * @param packageName           包名
         * @return String               日志级别
         */
        private String getLevel(String packageName){
            Logger logger = loggerContext.getLogger(packageName);
    //        ArrayUtil.hasNull(logger,logger.getLevel());//依赖Hutool工具
            return hasNull(logger,logger.getLevel())
                    ? ""
                    : logger.getLevel().toString();
        }
    
        /**
         * 设置制定包的日志级别
         * @param packageName           包名
         * @param level                 日志等级
         */
        private void setLevel(String packageName,String level){
            loggerContext.getLogger(packageName).setLevel(Level.toLevel(level));
        }
    
        /**
         * 判断是否是合法的日志级别
         * @param level                 日志等级
         * @return boolean
         */
        private boolean isAllowed(String level){
            return Arrays.asList(levels).contains(level.toUpperCase());
        }
    
        /**
         * 判断多个对象中是否包含空对象
         * @param objects               多个对象
         * @return String               日志级别
         */
        private boolean hasNull(Object... objects) {
            if (Objects.nonNull(objects)) {
                for (Object element : objects) {
                    if (null == element) {
                        return true;
                    }
                }
            }
            return false;
        }
    }
    

    Result.java是web统一返回数据的类,不是必须要的。也可以自己实现。但是这里也提供一下。

    Result.java

    /**
     * @ IDE    :IntelliJ IDEA.
     * @ Date   :2019/9/27  16:44
     * @ Desc   :web 统一返回工具类
     */
    import java.io.Serializable;
    import java.time.LocalDateTime;
    
    public class Result<T> implements Serializable {
        private static final long serialVersionUID = 1L;
        private Integer code;
        private String msg;
        private  T data;
        private String time;
        public Result(){
            setTime(LocalDateTime.now().toString());
        }
        public Result(Integer code){
            setCode(code).setTime(LocalDateTime.now().toString());
        }
        public Result(Integer code, String msg){
            setCode(code).setMsg(msg).setTime(LocalDateTime.now().toString());
        }
        public Result(Integer code, String msg, T data){
            setCode(code).setMsg(msg).setData(data).setTime(LocalDateTime.now().toString());
        }
        private static final int SUCCESS_CODE = 200;
        private static final int ERROR_CODE = 500;
        private static final String SUCCESS_MSG = "成功";
        private static final String ERROR_MSG = "失败";
        //成功返回值
        public static Result getSuccessResult() {
            return new Result(SUCCESS_CODE,SUCCESS_MSG);
        }
        public static <T> Result<T> getSuccessResult(T data) {
            return new Result<T>(SUCCESS_CODE,SUCCESS_MSG,data);
        }
        //错误返回值
        public static Result getErrorResult() {
            return new Result(ERROR_CODE,ERROR_MSG);
        }
        public static Result getErrorResult(String msg) {
            return new Result(ERROR_CODE,msg);
        }
        //自定义消息
        public static Result getMsgResult(String msg) {
            return new Result(SUCCESS_CODE,msg);
        }
        public static <T> Result<T> getMsgResult(String msg,T data) {
            return getMsgResult(msg).setData(data);
        }
        //自定义返回Code
        public static Result getCodeResult(Integer code,String msg) {
            return new Result(code,msg);
        }
        public static <T> Result<T> getCodeResult(Integer code,String msg,T data) {
            return getCodeResult(code,msg).setData(data);
        }
        public Integer getCode() {
            return code;
        }
        public Result<T> setCode(Integer code) {
            this.code = code;
            return this;
        }
        public String getMsg() {
            return msg;
        }
        public Result<T> setMsg(String msg) {
            this.msg = msg;
            return this;
        }
        public T getData() {
            return data;
        }
        public Result<T> setData(T data) {
            this.data = data;
            return this;
        }
        public String getTime() {
            return time;
        }
        public Result<T> setTime(String time) {
            this.time = time;
            return this;
        }
    }
    
    

    推荐阅读
    一个AOP小专题

    {
    	"author": "大火yzs",
    	"title": "SpringBoot不重启修改日志级别【Slf4jj动态日志级别】",
    	"tag": "动态日志,不重启服务",
    	"createTime": "2020-05-19  12:35"
    }
    
    展开全文
  • SpringBoot日志级别设置

    千次阅读 2022-03-20 18:34:43
    SpringBoot日志级别设置 设置时区: spring.jackson.date-format=yyyy-MM-dd HH:mm:ss spring.jackson.time-zone=GMT+8 启用日志配置信息: logging.level.com.debug.steadyjack=debug 日志配置文件名: log4j....
  • 配置日志级别

    千次阅读 2020-04-16 15:36:02
    默认情况下,spring boot从控制台打印出来的日志级别只有INFO及以上级别,可以配置日志级别 # 设置日志级别 logging.level.root=WARN 这种方式只能将日志打印在控制台上 那要是想把日志不仅要输出到控制...
  • Tomcat 修改控制台输出日志级别

    千次阅读 2022-06-03 12:34:32
    SEVERE (highest value) > WARNING > INFO > CONFIG > FINE > FINER > FINEST (lowest value)修改tomcat日志级别,根据下面路径,打开logging.properties文件 log4j定义了8个级别的log(除去OFF和ALL
  • log4j的日志级别以及配置

    千次阅读 2020-09-02 16:11:40
    TRACEdesignates finer-grained informational events than the DEBUG.Since:1.2.12,很低的日志级别,一般不会使用。 DEBUG指出细粒度信息事件对调试应用程序是非常有帮助的,主要用于开发过程中打印一...
  • Log日志级别

    千次阅读 2020-05-20 16:33:41
    1. 日志级别 日志一共分成5个等级,从低到高分别是: DEBUG INFO WARNING ERROR CRITICAL 说明: DEBUG:详细的信息,通常只出现在诊断问题上 INFO:确认一切按预期运行 WARNING:一个迹象表明,一些意想不到的事情...
  • Kafka Connect不提供一个开箱即用的工具来更改日志级别。在调试连接器或Connect框架时,必须更新log4j。属性文件,并重新启动worker以查看新的日志。在大多数情况下,这是很麻烦的,并且重新启动worker有时会通过...
  • springboot动态调整日志级别

    千次阅读 2021-10-10 21:43:36
    1.springboot使用log4j2 ...2.指定日志配置文件和日志等级(此配置不限于log4j2,也适用于其他日志框架) 在resources目录下加入log4j2的xml配置文件,默认spring-boot会加载classpath下面的名为log4j2.xml,或log4j
  • 通过Nacos实现动态日志级别调整

    千次阅读 2021-06-16 09:47:57
    很多公司在上线项目的时候,都要求代码具备动态调整日志级别的功能。 好处: 1.项目正常运行时调高日志级别提高性能。 2.出现问题时可以调低日志级别快速排错。
  • 修改SpringBoot日志级别

    千次阅读 2021-09-12 16:23:21
    修改SpringBoot日志级别 你会发现日志中只有这些打印信息, debug的日志信息都没有 ,因为springboot默认是显示info级别,我们需要进行手动修改日志级别。 在application.yml 或者 application.properties 配置文件...
  • 一文搞懂Java日志级别,重复记录、丢日志问题

    万次阅读 多人点赞 2020-12-06 21:33:46
    13 | 日志日志记录真没你想象的那么简单 2020-04-07 朱晔 你好,我是朱晔。今天,我和你分享的是,记录日志可能会踩的坑。 一些同学可能要说了,记录日志还不简单,无非是几个常用的API方法,比如debug、info、...
  • Java如何设置Logger日志级别

    千次阅读 2021-03-01 09:04:51
    在此示例中,您将看到我们如何更改或设置Logger日志级别日志级别将告诉您Logger将记录哪个特定的日志消息。Logger如果级别等于或高于级别,则仅记录日志消息Logger。例如,当级别设置Level.SEVERE为时,除以记录的...
  • FreeSWITCH之日志级别

    千次阅读 2022-01-26 16:02:45
    1、控制台设置日志级别 // 从 0-7 级别越大 console loglevell 7 2、sip详细日志 // on开启/off关闭 sofia profile internal siptrace on/off 3、mod_logfile模块 // 模块位置 conf/autoload_configs/logfile...
  • 日志级别详解

    千次阅读 2020-12-18 15:56:01
      表明粗粒度级别,上强调应用程序的运行过程,比如进入某个业务分支。 3. WARN level   表明出现潜在错误。 4. ERROR leve   指出虽然发生错误事件,但不影响系统的继续运行。 5.FATAL level   指出每个严重的...
  • 如何动态改变日志级别

    千次阅读 2020-12-17 08:45:22
    关于日志级别,大部分项目可能都设置为info级别,当然也可能有一些追求性能或者说包含很多敏感信息的项目直接将级别设置为warn或者error;这时候如果项目中出现一些未知异常,需要用到很详细的日志信息,此时如果...
  • clickhouse日志级别

    千次阅读 2021-06-03 09:27:03
    TRACE 很低的日志级别,输出大量日志,不建议使用。 DEBUG 指出细粒度信息事件对调试应用程序是非常有帮助的,主要用于开发过程中打印一些运行信息。 INFO 消息在粗粒度级别上突出强调应用程序的运行过程.
  • 日志级别及实践

    千次阅读 2020-12-13 13:06:11
    日志级别从低到高依次是ALL、TRACE、DEBUG 、INFO、WARN、ERROR 、FATAL 、OFF。等级越低输出的日志信息越详细,也就是说DEBUG级别的输出日志是包含了ERROR级别的输出日志的。 ALL 记录所有日志 TRACE 日志...
  • java log4j日志级别配置详解

    千次阅读 2020-10-21 10:51:28
    1.1在项目的classpath下或者resource包下(maven项目)新建一个log4j.properties文件,初始项目配置如下参数就足够了,更详细配置可继续看1.4 log4j日志级别配置; #通过根日志记录器指定日志级别及输出源 #日志...
  • log4j日志级别配置详解

    千次阅读 2019-04-15 15:05:29
    java log4j日志级别配置详解 1.1 前言 说出来真是丢脸,最近被公司派到客户公司面试外包开发岗位,本来准备了什么redis、rabbitMQ、SSM框架的相关面试题以及自己做过的一些项目回顾,信心满满地去面试,结果别人一...
  • 日志管理(一)-日志级别

    千次阅读 2019-07-22 21:59:43
    日志管理在我们开发中极其的重要,我们可以通过日志来定位问题,也可以来统计所需要的内容。Java中使用比较多日志框架有:log4j,logback。logback是log4j的优化版,由同一个作者开发,在速度和性能上都超过其他的...
  • Spring Boot 2动态修改日志级别

    千次阅读 2019-04-22 10:02:12
    本文基于:Spring Boot 2.1.3,理论支持...将日志级别设低,例如 DEBUG ; 重启应用; 复现问题,观察日志; 如果能动态修改日志级别(无需重启应用,就能立刻刷新),那绝对 如猫添翼 。事实上,从 Spring Boot 1...
  • Springboot nacos实现日志级别动态调整

    千次阅读 2020-08-29 17:54:07
    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录 ...除了以上方式,我们还可以通过日志级别控制日志输出。 一、日志级别 Log4j日志按重要性程度由高到低分位4级...
  • idea 设置日志级别

    千次阅读 2020-06-27 19:14:23
    log4j.appender.console.layout=org.apache.log4j.PatternLayout #设置输出格式 log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n 设置日志级别为ERROR,就会把info隐藏 Log4...
  • java日志级别

    千次阅读 2020-03-03 17:58:18
    java中日志级别有7 个级别:severe、Warning、info、config、fine、finer、finest。默认情况只记录前三个级别。另外可以使用Level.ALL开启所有的级别记录。或者使用Level.OFF关闭所有的级别记录。 log4j中日志级别...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 454,621
精华内容 181,848
关键字:

日志级别

友情链接: FileTransfer.zip