AOP+LOG4J日志框架(自定义注解)

最新推荐文章于 2024-07-28 22:05:48 发布
最新推荐文章于 2024-07-28 22:05:48 发布
阅读量469 收藏
点赞数
分类专栏： Spring 文章标签： log4j
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengqingyu21/article/details/84417908
版权
工作中用到日志功能，参考网上一些资料，写了个比较通用的日志框架，现在拿出来分享，内容没有做太多解释，如有不清楚的地方可以给我留言或是通过网上查资料来解决。
设计思路：通过AOP进入方法之前拦截做行为日志记录，方法抛异常拦截做错误日志记录。实现自定义注解，可以存入行为中文注释，也可以配置成完全根据注解来决定是否记录日志的策略，支持控制台、文件、数据库、邮件和异步处理等功能以及针对数据库可以添加行为统计、异常统计和钻取明细等等。
web.xml文件配置如下：
<!-- 日志 --> 
<context-param>
	<param-name>log4jConfigLocation</param-name>
	<param-value>classpath:log4j.xml</param-value>
</context-param>
<!-- 监听器 放在spring监听器之前-->
<listener>
	<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>


spring配置文件如下： 

<!-- 日志  AOP-->	
<bean id="logBeforeAdvice" class="com.berheley.bi.system.log.logManage.LogBeforeAdvice">
	<property name="annotation" value="true"/>
</bean>
<bean id="logThrowingAdvice" class="com.berheley.bi.system.log.logManage.LogThrowingAdvice">
	<property name="annotation" value="true"/>
</bean>
<!-- 日志  begin-->
<aop:config> 
	<aop:advisor pointcut="execution(* com.berheley.bi.meta..*.*(..))"   advice-ref="logBeforeAdvice"/>  
</aop:config>
<!-- 日志 end -->

import java.lang.reflect.Method;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.aop.MethodBeforeAdvice;

/**
 * 
 * 类功能描述：日志框架
 *
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2013-4-9 下午05:23:41
 */
public class LogBeforeAdvice implements MethodBeforeAdvice {

	protected Log log = LogFactory.getLog(this.getClass());

	private boolean annotation = true;

	public void setAnnotation(boolean annotation) {
		this.annotation = annotation;
	}

	/**
	 * service方法前调用，记录行为或调试
	 */
	public void before(Method method, Object[] args, Object target) throws Throwable {
        LogUtils.beforeLog(target.getClass(), method, args, log, annotation);
	}
}


import java.lang.reflect.Method;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.aop.ThrowsAdvice;

import com.berheley.bi.basic.exp.BusinessException;

/**
 * 
 * 类功能描述：日志框架
 *
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2013-4-9 下午05:23:41
 */
public class LogThrowingAdvice implements ThrowsAdvice {

	protected Log log = LogFactory.getLog(this.getClass());

	private boolean annotation = true;

	public void setAnnotation(boolean annotation) {
		this.annotation = annotation;
	}

	/**
	 * 
	 * @function:抛出异常时调用，记录错误内容
	 * @param method
	 * @param args
	 * @param target
	 * @param ex
	 * @throws BusinessException
	 * @author: mengqingyu    2013-4-9 下午05:24:20
	 */
	public void afterThrowing(Method method, Object[] args, Object target,  
			Exception ex) throws BusinessException {
//		DOMConfigurator.configure(LogThrowingAdvice.class.getResource("/log4j.xml"));//临时测试用
		LogUtils.throwingLog(target.getClass(), method, args, ex, log, annotation);
    }
}

