Spring AOP来自定义注解实现审计或日志记录（完整代码）

本是古典何须时尚 2022-01-09 07:03 170阅读 0赞

### 环境准备 ###

JDK 1.8，Springboot 2.1.3.RELEASE，spring-boot-starter-aop.2.1.4.RELEASE.jar，aspectjrt.1.9.2.jar，aspectjweaver.1.9.2.jar，pom依赖如下：

<dependency>
    	 <groupId>org.springframework.boot</groupId>
    	 <artifactId>spring-boot-starter-aop</artifactId>
    	 <version>2.1.4.RELEASE</version>
    </dependency>
    <dependency>
    	<groupId>org.aspectj</groupId>
    	<artifactId>aspectjrt</artifactId>
    	<version>1.9.2</version>
    </dependency>
    <dependency>
    	<groupId>org.aspectj</groupId>
    	<artifactId>aspectjweaver</artifactId>
    	<version>1.9.2</version>
    </dependency>

### 项目结构 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6ZWhhbw_size_16_color_FFFFFF_t_70][]

### 自定义审计注解 ###

package com.cjia.common.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Retention(value = RetentionPolicy.RUNTIME)
    @Target(value = { ElementType.METHOD })
    public @interface Audit {
    
    	/**
    	 * 模块代码
    	 */
    	int moudleCode() default -1;
    	
    	/**
    	 * 扩展信息，用户返回操作类型及参数
    	 */
    	Class<?> extension();
    }

### 定义切面类 ###

