采用切面的方式去管理全局的日志

最新推荐文章于 2024-06-14 14:19:04 发布
最新推荐文章于 2024-06-14 14:19:04 发布
阅读量418 收藏 2
点赞数 1
分类专栏： 日志 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiongzhudada/article/details/105119360
版权
  1. 定义切面注解
package cn.ivg.retail.common.annotate;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.annotation.AliasFor;

import cn.ivg.retail.common.enumerate.OperationEnum;

/**
 * 
 * 
 * 
 * Module:
 * 
 * Log.java
 * 
 * @author xz
 * @version 1.0
 * @date 2019年9月19日 上午8:53:35
 * @description: 日志注解
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD }) // 只能在方法上使用此注解
public @interface IvgLog {

	public static final int ADD = 1; // 新增
	public static final int EDIT = 2; // 修改
	public static final int DELETE = 3; // 删除
	public static final int IMPORT = 4; // 导入
	public static final int EXPORT = 5; // 导出
	
	/**
	 * 日志描述，这里使用了@AliasFor 别名。spring提供的
	 * 
	 * @return
	 */
	@AliasFor("value")
	OperationEnum value();

	/**
	 * 日志描述
	 * 
	 * @return
	 */
	@AliasFor("desc")
	String desc() default "";

	/**
	 * 业务模块
	 * 
	 * @return
	 */
	@AliasFor("businesstype")
	String businesstype() default "";

	/**
	 * 操作类型 1-新建 2-修改 3-删除
	 * 
	 * @return
	 */
	@AliasFor("operatetype")
	int operatetype() default 1;
}

2. 操作类型的枚举

package cn.ivg.retail.common.enumerate;

/**
 * 
 * 
 * 
 * Module:
 * 
 * OperationEnum.java
 * 
 * @author xz
 * @version 1.0
 * @date 2019年9月19日 上午10:03:30
 * @description: 日志枚举类
 */
public enum OperationEnum {
	LOGINLOG(0, "登陆日志"), OPERATIONLOG(1, "操作日志"), THIRDPARTYLOG(2, "第三方对接日志");
    
    private  int value  = 0;;

    private  String label = null;

     OperationEnum(int value, String label) {
        this.value = value;
        this.label = label;
    }


    /**
	 * @description 是否包含该枚举值
	 * @param type
	 * @return
	 */
    public static boolean contain(Integer type) {
        OperationEnum[] types = OperationEnum.values();
        if (type == null) {
            return false;
        }
        for (OperationEnum ete : types) {
            if (ete.getValue() == type.intValue()) {
                return true;
            }
        }
        return false;
    }

    public static boolean notContain(Integer type) {
        return !contain(type);
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public String getLabel() {
        return label;
    }

    public void setLabel(String label) {
        this.label = label;
    }
}

3.日志切面,本次采用后置日志切面记录接口请求的开始和返回,并把日志写入kafka内容, 后续采用生产消费的模式讲日志写入到mysql数据库或者es全文检索数据

package cn.ivg.retail.tools.aspect;

import java.lang.reflect.Method;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.concurrent.Executor;

import javax.servlet.http.HttpServletRequest;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.CodeSignature;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;
import org.springframework.validation.BeanPropertyBindingResult;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

import cn.hutool.core.util.IdUtil;
import cn.ivg.retail.common.annotate.IvgLog;
import cn.ivg.retail.common.entity.IvgResponse;
import cn.ivg.retail.common.enumerate.OperationEnum;
import cn.ivg.retail.common.exception.IvgBizException;
import cn.ivg.retail.service.ivgcommonservice.bo.LogLoginBo;
import cn.ivg.retail.service.ivgcommonservice.bo.LogOperationBo;


/**
 * 
 * 
 * 
 * Module:
 * 
 * SysLogAspect.java
 * 
 * @author xz
 * @version 1.0
 * @date 2019年9月19日 上午8:42:46
 * @description: 日志切面,本次采用后置日志切面记录接口请求的开始和返回,并把日志写入kafka内容, 后续采用生产消费的模式讲日志写入到mysql数据库或者es全文检索数据
 */
@Aspect
@Component
public class SysLogAspect {

