基于Spring的AspectJ操作日志实现

最新推荐文章于 2024-03-22 16:36:29 发布

weixin_34284188

最新推荐文章于 2024-03-22 16:36:29 发布

阅读量146

点赞数

文章标签： python java runtime

原文链接：https://my.oschina.net/u/3413394/blog/1540801

版权

2019独角兽企业重金招聘Python工程师标准>>>

前言

前段日子项目部分方法访问需要记录相对应的用户和前后变化的值，为了减免代码的重复性，提高代码的可复用性。特定采用面向切面的注解形式来实现操作日志记录。

AOP简单概念介绍

常见术语

切面(Aspect)：一个关注点的模块化,比如日志、事务，这个关注点可能会横切多个对象，一个类，里面有各种通知方法
连接点(JoinPoint) 程序执行过程中的某个特定的切入点，比如service层login()方法被调用执行时，login()方法就是一个连接点
通知(Advice) 在切面的某个特定的连接点上执行的动作，有前置通知、后置通知等等，是一个具体方法
切入点(Pointcut) 匹配连接点的断言，在AOP中通知和一个切入点表达式关联，就是一个表达式(在Aspectj注解中是一个空方法)，把连接点和通知联通起来
引入(Introduction) 在不修改类代码的前提下,为类添加新的方法和属性
目标对象(Target Object) 被一个类或者多个切面所通知的对象，业务对象，比如LoginServiceImpl对象
AOP代理(AOP Proxy) AOP框架创建的对象,用来实现切面契约(包括通知方法执行等功能)，AOP并不直接使用目标对象，而通过动态代理生产目标对象的代理对象
织入(Weaving) 把切面连接到其它的应用程序或者对象上,并创建一个被通知的对象,分为:编译时织入/类加载时织入/执行时织入，生成代理对象的过程

五种通知类型

Before 在方法被调用之前调用
After 在方法完成后调用通知，无论方法是否执行成功
After-returning 在方法成功执行之后调用通知
After-throwing 在方法抛出异常后调用通知
Around 通知了好、包含了被通知的方法，在被通知的方法调用之前后调用之后执行自定义的行为

引入相关jar包

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.2</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>

配置文件配置

<!-- @描述：proxy-target-class为true选择CGLib来生成AOP代理类，无或默认用 JDK 动态代理。即使你未声明 proxy-target-class="true" ，但运行类没有继承接口，spring也会自动使用CGLIB代理。 高版本spring自动根据运行类选择 JDK 或 CGLIB 代理
JDK动态代理是模拟接口实现的方式，cglib是模拟子类继承的方式，一般采用前者，因为前者效率高。后者不建议使用，除非非用不可-->
	<aop:aspectj-autoproxy />

构造注解接口

package com.demo.base.aop;


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

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface opLog {

    /**
     * 要执行的操作码比如：add操作
     **/
    int opCode() default 0;

    /**
     * 要执行的具体操作比如：添加用户
     **/
    String opName() default "";

    /**
     * 更改前备注
     **/
    String beforeRemark() default "";

    /**
     * 更改后备注
     **/
    String afterRemark() default "";

}

实现操作日志处理逻辑类

package com.demo.base.aop;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * <p>Description:记录操作日志</p>
 * <p>Author:Gred</p>
 * <p>Date:2017/9/19 19:28</p>
 * <p>version:1.0</p>
 **/
@Aspect
@Component
public class AdminLogAop {

    @Autowired
    private HttpServletRequest request;

    //@描述：方法前处理逻辑
    @Before("@annotation(opLog)")
    public void logInfo() {
        //记录开始时间
        request.setAttribute("startTime", System.currentTimeMillis());
    }

    //@时间：2017/9/19 20:39
    //@描述：方法后处理逻辑
    @After("@annotation(opLog)")
    public void logAfter(){
        long entTime = System.currentTimeMillis();
        Long startTime = (Long) request.getAttribute("startTime");
        System.out.println("方法耗时："+(entTime-startTime)+"ms");
    }