package com.cjia.common.aspect;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Method;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    
    import javax.servlet.http.HttpServletRequest;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.After;
    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.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import com.cjia.common.Moudle;
    import com.cjia.common.Operate;
    import com.cjia.common.annotation.Audit;
    import com.cjia.common.reflect.BaseValueReturn;
    import com.cjia.model.AuditMessage;
    import com.cjia.model.ResponseContent;
    import com.cjia.model.User;
    import com.cjia.service.AuditService;
    import com.cjia.service.UserService;
    
    @Aspect
    @Component
    public class AuditAop {
    
    	private static final Logger LOGGER = LoggerFactory.getLogger(AuditAop.class);
    	@Autowired
    	private AuditService auditService;
    	@Autowired
    	private UserService userService;
    	// 操作发起者
    	ThreadLocal<User> user = new ThreadLocal<>();
    	// 操作应用
    	ThreadLocal<Integer> appId = new ThreadLocal<>();
    	// 功能模块
    	ThreadLocal<Integer> moudleCode = new ThreadLocal<>();
    	// 操作类型
    	ThreadLocal<Integer> operateType = new ThreadLocal<>();
    	// IP地址
    	ThreadLocal<String> ip = new ThreadLocal<>();
    	// 操作时间点
    	ThreadLocal<String> operateTime = new ThreadLocal<>();
    	// 操作信息实体
    	ThreadLocal<AuditMessage> msg = new ThreadLocal<>();
    	// 对CIS，额外的菜单id信息extension
    	ThreadLocal<String> extension = new ThreadLocal<>();
    
    	// 声明AOP切入点
    	@Pointcut("@annotation(com.cjia.common.annotation.Audit)")
    	public void audit() {
    	}
    
    	@Before("audit()")
    	public void beforeExec(JoinPoint joinPoint) {
    	}
    
    	@After("audit()")
    	public void afterExec(JoinPoint joinPoint) {
    	}
    
    	@Around("audit()")
    	public Object aroundExec(ProceedingJoinPoint pjp) throws Throwable {
    		try {
    			HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    			extension.set(request.getParameter("extension"));
    			operateTime.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    			ip.set(getIpAddr(request));
    			appId.set(Integer.valueOf(request.getParameter("appId")));
    
    			MethodSignature ms = (MethodSignature) pjp.getSignature();
    			Method method = ms.getMethod();
    			// 获取注解的参数信息
    			Audit auditAnno = method.getAnnotation(Audit.class);
    			moudleCode.set(auditAnno.moudleCode());
    			Class<?> external = auditAnno.extension();
    			Constructor<?> cons = external.getConstructor(Integer.class, HttpServletRequest.class);
    			BaseValueReturn bvr = (BaseValueReturn) cons.newInstance(moudleCode.get(), request);
    			Map<String, Object> reqInfo = bvr.getRequestInfo();
    			Integer operate_type = Integer.valueOf(reqInfo.get(BaseValueReturn.OPT) + "");
    			operateType.set(operate_type);
    			Object target = reqInfo.get(BaseValueReturn.TARGET);
    			// 获取当前登录的用户，需注意：登录时没有msgKey
    			String msgKey = request.getParameter("msgKey");
    			User loginUser = null;
    			if (operate_type.equals(Operate.LOGIN)) {
    				List<User> users = userService.selectByEmail(String.valueOf(target));
    				if (users != null && !users.isEmpty()) {
    					loginUser = users.get(0);
    				}
    			} else if (msgKey != null) {
    				loginUser = userService.selectMsgFromRedisPurely(msgKey);
    			}
    			user.set(loginUser);
    
    			AuditMessage am = new AuditMessage();
    			// am.setUserId需判空，代表过期
    			if (loginUser != null) {
    				am.setUserId(loginUser.getId());
    			} else {
    				am.setUserId(-1);
    			}
    			am.setAppId(appId.get());
    			am.setMoudleCode(moudleCode.get());
    			am.setOperateType(operateType.get());
    			am.setIp(ip.get());
    			am.setOperateTime(operateTime.get());
    			// TODO details=target
    			String details = "";
    			if (moudleCode.get() == Moudle.DATA && loginUser != null) {
    				details = (String) target;
    			} else {
    				// TODO 其他模块
    			}
    			am.setTarget(details);
    			msg.set(am);
    		} catch (Exception e) {
    			LOGGER.error("Error occured while auditing, cause by: ", e);
    		}
    		Object rtn = pjp.proceed();
    		return rtn;
    	}
    
    	/**
    	 * 带参返回
    	 */
    	@AfterReturning(pointcut = "audit()", returning = "rc")
    	public void doAfterReturning(ResponseContent rc) {
    		try {
    			// 返回码SUCCESS才去审计记录
    			if (ResponseContent.RESPCODE_SUCCESS.equals(rc.getRespCode())) {
    				if (null == msg.get() && extension.get() != null) {
    					LOGGER.warn("Warning occured, because msg is null!");
    				} else if (!(operateType.get() == Operate.FETCH_DATA
    						&& (extension.get() == null || extension.get().isEmpty()))) {
    					auditService.insert(msg.get());
    				}
    			}
    		} catch (Exception e) {
    			LOGGER.warn("Warning occured while afterReturning, cause by: ", e);
    		}
    	}
    
    	/**
    	 * 不带参返回
    	 */
    	@AfterReturning(pointcut = "audit()")
    	public void doAfterReturning(JoinPoint joinPoint) {
    		LOGGER.debug("afterReturning without returnType..");
    	}
    
    	@AfterThrowing(pointcut = "audit()", throwing = "e")
    	public void doAfterThrowing(JoinPoint joinPoint, Throwable e) {
    		LOGGER.error("Error occured, cause by {}", e.getMessage());
    	}
    
    	private String getRemoteHost(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 ip.equals("0:0:0:0:0:0:0:1") ? "127.0.0.1" : ip;
    	}
    
    	/** 
         * 获取用户真实IP地址，不使用request.getRemoteAddr()的原因是有可能用户使用了代理软件方式避免真实IP地址, 
         * 可是，如果通过了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP值 
         *  
         * @return ip
         */
        private String getIpAddr(HttpServletRequest request) {
            String ip = request.getHeader("x-forwarded-for"); 
            if (ip != null && ip.length() != 0 && !"unknown".equalsIgnoreCase(ip)) {  
                // 多次反向代理后会有多个ip值，第一个ip才是真实ip
                if( ip.indexOf(",")!=-1 ){
                    ip = ip.split(",")[0];
                }
            }  
            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.getHeader("HTTP_CLIENT_IP");  
            }  
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {  
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");  
            }  
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {  
                ip = request.getHeader("X-Real-IP");  
            }  
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {  
                ip = request.getRemoteAddr();  
            } 
            return ip;  
        }
    
    }

**注意事项**

