//操作日志記錄的是：某一個“時間”“誰”對“什么”做了什么“事情”。
log.info("訂單創(chuàng)建")
log.info("訂單已經(jīng)創(chuàng)建，訂單編號:{}",?orderNo)
log.info("修改了訂單的配送地址：從“{}”修改到“{}”，?"金燦燦小區(qū)",?"銀盞盞小區(qū)")

@LogRecord(content="修改了配送地址")
public void modifyAddress(updateDeliveryRequest request){
//?更新派送信息?電話，收件人、地址
doUpdate(request);
}

# 返回目標(biāo)對象，即被代理的對象
Object getTarget();

# 返回切入點的參數(shù)
Object[] getArgs();

# 返回切入點的Signature
Signature getSignature();

# 返回切入的類型，比如method-call，field-get等等，感覺不重要?
String getKind();

//獲取切入點方法的名字,getSignature());是獲取到這樣的信息 :修飾符+ 包名+組件名(類名) +方法名
String methodName = joinPoint.getSignature().getName()

//獲取方法的參數(shù),這里返回的是切入點方法的參數(shù)列表
Object[] args = joinPoint.getArgs();

//獲取方法上的注解
Signature signature = joinPoint.getSignature();
MethodSignature methodSignature = (MethodSignature) signature;
Method method = methodSignature.getMethod();
if (method != null)
{
xxxxxx annoObj= method.getAnnotation(xxxxxx.class);
}

//獲取切入點所在目標(biāo)對象
Object targetObj =joinPoint.getTarget();
//可以發(fā)揮反射的功能獲取關(guān)于類的任何信息，例如獲取類名如下
String className = joinPoint.getTarget().getClass().getName();

execution(方法修飾符 返回類型 方法所屬的包.類名.方法名稱(方法參數(shù))
//com.hs.demo.controller包中所有類的public方法都應(yīng)用切面里的通知
execution(public * com.hs.demo.controller..(…))
//com.hs.demo.service包及其子包下所有類中的所有方法都應(yīng)用切面里的通知
execution(* com.hs.demo.service….(…))
//com.hs.demo.service.EmployeeService類中的所有方法都應(yīng)用切面里的通知
execution(* com.hs.demo.service.EmployeeService.*(…))

@Aspect
@Component
public class LogFilter1Aspect {
	@Pointcut(value = "@annotation(com.hs.aop.annotation.LogFilter)")
	public void pointCut(){
	
	}
}

@Target(ElementType.METHOD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface LogFilter1 {
}

@RestController
public class AopController {
	@RequestMapping("/aop")
	@LogFilter
	public String aop(){
	    System.out.println("這是執(zhí)行方法");
	    return "success";
	}
}

@Pointcut(value = "execution(public * com.train.aop.controller.AopController.*(..))")
public void pointCut(){

}

   /**
	 * 環(huán)繞通知是spring框架為我們提供的一種可以在代碼中手動控制增強部分什么時候執(zhí)行的方式。
	 *
	 */
	public void aroundPringLog(ProceedingJoinPoint pjp)
   {
      //拿到目標(biāo)方法的方法簽名
       Signature signature = pjp.getSignature();
      //獲取方法名
      String name = signature.getName();

	  try {
			//@Before
			System.out.println("【環(huán)繞前置通知】【"+name+"方法開始】");
            //這句相當(dāng)于method.invoke(obj,args)，通過反射來執(zhí)行接口中的方法
			proceed = pjp.proceed();
			//@AfterReturning
			System.out.println("【環(huán)繞返回通知】【"+name+"方法返回，返回值："+proceed+"】");
		} catch (Exception e) {
			//@AfterThrowing
			System.out.println("【環(huán)繞異常通知】【"+name+"方法異常，異常信息："+e+"】");
		}
        finally{
			//@After
			System.out.println("【環(huán)繞后置通知】【"+name+"方法結(jié)束】");
		}
	}

<dependency>
<groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

@Data
public class WebLog {
    /**
     * 操作描述
     */
    private String description;

    /**
     * 操作用戶
     */
    private String username;

    /**
     * 操作時間
     */
    private Long startTime;

    /**
     * 消耗時間
     */
    private Integer spendTime;

    /**
     * 根路徑
     */
    private String basePath;

    /**
     * URI
     */
    private String uri;

    /**
     * URL
     */
    private String url;

    /**
     * 請求類型
     */
    private String method;

    /**
     * IP地址
     */
    private String ip;

    /**
     * 請求參數(shù)
     */
    private Object parameter;

    /**
     * 請求返回的結(jié)果
     */
    private Object result;

}

import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.URLUtil;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
/**
 * 統(tǒng)一日志處理切面
 */
@Aspect
@Component
@Order(1)
@Slf4j
public class WebLogAspect {
 
    //定義切點表達式,指定通知功能被應(yīng)用的范圍
    @Pointcut("execution(public * com.hs.notice.controller.*.*(..))")
    public void webLog() {
    }
 
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
    }
 
    /**value切入點位置
     * returning 自定義的變量，標(biāo)識目標(biāo)方法的返回值,自定義變量名必須和通知方法的形參一樣
     * 特點：在目標(biāo)方法之后執(zhí)行的,能夠獲取到目標(biāo)方法的返回值，可以根據(jù)這個返回值做不同的處理
     */     
    @AfterReturning(value = "webLog()", returning = "ret")
    public void doAfterReturning(Object ret) throws Throwable {
    }
 
    //通知包裹了目標(biāo)方法，在目標(biāo)方法調(diào)用之前和之后執(zhí)行自定義的行為
    //ProceedingJoinPoint切入點可以獲取切入點方法上的名字、參數(shù)、注解和對象
    @Around("webLog()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable 
    {
        long startTime = System.currentTimeMillis();
        //獲取當(dāng)前請求對象
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        //記錄請求信息
        WebLog webLog = new WebLog();

        //前面是前置通知，后面是后置通知
        Object result = joinPoint.proceed();

        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        long endTime = System.currentTimeMillis();
        String urlStr = request.getRequestURL().toString();
        webLog.setBasePath(StrUtil.removeSuffix(urlStr, URLUtil.url(urlStr).getPath()));
        webLog.setIp(request.getRemoteUser());
        webLog.setMethod(request.getMethod());
        webLog.setParameter(getParameter(method, joinPoint.getArgs()));
        webLog.setResult(result);
        webLog.setSpendTime((int) (endTime - startTime));
        webLog.setStartTime(startTime);
        webLog.setUri(request.getRequestURI());
        webLog.setUrl(request.getRequestURL().toString());
        log.info("{}", JSONUtil.parse(webLog));
        return result;
    }
 
    /**
     * 根據(jù)方法和傳入的參數(shù)獲取請求參數(shù)
     */
    private Object getParameter(Method method, Object[] args) 
   {
        List<Object> argList = new ArrayList<>();
        Parameter[] parameters = method.getParameters();
        for (int i = 0; i < parameters.length; i++) {
            //將RequestBody注解修飾的參數(shù)作為請求參數(shù)
            RequestBody requestBody = parameters[i].getAnnotation(RequestBody.class);
            if (requestBody != null) {
                argList.add(args[i]);
            }
            //將RequestParam注解修飾的參數(shù)作為請求參數(shù)
            RequestParam requestParam = parameters[i].getAnnotation(RequestParam.class);
            if (requestParam != null) {
                Map<String, Object> map = new HashMap<>();
                String key = parameters[i].getName();
                if (!StringUtils.isEmpty(requestParam.value())) {
                    key = requestParam.value();
                }
                map.put(key, args[i]);
                argList.add(map);
            }
        }
        if (argList.size() == 0) {
            return null;
        } else if (argList.size() == 1) {
            return argList.get(0);
        } else {
            return argList;
        }
    }
}

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
?* 定義操作日志注解
?*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface OperatorLog 
{
 // 操作
 String operate();

 // 模塊
 String module();
}

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import com.elon.springbootdemo.manager.OperatorLog;
import com.elon.springbootdemo.model.ResponseModel;

/**
 * 操作日志切面定義
 */
@Aspect
@Component
public class OperatorLogApsect {
    
    private static Logger logger = LogManager.getLogger(OperatorLogApsect.class);
    
    @Pointcut("@annotation(com.hs.springbootdemo.aop.OperatorLog)")
    public void operatorLog() {
        
    }
    
    @SuppressWarnings("rawtypes")
    @AfterReturning(returning="result", pointcut="operatorLog()&&@annotation(log)")
    public void afterReturn(JoinPoint joinPoint, ResponseModel result, OperatorLog log) {
        
        /**
         * 接口調(diào)用信息可以記日志，也可以寫到數(shù)據(jù)庫
         */
        StringBuilder sb = new StringBuilder();
        sb.append("模塊：").append(log.module());
        sb.append("|操作:").append(log.operate());
        sb.append("|接口名稱:").append(joinPoint.getSignature().getName());
        sb.append("|錯誤碼:").append(result.getRetCode());
        sb.append("|錯誤信息:").append(result.getErrorMsg());
        logger.info(sb.toString());
    }
}

@RequestMapping(value="/v1/query-user", method=RequestMethod.GET)
@OperatorLog(operate="查詢用戶", module="用戶管理")
public ResponseModel queryUser(@RequestParam(value="user", required=true) String user)?
{
log.info("[INFO]user info:" + user);
log.warn("[WARN]user info:" + user);
log.error("[ERROR]user info:" + user);
return ResponseModel.success(null);
}