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

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

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

例如：

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

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

systemName：表示该系统的名称。

bizCode：表示具体的方法描述

logtype：表示日志的格式类型

package myspring;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.METHOD})

public @interface LogAnnotation {

String systemName();

String bizCode();

LogType logtype() default LogType.TIME;

}

2.定义日志格式枚举：

package myspring;

public enum LogType {

TIME("TIME", "方法调用时间"),

PARAM("PARAM", "参数打印");

private String type;

private String desc;

LogType(String type, String desc) {

this.type = type;

this.desc = desc;

}

public String getType() {

return type;

}

public void setType(String type) {

this.type = type;

}

public String getDesc() {

return desc;

}

public void setDesc(String desc) {

this.desc = desc;

}

3.切面代码：

其中execution(* *(..))

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

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

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

例如：

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

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

*.. :表示所有包

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

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

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

代码如下：

package myspring;

import com.alibaba.fastjson.JSON;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.reflect.MethodSignature;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Component;

import org.springframework.util.StopWatch;

import org.springframework.util.StringUtils;

@Component

@Aspect

public class LogAspect {

private static Logger thisLog = LoggerFactory.getLogger(LogAspect.class);

private static Logger timeLog = LoggerFactory.getLogger(TimeTypeLog.class);

private static Logger paramLog = LoggerFactory.getLogger(ParamTypeLog.class);

@Around("execution(* *(..)) && @annotation(logAnnotation)")

public Object log(ProceedingJoinPoint point, LogAnnotation logAnnotation) {

StopWatch stop = new StopWatch();

stop.start();

boolean flag = false;

Object retValue = null;

try {

retValue = point.proceed();

flag = true;

} catch (Throwable throwable) {

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);

}

return retValue;

}

private void timeLog(String method, ProceedingJoinPoint point, long totalTimeMillis, LogAnnotation logAnnotation, boolean flag) {

timeLog.info("系统为:{},调用的方法名字:{},调用是否成功:{},运行时间为:{}ms", logAnnotation.systemName(), method, flag, totalTimeMillis);

}

private void paramLog(String method, ProceedingJoinPoint point, Object retValue) {

try {

String result = JSON.toJSONString(retValue);

//获取入参

Object[] args = point.getArgs();

StringBuffer sb = new StringBuffer();

for (Object obj : args) {

String str = JSON.toJSONString(obj);

sb.append(subStr(str, 200)).append(" ");

}

paramLog.info("调用方法为:{},入参为:{},出参为:{}", method, sb, subStr(result, 200));

} catch (Exception e) {

thisLog.warn("切面日志参数日志打印异常，异常信息：{}", e.getMessage());

}

private String getMethod(ProceedingJoinPoint pjp) {

MethodSignature methodSignature = (MethodSignature) pjp.getSignature();

return methodSignature.getDeclaringTypeName() + "#" + methodSignature.getMethod().getName();

}

private String subStr(String string, int length) {

if (!StringUtils.isEmpty(string)) {

if (string.length() > length) {

string = string.substring(0, 200);

return string;

}

return string;

}

4.定义一个操作对象：

package myspring;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Component;

@Component("logTest")

public class LogTest {

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

@LogAnnotation(systemName = "计算器系统", bizCode = "+", logtype = LogType.TIME)

public int testLog01(int a, int b) {

logger.info("进入+运算");

return a + b;

}

@LogAnnotation(systemName = "计算器系统", bizCode = "-", logtype = LogType.PARAM)

public int testLog02(int a, int b) {

logger.info("进入-运算");

return a - b;

}

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

package myspring;

public class TimeTypeLog {

package myspring;

public class ParamTypeLog {

}

6.spring xml配置文件：

7.启动spring的测试类：

package myspring;

import org.springframework.context.support.AbstractApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

public static void main(String[] args) {

AbstractApplicationContext context = new ClassPathXmlApplicationContext("application.xml");

LogTest logTest = (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

shttp://pring-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

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

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

pom文件

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http:http:////maven.apache.org/xsd/maven-4.0.0.xsd">

4.0.0

org.springframework.boot

spring-boot-starter-parent

2.1.4.RELEASE

com.aline

demo

0.0.1-SNAPSHOT

demo

Demo project for Spring Boot

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

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http:http:////maven.apache.org/xsd/maven-4.0.0.xsd">

4.0.0

org.springframework.boot

spring-boot-starter-parent

2.1.4.RELEASE

com.aline

demo

0.0.1-SNAPSHOT

demo

Demo project for Spring Boot

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

package com.aline.demo.annotation;

import java.lang.annotation.*;

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface SysLog {

}

定义一个日志实例缓存

LoggerCache.class

package com.aline.demo.util;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import java.util.HashMap;

public class LoggerCache {

/**

* 日志实例记录在内存中

private static HashMap LOGERS = new HashMap();

/**

* 根据类名获取缓存的日志实例

* @param className 包名加类名 this.getClass().getName();

* @return

public static Logger getLoggerByClassName(String className) {

// 从静态map中获取日志实例

Logger logger = LOGERS.get(className);

// 如果没取到

if (logger == null) {

// 创建一个日志实例

logger = LoggerFactory.getLogger(className);

// 加入到静态map中

LOGERS.put(className, logger);

}

// 返回

return logger;

}

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

SysLogAspect.java

package com.aline.demo.aspect;

import com.alibaba.fastjson.JSON;

import com.aline.demo.util.LoggerCache;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Pointcut;

import org.aspectj.lang.reflect.MethodSignature;

import org.slf4j.Logger;

import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect

@Component

public class SysLogAspect {

@Pointcut("@annotation(com.aline.deCaTiADVmo.annotation.SysLog)")

public void log() {

}

/**

* 加入注解自动记录方法日志

* @param joinPoint

* @return

* @throws Throwable

@Around(value = "log()")

public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {

// 获取执行方法的类的名称（包名加类名）

String className = joinPoint.getTarget().getClass().getName();

// 获取实例和方法

MethodSignature signature = (MethodSignature) joinPoint.getSignature();

Method method = signature.getMethod();

// 从缓存中获取日志实例

Logger log = LoggerCache.getLoggerByClassName(className);

// 记录日志

log.info(className + "." + method.getName() + "() 执行");

Object[] args = joinPoint.getArgs();

log.info("Params\t===》\t" + JSON.toJSONString(args));

// 执行方法获取返回值

Object proceed = joinPoint.proceed();

// 记录日志

log.info("Returns\t===》\t" + JSON.toJSONString(proceed));

// 返回

return proceed;

}

写个controller测试

TestController.java

package com.aline.demo.controller;

import com.aline.demo.annotation.SysLog;

import com.aline.demo.util.LoggerCache;

import org.slf4j.Logger;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import java.text.SimpleDateFormat;

import java.util.Date;

@RestController

@RequestMapping("/test")

public class TestController {

static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

@GetMapping("/now")

public String now(){

// 从缓存中获取日志

LCaTiADVogger LOG = LoggerCache.getLoggerByClassName(this.getClass().getName());

LOG.info("自定义日志 ==》日志内容。。。");

return sdf.format(new Date());

}

@GetMapping("/hello")

@SysLog()

public String hello(String name){

return "Hello, " + name;

}

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

打印日志：

2019-05-09 16:58:20.410 INFO 40004 --- [nio-8080-exec-1] c.aline.demo.controller.TestController : com.aline.demo.controller.TestController.hello() 执行，参数 ==》

2019-05-09 16:58:20.584 INFO 40004 --- [nio-8080-exec-1] c.aline.demo.controller.TestController : Params ===》 ["aline"]

2019-05-09 16:58:20.598 INFO 40004 --- [nio-8080-exec-1] c.aline.demo.controller.TestController : Returns ===》 "Hello, aline"

访问 http://localhost:8080/now

打印日志：

2019-05-09 16:58:29.208 INFO 40004 --- [nio-8080-exec-3] c.aline.demo.controller.TestController : 自定义日志 ==》日志内容。。。

Linux中怎么用cat命令创建文件并写入数据

246 2023-01-30

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

linux怎么查看本机内存大小

linux cpu占用率如何看

Linux中怎么用cat命令创建文件并写入数据

推荐文章

api接口有哪几种分类及功能

什么是API接口?API接口简单介绍

短信API接口概述，短信API接口的优势

7款快递物流的物流查询API工具，物流快递查询API接口怎么对接？

企业四要素: 了解企业经营成功的关键

什么是语音验证码?,语音验证码平台有哪些

全国工商查询系统怎么查企业名录

哪些平台提供实名认证的接口？

PHP如何调用API接口?

如何使用百度天气预报API接口?

最近发表

热评文章

数据接口api（数据接口API开发平台）

数据开放接口api（数据服务api开发）

Python爬虫教程：爬取酷狗音乐（python爬取

hbuilder怎么更改字体大小和颜色

直播平台api接口 - 构建卓越的直播平台

实时股票数据api接口（股票实时行情api接口）