> 第81行的**HttpServletRequest request**最好设置为局部变量，或**ThreadLocal**修饰的成员变量，而非普通成员变量，防止异步请求较多，导致有的**request丢失参数**的离奇问题。

### 定义返回值处理基类 ###

package com.cjia.common.reflect;
    
    import java.util.Map;
    
    import javax.servlet.http.HttpServletRequest;
    
    public abstract class BaseValueReturn {
    	public static final String OPT = "operate";
    	public static final String TARGET = "target";
    
    	protected Integer moudleCode;
    	protected HttpServletRequest request;
    
    	public BaseValueReturn(Integer moudleCode, HttpServletRequest request) {
    		super();
    		this.moudleCode = moudleCode;
    		this.request = request;
    	}
    
    	/**
    	 * 返回操作动作operate和操作目标target
    	 */
    	public abstract Map<String, Object> getRequestInfo();
    }

### 定义返回值处理子类 ###

package com.cjia.common.reflect;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import javax.servlet.http.HttpServletRequest;
    
    import com.cjia.common.Operate;
    
    public class DataValueReturn extends BaseValueReturn {
    
    	public DataValueReturn(Integer moudleCode, HttpServletRequest request) {
    		super(moudleCode, request);
    	}
    
    	@Override
    	public Map<String, Object> getRequestInfo() {
    		Map<String, Object> info = new HashMap<>();
    		info.put(OPT, Operate.FETCH_DATA);
    		String menuId = request.getParameter("extension");
    		info.put(TARGET, menuId);
    		return info;
    	}
    
    }

package com.cjia.common.reflect;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import javax.servlet.http.HttpServletRequest;
    
    import com.cjia.common.Operate;
    
    public class LoginValueReturn extends BaseValueReturn {
    
    	public LoginValueReturn(Integer moudleCode, HttpServletRequest request) {
    		super(moudleCode, request);
    	}
    
    	@Override
    	public Map<String, Object> getRequestInfo() {
    		Map<String, Object> info = new HashMap<>();
    		info.put(OPT, Operate.LOGIN);
    		String email = request.getParameter("email");
    		info.put(TARGET, email);
    		return info;
    	}
    
    }

### 定义功能模块类 ###

package com.cjia.common;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class Moudle {
    
    	public static final int LOGIN = 1;
    	public static final int DATA = 2;
    	public static final int USER = 3;
    	// TODO more moudles
    	
    	private static final Map<Integer, String> moudleMap = new HashMap<>();
    	static {
    		moudleMap.put(Moudle.LOGIN, "登录");
    		moudleMap.put(Moudle.DATA, "业务数据");
    		moudleMap.put(Moudle.USER, "用户");
    	}
    	
    	public static String getNameByCode(int code) {
    		return moudleMap.get(code);
    	}
    }

### 定义操作类 ###

package com.cjia.common;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class Operate {
    
    	public static final int LOGIN = 1;
    	// 内部系统获取数据
    	public static final int FETCH_DATA = 2;
    	public static final int INSERT = 3;
    	public static final int DELETE = 4;
    	public static final int UPDATE = 5;
    	public static final int SEARCH = 6;
    	// TODO more opts
    	
    	private static final Map<Integer, String> optMap = new HashMap<>();
    	static {
    		optMap.put(Operate.LOGIN, "登录");
    		optMap.put(Operate.FETCH_DATA, "获取业务数据");
    		optMap.put(Operate.INSERT, "新增");
    		optMap.put(Operate.DELETE, "删除");
    		optMap.put(Operate.UPDATE, "修改");
    		optMap.put(Operate.SEARCH, "查询");
    	}
    	
    	public static String getNameByCode(int code) {
    		return optMap.get(code);
    	}
    }

### 定义审计信息实体类 ###

