自定义注解AOP注解完成日志记录

最新推荐文章于 2024-03-29 11:25:15 发布
最新推荐文章于 2024-03-29 11:25:15 发布
阅读量282 收藏
点赞数
分类专栏： springboot 文章标签： java intellij-idea spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43990465/article/details/122924051
版权

@自定义注解AOP注解完成日志记录

创建一个注解 @interface

在这里插入图片描述

public @interface User {
    String value() default "";
}

创建一个切面

在这里插入图片描述
1、配置一个织入点，使用注解就会进来

/**
     * 配置织入点
     */
    
    //配置切入点
    @Pointcut("@annotation(com.zhang.validator.User)")
    public void UserCut() {}

2、切点
（第一种）

@Around("UserCut()")
    public void log(ProceedingJoinPoint pointcut) throws Throwable {
        //获取传入参数
        Object result = pointcut.proceed();
        //获取返回参数
        System.out.println(pointcut.getArgs());
    }*

（第二种）

 /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "UserCut()")
    public void doAfterReturning(JoinPoint joinPoint){
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        //获取参数
//获取方法
        String classType = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName(); //获取方法名称

        System.out.println("进入切点，准备开切");
       // HttpServletRequest request = WebUtils.getRequest();
        saveSysAccessLog(joinPoint, request, null);

    }

2、异常

@AfterThrowing(pointcut = "logPointCut()", throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Throwable e) {
        log.info("系统抛出异常，保存日志信息");
        HttpServletRequest request = WebUtils.getRequest();
        asyncTaskExecutor.execute(() -> saveSysAccessLog(joinPoint, request, e));
    }

完整代码在最后

aop执行顺序

在这里插入图片描述

aop异常执行顺序
*加粗样式

完整代码

controller

 @PostMapping("/dologin")
    @com.zhang.validator.User
    public String  dologin(@RequestBody User user){
        System.out.println(user.getName());
        return "adfasdfas";
    }

自定义注解

public @interface User {
    String value() default "";
}

UserAspectj

@Aspect
@Component
public class UserAspectj {
    private Long beginTime;

    /**
     * 配置织入点
     */
    @Pointcut("@annotation(com.zhang.validator.User)")
    public void UserCut() {}


   /* @Around("UserCut()")
    public void log(ProceedingJoinPoint pointcut) throws Throwable {
        //获取传入参数
        Object result = pointcut.proceed();
        //获取返回参数
        System.out.println(pointcut.getArgs());
    }*/

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "UserCut()")
    public void doAfterReturning(JoinPoint joinPoint){
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        //获取参数
//获取方法
        String classType = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName(); //获取方法名称

        System.out.println("进入切点，准备开切");
       // HttpServletRequest request = WebUtils.getRequest();
        saveSysAccessLog(joinPoint, request, null);

    }

    /*@AfterThrowing(pointcut = "logPointCut()", throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Throwable e) {
        log.info("系统抛出异常，保存日志信息");
        HttpServletRequest request = WebUtils.getRequest();
        asyncTaskExecutor.execute(() -> saveSysAccessLog(joinPoint, request, e));
    }*/
    /**
     * 用于记录用户的操作日志描述
     */
    private void saveSysAccessLog(JoinPoint joinPoint, HttpServletRequest request, Throwable e) {

        // 执行时间
       /* long time = System.currentTimeMillis() - beginTime;
        System.out.println("执行时间:"+time);*/

        // 用户操作描述
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();


        // 请求方法名
        String typeName = signature.getDeclaringTypeName();
        String methodName = signature.getName();
        System.out.println("方法明"+typeName + "." + methodName + "()");

        // 请求参数
        Object[] args = joinPoint.getArgs();
        System.out.println("请求参数："+args);

        // 请求路径
        String requestPath = request.getRequestURI();
        System.out.println("请求路径："+requestPath);

        // 请求方式
        String requestType = request.getMethod();
        System.out.println("请求方式："+requestType);

        // 请求时间
        Date date = new Date();
        System.out.println("请求时间："+date);

        // ip地址
        String ip = WebUtils.getIpAddress(request);
        System.out.println("ip地址："+ip);

        User user = (User) request.getSession().getAttribute("user");
        System.out.println(user.getName());


    }
}

webutils

/**
 * Http与Servlet工具类.
 */
public class WebUtils {

