Spring in Action4-AOP

最新推荐文章于 2026-04-17 10:11:10 发布
转载 最新推荐文章于 2026-04-17 10:11:10 发布 · 120 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
原文链接：https://my.oschina.net/mengyuankan/blog/906624

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

##Spring in Action4-AOP Spring in Action4的读书笔记之AOP：

在我们编写程序的过程中，如果要重用通用功能的话，在 Java中最常见的技术继承（inheritance） 或委托 （delegation） ，但是， 如果在整个应用中都使用相同的基类， 继承往往会导致一个脆弱的对象体系； 而使用委托可能需要对委托对象进行复杂的调用。

切面提供了取代继承和委托的另一种可选方案， 而且在很多场景下更清晰简洁。

在使用面向切面编程时， 我们仍然需要在一个地方定义这些通用的功能， 但是可以通过声明的方式定义这个功能要以何种方式在何处应用， 而无需修改受影响的类。 横切关注点可以被模块化为特殊的类， 这些类被称为**切面（aspect） **。

这样做有两个好处：

  1. 现在每个关注点都集中于一个地方， 而不是分散到多处代码中，便于修改。
  2. 服务模块更简洁， 因为它们只包含主要核心功能的代码， 而次要关注点的代码被转移到切面中了。

####AOP术语

  1. 通知（advice） 、
  2. 切点（pointcut）
  3. 连接点（join point）

#####通知（advice）: 切面的工作被称为通知。通知定义了切面是什么以及何时使用，它应该应用在某个方法被调用之前？ 之后？ 之前和之后都调用？ 还是只在方法抛出异常时调用？

#####Spring切面可以应用5种类型的通知：

  1. 前置通知（Before） ： 在目标方法被调用之前调用通知功能；
  2. 后置通知（After） ： 在目标方法完成之后调用通知， 此时不会关心方法的输出是什么；
  3. 返回通知（After-returning） ： 在目标方法成功执行之后调用通知；
  4. 异常通知（After-throwing） ： 在目标方法抛出异常后调用通知；
  5. 环绕通知（Around） ： 通知包裹了被通知的方法， 在被通知的方法调用之前和调用之后 执行自定义的行为。

#####连接点（Join point）： 程序可能有数以千计的时机应用通知。 这些时机被称为连接点。 连接点是在应用执行过程中能够插入切面的一个点。 这个点可以是调用方法时、 抛出异常时、 甚至修改一个字段时。 切面代码可以利用这些点插入到应用的正常流程之中， 并添加新的行为。

切点（pointcut） ：

切点表示了通知在哪里执行，切点有助于缩小切面所通知的连接点的范围。

切点的定义会匹配通知所要织入的一个或多个连接点。 我们通常使用明确的类和方法名称， 或是利用正则表达式定义所匹配的类和方法名称来指定这些切点

如：

@Before("execution(**chapter03.annotation_aop.Performance.perform())")

#####切面（AspectJ）: 切面是通知和切点的结合。 通知和切点共同定义了切面的全部内容——它是什么， 在何时和何处完成其功能。

<br> 如下定义了一个切面：