package com.cjia.model;
    
    public class AuditMessage {
    
    	private int id;
    	private int userId;
    	private int appId;
    	private int moudleCode;
    	private int operateType;
    	private String ip;
    	private String operateTime;
    	private String target;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public int getUserId() {
    		return userId;
    	}
    
    	public void setUserId(int userId) {
    		this.userId = userId;
    	}
    
    	public int getAppId() {
    		return appId;
    	}
    
    	public void setAppId(int appId) {
    		this.appId = appId;
    	}
    
    	public int getMoudleCode() {
    		return moudleCode;
    	}
    
    	public void setMoudleCode(int moudleCode) {
    		this.moudleCode = moudleCode;
    	}
    
    	public int getOperateType() {
    		return operateType;
    	}
    
    	public void setOperateType(int operateType) {
    		this.operateType = operateType;
    	}
    
    	public String getIp() {
    		return ip;
    	}
    
    	public void setIp(String ip) {
    		this.ip = ip;
    	}
    
    	public String getOperateTime() {
    		return operateTime;
    	}
    
    	public void setOperateTime(String operateTime) {
    		this.operateTime = operateTime;
    	}
    
    	public String getTarget() {
    		return target;
    	}
    
    	public void setTarget(String target) {
    		this.target = target;
    	}
    
    	@Override
    	public String toString() {
    		return "AuditMessage [id=" + id + ", userId=" + userId + ", appId=" + appId + ", moudleCode=" + moudleCode
    				+ ", operateType=" + operateType + ", ip=" + ip + ", operateTime=" + operateTime + ", target=" + target
    				+ "]";
    	}
    
    }

### 书写mapper文件 ###

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.cjia.dao.AuditMessageMapper">
    
    	<resultMap id="BaseResultMap" type="com.cjia.model.AuditMessage">
    		<result column="id" jdbcType="INTEGER" property="id" />
    		<result column="user_id" jdbcType="VARCHAR" property="userId" />
    		<result column="app_id" jdbcType="VARCHAR" property="appId" />
    		<result column="moudle_code" jdbcType="VARCHAR" property="moudleCode" />
    		<result column="operate_type" jdbcType="INTEGER" property="operateType" />
    		<result column="ip" jdbcType="VARCHAR" property="ip" />
    		<result column="operate_time" jdbcType="INTEGER" property="operateTime" />
    		<result column="target" jdbcType="VARCHAR" property="target" />
    	</resultMap>
    
    	
    	<sql id="keys">
    		<trim suffixOverrides=",">
    			<if test="id!=null and id!=''">
    				id,
    			</if>
    			<if test="userId!=null and userId!=''">
    				user_id,
    			</if>
    			<if test="appId!=null and appId!=''">
    				app_id,
    			</if>
    			<if test="moudleCode!=null and moudleCode!=''">
    				moudle_code,
    			</if>
    			<if test="operateType!=null and operateType!=''">
    				operate_type,
    			</if>
    			<if test="ip!=null and ip!=''">
    				ip,
    			</if>
    			<if test="operateTime!=null and operateTime!=''">
    				operate_time,
    			</if>
    			<if test="target!=null and target!=''">
    				target,
    			</if>
    		</trim>
    	</sql>
    
    	
    	<sql id="values">
    		<trim suffixOverrides=",">
    			<if test="id!=null and id!=''">
    				#{id},
    			</if>
    			<if test="userId!=null and userId!=''">
    				#{userId},
    			</if>
    			<if test="appId!=null and appId!=''">
    				#{appId},
    			</if>
    			<if test="moudleCode!=null and moudleCode!=''">
    				#{moudleCode},
    			</if>
    			<if test="operateType!=null and operateType!=''">
    				#{operateType},
    			</if>
    			<if test="ip!=null and ip!=''">
    				#{ip},
    			</if>
    			<if test="operateTime!=null and operateTime!=''">
    				#{operateTime},
    			</if>
    			<if test="target!=null and target!=''">
    				#{target},
    			</if>
    		</trim>
    	</sql>
    	<insert id="insert" parameterType="com.cjia.model.AuditMessage">
    		insert into audit_message(
    		<include refid="keys" />
    		)
    		values(
    		<include refid="values" />
    		)
    	</insert>
    
    	<select id="selectAll" resultMap="BaseResultMap">
    		select * from audit_message
    	</select>
    
    </mapper>

### 开启AOP拦截 ###

package com.cjia;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    
    @SpringBootApplication
    @MapperScan("com.cjia.dao")
    @EnableAspectJAutoProxy(exposeProxy=true)
    public class DataserviceApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(DataserviceApplication.class, args);
    	}
    
    }