	private static final Logger log = LoggerFactory.getLogger(SysLogAspect.class);

	

	@Autowired
	private Executor taskExecutor;

	@Autowired
	private KafkaTemplate<String, Object> kafkaTemplate;

	// 定义切点 @Pointcut
	// 在注解的位置切入代码
	@Pointcut("@annotation(cn.ivg.retail.common.annotate.IvgLog)")
	public void logPoinCut() {
	}

	@Around("logPoinCut()")
	public Object doAround(ProceedingJoinPoint point) throws Throwable {
		IvgResponse<?> result = null;
		Throwable throwable = null;
		IvgBizException ivg = null;
		// 耗时
		long useTime = 0;
		// 此处捕捉了异常,所有必须有返回值,不然页面收不到返回消息体
		try {
			long startTime = System.currentTimeMillis();
			Object proceed = point.proceed();
			long endTime = System.currentTimeMillis();
			useTime = endTime - startTime;
			if (proceed != null) {

				result = (IvgResponse<?>) proceed;
			}
		} catch (Throwable e) {
			result = new IvgResponse<>();
			Throwable fillInStackTrace = e.fillInStackTrace();

			if (fillInStackTrace instanceof IvgBizException) {
				// 自定义异常
				ivg = (IvgBizException) fillInStackTrace;
				result.setSuccess(false);
				result.setCode(ivg.getCode());
				result.setMsg(ivg.getMsg());
			} else {
				// 其他异常
				result.setSuccess(false);
				result.setCode(500);
				result.setMsg(e.toString());
			}
			throwable = e;
		}

		MethodSignature signature = (MethodSignature) point.getSignature();
		// 获取切入点所在的方法
		Method method = signature.getMethod();
		// 获取操作--方法上的ViLog的值
		IvgLog logEvict = method.getAnnotation(IvgLog.class);
		if (logEvict != null) {

			ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder
					.getRequestAttributes();
			HttpServletRequest request = servletRequestAttributes.getRequest();
			OperationEnum value = logEvict.value();
			if (OperationEnum.LOGINLOG.equals(value)) {
				// 记录登陆日志,加入到线程池中等待执行
				try {
					recordLoginLog(point, result, request);
				} catch (Exception e) {
					e.printStackTrace();
				}
			} else if (OperationEnum.OPERATIONLOG.equals(value)) {
				// 记录操作日志
				try {
					recordOperationLog(point, result, logEvict, useTime);
				} catch (Exception e) {
					e.printStackTrace();
				}
			} else if (OperationEnum.THIRDPARTYLOG.equals(value)) {
				// 第三方对接日志
			}
		}
		// 假如报了异常此处需要给前端返回异常信息
		if (!result.getSuccess()) {
			if (throwable != null) {

				throw throwable;
			}
		}
		return result;
	}

	/**
	 * 记录登陆日志
	 * 
	 * @throws Throwable
	 */
	private void recordLoginLog(JoinPoint point, IvgResponse<?> result, HttpServletRequest request) {
		LogLoginBo logLogin = new LogLoginBo();
		// String remoteAddr = request.getRemoteAddr();// 得到来访者的IP地址
		String remoteAddr = getRealIp(request);
		String Agent = request.getHeader("User-Agent");
		StringTokenizer st = new StringTokenizer(Agent, ";");
		// 得到用户的浏览器名
		String userbrowser = "";
		if (st.hasMoreTokens()) {
			userbrowser = st.nextToken();
		}
		// 得到用户的操作系统名
		String useros = "";
		if (st.hasMoreTokens()) {
			useros = st.nextToken();
		}
		Map<String, Object> nameAndValue = getNameAndValue(point);// 请求参数
		Object object = nameAndValue.get("loginDto");
		JSONObject loginDto = JSON.parseObject(JSON.toJSONString(object));

		logLogin.setFid(IdUtil.fastSimpleUUID());
		logLogin.setUserName(loginDto.get("username") + "");
		logLogin.setPassword(loginDto.get("password") + "");
		logLogin.setEquipmentType(loginDto.get("loginType") + "");
		logLogin.setLoginStatus(result.getSuccess() ? "成功" : "失败");
		logLogin.setIpAddress(remoteAddr);
		logLogin.setBrowserInfo(userbrowser);
		logLogin.setOsInfo(useros);
		logLogin.setSoftVersion(serverVersion);
		logLogin.setRemark(result.getMsg());
		logLogin.setCreateDate(new Date());

		JSONObject parseObject = JSON.parseObject(JSON.toJSONString(result.getData()));
		if (parseObject != null) {

			logLogin.setTenantId(parseObject.getString("tenantId"));
		}
		
		pushToKafka("login-log", JSON.toJSONString(logLogin));
	}

