（三）Spring的AOP思想

最新推荐文章于 2023-12-01 14:17:45 发布
原创 最新推荐文章于 2023-12-01 14:17:45 发布 · 538 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Spring #SpringAOP 

title: （三）Spring的AOP思想
comments: false
date: 2018-05-25 21:01:45
top: 8
tags: Spring

AOP —> 面向切面编程

想要学习AOP思想，我们必须要理解几个名词：

横切关注点： 分布于应用中的众多功能被称为横切关注点。将横切关注点与业务逻辑相分离正是面向切面编程（AOP），横切关注点可以被模块化为特殊的类，这些类被称为切面。

通知（Advice）： 定义了切面是什么以及何时使用切面。

连接点（Joinpoint）: 定义了应用被通知的时机。

切点（Poincut）: 定义了切面在何处使用。

切面（Aspect）: 通知和切点共同定义了切面的全部内容（知道完成工作的一切事宜）。

引入（Introduction）: 以上整个过程我们可以称其为引入；是实现将现有类中添加新方法和属性。

织入（Wearving）: 织入是当切面应用到目标对象后创建新的代理对象的过程。

<!--more-->

那么我们用一张图来概括上面的内容吧：

解释几个点：

  1. Spring切面可以应用五种类型的通知：

    • Before —>在方法被调用之前调用通知

    • After —>在方法完成之后调用通知，无论方法执行是否成功。

    • After-returning —>在方法成功执行之后调用通知。

    • After-throwing —>在方法是抛出异常后调用通知。

    • Around —>通知包裹了呗通知的方法，在呗通知的方法调用之前后调用之后执行自定义的行为。

  2. 切面在指定的连接点被织入到目标对象中。在目标对象的声明周期里有多个点可以进行织入：

    • 编译期 —>切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的。

    • 类加载期 —>切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器（ClassLoader），它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5就支持以这种方式的织入切面。

    • 运行期 —>切面在应用运行的某个时刻被织入。一般情况下，在织入切面时AOP容器会为目标对象动态的创建一个代理对象。Spring AOP就是以这种方式织入切面的。

Spring对AOP的支持

AOP领域主要以下列三种框架为主：

  • AspectJ

  • JBoss AOP

  • Spring AOP

不是所有的AOP框架都是一样的，它们在连接点的模型上可能有强弱之分，它们织入切面的方式和时机也会有所不同。但是无论哪种，创建切点来定义切面织入的连接点是AOP框架的基本功能。

Spring提供了4种各具特色的AOP支持：

基于代理的经典AOP

@AspectJ注解驱动的切面

纯POJO切面

注入式AspectJ切面（适合Spring各版本）

注意： 前三种都是Spring基于代理的AOP的变体，Spring对AOP的支持局限于方法拦截

关于Spring AOP框架的一些关键点：

  • Spring通知是Java编写的（AspectJ则是用以Java语言扩展的方式实现的）

  • Spring在运行期通知对象

  • Spring只支持方法连接点

解释：

  1. 我们必须了解一下Spring是如何实现在运行期通知对象的：

  2. 因为Spring基于动态代理，所以Spring只支持方法连接点。其他框架如AspectJ和Jboss，除了方法切点，它们还提供了字段和构造器接入点。若需要方法拦截之外的连接点可利用AspectJ来协助。

使用切点选择连接点

在Spring AOP中，需要使用AspectJ的切点表达式语言来定义切点。但是：Spring仅支持AspectJ切点指示器的一个子集（Spring是基于代理的，而某些切点表达式是与基于代理的AOP无关的）。

Spring AOP所支持的切点表达式：

arg() —>限制连接点匹配参数为指定类型的执行方法

@args() —>限制连接点匹配参数由指定注解标注的执行方法

execution() —>用于匹配是连接点的执行方法

this() —>限制连接点匹配AOP代理的Bean引用为指定类型的类

target() —>限制连接点匹配目标对象为指定类型的类

@target() —>限制连接点匹配特定的执行对象，这些对象对应的类要具备指定类型的注解

within() —>限制连接点匹配指定的类型

