1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.test.common.annotation;
import java.lang.annotation.*;
/**
* 类注解 日志记录
* 其他模块调用时注意问题：
* 1.xml是否引入common模块
* 2.xml和yml是否引入和配置mongo
* 3.是否放入Shiro否则用户信息为空
*/
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ClassRecord {
// 记录的补充备注
String note() default "";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.test.common.annotation;
import java.lang.annotation.*;
/**
* 方法审计 注解
* 其他模块调用时注意问题：
* 1.xml是否引入common模块
* 2.xml和yml是否引入和配置mongo
* 3.是否放入Shiro否则用户信息为空
*/
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodRecord {
String note() default "";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
package com.test.common.Aop;
import com.alibaba.fastjson.JSONObject;
import com.test.common.annotation.ClassRecord;
import com.test.common.annotation.MethodRecord;
import com.test.common.utils.ConstantsUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang.time.DateFormatUtils;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Date;
/**
* 记录跟踪的自定义切面yq
*/
@Component
@Aspect
public class RecordAspect {
// 访问的类
private Class clazz;
// 访问的方法
private Method method;
@Autowired
private MongoTemplate mongoTemplate;
// 方法切入点
详情-切点表达式
@Pointcut("@annotation(com.test.common.annotation.MethodRecord)")
private void annotationMethod(){}
// 类切入点
@Pointcut("@within(com.test.common.annotation.ClassRecord)")
private void annotationClass(){}
// 前置通知 - 方法切入点
@Before("annotationMethod()")
private void methodBefore(JoinPoint joinPoint) throws Exception{
saveObj(joinPoint, "Method");
}
// 前置通知 - 类切入点
@Before("annotationClass()")
private void classBefore(JoinPoint joinPoint) throws Exception{
saveObj(joinPoint, "Class");
}
// 保存日志记录
private void saveObj(JoinPoint joinPoint, String type) throws Exception{
clazz = joinPoint.getTarget().getClass();
ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = requestAttributes.getRequest();
String requestMethod = request.getMethod();
Date date = new Date();
String nowTime = DateFormatUtils.format(date, "yyyy-MM-dd HH:mm:ss");
JSONObject recordObj = new JSONObject();
// 请求时间
recordObj.put("time", nowTime);
// 访问Ip
recordObj.put("visitIp", getIpAddr(request));
// 服务Ip
recordObj.put("serverIp", request.getRemoteAddr());
// 请求人
recordObj.put("remoteUser", request.getRemoteUser());
// 请求地址
recordObj.put("uri", request.getRequestURI());
recordObj.put("url", request.getRequestURL());
// 请求方式
recordObj.put("method", requestMethod);
// 请求类方法
recordObj.put("signature", joinPoint.getSignature());
// 请求类方法参数
recordObj.put("args", Arrays.toString(joinPoint.getArgs()));
// 日志审计备注
if ("Method".equals(type)) {
String methodName = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();
if (args == null || args.length == 0) {
method = clazz.getMethod(methodName);
} else {
Class[] argsClasses = new Class[args.length];
for (int i = 0; i < args.length; i++) {
argsClasses[i] = args[i].getClass();
}
method = clazz.getMethod(methodName, argsClasses);
}
// 方法注解
recordObj.put("note", method.getAnnotation(MethodRecord.class).note());
mongoTemplate.save(recordObj.toJSONString(), ConstantsUtils.INFRA_RECORD);
}
if ("Class".equals(type)) {
// 类注解
ClassRecord classRecord = (ClassRecord) clazz.getAnnotation(ClassRecord.class);
recordObj.put("note", classRecord.note());
mongoTemplate.save(recordObj.toJSONString(), ConstantsUtils.INFRA_RECORD);
}
// 临时打印
System.out.println("=================== 日志开始 ===================");
System.out.println("请求时间: " + nowTime);
System.out.println("访问Ip: " + getIpAddr(request));
System.out.println("服务Ip: " + request.getRemoteAddr());
System.out.println("用户信息: " + request.getRemoteUser());
System.out.println("请求地址URI: " + request.getRequestURI());
System.out.println("请求地址URL: " + request.getRequestURL());
System.out.println("请求方式: " + requestMethod);
System.out.println("请求类方法: " + joinPoint.getSignature());
System.out.println("请求类方法参数: " + Arrays.toString(joinPoint.getArgs()));
System.out.println("日志备注: " + recordObj.get("note"));
System.out.println("=================== 日志结束 ===================");
}
// 获取访问IP
private String getIpAddr(HttpServletRequest request) {
String ip = request.getHeader("x-forwarded-for");
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
}
// 后置通知
//
@After("annotationMethod()")
//
private void methodAfter() {}
}

1
2
3
4
5
6

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

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.test.common.Aop;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
/**
* aop配置类
* spring 需要添加此注解类才能生效
* springboot有自动配置
*/
@Configuration
@EnableAspectJAutoProxy
public class ConfigAop {
}

1
2
3
4
5
6
7
8

@MethodRecord(note = "删除备注123")
@DeleteMapping("/delStorages/{ids}")
public ResponseEntity<Void> delStorages(@PathVariable String ids) throws Exception {
storageService.delStorages(ids);
return ResponseEntity.status(HttpStatus.OK).build();
}

1
2
3
4
5
6
7
8
9
@RestController
@CrossOrigin(origins = "*", maxAge = 3600)
@ClassRecord
//
<--- 注解在这里
@RequestMapping("/storage")
public class StorageController {
}