spring——基于注解的AOP

于 2024-03-25 15:40:54 发布
阅读量1.1k 收藏 14
点赞数 32
分类专栏： 框架 文章标签： spring java 后端 eclipse 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43905491/article/details/137015955
版权
文章介绍了如何在Java中使用AOP（面向切面编程）实现接口Calculator的扩展，以添加日志功能，同时讨论了代码解耦的问题和基于注解的SpringAOP配置。作者演示了如何在Calculator接口的实现类中加入日志通知，并展示了如何使用@Aspect和@Pointcut注解进行切面编程。
摘要由CSDN通过智能技术生成

3.1、场景模拟

3.1.1、声明接口

声明计算器接口Calculator，包含加减乘除的抽象方法

public interface Calculator {
    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.1.2 、创建实体类
public class CalculatorPureImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}
3.1.3、改变需求

为了提高系统安全，现需要加入日志功能，用户的每一步操作，都需要计入日志里。

传统做法：

public class CalculatorLogImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        System.out.println("[日志] 用户xxx操作 add 方法开始了，参数是：" + i + "," + j);
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] add 方法结束了，结果是：" + result);
        return result;
    }
    @Override
    public int sub(int i, int j) {
        System.out.println("[日志]用户xxx操作 sub 方法开始了，参数是：" + i + "," + j);
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] sub 方法结束了，结果是：" + result);
        return result;
    }
    @Override
    public int mul(int i, int j) {
        System.out.println("[日志]用户xxx操作 mul 方法开始了，参数是：" + i + "," + j);
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] mul 方法结束了，结果是：" + result);
        return result;
    }
    @Override
    public int div(int i, int j) {
        System.out.println("[日志]用户xxx操作 div 方法开始了，参数是：" + i + "," + j);
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] div 方法结束了，结果是：" + result);
        return result;
    }
}
3.1.4、 提出问题
①现有代码缺陷

针对带日志功能的实现类，我们发现有如下缺陷：

  • 对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力

  • 附加功能分散在各个业务功能方法中，不利于统一维护

②解决思路

解决这两个问题，核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。

③困难

解决问题的困难：要抽取的代码在方法内部，靠以前把子类中的重复代码抽取到父类的方式没法解决。所以需要引入新的技术。

3.2、AOP概念以及相关术语

3.2.1、概述

AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

①切面

需要添加额外功能的类

②通知

每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

  • 前置通知：在被代理的目标方法前执行

  • 返回通知：在被代理的目标方法成功结束后执行（寿终正寝）

  • 异常通知：在被代理的目标方法异常结束后执行（死于非命）

  • 后置通知：在被代理的目标方法最终结束后执行（盖棺定论）

  • 环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所

③切点

切面的功能插入到哪里去执行的路径。

3.2.2、作用

  • 简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。

  • 代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。

3.3 基于注解的AOP

3.3.1 配置工作

  1. 需要的依赖

    aspectjrt-1.5.3.jar

    aspectjweaver-1.9.9.jar

    spring-aspects-5.2.22.RELEASE.jar

  2. 配置

    创建 applicationContext.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd 
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!-- 开始基于注解的AOP -->
    <context:component-scan base-package="com.AOP.test"></context:component-scan>   
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  </beans>

  1. 功能编码

    • 功能接口

      package com.AOP.test;
​
public interface Calculator {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}

    • 实现类

      package com.AOP.test;
​
import org.aspectj.lang.annotation.Aspect;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
​
@Component
public class CalculatorImpl implements Calculator{
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}
      ​

  2. 切面编码 

    //@Aspect表示这个类是一个切面类
@Aspect
//@Component注解保证这个切面类能够放入IOC容器  也可以换成@controller等
@Component
public class LoggerAspect {
    
  //切点  要添加改切面功能的类的路径
    @Pointcut("execution(* com.AOP.test.CalculatorImpl.*(..))")
    public void poincut() {
        
    }
    
