java注解结合aspectj AOP进行日志打印的操作

2023-07-05 09:07:03 84

在很多系统开发中，我们希望在指定的方法调用之前或者之后能打印出该方法的调用时间以及方法的出参和入参，就可以使用spring的AOP，还可以结合自定义的注解进行进行一些指定参数的打印

例如：

一个分层的架构系统，每层都有自己的指定系统名字，并且每个方法都有自己指定的作用（通过注解指定，在切面的时候取出该参数），而且可以根据注解的指定日志类型（在注解中指定，在切面的时候取出参数进行判断，然后打印相对应的日志格式）。

1.首先需要自定义注解：

systemName：表示该系统的名称。

bizCode：表示具体的方法描述

logtype：表示日志的格式类型

packagemyspring;
importjava.lang.annotation.ElementType;
importjava.lang.annotation.Retention;
importjava.lang.annotation.RetentionPolicy;
importjava.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public@interfaceLogAnnotation{
StringsystemName();
StringbizCode();
LogTypelogtype()defaultLogType.TIME;
}

2.定义日志格式枚举：

packagemyspring;
publicenumLogType{
TIME("TIME","方法调用时间"),
PARAM("PARAM","参数打印");
privateStringtype;
privateStringdesc;
LogType(Stringtype,Stringdesc){
this.type=type;
this.desc=desc;
}
publicStringgetType(){
returntype;
}
publicvoidsetType(Stringtype){
this.type=type;
}
publicStringgetDesc(){
returndesc;
}
publicvoidsetDesc(Stringdesc){
this.desc=desc;
}
}

3.切面代码：

其中execution(**(..))

第一个*:表示所有返回值

第二个*:表示所有包匹配规则和所有类匹配规则以及所有方法匹配规则

两个点..:表示任何参数匹配

例如：

execution(**..*Service.*(..))

表示任何返回值任何包以Service结尾的类或者实现类的任何方法任何参数

*..:表示所有包

*:Service表示所有以Service结尾的类或者实现类

execution(*cn.lijie.MyService.*(..))

表示任何返回值cn.lijie包下面MyService类或者实现类的所有方法所有参数

代码如下：

packagemyspring;
importcom.alibaba.fastjson.JSON;
importorg.aspectj.lang.ProceedingJoinPoint;
importorg.aspectj.lang.annotation.Around;
importorg.aspectj.lang.annotation.Aspect;
importorg.aspectj.lang.reflect.MethodSignature;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importorg.springframework.stereotype.Component;
importorg.springframework.util.StopWatch;
importorg.springframework.util.StringUtils;
@Component
@Aspect
publicclassLogAspect{
privatestaticLoggerthisLog=LoggerFactory.getLogger(LogAspect.class);
privatestaticLoggertimeLog=LoggerFactory.getLogger(TimeTypeLog.class);
privatestaticLoggerparamLog=LoggerFactory.getLogger(ParamTypeLog.class);
@Around("execution(**(..))&&@annotation(logAnnotation)")
publicObjectlog(ProceedingJoinPointpoint,LogAnnotationlogAnnotation){
StopWatchstop=newStopWatch();
stop.start();
booleanflag=false;
ObjectretValue=null;
try{
retValue=point.proceed();
flag=true;
}catch(Throwablethrowable){
throwable.printStackTrace();
}finally{
stop.stop();
if(logAnnotation.logtype().equals(LogType.TIME)){
timeLog(this.getMethod(point),point,stop.getTotalTimeMillis(),logAnnotation,flag);
}else{
paramLog(this.getMethod(point),point,retValue);
}
}
returnretValue;
}
privatevoidtimeLog(Stringmethod,ProceedingJoinPointpoint,longtotalTimeMillis,LogAnnotationlogAnnotation,booleanflag){
timeLog.info("系统为:{},调用的方法名字:{},调用是否成功:{},运行时间为:{}ms",logAnnotation.systemName(),method,flag,totalTimeMillis);
}
privatevoidparamLog(Stringmethod,ProceedingJoinPointpoint,ObjectretValue){
try{
Stringresult=JSON.toJSONString(retValue);
//获取入参
Object[]args=point.getArgs();
StringBuffersb=newStringBuffer();
for(Objectobj:args){
Stringstr=JSON.toJSONString(obj);
sb.append(subStr(str,200)).append("");
}
paramLog.info("调用方法为:{},入参为:{},出参为:{}",method,sb,subStr(result,200));
}catch(Exceptione){
thisLog.warn("切面日志参数日志打印异常，异常信息：{}",e.getMessage());
}
}
privateStringgetMethod(ProceedingJoinPointpjp){
MethodSignaturemethodSignature=(MethodSignature)pjp.getSignature();
returnmethodSignature.getDeclaringTypeName()+"#"+methodSignature.getMethod().getName();
}
privateStringsubStr(Stringstring,intlength){
if(!StringUtils.isEmpty(string)){
if(string.length()>length){
string=string.substring(0,200);
returnstring;
}
}
returnstring;
}
}

4.定义一个操作对象：

packagemyspring;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importorg.springframework.stereotype.Component;
@Component("logTest")
publicclassLogTest{
privatestaticLoggerlogger=LoggerFactory.getLogger(LogTest.class);
@LogAnnotation(systemName="计算器系统",bizCode="+",logtype=LogType.TIME)
publicinttestLog01(inta,intb){
logger.info("进入+运算");
returna+b;
}
@LogAnnotation(systemName="计算器系统",bizCode="-",logtype=LogType.PARAM)
publicinttestLog02(inta,intb){
logger.info("进入-运算");
returna-b;
}
}

5.定义两个空类，用于区分不同类型的日志：

