SpringAOP的简单理解

最新推荐文章于 2024-07-25 07:11:09 发布
最新推荐文章于 2024-07-25 07:11:09 发布
阅读量323 收藏
点赞数
文章标签： spring java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46012115/article/details/126682939
版权

SpringAOP

1、什么是SpringAOP

  • 面向切面编程 (AOP) 通过提供另一种思考程序结构的方式来补充面向对象编程 (OOP)。OOP 中模块化的关键单元是类，而 AOP 中模块化的单元是切面。切面支持跨多种类型和对象的关注点（例如事务管理）的模块化。（这种关注点在 AOP 文献中通常被称为“横切”关注点。）
  • Spring 的关键组件之一是 AOP 框架。虽然 Spring IoC 容器不依赖 AOP（这意味着如果您不想使用 AOP，则无需使用 AOP），AOP 补充了 Spring IoC 以提供非常强大的中间件解决方案。
  • Spring 通过使用 基于模式的方法或@AspectJ 注释样式提供了编写自定义切面的简单而强大的方法。这两种风格都提供了完全类型化的通知和使用 AspectJ 切入点语言，同时仍然使用 Spring AOP 进行织入。

AOP 在 Spring Framework 中用于：

  • 提供声明式企业服务。最重要的此类服务是 声明式事务管理。
  • 让用户实现自定义切面，用 AOP 补充他们对 OOP 的使用。

Spring AOP术语：

  • Aspect：跨多个类的关注点的模块化。事务管理是企业 Java 应用程序中横切关注点的一个很好的例子。在 Spring AOP 中，切面是通过使用常规类（基于模式的方法）或使用 @Aspect注解注释的常规类（@AspectJ 样式）来实现的。
  • Join point ：程序执行过程中的一个点，例如方法的执行或异常的处理。在 Spring AOP 中，一个连接点总是代表一个方法执行。
  • Advice ：切面在特定连接点采取的行动。不同类型的通知包括“环绕”、“之前”和“之后”通知。包括 Spring 在内的许多 AOP 框架将通知建模为拦截器，并在连接点周围维护一个拦截器链。
  • Pointcut ：匹配连接点的谓词。Advice 与切入点表达式相关联，并在与切入点匹配的任何连接点处运行（例如，执行具有特定名称的方法）。切入点表达式匹配的连接点的概念是 AOP 的核心，Spring 默认使用 AspectJ 切入点表达式语言。
  • Introduction ：代表一个类型声明额外的方法或字段。Spring AOP 允许您向任何通知的对象引入新接口（和相应的实现）。例如，您可以使用介绍使 bean 实现 IsModified接口，以简化缓存。（介绍在 AspectJ 社区中称为类型间声明。）
  • Target object ：一个或多个切面通知的对象。也称为“通知对象”。由于 Spring AOP 是使用运行时代理实现的，因此该对象始终是代理对象。
  • AOP proxy ：由 AOP 框架创建的对象，用于实现切面协定（通知方法执行等）。在 Spring Framework 中，AOP 代理是 JDK 动态代理或 CGLIB 代理。
  • Weaving ：将切面与其他应用程序类型或对象链接以创建通知对象。这可以在编译时（例如，使用 AspectJ 编译器）、加载时或运行时完成。Spring AOP 与其他纯 Java AOP 框架一样，在运行时执行织入。

Spring AOP 包括以下类型的通知：

  • 前置通知（Before advice）：在连接点之前运行但不能阻止执行流继续到连接点的通知（除非它抛出异常）。
  • 后置返回通知（After returning advice）：在连接点正常完成后运行的通知（例如，如果方法返回而没有引发异常）。
  • 后置抛出通知（After throwing advice）：如果方法因抛出异常而退出，则要执行的通知。
  • 后置通知（After（finally）advice）：无论连接点以何种方式退出（正常或异常返回），都要执行的通知。
  • 环绕通知（Around advice）：环绕连接点的通知，例如方法调用。这是最有力的建议。环绕通知可以在方法调用之前和之后执行自定义行为。它还负责选择是继续到连接点还是通过返回自己的返回值或抛出异常来缩短通知的方法执行。

