用AOP记录操作日志，并写进数据库。

先用AOP注解  
1 package com.vlandc.oss.apigate.log.aspect;

 import java.util.Map;
 import java.util.Optional;

 import javax.servlet.http.HttpServletRequest;

 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.annotation.After;
 import org.aspectj.lang.annotation.AfterReturning;
 import org.aspectj.lang.annotation.AfterThrowing;
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Before;
 import org.aspectj.lang.annotation.Pointcut;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationContext;
 import org.springframework.stereotype.Component;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;

 import com.vlandc.oss.apigate.log.annotation.IUserLogAction;
 import com.vlandc.oss.apigate.log.annotation.UserLogActionAnnotation;
 import com.vlandc.oss.apigate.log.annotation.UserLogAnnotation;
 import com.vlandc.oss.apigate.shiro.token.UserInfo;
 import com.vlandc.oss.apigate.shiro.token.manager.TokenManager;
 import com.vlandc.oss.common.JsonHelper;

 @Aspect
 @Component
 public class UserLogAspect {

     private final static Logger logger = LoggerFactory.getLogger(UserLogAspect.class);

     ThreadLocal<UserLogBean> userLogObj = new ThreadLocal<>();

     @Autowired
     private TokenManager tokenManager;

     @Autowired
     private UserLogManager userLogManager;

     @Autowired
     private ApplicationContext context;

     @Pointcut("@annotation(com.vlandc.oss.apigate.log.annotation.UserLogAnnotation)"
             + "|| @annotation(com.vlandc.oss.apigate.log.annotation.UserLogActionAnnotation)")
     public void userLog() {
     }

     protected UserInfo getCurrentUserInfo(String token) {
         UserInfo userInfo = tokenManager.getUserInfo(token);
         if (null != userInfo) {
             return userInfo;
         } else {
             return null;
         }
     }

     @Before(value = "userLog() && !@annotation(com.vlandc.oss.apigate.log.annotation.UserLogAnnotation)")
     public void doBefore(JoinPoint joinPoint) throws Throwable {
         parseCommonUserLogBean(joinPoint);
     }

     @Before(value = "userLog() && @annotation(ul)", argNames = "joinPoint,ul")
     public void doBefore(JoinPoint joinPoint, UserLogAnnotation ul) throws Throwable {
         parseCommonUserLogBean(joinPoint);

         Object[] args = joinPoint.getArgs();
         Optional.ofNullable(args).map(t -> {
             try {
                 if (ul.loginIdOrder() > -1) {
                     userLogObj.get().setLoginId(String.valueOf(t[ul.loginIdOrder()]));
                 }
                 userLogObj.get().setTargetType(ul.targetType().name());
                 userLogObj.get().setTarget(String.valueOf(t[ul.targetOrder()]));
             } catch (Exception e) {
                 logger.error("parse user log target error :" + JsonHelper.toJson(userLogObj.get()) + "; target annotation:" + ul.targetOrder() + "-" + ul.targetType().name());
             }
             return t;
         });
     }

     private void parseCommonUserLogBean(JoinPoint joinPoint) {
         UserLogBean userLogBean = new UserLogBean();
         userLogObj.set(userLogBean);
         userLogBean.setStartTime(System.currentTimeMillis() / 1000);
         userLogBean.setAction(joinPoint.getSignature().getName());

         Object[] args = joinPoint.getArgs();
         Optional.ofNullable(args).map(t -> {
             userLogBean.setParameter(JsonHelper.toJson(t));
             return t;
         });

         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
         HttpServletRequest httpRequest = attributes.getRequest();
         UserInfo userInfo = getCurrentUserInfo(httpRequest.getHeader(TokenManager.TOKEN_KEY));
         Optional.ofNullable(userInfo).map(t -> {
             userLogBean.setLoginId(t.getLoginId());
             userLogBean.setUserName(t.getName());
             return t;
         });
     }

     @AfterReturning(returning = "result", pointcut = "userLog() && !@annotation(com.vlandc.oss.apigate.log.annotation.UserLogActionAnnotation)")
     public void doAfterReturning(Object result) throws Throwable {
         parseCommonResult(result);
     }

     @AfterReturning(returning = "result", pointcut = "userLog() && @annotation(ula)", argNames = "result,ula")
     public void doAfterReturning(Object result, UserLogActionAnnotation ula) throws Throwable {
         try {
             userLogObj.get().setTargetType(ula.targetType().name());

             String userLogActionName = Optional.ofNullable(ula).map(t -> t.userLogAction()).orElse("");
             if (context.containsBean(userLogActionName)) {
                 IUserLogAction userLogAction = (IUserLogAction) context.getBean(userLogActionName);
                 if(ula.defaultTargetKey().length() > 0) {
                     userLogAction.parseUserLogResult(ula.defaultTargetKey(), result, userLogObj.get());
                 }else {
                     userLogAction.parseUserLogResult(result, userLogObj.get());
                 }
             }
         } catch (Exception e) {
             logger.error("parse target user log result error!", e);
         }

         parseCommonResult(result);
     }

     private void parseCommonResult(Object result) {
         if (result instanceof String) {
             userLogObj.get().setResult((String) result);

         } else if (result instanceof Map) {
             userLogObj.get().setResult(JsonHelper.toJson(result));
         }
         try {
             logger.debug("the syslog object is " + JsonHelper.toJson(userLogObj.get()));
             userLogManager.saveUserLog(userLogObj.get());
         } catch (Exception e) {
             logger.error("set sys log result error!", e);
         }
     }

     @AfterThrowing(throwing = "ex", pointcut = "userLog()")
     public void throwss(JoinPoint jp, Exception ex) {

     }

     @After("userLog()")
     public void after(JoinPoint jp) {
         userLogObj.get().setEndTime(System.currentTimeMillis() / 1000);
     }
 }

package com.vlandc.oss.apigate.log.aspect;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.vlandc.oss.apigate.db.DBService;
import com.vlandc.oss.apigate.db.DBServiceConst;
import com.vlandc.oss.apigate.log.annotation.OssUserLogRabbitMQClient;

@Component
public class UserLogManager {
    private final static Logger logger = LoggerFactory.getLogger(UserLogManager.class);

    public static final String USER_LOG_INDEX_PREFIX = "ossuserlog";
    public static final String USER_LOG_INDEX_TYPE = "log";

    public static String getCurrentlogIndex() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd");
        return USER_LOG_INDEX_PREFIX + "-" + sdf.format(new Date());
    }

    @Autowired
    private OssUserLogRabbitMQClient ossUserLogMQClient;

    @Autowired
    private DBService dbService;

    public void saveUserLog(UserLogBean logContext){
        try {
            ossUserLogMQClient.send(logContext);
            insertUserLog(logContext);
        } catch (Exception e) {
            logger.error("send user log to rabbitmq and db !" , e);
        }
    }
   // 直接写入数据库
    private void insertUserLog(UserLogBean logContext) {
        HashMap<String, Object> parameters = new HashMap<String, Object>();
        parameters.put("loginId", logContext.getLoginId());
        parameters.put("response", logContext.getResult());
        parameters.put("user", logContext.getUserName());
        parameters.put("type", logContext.getTargetType());
        parameters.put("subType", logContext.getAction());
        parameters.put("ts", logContext.getStartTime());
        parameters.put("endTs", logContext.getEndTime());

        dbService.insert(DBServiceConst.INSERT_USER_LOG, parameters);
    }
}