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() + " 出现异常");
	}
}