【Spring】之Spring AOP-07

最新推荐文章于 2024-08-16 20:21:37 发布

CodeDove

最新推荐文章于 2024-08-16 20:21:37 发布

阅读量121

点赞数

分类专栏： Spring 文章标签： spring java

本文链接：https://blog.csdn.net/ShangPanGe/article/details/118692758

版权

Spring 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Spring

1 AOP概述

1 AOP概述

1.1 AOP概念

AOP： 全称是 Aspect Oriented Programming 即： 面向切面编程。

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
作用： 在程序运行期间，不修改源码对已有方法进行增强。
优势： 减少重复代码、提高开发效率、维护方便
AOP 的实现方式： 使用动态代理技术

1.2 Spring中的AOP

1.2.1 AOP相关术语

Joinpoint(连接点)： 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
Pointcut(切入点)： 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice(通知/增强)： 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction(引介)： 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
Target(目标对象)： 代理的目标对象。
Weaving(织入)： 是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy（代理）： 一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect(切面)： 是切入点和通知（引介）的结合。

1.2.2 Spring 中的 AOP 要明确的事

a、开发阶段（我们做的）

编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
把公用代码抽取出来，制作成通知。（开发阶段最后再做）： AOP 编程人员来做。
在配置文件中，声明切入点与通知间的关系，即切面。： AOP 编程人员来做。

b、运行阶段（ Spring 框架完成的）

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行

1.2.3 关于代理的选择

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

1.3 基于 XML 的 AOP 配置

示例：采用账户转账作为示例。并且把 spring 的 IOC也一起应用进来。

1.3.1 环境搭建

新建项目spring_day03_03springaop
创建AccountService.java

package com.spg.service;

/**
 * 账户的业务层接口
 */
public interface AccountService {
    /**
     * 模拟保存账户
     */
    void saveAccount();

    /**
     * 模拟更新账户
     * @param i
     */
    void updateAccount(int i);

    /**
     * 删除账户
     * @return
     */
    int deleteAccount();
}

创建AccountServiceImpl.java

package com.spg.service.impl;

import com.spg.service.AccountService;

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements AccountService {
    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
    }

    @Override
    public void updateAccount(int i) {
        System.out.println("执行了更新" + i);
    }

    @Override
    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}

创建Logger.java

package com.spg.utils;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {

    /**
     * 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）
     */
    public void printLog(){
        System.out.println("Logger类中的printLog方法开始记录日志了...");
    }
}

1.3.2 配置步骤

引入依赖pom.xml

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
		<!-- 解析切入点表达式 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>

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

    <!-- 配置spring的IOC，把Service对象配置进来 -->
    <bean id="accountService" class="com.spg.service.impl.AccountServiceImpl"/>

    <!-- spring中基于XML的AOP配置步骤
            1.把通知Bean也交给spring来管理
            2.使用aop:config标签表明开始AOP的配置
            3.使用aop:aspect标签表明配置切面
                id属性：给切面提供一个唯一标识
                ref属性：指定通知类bean的id
            4.在aop:aspect标签的内部使用对应标签来配置通知的类型
                我们现在示例是让printLog方法在切入点方法执行之前执行，所以是前置通知
                aop:before：表示配置前置通知
                    method属性：用于指定Logger类中哪个方法是前置通知
                    pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强
                切入点表达式的写法：
                    关键字:execution(表达式)
                    表达式：访问修饰符 返回值 包名.包名.包名...类名.方法名(参数列表)
                    标准的表达式写法：
                        public void com.spg.service.impl.AccountServiceImpl.saveAccount()
     -->

    <!-- 配置Logger类 -->
    <bean id="logger" class="com.spg.utils.Logger"/>

    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置通知的类型并且建立通知方法和切入点方法的关联 -->
            <aop:before method="printLog" pointcut="execution(public void com.spg.service.impl.AccountServiceImpl.saveAccount())"/>
        </aop:aspect>
    </aop:config>

</beans>

创建测试类AOPTest.java

package com.spg.test;

import com.spg.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试AOP的配置
 */
public class AOPTest {
    public static void main(String[] args) {
        // 1.获取容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        // 2.获取对象
        AccountService accountService = (AccountService) applicationContext.getBean("accountService");
        // 3.执行方法
        accountService.saveAccount();

    }
}

测试结果：
在这里插入图片描述

1.3.3 切入点表达式的写法