@within() —>限制连接点匹配指定注解所标注的类型（使用SpringAOP，方法定义在由指定的注解所标注的类里）

@annotation —>限制匹配带有指定注解连接点

编写切点

以上可以看到只有execution()是唯一的执行匹配，其他都是限制匹配的，那么我们以一张图来分析一下如何编写切点。

如上图，整个execution方法表达式以*开头，标识我们不关系方法的返回值的类型。然后我们指定了全限定类名和方法名。对于参数列表，使用(..)表示可以匹配任意的play()方法。另外：

  • 使用within()指示器限制匹配，比如within(* cn.tycoding.demo1.*)

  • 可以使用一些表达式来连接多个限定。比如&& ||

  • 使用Spring的bean()指示器，允许在切点表达式中使用Bean的ID表示Bean。bean()使用BeanID或Bean名称作为参数来限制切点只匹配特定的Bean。例如：execution(* xxx.price()) and bean(beanID)

在XML中声明切面

<aop:advisor> 定义AOP通知器

<aop:after> 定义AOP后置通知（不管被通知的方法是否执行成功）

<aop:after-returning> 定义AOP after-retturning通知

<aop:after-throwing> 定义after-throwing通知

<aop:around> 定义AOP环绕通知

<aop:aspect> 定义切面

<aop:aspectj-autoproxy> 启用@AspectJ注解驱动的切面

<aop:before> 定义AOP的前置通知

<aop:config> 顶层的AOP配置元素。大多数的<aop:*>元素必须包含在<aop:config>元素内

<aop:declare-parents> 为被通知的对象引入额外的接口，并透明的实现

<aop:pointcut> 定义切点

综上我们已经解释了Spring AOP的一下概念性问题，那么下面我们写一个小案例来体会一下Spring AOP

在写案例之前必须要提示一下，之前我们已经给出了Spring的全部jar包，其中也包含针对AOP功能的jar：

要注意这里需要Aspectjweaver的jar文件

案例

  1. 定义一个Advice.java通知类

package demo3;
public class Advice {
    public void changeBefore(){
        System.out.println("price change before...");
    }
    public void changeAfter(){
        System.out.println("price change after...");
    }
    public void errorAfter(){
        System.out.println("price change error...");
    }
}

  1. 定义一个Fruits.java接口

package demo3;
public interface Fruits {
    void price();
}

  1. 定义一个Fruits的实现类Apple.java

package demo3;
public class Apple implements Fruits {
    public void price(){
        System.out.println("apple wang change price...");
    }
}

  1. 编写配置文件spring.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:context="http://www.springframework.org/schema/context"
       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/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
​
    <bean id="apple" class="demo3.Apple"/>
    <bean id="advice" class="demo3.Advice"/>
    <aop:config>
        <aop:aspect ref="advice">
            <aop:before pointcut="execution(* demo3.Apple.price(..))" method="changeBefore"/>
            <aop:after pointcut="execution(* demo3.Apple.price(..))" method="changeAfter"/>
            <aop:after-throwing pointcut="execution(* demo3.Apple.price(..))" method="errorAfter"/>
        </aop:aspect>
    </aop:config>
</beans>

解释：

  1. 大多数的AOP配置元素必须在<aop:config>元素的上下文内使用。

  2. <aop:config>元素内，可以声明多个通知器、切面、或者切点。

  3. 使用<aop:aspect>元素声明一个简单的切面。

  1. Test测试类

@Test
public void run(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
    //Apple apple = (Apple) ac.getBean("apple");
    //apple.price();
    Fruits fruits = (Fruits) ac.getBean("apple");
    fruits.price();
}

打印结果：

拓展：

我们使用Test测试类中被注释的部分去获取Bean会怎样呢？

@Test
public void run(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
    Apple apple = (Apple) ac.getBean("apple");
    apple.price();
    //Fruits fruits = (Fruits) ac.getBean("apple");
    //fruits.price();
}

就会出现如上报错，为什么呢？

原因