    //@描述：方法环绕处理逻辑
    @Around("@annotation(opLog)")
    public Object logInfoAround(ProceedingJoinPoint pjp) throws Throwable {

        //执行方法，获取方法的返回值获取方法返回值
        Object object =  pjp.proceed();
        //根据返回值，判断判断该方法是否有执行成功
        //获取操作码和操作说明
        Map<String, Object> map = getLogParameter(pjp, request);
        //进行操作日志插入记录处理
        System.out.println("插入成功");

        return object;
    }

    /**
     * <p>Description:获取注解中对方法的描述信息 用于Controler层注解</p>
     * <p>Author:Gred</p>
     * <p>Date:2017/9/19 19:57</p>
     * <p>param:joinPoint</p>
     **/
    public static Map<String, Object> getLogParameter(ProceedingJoinPoint pjp, HttpServletRequest request)
            throws Exception {

        Map<String, Object> map = new HashMap<String, Object>();
        String targetName = pjp.getTarget().getClass().getName();//获取目标类的名称
        String methodName = pjp.getSignature().getName();//获取目标方法名
        Object[] arguments = pjp.getArgs();//返回目标方法的参数
        Class targetClass = Class.forName(targetName);//加载目标类
        Method[] methods = targetClass.getMethods();//获取该目标类的所有方法

        String opName = "";
        String beforeRemark = "";
        String afterRemark = "";
        int opCode = 0;
        //获取注解中参数值【下一步需要根据里面的值来当做参数名 从封装好的map里获取值】
        for (Method method : methods) {
            if (method.getName().equals(methodName)) {//判断方法名是否一致
                Class[] clazzs = method.getParameterTypes();
                if (clazzs.length == arguments.length) {//判断参数个数是否一致
                    opName = method.getAnnotation(opLog.class).opName();
                    opCode = method.getAnnotation(opLog.class).opCode();
                    beforeRemark = method.getAnnotation(opLog.class).beforeRemark();
                    afterRemark = method.getAnnotation(opLog.class).afterRemark();
                    break;
                }
            }
        }

        //将隐射成RequestParam的参数封装一个map=
        Map<String, Object> paramMap = changMap(pjp);
        //根据从注解接口中获取的参数名，在从map获取我们需要的值
        beforeRemark = paramMap.get(beforeRemark) == null ? "" : String.valueOf(paramMap.get(beforeRemark));
        afterRemark = paramMap.get(afterRemark) == null ? "" : String.valueOf(paramMap.get(afterRemark));

        map.put("opCode", opCode);
        map.put("opName", opName);
        map.put("beforeRemark", beforeRemark);
        map.put("afterRemark", afterRemark);

        return map;
    }

    //@描述：从切点中中获取已经映射好的参数,因为不确定request的类型，所以只能够通过映射封装好
    //的参数来获取参数值，参数一定要用方法@RequestParam接收
    private static Map<String, Object> changMap(ProceedingJoinPoint pjp) {
        Signature signature = pjp.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        String[] strings = methodSignature.getParameterNames();//获取该方法所有参数
        Object[] args = pjp.getArgs();
        List<String> list = Arrays.asList(strings);
        Map<String, Object> map = new HashMap<String, Object>();
        for (int i = 0; i < args.length; i++) {
            map.put(list.get(i), args[i]);
        }

        return map;
    }


}

使用方法

@RequestMapping("/index.page")
    public String test(){
        return "/demo/index";
    }

    @opLog(opCode = 1,opName = "test",beforeRemark = "beforeRemark",afterRemark = "afterRemark")
    @RequestMapping("/testAop.page")
    public String testAop(@RequestParam String beforeRemark,
                          @RequestParam String afterRemark,
                          @RequestParam String test,
                          Model model){

        model.addAttribute("test",test);
        return "/demo/success";
    }

结果

获取到参数：{opName=test, afterRemark=test, beforeRemark=test, opCode=1}
插入成功
方法耗时：0ms

项目地址

感谢以下博客作者的文章

转载于:https://my.oschina.net/u/3413394/blog/1540801