log4j配置文件如下： 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"> 
<!-- log4j xml配置 控制台、文件、数据库和邮件 支持异步  mengqingyu -->
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
	<!-- 控制台 -->
	<appender name="console" class="org.apache.log4j.ConsoleAppender">
		<param name="target" value="System.out"/>
		<layout class="org.apache.log4j.PatternLayout">
			<param name="conversionPattern" value="[%-5p] %d{yyyy-MM-dd HH:mm:ss} %m %n"/>
		</layout>
	</appender>

	<!-- 文件 -->
	<appender name="webframe" class="org.apache.log4j.DailyRollingFileAppender">
		<param name="file" value="${webframe.root}/WEB-INF/logs/webframe.log"/>
		<!-- 8K为一个写单元
		<param name="BufferedIO" value="true" />
        <param name="BufferSize" value="8192" />
         -->
		<param name="append" value="true"/>
		<param name="datePattern" value="'.'yyyy-MM-dd"/>
		<layout class="org.apache.log4j.PatternLayout">
			<param name="conversionPattern" value="[%-5p] %d{yyyy-MM-dd HH:mm:ss} %m %n"/>
		</layout>
	</appender>	

	<!-- 数据库 -->
	<appender name="db" class="com.berheley.bi.system.log.log4j.JDBCCustomAppender">
		<param name="bufferSize" value="1" />
		<layout class="org.apache.log4j.PatternLayout">
			<param name="conversionPattern"
				value="insert into t_log (LOG_NAME_,USER_NAME_,CLASS_,METHOD_NAME_,CREATE_TIME_,LOG_LEVEL_,METHOD_PARAM_,MSG_BRIEF_,MSG_DETAIL_,CLASS_DISCRIPTION_,METHOD_DISCRIPTION_) values ('%X{LOG_NAME_}','%X{USER_NAME_}','%X{CLASS_}','%X{METHOD_NAME_}','%d{yyyy-MM-dd HH:mm:ss}','%p','%X{METHOD_PARAM_}','%m','%X{MSG_DETAIL_}','%X{CLASS_DISCRIPTION_}','%X{METHOD_DISCRIPTION_}')" />
		</layout>
		<!-- 级别过滤
		<filter class="org.apache.log4j.varia.LevelRangeFilter"> 
			<param name="LevelMax" value="error" /> 
			<param name="LevelMin" value="error" /> 
		</filter> 
		-->
	</appender>

	<!-- 邮件 可配置多个appender模块划分-->
	<appender name="mail" class="com.berheley.bi.system.log.log4j.SMTPCustomAppender">
		<param name="threshold" value="fatal"/>
		<param name="bufferSize" value="1"/>
		<param name="from" value="1@gmail.com"/>
		<param name="smtpHost" value="smtp.gmail.com"/>
		<param name="smtpAuth" value="true"/>
		<param name="smtpUsername" value="1@gmail.com"/>
		<param name="smtpPassword" value="1"/>
		<param name="subject" value=" Log4J Message"/>
		<param name="packages" value="com.berheley.bi.fillform,com.berheley.bi.system"/>  <!-- 可以配置多个以,号间隔 -->		
		<param name="to" value="1@gmail.com"/> <!-- 可以配置多个以,号间隔 -->		
		<layout class="com.berheley.bi.system.log.log4j.HTMLCustomLayout"/>
	</appender>	

	<!-- 多线程 -->		
	<appender name="async" class="org.apache.log4j.AsyncAppender">
		<param name="bufferSize" value="100" />
		<appender-ref ref="db" />
		<appender-ref ref="mail" />
	</appender>

	<!-- 继承root log4j包下运行异步线程日志 -->
	<logger name="com.berheley.bi.system.log"> 
		<level value="info"/>
		<appender-ref ref="async"/> 
	</logger>

	<!-- 输出级别 -->	
	<root>
		<priority value="error" />
		<appender-ref ref="console" />
		<appender-ref ref="webframe" />
	</root>

	<!-- 单个日志级别控制
	<category name="monitorLogger" additivity="false">
        <priority value="info" />
        <appender-ref ref="console"/>
    </category >
    -->
</log4j:configuration>



import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Method;

import org.apache.commons.logging.Log;
import org.apache.log4j.MDC;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.webframe.web.springmvc.exp.AjaxException;

import com.berheley.bi.basic.exp.BusinessException;
import com.berheley.bi.system.login.LoginUser;

/**
 * 
 * 类功能描述： 日志工具类，设置属性
 *
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2013-4-12 下午04:55:44
 */
public abstract class LogUtils {

	public static final String WEB_CONTEXT_ 			= 		"WEB_CONTEXT_";

	public static final String LOG_NAME_ 				= 		"LOG_NAME_";

	public static final String USER_NAME_ 				= 		"USER_NAME_";

	public static final String CLASS_ 					= 		"CLASS_";

	public static final String PACKAGES_ 				= 		"PACKAGES_";

	public static final String METHOD_NAME_ 			= 		"METHOD_NAME_";

	public static final String METHOD_PARAM_ 			= 		"METHOD_PARAM_";

	public static final String CLASS_DISCRIPTION_ 		= 		"CLASS_DISCRIPTION_";

	public static final String METHOD_DISCRIPTION_ 		= 		"METHOD_DISCRIPTION_";

	public static final String MSG_DETAIL_ 				= 		"MSG_DETAIL_";

	/**
	 * 
	 * @function:操作行为记录
	 * @param clazz 类对象
	 * @param method 方法对象
	 * @param args 方法参数
	 * @param log 日志对象
	 * @throws BusinessException
	 * @author: mengqingyu    2013-5-30 下午05:29:57
	 */
	public static void beforeLog(Class<?> clazz, Method method, Object[] args, Log log, boolean annotation) throws BusinessException{
		LogDiscription methodDiscription =  method.getAnnotation(LogDiscription.class);
		if(annotation==false||methodDiscription!=null){
			initLog(clazz, method, args, null, methodDiscription);
			log.info(new StringBuilder("info:").append(LogUtils.getClassName()).append("->").append(LogUtils.getMethodName()));
		}
	}

