springAOP进行自定义注解，用于方法的处理

最新推荐文章于 2024-04-29 16:49:23 发布
最新推荐文章于 2024-04-29 16:49:23 发布
阅读量4.5k 收藏 3
点赞数
文章标签： aop spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011191463/article/details/77747639
版权

本文采用的spring boot进行配置

maven 引入

     <!-- spring boot aop starter依赖 -->  
       <dependency>
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-aop</artifactId>  
        </dependency>  

 

application.properties文件开启aop注解

spring.aop.auto = true;

 

自定义注解类

 

 

package com.kuaixin.crm.crm_tsale_kx_service.service.anno;

import java.lang.annotation.*;

/**
 *自定义注解 拦截service
 */

@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SystemServiceType {
    /**
     * 方法描述
     * @return
     */
    String description()  default "";

    /**
     * 方法类型 0 表示不进行处理，1 表示进行处理
     * @return
     */
    int type() default 0;

    /**
     * 类的元数据,用于指定需要转换为的目标格式
     * @return
     */
    Class classType();
}

 

 

 

 

切点类

package com.kuaixin.crm.crm_tsale_kx_service.service.anno;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 2017/8/31.
 * @desc 定义切点类，无论是前置通知还是后置通知、环绕通知以及异常通知，都需要在指定的方法上加上SystemServiceType注释就会生效
 * 还可以在通知中记录日志
 */
@Component // 注册到Spring容器，必须加入这个注解
@Aspect // 该注解标示该类为切面类，切面是由通知和切点组成的。
public class SystemServiceTypeAspect {

    //注入Service用于把日志保存数据库
  /*  @Resource
    private LogService logService;*/

    //日志记录对象
    private final static Logger log = LogManager.getLogger(SystemServiceTypeAspect.class);

    //Service层切点
    @Pointcut("@annotation(com.kuaixin.crm.crm_tsale_kx_service.service.anno.SystemServiceType)")
    public  void serviceAspect() {
    }

    //controller层切点 com.kuaixin.crm.crm_tsale_kx_service.service.anno.SystemServiceType可以指定另外定义的注释接口
    @Pointcut("@annotation(com.kuaixin.crm.crm_tsale_kx_service.service.anno.SystemServiceType)")
    public  void controllerAspect() {
    }

    /**
     *对某个方法返回的结果进行处理后，如将entity转换为与前端交互的vo
     */
    @Around(value = "serviceAspect()")
    public Object aroundProcess(ProceedingJoinPoint pjp) throws Throwable {

        Object retVal = pjp.proceed();
         //*==========记录本地异常日志==========*//*
        //logger.error("异常方法:{}异常代码:{}异常信息:{}参数:{}", joinPoint.getTarget().getClass().getName() + joinPoint.getSignature().getName(), e.getClass().getName(), e.getMessage(), params);

        //需要转换为的vo对象Class
        Class vClass = getClassByAnno(pjp);

        //数组或集合对象
        if(retVal.getClass().isArray()||retVal instanceof List){
            List list = new ArrayList<>();
            for(Object origin:(List)retVal){
                Object dest = vClass.newInstance();
                BeanUtils.copyProperties(dest,origin);
                list.add(dest);
            }
            return list;
        }
        //单个对象
        Object dest = vClass.newInstance();
        BeanUtils.copyProperties(dest,retVal);

        return dest;
    }

    /**
     * 前置通知
     *
     * @param joinPoint 切点
     */
    @Before("serviceAspect()")
    public  void doBefore(JoinPoint joinPoint) {
        //获得http请求
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        //读取session中的用户
        //User user = (User) session.getAttribute(WebConstants.CURRENT_USER);
        //请求的IP
        String ip = request.getRemoteAddr();
        try {
            String desc = getServiceMthodDescription(joinPoint);
            log.info("getServiceMthodDescription："+desc);
        } catch (Exception e) {
            log.error("aop处理异常：", e);
        }

    }

    /**
     * 后置通知
     *
     * @param joinPoint 切点
     */
    @After("serviceAspect()")
    public  void doAfter(JoinPoint joinPoint) {
        try {
            String desc = getServiceMthodDescription(joinPoint);
            log.info("getServiceMthodDescription："+desc);
        } catch (Exception e) {
            log.error("aop处理异常：", e);
        }

    }


