LOG 日志级别，标签输出， 根据标签控制输出日志级别 ， 自定义printf输出

最新推荐文章于 2022-11-02 16:22:36 发布
最新推荐文章于 2022-11-02 16:22:36 发布
阅读量1.4k 收藏 5
点赞数 1
分类专栏： 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kyzb002/article/details/101320225
版权

功能：

1. 错误，警告， 信息，调试，四个等级输出， 四种颜色区别。 建议使用putty调试

2.标签独立划分等级， 每个标签可单独定义输出等级，控制输出、不输出

3.十进制/十六进制数组输出

4.自定义printf ， 标准C库printf输出， 宏切换。

输出效果：

函数说明：

//tag为输出标签， 必须为静态字符或全局字符
//level 为对应标签输出等级
LOG_ADD(tag, level)
LOGE(tag, format, ...)    //输出错误日志， 红色
LOGW(tag, format, ...)    //输出警告日志，绿色
LOGI(tag, format, ...)    //输出信息日志，黄色
LOGD(tag, format, ...)    //输出调试日志，白色

//示例
LOG_ADD(TAG, _LOG_DEBUG);

LOGE(TAG, "put string, %s\n", "hello world");
LOGW(TAG, "put string, %s\n", "hello world");
LOGI(TAG, "put string, %s\n", "hello world");
LOGD(TAG, "put string, %s\n", "hello world");

//十六进制输出数组，默认为答谢
//level ，输出等级
//tag 标签
//title 描述
//buffer ， 数组指针
//size 长度
LOG_ARRY_HEX(level, tag, tltle, buffer, size)

//十进制输出数组
LOG_ARRY_DEC(level, tag, tltle, buffer, size)
//示例
LOG_ARRY_HEX(_LOG_DEBUG, TAG, "test buffer", buffer, sizeof(buffer));
LOG_ARRY_DEC(_LOG_DEBUG, TAG, "test buffer", buffer, sizeof(buffer));

 

源码， log.c

#include "log.h"
#include <stdarg.h>

stp_tag_level_t *tag_level = NULL;

static const char log_color[][15] =
	{
		{0},
		{"\033[0;31mE "},
		{"\033[0;32mW "},
		{"\033[0;33mI "},
		{"\033[0;37mD "},
		{0},
};

static const char log_binary[][6] =
	{
		{0},
		{"[DEC]"},
		{"[HEX]"},
		{0},
};

#if (USE_PRINTF == 0)
static const char log_str_cap_num[17] = "0123456789ABCDEF";
static const char log_str_sml_num[17] = "0123456789abcdef";

void stp_put_num(const char *str_num, unsigned long num, int base)
{
	if (num == 0)
	{
		return;
	}
	stp_put_num(str_num, num / base, base);
	putchar(str_num[num % base]);
}

void stp_put_dec(int dec)
{
	if (dec < 0)
	{
		putchar('-');
		dec = abs(dec);
	}

	if (dec == 0)
	{
		putchar('0');
		return;
	}
	else
	{
		stp_put_num(log_str_sml_num, dec, 10);
	}
}

void stp_put_oct(unsigned oct)
{
	if (oct == 0)
	{
		putchar('0');
		return;
	}
	else
	{
		stp_put_num(log_str_sml_num, oct, 8);
	}
}

void stp_put_hex(unsigned hex, char iscap)
{
	if (hex == 0)
	{
		putchar('0');
		return;
	}
	else
	{
		if (iscap)
		{
			stp_put_num(log_str_cap_num, hex, 16);
		}
		else
		{
			stp_put_num(log_str_sml_num, hex, 16);
		}
	}
}

void stp_put_addr(unsigned long addr)
{
	putchar('0');
	putchar('x');
	stp_put_num(log_str_cap_num, addr, 16);
}

void stp_put_str(char *str)
{
	int i = 0;

	while (str[i] != '\0')
	{
		putchar(str[i++]);
	}
}

void stp_put_float(double f)
{
	int temp;

	temp = (int)f;
	stp_put_num(log_str_sml_num, temp, 10);
	putchar('.');

	f -= temp;
	if (f == 0)
	{
		for (temp = 0; temp < 6; temp++)
		{
			putchar('0');
		}
		return;
	}
	else
	{
		temp = (int)(f * 1000000);
		stp_put_num(log_str_sml_num, temp, 10);
	}
}