对于Spring AOP采用两种代理方法，一种是JDK的动态代理，一种是CGLIB。当代理对象实现了至少一个接口时，默认使用JDK动态创建代理对象。当代理对象没有实现任何接口时就是使用CGLIB

综上： JDK的动态代理是基于接口的； CJLIB是基于类的

首先我们要明白Spring AOP是通过什么方式创建代理对象的（可以查看这篇博文：代理对象生成）。上面的案例中，Apple实现了接口Fruits，这一点就决定了Spring会采用JDK的动态代理方式创建代理对象。而我们使用getBean即获取到一个返回的代理对象，这个代理对象其实是和Apple一样实现了Fruits接口。那么getBean()返回的代理对象让Apple这个实现类的引用来用，只能由他们的共同接口来引用。

改进

观察spring.xml我们发现，下面的通知元素中pointcut属性值都是一样的，这是因为所有的通知都是应用到同一个切点上，那么我们就可以通过<aop:pointcut>改进上述代码：

spring.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:context="http://www.springframework.org/schema/context"
       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/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
​
    <bean id="apple" class="demo3.Apple"/>
    <bean id="advice" class="demo3.Advice"/>
    <aop:config>
        <aop:aspect ref="advice">
            <aop:pointcut id="price" expression="execution(* demo3.Apple.price(..))"/>
            <aop:before pointcut-ref="price" method="changeBefore"/>
            <aop:after pointcut-ref="price" method="changeAfter"/>
            <aop:after-throwing pointcut-ref="price" method="errorAfter"/>
        </aop:aspect>
    </aop:config>
</beans>

声明环绕通知

使用环绕通知可以完成之前前置通知和后置通知所实现相同的功能。首先环绕通知需要使用ProceedingJoinPoint作为方法的入参。这个对象可以让我们在通知里调用被通知方法proceed()

  1. 创建环绕通知类：AroundAdvice.java

package demo3;
import org.aspectj.lang.ProceedingJoinPoint;
public class AroundAdvice {
    public void watchPrice(ProceedingJoinPoint joinPoint) {
        try{
            //前置通知
            System.out.println("around: price change before...");
            //执行被通知的方法
            joinPoint.proceed();
            //后置通知
            System.out.println("around: price change after...");
        } catch(Throwable t){
            System.out.println("around: change error...");
        }
    }
}

  1. 在spring.xml中需要使用<aop:pointcut>即可

<?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:context="http://www.springframework.org/schema/context"
       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/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
​
    <bean id="apple" class="demo3.Apple"/>
    <bean id="aroundAdvice" class="demo3.AroundAdvice"/>
    <aop:config>
        <aop:aspect ref="aroundAdvice">
            <aop:pointcut id="price" expression="execution(* demo3.Apple.price(..))"/>
            <!-- 声明环绕通知 -->
            <aop:around method="watchPrice" pointcut-ref="price"/>
        </aop:aspect>
    </aop:config>
</beans>

通知方法可以完成任何他需要做的事情，如果我们想讲控制权转给被通知的方法时，就可以调用proceed()实现。

为通知传递参数

  1. Fruits.java

package demo3;
public interface Fruits {
    void changePrice(int price);
    int getPrice();
}

在接口定义声明一个方法changePrice()，并在其参数列表中写入一个参数。为了方便观察通知前后参数的变化，在这里又声明一个方法getPrice()。

  1. Apple.java

package demo3;
public class Apple implements Fruits {
    private int price;
    {
        System.out.println("at first,apple price is: " + price);
    }
    public void changePrice(int price) {
        this.price = price;
    }
    public int getPrice() {
        return price;
    }
}

为了观察参数price的初始值，我们写了一个代码块打印price的初始值。因为Spring AOP是采用动态代理方式创建代理对象的，所以都要定义接口和实现类，这里Apple实现了Fruits.

  1. 创建实现传递参数功能的通知类：ParamAdvice.java

package demo3;
public class ParamAdvice  {
    private int price;
    public void changePrice(int price) {
        System.out.println("boss decision change price...");
        this.price = price;
    }
}