<?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">

    <!-- 配置spring的IOC，把Service对象配置进来 -->
    <bean id="accountService" class="com.spg.service.impl.AccountServiceImpl"/>

    <!-- spring中基于XML的AOP配置步骤
            1.把通知Bean也交给spring来管理
            2.使用aop:config标签表明开始AOP的配置
            3.使用aop:aspect标签表明配置切面
                id属性：给切面提供一个唯一标识
                ref属性：指定通知类bean的id
            4.在aop:aspect标签的内部使用对应标签来配置通知的类型
                我们现在示例是让printLog方法在切入点方法执行之前执行，所以是前置通知
                aop:before：表示配置前置通知
                    method属性：用于指定Logger类中哪个方法是前置通知
                    pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强
                切入点表达式的写法：
                    关键字:execution(表达式)
                    表达式：访问修饰符 返回值 包名.包名.包名...类名.方法名(参数列表)
                    标准的表达式写法：
                        public void com.spg.service.impl.AccountServiceImpl.saveAccount()
                    访问修饰符可以省略
                        void com.spg.service.impl.AccountServiceImpl.saveAccount()
                    返回值可以使用通配符，表示任意返回值
                        * com.spg.service.impl.AccountServiceImpl.saveAccount()
                    包名可以使用通配符，表示任意包，但是有几级包，就需要写几个*
                        * *.*.*.*.AccountServiceImpl.saveAccount()
                    包名可以使用..表示当前包及其子包
                        * *..AccountServiceImpl.saveAccount()
                    类名和方法名都可以使用*来实现通配
                        * *..*.*()
                    参数列表：
                        可以直接写数据类型：
                            基本类型直接写名称         int
                            引用类型写包名.类名的方式   java.lang.String
                            可以使用通配符表示任意类型，但是必须有参数
                            可以使用..表示有无参数均可，有参数可以是任意类型
                    全通配写法：
                        * *..*.*(..)

                    实际开发中，切入点表达式的通常写法：
                        切到业务层实现类下的所有方法
                            * com.spg.service.impl.*.*(..)
     -->

    <!-- 配置Logger类 -->
    <bean id="logger" class="com.spg.utils.Logger"/>

    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置通知的类型并且建立通知方法和切入点方法的关联 -->
            <aop:before method="printLog" pointcut="execution(* com.spg.service.impl.*.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

1.3.4 四种常用通知类型

修改Logger.java

package com.spg.utils;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {

    /**
     * 前置通知
     */
    public void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了...");
    }

    /**
     * 后置通知
     */
    public void afterReturningLog(){
        System.out.println("后置通知Logger类中的afterReturningLog方法开始记录日志了...");
    }

    /**
     * 异常通知
     */
    public void afterThrowingLog(){
        System.out.println("异常通知Logger类中的afterThrowingLog方法开始记录日志了...");
    }

    /**
     * 最终通知
     */
    public void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了...");
    }
}

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

    <!-- 配置spring的IOC，把Service对象配置进来 -->
    <bean id="accountService" class="com.spg.service.impl.AccountServiceImpl"/>

    <!-- 配置Logger类 -->
    <bean id="logger" class="com.spg.utils.Logger"/>

    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置通知的类型并且建立通知方法和切入点方法的关联 -->
            <!-- 配置前置通知：在切入点方法执行之前执行 -->
            <aop:before method="beforePrintLog" pointcut="execution(* com.spg.service.impl.*.*(..))"/>
            <!-- 配置后置通知：在切入点方法正常执行之后执行，它和异常通知永远只能执行一个 -->
            <aop:after-returning method="afterReturningLog" pointcut="execution(* com.spg.service.impl.*.*(..))"/>
            <!-- 配置异常通知：在切入点方法执行产生异常之后执行，它和后置通知永远只能执行一个 -->
            <aop:after-throwing method="afterThrowingLog" pointcut="execution(* com.spg.service.impl.*.*(..))"/>
            <!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行 -->
            <aop:after method="afterPrintLog" pointcut="execution(* com.spg.service.impl.*.*(..))"/>
        </aop:aspect>
    </aop:config>

</beans>

测试结果：
在这里插入图片描述
在AccountServiceImpl.java中saveAccount()加入int i = 1 / 0 ;

    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
        int i = 1 / 0 ;
    }

测试结果：
在这里插入图片描述

1.3.5 通用化切入点表达式

<?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">

    <!-- 配置spring的IOC，把Service对象配置进来 -->
    <bean id="accountService" class="com.spg.service.impl.AccountServiceImpl"/>

    <!-- 配置Logger类 -->
    <bean id="logger" class="com.spg.utils.Logger"/>

    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置通知的类型并且建立通知方法和切入点方法的关联 -->
            <!-- 配置前置通知：在切入点方法执行之前执行 -->
            <aop:before method="beforePrintLog" pointcut-ref="pt1" />
            <!-- 配置后置通知：在切入点方法正常执行之后执行，它和异常通知永远只能执行一个 -->
            <aop:after-returning method="afterReturningLog" pointcut-ref="pt1" />
            <!-- 配置异常通知：在切入点方法执行产生异常之后执行，它和后置通知永远只能执行一个 -->
            <aop:after-throwing method="afterThrowingLog" pointcut-ref="pt1" />
            <!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行 -->
            <aop:after method="afterPrintLog" pointcut-ref="pt1" />
            <!-- 配置切入点表达式
                    id属性：用于指定表达式的唯一标识
                    expression属性：用于指定表达式内容
                 此标签写在aop:aspect标签内部只能当前切面使用。
                 它还可以写在aop:aspect外面（要放在aop:aspect之前），此时就变成了所有切面可用
             -->
            <aop:pointcut id="pt1" expression="execution(* com.spg.service.impl.*.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