	/**
	 * 
	 * @function:异常记录
	 * @param clazz 类对象
	 * @param method 方法对象
	 * @param args 方法参数
	 * @param ex 异常对象
	 * @param log 日志对象
	 * @throws BusinessException
	 * @author: mengqingyu    2013-5-30 下午05:30:00
	 */
	public static void throwingLog(Class<?> clazz, Method method, Object[] args, Exception ex, Log log, boolean annotation) throws BusinessException{
		LogDiscription methodDiscription =  method.getAnnotation(LogDiscription.class);
		if(annotation==false||methodDiscription!=null){
			initLog(clazz, method, args, ex, methodDiscription);
			if(ex instanceof BusinessException || ex instanceof AjaxException){
				log.error(ex.getMessage(),ex);
			}
			else{
				log.fatal(ex.getMessage(),ex);
			}
		}
	}

	/**
	 * 
	 * @function:初始化参数
	 * @param clazz 类对象
	 * @param method 方法对象
	 * @param args 方法参数
	 * @param ex 异常对象
	 * @throws BusinessException
	 * @author: mengqingyu    2013-4-12 下午04:56:09
	 */
	protected static void initLog(Class<?> clazz, Method method, Object[] args, Exception ex, LogDiscription methodDiscription) throws BusinessException{
		if(clazz==null||method==null)
			throw new BusinessException("日志初始化参数clazz或method为空");

		setLogName();
		setClass(clazz);
		setMethodName(method);
		setMethodParam(args,methodDiscription);
		setClassDiscription(clazz.getAnnotation(LogDiscription.class));
		setMethodDiscription(methodDiscription);
		setMsgDetail(ex);
	}

	/**
	 * 
	 * @function:初始化参数
	 * @param clazz 类对象
	 * @param method 方法名称
	 * @param classTypes 方法参数类型
	 * @param args 方法参数
	 * @param ex 异常对象
	 * @throws BusinessException
	 * @author: mengqingyu    2013-4-12 下午04:56:09
	 */
	@SuppressWarnings("rawtypes")
	public static Method initLog(Class<?> clazz, String methodName, Class[] classTypes) throws BusinessException{
		if(clazz==null||methodName==null)
			throw new BusinessException("日志初始化参数：clazz或method为空");

		Method method;
		try {
			method = clazz.getMethod(methodName, classTypes);
		} catch (SecurityException e) {
			throw new BusinessException("方法权限错误"+methodName,e);
		} catch (NoSuchMethodException e) {
			throw new BusinessException("方法名或参数类型错误："+methodName,e);
		}
		return method;
	}

	private static void setLogName(){
		Authentication auth = SecurityContextHolder.getContext().getAuthentication();
		String Username;
		String RealName;
		if(auth!=null){
			LoginUser loginUser = (LoginUser)auth.getPrincipal();
			Username = loginUser.getUsername();
			RealName = loginUser.getRealName();
		}
		else{
			Username = Thread.currentThread().getName();
			RealName = "无";
		}
		MDC.put(LogUtils.LOG_NAME_, Username);
		MDC.put(LogUtils.USER_NAME_, RealName);
	}

	private static void setClass(Class<?> clazz){
		MDC.put(LogUtils.CLASS_, clazz.getName().substring(clazz.getName().lastIndexOf(".")+1));
		MDC.put(LogUtils.PACKAGES_, clazz.getName());
	}

	private static void setMethodName(Method method){
		MDC.put(LogUtils.METHOD_NAME_, method.getName());
	}

	private static void setMethodParam(Object[] args, LogDiscription logDiscription){
		if(args!=null){
			StringBuilder methodParam = new StringBuilder();
			String param = logDiscription==null?"":logDiscription.param();
			if("".equals(param)){
		        for(Object o:args){  
		        	methodParam.append(o).append("<br/>");
		        }  
			}
			else{
				String[] paramArray = param.split(",");
				int paramLength = paramArray.length;
				if(paramLength != args.length){
					methodParam.append("参数注释错误");
				}
				else{
					for(int i=0;i<args.length;i++){
						methodParam.append(paramArray[i]).append("：").append(args[i]).append("<br/>");
					}
				}
			}
			MDC.put(LogUtils.METHOD_PARAM_, replaceParam(methodParam.toString()));
		}
	}

	private static void setClassDiscription(LogDiscription logDiscription){
		MDC.put(LogUtils.CLASS_DISCRIPTION_, replaceParam(logDiscription==null?"":logDiscription.clazz()));
	}

	private static void setMethodDiscription(LogDiscription logDiscription){
		MDC.put(LogUtils.METHOD_DISCRIPTION_, replaceParam(logDiscription==null?"":logDiscription.method()));
	}

	/**
	 * 
	 * @function:设置异常信息
	 * @param ex 异常对象
	 * @author: mengqingyu    2013-4-12 下午04:56:53
	 */
	public static void setMsgDetail(Exception ex){
		if(ex!=null){
			StringWriter sw = new StringWriter();
			PrintWriter pw = new PrintWriter(sw);
			ex.printStackTrace(pw);
			MDC.put(LogUtils.MSG_DETAIL_, sw);
		}
	}