	/**
	 * 记录操作日志
	 */
	private void recordOperationLog(JoinPoint point, IvgResponse<?> result, IvgLog logEvict, long useTime) {
		LogOperationBo logOperation = new LogOperationBo();
		logOperation.setFid(IdUtil.fastSimpleUUID());
		
		logOperation.setBusinessType(logEvict.businesstype());
		logOperation.setOperateType(logEvict.operatetype());
		logOperation.setOperateResource(logEvict.desc());

		Map<String, Object> nameAndValue = getNameAndValue(point);// 请求参数
		logOperation.setRequestValue(JSON.toJSONString(nameAndValue));
		logOperation.setResponseValue(JSON.toJSONString(result));
		logOperation.setRemark(result.getMsg());
		logOperation.setTimeConsuming(useTime + "ms");
		logOperation.setCreateDate(new Date());
		logOperation.setOperationStatus(result.getSuccess() ? "成功" : "失败");
		
		
		System.out.println(JSON.toJSONString(logOperation));
		pushToKafka("operation-log", JSON.toJSONString(logOperation));
	}

	/**
	 * 记录第三方接口日志
	 */
	private void recordThirdpartyLog(JoinPoint point, IvgResponse<?> result, HttpServletRequest request) {

	}

	/**
	 * 
	 * 
	 * @param topic
	 * @param context
	 * @description 推送kafka
	 */
	private void pushToKafka(String topic, String context) {
		// 此处采用异步操作,因为kafka可能会连接失败!
		taskExecutor.execute(new Runnable() {
			@Override
			public void run() {
				kafkaTemplate.send(topic, context);
			}
		});
	}

	/**
	 * @description 获取请求参数
	 * @param joinPoint
	 * @return
	 */
	Map<String, Object> getNameAndValue(JoinPoint joinPoint) {
		Map<String, Object> param = new HashMap<String, Object>();
		Object[] paramValues = joinPoint.getArgs();
		String[] paramNames = ((CodeSignature) joinPoint.getSignature()).getParameterNames();
		for (int i = 0; i < paramNames.length; i++) {
			if (!(paramValues[i] instanceof BeanPropertyBindingResult)) {
				if (paramValues[i] instanceof HashMap) {
					Map<String, Object> map = (Map<String, Object>) paramValues[i];
					map.forEach((key, value) -> {
						param.put(key, value);
					});
				} else {
					param.put(paramNames[i], paramValues[i]);
				}
			}
		}
		return param;
	}

	/**
	 * 获取真实ip
	 * 
	 * @param request
	 * @return
	 */
	public String getRealIp(HttpServletRequest request) {
		// 这个一般是Nginx反向代理设置的参数
		String ip = request.getHeader("X-Real-IP");
		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("X-Forwarded-For");
		}
		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("Proxy-Tenant-IP");
		}
		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("WL-Proxy-Tenant-IP");
		}
		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getRemoteAddr();
		}
		// 处理多IP的情况（只取第一个IP）
		if (ip != null && ip.contains(",")) {
			String[] ipArray = ip.split(",");
			ip = ipArray[0];
		}
		return ip;
	}
}