这是一个可以传递参数的通知类，可以看到，这与普通的类并没有什么区别，只是多了一个参数而已。

  1. spring.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:context="http://www.springframework.org/schema/context"
       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/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    
    <!-- 通知类 -->
    <bean id="paramAdvice" class="demo3.ParamAdvice"/>
    <!-- 目标类 -->
    <bean id="apple" class="demo3.Apple"/>
    <aop:config>
        <aop:aspect ref="paramAdvice">
            <aop:pointcut id="fruits" expression="execution(* demo3.Fruits.changePrice(int)) and args(price)"/>
            <aop:after method="changePrice" pointcut-ref="fruits" arg-names="price"/>
        </aop:aspect>
    </aop:config>
</beans>

织入一个可以实现传递参数的通知，我们首先要在<aop:config>下的<aop:aspect>中引入通知类的id；然后可以配置一个通用的切入点<aop:pointcut>，在使用execution()编写切点有所不同，首先在切入的方法changePrice()中指明切入的参数数据类型，再通过and args()来指明切入点的参数名称。

  1. Test测试类

@Test
public void run() {
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
    Fruits fruits = (Fruits) ac.getBean("apple");
    fruits.changePrice(12);
    System.out.println("now,this apple price is :" + fruits.getPrice());
}

这里还是要注意：因为Spring AOP采用JDK的动态代理和CGLIB的方式创建代理对象，所以对于这里有接口的实现类就必须用实现类和代理对象够共同具有的接口来接收getBean()获取的代理对象，然后我们就可以通过Fruits接口中的changePrice()设置参数的值。

通过切面引入新功能

之前我们一直探讨的是Spring AOP如何编写一个简单的通知类，即使上面我们实现了为通知传递参数，也仅仅是在目标类原有方法上进行的操作。其实Spring AOP可以借助<aop:declare-parent>元素来为目标对象添加信息的功能。我们用一张图来看一下实现流程：

实现代码

  1. 创建一个新的接口Orange.java

package demo3;
public interface Orange {
    void wantChangePrice();
}

  1. 创建Orange接口的实现类

package demo3;
public class OrangeAdvice implements Orange {
    public void wantChangePrice() {
        System.out.println("It's new method.Orange want  change price...");
    }
}

  1. spring.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:context="http://www.springframework.org/schema/context"
       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/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
​
    <bean id="orangeAdvice" class="demo3.OrangeAdvice"/>
    <aop:config>
        <aop:aspect>
            <aop:declare-parents types-matching="demo3.Fruits+" implement-interface="demo3.Orange" delegate-ref="orangeAdvice"/>
        </aop:aspect>
    </aop:config>
</beans>

<aop:declare-parents>声明了此切面所通知的Bean在它的对象层次结构中拥有新的父类型；types-matching指明创建的新类型匹配此接口；delegate-ref或default-impl都是指明匹配接口的实现类，区别是前者指明一个引用Bean，后置是直接写Bean的全限定名。

  1. Test测试类

@Test
public void run() {
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
    Orange orange = (Orange) ac.getBean("orangeAdvice");
    orange.wantChangePrice();
}

注解切面

Spring AOP提供了一个@AspectJ注解，实现了使其不需要额外的类或Bean声明就能将它转换成一个切面。不同的通知类型对应不同的注解，如：@Before() @After() @AfterReturning() @AfterThrowing()。下面我们通过一个案例来观察：

  1. 首先新创建一个Melon类

package demo3;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class Melon {
    //使用注解声明Bean对象
    @Bean
    public Melon melon(){
        return new Melon();
    }
    public void changePrice(){
        System.out.println("melon also need change price...");
    }
}

如果使用注解注入一个Bean对象，要使用@Configuration标记Java类，并通过@Bean标记一个return 对象的方法，告诉Spring这个方法将返回一个对象，且该对象应该被注册为Spring上下文中的一个Bean。

  1. 创建一个基于注解的通知类AnnoAdvice

package demo3;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Aspect
@Configuration
public class AnnoAdvice {
    @Pointcut("execution(* demo3.Melon.changePrice(..))")
    public void price(){
    }
    //后置通知
    @After("price()")
    public void changeAfter(){
        System.out.println("after melon price change...");
    }
    //使用注解注入Bean对象
    @Bean
    public AnnoAdvice annoAdvice (){
        return new AnnoAdvice();
    }
}

