用aspectJ 做了一次日誌

1、

<aspectj.version>1.7.4.RELEASE</aspectj.version>

    <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectj.version}</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>${aspectj.version}</version>
        </dependency>

 注意：如果JDK1.7的 必須這裏也是1.7+

 

 

2、

<aop:config proxy-target-class="true"></aop:config>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

    <aop:aspectj-autoproxy proxy-target-class="true"/>

 注意：下載 必須在spring-mvc.xml裏面，且有兩個aop配置，下面那個是必須的，上面那個可能不是必須的（上面那個應該是spring aop的，如果有aspectJ了，可以不需要）

 

3、AOP類

 

package com.kingen.aop;

import java.lang.reflect.Method;

import javax.servlet.http.HttpServletRequest;
import javax.transaction.Transactional;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.kingen.bean.Log;
import com.kingen.bean.User;
import com.kingen.service.log.LogService;
import com.kingen.util.Constants;
import com.kingen.util.DateUtils;
import com.kingen.util.SpringContextHolder;
import com.kingen.util.StringUtils;
import com.kingen.util.UserUtils;

/**
 * 日誌AOP
 *
 * @author wj
 * @date 2016-11-16
 *
 */
@Aspect
@Component
public class LogAOP {
  下載
    private static LogService logService = SpringContextHolder.getBean(LogService.class);

    // 本地異常日誌記錄對象
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 在所有標註@LogAnnotation的地方切入
     *
     * @param joinPoint
     */
    @Pointcut("@annotation(com.kingen.aop.LogAnnotation)")
    public void logAspect() {
    }

    // @Around(value = "aApplogic() && @annotation(annotation) &&args(object,..)
    // ", argNames = "annotation,object")
    // public Object around(ProceedingJoinPoint pj,
    // LogAnnotation annotation, Object object) throws Throwable {
    // System.out.println("moduleName:"+annotation.moduleName());
    // System.out.println("option:"+annotation.option());
    // pj.proceed();
    // return object;
    // }

    /**
     * 前置通知 用於攔截Controller層記錄用戶的操作
     *
     *  joinPoint
     *            切點
     * @throws Exception
     */
//  @Around(value = "logAspect() && @annotation(annotation) &&args(object,..) ", argNames = "annotation,object")
//  public void doAround(ProceedingJoinPoint joinPoint, LogAnnotation annotation, Object object) {
    //用@Around 會導致controller不執行，不返回頁面

//   @After(value = "logAspect() && @annotation(annotation) &&args(object,..) ", argNames = "annotation,object")
//   public void doAfter(JoinPoint joinPoint, LogAnnotation annotation, Object object) {

     @AfterReturning(value = "logAspect() && @annotation(annotation) &&args(object,..) ", argNames = "", returning = "retVal")
     public void doAfterReturning(JoinPoint joinPoint, LogAnnotation annotation, Object object,  String retVal) {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
                .getRequest();
        try {
            // String title = getAnnotationValue(joinPoint);
            String title = getAnnotationValue(annotation);
            saveLog(request, title);
        } catch (Exception e) {
            e.printStackTrace();
            // 記錄本地異常日誌
            logger.error("==異常通知異常==");
            logger.error("異常信息:{}", e.getMessage());
        }
    }  下載

    /**
     * 異常通知 用於攔截service層記錄異常日誌
     *
     *  joinPoint
     *  e
     */
    // 方法  catch住異常的話，這裏執行不到
//  @AfterThrowing(pointcut = "logAspect()", throwing = "e")
    @AfterThrowing(value = "logAspect() && @annotation(annotation) &&args(..) " , throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint,  LogAnnotation annotation, Exception e) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
                .getRequest();

        try {

//          String title = getAnnotationValue(joinPoint);
            String title = getAnnotationValue(annotation);
            saveLog(request, title, e);
        } catch (Exception ex) {
            // 記錄本地異常日誌
            logger.error("==異常通知異常==");
            logger.error("異常信息:{}", ex.getMessage());
        }

    }

    public static void saveLog(HttpServletRequest request, String title) {
        saveLog(request, title, null);
    }

    /**
     * 保存日誌
     */
    @Transactional
    public static void saveLog(HttpServletRequest request, String title, Exception ex) {
        User user = UserUtils.getCurrentUser();
        if (user != null && user.getUserId() != null) {
            Log log = new Log();
            log.setCreateDate(DateUtils.getDateTime());
            log.setTitle(title);
            log.setType(ex == null ? Log.TYPE_ACCESS : Log.TYPE_EXCEPTION);
            log.setRemoteAddr(StringUtils.getRemoteAddr(request));
            log.setUserAgent(user.getUsername());
            // log.setUserAgent(request.getHeader("user-agent"));
            log.setRequestUri(request.getRequestURI());
            log.setParams(request.getParameterMap());
            // 如果有異常，設置異常信息
            log.setException(ex == null ? null : ex.getMessage());
//          log.setException(ex == null ? null : Exceptions.getStackTraceAsString(ex));
            log.setStatus(ex == null ? Constants.StatusEnum.Success.getIndex() : Constants.StatusEnum.Fail.getIndex());
            // log.setMethod(request.getMethod());
            // 異步保存日誌
            // new SaveLogThread(log, handler, ex).start();
            logService.saveLog(log);
        }  下載
    }

    /**
     * 獲取註解中對方法的描述信息 用於Controller層註解
     *
     * @param joinPoint
     *            切點
     * @return 方法描述
     * @throws Exception
     */
    @Deprecated
    public static String getAnnotationValue(JoinPoint joinPoint) throws Exception {
        String targetName = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        Object[] arguments = joinPoint.getArgs();
        Class targetClass = Class.forName(targetName);
        Method[] methods = targetClass.getMethods();
        String description = "";
        for (Method method : methods) {
            if (method.getName().equals(methodName)) {
                Class[] clazzs = method.getParameterTypes();
                if (clazzs.length == arguments.length) {
                    String moduleName = method.getAnnotation(LogAnnotation.class).moduleName();
                    String option = method.getAnnotation(LogAnnotation.class).option();
                    Assert.hasText(moduleName, "模塊名字不應爲空");
                    Assert.hasText(option, "操作名字不應爲空");
                    description = moduleName + "-" + option;
                    break;
                }
            }
        }
        return description;
    }

    public static String getAnnotationValue(LogAnnotation anno) throws Exception {
        String moduleName = anno.moduleName();
        String option = anno.option();
        Assert.hasText(moduleName, "模塊名字不應爲空");
        Assert.hasText(option, "操作名字不應爲空");
        String description = moduleName + "-" + option;
        return description;
    }
}

 注意這裏 @After和 @AfterReturning的區別，總的來說，就是 @After 是無論如何都會執行的，不管有沒有異常拋出（這樣會導致，在有異常的時候，記錄兩次日誌，after一次、throwing一次）；@AfterReturning 在有異常的情況下，不會執行到，因爲沒有renturn，在retrun之前就throw了。