Java Aop 环绕通知 监控 controller 层

最新推荐文章于 2024-05-14 15:36:58 发布
最新推荐文章于 2024-05-14 15:36:58 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： Java 文章标签： aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxlzs_/article/details/110195337
版权

我们项目中一般需要去监控 controller 层， 校验参数、加密、日志打印等等。

一、首先是写个切面，定位所有controller 层的方法

@Aspect
@Component
@Slf4j
public class MutmsAspect {

	@Value("${spring.application.name}")
	private String  appName;

    @Autowired
    private ExeService exeService;

	@Around("execution(public * com.ceair.mutms..controller.*.*(..))")
	public Object exeMethod(ProceedingJoinPoint joinPoint)throws Throwable{

二、校验参数

// 版本验证，低版本报错
MutmsVersion.update(methodName,req);
// token 验证
MutmsToken.verify(appName, permittedServer, joinPoint,req);
// session校验
MutmsSession.verify(appName,permittedServer, joinPoint);

三、打印入参，执行方法，拿到反参

// 因为阿里云日志只支持xxxx* 这种方式模糊查找不支持*xxxx这种方式所以给关键日志加一个前缀
log.info("{}{}方法：{},入参: {}", AliyunLogConsts.MUTMS_REQ_PREFIX, methodName, joinPoint.getSignature().getName(), JsonUtil.toString(req,""));
res=joinPoint.proceed(joinPoint.getArgs());

四、打印反参，方法执行时间，保存访问记录等

// 因为阿里云日志只支持xxxx* 这种方式模糊查找不支持*xxxx这种方式所以给关键日志加一个前缀
log.info("{}{}返回: {}", AliyunLogConsts.MUTMS_RES_PREFIX, methodName, JsonUtil.toString(res,""));
log.info("方法: {}, 接口耗时：{}毫秒", methodName, (System.currentTimeMillis()-starttime));
// 异步保存接口访问记录
MUTMSAccessLogQueueHelper.execute(() -> {
MUTMSAccessLog accessLog = new MUTMSAccessLog();
accessLog.setPassportId(passportId);
accessLog.setTransactionId(transactionId);  // 明文transactionId
accessLog.setSessionId(sessionId);
accessLog.setOs(req.getOs());
accessLog.setLocalIp(IpHelper.getLocalIp());
accessLog.setClientRealIp(clentRealIp);
accessLog.setLanguage(req.getLanguage());
accessLog.setRegion(req.getRegion());
accessLog.setAppVersion(req.getAppVersion());
accessLog.setChannelNo(req.getChannelNo());
accessLog.setSecondChannelNo(req.getSecondChannelNo());
accessLog.setThirdChannelNo(req.getThirdChannelNo());
accessLog.setSalesChannel(salesChannel);

 完整代码

package com.ceair.mutms.common.aop;

import com.ceair.mutms.common.aliyunlog.AliyunLogConsts;
import com.ceair.mutms.common.aliyunlog.MUTMSAccessLogItemKeyConsts;
import com.ceair.mutms.common.base.BaseReq;
import com.ceair.mutms.common.base.CommonRes;
import com.ceair.mutms.common.entity.MUTMSAccessLog;
import com.ceair.mutms.common.exception.*;
import com.ceair.mutms.common.filter.ContextUtil;
import com.ceair.mutms.common.aliyunlog.AliyunLogHelper;
import com.ceair.mutms.common.aliyunlog.AliyunLogItemKeyConsts;
import com.ceair.mutms.common.log.MDCBean;
import com.ceair.mutms.common.log.MDCHelper;
import com.ceair.mutms.common.sec.aes.BangBang;
import com.ceair.mutms.common.service.ExeService;
import com.ceair.mutms.common.utils.*;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.support.StandardMultipartHttpServletRequest;

import java.util.Map;
/**
 * 接口控制
 * @author DELL
 *
 */
@Order(-1)
@Aspect
@Component
@Slf4j
public class MutmsAspect {
	@Value("${spring.application.name}")
	private String  appName;

    @Autowired
    private ExeService exeService;


	@Around("execution(public * com.ceair.mutms..controller.*.*(..))")
	public Object exeMethod(ProceedingJoinPoint joinPoint)throws Throwable{
		long starttime = System.currentTimeMillis();

		String permittedServer=CacheUtil.getOtherCode(CacheKey.PERMITTED_SERVER);
		BaseReq req=getParam(joinPoint.getArgs());

		// 加密 token
		String tokenRsa = req.getCeairToken();
		Long passportId = req.getPassportId();
		String clentRealIp = ContextUtil.getContext().getString(CacheKey.CLIENT_REAL_IP_KEY);
		String sessionId = ContextUtil.getContext().getString(CacheKey.SESSION_ID_KEY);
		String salesChannel = SalesChannelHelper.salesChannel(req.getLanguage(), req.getRegion());
		//当前请求所执行的controller类的方法
		final String methodName=joinPoint.getSignature().getName();
		String className = joinPoint.getSignature().getDeclaringTypeName();
		final String interfaceKey = className + "." + methodName;

        Object res=null;

        final String transactionId = Assert.isNotEmpty(req.getTransactionId()) ? req.getTransactionId() : BaseReq.generateTransactionId(passportId);

        MDCBean bean = new MDCBean();

        bean.setTransactionId(transactionId);
        bean.setPassportId(Assert.nullToEmpty(passportId));
        bean.setSessionId(sessionId);

        AliyunLogHelper.addItemIfAbsent(req.getAliyunLogItems(), AliyunLogItemKeyConsts.TRANSACTION_ID, transactionId);
        AliyunLogHelper.addItemIfAbsent(req.getAliyunLogItems(), AliyunLogItemKeyConsts.SESSION_ID, sessionId);
        AliyunLogHelper.addItemIfAbsent(req.getAliyunLogItems(), AliyunLogItemKeyConsts.PASSPORT_ID, passportId);
        AliyunLogHelper.addItemIfAbsent(req.getAliyunLogItems(), AliyunLogItemKeyConsts.INTERFACE_NAME, interfaceKey);
        AliyunLogHelper.addLogTime(req.getAliyunLogItems());

		try {
            MDCHelper.insertIntoMDC(bean);

			// 当前请求所使用的语言类型
			ContextUtil.getContext().put(CacheKey.LANGUAGE_CACHE_KEY, Assert.isEmpty(req.getLanguage())?"zh":req.getLanguage());
			// 版本验证，低版本报错
			MutmsVersion.update(methodName,req);
			// token 验证
			MutmsToken.verify(appName, permittedServer, joinPoint,req);

			req.setSalesChannel(salesChannel);
			// 当前线程执行子任务的唯一标识
//			ContextUtil.getContext().put("logbean.uuid", UUID.randomUUID().toString());
			// 地区
			ContextUtil.getContext().put(CacheKey.REGION_CACHE_KEY, Assert.isEmpty(req.getRegion())?"CN":req.getRegion());
			// 渠道
			ContextUtil.getContext().put(CacheKey.SALES_CHANNEL_CACHE_KEY, salesChannel);
			//系统支持的支付方式
			if(req.getSupportPay()!=null && req.getSupportPay()) {
				ContextUtil.getContext().put(CacheKey.OS_PAY_METHOD_CACHE_KEY, req.getOsPayMethod());
			}
			// 每次请求唯一ID，明文tansactionId
			ContextUtil.getContext().put(CacheKey.TRANSACTION_ID_CACHE_KEY, transactionId);
			// 当前请求的用户ID
			ContextUtil.getContext().put(CacheKey.PASSPORTID_CACHE_KEY, passportId);
			// 当前请求的客户端平台系统：AD|iOS
			ContextUtil.getContext().put(CacheKey.APP_OS_CACHE_KEY, req.getOs());
			// 当前请求的客户端版本号
			ContextUtil.getContext().put(CacheKey.APP_VERSION_CACHE_KEY, req.getAppVersion());
			// 当前请求的设备ID
			ContextUtil.getContext().put(CacheKey.IEMI_CACHE_KEY,req.getImei());
			//阿里token
			ContextUtil.getContext().put(CacheKey.APDIDTOKEN_CACHE_KEY,req.getApdidToken());

			// session校验
			MutmsSession.verify(appName,permittedServer, joinPoint);

			String codeEnity=null;

			if(permittedServer==null||!permittedServer.contains(appName)) {
				//接口调用开关
				codeEnity=CacheUtil.getMethod(methodName);
			}
			//*表示关闭当前所有接口
			if(codeEnity !=null || (codeEnity=CacheUtil.getMethod("*"))!=null) {
				log.info("方法：{},被禁用：{}", joinPoint.getSignature().getName(), codeEnity);
				res = new CommonRes<Object>(CommonRes.FAIL,CacheUtil.getI18nVal(codeEnity, codeEnity));
			}else {
			    // 因为阿里云日志只支持xxxx* 这种方式模糊查找不支持*xxxx这种方式所以给关键日志加一个前缀
				log.info("{}{}方法：{},入参: {}", AliyunLogConsts.MUTMS_REQ_PREFIX, methodName, joinPoint.getSignature().getName(), JsonUtil.toString(req,""));
				res=joinPoint.proceed(joinPoint.getArgs());

			}

		}catch (MUTMSFirstExceptionWithData tx){
            res= ExceptionHandler.doException(tx);
        }catch (MUTMSFirstException tx){
			res= ExceptionHandler.doException(tx);
		}catch (MUTMSRuntimeException tx){
			res= ExceptionHandler.doException(tx);
		}catch(MUTMSSecondExceptionWithData e){
            res= ExceptionHandler.doException(e);
        }catch(MUTMSSecondException e){
			res= ExceptionHandler.doException(e);
		}catch(MUTMSThirdException e){
			res= ExceptionHandler.doException(e);
		}catch(MUTMSFourthException e){
            res= ExceptionHandler.doException(e);
        }catch(Exception e) {
		    if(e instanceof NullPointerException)
            {
                log.info("接口调用出现异常, ex: {}：", Assert.callStackOneLine(e));
            }

			res= ExceptionHandler.doException(e);
			log.error("接口调用出现异常：", e);
		}finally {
			// 把请求参数存入redis缓存
			exeService.exec(()-> {
				try {
					MutmsToken.setToken(tokenRsa,req);
				} catch (Exception e) {
					log.error("异步记录ceair token 出现异常：", e);
				}
			});

			final String resultCode;
			final String resultMsg;
			if(res instanceof CommonRes){
				((CommonRes<?>) res).setTransactionId(transactionId);
				resultCode = ((CommonRes<?>) res).getResultCode();
				resultMsg = ((CommonRes<?>) res).getResultMsg();
				// 构建统一弹框
                DialogHelper.buildDialog((CommonRes<?>)res, interfaceKey, req.getDialogParams());

			}else {
				resultCode = "";
				resultMsg = "";
			}

//			log.info("isNeedToAliyunLog: {}, interfaceKey: {}", AliyunLogHelper.isNeedToAliyunLog(interfaceKey), interfaceKey);
			if(AliyunLogHelper.isNeedToAliyunLog(interfaceKey))
            {
                AliyunLogHelper.addTopic(req.getAliyunLogItems(), interfaceKey);

                AliyunLogHelper.execute(() -> {
                    AliyunLogHelper.putLogs(req.getAliyunLogItems());
                });
            }

            Long costTimeMillisecond = System.currentTimeMillis() - starttime;
			// 异步保存接口访问记录
			MUTMSAccessLogQueueHelper.execute(() -> {
				MUTMSAccessLog accessLog = new MUTMSAccessLog();
				accessLog.setPassportId(passportId);
				accessLog.setTransactionId(transactionId);  // 明文transactionId
				accessLog.setSessionId(sessionId);
				accessLog.setOs(req.getOs());
				accessLog.setLocalIp(IpHelper.getLocalIp());
				accessLog.setClientRealIp(clentRealIp);
				accessLog.setLanguage(req.getLanguage());
				accessLog.setRegion(req.getRegion());
				accessLog.setAppVersion(req.getAppVersion());
				accessLog.setChannelNo(req.getChannelNo());
				accessLog.setSecondChannelNo(req.getSecondChannelNo());
				accessLog.setThirdChannelNo(req.getThirdChannelNo());
				accessLog.setSalesChannel(salesChannel);
				accessLog.setCrtDt(TimeUtils.nowLong());
				accessLog.setClassName(className);
				accessLog.setMethodName(methodName);
				accessLog.setImei(req.getImei());
				accessLog.setResultCode(resultCode);
				accessLog.setResultMsg(resultMsg);
                accessLog.setRegistrationID(req.getRegistrationID());
				accessLog.setCostTimeMillisecond(costTimeMillisecond);

                Map<String, String> accessLogItemsMap =  MUTMSAccessLogItemKeyConsts.buildAliyunLogItems(accessLog, req.getAliyunLogItems(), req.getAliyunLogItemsExt());

                AliyunLogHelper.putAccessLogs(accessLogItemsMap);

//                MongoTemplate mongoTemplate = AppContext.getBean(MongoTemplate.class);
//				mongoTemplate.insert(accessLog);
			});

			//非生产环境打印接口返回值
			if(CacheUtil.PRINT_RES) {
			    // 因为阿里云日志只支持xxxx* 这种方式模糊查找不支持*xxxx这种方式所以给关键日志加一个前缀
				log.info("{}{}返回: {}", AliyunLogConsts.MUTMS_RES_PREFIX, methodName, JsonUtil.toString(res,""));
			}
 
            log.info("方法: {}, 接口耗时：{}毫秒", methodName, (System.currentTimeMillis()-starttime));
		}
		return res;
	}


	private BaseReq getParam(Object args[]) {

	    String appVersion = null;
	    Long passportId = null;
		// 转BaseReq 对象并返回
	    if(args !=null) {
			for (Object object : args) {
				if(object instanceof BaseReq) {
					return (BaseReq)object;
				// 参数写在 form-data中处理
				}else if(object instanceof StandardMultipartHttpServletRequest){
                    try {
                        String pid = ((StandardMultipartHttpServletRequest) object).getParameter("passportId");
                        passportId = Assert.isEmpty(pid)?null:Long.valueOf(pid);
                        appVersion = ((StandardMultipartHttpServletRequest) object).getParameter("appVersion");
                    }catch (Exception e){
                        Assert.callStack(e);
                    }
                }
			}
		}


		BaseReq req =new BaseReq();
		req.setLanguage("zh");
		req.setRegion("CN");
        req.setAppVersion(appVersion);
        req.setPassportId(passportId);
		return req;
	}

}

 

sxlzs_
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Aspect编程中@Around注解的使用及接口Controller监控
家住海边，见过大风大浪
12-12 5005
Spring Aspect编程中，Spring切面包含通知和切点，通知和切点分别定义了在何时何处执行切面逻辑。 其中，Spring定义了五种不同类型的通知： Before（目标方法执行前） After（目标方法执行后，不关注执行结果） After-returning（目标方法执行后，返回通知） After-throwing（目标方法抛出异常后） Around（目标方法执行前后、...
Aop监控所有Controller，包括void类型的response中的出参（工具类）
qq_44299529的博客
08-02 532
Aop监控所有Controller，包括void类型的response中的出参（工具类） response.getWriter().write();
java AOP环绕通知记录操作日志
letterss的博客
05-14 233
【代码】java AOP环绕切面记录操作日志。
Spring AOP -- execution表达式
weixin_44822455的博客
10-16 830
*：匹配任何数量字符； ..：匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数。 +：匹配指定类型的子类型；仅能作为后缀放在类型模式后边。 表达式示例 execution(* com.sample.service.impl…(…)) 详述： execution()，表达式的主体 第一个“”符号，表示返回值类型任意； com.sample.service.impl，AOP所切的服务的包名，即我们的业务部分 包名后面的“…”，表示当前包及子包 第二个“”，表示类名，
AOP-@Aspect：Controller日志全监控
u013947963的博客
11-23 556
一、Controller @Aspect @Component public class ControllerMonitor { private static final Logger LOGGER = LoggerFactory.getLogger("CONTROLLER-DETAIL-AOP-LOGGER"); //*** 替换成路径 @Around("execution(* com.***.controller.*.*Controller.*(..))") public
Spring AOP使用@Around封装service方法传递给controller时报nullpointexception异常解决方案。
weiboKDhuo的博客
05-15 1365
百度了一下，大致出现类似的问题有如下情况： controller中有private方法，把private改成public，具体原因可以自行百度。 使用@Autowired注入的service为空，具体解决方案自行百度。 service返回的值为空。 3.1 service方法返回值为数据类型而不是引用类型，修改类型就可以了，AOP只支持引用类型不支持数据类型，具体原因可以自行百度。 3.2 @A...
Spring Controller层设置AOP
u012780655的博客
11-01 431
近期公司需要做一个web项目，项目中有需求是需要记录特定管理员的操作。操作属性包括：操作时间、操作人、触发数据量等。 自然而然的就想到了面向切面编程(AOP)。 项目初步的技术选型是： Intellij idea+gradle+spring+spring security+hibernate+spring aop+jsp完成项目需求。 项目结构图如下所...
SpringAOP拦截Controller总结
Tracycater的专栏
03-07 5005
有的人说想拦AnnotationMethodHandlerAdapter截到Controller必须得拦截org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter。 经过查询Aop可以拦截到Controller的之所以有的人说拦截不到Controller是因为Controller被jdk代理了。我们只
@Around(value = “execution(* com....api.controller..*.*(..))“)
qq_44942083的博客
03-22 589
环绕通知（Around Advice）是AOP中的一种通知类型，它可以在目标方法执行前后进行处理，并且可以决定是否继续执行目标方法或者在执行完毕后进行一些额外的操作。在这段代码中，使用了@Around注解来定义一个环绕通知（Around Advice），它会在指定的切点（Pointcut）处执行。))"，表示匹配com.alm.ori包及其子包下的api.controller包中所有类的所有方法。具体来说，这段代码中的@Around注解指定了切点表达式为"execution(* com.alm.ori…
【Spring boot篇 1】AOP
Elevenoo的博客
04-27 299
AOP Aspect-Oriented Programming， 面向切面编程，基于横向抽取机制将公共的非业务逻辑代码抽取出来封装为切面类 AOP的好处 业务逻辑和非业务逻辑分离，便于维护和升级 业务模块更简洁 切入点（Pointcut） AOP通过切入点作用于连接点 连接点（Joinpoint） AOP作用的位置，包括方法执行前、执行后、捕获异常后、正常返...
java-SpringAOP
不会写代码的胖子
01-07 139
一：什么是AOP AOP面向切面编程，是一种方法论，是对传统OOP编程的补充。每一个事物逻辑位于一个位置，代码不分散，便于维护和升级，业务模块更加简洁，只包括核心业务代码。 二：AOP的实现 AspectJ注解 <!--配置自动扫描的包--> <context:component-scan base-package="com.spring.aop.impl">...
Springboot实现自定义注释的aop环绕通知
qq_34297581的博客
11-18 571
Springboot实现自定义注释的aop环绕通知
正确配置 在controller中使用AOP
毅个混蛋的专栏
10-04 2863
在controller中使用AOP的问题主要有2个 1，在于如何让controller能够被检测到，controller和其他spring bean的区别在于:controller是由mvc定义并在web.xml中的dispatcher中定义的。  2，更改默认的代理配置使用cglib 解决方法：  1、正确定义controller,(比较通用的做法,没有特殊情况的
[Java[Spring]AOP
zkxshg的博客
01-15 137
step1:定义主方法： package com.how2java.service; public class ProductService { public void doSomeService(){ System.out.println("doSomeService"); } } step2
Java练习（十九）：编写代码，实现AOP的@Around操作 （两种写法）
sulia1234567890的博客
09-26 5676
目录 1. 要求 2. 涉及的知识点 3.示例工程 （第一种方式） 3.1 maven的配置文件： pom.xml 3.2 bean配置文件： bean_aop_around.xml 3.3 接口和类的代码 3.3.1 接口：UserService 3.3.2 实现接口的类：UserServiceImpl 3.3.3 AroundLog类：AroundLog 3.4 测试类 4. 示例代码（第二种方式） 1. 要求 之前完成了通过@Before和@After的方式，完成了...
Spring boot如何在Controller层的各个方法设置切面了解调用的相关信息
qq_43411729的博客
11-23 665
@Aspect @Component public class AccessLogAspect { private Logger logger = LoggerFactory.getLogger(AccessLogAspect.class); @Pointcut("execution(* com.xdaozwg.preformance.controller.*.*.*(..))") public void controllerAspect() { } @Arou
日志 aop 中 @Around(“execution(?)“)中路径的配置
热门推荐
CYY941027的博客
07-02 1万+
//环绕通知 首先是:包名 然后是: 类名 然后是方法名:方法名 括号内是:参数 @Around("execution(* com.sinosoft.*.controller.*.*(..))") public Object around(ProceedingJoinPoint point) throws Throwable{ //参数是目标方法 try { String typeName=""; String locat=""; Signature signature = po
Spring——AOP细节
weixin_45483328的博客
12-02 1431
文章目录细节一：被切入的类获取的bean是代理对象细节二：接入点表达式细节三：通知方法运行时，拿到目标方法的详细信息细节四：拿到连接点的返回结果，异常信息细节五：抽取可重用的切入点表达式细节六：环绕通知@Around 细节一：被切入的类获取的bean是代理对象 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml"); @Test public void test01(){
基于spring boot的controller日志切面处理
hhttim的博客
08-05 4889
基于spring boot的controller日志切面处理 问题需求：项目中需要在日志中记录接口传入值，接口调用ip，接口调用时间等等 处理方式：在controller层加切面处理 1.需要的包，springboot 中aop切面，两个工具类，hutool和jackson pom如下（版本可以更换）： <dependency> <grou...
spring aop 环绕通知
最新发布
05-24
其中，环绕通知是 Spring AOP 中最强大的通知类型之一。 环绕通知（Around Advice）是 AOP 中最常用的通知之一，它可以在目标方法执行之前和之后进行操作。环绕通知是可以控制目标方法的调用，可以决定是否调用目标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值