	/**
	 * 
	 * @function:获取类名称
	 * @return
	 * @author: mengqingyu    2013-4-12 下午04:57:13
	 */
	public static String getClassName(){
		return MDC.get(LogUtils.CLASS_)==null?"null":MDC.get(LogUtils.CLASS_).toString();
	}

	/**
	 * 
	 * @function:获取方法名称
	 * @return
	 * @author: mengqingyu    2013-4-12 下午04:57:30
	 */
	public static String getMethodName(){
		return MDC.get(LogUtils.METHOD_NAME_)==null?"null":MDC.get(LogUtils.METHOD_NAME_).toString();
	}

	private static String replaceParam(String value){
		return value.replace(",", "\\,").replace("'", "\\'");
	}
}

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

/**
 * 
 * 类功能描述：自定义日志注解
 *
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2013-4-12 下午01:57:44
 */
@Retention(RetentionPolicy.RUNTIME)
public @interface LogDiscription {
	/**
	 * 用法：在类名上方加入注解代码 @LogDiscription(clazz="表单分配")
	 * @function:类注释
	 * @return
	 * @author: mengqingyu    2013-4-12 下午01:57:10
	 */
	String clazz() default "";

	/**
	 * 用法：在方法名上方加入注解代码 @LogDiscription(method = "立即发布",param = "任务ID:{0} 主键:{1} 创建时间:{2}")
	 * @function:方法注释
	 * @return
	 * @author: mengqingyu    2013-4-12 下午01:57:22
	 */
	String method() default "";

	/**
	 * 
	 * @function:方法参数注释
	 * @return
	 * @author: mengqingyu    2013-4-12 下午01:57:30
	 */
	String param() default "";
}

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Iterator;

import javax.sql.DataSource;

import org.apache.log4j.jdbc.JDBCAppender;
import org.apache.log4j.spi.ErrorCode;
import org.apache.log4j.spi.LoggingEvent;
import org.webframe.web.util.WebFrameUtils;

/**
 * 
 * 类功能描述：log4j 入库日志管理，重写此类解决数据源、批量插入和日志过滤等问题
 *
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2013-4-9 下午02:20:08
 */
public class JDBCCustomAppender extends JDBCAppender {

	/**
	 * 类功能描述：数据库连接池，单例，延迟实例化
	 */
	private static class DataSourceHolder {
		private static final DataSource dataSource = (DataSource) WebFrameUtils.getApplicationContext().getBean("dataSource");
	}

	/**
	 * 在日志加入集合过程中进行处理
	 */
	@SuppressWarnings("unchecked")
	@Override
	public void append(LoggingEvent event) {
		buffer.add(event);
		if (buffer.size() >= bufferSize)
			flushBuffer();
	}

	/**
	 * 从连接池中获取连接
	 */
	@Override
	protected Connection getConnection() throws SQLException {
		return DataSourceHolder.dataSource.getConnection();
	}

	/**
	 * 删去了源方法中的一些操作
	 */
	@Override
	public void close() {
		this.closed = true;
	}

	/**
	 * 释放连接
	 */
	@Override
	protected void closeConnection(Connection con) {
		try {
			con.close();
		} catch (SQLException e) {
			errorHandler.error("Error closing connection", e, ErrorCode.GENERIC_FAILURE);
		}
	}

	/**
	 * 重写批量插入操作
	 */
	@SuppressWarnings("unchecked")
	@Override
	public void flushBuffer() {
		Connection con = null;
		Statement stmt = null;
		try {
			con = getConnection();
			stmt = con.createStatement();
			removes.ensureCapacity(buffer.size());
			for (Iterator<LoggingEvent> i = buffer.iterator(); i.hasNext();) {
				LoggingEvent logEvent = i.next();
				stmt.addBatch(getLogStatement(logEvent));
				removes.add(logEvent);
			}
		 	stmt.executeBatch();
		} catch (SQLException e) {
		    errorHandler.error("Failed to excute sql", e,ErrorCode.FLUSH_FAILURE);
		} finally {
			try {
				stmt.close();
			} catch (SQLException e) {
				errorHandler.error("Failed to excute sql", e,ErrorCode.FLUSH_FAILURE);
			} finally {
				closeConnection(con);
			}
		}
		buffer.removeAll(removes);
		removes.clear();
	}
}

import java.util.Properties;

import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.net.SMTPAppender;
import org.apache.log4j.spi.ErrorCode;
import org.apache.log4j.spi.LoggingEvent;

/**
 * 
 * 类功能描述：log4j 邮件日志管理，重写此类解决不支持权限认证、缓存问题和gmail端口号问题，注：新版本log4j已经支持认证
 *
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2013-4-11 下午01:44:19
 */