使用@Aspect标记的类会被Spring转换为一个切面，那么我们可以用@Pointcut定义一个切点，但是，注意被@Pointcut标记的方法内容并无意义，但是此方法名称则是切点名称，该方法文本只是一个标识，供@pointcut注解依附。

  1. spring.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:context="http://www.springframework.org/schema/context"
       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/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    <!-- 开启注解扫描 -->
    <context:component-scan base-package="demo3"/>
    <!-- 声明自动代理的Bean，该Bean知道如何把@AspectJ注解所标注的Bean转变为代理通知 -->
    <aop:aspectj-autoproxy/>
</beans>

通过<context:component-scan>可以实现注解扫描，这样我们在类中写的注解就会被扫描到。<aop:aspectj-autoproxy>是在Spring上下文中声明一个自动代理的Bean，这样Spring就会将被@Aspect注解标记的Bean定义为一个切面，而Spring自动代理的Bean就会与用@Pointcut注解定义的切点相匹配。

  1. Test测试类

@Test
public void run2(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
    Melon melon = (Melon) ac.getBean("melon");
    melon.changePrice();
}

注意

  1. <aop:aspectj-autoproxy>仅仅使用@AspectJ注解作为指引来创建基于代理的切面，但本质上它仍然是一个Spring风格的切面。这就意味着我们仍然限于代理方法的调用，想使用AspectJ的全部功能就必须在运行时使用AspectJ并不依赖Spring来创建基于代理的切面。

    1. <aop:aspect>元素和@Aspect注解都是把一个POJO转变成一个切面的有效方式。但是<aop:aspect>相比@Aspect优势就是不需要实现切面的代码，而@Aspect必须标注类和方法，需要由源码。

注解环绕通知

使用Spring的@Around注解就可以实现环绕通知，Demo如下：

我们改进上面的AnnoAdvice.java