[@Aspect](https://my.oschina.net/aspect)
public class Audience {

/**
 * 方法执行之前执行
 */
@Before("execution(**chapter03.annotation_aop.Performance.perform())")
public void silenceCellPhones(){
    System.out.println("表演之前，手机调成静音");
}

/**
 * 方法执行后执行
 */
@AfterReturning("execution(**chapter03.annotation_aop.Performance.perform())")
public void applause(){
    System.out.println("表演很精彩，鼓掌");
}

/**
 * 方法抛出异常执行
 */
@AfterThrowing("execution(**chapter03.annotation_aop.Performance.perform())")
public void demandRefund(){
    System.out.println("表演失败，要求退款");
}
}

<br> ######Spring在运行时通知对象

通过在代理类中包裹切面， Spring在运行期把切面织入到Spring管理的bean中。 代理类封装了目标类， 并拦截被通知方法的调用， 再把调用转发给真正的目标bean。

当代理拦截到方法调用时， 在调用目标bean方法之前， 会执行切面逻辑。

因为Spring基于动态代理来实现AOP功能， 所以Spring只支持方法连接点，但是方法拦截可以满足绝大部分的需求。 如果需要方法拦截之外的连接点拦截功能， 那么我们可以利用Aspect来补充Spring AOP的功能

<br> ####编写切点 比如有如下一个接口，编写一个切面通知，在接口方法调用的时候触发：

package chapter03.annotation_aop;
public interface Performance {
    void perform();
}

那么我们的切点表达式可以这样写：

@Pointcut("execution(* chapter03.annotation_aop.Performance.perform(..))")
public void perform(){

}

其中 ***** 表示该接口下任意返回值的方法， .. 表示方法的任意参数

还可以使用指示器来更加详细的进行匹配，有以下几种指示器：

AspectJ指示器描述例子说明
arg()限制连接点匹配参数为指定类型,args属于动态切入点，这种切入点开销非常大，非特殊情况最好不要使用；@Pointcut("execution(* CompactDisc.playTrack(int)) && args(number)")public void trackPlay(int number){}匹配playTrack()方法且参数为int类型
@args()匹配当前执行的方法传入的参数持有指定注解的执行@args(Anno))方法参数标有Anno注解
this()匹配当前AOP代理对象类型的执行方法this(service.IPointcutService)当前AOP对象实现了 IPointcutService接口的任何方法
target()匹配当前目标对象类型的执行方法target(service.IPointcutService)当前目标对象（非AOP对象）实现了 IPointcutService接口的任何方法
@target()匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解@target (Secure)任何目标对象持有Secure注解的类方法；必须是在目标对象上声明这个注解，在接口上声明的对它不起作用
within()匹配指定类型内的方法执行within(cn.javass..*)cn.javass包及子包下的任何方法执行
@within()匹配所有持有指定注解类型内的方法@within(Secure)任何目标对象持有Secure注解的类方法；必须是在目标对象上声明这个注解，在接口上声明的对它不起作用
@annotation匹配当前执行方法持有指定注解的方法@annotation(Secure )当前执行方法上持有注解Secure将被匹配
bean()匹配特定名称的Bean对象的执行方法bean(*Service)匹配所有以Service命名（id或name）结尾的Bean

<br><br> ####Spring使用注解实现AOP：

首先定义一个接口，通知作用在该接口中的方法，当该接口下的方法被调用的时候就会触发通知。

package chapter03.annotation_aop;
public interface Performance {
    void perform();
}

然后写一个该接口的实现类：

package chapter03.annotation_aop;
@Component(value = "performance")
public class PerformanceImpl implements Performance {
    @Override
    public void perform() {
        System.out.println("舞蹈表演中......");
    }
}

使用@Component(value = "performance")把该类注入到Spring中，bean的名字为：performance。

<br> 接下来编写**切面**：

@Aspect
public class Audience {
    /**
     * 方法执行之前执行
     */
    @Before("execution(* chapter03.annotation_aop.Performance.perform())")
    public void silenceCellPhones(){
        System.out.println("表演之前，手机调成静音");
    }

    /**
     * 方法执行之前执行
     */
    @Before("execution(* chapter03.annotation_aop.Performance.perform())")
    public void takeSeats(){
        System.out.println("表演之前，坐好");
    }

    /**
     * 方法执行后执行
     */
    @AfterReturning("execution(* chapter03.annotation_aop.Performance.perform())")
    public void applause(){
        System.out.println("表演很精彩，鼓掌");
    }

    /**
     * 方法抛出异常执行
     */
    @AfterThrowing("execution(* chapter03.annotation_aop.Performance.perform())")
    public void demandRefund(){
        System.out.println("表演失败，要求退款");
    }
}
  1. @Aspect表示该类是一个切面。
  2. @Before标注的通知方法在目标方法执行之前执行。
  3. @AfterReturning标注的通知方法在目标方法成功执行后执行。
  4. @AfterThrowing标注的通知方法在目标方法出现异常的时候执行

提示：在每个通知方法中，都要写一遍切点表达式：

execution(* chapter03.annotation_aop.Performance.perform())"

可以使用 @Pointcut 来编写一个可重用的切点表达式：

@Aspect
public class Audience2 {

    //定义可重用的切点表达式
    @Pointcut("execution(* chapter03.annotation_aop.Performance.perform(..))")
    public void perform(){

    }
    /**
     * 方法执行之前执行
     */
    @Before("perform()")
    public void silenceCellPhones(){
        System.out.println("表演之前，手机调成静音");
    }