public class SMTPCustomAppender extends SMTPAppender {

	protected String smtpUsername;

	protected String smtpPassword;

	protected String smtpAuth;

	protected String[] packages;

	protected String to;

	protected String from;

	protected String subject;

	protected String smtpHost;

	protected int bufferSize = 512;

	protected boolean locationInfo = false;

	public void setSmtpUsername(String smtpUsername) {
		this.smtpUsername = smtpUsername;
	}

	public void setSmtpPassword(String smtpPassword) {
		this.smtpPassword = smtpPassword;
	}

	public void setSmtpAuth(String smtpAuth) {
		this.smtpAuth = smtpAuth;
	}

	public void setTo(String to) {
		this.to = to;
	}

	public void setPackages(String packages) {
		this.packages = packages.split(",");
	}

	public void setFrom(String from) {
		this.from = from;
	}

	public void setSubject(String subject) {
		this.subject = subject;
	}

	public void setSmtpHost(String smtpHost) {
		this.smtpHost = smtpHost;
	}

	public void setBufferSize(int bufferSize) {
		this.bufferSize = bufferSize;
	}

	public void setLocationInfo(boolean locationInfo) {
		this.locationInfo = locationInfo;
	}

	/**
	 * 在日志加入集合过程中进行处理
	 */
	public void append(LoggingEvent event) {
		if (!checkEntryConditions()) {
			return;
		}

		event.getThreadName();
		event.getNDC();
		if (locationInfo) {
			event.getLocationInformation();
		}
		//包过滤
		if(packages!=null&&packages.length>0){
			String clazz = event.getMDC(LogUtils.PACKAGES_).toString();
			for(int i=0;i<packages.length;i++){
				if(clazz.startsWith(packages[i])){
					cb.add(event);
					break;
				}
			}
		}
		else{
			cb.add(event);
		}
		if (evaluator.isTriggeringEvent(event)) {
            if (cb.length() >= bufferSize) { //添加缓存判断 
                sendBuffer();  
            }  
		}
	}

	/**
	 * 初始化邮件对象并进行权限认证
	 */
	public void activateOptions() {
		Properties props = new Properties(System.getProperties());
		if (smtpHost != null) {
			props.put("mail.smtp.host", smtpHost);
			// 邮件默认端口号是25，gmail邮件服务商用是465端口，需要手动处理
			if (smtpHost.indexOf("smtp.gmail.com") >= 0) {
				props.setProperty("mail.smtp.socketFactory.class",
						"javax.net.ssl.SSLSocketFactory");
				props.setProperty("mail.smtp.socketFactory.fallback", "false");
				props.setProperty("mail.smtp.port", "465");
				props.setProperty("mail.smtp.socketFactory.port", "465");
			}
		}

		Authenticator authenticator = null;

		if (smtpAuth != null && smtpAuth.trim().equals("true")) {
			props.put("mail.smtp.auth", "true");
			authenticator = new Authenticator() {
				protected PasswordAuthentication getPasswordAuthentication() {
					return new PasswordAuthentication(smtpUsername,
							smtpPassword);
				}
			};
		}

		Session session = Session.getInstance(props, authenticator);
		msg = new MimeMessage(session);

		try {
			if (from != null)
				msg.setFrom(getAddress(from));// 设置发件人
			else
				msg.setFrom();
			msg.setRecipients(Message.RecipientType.TO, parseAddress(to));// 设置收件人
			if (subject != null){
				String context = WebFrameUtils.getWebContextPath();
				context = StringUtils.isBlank(context)?subject:context.replace("/", "")+" "+subject;
				msg.setSubject(context);
			}

		} catch (MessagingException e) {
			LogLog.error("Could not activate SMTPAppender options.", e);
		}
	}

	/**
	 * 
	 * @function:获得地址
	 * @param addressStr
	 * @return
	 * @author: mengqingyu 2013-4-10 下午02:38:30
	 */
	protected InternetAddress getAddress(String addressStr) {
		try {
			return new InternetAddress(addressStr);
		} catch (AddressException e) {
			errorHandler.error("Could not parse address [" + addressStr + "].",
					e, ErrorCode.ADDRESS_PARSE_FAILURE);
			return null;
		}
	}

	/**
	 * 
	 * @function:转换地址
	 * @param addressStr
	 * @return
	 * @author: mengqingyu 2013-4-10 下午02:38:52
	 */
	protected InternetAddress[] parseAddress(String addressStr) {
		try {
			return InternetAddress.parse(addressStr, true);
		} catch (AddressException e) {
			errorHandler.error("Could not parse address [" + addressStr + "].",
					e, ErrorCode.ADDRESS_PARSE_FAILURE);
			return null;
		}
	}
}

