Spring05：面向切面编程

最新推荐文章于 2022-11-25 21:33:34 发布
最新推荐文章于 2022-11-25 21:33:34 发布
阅读量730 收藏
点赞数
分类专栏： Java EE 文章标签： java spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44262126/article/details/122015573
版权

本文为 SSM 框架系列之 Spring 第五部分：面向切面编程
其它内容的链接如下：
    1. HelloSpring
    2. 控制反转
    3. 依赖注入与装配机制
    4. 代理模式
    5. 面向切面编程
    6. 声明式事务

目录：

1 AOP 的定义

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

面向切面编程是面向对象编程的补充，它将面向对象编程产生的各个业务模块所共同调用的部分封装起来，达到与主业务逻辑解耦的目的。同时，AOP 可以在不改变原来的代码的情况下，实现对原有功能的增强。（代理模式，开闭原则）
图片来源：狂神说

 

2 Spring 中的 AOP

AOP 是 Spring 的特性之一，它可以让我们通过少量的代码就可以完成面向切面编程的目的。

Spring AOP 就是基于动态代理的，Spring 中的 AOP 目前支持 JDK 动态代理和 Cglib 代理。

Spring 中的 AOP 定义如下：

请添加图片描述
其中的核心术语的含义如下：

  • 横切关注点：我们需要关注的部分，就是横切关注点；
  • 切面：横切关注点被模块化的特殊对象。是一个类；
  • 通知：切面需要完成的工作。是类中的一个方法；
  • 切入点：用来匹配特定接入点的表达式，通过切入点表达式匹配接入点是 AOP 的核心，Spring 默认使用AspectJ的切点表达式；
  • 织入：将一个或多个切面与类或对象链接在一起创建一个被增强对象；
  • 接入点：程序执行期的一个点，例如方法执行、类初始化、异常处理。

Spring AOP 中常用的四种 Advice 方式：

通知类型连接点
前置通知方法执行前
后置通知方法放回后
环绕通知方法前后
异常抛出通知方法抛出异常时

下面感受一下同一 aspect，不同 advice 的执行顺序：

请添加图片描述

更多形式的通知的执行流程请看这位大神的博客：【传送门】

 

3 使用 Spring 实现 AOP

3.1 通过使用 Spring API 接口实现

1 导入 AOP 所需要的依赖包

    <!-- 经过实践证明，这段代码确实是必须要写的 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>11</java.version>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!-- AOP 所需要的依赖包 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

    <!-- 静态资源导出 -->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

2 编写原来的业务接口和实现类

package sharm.service;

public interface Rent {
    public void rent();
}

package sharm.service;

public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("我是房东，我想要出租房子。");
    }
}

3 书写两个增强类，一个是前置增强，一个是后置增强。即我们需要织入的切面

3.1 前置增强

package sharm.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class BeforeLog implements MethodBeforeAdvice {
    //method : 要执行的目标对象的方法
    //args : 被调用的方法的参数
    //target : 目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "方法被执行了");
        // 额外加上的领域业务
        seeHouse();
    }

    //看房
    public void seeHouse(){
        System.out.println("带房客看房");
    }
}

3.2 后置增强

package sharm.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

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()+"方法,"
                +"返回值："+returnValue);
        // 额外加上的领域业务
        fare();
    }

    // 收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

4 配置 Spring 的配置文件，并且实现 AOP 切入

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

    <!--注册bean-->
    <bean id="host" class="sharm.service.Host"/>
    <bean id="beforeLog" class="sharm.log.BeforeLog"/>
    <bean id="afterLog" class="sharm.log.AfterLog"/>

    <!--aop的配置-->
    <aop:config>
        <!--切入点 expression:表达式匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* sharm.service.*.*(..))"/>
        <!--执行通知。advice-ref：执行方法，pointcut-ref切入点-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

在切入点表达式execution(* sharm.service.*.*(..))中，各参数的含义如下：

  • execution() 表示表达式主体；

  • 第一个 * 表示返回类型为所有的类型；

  • sharm.service.表示包名。尾部的一个点表示当前包，两个点表示当前包下的所有子包；

  • 第二个 * 表示类名为所有的类；

  • *(..)中的星号表示所有的方法，后面的括号表示方法的参数，两个句点表示任何参数。

5 编写测试类

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import sharm.service.Rent;