void stp_log_print(const char *s, ...)
{
	int i = 0;
	va_list va_ptr;

	va_start(va_ptr, s);
	while (s[i] != '\0')
	{
		if (s[i] != '%')
		{
			putchar(s[i++]);
			continue;
		}

		switch (s[++i])
		{
		case 'd':
			stp_put_dec(va_arg(va_ptr, int));
			break;
		case 'o':
			stp_put_oct(va_arg(va_ptr, unsigned int));
			break;
		case 'x':
			stp_put_hex(va_arg(va_ptr, unsigned int), false);
			break;
		case 'X':
			stp_put_hex(va_arg(va_ptr, unsigned int), true);
			break;
		case 'c':
			putchar(va_arg(va_ptr, int));
			break;
		case 'p':
			stp_put_addr(va_arg(va_ptr, unsigned long));
			break;
		case 'f':
			stp_put_float(va_arg(va_ptr, double));
			break;
		case 's':
			stp_put_str(va_arg(va_ptr, char *));
			break;
		default:
			break;
		}
		i++;
	}
	va_end(va_ptr);
}
#endif

/*
 * Tag must be a static string
 */
uint8_t stp_log_add_tag(char *tag, uint8_t level)
{
	stp_tag_level_t *priv;
	stp_tag_level_t *this;

	if (level >= _LOG_MAX)
	{
		return false;
	}

	this = malloc(sizeof(stp_tag_level_t));
	if (this != NULL)
	{
		this->tag = tag;
		this->level = level;
		this->next = NULL;
		if (tag_level == NULL)
		{
			tag_level = this;
		}
		else
		{
			priv = tag_level;
			while (priv->next != NULL)
			{
				priv = priv->next;
			}
			priv->next = this;
		}
	}
	else
	{
		return false;
	}

	return (true);
}

stp_tag_level_t *stp_log_find_tag(const char *tag)
{
	stp_tag_level_t *priv = tag_level;

	while (priv != NULL)
	{
		if ((strlen(priv->tag) == strlen(tag)) && (strncmp(priv->tag, tag, strlen(tag)) == 0))
		{
			return priv;
		}
		priv = priv->next;
	}

	return NULL;
}

int stp_log_write_str(const char *s, int len)
{
	int ret = 0;

	while (ret != EOF && len--)
	{
		ret = putchar(*s++);
	}

	return ret;
}

/*
 * log printf
 */
#if USE_PRINTF
uint8_t stp_log_write(stp_log_level_t level, const char *tag, const char *format, ...)
{
	char *log_buf;
	stp_tag_level_t *info_tag = NULL;

	int ret;
	va_list arg;

	info_tag = stp_log_find_tag(tag);
	if ((info_tag == NULL) || (info_tag->level < level))
	{
		return false;
	}

	if (level >= _LOG_MAX)
	{
		return false;
	}
	stp_log_write_str(log_color[level], strlen(log_color[level]));

	stp_log_write_str(tag, strlen(tag));
	stp_log_write_str(" : ", strlen(" : "));

	/* compute the length of the formatted message */
	va_start(arg, format);
	ret = vsnprintf(NULL, 0, format, arg);
	va_end(arg);

	/* allocated an array for the formatted message */
	if (ret < 0 || (log_buf = malloc(ret + 1)) == NULL)
	{
		stp_log_write_str(LOG_COLOR_END, strlen(LOG_COLOR_END));
		return -1;
	}
	/* construct the formatted message */
	va_start(arg, format);
	ret = vsnprintf(log_buf, ret + 1, format, arg);
	va_end(arg);

	ret = stp_log_write_str(log_buf, ret);

	stp_log_write_str(LOG_COLOR_END, strlen(LOG_COLOR_END));

	free(log_buf);
	return true;
}