import org.apache.log4j.HTMLLayout;
import org.apache.log4j.Layout;
import org.apache.log4j.Level;
import org.apache.log4j.helpers.Transform;
import org.apache.log4j.spi.LocationInfo;
import org.apache.log4j.spi.LoggingEvent;

/**
 * 
 * 类功能描述：log4j 日志模板，重写此类解决中文乱码和自定义模板问题
 *
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2013-4-11 下午01:46:43
 */
public class HTMLCustomLayout extends HTMLLayout {

	protected StringBuffer sbuf = new StringBuffer(BUF_SIZE);

	protected static String TRACE_PREFIX = "<br>    ";

	protected boolean locationInfo = false;

	protected String title = "Log4J Log Messages";

	public void setLocationInfo(boolean flag) {
		locationInfo = flag;
	}

	public boolean getLocationInfo() {
		return locationInfo;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getTitle() {
		return title;
	}

	/**
	 * 格式化HTML头部模板
	 */
	public String getHeader() {
		StringBuffer sbuf = new StringBuffer();
		sbuf.append("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">"
				+ Layout.LINE_SEP);
		sbuf.append("<html>" + Layout.LINE_SEP);
		sbuf.append("<head>" + Layout.LINE_SEP);
		sbuf.append("<title>" + title + "</title>" + Layout.LINE_SEP);
		sbuf.append("<style type=\"text/css\">" + Layout.LINE_SEP);
		sbuf.append("<!--" + Layout.LINE_SEP);
		sbuf.append("body, table {font-family: arial,sans-serif; font-size: x-small;}"
				+ Layout.LINE_SEP);
		sbuf.append("th {background: #336699; color: #FFFFFF; text-align: left;}"
				+ Layout.LINE_SEP);
		sbuf.append("-->" + Layout.LINE_SEP);
		sbuf.append("</style>" + Layout.LINE_SEP);
		sbuf.append("</head>" + Layout.LINE_SEP);
		sbuf.append("<body bgcolor=\"#FFFFFF\" topmargin=\"6\" leftmargin=\"6\">"
				+ Layout.LINE_SEP);
		sbuf.append("<hr size=\"1\" noshade>" + Layout.LINE_SEP);
		sbuf.append("Log session start time " + new java.util.Date() + "<br>"
				+ Layout.LINE_SEP);
		sbuf.append("<br>" + Layout.LINE_SEP);
		sbuf.append("<table cellspacing=\"0\" cellpadding=\"4\" border=\"1\" bordercolor=\"#224466\" width=\"100%\">"
				+ Layout.LINE_SEP);
		sbuf.append("<tr>" + Layout.LINE_SEP);
		sbuf.append("<th>登录名</th>" + Layout.LINE_SEP);
		sbuf.append("<th>用户名</th>" + Layout.LINE_SEP);
		sbuf.append("<th>级别</th>" + Layout.LINE_SEP);
		sbuf.append("<th>类名称</th>" + Layout.LINE_SEP);
		if (locationInfo) {
			sbuf.append("<th>File:Line</th>" + Layout.LINE_SEP);
		}
		sbuf.append("<th>方法名称</th>" + Layout.LINE_SEP);
		sbuf.append("</tr>" + Layout.LINE_SEP);
		return sbuf.toString();
	}

	/**
	 * 格式化HTML模板
	 */
	public String format(LoggingEvent event) {
		if (sbuf.capacity() > MAX_CAPACITY) {
			sbuf = new StringBuffer(BUF_SIZE);
		} else {
			sbuf.setLength(0);
		}

		sbuf.append(Layout.LINE_SEP + "<tr>" + Layout.LINE_SEP);

		sbuf.append("<td>");
		sbuf.append(event.getMDC("LOG_NAME_"));
		sbuf.append("</td>" + Layout.LINE_SEP);

		sbuf.append("<td>");
		sbuf.append(event.getMDC("USER_NAME_"));
		sbuf.append("</td>" + Layout.LINE_SEP);

		sbuf.append("<td title=\"Level\">");
		if (event.getLevel().equals(Level.DEBUG)) {
			sbuf.append("<font color=\"#339933\">");
			sbuf.append(event.getLevel());
			sbuf.append("</font>");
		} else if (event.getLevel().isGreaterOrEqual(Level.WARN)) {
			sbuf.append("<font color=\"#993300\"><strong>");
			sbuf.append(event.getLevel());
			sbuf.append("</strong></font>");
		} else {
			sbuf.append(event.getLevel());
		}
		sbuf.append("</td>" + Layout.LINE_SEP);

		sbuf.append("<td>");
		sbuf.append(event.getMDC("CLASS_"));
		sbuf.append("</td>" + Layout.LINE_SEP);

		if (locationInfo) {
			LocationInfo locInfo = event.getLocationInformation();
			sbuf.append("<td>");
			sbuf.append(Transform.escapeTags(locInfo.getFileName()));
			sbuf.append(':');
			sbuf.append(locInfo.getLineNumber());
			sbuf.append("</td>" + Layout.LINE_SEP);
		}

		sbuf.append("<td>");
		sbuf.append(event.getMDC("METHOD_NAME_"));
		sbuf.append("</td>" + Layout.LINE_SEP);
		sbuf.append("</tr>" + Layout.LINE_SEP);

		if (event.getNDC() != null) {
			sbuf.append("<tr><td bgcolor=\"#EEEEEE\" style=\"font-size : xx-small;\" colspan=\"6\" title=\"Nested Diagnostic Context\">");
			sbuf.append("NDC: " + Transform.escapeTags(event.getNDC()));
			sbuf.append("</td></tr>" + Layout.LINE_SEP);
		}

		Object methodParam = event.getMDC("METHOD_PARAM_");
		if(methodParam!=null){
			sbuf.append("<tr><td style=\"font-size : xx-small;\" colspan=\"6\">");
			sbuf.append("方法参数："+methodParam.toString().replace("\\r\\n", "  "));
			sbuf.append("</td></tr>" + Layout.LINE_SEP);
		}

		sbuf.append("<tr><td style=\"font-size : xx-small;\" colspan=\"6\">");
		sbuf.append("异常摘要："+event.getMessage());
		sbuf.append("</td></tr>" + Layout.LINE_SEP);

		String[] s = event.getThrowableStrRep();
		if (s != null) {
			sbuf.append("<tr><td bgcolor=\"#993300\" style=\"color:White; font-size : xx-small;\" colspan=\"6\">");
			appendThrowableAsHTML(s, sbuf);
			sbuf.append("</td></tr>" + Layout.LINE_SEP);
		}

		return sbuf.toString();
	}

	/**
	 * 
	 * @function:拼装异常内容
	 * @param s
	 * @param sbuf
	 * @author: mengqingyu    2013-4-11 下午01:49:29
	 */
	protected void appendThrowableAsHTML(String[] s, StringBuffer sbuf) {
		if (s != null) {
			int len = s.length;
			if (len == 0)
				return;
			sbuf.append(Transform.escapeTags(s[0]));
			sbuf.append(Layout.LINE_SEP);
			for (int i = 1; i < len; i++) {
				sbuf.append(TRACE_PREFIX);
				sbuf.append(Transform.escapeTags(s[i]));
				sbuf.append(Layout.LINE_SEP);
			}
		}
	}

	/**
	 * 中文编码
	 */
	public String getContentType() {
		return "text/html;charset=GBK";
	}
}

注：在类或方法上通过注解的方式来进行描述 
@LogDiscription(method = "立即发布",param = "任务ID, 主键, 创建时间")
	@Override
	public void insertOrUpdateMysqlDatas(JSONArray datas, String tableName, String pkName){}
mengqingyu21
关注
专栏目录
【SpringBoot笔记21】SpringBoot框架使用AOP + 自定义注解实现请求日志记录
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
11-03 912
这里我们自定义一个@LogRecord注解，该注解使用在方法上面，由于标记AOP切面会拦截这个方法，并且记录请求日志信息。/*** @Description 自定义日志注解*/// 注解可以保留到运行期间// 注解使用在方法上面/*** 操作名称*//*** 描述信息*/}为了能够收集请求日志的信息，这里定义一个日志实体类来保存没有一次请求的日志信息。/*** @Description 日志实体类*//** 日志唯一标识 *//** 操作名称 */
MyBatis学习总结（4）--- LOG4J日志、分页、注解
qq_44823091的博客
07-25 370
MyBatis学习总结（4）— LOG4J日志、分页、注解 1. LOG4J log for java ：Java的日志 Log4j 是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件。 最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。 Log4j依赖 pom.xml中添加， <!-- ht...
Java日志Log4j与@Slf4j注解
xuxinan88888的博客
05-28 2570
Log4j 是一个功能强大且灵活的日志框架，广泛用于Java应用程序中。Log4j 允许开发人员在应用程序中记录各种级别的日志信息，以帮助调试、监控和分析程序的运行情况。以下是对Log4j的详细介绍及其使用方法。
AOP面向切面编程和log4j的使用（Java版）
最新发布
beautiful77moon的博客
07-28 258
在传统的面向对象编程中，程序的功能被模块化成各个类和方法，这些类和方法分别处理特定的功能。然而，有些功能可能涉及到多个类、多个方法，例如日志记录、事务管理、性能监控等，这些功能可能在不同的地方重复出现，导致代码的重复性和复杂性增加。AOP 解决了这个问题，它允许你在程序的运行时，将这些横切逻辑（cross-cutting concerns）从它们所影响的对象中分离出来，然后以一种更模块化的方式进行管理。
Mybatis自学日志03（LOG4J，注解）
qq_43697752的博客
01-02 715
什么是LOG4J? Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码...
log4j注解_自定义注解方法重试@RetryProcess
weixin_39551996的博客
12-04 187
背景在项目开发中，有时候会出现接口调用失败，本身调用又是异步的，如果是因为一些网络问题请求超时，总想可以重试几次把任务处理掉。一些RPC框架，比如dubbo都是有重试机制的，但是并不是每一个项目多会使用dubbo框架，常规的小项目有时候直接使用http进行不同项目之间的交互。思路使用spring aop和自定义注解来，建立一套重试机制。根据切入点和自定义注解，来完成重试工作。自定义注解定...
Log4j.properties配置详解
热门推荐
snakeqi的专栏
01-12 2万+
一、Log4j简介Log4j有三个主要的组件：Loggers(记录器)，Appenders (输出源)和Layouts(布局)。这里可简单理解为日志类别，日志要输出的地方和日志以何种形式输出。综合使用这三个组件可以轻松地记录信息的类型和级别，并可以在运行时控制日志输出的样式和位置。1、LoggersLoggers组件在此系统中被分为五个级别：DEBUG、INFO、WARN、ERROR和
SSM中 实现日志记录（AOP+log4j2）
weixin_44678333的博客
12-14 458
使用工具 集成开发环境：idea 项目管理工具：maven 数据库：masql 框架：Spring+SpringMVC+myBatis 主要步骤 在pom.xml中引入插件依赖 log4j2.xml文件配置 web.xml文件配置 编写日志管理类LogInterceptor.class spring-mvc.xml中配置AOP【可以使用注解和自定义注解，我这使用的是xml】 在controlle...
使用springboot+aop+log4j2进行全局接口请求监控，记录请求耗时
zdx355的博客
08-21 3187
1在pom.xml中引入aop、log4j2依赖 <!-- aop 依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependen...
springmvc log4j2 logback 注解 jackson 日志脱敏实现源码
12-30
`Logback`和`Log4j`都是广泛使用的日志框架，它们允许自定义日志格式和处理策略。 2. **SpringMVC返回报文脱敏**：`SpringMVC`是Spring框架的一个模块，主要用于构建Web应用。在响应报文时，如果包含了敏感信息（如...
自定义注解+反射+AOP+异步多线程统一日志管理
u014474768的博客
03-11 1115
自定义注解+反射+AOP+异步多线程统一日志管理
spring简单注解+log4j记录日志
12-30
简单的demo4初学者，用到spring注解，log4j记录日志到文件
SpringMVC利用AOP实现自定义注解记录日志
10-14
SpringMVC利用AOP实现自定义注解记录日志
springmvc中使用log4j及aop记录日志的例子
12-27
使用springmvc，利用aop aspectj log4j 实现进入函数，退出函数的日志的记录
ssh+aop+log4j+日志拦截器+注解
11-27
ssh+aop+log4j+日志拦截器+注解
MyBatis(4)Log4J日志、分页、注解
weixin_42478671的博客
07-27 457
地址：http://www.codeceo.com/log4j-usage.html 日志是应用软件中不可缺少的部分，Apache的开源项目log4j是一个功能强大的日志组件,提供方便的日志记录。在apache网站：jakarta.apache.org/log4j 可以免费下载到Log4j最新版本的软件包。 1.LOG4J log4j–log for java(java的日志) 在强调可重用组件开...
log4j注解_Spring Boot 使用自定义注解，AOP 切面打印出日志及Dubbo链路追踪透传traceId
weixin_39944944的博客
11-30 594
一、使用背景开发排查系统问题用得最多的手段就是查看系统日志，在分布式环境中一般使用 ELK 来统一收集日志，但是在并发大时使用日志定位问题还是比较麻烦，由于大量的其他用户/其他线程的日志也一起输出穿行其中导致很难筛选出指定请求的全部相关日志，以及下游线程/服务对应的日志。二、解决思路每个请求都使用一个唯一标识来追踪全部的链路显示在日志中，并且不修改原有的使用Logback的MDC机制日志模板中加入...
spring aop整合log4j实现简单日志输出
mzjmmc的博客
08-22 611
第一步：引入jar包 第二步：在web.xml配置日志监听器
SpringAOP +log4J+注解的 日志管理
Kaybee - 练级之路
08-10 4924
SpringAOP 日志管理by Kay 2017.8.10 在Spring项目中，日志管理的通常方式是采用AOP来实现，以下为我使用SpringAOP进行分类管理的一个Demo，以便总结。 代码下载：https://github.com/LiuKay/AopLog1.pom.xml 项目依赖<project xmlns="http://maven.apache.org/POM/4.0.0" x
Spring AOP自定义注解日志管理实战教程
本文档主要介绍了如何使用Spring AOP (Aspect Oriented Programming) 自定义注解的方式来实现日志管理的实例。在Spring框架中，AOP提供了一种面向切面编程的解决方案，使得我们可以将关注点（如日志记录）与业务逻辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值