package demo3;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.context.annotation.Configuration;
@Aspect
@Configuration
public class AnnoAdvice {
    @Pointcut("execution(* demo3.Melon.changePrice(..))")
    public void price(){
    }
    //创建环绕通知
    @Around("price()")
    public void aroundAdvice(ProceedingJoinPoint joinPoint){
        try {
            System.out.println("before, it's around advice...");
            joinPoint.proceed();
            System.out.println("after, it's around advice...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

同样，@Around标注的方法也需要一个ProceedingJoinPoint对象作为入参，以便可以通过proceed()调用被代理的方法。

传递参数给所标注的通知

通过注解传递参数与XML传递参数相似，只需要改变切点的表达式就能实现。

@Pointcut("execution(* demo3.Xxx(int)) && args(xxx)")
​
@Before("Xxx(xx)")

标注引入

前面我们使用了XML实现在原有类中引入新的接口，其实使用注解也可以实现。XML的<aop:declare-parents> 对应 @AspectJ的@DeclareParents。观察一下代码：

Melon“瓜”类

package demo3;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class Melon implements WaterMelon{
    //使用注解声明Bean对象
    @Bean
    public Melon melon(){
        return new Melon();
    }
    public void changePrice(){
        System.out.println("melon also need change price...");
    }
}

创建WaterMelon“西瓜”接口

package demo3;
public interface WaterMelon {
    void changePrice();
}

通知类AnnoAdvice

package demo3;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Aspect
@Configuration
public class AnnoAdvice {
    //使用注解注入Bean对象
    @Bean
    public AnnoAdvice annoAdvice (){
        return new AnnoAdvice();
    }
    @DeclareParents(value = "demo3.Fruits", defaultImpl = Melon.class)
    private static WaterMelon waterMelon;
}

如上所示，AnnoAdvice其实就是一个切面，通过@DeclareParents注解，为Fruits引入了一个新的接口WaterMelon，该接口的实现类是Melon,对于@DeclareParents注解由3个部分组成：

  • value属性 等同于<aop:declare-parents>的types-matching属性。它表示应该被引入指定接口的Bean类型。（目标对象）

  • defaultImpl属性 等同于<aop:declare-parents>的default-impl属性。它标识该类提供了所引入接口的实现。（引入的新接口的实现）

  • @DeclareParents 注解所标注的static指定了被引入的接口。（引入的新的接口）

<br/>

交流

如果大家有兴趣，欢迎大家加入我的Java交流群：671017003 ，一起交流学习Java技术。博主目前一直在自学JAVA中，技术有限，如果可以，会尽力给大家提供一些帮助，或是一些学习方法，当然群里的大佬都会积极给新手答疑的。所以，别犹豫，快来加入我们吧！


<br/>

联系

If you have some questions after you see this article, you can contact me or you can find some info by clicking these links.


适用spring 实现AOP思想
04-12
NULL 博文链接：https://wujie2008.iteye.com/blog/1703058
小马哥讲 Spring AOP 编程思想 - API 线索图.pdf
04-13
标题中的“API 线索图”可能意味着本文将通过一种图解的方式，即流程图或者类图的形式，来阐述Spring AOP的编程思想和API的使用。 描述中，“小马哥讲 Spring AOP 编程思想”表明这是由一位专家小马哥讲解的内容，...
Spring框架系列之AOP思想
weixin_33754065的博客
02-28 165
微信公众号：compassblog欢迎关注、转发，互相学习，共同进步！有任何问题，请后台留言联系！1、AOP概述（1）、什么是 AOPAOP 为 Aspect Oriented Programming 的缩写，意为“面向切面编程”。AOP 是 OOP （面向对象）的延续，可以对业务的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性和开发效率。（2）、AOP 思想图解：横...
AOP(四)之After增强处理
qq_40179479的博客
12-01 1320
After增强处理 使用@After可以修饰After增强处理，它与AfterReturning增强处理有点相似，但也有区别： AfterReturing增强处理只有在目标方法成功完成后才会被织入。 After增强处理不管目标方法如何结束（包括成功完成和遇到异常中止两种情况），它都会被织入。 测试 实现类方法 @Override public void testAfter1()...
spring的aop思想
weixin_41536380的博客
11-09 293
1.知识点总结 springAop: aop: 被称为 面向 切面编程 ， 是 oop 的 延续 ，升级版; oop ： Oriented Object programming aop ： Aspect Oriented programming aop作用： 简化代码量 ，可以动态的 监控程序的运行 ，并添加一些功能 ...
spring的AOP思想
weixin_40843624的博客
11-05 314
1.利用一个简单的静态的代理体会AOP思想（举例） 所谓的静态的代理就是在程序创建之前，代理类利用java代码实现 （1）首先创建一个接口： public interface ProductService { public void biz1(); public void biz2(); } （2）创建一个目标的类，实现这个接口： public class ProductTar...
springAOP的三种实现方式示例代码
08-18
Spring AOP 三种实现方式示例代码 Spring AOP（Aspect-Oriented Programming）是 Spring 框架中的一种面向方面编程技术，主要用于解决横切关注点的问题。AOP 的主要思想是将横切逻辑代码从业务逻辑代码中分离出来，...
理解Spring AOP实现与思想 案例代码
06-06
Spring AOP（面向切面编程）是Spring框架中的一个重要特性，它允许开发者在不修改源代码的情况下，通过插入额外的代码（称为切面）来增强应用程序的功能。这主要通过代理模式实现，使得我们可以集中处理系统中横切...
Spring IOC和Spring AOP_spring aop_springIOC
09-24
Spring的IOC，也称为控制反转，它是一种设计思想，核心就是将对象的创建和管理权交给容器，而不是由代码直接创建。这样做的好处在于，开发者不再需要关心对象的生命周期，只需要定义好对象的配置，由Spring容器负责...
springAOP的思想和设计以及实现
qq_41993438的博客
11-25 958
AOP(Aspect-Oriented Programming -面向切面编程)其实是OOP(Object-Oriented Programing -面向对象编程) 思想的补充和完善。 我们知道，面向对象的特性是：“多态”，“继承” ，“封装”，对事物进行了抽象和封装，以此建立了一种对象的层次结构，它强调一种完整的自上而下的关系。不过 OOP 的设计允许开发者定义事务的纵向关系，并不适合定义横向关...
Spring的AOP思想
Savior.D的博客
07-13 229
Spring之AOP 什么是AOP？   AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 目的：   利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 作用及其优势 **作用：**在程序运行期间，在不修改源码的情况下对方法进行功能增强 **优势：**减少重复代码，提高开发效率，并且便于维护 AOP 的底层实现   A
Spring中的AOP思想
最新发布
小王同学的博客
12-01 433
AOP 思想是和 Java 中的代理模式差不多，就是在不改变原有代码的情况下，对某些方法的功能进行增强。其中关键的概念有：连接点、切入点、切面、通知；：需要被增强功能的方法，以及通知所包围的原有代码段；：需要被增强的方法；：描述切入点和通知的关系，具体地指描述某个切入点需要哪个通知；：就是一些不变的代码段，需要给多个切入点添加的功能相同的代码；
Spring之AOP思想
一名在校大三学习JAVA
08-30 489
目录什么是AOP ​​​为什么用AOPSpring AOP 应该怎么学习呢AOP下的一些核心概念（SpringAOP并没有实现所有的概念）基于概念的使用Spring的AOP 一个使用的实例关于切点的匹配通知的种类 使用注解的方式来实现功能​编辑AOP框架背后的核心 需要实现两个原理AOP的应用-事务场景事务的概念 事务的隔离性 Spring的提供的一个事务切点@Transcctional​编辑...
spring的AOP思想（动态代理）
weixin_45063957的博客
03-26 1060
1、spring的AOP面向切面编程的思想 核心思想：在不改变原有代码的基础上，添加其他的功能；即把原来的代码调过来，然后再原来代码的基础上，在其前面或者后面添加额外的功能； 场景：权限控制、缓存、日志处理、事务控制； 拦截器也是aop思想的一种利用； 利用aop的代码中，一般分为两部分核心与非核心；核心部分一般就是原来的代码，非核心就是通过切入点，额外加入的功能； spring的AOP 本质是一种动态代理，分为JDK动态代理(实现了接口) 和CGlab动态代理两种； 2、核心概念：..
spring aop思想
hellodake的博客
08-22 224
spring插件：STS插件 spring整合junit测试     每一个方法都不需要先获得容器再获得对象了。 //帮我们创建容器 @RunWith(SpringJUnit4ClassRunner.class) //指定创建容器时使用哪个配置文件 @ContextConfiguration("classpath:applicationContext.xml") public class ...
Spring AOP思想
Giraffe_it的博客
12-10 331
1 . AOP        AOP（Aspect Oriented Programming）称为面向切面编程，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的...
AOP简介与作用
热门推荐
邵小小的博客
06-18 4万+
AOPAspect Oriented Programming（AOP）是较为热门的一个话题。AOP，国内大致译作“面向切面编程”。 “面向切面编程”,这样的名字并不是非常容易理解，且容易产生一些误导。 笔者不止一次听到类似“OOP/OOD11即将落伍，AOP是新一代软件开发方式”这样的发言。而在AOP中，Aspect的含义，可能更多的理解为“切面”比较合适。所以笔者更倾向于“面向切面编程”的译法。可
【Spring】AOP思想
你不来，再美的天地，都狼藉 ~
12-30 699
这篇文章主要介绍spring中的AOP思想及相关应用。
Spring中的AOP基本思想
lycos的六度空间
05-22 1368
AOP是Aspect Oriented Programming的缩写，即面向切面编程。 设计模式所追求的是降低代码之间的耦合度，增加程序的灵活性和可重用性，AOP实际上就是设计模式所追求的目标的一种实现。所谓的分离关注就是将某一通用的需求功能从不相关的类之中分离出来；同时，能够使得很多类共享一个行为，一旦行为发生变化，不必修改很多类，只要修改这个行为就可以。AOP就是这种实现分散关注的编程方法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值