uint8_t stp_log_write_arry(stp_log_level_t level, char *tag, char *tltle, uint8_t *buffer, int size, stp_log_binary_t binary)
{
	stp_tag_level_t *info_tag = NULL;
	char *log_buf = NULL;
	int len = 0, ret = 0, malloc_size = 0;

	info_tag = stp_log_find_tag(tag);
	if ((info_tag == NULL) || (info_tag->level < level))
	{
		return false;
	}
	if ((level >= _LOG_MAX) || (binary >= _LOG_BINARY_MAX))
	{
		return false;
	}

	malloc_size = strlen(log_color[level]) + strlen(tag) + strlen(" : ") + strlen(tltle);
	malloc_size += snprintf(NULL, 0, "[%d]", size);
	malloc_size += 1;		 // ‘=’ size
	malloc_size += size * 4; //buffer size
	malloc_size += strlen(LOG_COLOR_END);
	malloc_size += 1; //end
	log_buf = malloc(malloc_size);

	ret = snprintf(log_buf, malloc_size + 1, "%s%s : %s%s[%d]=", log_color[level], tag, tltle, log_binary[binary], size);
	if (ret < 0)
	{
		goto log_arry_err;
	}
	while (size--)
	{
		len += ret;
		if (binary == _LOG_BINARY_HEX)
		{
			ret = snprintf(log_buf + len, 4, "%02X ", *buffer++);
 			if (ret < 0)
			{
				goto log_arry_err;
			}
		}
		else if (binary == _LOG_BINARY_DEC)
		{
			ret = snprintf(log_buf + len, 4, "%02d ", *buffer++);
			if (ret < 0)
			{
				goto log_arry_err;
			}
		}
	}
	ret = snprintf(log_buf + len, 15, "%s\n", LOG_COLOR_END);
	if (ret < 0)
	{
		return false;
	}
	len += ret;
	stp_log_write_str(log_buf, len);

	free(log_buf);
	return true;

log_arry_err:
	free(log_buf);
	return false;
}

#else

uint8_t stp_log_write(stp_log_level_t level, const char *tag)
{
	stp_tag_level_t *info_tag = NULL;

	info_tag = stp_log_find_tag(tag);
	if ((info_tag == NULL) || (info_tag->level < level))
	{
		return false;
	}
	if (level >= _LOG_MAX)
	{
		return false;
	}

	stp_log_write_str(log_color[level], strlen(log_color[level]));
	stp_log_write_str(tag, strlen(tag));
	stp_log_write_str(" : ", strlen(" : "));

	return true;
}

uint8_t stp_log_write_arry(stp_log_level_t level, char *tag, char *tltle, uint8_t *buffer, int size, stp_log_binary_t binary)
{
	stp_tag_level_t *info_tag = NULL;

	info_tag = stp_log_find_tag(tag);
	if ((info_tag == NULL) || (info_tag->level < level))
	{
		return false;
	}
	if ((level >= _LOG_MAX) || (binary >= _LOG_BINARY_MAX))
	{
		return false;
	}

	stp_log_write_str(log_color[level], strlen(log_color[level]));
	stp_log_write_str(tag, strlen(tag));
	stp_log_write_str(" : ", strlen(" : "));
	stp_log_write_str(tltle, strlen(tltle));
	stp_log_write_str(log_binary[binary], strlen(log_binary[binary]));
	putchar('[');
	stp_put_dec(size);
	putchar(']');
	putchar('=');
	while (size--)
	{
		if (binary == _LOG_BINARY_HEX)
		{
			stp_put_hex(*buffer++, true);
		}
		else if (binary == _LOG_BINARY_DEC)
		{
			stp_put_dec(*buffer++);
		}
		putchar(' ');
	}
	stp_log_write_str(LOG_COLOR_END, strlen(LOG_COLOR_END));
	putchar('\n');

	return true;
}
#endif

 

log.h

#ifndef __LOG_H__
#define __LOG_H__

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>

/*
*Whether to use the standard C language library, 0 is not used, 1 is used
*/
#define USE_PRINTF (0)

typedef enum
{
	_LOG_NONE = 0,
	_LOG_ERROR,	
	_LOG_WARN,	 
	_LOG_INFO,	 
	_LOG_DEBUG,	
	_LOG_MAX
} stp_log_level_t;

typedef enum
{
	_LOG_BINARY_NONE = 0,
	_LOG_BINARY_DEC,
	_LOG_BINARY_HEX,
	_LOG_BINARY_MAX
} stp_log_binary_t;

typedef struct
{
	char *tag;
	uint8_t level;
	void *next;
} stp_tag_level_t;

#define LOG_COLOR_HEAD "\033[0;%dm"
#define LOG_COLOR_E "\033[0;31m"
#define LOG_COLOR_W "\033[0;32m"
#define LOG_COLOR_I "\033[0;33m"
#define LOG_COLOR_D "\033[0;37m"
#define LOG_COLOR_END "\033[0;39m"

uint8_t stp_log_add_tag(char *tag, uint8_t level);
uint8_t stp_log_write_arry(stp_log_level_t level, char *tag, char *tltle, uint8_t *buffer, int size, stp_log_binary_t binary);

#define LOG_ADD(tag, level) stp_log_add_tag(tag, level)