  //前置通知
    @Before("poincut()")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
        }
  //后置通知
    @After("poincut()")
     public  void afterMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println("Logger-->后置通知，方法名："+methodName+"，参数："+args);
    }
    //返回通知
    @AfterReturning(value = "poincut()",returning = "result")
    public void afterReturningMethod(JoinPoint joinPoint, Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Logger-->返回通知，方法名："+methodName+"，结果："+result);
    } 
  //异常通知
  @AfterThrowing(value = "poincut()", throwing = "ex")
    public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Logger-->异常通知，方法名："+methodName+"，异常："+ex);
    }
    
      //环绕通知
    @Around("poincut()")
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
           String methodName = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        Object result = null;
           try {
               System.out.println("环绕通知-->目标对象方法执行之前");
               //目标对象（连接点）方法的执行
               result = joinPoint.proceed();
               System.out.println("环绕通知-->目标对象方法返回值之后");
        } catch (Throwable throwable) {
               throwable.printStackTrace();
               System.out.println("环绕通知-->目标对象方法出现异常时");
        } finally {
            System.out.println("环绕通知-->目标对象方法执行完毕");
        }
        return result;
    }

  3. 测试

        public static void main(String[] args) {
        // TODO Auto-generated method stub
        ApplicationContext ac= new ClassPathXmlApplicationContext("applicationContext3.xml");
        Calculator calculator = ac.getBean(Calculator.class);
        calculator.div(1, 3);//连接点
    }

  4. 结果

    环绕通知-->目标对象方法执行之前
Logger-->前置通知，方法名：div，参数：[1, 3]
方法内部 result = 0
环绕通知-->目标对象方法返回值之后
环绕通知-->目标对象方法执行完毕
Logger-->后置通知，方法名：div，参数：[1, 3]
Logger-->返回通知，方法名：div，结果：0