    /**
     * 异常通知 用于拦截service层记录异常日志
     *
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(pointcut = "serviceAspect()", throwing = "e")
    public  void doAfterThrowing(JoinPoint joinPoint, Throwable e) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        //读取session中的用户
       // User user = (User) session.getAttribute(WebConstants.CURRENT_USER);
        //获取请求ip
        String ip = request.getRemoteAddr();
        //获取用户请求方法的参数并序列化为JSON格式字符串
        String params = "";
        if (joinPoint.getArgs() !=  null && joinPoint.getArgs().length > 0) {

        }

        //日志记录操作..............
    /*    Log log = SpringContextHolder.getBean("logxx");
        log.setDescription(getControllerMethodDescription(joinPoint));
        log.setMethod((joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));
        log.setType("0");
        log.setRequestIp(ip);
        log.setExceptionCode( null);
        log.setExceptionDetail( null);
        log.setParams( null);
        log.setCreateBy(user);
        log.setCreateDate(DateUtil.getCurrentDate());
        //保存数据库
        logService.add(log);*/


    }

    /**
     * 获取注解中对方法的描述信息type等 用于service层注解k
     *
     * @param joinPoint 切点
     * @return 方法描述
     * @throws Exception
     */
    public static String getServiceMthodDescription(JoinPoint joinPoint)
            throws Exception {
        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 description = "";
        for (Method method : methods) {
            if (method.getName().equals(methodName)) {
                Class[] clazzs = method.getParameterTypes();
                if (clazzs.length == arguments.length) {
                    SystemServiceType serviceType = method.getAnnotation(SystemServiceType.class);
                    //得到对应的方法结果
                    Class clazz = serviceType.classType();
                    int type = serviceType.type();
                    description = serviceType.description();
                    log.info("type:" + type);
                    break;
                }
            }
        }
        return description;
    }

    /***
     * 获取aop拦截到的方法注解的Class
     * @param pjp
     * @return
     */
    public static Class getClassByAnno(ProceedingJoinPoint pjp){
        Class<?> aClass = pjp.getTarget().getClass();
        Method[] methods = aClass.getMethods();

        for (Method method : methods) {
            Annotation[] annotations = method.getAnnotations();
            for (Annotation annotation : annotations) {
                // 获取注解的具体类型
                Class<? extends Annotation> annotationType = annotation.annotationType();
                //比较当前方法注解是否是SystemServiceType注解
                if (SystemServiceType.class == annotationType) {
                    log.info("方法：" + method.getName() + "()\t" + SystemServiceType.class.getName());
                    SystemServiceType serviceType = method.getAnnotation(SystemServiceType.class);
                    //得到对应的方法结果
                    Class clazz = serviceType.classType();
                    int type = serviceType.type();
                    String desc = serviceType.description();

                    return clazz;
                }
            }
        }
        return null;
    }


}
        Object retVal = pjp.proceed();
         //*==========记录本地异常日志==========*//*
        //logger.error("异常方法:{}异常代码:{}异常信息:{}参数:{}", joinPoint.getTarget().getClass().getName() + joinPoint.getSignature().getName(), e.getClass().getName(), e.getMessage(), params);

        //需要转换为的vo对象Class
        Class vClass = getClassByAnno(pjp);

        //数组或集合对象
        if(retVal.getClass().isArray()||retVal instanceof List){
            List list = new ArrayList<>();
            for(Object origin:(List)retVal){
                Object dest = vClass.newInstance();
                BeanUtils.copyProperties(dest,origin);
                list.add(dest);
            }
            return list;
        }
        //单个对象
        Object dest = vClass.newInstance();
        BeanUtils.copyProperties(dest,retVal);

        return dest;
    }

    /**
     * 前置通知
     *
     * @param joinPoint 切点
     */
    @Before("serviceAspect()")
    public  void doBefore(JoinPoint joinPoint) {
        //获得http请求
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        //读取session中的用户
        //User user = (User) session.getAttribute(WebConstants.CURRENT_USER);
        //请求的IP
        String ip = request.getRemoteAddr();
        try {
            String desc = getServiceMthodDescription(joinPoint);
            log.info("getServiceMthodDescription："+desc);
        } catch (Exception e) {
            log.error("aop处理异常：", e);
        }

    }

    /**
     * 后置通知
     *
     * @param joinPoint 切点
     */
    @After("serviceAspect()")
    public  void doAfter(JoinPoint joinPoint) {
        try {
            String desc = getServiceMthodDescription(joinPoint);
            log.info("getServiceMthodDescription："+desc);
        } catch (Exception e) {
            log.error("aop处理异常：", e);
        }

    }


    /**
     * 异常通知 用于拦截service层记录异常日志
     *
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(pointcut = "serviceAspect()", throwing = "e")
    public  void doAfterThrowing(JoinPoint joinPoint, Throwable e) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        //读取session中的用户
       // User user = (User) session.getAttribute(WebConstants.CURRENT_USER);
        //获取请求ip
        String ip = request.getRemoteAddr();
        //获取用户请求方法的参数并序列化为JSON格式字符串
        String params = "";
        if (joinPoint.getArgs() !=  null && joinPoint.getArgs().length > 0) {

        }

        //日志记录操作..............
    /*    Log log = SpringContextHolder.getBean("logxx");
        log.setDescription(getControllerMethodDescription(joinPoint));
        log.setMethod((joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));
        log.setType("0");
        log.setRequestIp(ip);
        log.setExceptionCode( null);
        log.setExceptionDetail( null);
        log.setParams( null);
        log.setCreateBy(user);
        log.setCreateDate(DateUtil.getCurrentDate());
        //保存数据库
        logService.add(log);*/


    }

    /**
     * 获取注解中对方法的描述信息type等 用于service层注解k
     *
     * @param joinPoint 切点
     * @return 方法描述
     * @throws Exception
     */
    public static String getServiceMthodDescription(JoinPoint joinPoint)
            throws Exception {
        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 description = "";
        for (Method method : methods) {
            if (method.getName().equals(methodName)) {
                Class[] clazzs = method.getParameterTypes();
                if (clazzs.length == arguments.length) {
                    SystemServiceType serviceType = method.getAnnotation(SystemServiceType.class);
                    //得到对应的方法结果
                    Class clazz = serviceType.classType();
                    int type = serviceType.type();
                    description = serviceType.description();
                    log.info("type:" + type);
                    break;
                }
            }
        }
        return description;
    }

    /***
     * 获取aop拦截到的方法注解的Class
     * @param pjp
     * @return
     */
    public static Class getClassByAnno(ProceedingJoinPoint pjp){
        Class<?> aClass = pjp.getTarget().getClass();
        Method[] methods = aClass.getMethods();

        for (Method method : methods) {
            Annotation[] annotations = method.getAnnotations();
            for (Annotation annotation : annotations) {
                // 获取注解的具体类型
                Class<? extends Annotation> annotationType = annotation.annotationType();
                //比较当前方法注解是否是SystemServiceType注解
                if (SystemServiceType.class == annotationType) {
                    log.info("方法：" + method.getName() + "()\t" + SystemServiceType.class.getName());
                    SystemServiceType serviceType = method.getAnnotation(SystemServiceType.class);
                    //得到对应的方法结果
                    Class clazz = serviceType.classType();
                    int type = serviceType.type();
                    String desc = serviceType.description();

                    return clazz;
                }
            }
        }
        return null;
    }


}
 

 

 