或在配置文件中：

<aop:aspectj-autoproxy proxy-target-class="true" /> 
    <mvc:annotation-driven />
    
    <context:component-scan base-package="**.common" >
    	 <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

### 注解配置 ###

package com.cjia.controller;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    
    import javax.servlet.http.HttpServletRequest;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import com.alibaba.fastjson.JSON;
    import com.cjia.common.InnerApp;
    import com.cjia.common.Moudle;
    import com.cjia.common.ResConstance.UserGroup;
    import com.cjia.common.annotation.Audit;
    import com.cjia.common.reflect.LoginValueReturn;
    import com.cjia.model.Menu;
    import com.cjia.model.ResponseContent;
    import com.cjia.model.User;
    import com.cjia.service.MenuService;
    import com.cjia.service.UserService;
    import com.cjia.utils.DigestUtil;
    
    /**
     * 处理内部系统登录信息验证
     */
    @Controller
    public class LoginController {
    
    	private static final Logger LOGGER = LoggerFactory.getLogger(LoginController.class);
    
    	@Autowired
    	private UserService userService;
    
    	@Autowired
    	private MenuService menuService;
    
    	/**
    	 * 处理登录页表单提交信息
    	 */
    	@ResponseBody
    	@PostMapping("/doLogin")
    	@Audit(moudleCode = Moudle.LOGIN, extension = LoginValueReturn.class)
    	public ResponseContent doLogin(HttpServletRequest req) throws Exception {
    		String email = req.getParameter("email");
    		String password = req.getParameter("password");
    		int appId = Integer.valueOf(req.getParameter("appId"));
    		// 获取到的这么多user（同一账户）只是role或门店不同，密码等其他都一致
    		List<User> users = new ArrayList<>();
    		// 对SRP报表系统不允许管家登录
    		if (appId == InnerApp.CIS) {
    			users = userService.selectByEmail4CIS(email);
    		} else {
    			users = userService.selectByEmail(email);
    		}
    		ResponseContent responseContent = new ResponseContent();
    		if (users != null && !users.isEmpty()
    				&& users.get(0).getPassword().equals(DigestUtil.threeHash(password, users.get(0).getSecurityKey()))) {
    			User user = users.get(0);
    			LOGGER.debug("登陆验证成功{}", user);
    			// 设置roleIdLst和branchMap
    			List<Integer> roleIdLst = users.stream().map(User::getRoleId).collect(Collectors.toList());
    			Map<String, String> branchMap = new HashMap<>();
    			Map<Integer, List<Menu>> menuMap = getAllMenus(users);
    			for (User u : users) {
    				branchMap.put(u.getBranchId() + "", u.getBranchName());
    			}
    			user.setRoleIdLst(roleIdLst);
    			user.setBranchMap(branchMap);
    			// 给user设置菜单列表
    			user.setMenuMap(menuMap);
    			// 登陆成功后，需要看此用户的信息是否存在于redis，存在则刷新过期时间，不存在则插入记录
    			String msgKey = userService.insertIntoRedis(user);
    			responseContent.setRespCode(ResponseContent.RESPCODE_SUCCESS);
    			responseContent.setMessage("登陆成功");
    			responseContent.setData(msgKey);
    		} else {
    			LOGGER.debug("登陆验证失败");
    			responseContent.setRespCode(ResponseContent.RESPCODE_FAILURE);
    			responseContent.setMessage("登陆失败，请检查用户账号密码是否正确");
    		}
    		String jsonString = JSON.toJSONString(responseContent);
    		LOGGER.debug("登录返回信息:{}", jsonString);
    		return responseContent;
    	}
    }

扩展资料可参阅[https://blog.csdn.net/songzehao/article/details/80171646][https_blog.csdn.net_songzehao_article_details_80171646]。

--------------------

以上。

转载于:https://www.cnblogs.com/songzehao/p/11000723.html

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6ZWhhbw_size_16_color_FFFFFF_t_70]: /images/20220109/df5e22ff90ac4a4bab0ac4a1b0aa3023.png
[https_blog.csdn.net_songzehao_article_details_80171646]: https://blog.csdn.net/songzehao/article/details/80171646