陈(chen)
关注
专栏目录
Spring——基于 ApsectJ 的注解的 AOP 开发
casey_xiaoxin的博客
09-25 473
一个初学者的学习笔记 文章目录一、注解版与XML版的利弊1.什么是Spring注解？2.注解与XML版的利弊3.ApsrctJ二、正片开始1.环境搭建1.1导入所需要的jar包1.2配置xml文件2.具体实现2.1编写目标类2.2编写切面类2.3编写测试类三、AOP 的注解切入点的配置作用：备注说明： 一、注解版与XML版的利弊 1.什么是Spring注解？ 注解就是将原本需要在xml文件中进行注入的步骤，进行了封装整理，使得开发更高效， 常用的注解有： @Autowired @Repository .
Spring——IOC、AOP、7种事务传播
m0_38057941的博客
04-22 402
什么是IOC 什么是AOP 什么是事务 1.IOC 1.什么是控制反转？ 就是把创建和管理bean的过程交给第三方，而这个第三方就是IoC容器。 容器负责创建、配置和管理bean，也就是管理着bean的生命，控制着bean的依赖注入。 1. 为什么要用 IoC 这种思想呢？ 答：解藕。 本来ABCD是互相关联在一起的，当加入第三方容器的管理后，每个对象都和第三方Ioc容器相互关联，ABCD彼此不再联系，解除了耦合关系，全由容器来实现。 2. 什么是bean？——包装好了的Object B.
使用注解实现AOP
03-16
NULL 博文链接：https://elf8848.iteye.com/blog/436464
Spring源码学习(十八)---基于注解配置Aop的aspectj-autoproxy解析
https://juejin.cn/user/4248168663101239/posts
02-16 1465
这里主要是使用org.springframework:spring-beans:5.2.0.RELEASE进行分析 文章目录①. aspectj-autoproxy标签1. proxy-target-class属性2. expose-proxy属性②. aspectj-autoproxy标签解析③. DefaultBeanDefinitionDocumentReader类的parseBeanDefinitions方法④. 通过parseCustomElement解析自定义标⑤. Namespacehand.
使用spring注解方式的好处
chengaezakmi696的博客
08-05 2547
使用spring注解方式的好处 一、什么是spring注解 传统的Spring做法是使用.xml文件来对bean进行注入或者是配置aop、事物，这么做有两个缺点： 1、如果所有的内容都配置在.xml文件中，那么.xml文件将会十分庞大；如果按需求分开.xml文件，那么.xml文件又会非常多。总之这将导致配置文件的可读性与可维护性变得很低 2、在开发中在.java文件和.xml文件之间不断切...
3.4 AOP之基于注解的AOP和基于XML的AOP
qq_44774198的博客
08-02 361
AfterReturning中的属性returning，用来将通知方法的某个形参，接收目标方法的返回值。@AfterThrowing中的属性throwing，用来将通知方法的某个形参，接收目标方法的异常。获取连接点信息可以在通知方法的参数位置设置JoinPoint类型的形参。相同目标方法上同时存在多个切面时，切面的优先级控制切面的。参考基于注解的AOP环境。...
Spring AOP 注解和xml实现 --转载
weixin_34159110的博客
03-15 374
   AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向切面编程。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。我们现在做的一些非业务，如：日志、事务、安全等都会写在业务代码中(也即是...
基于注解的AOP
qq_47336547的博客
10-11 191
哈哈哈
Spring AOP——基于注解的AOP实现
最新发布
05-18
Spring AOP提供了基于注解的AOP实现，使得开发者可以通过注解的方式来定义切面、切点和通知等相关内容，从而简化了AOP的使用。 下面是一个基于注解的AOP实现的例子： 1. 定义切面类 ```java @Aspect @Component ...
基于注解方式声明切面(AOP)
04-05
NULL 博文链接：https://1028826685.iteye.com/blog/1517747
基于注解实现SpringAop
12-15
基于注解实现SpringAop基于注解实现SpringAop基于注解实现SpringAop
Spring通过注解实现AOP
04-17
Spring通过注解实现AOP，Spring通过注解实现AOP，Spring通过注解实现AOPSpring通过注解实现AOP，Spring通过注解实现AOP，Spring通过注解实现AOP
Spring之 AOP 代理模式 基于注解的AOP
小颖同学
08-03 244
把横切关注点封装到我们的类中，这个类叫做切面，（切面里的封装的每一个横切关注点都是一个通知）也就是说：你的非核心业务代码在目标对象中，叫横切关注点，把它抽取出来之后，放到一个切面类中，进行封装，我们的横切关注点在切面中表示为一个通知方法，（横切关注点是对目标对象来说的，抽取出来的非核心业务代码，通知针对把横切关注点封装到我们的切面中，而在切面中每一个横切关注点表示为一个通知方法）（把横切关注点封装到切面（封装通知方法的类）中，切面中的每个横切关注点都表示一个通知方法）： 封装通知方法的类。...
【Spring AOP】基于注解的 AOP 编程
萌宅鹿的技术小屋
05-31 2211
Spring AOP基于注解的 AOP 编程的开发开发步骤切入点复用切换动态代理的创建方式（JDK、Cglib）AOP 开发中的一个坑（业务方法互相调用）AOP 知识总结 更多内容请查看笔记目录：【Spring 5.x】学习笔记汇总 基于注解的 AOP 编程的开发 开发步骤 原始功能 public interface UserService { void register(User user); boolean login(String name, String password);
Spring--基于注解的AOP配置
龙源IT 的博客
09-17 537
SpringAOP基于注解的入门案例。
基于注解的AOP开发
weixin_60719453的博客
08-13 569
同xml配置aop一样。我们可以将切点表达式抽取，抽取方式是在切面内定义方法，早该方法上使用。③将目标类和切面类的对象创建权交给spring。⑤在配置文件中开启组件扫描和AOP的自动代理。定义切点表达式，然后在在增强注解中进行引用。①创建目标接口和目标类（内部有切点）快速入门，基于注解的aop开发步骤。④在切面类中使用注解配置织入关系。②创建切面类（内部有增强方法）MyAspect切面类下。AnnoTest测试类下。Interface类下。其中Target类下。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈(chen)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值