    /**
     * 方法执行之前执行
     */
    @Before("perform()")
    public void takeSeats(){
        System.out.println("表演之前，坐好");
    }

    /**
     * 方法执行后执行
     */
    @AfterReturning("perform())")
    public void applause(){
        System.out.println("表演很精彩，鼓掌");
    }

    /**
     * 方法抛出异常执行
     */
    @AfterThrowing("perform()")
    public void demandRefund(){
        System.out.println("表演失败，要求退款");
    }
}

<br> 我们定义了切点之后，它只是一个POJO，并没有特别之处，我们还要把它们注入到Spring中，

下面编写一个配置文件：

@Configuration
@EnableAspectJAutoProxy//启动 AspectJ 自动代理
@ComponentScan
public class Config {

    // 注入 bean
    @Bean
    public Audience2 audience(){
        return new Audience2();
    }
}

<br> 1. `@Configuration`：标识这是一个配置文件。 2. `@EnableAspectJAutoProxy` : 启动 AspectJ 自动代理。 3. `@ComponentScan`：启动注解扫描。

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = Config.class)
public class TestAop {

    @Autowired
    private Performance performance;
    
    @Test
    public void testAdvice(){
        performance.perform();
    }
}
  1. @RunWith(SpringJUnit4ClassRunner.class):自动创建 Spring 上下文
  2. @ContextConfiguration(classes = Config.class): 加载配置文件

结果：

表演之前，手机调成静音 表演之前，坐好 舞蹈表演中...... 表演很精彩，鼓掌

####环绕通知： 环绕通知 @Around()：

这个环绕通知所达到的效果与之前的前置通知和后置通知是一样的。 但是， 现在它们 位于同一个方法中， 不像之前那样分散在四个不同的通知方法里面。

使用 **ProceedingJoinPoint**当作方法的参数

@Aspect
public class AroundAdvice {

    //定义可重用切点
    @Pointcut("execution(* chapter03.annotation_aop.Performance.perform(..))")
    public void perform(){
    }

  
    @Around("perform()")
    public void around(ProceedingJoinPoint joinPoint){
        try {

            System.out.println("表演之前，手机调成静音");
            System.out.println("表演之前，坐好");
            joinPoint.proceed();
            System.out.println("表演很精彩，鼓掌");
        } catch (Throwable throwable) {
            System.out.println("表演失败，要求退款");
            throwable.printStackTrace();
        }
    }
}

####带参数的情况：

接口：

package chapter03.annotation_aop.aop_args;
public interface CompactDisc {
    void playTrack();
    void playTrack(int i);
}

接口的实现：

@Component(value = "compactDisc")
public class CompactDiscImpl implements CompactDisc {
    @Override
    public void playTrack() {
        System.out.println("playTrack with no args........");
    }

    @Override
    public void playTrack(int i) {
        System.out.println("playTrack with args : " + i);
    }
}

编写切面：

@Aspect
public class AvdiceWithArgs {

    @Pointcut("execution(* chapter03.annotation_aop.aop_args.CompactDisc.playTrack(int)) && args(number)")
    public void trackPlay(int number){

    }

    @Before("trackPlay(num)")
    public void trackPlayBefore(int num){
        System.out.println("表演之前......" + num);
    }

    @After("trackPlay(num)")
    public void trackPlayAfter(int num){
        System.out.println("表演之后......" + num);
    }
}

args(number)：: 它表明传递给 playTrack()方法的int类型参数也会传递到通知中去

@Configuration
@EnableAspectJAutoProxy//启动 AspectJ 自动代理
@ComponentScan
public class Config {

    @Bean
    public AvdiceWithArgs avdiceWithArgs(){
        return new AvdiceWithArgs();
    }
}

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = Config.class)
public class TestAop {

    @Autowired
    private CompactDisc compactDisc;

    @Test
    public void testAdviceWithArgs(){
        compactDisc.playTrack(100);
    }
}

结果：

表演之前......100 playTrack with args : 100 表演之后......100

<BR><BR> ####Spring使用XML实现AOP

定义切面：只是一个POJO。

public class Audience {

    public void silenceCellPhones(){
        System.out.println("表演之前，手机调成静音");
    }

    public void takeSeats(){
        System.out.println("表演之前，坐好");
    }

    public void applause(){
        System.out.println("表演很精彩，鼓掌");
    }

    public void demandRefund(){
        System.out.println("表演失败，要求退款");
    }
}