packagemyspring;
publicclassTimeTypeLog{

packagemyspring;
publicclassParamTypeLog{
}

6.springxml配置文件：

7.启动spring的测试类：

packagemyspring;
importorg.springframework.context.support.AbstractApplicationContext;
importorg.springframework.context.support.ClassPathXmlApplicationContext;
publicclassMain{
publicstaticvoidmain(String[]args){
AbstractApplicationContextcontext=newClassPathXmlApplicationContext("application.xml");
LogTestlogTest=(LogTest)context.getBean("logTest");
logTest.testLog01(1,2);
logTest.testLog02(3,4);
context.registerShutdownHook();
}
}

8.pom


4.3.8.RELEASE



org.springframework
spring-context
${spring_version}


org.springframework
spring-core
${spring_version}


org.springframework
spring-beans
${spring_version}


org.springframework
spring-aop
${spring_version}


org.springframework
spring-test
${spring_version}


org.springframework
spring-aop
${spring_version}


org.aspectj
aspectjrt
1.8.11


org.aspectj
aspectjweaver
1.8.11


org.slf4j
slf4j-api
1.7.21


ch.qos.logback
logback-classic
1.1.7


ch.qos.logback
logback-core
1.1.7


com.alibaba
fastjson
1.2.4

最后执行测试的类，日志打印如下：

补充：springboot自定义注解实现自动打印方法日志（入参和返回值）

pom文件



4.0.0

org.springframework.boot
spring-boot-starter-parent
2.1.4.RELEASE


com.aline
demo
0.0.1-SNAPSHOT
demo
DemoprojectforSpringBoot

1.8



org.springframework.boot
spring-boot-starter-web


org.springframework.boot
spring-boot-starter-aop


com.alibaba
fastjson
1.2.7


org.springframework.boot
spring-boot-starter-test
test





org.springframework.boot
spring-boot-maven-plugin

定义一个日志注解

SysLog.java

packagecom.aline.demo.annotation;
importjava.lang.annotation.*;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public@interfaceSysLog{
}

定义一个日志实例缓存

LoggerCache.class
packagecom.aline.demo.util;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importjava.util.HashMap;
publicclassLoggerCache{
/**
*日志实例记录在内存中
*/
privatestaticHashMapLOGERS=newHashMap();
/**
*根据类名获取缓存的日志实例
*@paramclassName包名加类名this.getClass().getName();
*@return
*/
publicstaticLoggergetLoggerByClassName(StringclassName){
//从静态map中获取日志实例
Loggerlogger=LOGERS.get(className);
//如果没取到
if(logger==null){
//创建一个日志实例
logger=LoggerFactory.getLogger(className);
//加入到静态map中
LOGERS.put(className,logger);
}
//返回
returnlogger;
}
}

定义一个切面实现日志记录

SysLogAspect.java

packagecom.aline.demo.aspect;
importcom.alibaba.fastjson.JSON;
importcom.aline.demo.util.LoggerCache;
importorg.aspectj.lang.ProceedingJoinPoint;
importorg.aspectj.lang.annotation.Around;
importorg.aspectj.lang.annotation.Aspect;
importorg.aspectj.lang.annotation.Pointcut;
importorg.aspectj.lang.reflect.MethodSignature;
importorg.slf4j.Logger;
importorg.springframework.stereotype.Component;
importjava.lang.reflect.Method;
@Aspect
@Component
publicclassSysLogAspect{
@Pointcut("@annotation(com.aline.demo.annotation.SysLog)")
publicvoidlog(){
}
/**
*加入注解自动记录方法日志
*
*@paramjoinPoint
*@return
*@throwsThrowable
*/
@Around(value="log()")
publicObjectlogAround(ProceedingJoinPointjoinPoint)throwsThrowable{
//获取执行方法的类的名称（包名加类名）
StringclassName=joinPoint.getTarget().getClass().getName();
//获取实例和方法
MethodSignaturesignature=(MethodSignature)joinPoint.getSignature();
Methodmethod=signature.getMethod();
//从缓存中获取日志实例
Loggerlog=LoggerCache.getLoggerByClassName(className);
//记录日志
log.info(className+"."+method.getName()+"()执行");
Object[]args=joinPoint.getArgs();
log.info("Params\t===》\t"+JSON.toJSONString(args));
//执行方法获取返回值
Objectproceed=joinPoint.proceed();
//记录日志
log.info("Returns\t===》\t"+JSON.toJSONString(proceed));
//返回
returnproceed;
}
}

写个controller测试

TestController.java

packagecom.aline.demo.controller;
importcom.aline.demo.annotation.SysLog;
importcom.aline.demo.util.LoggerCache;
importorg.slf4j.Logger;
importorg.springframework.web.bind.annotation.GetMapping;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RestController;
importjava.text.SimpleDateFormat;
importjava.util.Date;
@RestController
@RequestMapping("/test")
publicclassTestController{
staticSimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddhh:mm:ss");
@GetMapping("/now")
publicStringnow(){
//从缓存中获取日志
LoggerLOG=LoggerCache.getLoggerByClassName(this.getClass().getName());
LOG.info("自定义日志==》日志内容。。。");
returnsdf.format(newDate());
}
@GetMapping("/hello")
@SysLog()
publicStringhello(Stringname){
return"Hello,"+name;
}
}

访问http://localhost:8080/test/hello?name=aline

打印日志：

2019-05-0916:58:20.410INFO40004---[nio-8080-exec-1]c.aline.demo.controller.TestController:com.aline.demo.controller.TestController.hello()执行，参数==》
2019-05-0916:58:20.584INFO40004---[nio-8080-exec-1]c.aline.demo.controller.TestController:Params===》["aline"]
2019-05-0916:58:20.598INFO40004---[nio-8080-exec-1]c.aline.demo.controller.TestController:Returns===》"Hello,aline"

访问http://localhost:8080/now