1.3.6 Spring中的环绕通知

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

    <!-- 配置spring的IOC，把Service对象配置进来 -->
    <bean id="accountService" class="com.spg.service.impl.AccountServiceImpl"/>

    <!-- 配置Logger类 -->
    <bean id="logger" class="com.spg.utils.Logger"/>

    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切入点表达式
                id属性：用于指定表达式的唯一标识
                expression属性：用于指定表达式内容
             此标签写在aop:aspect标签内部只能当前切面使用。
             它还可以写在aop:aspect外面（要放在aop:aspect之前），此时就变成了所有切面可用
         -->
        <aop:pointcut id="pt1" expression="execution(* com.spg.service.impl.*.*(..))"/>
        <!-- 配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置环绕通知 详细的注释看Logger-->
            <aop:around method="aroundPrintLog" pointcut-ref="pt1"/>
        </aop:aspect>

    </aop:config>

</beans>

Logger.java中加入

    /**
     * 环绕通知
     * 问题：
     *     当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了
     * 分析：
     *     通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有
     *      Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
     *      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
     * spring中的环绕通知：
     *      它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     */
    public Object aroundPrintLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
        }
    }

1.4 基于注解的AOP配置

新建项目spring_day03_05annotationAOP
创建AccountService.java

package com.spg.service;

/**
 * 账户的业务层接口
 */
public interface AccountService {
    /**
     * 模拟保存账户
     */
    void saveAccount();

    /**
     * 模拟更新账户
     * @param i
     */
    void updateAccount(int i);

    /**
     * 删除账户
     * @return
     */
    int deleteAccount();
}

创建AccountServiceImpl.java

package com.spg.service.impl;

import com.spg.service.AccountService;
import org.springframework.stereotype.Service;

/**
 * 账户的业务层实现类
 */
@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
//        int i = 1 / 0 ;
    }

    @Override
    public void updateAccount(int i) {
        System.out.println("执行了更新" + i);
    }

    @Override
    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}

创建Logger.java

package com.spg.utils;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
@Aspect // 表示当前类是一个切面类
public class Logger {

    /**
     * @Pointcut
     * 作用： 指定切入点表达式
     * 属性： value：指定表达式的内容
     */
    @Pointcut("execution(* com.spg.service.impl.*.*(..))")
    private void pt1(){}

    /**
     * 前置通知
     * @Before
     * 作用： 把当前方法看成是前置通知。
     * 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用。
     */

    @Before("pt1()")
    public void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了...");
    }

    /**
     * 后置通知
     * @AfterReturning
     * 作用： 把当前方法看成是后置通知。
     * 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用
     */
    @AfterReturning("pt1()")
    public void afterReturningLog(){
        System.out.println("后置通知Logger类中的afterReturningLog方法开始记录日志了...");
    }

    /**
     * 异常通知
     * @AfterThrowing
     * 作用： 把当前方法看成是异常通知。
     * 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用
     */
    @AfterThrowing("pt1()")
    public void afterThrowingLog(){
        System.out.println("异常通知Logger类中的afterThrowingLog方法开始记录日志了...");
    }

    /**
     * 最终通知
     * @After
     * 作用： 把当前方法看成是最终通知。
     * 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用
     */
    @After("pt1()")
    public void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了...");
    }

    /**
     * 环绕通知
     * 问题：
     *     当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了
     * 分析：
     *     通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有
     *      Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
     *      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
     * spring中的环绕通知：
     *      它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     * @Around
     * 作用： 把当前方法看成是环绕通知。
     * 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用。
     */
    @Around("pt1()")
    public Object aroundPrintLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
        }
    }
}

引入依赖pom.xml

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
		<!-- 解析切入点表达式 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>

创建bean.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"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置spring在创建容器时要扫描的包 -->
    <context:component-scan base-package="com.spg"/>

    <!-- 配置spring开启对注解AOP的支持 -->
    <aop:aspectj-autoproxy/>

</beans>

或者不使用XML的文件配置

@Configuration
@ComponentScan(basePackages="com.spg")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}

创建测试类AOPTest.java

package com.spg.test;

import com.spg.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试AOP的配置
 */
public class AOPTest {
    public static void main(String[] args) {
        // 1.获取容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        // 2.获取对象
        AccountService accountService = (AccountService) applicationContext.getBean("accountService");
        // 3.执行方法
        accountService.saveAccount();

    }
}

CodeDove

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Spring】之Spring AOP-07

Spring1 AOP概述1.1 AOP概念1.2 AOP具体应用1 AOP概述1.1 AOP概念AOP：全称是 Aspect Oriented Programming 即：面向切面编程。简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。作用：在程序运行期间，不修改源码对已有方法进行增强。优势：减少重复代码、提高开发效率、维护方便AOP 的实现方式：使用动态代理技术1.2 AOP具体应用...
复制链接

扫一扫

专栏目录