2、使用Spring实现AOP

第一种方式：

导入依赖

<!--单元测试-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<!--aop-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>
<!--spring相关包-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>
<!--aspectj-->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.6.8</version>
</dependency>

项目结构

请添加图片描述
UserMapper接口

public interface UserMapper {

    void select();

    void add();

    void update();

    void delete();

}

UserMapperImpl

public class UserMapperImpl implements UserMapper{
    @Override
    public void select() {
        System.out.println("查询用户");
    }

    @Override
    public void add() {
        System.out.println("添加用户");
    }

    @Override
    public void update() {
        System.out.println("更新用户");
    }

    @Override
    public void delete() {
        System.out.println("删除用户");
    }
}

BeforeLog通知

public class BeforeLog implements MethodBeforeAdvice {
    /*
    * method:要执行的目标对象的方法
    * objects:要被调用的方法的参数
    * object:目标对象
    * */
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"的"+method.getName()+"执行了");
    }
}

AfterLog通知

public class AfterLog implements AfterReturningAdvice {

    /*
    * returnValue:返回值
    * method:要执行目标的对象的方法
    * args:执行方法的参数
    * target:执行目标
    * */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"执行了");
    }
}

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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userMapperImpl" class="com.yinzi.dao.UserMapperImpl"/>
    <bean id="beforeLog" class="com.yinzi.log.BeforeLog"/>
    <bean id="afterLog" class="com.yinzi.log.AfterLog"/>

    <!--aop配置-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.yinzi.dao.*Impl.*(..))"/>
        <!--通知-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

测试

public class MyTest {
    @Test
    public void test1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapperImpl", UserMapper.class);
        userMapper.select();
    }
}

测试结果

请添加图片描述

第二种方式：

项目结构

请添加图片描述

UserMapper接口

public interface UserMapper {

    void select();

    void add();

    void update();

    void delete();

}

UserMapperImpl

public class UserMapperImpl implements UserMapper{
    @Override
    public void select() {
        System.out.println("查询用户");
    }

    @Override
    public void add() {
        System.out.println("添加用户");
    }

    @Override
    public void update() {
        System.out.println("更新用户");
    }

    @Override
    public void delete() {
        System.out.println("删除用户");
    }
}

DiyPointcut

//自定义切入点
public class DiyPointcut {

    public void before(){
        System.out.println("======方法执行之前==========");
    }

    public void after(){
        System.out.println("======方法执行之后==========");
    }

}

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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userMapperImpl" class="com.yinzi.dao.UserMapperImpl"/>
    <bean id="diyPointcut" class="com.yinzi.log.DiyPointcut"/>

    <!--aop配置-->
    <aop:config>
        <!--切面-->
        <aop:aspect ref="diyPointcut">
            <!--切点-->
            <aop:pointcut id="pointcut" expression="execution(* com.yinzi.dao.*Impl.*(..))"/>
            <!--前置通知-->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <!--后置通知-->
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

</beans>

测试

public class MyTest2 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapperImpl", UserMapper.class);
        userMapper.select();
    }
}

测试结果

请添加图片描述

第三种方法（注解实现）

项目结构

请添加图片描述

UserMapper接口

public interface UserMapper {

    void select();

    void add();

    void update();

    void delete();

}

UserMapperImpl

public class UserMapperImpl implements UserMapper{
    @Override
    public void select() {
        System.out.println("查询用户");
    }

    @Override
    public void add() {
        System.out.println("添加用户");
    }

    @Override
    public void update() {
        System.out.println("更新用户");
    }

    @Override
    public void delete() {
        System.out.println("删除用户");
    }
}

AnnotationPointcut

@Aspect
public class AnnotationPointcut {

    @Before("execution(* com.yinzi.dao.*Impl.*(..))")
    public void before(){
        System.out.println("========注解:方法执行前=======");
    }

    @After("execution(* com.yinzi.dao.*Impl.*(..))")
    public void after(){
        System.out.println("========注解:方法执行后=======");
    }