4.使用示例

 5.日志实体

package cn.ivg.retail.service.ivgcommonservice.bo;

import java.io.Serializable;
import java.util.Date;
@Date
public class LogLoginBo implements Serializable {
   
    private String fid;

	private String password;

   
    private String userName;


    
    private String equipmentType;

   
    private String equipmentSign;

    
    private String softVersion;

    
    private String loginStatus;

    
    private String ipAddress;

   
    private String browserInfo;

    
    private String osInfo;

   
    private String remark;

   
    private Date createDate;

   
    private String creater;

    
    private String tenantId;

   
   
}

 6.建表语句

CREATE TABLE `b_log_operation` (
  `fid` varchar(64) NOT NULL COMMENT '主键id',
  `user_id` varchar(64) NOT NULL COMMENT '用户id 关联b_user.fid',
  `business_type` varchar(64) NOT NULL COMMENT '业务模块',
  `operate_type` int(8) NOT NULL COMMENT '操作类型 1-新建 2-修改 3-删除',
  `operate_resource` varchar(64) NOT NULL COMMENT '操作资源',
  `request_value` text COMMENT '请求值json ',
  `response_value` text COMMENT '返回值json',
  `operation_status` varchar(16) DEFAULT 'N' COMMENT '操作状态 成功 失败',
  `time_consuming` varchar(64) DEFAULT NULL COMMENT '耗时(单位ms)',
  `remark` varchar(2000) DEFAULT 'N' COMMENT '备注 失败原因',
  `create_date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `creater` varchar(64) NOT NULL DEFAULT 'N' COMMENT '记录创建人 关联b_user.fid',
  `tenant_id` varchar(64) DEFAULT 'N' COMMENT '记录所属租户 关联b_tenant.fid',
  PRIMARY KEY (`fid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='操作日志主表';

7. kafka消费端

package cn.ivg.retail.consumer;

import java.util.Optional;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;

import cn.ivg.retail.dao.entity.domain.LogLogin;
import cn.ivg.retail.dao.entity.domain.LogOperation;
import cn.ivg.retail.dao.mapper.LogLoginMapper;
import cn.ivg.retail.dao.mapper.LogOperationMapper;

@Component
public class KafkaConsumer {
	@Autowired
	private LogLoginMapper logLoginMapper;
	@Autowired
	private LogOperationMapper logOperationMapper;
	@KafkaListener(topics = { "login-log" })
	public void consumerLogin(ConsumerRecord<?, ?> consumerRecord) {
		// 判断是否为null
		Optional<?> kafkaMessage = Optional.ofNullable(consumerRecord.value());
		if (kafkaMessage.isPresent()) {
			// 得到Optional实例中的值
			Object message = kafkaMessage.get();
			if (message != null) {
				LogLogin parseObject = JSON.parseObject(message.toString(), LogLogin.class);
				System.err.println(JSON.toJSONString(parseObject));
				logLoginMapper.insert(parseObject);
			}
		}
	}

	@KafkaListener(topics = { "operation-log" })
	public void consumerOperation(ConsumerRecord<?, ?> consumerRecord) {
		// 判断是否为null
		Optional<?> kafkaMessage = Optional.ofNullable(consumerRecord.value());
		if (kafkaMessage.isPresent()) {
			// 得到Optional实例中的值
			Object message = kafkaMessage.get();
			if (message != null) {
				LogOperation parseObject = JSON.parseObject(message.toString(), LogOperation.class);
				System.err.println(JSON.toJSONString(parseObject));
				logOperationMapper.insert(parseObject);
			}
		}
	}
}

说明:此代码略有删减,可能无法直接使用,需要稍微改造~~~~~~

xiongzhudada
关注
专栏目录
利用AOP实现日志切面统一处理
流星球
10-30 1万+
利用AOP实现日志切面统一处理最近很多业务日志需要优化改进，实现对业务更好的监控和优化。下面介绍利用Spring Aop实现面向切面编程的一个实例。能够实现不改动原有代码逻辑，只加一行描述即可实现统一日志收集。实现思路定义两个注解类，分别给service类和controller类使用，然后使用切面类，对这两个注解进行绑定监控。 可以达到效果就是，只需要在我们想要监控的敏感方法增加一行代码注解，相当
Spring AOP切面实现日志管理及获取更多的参数入库
asdfghjkl521947的博客
11-20 750
使用AOP切面基于注解实现日志功能 1.首先是先设计数据库的表结构 2.自定义注解，确定要通过注解获取的几个属性 3.编写切面和做入库处理 这边只写基于后台的代码逻辑 1.定义日志的实体类 public class apiLog{ private Long id; private String apiCode; private String apiName; public Long getId() { return id; } pu
项目中全局日志利用切面技术来处理
因为低调所以牛逼
08-26 437
现在项目中利用切面技术很容易处理异常，以下是我的给出的一个实践项目中处理异常日志的案例。 1.首先区分@Pointcut注解中execution属性定义： expression="execution(* com.controller.*.*(..))" 切入点为com.controller包下的类的任意方法 expression="execution(* com.controller..*.*(..))" 切入点为com.controller包下子包的类的任意方法 实例： 项目中一般要定位c...
SpringBoot(9) --全局日志切面处理并且保存请求，返回参数到数据库
CoreyXuu的博客
06-19 1235
文章目录功能说明上代码 功能说明 全局日志处理，保存请求参数和返回参数到数据库，并且自定义注解 如下图所示： 上代码 首先数据库为： CREATE TABLE `cl_sys_log` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id', `username` varchar(20) COLLATE utf8_bin DEFAULT NULL COMMENT '操作者', `operation` varchar(25) COLLATE utf
1、springboot中使用AOP切面完成全局日志
小邹的博客
02-03 1801
ProceedingJoinPoint对象是JoinPoint的子接口,该对象只用在@Around的切面方法中,注：下面只是实现了在控制台打印日志信息，我们在末尾可添加一个插入方法，插入此次收获的所有信息存储进日志表中。注：可不用声明，默认开启且使用的是 JDK（即接口方式的动态代理，如果需要使用类的动态代理就需要将。注：第二个依赖可选择不用，本质就是将数据 JSON 化、使用阿里的也行(后期出错再改)其次，此实现只AOP类控制层的方法，其他层也可照此。1、在配置 AOP 切面之前，我们需要了解下。
如何利用切面全局处理异常？
qq_20446879的博客
05-23 431
切面控制器代码： package com.example.empboxwarehousing.config; import com.example.empboxwarehousing.common.exception.BusinessException; import com.example.empboxwarehousing.common.response.WebResult; import lombok.extern.slf4j.Slf4j; import org.springframework
aop注解方式实现全局日志管理方法
08-28
AOP注解方式实现全局日志管理方法是一种使用Aspect-Oriented Programming（面向方面编程）技术来实现日志管理的方法。该方法使用Java的注解方式来实现日志记录，能够对应用程序的日志进行统一管理。 知识点一：AOP...
利用springmvc切面捕获全局异常入库源码
12-12
"利用SpringMVC切面捕获全局异常入库源码"这个项目正是为了实现这样的功能，即通过面向切面编程（AOP）的方式捕获并记录全局异常，然后将这些异常信息存储到数据库中。下面我们将详细探讨相关的知识点。 首先，让...
解决springboot的aop切面不起作用问题(失效的排查)
08-19
SpringBoot中的AOP（Aspect-Oriented Programming）切面是指在业务逻辑中添加的额外功能，以实现日志记录、安全检查、事务管理等功能。但是，在实际开发中，我们可能会遇到AOP切面不起作用的问题。下面我们将介绍...
Spring Boot : 全局异常处理与自定义切面
u012129340的博客
04-06 1836
工程地址：https://github.com/showsys20/spring-demo-cm.git 1.Spring提供了便利的异常捕获机制，采用注解@ExceptionHandler(具体Exception.class)就可以了。全局的异常可以通过定义专门的异常处理类加上注解@ControllerAdvice来实现。下面是个简单的例子。 @ControllerAdvice @Slf4...
RecordLog操作日志
07-16
顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶
Spring boot中使用aop详解
热门推荐
tianyaleixiaowu的专栏
04-27 2万+
aop是spring的两大功能模块之一，功能非常强大，为解耦提供了非常优秀的解决方案。 现在就以springboot中aop的使用来了解一下aop。 一：使用aop来完成全局请求日志处理 创建一个springboot的web项目，勾选aop，pom如下： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="htt
操作日志统一处理（切面）
qq_32627651的博客
03-02 1231
1，简介： 日志切面可以通过在方法上加注解，记录操作日志入库 具体参考：https://www.cnblogs.com/inspred/p/10385005.html 2，上代码 org.springframework.boot spring-boot-starter-aop <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver&l
springboot添加全局日志aop
猿脑2.0的博客
06-14 439
在 Spring Boot 中添加全局日志 AOP（面向切面编程）可以通过定义一个切面（Aspect）来实现。切面允许你在不修改实际业务逻辑的情况下，对方法执行进行拦截和处理。完成以上步骤后，你的 Spring Boot 应用程序就会在匹配的方法执行前后添加日志记录了。最后，不要忘记在 Spring Boot 的主类或配置类上添加。，它会在方法成功执行后打印一条日志，包括方法的名称和返回值。确保你的切面类被 Spring 托管，可以通过在类上添加。，它会在方法执行前打印一条日志，以及一个后置通知。
后台管理系统 -- @OperateLog记录操作日志
放码过来
11-30 3985
开篇说明 如果在这里获得过启发和思考，希望点赞支持！对于内容有不同的看法欢迎来信交流。 技术栈 >> java 邮箱 >> 15673219519@163.com 描述 后台记录操作日志是一个非常普遍的功能，几乎可以涉及到所有的后台管理接口。所以一个方便使用的日志记录工具，将会简化开发中的代码重复。于是我想实现下面的效果：通过注解@OperateLog 可填写日志内容占位符{0},可传入请求参数中的值。 @OperateLog(content = "设置用户id:{0}临时密
@OperateLog注解 Spring 日志Log
wufaqidong1的博客
05-14 2564
Spring开发中， 1、对于重要的日志数据，需要做持久化处理， 2、日志数据的记录，方便开发人员查看。 添加日志记录的逻辑，只需要在Service层方法上加入@OperateLog注解即可。
AOP全局切面编程
weixin_51591918的博客
08-27 167
package com.zhonggu.websocket.config.webService; import com.zhonggu.websocket.until.controller.AbstractBaseController; import com.zhonggu.websocket.until.json.JsonUntil; import lombok.Data; import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.JoinPoi
springboot学习四：全局捕获异常使用的是AOP的切面技术
Nancy
08-25 2269
@ExceptionHandler(RuntimeException.class)：表示拦截异常；@ControllerAdvice(basePackages = {"com.whut.springboot1.controller"})是 controller 的一个辅助类；可以指定扫描包范围；有几种可行的返回model+@ResponseBody,String:跳转到某个view;modelA...
切面实现Dubbo请求日志以及全局异常处理
xue632777974的博客
05-13 2677
一、背景 项目中经常会看到在所有的Rpc接口实现中记录请求参数，以及try catch，每个方法都来一次，看着就不舒服，类似下面这段代码 public CloudServerResponse<Boolean> updateExpressInfo(SendAppraisalExpressParam sendAppraisalExpressParam) { log.info("updateExpressInfo:{}",JSON.toJSONString(sendAppraisal
springboot 全局controller切面
最新发布
09-26
Spring Boot 中全局Controller切面通常是指使用Spring AOP (Aspect Oriented Programming) 来创建一个可以跨越多个控制器的行为拦截器，比如日志记录、权限验证、性能统计等。通过定义一个切面（Aspect），你可以在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值