service或controller层调用


 

@SystemServiceType(type = 1,description = "根据pcode获取下级列表",classType = SysDictionaryInfoVO.class)
    public Object getChildDicVosByPcode(String pcode) throws Exception{


        List<SysDictionaryInfo> dictionaryInfos = dictionaryInfoMapper.selectChildDictionaryByPcode(pcode);


        List<SysDictionaryInfoVO> sysDictionaryInfoVOs = new ArrayList<SysDictionaryInfoVO>();


        return dictionaryInfos;


    }

这里将会对返回结果dictionaryInfos为SysDictionaryInfo集合，在Around环绕通知进行结果的转换，返回的结果为SysDictionaryInfoVO，

 

由于转换前和转换后的类型不一样，所有需要定义方法的返回类型为Object

 

此外，可以在前置通知、异常通知等通知中进行日志的处理

 

 

参考：http://blog.csdn.net/czmchen/article/details/42392985

           http://blog.csdn.net/liuchuanhong1/article/details/55099753

 

追不上老鼠的猫
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详解使用Spring AOP和自定义注解进行参数检查
08-27
使用Spring AOP和自定义注解进行参数检查 了解使用Spring AOP和自定义注解进行参数检查的技术细节。通过自定义注解和spring AOP，我们可以实现参数的校验，提高代码的可读性和可维护性。 自定义注解 在本篇文章中...
Spring之Aop的注解配置
qq_41458842的博客
07-31 134
1.首先要添加jar包 2.写方法接口 public interface calculate { int add(int i, int j); int sub(int i, int j); int mul(int i, int j); int div(int i, int j); } 3.写方法...
Spring Aop 和 自定义注解的使用的详解
m0_57764322的博客
12-13 2538
什么是AOP AOP，Spring框架的两大核心之一，又称面向切面编程，通过代理模式，对原有的类进行增强。在Spring框架中，AOP有两种动态代理方式，其一是基于JDK的动态代理，需要代理的类实现某一个接口；其二是基于CGLIB的方式，该方式不需要类实现接口就能进行代理。AOP的应用场景，常见的就是事务的处理和日志的记录，还有权限的认证。（笔者使用AOP的场景：保存所有用户对数据进行的增删改内容等，比如，张三修改了一个表格数据的值，就需要记录谁，什么时候，修改or添加or删除，哪项数据，...
spring自定义注解及使用
最新发布
qq_43985303的博客
04-29 1125
在spring项目中使用注解，简化了代码量，减轻对业务代码的侵入性；对框架统一处理鉴权、日志等起到极大的作用，可以结合着拦截器、aop在请求调用前后添加额外处理。spring有内置的@Controller、@Service等注解，出于业务考虑，我们可以自定义想要的注解。自定义注解类似于定义接口，但是需要指明注解的作用范围、生命周期等属性。
自定义注解 +AOP
m0_46192647的博客
07-13 7236
自定义注解
【SpringBoot】AOP 自定义注解的使用详解
yuxiangdeming的博客
07-06 5103
AOP 的全称为 Aspect Oriented Programming，译为面向切面编程，是通过预编译方式和运行期动态代理实现核心业务逻辑之外的横切行为的统一维护的一种技术。AOP 是面向对象编程（OOP）的补充和扩展。利用 AOP 可以对业务逻辑各部分进行隔离，从而达到降低模块之间的耦合度，并将那些影响多个类的公共行为封装到一个可重用模块，从而到达提高程序的复用性，同时提高了开发效率，提高了系统的可操作性和可维护性。AOP 是 Spring 框架中的一个核心内容。
自定义注解实现AOP
qq_45774645的博客
09-28 3350
从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。/*** @return 操作类型}/*** 定义切点} /*** 切点后置通知* @param joinPoint 切点* @param result 返回结果。
spring AOP自定义注解方式实现日志管理的实例讲解
08-28
Spring AOP 自定义注解方式实现日志管理的实例讲解 在本文中，我们将探讨如何使用 Spring AOP 实现日志管理，并使用自定义注解方式来记录日志信息。这种方式可以灵活地实现日志管理，提高系统的可维护性和可扩展性...
Spring Boot 通过AOP和自定义注解实现权限控制的方法
08-25
Spring Boot 通过 AOP 和自定义注解实现权限控制的方法 在本文中，我们将探讨如何使用 Spring Boot 通过 Aspect-Oriented Programming（AOP）和自定义注解来实现权限控制。权限控制是任何应用程序的重要组件，它...
Spring AOP 自定义注解的实现代码
08-30
在 Spring AOP 中，我们可以使用 AspectJ 来织入自定义注解，以便在方法执行前后执行相应的处理逻辑。例如： ```java <aop:aspectj-autoproxy proxy-target-class="true"> <aop:include name="controllerAspect" /...
spring aop+自定义注解+反射实现统一校验脚手架
05-24
工程介绍：SpringBoot项目脚手架，利用spring aop+java反射实现自定义注解校验参数 源码里有使用都例子在DemoContorller example1：校验userName参数必填 @CheckParams(notNull = true) private String userName;...
SpringAop（自定义注解）实现用户操作日志记录
yjt520557的博客
12-19 4302
1.简介 我在使用spring完成项目的时候需要完成记录日志，我开始以为Spring 的AOP功能，就可以轻松解决，半个小时都不用，可是经过一番了解过后，发现一般的日志记录，只能记录一些简单的操作，例如表名、表名称等记录不到。这个时侯就用到了自定义注解，把想要记录的内容放在注解中，通过切入点来获取到注解参数，然后将参数插入数据库记录 2.Spring AOP 对于Spring Aop的基本介...
【Java注解系列】内置注解与AOP实现自定义注解
qq_35789269的博客
03-27 4181
1、深入理解Java注解类型(@Annotation)_zejian_的博客-CSDN博客_java注解 2、java之aop使用及自定义注解 - 沦陷 - 博客园 3、SpringAOP中的JointPoint和ProceedingJoinPoint使用详解（附带详细示例）_如何在5年薪百万的博客-CSDN博客_proceedingjoinpoint有什么用 ...
aop实现自定义注解
CelineT的博客
05-25 1430
添加依赖写需要的注解/** 请求类型 *//** 接口类型 */定义切面@Aspect@Component// 类名// 方法名// 开始时间// 执行方法 proceed就是返回值// 结束时间// 获取入参// 获取注解中apiType的值System.out.println("类名:" + className + ";方法名:" + methodName + ";开始时间:" + startTime + "；结束时间:" + endTime);
Aop之自定义注解用法与用途-切点与切面
suqinyi的博客
12-30 2016
Aop之自定义注解使用与介绍 切面注解说明 @Before: 前置通知, 在方法执行之前执行 @After: 后置通知, 在方法执行之后执行 @AfterRunning: 返回通知, 在方法返回结果之后执行 @AfterThrowing: 异常通知, 在方法抛出异常之后 @Around: 环绕通知, 围绕着方法执行 后置通知的执行顺序.. 1. 案例一：简单使用前置后置通知-顺序问题 2. 案例二：自定义注解，记录接口调用的耗时时间 3. 当然也有`校验是否重复提交`、`登入权限校验`等拓展使用...
使用Aop实现自定义注解 - 原理篇
Mr.hu
07-31 5543
自定义注解的实现 本次我们将使用Spring boot 和AOP 实现自定义注解，主要功能是自动打日志。 元注解 元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解： 1.@Target,说明了Annotation所修饰的对象范围 　　　　2.@Retention,定义了该Annotation生命周期（编译/运行） 　　　　3.@Documented,是一个标记注解，没有成员
自定义注解与AOP结合使用
Ying_hao_kun的博客
09-16 1317
注解（Annotation）是Java语言的一种元数据（metadata）机制，它提供了一种在代码中添加额外信息的方式。注解可以用于标记代码的特定元素，如类、方法、字段、参数等，以便在编译时、运行时或者通过工具进行处理。注解相关类都包含在包中。自定义注解是开发者根据自己的需求创建的注解。通过自定义注解，开发者可以为代码添加特定的元数据信息，并定义相应的处理逻辑。使用@interface关键字定义一个注解类型。在注解中定义需要的元素，可以包括基本类型、枚举类型、Class类型、注解类型等。
JVM基础（二）：运行时数据区
一只修仙的猿
10-21 297
前言 很高兴遇见你~ 欢迎阅读我的文章。 在上一篇文章JVM基础（一）：认识虚拟机中，介绍了什么是虚拟机，以及字节码class文件。这一篇文章主要讲关于JVM的运行时数据区结构。 我们知道，c/c++在内存上划分为了栈和堆区，栈区存放函数的局部变量等，堆区为用户自主开辟的空间。当开发者需要新建一个对象时，首先需要在堆区中开辟一个空间，再初始化，使用。最后需要自己手动去释放该内存区域。而JVM把这些工作都做好了，当我们需要新建一个对象的时候，只需要一个关键字new即可创建一个对象，当我们不再使用这个对象的时候
【SpringBoot】SpringBoot 中的 Aop + 自定义注解
sco5282的博客
12-23 6347
在 SpringBoot 中使用 Aop
怎么使用spring aop 切入自定义注解？
09-13
通过以上步骤，我们可以使用Spring AOP方便地切入自定义注解，实现对目标类或方法的增强、日志记录、权限控制等功能。 ### 回答3： 使用Spring AOP切入自定义注解需要以下几个步骤： 1. 定义一个自定义的注解。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值