    @Around("execution(* com.yinzi.dao.*Impl.*(..))")
    public Object around(ProceedingJoinPoint pj) throws Throwable {
        System.out.println("环绕前");
        System.out.println("签名:"+pj.getSignature());
        //执行目标方法proceed
        Object proceed = pj.proceed();
        System.out.println("环绕后");
//        System.out.println(proceed);
        return proceed;
    }

}

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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userMapperImpl" class="com.yinzi.dao.UserMapperImpl"/>


    <bean id="annotationPointcut" class="com.yinzi.log.AnnotationPointcut"/>

    <!--
    过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面
    的bean创建代理，织入切面。当然，spring 在内部依旧采用
    AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被
    <aop:aspectj-autoproxy />隐藏起来了
    <aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态
    代理织入增强，当配为<aop:aspectj-autoproxy poxy-target-class="true"/>时，表示使用
    CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接
    口，则spring将自动使用CGLib动态代理。
    -->
    <aop:aspectj-autoproxy/>

</beans>

测试

public class MyTest3 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapperImpl", UserMapper.class);
        userMapper.select();
    }
}

测试结果

请添加图片描述

以上就是spring-aop的简单理解了~~

寅子学Java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
SpringAop的简单理解.pdf
02-28
SpringAop的简单理解.pdf
SpringAOP简单理解
COS0度
01-30 692
1 SpringAOP是什么？ Aspect Oriented Programming：面向切面编程，是通过预编译方式和运行期动态代理的方式实现程序功能统一维护的一种技术。 2 SpringAOP的优劣势 2.1 优势 SpringAOP优势在于解耦，减少代码编写，提高开发效率，在不修改源代码的情况下对方法进行增强 2.2 缺点 3 底层实现 底层是依靠Spring提供的动态代理技术实现的，运行期间，Spring通过动态代理技术动态生成代理对象，代理对象方法在执行时相应的通知/增强方法进行及时介入，从而完成
Spring Aop简单理解
蓝星花
11-15 1459
1.简要描述aop概念： AOP就是在某一个类或方法执行前后打个标记，声明在执行到这里之前要先执行什么，执行完这里之后要接着执行什么。插入了新的执行方法。 切面编程，就是在你项目原有的功能基础上，通过AOP去添加新的功能，这些功能是建立在原有功能的基础上的，而且原有的功能并不知道你已经添加了新的功能。比如说，你去ATM取钱，取钱是一个功能，取完钱后向你的手机发送一条取钱信息，这就是新加的功能。
对Spring AOP的理解
qq_53999369的博客
06-14 1949
对SpringAOP的相关术语的理解和代理的思想
Spring AOP理解
I_m_j的博客
06-10 1481
Spring AOP基础解读
对Spring当中AOP的理解
2301_77707071的博客
01-28 1591
指切面在系统中要应用的位置,spring 中能够使用切面的位置为方法，所以连接指方法连接点指要调用某个方法时拦截到对这个方法的调用，做一些其他事情然后再执行目标方法拦截到的方法就是连接点。AOP就是把系统中重复的代码抽取出来，单独开发，在系统需要时，使用动态代理技术，在不修改源码的基础上，将单独开发的功能通知织入(应用)到系统中的过程，完成完整的代码逻辑。下面我们来看后置通知，通过上述的前置通知，我们可以推断出后置通知应该就是addUser()执行后进行通知的，下面我们来看看是不是这样的。
Spring的AOP的理解
郭晓冬
03-29 502
一、什么是AOP？ Spring AOP是OOP思想的补充和完善，OOP引进的是抽象、封装、继承和多态等的概念，它强调的是一个完整的事务自上而下的概念，对于事务的具体内部实现是不清楚的。OOP允许开发者定义的是纵向的关系，而AOP是定义的是横向的关系。这里就像日志功能，它的功能是横向的分布在所有对象层次中，与对象的核心代码功能是无关的，这样造成了大量代码的重用，不利于模块之间的重用。而AOP是利...
Spring AOP的理解
没有进步就是退步
07-05 452
本文旨在帮助还没有理解AOP的童鞋看透弄懂AOP，也欢迎高手批评指正。先说一个Spring是什么吧，大家都是它是一个框架，但框架这个词对新手有点抽象，以致于越解释越模糊，不过它确实是个框架的，但那是从功能的角度来定义的，从本质意义上来讲，Spring是一个库，一个Java库，所以我个人觉得应该这样回答Spring是什么：Spring是一个库，它的功能是提供了一个软件框架，这个框架目的是使软件之间的逻
谈谈对Spring AOP的理解
延宝小白马的博客
01-14 6841
首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而使得业务逻辑各部分之间的耦...
简单spring aop 例子
03-24
现在，我们来看如何创建一个简单的Spring AOP例子： 1. **定义切面（Aspect）**：切面是包含通知（Advice）和切入点（Pointcut）的类。通知定义了要执行的逻辑，切入点定义了何时执行。例如，我们可以创建一个名为`...
Spring Aop的简单实现
09-12
首先，我们需要理解Spring AOP的核心概念。切面（Aspect）是关注点的模块化，这些关注点定义了跨越多个对象的行为或责任。切点（Join Point）是程序执行中的特定点，如方法调用或异常处理。通知（Advice）是在特定...
SpringAOP简单项目实现
09-28
总结，这个"SpringAOP简单项目实现"涵盖了Spring AOP的基础知识，包括切面、通知、切入点的定义与配置，以及如何在实际项目中使用Maven进行构建和依赖管理。对于初学者来说，这是一个很好的实践案例，能够帮助他们...
Spring基础：Spring AOP简单使用
05-04
创建一个简单的Spring AOP应用，首先定义一个切面类，包含切点和通知，然后在Spring配置文件中启用AOP并注册切面，最后编写测试类验证AOP功能是否正常工作。 8. **最佳实践** - 适度使用AOP，过多的切面可能导致...
springboot中实现微信登录功能
zxxcccc11的博客
07-24 308
Controller层。
源码拆解SpringBoot的自动配置机制
糖拌西红柿
07-24 1074
SpringBoot的自动化配置原理、starter开发的基础，SpringBoot配置自动化
SpringCloud之使用 Nacos 实现高效购物车商品信息处理
Takumilove的博客
07-24 1211
通过上述步骤，我们成功实现了一个高效的购物车商品信息处理流程。使用 Nacos 来进行服务发现，并结合手写的负载均衡策略，确保了服务调用的高可用性和稳定性。这样不仅提升了系统的性能，还能给用户带来更好的购物体验。
Spring踩坑：抽象类作为父类，使用子类@Autowired属性进行填充，属性值为null
最新发布
five-five
07-25 1227
本文将深入探讨在Spring Boot 2.0及以上版本中使用抽象类作为父类时的最佳实践，特别关注依赖注入的正确使用方式。在Spring Boot 2.0及以上版本中，我们可以直接在抽象类的属性上使用@Autowired注解进行依赖注入。这意味着在构造器执行时，@Autowired注解的属性还没有被注入，它们的值为null。这个问题在子类中更加复杂。当你创建一个抽象类的子类时，子类的构造器会首先调用父类的构造器。这意味着即使是在子类的构造器中，父类中@Autowired注解的属性仍然是null。
springAOP怎么理解
04-01
Spring AOP是Spring框架中的一个模块，它提供了一种在运行时动态地将行为（例如日志记录、性能统计等）添加到代码中的方式，而无需修改原始代码。它通过代理模式实现，将横切关注点（cross-cutting concerns）从业务逻辑中分离出来，从而实现了代码的解耦和复用。 在Spring AOP中，切面（Aspect）是横切关注点的一种实现方式，它通过定义切点（Pointcut）和通知（Advice）来描述横切关注点在哪些地方执行以及执行什么操作。切点是一个表达式，用于匹配需要执行通知的方法或类，通知则是在切点匹配的方法或类执行前、后或发生异常时执行的代码块。 Spring AOP还提供了其他功能，例如引入（Introduction）、环绕通知（Around Advice）等，可以更加灵活地实现横切关注点的功能。 总的来说，Spring AOP是一种基于代理模式的轻量级AOP框架，它提供了一种简单、灵活、可扩展的方式来实现横切关注点的功能，可以大大提高代码的可维护性和复用性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值