    /**
     * 获取request对象
     */
    public static HttpServletRequest getRequest() {
        return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    }

    /**
     * 获取Response对象
     */
    public static HttpServletResponse getResponse() {
        return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
    }

    /**
     * 获取Session对象
     */
    public static HttpSession getSession() {
        return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest().getSession();
    }

    /**
     * 获取IP地址
     *
     * @param request
     * @return
     */
    public static String getIpAddress(HttpServletRequest request) {
        String unknown = "unknown";
        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.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();
        }
        //对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
        if (ip != null && ip.length() > 0) {
            String[] ips = ip.split(",");
            if (ips.length > 0) {
                ip = ips[0];
            }
        }
        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
    }

    /**
     * 从request中获得参数，并返回可读的Map
     * application/x-www-form-urlencode
     * application/json
     * application/json;charset=UTF-8
     * multipart/form-data
     *
     * @param request
     * @return
     */
    public static Map<String, String> getParameterMap(HttpServletRequest request) {
        String contentType = request.getHeader(org.springframework.http.HttpHeaders.CONTENT_TYPE);
        Map<String, String> returnMap = new HashMap();
        if (contentType != null && contentType.contains(MediaType.MULTIPART_FORM_DATA_VALUE)) {
            // form-data表单
            MultipartResolver multipartResolver = SpringUtils.getBean(MultipartResolver.class);
            MultipartHttpServletRequest multiReq = multipartResolver.resolveMultipart(request);
            returnMap = conventMap(multiReq.getParameterMap());
        } else if (MediaType.APPLICATION_JSON_VALUE.equals(contentType) || MediaType.APPLICATION_JSON_UTF8_VALUE.equals(contentType)) {
            // json表单
            String body = getBodyString(request);
            if (StringUtils.isNotBlank(body)) {
                try {
                    returnMap = JSONObject.parseObject(body, Map.class);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } else {
            // 普通表单
            returnMap = conventMap(request.getParameterMap());
        }
        // 参数Map
        return returnMap;
    }

    private static Map conventMap(Map map) {
        Map<String, String> returnMap = new HashMap();
        // 返回值Map
        Iterator entries = map.entrySet().iterator();
        Map.Entry entry;
        String name = "";
        String value = "";
        while (entries.hasNext()) {
            entry = (Map.Entry) entries.next();
            name = (String) entry.getKey();
            Object valueObj = entry.getValue();
            if (null == valueObj) {
                value = "";
            } else if (valueObj instanceof String[]) {
                String[] values = (String[]) valueObj;
                if (values != null && values.length > 0) {
                    for (int i = 0; i < values.length; i++) {
                        value = values[i] + ",";
                    }
                    value = value.substring(0, value.length() - 1);
                }
            } else {
                value = valueObj.toString();
            }
            returnMap.put(name, value);
        }
        return returnMap;
    }

    /**
     * 获取请求Body.
     *
     * @param request
     * @return
     */
    public static String getBodyString(final ServletRequest request) {
        StringBuilder sb = new StringBuilder();
        InputStream inputStream = null;
        BufferedReader reader = null;
        try {
            inputStream = cloneInputStream(request.getInputStream());
            reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
            String line = "";
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }

    /**
     * 复制输入流.
     *
     * @param inputStream 读取http请求传入的数据
     * @return byteArrayInputStream
     */
    public static InputStream cloneInputStream(ServletInputStream inputStream) {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        try {
            while ((len = inputStream.read(buffer)) > -1) {
                byteArrayOutputStream.write(buffer, 0, len);
            }
            byteArrayOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        InputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        return byteArrayInputStream;
    }
}
长街长呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMVC利用AOP实现自定义注解记录日志
10-14
SpringMVC利用AOP实现自定义注解记录日志
自定义注解-aop实现日志记录
niceyoo的博客
05-22 784
自定义注解-aop实现日志记录 关于注解，平时接触的可不少，像是 @Controller、@Service、@Autowried 等等，不知道你是否有过这种疑惑，使用 @Service 注解的类成为我们的业务类，使用 @Controller 注解的类就成了请求的控制器，使用 @Autowried 注解的类就会帮我们实现自动注入… 以前，我们只...
SpringBoot自定义注解实现接口日志记录
最新发布
Clozzz的博客
03-29 327
springboot aop注解实现项目日志记录
自定义注解完成日志AOP
weixin_48907384的博客
07-01 247
1、定义注解 2、定义一个AOP切面类示例一个前置通知： 3、在需要加入日志的地方按照注解的属性加入自己的实际需求
自定义注解+AOP实现请求日志记录
远处
07-22 477
需求描述： 在所有的接口中记录客户端发送过来的请求。记录信息包括： 请求链接 请求类型 请求IP 请求描述等… 实现效果： 1、自定义注解 package com.nys.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotati
spring aop 自定义注解保存操作日志到mysql数据库 源码
11-25
4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 （需要知道原理的请看spring aop源码，此处不做赘述） 3、...
springMVC自定义注解,用AOP来实现日志记录的方法
08-28
下面小编就为大家分享一篇springMVC自定义注解,用AOP来实现日志记录的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
aop注解方式实现全局日志管理方法
08-28
下面小编就为大家分享一篇aop注解方式实现全局日志管理方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
spring AOP自定义注解方式实现日志管理的实例讲解
08-28
下面小编就为大家分享一篇spring AOP自定义注解方式实现日志管理的实例讲解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
自定义注解的方式使用AOP写日志
yx15156537218的博客
03-11 297
这里用比较原生的方式实现比较利于学习和理解。 1、环境准备 创建一个maven工程并导入以下依赖 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version>
使用aop，基于注解记录日志
没故事的码农的博客
12-30 250
背景：最近项目有个需求就是需要记录访问指定方法（可能是CRUD中任意一个方法）的日志 思路： 我最先想到的是 基于mybatis 的拦截执行器 来实现，参考上篇文章。 但是我需要传递各个方法的一些信息，这个貌似不容易做到 于是基于 aop aspectj ，可以完成对日志操作的记录 步骤 一： 导入依赖 这里碰到了一个坑，就是 aspectware版本不能太低， 不然启动会报以下错误 invalid byte tag in constant pool: 18 我是1.8的j.
SpringAop（自定义注解）实现用户操作日志记录
gp_911014的博客
04-02 4777
1.简介 在使用spring完成项目的时候需要完成记录日志，开始以为Spring 的AOP功能，就可以轻松解决，半个小时都不用，可是经过一番了解过后，发现一般的日志记录，只能记录一些简单的操作，例如表名、表名称等记录不到。 这个时侯就用到了自定义注解，把想要记录的内容放在注解中，通过切入点来获取到注解参数，然后将参数插入数据库记录 2.Spring AOP 2.1.关于Spring AOP的一些术语 切面（Aspect）：在Spring AOP中，切面可以使用通用类或者在普通类中以@Aspec
自定义注解的应用场景
服务端开发进阶之路
08-23 385
参考：https://blog.csdn.net/weixin_36380516/article/details/108396260 应用场景：自定义注解+AOP 实现日志打印 先导入切面需要的依赖包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </d...
自定义注解+AOP记录访问日志
u010738038的专栏
04-06 387
1、问题描述 AOP拦截请求，记录请求参数、返回参数及响应时间，以前已经介绍过了，但是发现有个小问题，就是有些心跳或者仅仅是查询字典下拉框的请求，本身不用记录，排除的话，需要一个一个排除，有点麻烦，就用自定义注解对aop记录请求与返回做了下改进，简单记录下。 2、解决方案 简单说就是新建个自定义注解标签，然后对需要记录日志的方法加上标签就可以了。 2.1 自定义标签 importjava.lang.annotation.*; @Documented @Retention(RetentionP.
自定义注解+AOP实现日志管理
m0_59047431的博客
10-12 228
AOP实现 日志 基本上复制就能用
Aop+自定义注解实现查看操作日志
单俞浩的博客
06-19 1012
Aop+自定义注解实现操作日志查看
自定义注解，aop实现自定义注解的日志功能
qq_37948985的博客
03-17 201
功能：使用aop实现自定义注解日志记录 1、定义注解 LogAutoannotation @Documented @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface LogAutoannotation { /* 接口描述 */ String ...
springboot自定义注解aop
04-30
在Spring Boot中，使用自定义注解和AOP可以非常方便地实现一些特定的功能，例如权限控制、日志记录等。 实现自定义注解和AOP需要完成以下几个步骤： 1. 定义注解：定义一个注解，可以设置一些属性。 2. 声明切面...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值