Java Aop 环绕通知 监控 controller 层

最新推荐文章于 2024-05-14 15:36:58 发布
最新推荐文章于 2024-05-14 15:36:58 发布
阅读量1.3k 收藏 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
    评论
专栏目录
使用 aop拦截 springMVC的controller并获取请求参数及返回结果
tianmangshan80的专栏
06-08 1万+
有人说使用aop拦截不到springMVC的controller，一般出现此种情况大多是由于配置错误造成，不废话直接进入主题： 1、applicationContext.xml 配置扫描 除@controller外的bean 2、 applicationContext-mvc.xml 配置扫描 @controller bean
springMVC AOP拦截拦截Controller等实现日志管理
07-19
在Spring MVC中，AOP（面向切面编程）是一种强大的工具，可以让我们在不修改代码...综上所述，Spring MVC结合AOP为我们提供了一种优雅的方式，以声明式地管理和记录Controller层的日志，增强了系统的可观察性和稳定性。
java SpringAOP拦截Controller,Service实现日志管理(自定义注解的方式)
xwnxwn的专栏
07-06 1115
2015-01-20 11:33 386人阅读 评论(1) 收藏 举报 做日志管理最好的是Aop，有的人也喜欢用拦截器。都可以，在此我重点介绍我的实现方式。 Aop有的人说拦截不到Controller。有的人说想拦AnnotationMethodHandlerAdapter截到Controller必须得拦截org.springframework.web.servlet.mvc.annota
java AOP环绕通知记录操作日志
letterss的博客
05-14 213
【代码】java AOP环绕切面记录操作日志。
java aop改变方法返回值_controller层获取aop方法返回的值
weixin_36225424的博客
02-26 1331
问题描述：做的内容大致是阻止用户恶意不断请求，限制单位时间内访问次数然后做了一个aop，但是我没法在controller层中获取aop方法的返回值，如下代码：@Pointcut("execution(public * com.mzd.redis_springboot_mybatis_mysql.controller.*.*(..))")public void WebPointCut() {}@Be...
Springboot实现自定义注释的aop环绕通知
qq_34297581的博客
11-18 564
Springboot实现自定义注释的aop环绕通知
AOP-@Aspect：Controller日志全监控
u013947963的博客
11-23 550
一、Controller @Aspect @Component public class ControllerMonitor { private static final Logger LOGGER = LoggerFactory.getLogger("CONTROLLER-DETAIL-AOP-LOGGER"); //*** 替换成路径 @Around("execution(* com.***.controller.*.*Controller.*(..))") public
spring MVC AOP注解方式如何拦截controller 例子
12-22
在Spring中，我们可以使用AspectJ注解来声明切面，这些注解包括`@Aspect`、`@Before`、`@After`、`@Around`等，它们分别代表前置通知、后置通知、环绕通知等不同类型的拦截器。 1. **创建切面类** 首先，我们需要...
spring aop 拦截日志示例
09-28
我们使用`@Pointcut`注解来定义切点，例如定义一个切点匹配所有Controller层的方法：`@Pointcut("execution(* com.example.myapp.controller.*.*(..))")`。 4. **编写环绕通知**： 环绕通知最强大，因为它可以控制...
Spring-MVC-aop.zip
09-13
在本文中，我们将深入探讨如何使用Spring MVC框架中的AOP（面向切面编程）特性，结合注解方式来实现对Controller层的拦截，以便进行日志管理。这是一项非常实用的技术，可以帮助开发者追踪和记录应用程序的关键操作...
SpringMVC-Aop demo
09-23
AOP是一种编程范式，允许我们定义关注点（如日志、安全性或性能监控）并在多个地方透明地应用它们，而无需在每个函数或类中显式调用。在Spring框架中，AOP是通过代理模式实现的，可以使用XML配置或注解驱动的方式来...
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
08-18
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
Spring Controller层设置AOP
u012780655的博客
11-01 428
近期公司需要做一个web项目，项目中有需求是需要记录特定管理员的操作。操作属性包括：操作时间、操作人、触发数据量等。 自然而然的就想到了面向切面编程(AOP)。 项目初步的技术选型是： Intellij idea+gradle+spring+spring security+hibernate+spring aop+jsp完成项目需求。 项目结构图如下所...
基于Spring的Controller拦截器做性能监控
02-27 1113
package cn.javass.chapter5.web.interceptor; public class StopWatchHandlerInterceptor extends HandlerInterceptorAdapter { private NamedThreadLocal startTimeThreadLocal = new NamedThreadLoca
利用Aop记录Controller层日志信息
路漫漫其修远兮，吾将上下而求索
07-21 1185
aop写controller层日志记录，真实地址
使用Aop记录Controller层日志信息
imVainiycos的博客
05-09 443
为了记录controller的请求参数，请求地址，类名方法等日志信息，以及相关的RT请求耗时时间。在之前总结过RT时间的记录博客，以下将会介绍一种更加优雅的方式。
Controller负载监控及运行
weixin_30407099的博客
05-10 262
总概 　　 ①Controller全局设置 　　 　　　.lrs-----保存场景后缀 　　　　 ②Controller场景运行 　　场景控制： 　　　　　　 　　场景执行期间-VUser的运行状态： 　　　　关闭-挂起-初始化-就绪-运行-集合点-通过-失败-错误-逐渐退出-退出-停止 虚拟用户操作总结： 　　　　 　　场景执行期间-事务详细信息 　...
kube-prometheus监控 controller-manager && scheduler 组件
qq_43164571的博客
08-30 3433
一、问题描述 kube-prometheus 的安装，我们可以看到监控指标大部分的配置都是正常的，只有两个没有管理到对应的监控目标，比如 kube-controller-manager 和 kube-scheduler 这两个系统组件。 备注：   controller-manager：负责管理集群各种资源，保证资源处于预期的状态。   kube-scheduler：资源调度，负责决定将Pod放到哪个Node上运行。 二、问题分析 1、kube-scheduler 这其实就和 ServiceMonit
使用SpringAop做Controller层null值校验
安能
07-30 736
距离上次写博客已经有一段时间了,想到有很多技术点比较散又容易忘记,所以决定写点博客把这些都记下来 主要功能: 实现单属性,自定义对象和Map的null值校验处理 注意事项: 如果是SpringBoot 1.5的版本需要在pom文件加一下配置 <plugin> <groupId>org.apache.mav...
spring aop 环绕通知
最新发布
05-24
Spring AOP（Aspect-Oriented Programming）是 Spring 框架中的一个重要功能，它可以帮助我们实现面向切面编程，解决了很多传统OOP中难以解决的问题。其中，环绕通知是 Spring AOP 中最强大的通知类型之一。 环绕通知（Around Advice）是 AOP 中最常用的通知之一，它可以在目标方法执行之前和之后进行操作。环绕通知是可以控制目标方法的调用，可以决定是否调用目标方法，也可以在调用前后进行一些自定义的操作。 环绕通知的实现方式是通过拦截器（Interceptor）来实现的。在拦截器中，我们可以通过`ProceedingJoinPoint`对象来调用目标方法，并在适当的时候对目标方法进行控制。 下面是一个简单的环绕通知示例代码： ``` @Aspect @Component public class MyAspect { @Around("execution(* com.example.demo.service.UserService.*(..))") public Object around(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("before method invoked"); Object result = joinPoint.proceed(); System.out.println("after method invoked"); return result; } } ``` 在上面的示例中，我们定义了一个环绕通知，通过`@Around`注解指定了切入点表达式，表示对`com.example.demo.service.UserService`类中的所有方法进行拦截。在`around`方法中，我们可以在目标方法执行之前和之后进行一些操作，并使用`ProceedingJoinPoint`对象来调用目标方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值