SpringAOP实现日志的管理

最新推荐文章于 2023-07-30 10:04:17 发布
最新推荐文章于 2023-07-30 10:04:17 发布
阅读量277 收藏
点赞数
分类专栏： spring框架 文章标签： SpringAOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CLA1989/article/details/88581540
版权

一、配置文件（springMVC-servlet.xml）

<mvc:annotation-driven/>     
    <!-- 设置使用注解的类所在的包 -->
    <context:component-scan base-package="com.mapuni.controller.*"/>
    <!-- 注解方式实现aop -->
    <aop:aspectj-autoproxy/>
    <bean id="systemLogAspect" class="com.mapuni.spring.logaop.SystemLogAspect"></bean>

二、注解

package com.mapuni.spring.logaop;

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;

/**
 * 日志切面注解
 * @author chenla
 *
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MethodOperateLog {
    /** 要执行的操作类型比如：add操作 **/  
    public String operationType() default "";  
    /** 要执行的具体操作比如：添加用户 **/  
    public String operationName() default "";
    /**操作的模块**/
    public String moduleName() default "";

}
三、切面

package com.mapuni.spring.logaop;

import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Calendar;

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.Aspect;
import org.aspectj.lang.annotation.Pointcut;
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.mapuni.entity.oa.LogManage.XtRzSql;
import com.mapuni.security.user.MapuniUserDetails;
import com.mapuni.service.oa.LogManage.LogService;
import com.mapuni.utils.IpAddressUtil;
import com.mapuni.utils.StringUtil;

/**
 * 日志切面实现
 */
@Component
@Aspect
public class SystemLogAspect {

    @Autowired
    private LogService logService;
    
    private  static  final Logger logger = LoggerFactory.getLogger(SystemLogAspect. class);

    public SystemLogAspect() {
        System.out.println("Aop");
    }

    /**
     * Controller层切点
     */

    //这种切点是根据注解配在那个方法就对那个方法作用
    @Pointcut("@annotation(com.mapuni.spring.logaop.MethodOperateLog)")

     //这种切点配置方式是根据方法的名字来决定切点的作用方法
    //@Pointcut("execution(* com.mapuni.controller.oa.SystemOperation.*(..))")
    public void controllerAspect() { }
    
    /**
     * 前置通知，用于拦截Controller层记录用户的操作
     * @param jp 切点
     */
    //@Before("controllerAspect()")
    public void doBefore(JoinPoint jp){
        System.out.println("==========执行controller前置通知===============");
        if(logger.isInfoEnabled()){
            logger.info("before " + jp);
        }
    }
    