定义环绕通知：

public class AroundAdvice {

    public void aroundPerform(ProceedingJoinPoint joinPoint){
        try {
            System.out.println("表演之前，手机调成静音");
            System.out.println("表演之前，坐好");
            joinPoint.proceed();
            System.out.println("表演很精彩，鼓掌");
        } catch (Throwable throwable) {
            System.out.println("表演失败，要求退款");
            throwable.printStackTrace();
        }
    }
}

在 XML 文件中配置通知：

大多数的AOP配置元素必须在**<aop:config>元素的上下文内使用。这条规则有几种例外场景， 但是把bean声明为一个切面时，我们总是从<aop:config>**元素开始配置的。

在**<aop:config>**元素内， 我们可以声明一个或多个通知器、 切面或者切点。

使用**<aop:aspect>*元素声明了一个简单的切面， ref元素引用了一个POJO bean， 该bean实现了切面的功能

使用 <aop:pointcut> 定义了可重用的切点表达式， 供后面的通知使用而不用重新定义一遍

**<aop:pointcut>**元素所定义的切点可以被同一个<aop:aspect>元素之内的所 有通知元素引用。 如果想让定义的切点能够在多个切面使用，我们可以把<aop:pointcut>元素放在<aop:config>元素的范围内

启动 AspectJ 自动代理

<aop:aspectj-autoproxy/>

配置切面的 bean

<bean id="audience" class="chapter03.annotation_xml.Audience"/>

配置环绕通知的 bean

 <aop:config>
    <!-- 引用配置的切面 bean-->
    <aop:aspect ref="audience">
        <!-- 定义可重用的切点表达式-->
        <aop:pointcut id="pc" expression="execution(* chapter03.annotation_xml.Performance.perform(..))"/>
        <!-- 前置通知-->
        <aop:before pointcut-ref="pc" method="silenceCellPhones"/>
        <aop:before pointcut-ref="pc" method="takeSeats"/>
        <!-- 后置通知 -->
        <aop:after-returning pointcut-ref="pc" method="applause"/>
        <!-- 异常通知-->
        <aop:after-throwing pointcut-ref="pc" method="demandRefund"/>
    </aop:aspect>

    <!-- 配置环绕通知 -->
    <aop:aspect ref="aroundAdvice">
        <aop:pointcut id="apc" expression="execution(* chapter03.annotation_xml.Performance.perform(..))"/>
        <aop:around pointcut-ref="apc" method="aroundPerform"/>
    </aop:aspect>

    <!--配置带参数的通知-->
    <aop:aspect ref="adviceWithArgs">
        <aop:pointcut id="bpc" expression="execution(* chapter03.annotation_xml.aop_args.CompactDisc.playTrack(int)) and args(num)"/>
        <aop:before pointcut-ref="bpc" method="trackPlayBefore"/>
        <aop:after pointcut-ref="bpc" method="trackPlayAfter"/>
    </aop:aspect>

</aop:config>

测试：

首先加载配置文件：

@Configuration
@ImportResource("classpath:applicationContext.xml")
public class Config {
}

编写测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = Config.class)
public class TestAop {

    @Autowired
    private Performance performance;

    @Test
    public void test(){
        performance.perform();
    }
}

结果：

表演之前，手机调成静音 表演之前，坐好 表演之前，手机调成静音 表演之前，坐好 舞蹈表演中...... 表演很精彩，鼓掌 表演很精彩，鼓掌

因为配置了两个通知，所以出现上述效果。

结束！！！！

引用：

详细参考：

http://sishuok.com/forum/posts/list/281.html

转载于:https://my.oschina.net/mengyuankan/blog/906624