public class AopTest {
    @Test
    public void myTest(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // Bean 中用的是实现类，而返回值采用的是接口
        Rent hostService = (Rent)context.getBean("host");
        hostService.rent();
    }
}

6 控制面板输出

请添加图片描述

3.2 通过自定义类来实现

1 导入 AOP 所需要的依赖包

2 编写原来的业务接口和实现类

3 自定义切入类来实现 AOP

package sharm.log;

public class CustomAspect {
    //看房
    public void seeHouse(){
        System.out.println("带房客看房");
    }

    // 收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

4 配置 Spring，非常关键

    <!--注册bean-->
    <bean id="host" class="sharm.service.Host"/>
    <bean id="customAspect" class="sharm.log.CustomAspect"/>

    <!--aop的配置-->
    <aop:config>
        <!--第二种方式：使用AOP的标签实现-->
        <aop:aspect ref="customAspect">
            <aop:pointcut id="customPointCut" expression="execution(* sharm.service.*.*(..))"/>
            <aop:before pointcut-ref="customPointCut" method="seeHouse"/>
            <aop:after pointcut-ref="customPointCut" method="fare"/>
        </aop:aspect>
    </aop:config>

6 编写测试类

7 控制面板输出

请添加图片描述

3.3 使用注解来实现

1 导入 AOP 所需要的依赖包

2 编写原来的业务接口和实现类

3 编写一个注解实现的增强类

package sharm.log;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationAspect {
    //看房
    @Before("execution(* sharm.service.*.*(..))")
    public void seeHouse(){
        System.out.println("带房客看房");
    }

    @After("execution(* sharm.service.*.*(..))")
    // 收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

4 在 Spring 配置文件中注册 bean，并增加支持注解的配置

    <!--注册bean-->
    <bean id="host" class="sharm.service.Host"/>
    <!--第三种方式:注解实现-->
    <bean id="annotationPointcut" class="sharm.log.AnnotationAspect"/>
    <aop:aspectj-autoproxy/>

通过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 动态代理。

5 编写测试类

6 控制面板输出

请添加图片描述

是志明呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring实战 | 第一部分 Spring的核心（第四章 面向切面的Spring）
chetianyao8457的博客
08-23 551
第四章 面向切面编程 面向切面编程的基本原理 通过POJO创建切面 使用@AspectJ注解 为AspectJ切面注入依赖 AspectJ是一个面向切面的框架，它扩展了java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵循java字节编码规范的...
Spring依赖注入、控制反转、面向切面编程三大特性详解（含示例代码）
一叶知秋
06-16 1531
Spring 框架是一个开源的企业级应用程序开发框架，它提供了许多功能和特性，但主要包括以下三大核心特性：依赖注入（Dependency Injection，DI）： 依赖注入是 Spring 的核心特性之一。它通过控制反转（Inversion of Control，IOC）实现对象之间的解耦。在传统的编程模型中，对象自己负责创建和管理它所依赖的对象，而在 Spring 中，容器负责创建对象，并将依赖关系注入到对象中。这样可以提高代码的可维护性、可测试性和松耦合性。
（十五）Spring之面向切面编程AOP
忆亦何为的博客
11-25 602
一般一个系统当中都会有一些系统服务，例如：日志、事务管理、安全等。交叉业务这些交叉业务几乎是通用的，不管你是做银行账户转账，还是删除用户数据。日志、事务管理、安全，这些都是需要做的。第一：交叉业务代码在多个业务流程中反复出现，显然这个交叉业务代码没有得到复用。并且修改这些交叉业务代码的话，需要修改多处。第二：程序员无法专注核心业务代码的编写，在编写核心业务代码的同时还需要处理这些交叉业务。使用AOP可以很轻松的解决以上问题。
Spring面向切面编程（AOP）
Lovely-Zhang-1026的博客
02-16 282
面向切面编程（AOP) 1、什么是AOP AOP是Aspect Oriented Programing的简称，面向切面编程（面向方面编程），通过预编译方式（静态代理）和运行期（动态代理）实现程序功能的统一维护的一种技术，AOP是OOP的延续，是Spring框架中的一个重要内容，利用AOP可以对业务逻辑的各个部分进行隔离(Struts2的拦截器设计就是基于AOP的思想) 2、Spring AOP 主要是利用代理模式的技术来实现的 Spring默认使用JDK动态代理，在需要代理类而不是代理接口的时候
20210325笔记
hasgdhgsa的博客
03-25 89
1. Spring AOP. AOP: 面向切面编程 在不影响核心代码的前提下，可以在任意位置添加非核心代码。 2. AOP的前身 3. 通过动态代理实现核心业务和非核心业务的一种抽取。 比较麻烦 4. 可以使用spring 的aop来完成代理 （1） 把相关spring的依赖加入 <dependencies> <dependency> <groupId>org.springframework</groupId&
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
16.2 Spring框架-AOP面向切面编程
最新发布
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
Spring4AOP 面向切面编程实例之方法拦截
10-13
Spring4AOP 面向切面编程实例之方法拦截实例 一下利用Spring4的最后一个版本Spring4.3.9，实现简单的方法拦截实例。 Eclipse 建立java工程,导入必要的jar包，工程目录如下:
aop.rar_面向切面编程
09-24
在这个“aop.rar”压缩包中，我们可以预期它包含了关于如何使用Spring AOP进行面向切面编程的教程或示例代码。通常，这种资源会通过注解的方式来简化AOP的实现，使得学习过程更加直观和有趣。 首先，我们要理解...
SpringAOP切面编程依赖jar包.rar
04-30
学习Spring开发的AOP面向切面编程时所需要的jar包，包括com.springsource.net.sf.cglib-2.2.0.jar com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
spring boot 项目之-引入AOP切面
shinexunmeng的博客
03-06 1043
springboot 引入AOP切面
spring AOP依赖配置大全
qq_44534541的博客
04-21 1万+
pom.xml文件的依赖配置 <dependencies> <!--junit单元测试--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <versio...
Spring AOP依赖包
weixin_30693683的博客
07-11 1万+
Spring4和2.5发生了很大的变化，原来的spring2.5很多倚赖的jar包都是随着spring一起发布的，现在spring4已 经不再发布倚赖包，需要你自己去导入 1.org.springframework.aop-4.RELEASE 这个是spring的 AOP编程必备包 2.cglib-nodep-2.1_3 3.aspectjweaver-1.6.2 ...
Spring AOP切面类依赖注入失败问题解决
ChengJune's notes
07-06 7038
最近在项目中使用到了Spring AOP结合AspectJ注解为项目增加系统操作日志记录功能，遇到的问题是在切面类中使用注解的方式注入Service对象失败，导致日志记录功能无法使用。报如下空指针异常： 第一行是日志切面类中的方法，第二行是Controller中的方法。 我觉得应该是spring加载配置文件时是有顺序引起的，但是不知道是什么顺序。。 待解决，至今没找到解决方法。。。
Spring依赖注入与面向切面编程以及注解
格乄子
03-14 3512
一、spring IOC依赖注入和AOP面向切面编程 1、IOC（Inverse of Control）依赖注入 通过IOC可以将实现类 、参数信息等配置在其对应的配置文件中 ，那么当需要更改实现类或参数信息时，只需要修改配置文件即可，这种方法在上例的基础上更进一步的降低了类与类之间的耦合。 我们还可以对某对象所需要的其它对象进行注入 ，这种注入都是在配置文件中做的，Spring的IOC的实
Spring核心AOP（面向切面编程）总结
冷血之心的博客
07-16 3万+
（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/75208354冷血之心的博客） 目录 1、AOP概念： 2、AOP特点： 3、AOP底层实现： JDK动态代理实现： cglib动态代理实现： 代理方式的选择： 静态代理和动态代理的区别： 4、AOP原理 5、AOP操作术语： 6、AOP操作案例...
spring-jar包详解整理（大合集）
每天进步一点点
03-14 3万+
Spring各jar包详解
Spring AOP面向切面编程:理解篇（一看就明白）
热门推荐
healer的博客
09-28 7万+
一直想着怎么去通俗的讲解AOP，看了一篇文章受到了启发（https://blog.csdn.net/qukaiwei/article/details/50367761），下面我加入自己的理解，咱们来说说AOP! 一、到底什么是AOP（面向切面编程）？ 无论在学习或者面试的时候，大家都会张口说spring的特性AOP和IOC(控制反转咱们下一篇讲)，有些大神理解的很到位，但是对于大多数初中级工程...
Spring温故知新六AOP向切面程
05-09
SpringSpringSpring温故知新六AOP向切面程Spring温故知新六AOP向切面程

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值