    /**
     * 配置controller环绕通知，使用在方法aspect()上注册的切入点
     */
    //@Around("controllerAspect()")
    public void around(JoinPoint joinPoint){
        System.out.println("==========开始执行controller环绕通知===============");
        long start = System.currentTimeMillis();
        try {
            ((ProceedingJoinPoint) joinPoint).proceed();
            long end = System.currentTimeMillis();
            if(logger.isInfoEnabled()){
                logger.info("around " + joinPoint + "\tUse time : " + (end - start) + " ms!");
            }
            System.out.println("==========结束执行controller环绕通知===============");
        } catch (Throwable e) {
            long end = System.currentTimeMillis();
            if(logger.isInfoEnabled()){
                logger.info("around " + joinPoint + "\tUse time : " + (end - start) + " ms with exception : " + e.getMessage());
            }
        }
    }
    /**
     * 后置通知，用于拦截Controller层记录用户的操作
     * @param joinPoint
     */
    @After("controllerAspect()")
    public void after(JoinPoint joinPoint){
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder
                .getRequestAttributes()).getRequest();
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
        Calendar ca = Calendar.getInstance();
        String operDate = df.format(ca.getTime());
        //得到ip地址
        String ip = IpAddressUtil.getIp(request);
        try {
            String targetName = joinPoint.getTarget().getClass().getName();
            //方法签名
            String methodName = joinPoint.getSignature().getName();
            //方法参数
            Object[] arguments = joinPoint.getArgs();
            Class targetClass = Class.forName(targetName);
            Method[] methods = targetClass.getMethods();
            String operationType = "";
            String operationName = "";
            String moduleName = "";
            for (Method method : methods) {  
                if (method.getName().equals(methodName)) {  
                    Class[] clazzs = method.getParameterTypes();  
                    if (clazzs.length == arguments.length) {  
                        operationType = method.getAnnotation(MethodOperateLog.class).operationType();
                        operationName = method.getAnnotation(MethodOperateLog.class).operationName();
                        moduleName = method.getAnnotation(MethodOperateLog.class).moduleName();
                        break;  
                    }  
                }  
            }
            //*================控制台输出===============*//
            System.out.println("========controller后置通知开始=============");
            String packages = joinPoint.getThis().getClass().getName();
            // 如果是CGLIB动态生成的类
            if (packages.indexOf("$$EnhancerByCGLIB$$") > -1) { 
                try {
                    packages = packages.substring(0, packages.indexOf("$$"));
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            //被监测方法的request对象
            HttpServletRequest req = (HttpServletRequest) arguments[0];
            //*==============数据库日志===========*//
            XtRzSql sysLog = new XtRzSql();
            //主键
            sysLog.setPkid(StringUtil.getUUID_32());
            //用户id
            sysLog.setUserid(MapuniUserDetails.getCurrentUserId());
            //用户名
            String username = MapuniUserDetails.getCurrentUser().getUsername();
            sysLog.setUsername(username);
            //操作时间
            sysLog.setKssj(operDate);
            //ip地址
            sysLog.setIpaddress(ip);
            //方法名
            sysLog.setMethodname(packages + "." + methodName);
            //操作模块名字
            sysLog.setModulename(moduleName);
            /**
             * 版本管理模块
             */
            if("删除操作".equals(operationType)){
                sysLog.setOperatingcontent("删除版本：版本id为"+req.getParameter("id"));
            }
            //保存数据库
            logService.saveSysLog(sysLog);
            System.out.println("=========controller后置通知结束================");
        } catch (Exception e) {
            //记录本地异常日志
            logger.error("===后置通知异常===");
            logger.error("异常信息：{}", e.getMessage());
        }
        
    }

   //配置后置返回通知，使用在方法aspect()上注册的切入点
    //@AfterReturning("controllerAspect()")
    public void afterReturn(JoinPoint joinPoint){
        System.out.println("=====执行controller后置返回通知======");
        if(logger.isInfoEnabled()){
            logger.info("afterReturn " + joinPoint);
        }
    }

    /** 
     * 异常通知 用于拦截记录异常日志 
     * @param joinPoint 
     * @param e 
     */  
    //@AfterThrowing(pointcut = "controllerAspect()", throwing="e")  
    public  void doAfterThrowing(JoinPoint joinPoint, Throwable e) {  
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();  
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
        Calendar ca = Calendar.getInstance();
        String operDate = df.format(ca.getTime());
        //得到ip地址
        String ip = IpAddressUtil.getIp(request);
        //得到用户id
        String userid = MapuniUserDetails.getCurrentUserId(); 
//        String params = "";
//        if (joinPoint.getArgs() !=  null && joinPoint.getArgs().length > 0) {  
//            for ( int i = 0; i < joinPoint.getArgs().length; i++) {  
//                params += JsonUtil.getJsonStr(joinPoint.getArgs()[i]) + ";";  
//            }  
//        }  
        try {  
            String targetName = joinPoint.getTarget().getClass().getName();  
            String methodName = joinPoint.getSignature().getName();  
            Object[] arguments = joinPoint.getArgs();  
            Class targetClass = Class.forName(targetName);  
            Method[] methods = targetClass.getMethods();
            String operationType = "";
            String operationName = "";
            for (Method method : methods) {  
                if (method.getName().equals(methodName)) {  
                    Class[] clazzs = method.getParameterTypes();  
                    if (clazzs.length == arguments.length) {  
                        operationType = method.getAnnotation(MethodOperateLog.class).operationType();
                        operationName = method.getAnnotation(MethodOperateLog.class).operationName();
                    break;  
                }  
            }  
                }
            String packages = joinPoint.getThis().getClass().getName();
            // 如果是CGLIB动态生成的类
            if (packages.indexOf("$$EnhancerByCGLIB$$") > -1) { 
                try {
                    packages = packages.substring(0, packages.indexOf("$$"));
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        /*========控制台输出=========*/  
        System.out.println("=====异常通知开始=====");  
        System.out.println("异常代码:" + e.getClass().getName());  
        System.out.println("异常信息:" + e.getMessage());  
        System.out.println("异常方法:" + (joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()")+"."+operationType);  
        System.out.println("方法描述:" + operationName);  
        System.out.println("请求人id:" + userid);  
        System.out.println("请求IP:" + ip);  
//        System.out.println("请求参数:" + params);  
        //*==============数据库日志===========*//
        XtRzSql sysLog = new XtRzSql();
        sysLog.setPkid(StringUtil.getUUID_32());
        sysLog.setUserid(MapuniUserDetails.getCurrentUserId());
        String username = request.getParameter("userName");
        sysLog.setUsername(username);
        sysLog.setKssj(operDate);
        sysLog.setIpaddress(ip);
        sysLog.setMethodname(packages + "." + methodName);
        //TODO
        sysLog.setModulename("");
        //保存数据库
        logService.saveSysLog(sysLog);
        System.out.println("=====异常通知结束=====");  
        }  catch (Exception ex) {  
            //记录本地异常日志  
            logger.error("==异常通知异常==");  
            logger.error("异常信息:{}", ex.getMessage());  
        }  
            /*==========记录本地异常日志==========*/  
//            logger.error("异常方法:{}异常代码:{}异常信息:{}参数:{}", joinPoint.getTarget().getClass().getName() + joinPoint.getSignature().getName(), e.getClass().getName(), e.getMessage(), params);  
    }  

}
四、添加注解的测试

@RequestMapping(value = "/deleteInspection")
    @MethodOperateLog(moduleName="设置——>运维管理——>版本管理",operationType="删除操作",operationName="删除服务器版本")
    public void deleteInspection(HttpServletRequest request, PrintWriter pw) {

        try {
            String id = request.getParameter("id");
            int count = inspectionService.deleteInspection(id);
            if (count > 0) {
                pw.print(GlobalConstants.RESULT_PRINT_SUCCESS);
            } else {
                pw.print(GlobalConstants.RESULT_PRINT_ERROR);
            }
        } catch (Exception e) {
            e.printStackTrace();
            pw.print(GlobalConstants.RESULT_PRINT_ERROR);
            logger.error(e.getMessage());
        }
        pw.flush();
        pw.close();
    }

CLA1989
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring aop实现日志分析管理
01-02
在Spring AOP（面向切面编程）中实现日志分析管理是一种常见的做法，它能帮助开发者跟踪和理解系统运行过程中的行为，同时提供详细的错误日志以支持运维工作。通过元注解的方式，我们可以轻松地将日志记录功能集成到...
@AfterThrowing
weixin_30265103的博客
07-13 458
@AfterThrowing(throwing="ex", pointcut="within(com.xms.controller.*)") public void four(Exception ex){ System.out.println("four"); ex.printStackTrace();//打印异常信息 StackTraceElement []elements=ex.get...
SpringBoot AOP @AfterThrowing+自定义注解+自定义异常使用
weixin_44316557的博客
10-31 1966
springboot aop的使用
开始使用AspectJ-@AfterThrowing ,@After ,@Pointcut 定义切入点（比较重要）
weixin_48370579的博客
11-05 1263
开始使用AspectJ(接下来的作为了解就行) 1. [了解]@AfterThrowing 异常通知-注解中有 throwing 属性 在目标方法抛出异常后执行。该注解的 throwing 属性用于指定所发生的异常类对象。 当然，被注解为异常通知的方法可以包含一个参数 Throwable，参数名称为 throwing 指定的 名称，表示发生的异常对象。 接口： package com.bjp...
开启了全局异常处理，AOP日志处理中@AfterThrowing失效场景
qq_42102911的博客
05-12 3455
在实际业务场景中，我们通常会使用全局异常处理机制，也就是在业务代码发生异常的时候，拦截异常并进行统一的处理，然后以Json格式返回给前端。同时我们也会使用AOP进行操作日志记录，在不发生异常时，可以使用四种advice@After(“”)。当发生异常时，使用@AfterThrowing(value = “”,throwing = “e”)进行日志记录。
Spring AOP: 0 formal unbound in pointcut(Spring AOP)
sinat_34338162的博客
11-19 1684
 @Pointcut("execution(* com.user.action.AopController.*(..))")     public  void controllerAspect() {       }       @After("controllerAspect()")       public  void after( HttpServletRequest request,...
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
Spring Aop之AspectJ注解配置实现日志管理的方法 Spring Aop是基于AspectJ实现的面向切面编程（AOP），它提供了一个灵活的方式来实现日志管理。通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查...
spring AOP自定义注解方式实现日志管理的实例讲解
08-28
Spring AOP 自定义注解方式实现日志管理的实例讲解 在本文中，我们将探讨如何使用 Spring AOP 实现日志管理，并使用自定义注解方式来记录日志信息。这种方式可以灵活地实现日志管理，提高系统的可维护性和可扩展性...
spring aop实现日志功能 开发技术-其它
06-13
Spring AOP（面向切面编程）是一种强大的工具，可以用来优雅地实现日志功能。下面我们将深入探讨如何使用Spring AOP来实现日志功能，以及这一技术的核心概念和应用场景。 首先，Spring AOP是Spring框架的一个核心...
spring aop实现用户权限管理的示例
08-28
AOP（Aspect-Oriented Programming）在实际项目中运用的场景主要有权限管理（Authority Management）、事务管理（Transaction Management）、安全管理（Security）、日志管理（Logging）和调试管理（Debugging）等。...
Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2
08-22
Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2
SpringMVC利用AOP实现自定义注解记录日志
10-14
SpringMVC利用AOP实现自定义注解记录日志
SpringAOP日志管理
01-06
采用SpringAOP拦截Controller，Service实现操作日志管理，统一处理异常，登陆日志管理，是SpringAOP的应用实践。通过SpringAOP的处理，可以方便移植日志管理功能，是个不错的学习demo
详解基于SpringBoot使用AOP技术实现操作日志管理
08-25
主要介绍了详解基于SpringBoot使用AOP技术实现操作日志管理，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Spring AOP的原理及使用实例
乐点的博客
08-10 286
一、Spring AOP中的一些概念 切面（Aspect）：切入业务流程的一个独立模块。“切面”在ApplicationContext中<aop:aspect>来配置。 连接点（Joinpoint）：业务流程在运行过程中需要插入切面的具体位置。 通知（Advice）：切面的具体实现方法。可分为前置通知（Before）、后置通知（AfterReturning）、异常通知（Aft...
spring AOP实现日志管理
haiboSun的博客
03-16 4990
前言 spring AOP是使用spring提供的切面来横向拓展项目，使得一些和主业务无关的操作尽可能实现解耦，比如说我们经常使用的日志。 注： 需要用到pom文件 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 实操 1、编写一个自
SpringBoot学习笔记之AOP全局统一日志管理
编程火箭车（Coding Rocket）专注编程领域
04-09 4079
我们开发的 Web 系统都会有日志模块，用来记录对数据有进行变更的操作。一般都会记录请求的 URL，请求的 IP，执行的方法，操作人员等等。其目的可能是为了保留操作痕迹，防抵赖，或是记录系统运行情况，再有就是审计要求。抛开杂念，静下心来，只看当下；充电片刻，日积月累，步步向前。
使用Spring Boot AOP实现日志记录
最新发布
一名想当程序员的人
07-30 3548
1.1 什么是AOPAOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一（两外两个：IOC-控制反转、DI-依赖注入）。那么AOP为何那么重要呢？在我们的程序中，经常存在一些系统性的需求，比如权限校验、日志记录、统计等，这些代码会散落穿插在各个业务逻辑中，例如下面这个示意图：有多少业务操作，就要写多少重复的校验和日志记录代码，这显然是无法接受的。
Spring中Aop实现日志功能
qq_37400096的博客
06-10 1763
Spring中实现aop自定义注解实现日志功能。
Spring AOP与事务管理详解
在Spring框架中，AOP（面向切面编程）被广泛用于实现事务管理。AOP提供了一种在不改变原有代码结构的情况下，插入额外功能（如事务控制）的方式，使得业务逻辑与系统服务（如日志、安全、事务）解耦。Spring通过动态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值