#if USE_PRINTF
uint8_t stp_log_write(stp_log_level_t level, const char *tag, const char *fmt, ...);

#define LOGE(tag, format, ...) stp_log_write(_LOG_ERROR, tag, format, ##__VA_ARGS__)
#define LOGW(tag, format, ...) stp_log_write(_LOG_WARN, tag, format, ##__VA_ARGS__)
#define LOGI(tag, format, ...) stp_log_write(_LOG_INFO, tag, format, ##__VA_ARGS__)
#define LOGD(tag, format, ...) stp_log_write(_LOG_DEBUG, tag, format, ##__VA_ARGS__)
#else

uint8_t stp_log_write(stp_log_level_t level, const char *tag);
int stp_log_write_str(const char *s, int len);
void stp_log_print(const char *s, ...);
#define LOGE(tag, format, ...)                                   \
	do                                                           \
	{                                                            \
		if (stp_log_write(_LOG_ERROR, tag) == false)             \
		{                                                        \
			break;                                               \
		}                                                        \
		stp_log_print(format, ##__VA_ARGS__);                    \
		stp_log_write_str(LOG_COLOR_END, strlen(LOG_COLOR_END)); \
	} while (0)
#define LOGW(tag, format, ...)                                   \
	do                                                           \
	{                                                            \
		if (stp_log_write(_LOG_WARN, tag) == false)              \
		{                                                        \
			break;                                               \
		}                                                        \
		stp_log_print(format, ##__VA_ARGS__);                    \
		stp_log_write_str(LOG_COLOR_END, strlen(LOG_COLOR_END)); \
	} while (0)
#define LOGI(tag, format, ...)                                   \
	do                                                           \
	{                                                            \
		if (stp_log_write(_LOG_INFO, tag) == false)              \
		{                                                        \
			break;                                               \
		}                                                        \
		stp_log_print(format, ##__VA_ARGS__);                    \
		stp_log_write_str(LOG_COLOR_END, strlen(LOG_COLOR_END)); \
	} while (0)
#define LOGD(tag, format, ...)                                   \
	do                                                           \
	{                                                            \
		if (stp_log_write(_LOG_DEBUG, tag) == false)             \
		{                                                        \
			break;                                               \
		}                                                        \
		stp_log_print(format, ##__VA_ARGS__);                    \
		stp_log_write_str(LOG_COLOR_END, strlen(LOG_COLOR_END)); \
	} while (0)
#endif

#define LOG_ARRY_HEX(level, tag, tltle, buffer, size)                         \
	do                                                                        \
	{                                                                         \
		stp_log_write_arry(level, tag, tltle, buffer, size, _LOG_BINARY_HEX); \
	} while (0)

#define LOG_ARRY_DEC(level, tag, tltle, buffer, size)                         \
	do                                                                        \
	{                                                                         \
		stp_log_write_arry(level, tag, tltle, buffer, size, _LOG_BINARY_DEC); \
	} while (0)

#endif /*end of file*/

 

工程文件，Github: https://github.com/KarmaStone/stp_coms.git

 

后续此工程文件会陆续添加其他功能， 比如：基于Freertos的 串口命令（类似shell） ， MQTT , protocol buffer， http  , mebdTLS(AES, RSA ,MD5, BASE64) , simcom800 , w5500 , BC28 等

 

下片：  基于串口的调试 ， 串口命令解析cmd   类似uboot命令输入

KarmaStone
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Logcat五种级别日志
tectrol的专栏
12-01 1万+
Android 的调试信息分为五类： VERBOSE 类型调试信息，verbose啰嗦的意思 DEBUG 类型调试信息, debug调试信息 INFO 类型调试信息, 一般提示性的消息information WARN 类型调试信息，warning警告类型信息 ERROR 类型调试信息，错误信息 Android Log提供添加以上调试信息
Log4j按级别输出日志到不同文件的实现方法
09-01
下面小编就为大家带来一篇Log4j按级别输出日志到不同文件的实现方法。
IDEA里versionControl中(GIT工具)的log中的不同颜色是什么意思啊？
Ssssongsmith 天璇星
06-21 8624
每个标签代表不同的分支，不同分支标签颜色也可能相同的 黄色代表HEAD, 绿色表示的是你本地分支, 紫色是远程分支, 如果你看到一个标志是黄绿蓝, 表示当前HEAD和你远程还有你本地,都有这个分支.黄色只是表示HEAD的位置,没其它含意 如果你看到一个提交只有紫色分支,表示你本地没有这个分支. 如果你看到一个是紫色和绿色,表示这个提交是远程分支并且你本地也有这个分支.如果你看到一个提交只有绿...
Linux内核日志级别(loglevel)详解_printk函数的用法
a1809032425的博客
11-02 4854
linux日志
Logback自定义日志颜色
MrXionGe的博客
09-09 1万+
熟悉Spring Boot的同学应该都比较喜欢他默认的日志配色风格 在平时的开发中，我们也可以通过logback的配置来自定义日志的颜色 本次主要演示如何自定义不同日志等级的配色 留意：IDEA控制台和Linux控制台能够显示配色，Windows下PowerShell不支持该配色，Eclipse控制台未测试 自定义配置类 LogbackColorful.java impor...
printf()、printk()、消息级别、日志级别
lyndon
02-23 1万+
文章目录1. printf() 与 printk()2. printk() 的消息级别3. 控制台的日志级别(console_loglevel)4. /proc/sys/kernel/printk 1. printf() 与 printk() 用户空间有 printf()，内核空间有 printk()，他们就如代表善与恶得命运双生子，即使长相功能如何的接近，都不能在代码中共存。 对于我们来说，最容易犯的错误是，在需要 printk() 的地方误用了 printf()，而在需要 printf() 的地方又误用
C语言--使用技巧（二）日志分水平等级打印
似水流年
05-19 2871
debug.h #ifndef _DEBUG_H_ #define _DEBUG_H_ #include &quot;stdio.h&quot; // 定义log打印水平 #ifndef _LOGLEVEL_ #define _LOGLEVEL_ 3 #endif #define LOGERROR(x) if(_LOGLEVEL_&amp;gt;0) { printf(&quot;[WiFiDEV] &quot;); printf...
#define定义 printf实现log的打印`
qq_38901733的博客
09-22 1983
#define定义 printf实现log的打印 /* 如果需要打印调试信息 #define DEBUG_LOG_EN x 0/关闭所有调试信息 1/只打开最高级 2/打开高和中级 ...
Android中printf和LOGE区别
newtonnl的专栏
08-16 1万+
调试蓝牙驱动中，作为hci_qcomm_init由调用后，主文件bthci_qcomm_linux.cpp不能输出其中的printf语句，换为LOGE后可以输出。 分析可能： Printf属于linux应用的打印机制，在androd系统当中没有对应的输出机制，只有在终端下执行时才能回显出来。 LOGE属于android专门定义的机制Android logger，专门打印除kernel外的所有
巧用可变参数宏、编译器内置宏和printf输出调试信息
热门推荐
大道至简，持之以恒
06-15 1万+
前言：我们在写程序的时候，总是或多或少会加入一些printf之类的语句用于输出调试信息，但是printf语句有个很不方便的地方就是当我们需要发布程序的时候要一条一条的把这些语句删除，而一旦需要再次调试的时候，这些语句又不得不一条条的加上，这给我们带来了很大的不便，浪费了我们很多的时间，也造成了调试的效率低下。所以，很多人会选择使用宏定义的方式来输出调试语句。比如，定义一个宏开关：#define _
超实用的android自定义log日志输出工具类
08-26
主要为大家详细介绍了一个超实用的android自定义log日志输出工具类，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
日志输出库spdlog
12-29
日志输出库spdlog
shell脚本实现分日志级别输出的方法
01-10
①设定日志级别，实现可以输出不同级别的日志信息，方便调试 ②日志格式类似为：[日志级别] 时间 funcname:函数名 [lineno:行号] 日志信息 ③不同级别，设定不同颜色 ④让其变为函数库文件，重用代码 下面看看我...
单片机 串口控制台 ，类似shell cmd命令解析实现
kyzb002的专栏
09-26 2985
基于串口的 调试方法 ， 调试非常方便 功能： 1. 串口调试输入 2.命令解析， 空格区分参数 3.支持del 使用方法 一、如果使用工程中的Init.d框架，直接使用.c .h文件即可。 调试文件 //cmdtp 当前命令句柄 //flag run_command中传入 //argc 参数数量 //*argv[] 参数 int do_ls(cmd...
vscode stm32 openocd 在线调试，下载
kyzb002的专栏
03-30 2746
1、下载vscode 2、下载openocd 3、下载GNU Tools ARM Embedded 需要几个配置文件，路径分别： stlink.cfg ：........\OpenOCD-20200310-0.10.0\share\openocd\scripts\interface\stlink.cfg STM32WB5x.svd：C:\Program Files (x86)\IA...
clang-format 个人风格
kyzb002的专栏
01-30 2257
# 语言: None, Cpp, Java, JavaScript, ObjC, Proto, TableGen, TextProto Language: Cpp # BasedOnStyle: LLVM # 访问说明符(public、private等)的偏移 AccessModifierOffset: -4 # 开括号(开圆括号、开尖括号、开方括号)后的对齐: Align, DontAlign, AlwaysBreak(总是在开括号后换行) AlignAfterOpenBracket:...
esp8266 AT命令解析
kyzb002的专栏
10-10 1603
直接贴代码 ， 感冒好了有空再来注释 ， 原则就是基于sscanf来做命令解析。 #include "init_d.h" #include "miscdevice.h" #include "log.h" #include "cmsis_os.h" #include "stdlib.h" #include "esp8266.h" #include "stp_socket.h" #define...
[SIP]ubuntu安装PJSIP
kyzb002的专栏
10-21 991
1.下载PISIP:https://www.pjsip.org/download.htm 2.如果需要支持视频,需要以下组件: *Video4Linux2 sudo apt-get install libv4l-dev SDL 2.0 sudo apt-get install libsdl2-dev sudo apt-get install libsdl2-i...
log4j.properties配置自定义日志输出路径
最新发布
06-01
要在 `log4j.properties` 中配置自定义日志输出路径，可以按照以下步骤进行操作： 1. 在 `log4j.properties` 文件中添加一个新的 appender，指定日志输出路径。例如： ```properties log4j.appender.custom=org.apache.log4j.RollingFileAppender log4j.appender.custom.File=/path/to/custom.log log4j.appender.custom.MaxFileSize=10MB log4j.appender.custom.MaxBackupIndex=10 log4j.appender.custom.layout=org.apache.log4j.PatternLayout log4j.appender.custom.layout.ConversionPattern=%d{ISO8601} [%t] %-5p %c %x - %m%n ``` 在上面的配置中，`custom` 是 appender 的名称，`/path/to/custom.log` 是自定义日志输出路径，`MaxFileSize` 和 `MaxBackupIndex` 分别指定文件大小和备份文件数。 2. 在 `log4j.properties` 文件中指定日志输出目的地。例如： ```properties log4j.rootLogger=INFO, custom ``` 在上面的配置中，`custom` 是上一步中定义的 appender 名称。 3. 在代码中获取 Logger 对象并使用。例如： ```java import org.apache.log4j.Logger; public class MyApplication { private static final Logger logger = Logger.getLogger(MyApplication.class); public static void main(String[] args) { logger.info("Hello, world!"); } } ``` 在上面的代码中，使用 `Logger.getLogger(MyApplication.class)` 获取 Logger 对象，并调用 `logger.info("Hello, world!")` 输出日志信息。日志信息将会输出到自定义的日志输出路径 `/path/to/custom.log`。 注意：如果你已经在 `log4j.properties` 文件中定义了其他的 appender 和日志输出目的地，需要将自定义的 appender 和日志输出目的地添加到现有配置中。例如： ```properties log4j.rootLogger=INFO, console, file, custom log4j.appender.console=org.apache.log4j.ConsoleAppender log4j.appender.console.Target=System.out log4j.appender.console.layout=org.apache.log4j.PatternLayout log4j.appender.console.layout.ConversionPattern=%d{ISO8601} [%t] %-5p %c %x - %m%n log4j.appender.file=org.apache.log4j.RollingFileAppender log4j.appender.file.File=/path/to/file.log log4j.appender.file.MaxFileSize=10MB log4j.appender.file.MaxBackupIndex=10 log4j.appender.file.layout=org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern=%d{ISO8601} [%t] %-5p %c %x - %m%n log4j.appender.custom=org.apache.log4j.RollingFileAppender log4j.appender.custom.File=/path/to/custom.log log4j.appender.custom.MaxFileSize=10MB log4j.appender.custom.MaxBackupIndex=10 log4j.appender.custom.layout=org.apache.log4j.PatternLayout log4j.appender.custom.layout.ConversionPattern=%d{ISO8601} [%t] %-5p %c %x - %m%n ``` 在上面的配置中，`console` 和 `file` 是已经定义的 appender 和日志输出目的地，`custom` 是自定义的 appender 和日志输出目的地。注意在 `log4j.rootLogger` 中将它们都添加进去。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值