異常日志處理-ThrowsAdvice

　　有的時候，為了保全代碼的簡潔，我們不希望在程序中看到一些跟程序邏輯的代碼，譬如異常日志打印，這個時候就需要我們對程序中的異常日志進行統一的管理。spring aop 可以在不破壞程序邏輯的情況下很好的完成我們上面的需求。本文對對日志的處理使用到了ThrowsAdvice接口和spring aop

 

ThrowsAdvice接口

/*
 * Copyright 2002-2008 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.aop;

/**
 * Tag interface for throws advice.
 *
 * <p>There are not any methods on this interface, as methods are invoked by
 * reflection. Implementing classes must implement methods of the form:
 *
 * <pre class="code">void afterThrowing([Method, args, target], ThrowableSubclass);</pre>
 *
 * <p>Some examples of valid methods would be:
 *
 * <pre class="code">public void afterThrowing(Exception ex)</pre>
 * <pre class="code">public void afterThrowing(RemoteException)</pre>
 * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, Exception ex)</pre>
 * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)</pre>
 *
 * The first three arguments are optional, and only useful if we want further
 * information about the joinpoint, as in AspectJ <b>after-throwing</b> advice.
 *
 * <p><b>Note:</b> If a throws-advice method throws an exception itself, it will
 * override the original exception (i.e. change the exception thrown to the user).
 * The overriding exception will typically be a RuntimeException; this is compatible
 * with any method signature. However, if a throws-advice method throws a checked
 * exception, it will have to match the declared exceptions of the target method
 * and is hence to some degree coupled to specific target method signatures.
 * <b>Do not throw an undeclared checked exception that is incompatible with
 * the target method's signature!</b>
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @see AfterReturningAdvice
 * @see MethodBeforeAdvice
 */
public interface ThrowsAdvice extends AfterAdvice {

}

看接口說明可知，該接口上沒有任何方法，但是實現了這個接口的類必須至少實現以下4個方法中的一個，否則程序報：

Caused by: java.lang.IllegalArgumentException: At least one handler method must be found in class

接口中的異常類可以為自己自定義的異常類，方法是通過反射調用。

public void afterThrowing(Exception ex)
public void afterThrowing(RemoteException)
public void afterThrowing(Method method, Object[] args, Object target, Exception ex)
public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)

 

自定義異常類

package com.apt.study.exception;

public class StudyException extends RuntimeException {

    /**
     * 
     */
    private static final long serialVersionUID = -6183216129830888521L;

    /**
     * 異常信息
     */
    protected String message;
    
    /**
     * 異常編碼
     */
    protected int code;
    
    public static final StudyException PARAM_VALIDATE_EXCEPTION = new StudyException(1234,"參數校驗出錯");
    
    public StudyException(int code, String msgFormat, Object... args) {
        super(String.format(msgFormat, args));
        this.code = code;
        this.message = String.format(msgFormat, args);
    }
    
    public StudyException(String message, Throwable cause) {
        super(message, cause);
    }

    public StudyException(Throwable cause) {
        super(cause);
    }

    public StudyException(String message) {
        super(message);
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }
    
    
}

 

異常日志處理類

package com.apt.study.exception;

import java.lang.reflect.Method;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.ThrowsAdvice;

public class ExceptionLogHandler implements ThrowsAdvice{

    public Logger logger = LoggerFactory.getLogger(ExceptionLogHandler.class);
    
    public void afterThrowing(Method method, Object[] args, Object target, StudyException ex) {
        logger.error("ExceptionLogHandler--StudyExcception");
        logger.info("-------errCode:" + ex.getCode() + "; errMessage:" + ex.getMessage());
        errorClassInfo(ex);
        logger.info("-------" + ex.fillInStackTrace());
    }
    
    public void afterThrowing(Method method, Object[] args, Object target, Exception ex) {
        
        logger.error("ExceptionLogHandler--Exception");
        logger.error("------->Erro Class: "+ target.getClass().getName());
        logger.error("------->Error method:"+ method.getName());
        
        if(args != null) {
            for(int i=0; i<args.length; i++) {
                logger.error("------->args[" + i + "]: " + args[i]);
            }
        }
        
        logger.error("------->Exception class: " + ex.getClass().getName());
        errorClassInfo(ex);
        logger.error("------->" + ex.fillInStackTrace());
    }
    
    //打印拋出異常地方的信息
    private void errorClassInfo(Exception ex) {
        /*
         * ex.getStackTrace()返回堆棧跟蹤元素的數組，每個元素表示一個堆棧幀。數組的第零個元素（假定數據的長度為非零）表示堆棧頂部，
         * 它是序列中最后的方法調用。
         * 通常，這是創建和拋出該 throwable 的地方。數組的最后元素（假定數據的長度為非零）表示堆棧底部，它是序列中第一個方法調用
         */
        StackTraceElement[] stackTraceElementArr= ex.getStackTrace();
        StackTraceElement stackTraceElement = stackTraceElementArr[0];
        logger.error("------->Erro File:" + stackTraceElement.getFileName());
        logger.error("------->Erro Method:" + stackTraceElement.getMethodName());
        logger.error("------->Erro Line:" + stackTraceElement.getLineNumber());
    }
    
}

 

spring-context.xml 配置

<!-- 異常信息 攔截 -->
     <bean id="exceptionLog" class="com.apt.study.exception.ExceptionLogHandler"></bean>  
     <aop:config>
        <aop:pointcut id="exceptionTrade" expression="execution(* com.apt.study.service.*.*(..))" />
        <aop:advisor pointcut-ref="exceptionTrade" advice-ref="exceptionLog"/>
    </aop:config>