标签
#python #java
LEAP模型—低排放分析平台
weixin_54697010的博客
03-09 3252
LEAP 正在迅速成为进行综合资源规划、温室气体 (GHG) 缓解评估和低排放发展战略 (LEDS) 的国家的事实标准，尤其是在发展中国家，许多国家也选择使用 LEAP 作为其承诺的一部分向联合国气候变化框架公约（UNFCCC）报告。至少有 32 个国家使用 LEAP 来创建能源和排放情景，这些情景是其国家自主气候变化贡献计划 (INDC) 的基础：具有历史意义的巴黎气候协议的基础旨在表明各国开始经济脱碳的意图和投资于气候适应力。
从SolidWorks到Simulink：手把手教你用URDF文件搭建六轴机械臂仿真模型（含STL文件配置避坑）
最新发布
weixin_26812607的博客
04-17 229
本文详细介绍了从SolidWorks到Simulink的六轴机械臂URDF仿真全流程，包括URDF文件导出、Simscape模型生成与调试、动力学参数获取与验证等关键步骤。重点解决了STL文件配置、关节接口设置等工程化难题，帮助开发者高效构建可控制的数字孪生体。通过实战案例和优化技巧，提升机械臂仿真效率与准确性。
Struts2-4 action与Action类
Java名企面试吧
12-28 501
1. action：代表一个Struts2的请求（应用程序可以完成的每一个操作，如显示表单、保存信息等） 2. Action类：能够处理Struts2请求的类（普通Java类）, 必须遵守以下规则: 属性： 属性名必须遵守与JavaBeans属性名相同的命名规则；属性类型可以是任意类型，从字符串到非字符串(基本数据库类型)之间的数据转换可以自动发生； 构
英国道路交通事故数据集（21列，307973 条记录）CSV
该数据集包含英国多个地区的道路交通事故的详细记录，包括滨海绍森德、乌特尔斯福德、切姆斯福德、布伦特伍德、埃平森林等地区。它包括大约 300,000 行事件，每行事件都记录了事故发生时的环境、车辆和道路相关状况。这些数据非常适合涉及事故严重程度分析、地理空间可视化、城市规划和道路安全研究的项目。
Spring in Action 4读书笔记之使用标签创建AOP
谈谈IT
09-04 159
在之前的读书笔记Spring in Acton 4读书笔记之AOP原理及Spring对AOP的支持中，讲到Spring对AOP的支持包含四方面： Spring基于代理的经典的AOP 使用XML配置将纯POJO转化为aspect 使用Spring的@Aspect标签，创建aspect Spring不创建aspect，只注入（引用）AspectJ框架的aspect Spring in Action（Spring实战）的第四章第三节（4.3 Creating annotated aspects）讲述了其中第三
Spring in Action 4th 学习笔记 之 AOP
weixin_33804990的博客
04-23 118
前提：本文中的AOP仅限于Spring AOP。   先说说为什么需要AOP   最简单的一个例子就是日志记录，如果想记录一些方法的执行情况，最笨的办法就是修改每一个需要记录的方法。但这，真的很笨。。。 好的方法，应该是通过反射获取方法，然后去匹配，如果需要记录日志，那就调用日志方法即可。 这就是AOP 的Weaving，俗称编织、织入，就是将需要添加的功能编织到现有功能中，而不需要修...
Spring in Action 4 读书笔记之使用标签创建 AOP
GarfieldEr007的专栏
01-23 1044
目录 1. 定义一个 aspect 2. 创建一个 around advice 在之前的读书笔记 Spring in Acton 4 读书笔记之 AOP 原理及 Spring 对 AOP 的支持 中，讲到 Spring 对 AOP 的支持包含四方面： Spring 基于代理的经典的 AOP 使用 XML 配置将纯 POJO 转化为 aspect 使用
《Spring In Action（第4版）》阅读总结（二）Spring AOP
weixin_33889245的博客
04-26 113
面向切面编程的Spring 面向切面编程的基本原理 通过POJO创建切面 使用@AspectJ注解 为AspectJ切面注入依赖 面向切面编程 解决横切关注点与业务逻辑相分离AOP术语通知(Advice)：切面的工作目标，定义切面执行的工作以及何时执行。如调用前、调用后等；通知共分为5类前置通知(Before):在目标方法被调用之前调...
【转】Spring in Action 4th 学习笔记 之 AOP
BigDragon
11-14 180
http://www.cnblogs.com/larryzeal/tag/spring/ 先说说为什么需要AOP   最简单的一个例子就是日志记录，如果想记录一些方法的执行情况，最笨的办法就是修改每一个需要记录的方法。但这，真的很笨。。。 好的方法，应该是通过反射获取方法，然后去匹配，如果需要记录日志，那就调用日志方法即可。 这就是AOP 的Weaving，俗称编织、织入，就是将需要...
Failed to instantiate [org.springframework.aop.aspectj.AspectJExpressionPointcut]: No default constr
及时雨的csdn
07-19 2630
在学习spring in action AOP第四版书籍的时候报错： 警告: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean wi...
SPRING IN ACTION 第4版笔记-第一章-003-AOP介绍
weixin_30532987的博客
03-01 85
一、目标 要在BraveKnight调用embarkOnQuest()前后各做一些处理(调用Minstrel的方法) 二、 1.minstrel.xml 1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3...
SPRING IN ACTION 第4版笔记-第四章ASPECT-ORIENTED SPRING-003-Spring对AOP支持情况的介绍
weixin_30810239的博客
03-03 109
一、 不同的Aop框架在支持aspect何时、如何织入到目标中是不一样的。如AspectJ和Jboss支持在构造函数和field被修改时织入，但spring不支持，spring只支持一般method的织入。spring通过以下四种方式支持AOP:  Classic Spring proxy-based AOP Pure- POJO aspects @AspectJ annotation-...
SPRING IN ACTION 第4版笔记-第四章Aspect-oriented Spring-001-什么是AOP
weixin_30690833的博客
03-03 150
一、 Aspect就是把会在应用中的不同地方重复出现的非业务功能的模块化，比如日志、事务、安全、缓存 In software development, functions that span multiple points of an application arecalled cross-cutting concerns. Typically, these cross-cutting c...
SPRING IN ACTION 第4版笔记-第四章ASPECT-ORIENTED SPRING-002-AOP术语解析
weixin_30674525的博客
03-03 149
一、 1.Advice Advice是切面的要做的操作，它定义了what、when(什么时候要做什么事) aspects have a purpose—a job they’re meant to do. In AOP terms, the jobof an aspect is called advice.Advice defines both the what and the when...
SPRING IN ACTION 第4版笔记-第四章ASPECT-ORIENTED SPRING-012-AOP总结
weixin_30410999的博客
03-04 125
1.AOP是面向对象编程的有力补充，它可以让你把分散在应用中的公共辅助功能抽取成模块，以灵活配置，减少了重复代码，让类更关注于自身的功能 转载于:https://www.cnblogs.com/shamgod/p/5240640.html...
【spring】---概述
寻梦友的博客
01-10 160
学习网址“https://potoyang.gitbook.io/spring-in-action-v4/”。这部分是以《spring实战(第4版)》这本书进行讲述。 下面的是这本书主要知识点的概述，具体细节知识后面章节进行讲解。 第一部分 Spring的核心 IOC(DI) DI依赖注入方式和实现方式 Spring装配Bean方式 AOP 项目 ...
SpringInAction.4th.面向切面的Spring
杨川云的博客
08-21 497
SpringInAction.4th.面向切面的Spring@(spring)[AOP]面向切面编程，按我的理解就是，在执行一个动作的同时执行一些公共的动作。这些公共的动作没必要每个都写在各自的方法里，可以提取出公共的方法。Spring提供了4种类型的AOP支持： - 基于代理的经典Spring AOP - 纯POJO切面 - @AspectJ注解驱动的切面 - 注入式AspectJ切面（适
Spring In Action 4
热门推荐
Ranger的博客
12-12 1万+
在线学习连接：spring in action 4 关键词解释 名词 解释 EJB Enterprise JavaBean，企业级JavaBean POJO Plain Old Java Object，简单老式Java对象 J2EE Java 2 Enterprise Edition，Java2企业版 DI Dependency Injection，依赖注入，获取对象的过程被反转，获得依赖对象的过程由自身管理变成由IOC容器主动注入 IOC Inversion of Cont
Spring in Action之AOP
Vincent的博客
05-26 479
Spring in Action之AOP
Spring in Action -- AOP篇
JISOOLUO的博客
04-25 312
1、什么是面向切面编程？ 概念：通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 2、AOP术语 2.1、通知（Advice） 在AOP术语中，切面的工作被称为通知、 Spring切面可以应用5中类型的通知 前置通知（Before）：在目标方法被调...
Spring AOP 学习笔记 【Spring in action】
hqq1007的博客
08-11 438
1、DI：对象与对象之间的解耦；AOP：功能与对象之间的解耦； 2、通知（Advice）：定义切面的工作是什么、何时被调用【what、when】 3、切点（Ponitcut）：定义切面的功能在何处执行【where】 4、切面（Aspect）：通知+切点=切面，定义功能是什么，在何时何地完成其功能【what、when、where】 5、在spring文件中如果使用aop标签，需要在中加上
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值