SpringBoot AOP自定义注解实现日志功能

首先我们为什么需要做日志管理,在现实的上线中我们经常会遇到系统出现异常或者问题。 这个时候就马上打开CRT或者SSH连上服务器拿日子来分析。受网络的各种限制。于是我们就想为什么不能直接在管理后台查看报错的信息呢。于是日志管理就出现了。其次个人觉得做日志管理最好的是Aop,有的人也喜欢用拦截器。都可以,在此我重点介绍我的实现方式。
依赖

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

首先创建一个@interface的注解类

package org.mao.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface SysLog {
String value() default "";
}

@Documented –注解是否将包含在JavaDoc中

@Retention –什么时候使用该注解

@Target –注解用于什么地方

@Inherited – 是否允许子类继承该注解

1.)@Retention– 定义该注解的生命周期

● RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义,所以它们不会写入字节码。

@Override, @SuppressWarnings都属于这类注解。

● RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式

● RetentionPolicy.RUNTIME : 始终不会丢弃,运行期也保留该注解,因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。

2.)@Target 表示该注解用于什么地方。默认值为任何元素,表示该注解用于什么地方。可用的ElementType参数包括

● ElementType.CONSTRUCTOR:用于描述构造器

● ElementType.FIELD:成员变量、对象、属性(包括enum实例)

● ElementType.LOCAL_VARIABLE:用于描述局部变量

● ElementType.METHOD:用于描述方法

● ElementType.PACKAGE:用于描述包

● ElementType.PARAMETER:用于描述参数

● ElementType.TYPE:用于描述类、接口(包括注解类型) 或enum声明

3.)@Documented–一个简单的Annotations标记注解,表示是否将注解信息添加在java文档中。

4.)@Inherited 定义该注释和子类的关系

[@Inherited ]() 元注解是一个标记注解,@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class,则这个annotation将被用于该class的子类。

然后呢在controller中使用注解

package org.mao.controller;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.mao.annotation.SysLog;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

@SysLog("我是昴先生")
@RequestMapping("/index")
public String hello() {
return "hello word";
}

@SysLog("我是快乐鱼")
@RequestMapping("/main")
public Map<String, Object> main() {
Map<String, Object> map = new HashMap<>();
List<String> list = new ArrayList<>();
list.add("wo de");
map.put("task", 123);
map.put("task", list);
return map;
}

}

最后用下aop反射得到注解中的值

package org.mao.aop;

import java.lang.reflect.Method;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
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.mao.annotation.SysLog;
import org.springframework.stereotype.Component;
@SuppressWarnings("all")
@Aspect // AOP 切面
@Component
public class MyLogAspect {
// 切入点
@Pointcut(value = "@annotation(org.mao.annotation.SysLog)")
private void pointcut() {
}

/**
* 在方法执行前后
*
* @param point
* @param myLog
* @return
*/
@Around(value = "pointcut() && @annotation(sysLog)")
public Object around(ProceedingJoinPoint point, SysLog sysLog) {
System.out.println("++++执行了around方法++++");
String requestUrl = sysLog.value();
// 拦截的类名
Class clazz = point.getTarget().getClass();
// 拦截的方法
Signature sig = point.getSignature();
MethodSignature msig = null;
if (!(sig instanceof MethodSignature)) {
throw new IllegalArgumentException("该注解只能用于方法");
}
msig = (MethodSignature) sig;
Object target = point.getTarget();
Method currentMethod;
try {
currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
System.out.println("执行了类:" + clazz.getSimpleName());
System.out.println("方法:" + currentMethod.getName());
System.out.println("自定义注解:" + requestUrl);
} catch (Exception e) {
e.printStackTrace();
}
try {
return point.proceed(); // 执行程序
} catch (Throwable throwable) {
throwable.printStackTrace();
return throwable.getMessage();
}
}

/**
* 方法执行后
*
* @param joinPoint
* @param myLog
* @param result
* @return
*/
@AfterReturning(value = "pointcut() && @annotation(sysLog)", returning = "result")
public Object afterReturning(JoinPoint joinPoint, SysLog sysLog, Object result) {
// HttpServletRequest request = ((ServletRequestAttributes)
// RequestContextHolder.getRequestAttributes()).getRequest();
// HttpSession session = request.getSession();
System.out.println("++++执行了afterReturning方法++++");
System.out.println("执行结果:" + result);
return result;
}

/**
* 方法执行后 并抛出异常
*
* @param joinPoint
* @param myLog
* @param ex
*/
@AfterThrowing(value = "pointcut() && @annotation(sysLog)", throwing = "ex")
public void afterThrowing(JoinPoint joinPoint, SysLog sysLog, Exception ex) {
System.out.println("++++执行了afterThrowing方法++++");
System.out.println("请求:" + sysLog.value() + " 出现异常");
}
}