Spring中的AOP的使用

最新推荐文章于 2023-02-17 13:51:38 发布
最新推荐文章于 2023-02-17 13:51:38 发布
阅读量631 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40055163/article/details/108511997
版权

Spring中的AOP的使用

1.1 什么是AOP
AOP：全称是Aspect Oriented Programming即：面向切面编程。在这里插入图片描述
简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
1.2 AOP的作用及优势
作用： 在程序运行期间，不修改源码对已有方法进行增强。
优势： 减少重复代码 提高开发效率 维护方便。
1.3 AOP相关术语
Joinpoint(连接点): 所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。
Pointcut(切入点): 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。
Advice(通知/增强): 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。 通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
通知的类型如图所示：在这里插入图片描述
Introduction(引介): 引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field。
Target(目标对象): 代理的目标对象。
Weaving(织入): 是指把增强应用到目标对象来创建新的代理对象的过程。
spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
Proxy（代理）: 一个类被AOP织入增强后，就产生一个结果代理类。
Aspect(切面): 是切入点和通知（引介）的结合。
1.4 spring中的AOP要明确的事
a、开发阶段（我们做的） 编写核心业务代码（开发主线）：
大部分程序员来做，要求熟悉业务需求。
把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP编程人员来做。
在配置文件中，声明切入点与通知间的关系，即切面。：AOP编程人员来做。
b、运行阶段（Spring框架完成的）：
Spring框架监控切入点方法的执行。
一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
1.5 spring基于XML的AOP编写必要的代码
1.打开IDEA的界面如图所示，并点击Create New Project。在这里插入图片描述
2.选择Maven工程和JDK的版本，并点击Next。如图所示：在这里插入图片描述
3.填写项目名称和保存的地址，点击Finish。如图所示：在这里插入图片描述
4.导入相应的依赖jar包的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.txw</groupId>
    <artifactId>day03__03springAOP</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包的方式-->
    <packaging>jar</packaging>
    <dependencies>
        <!--导入spring的依赖jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
        <!--导入切入点的表达式的依赖jar包-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
    </dependencies>
</project>
  1. 账户的业务层接口的代码如下：
package com.txw.service;

/**
 * 账户的业务层接口
 * @author Adair
 */
@SuppressWarnings("all")          // 注解警告信息
public interface IAccountService {
    /**
     * 模拟保存账户
     */
   void saveAccount();
    /**
     * 模拟更新账户
     * @param i
     */
   void updateAccount(int i);
    /**
     * 删除账户
     * @return
     */
   int  deleteAccount();
}
  1. 账户的业务层实现类的代码如下：
package com.txw.service.impl;

import com.txw.service.IAccountService;
/**
 * 账户的业务层实现类
 * @author Adair
 */
@SuppressWarnings("all")          // 注解警告信息
public class AccountServiceImpl implements IAccountService{
    /**
     * 模拟保存账户
     */
    public void saveAccount() {
        System.out.println("执行了保存");
    }
    /**
     * 模拟更新账户
     * @param i
     */
    public void updateAccount(int i) {
        System.out.println("执行了更新"+i);

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

7.创建用于记录日志的工具类的代码如下：

package com.txw.utils;

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 * @author Adair
 */
@SuppressWarnings("all")          // 注解警告信息
public class Logger {
    /**
     * 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）
     */
    public  void printLog(){
        System.out.println("Logger类中的pringLog方法开始记录日志了。。。");
    }
}

8.在resource目录下创建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">
    <!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="com.txw.service.impl.AccountServiceImpl"></bean>
    <!--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.txw.service.impl.AccountServiceImpl.saveAccount()
                访问修饰符可以省略
                    void com.txw.service.impl.AccountServiceImpl.saveAccount()
                返回值可以使用通配符，表示任意返回值
                    * com.txw.service.impl.AccountServiceImpl.saveAccount()
                包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
                    * *.*.*.*.AccountServiceImpl.saveAccount())
                包名可以使用..表示当前包及其子包
                    * *..AccountServiceImpl.saveAccount()
                类名和方法名都可以使用*来实现通配
                    * *..*.*()
                参数列表：
                    可以直接写数据类型：
                        基本类型直接写名称           int
                        引用类型写包名.类名的方式   java.lang.String
                    可以使用通配符表示任意类型，但是必须有参数
                    可以使用..表示有无参数均可，有参数可以是任意类型
                全通配写法：
                    * *..*.*(..)
                实际开发中切入点表达式的通常写法：
                    切到业务层实现类下的所有方法
                        * com.txw.service.impl.*.*(..)
    -->
    <!-- 配置Logger类 -->
    <bean id="logger" class="com.txw.utils.Logger"></bean>
    <!--配置AOP-->
    <aop:config>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置通知的类型，并且建立通知方法和切入点方法的关联-->
            <aop:before method="printLog" pointcut="execution(* com.txw.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

9.测试类的代码如下：

package com.txw.test;

import com.txw.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * 测试AOP的配置
 * @author Adair
 */
@SuppressWarnings("all")          // 注解警告信息
public class AOPTest {
    public static void main(String[] args) {
        // 1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2.获取对象
        IAccountService as = (IAccountService)ac.getBean("accountService");
        // 3.执行方法
        as.saveAccount();
        as.updateAccount(1);
        as.deleteAccount();
    }
}

运行结果如图所示：在这里插入图片描述
1.6 四种常用通知类型
1.打开IDEA的界面如图所示，并点击Create New Project。在这里插入图片描述
2.选择Maven工程和JDK的版本，并点击Next。如图所示：在这里插入图片描述
3.填写项目名称和保存的地址，点击Finish。如图所示：在这里插入图片描述
4.导入相应的依赖jar包的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.txw</groupId>
    <artifactId>day03_04adviceType</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包的方式-->
    <packaging>jar</packaging>
    <dependencies>
        <!--导入spring的依赖jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
        <!--导入切入点的表达式的依赖jar包-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
    </dependencies>
</project>
  1. 账户的业务层接口的代码如下：
package com.txw.service.impl;

import com.txw.service.IAccountService;
/**
 * 账户的业务层实现类
 * @author Adair
 */
@SuppressWarnings("all")     // 注解警告信息
public class AccountServiceImpl implements IAccountService{
    /**
     * 模拟保存账户
     */
    public void saveAccount() {
        System.out.println("执行了保存");
//        int i=1/0;
    }
    /**
     * 模拟修改账户
     * @param i
     */
    public void updateAccount(int i) {
        System.out.println("执行了更新"+i);

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

6.创建用于记录日志的工具类的代码如下：

package com.txw.utils;

import org.aspectj.lang.ProceedingJoinPoint;
/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 * @author Adair
 */
@SuppressWarnings("all")     // 注解警告信息
public class Logger {
    /**
     * 前置通知
     */
    public  void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }
    /**
     * 后置通知
     */
    public  void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }
    /**
     * 异常通知
     */
    public  void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }
    /**
     * 最终通知
     */
    public  void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }
    /**
     * 环绕通知
     * 问题：
     *      当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。
     * 分析：
     *      通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
     * 解决：
     *      Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
     *      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
     * spring中的环绕通知：
     *      它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     */
    public Object aroundPringLog(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方法开始记录日志了。。。最终");
        }
    }
}

7.在resource创建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">
    <!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="com.txw.service.impl.AccountServiceImpl"></bean>
    <!-- 配置Logger类 -->
    <bean id="logger" class="com.txw.utils.Logger"></bean>
    <!--配置AOP-->
    <aop:config>
        <!-- 配置切入点表达式 id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容
              此标签写在aop:aspect标签内部只能当前切面使用。
              它还可以写在aop:aspect外面，此时就变成了所有切面可用
          -->
        <aop:pointcut id="pt1" expression="execution(* com.txw.service.impl.*.*(..))"></aop:pointcut>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置前置通知：在切入点方法执行之前执行
            <aop:before method="beforePrintLog" pointcut-ref="pt1" ></aop:before>-->
            <!-- 配置后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个
            <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>-->
            <!-- 配置异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个
            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>-->
            <!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行
            <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>-->
            <!-- 配置环绕通知 详细的注释请看Logger类中-->
            <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

8.测试类代码如下：

package com.txw.test;

import com.txw.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * 测试AOP的配置
 * @author Adair
 */
@SuppressWarnings("all")     // 注解警告信息
public class AOPTest {
    public static void main(String[] args) {
        // 1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2.获取对象
        IAccountService as = (IAccountService)ac.getBean("accountService");
        // 3.执行方法
        as.saveAccount();
    }
}

运行结果如图所示：
在这里插入图片描述
1.7 spring基于注解的AOP配置
1.打开IDEA的界面如图所示，并点击Create New Project。在这里插入图片描述
2.选择Maven工程和JDK的版本，并点击Next。如图所示：在这里插入图片描述
3.填写项目名称和保存的地址，点击Finish。如图所示：在这里插入图片描述
4.导入相应的依赖jar包的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.txw</groupId>
    <artifactId>day03_05annotationAOP</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包的方式-->
    <packaging>jar</packaging>
    <dependencies>
        <!--导入spring的依赖jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
        <!--导入切入点的表达式的依赖jar包-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
    </dependencies>
</project>
  1. 账户的业务层接口的代码如下：
package com.txw.service;

/**
 * 账户的业务层接口
 */
@SuppressWarnings("all")     // 注解警告信息
public interface IAccountService {
    /**
     * 模拟保存账户
     */
   void saveAccount();
    /**
     * 模拟更新账户
     * @param i
     */
   void updateAccount(int i);
    /**
     * 删除账户
     * @return
     */
   int  deleteAccount();
}
  1. 账户的业务层实现类的代码如下：
package com.txw.service.impl;

import com.txw.service.IAccountService;
/**
 * 账户的业务层实现类
 * @author Adair
 */
@SuppressWarnings("all")     // 注解警告信息
@Service("accountService")
public class AccountServiceImpl implements IAccountService{
    /**
     * 模拟保存账户
     */
    public void saveAccount() {
        System.out.println("执行了保存");
//        int i=1/0;
    }
    /**
     * 模拟修改账户
     * @param i
     */
    public void updateAccount(int i) {
        System.out.println("执行了更新"+i);

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

7．在resource目录下创建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.txw"></context:component-scan>
    <!-- 配置spring开启注解AOP的支持 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

8.创建用于记录日志的工具类的代码如下：

package com.txw.utils;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 * @author Adair
 */
@SuppressWarnings("all")     // 注解警告信息
@Aspect   // 表示当前类是一个切面类
@Component("logger")
public class Logger {
    /**
     * 切入点表达式
     */
    @Pointcut("execution(* com.txw.service.impl.*.*(..))")
    private void pt1(){}
    /**
     * 前置通知
     */
//    @Before("pt1()")
    public  void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }
    /**
     * 后置通知
     */
//    @AfterReturning("pt1()")
    public  void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }
    /**
     * 异常通知
     */
//    @AfterThrowing("pt1()")
    public  void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }
    /**
     * 最终通知
     */
//    @After("pt1()")
    public  void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }
    /**
     * 环绕通知
     * 问题：
     *      当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。
     * 分析：
     *      通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
     * 解决：
     *      Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
     *      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
     * spring中的环绕通知：
     *      它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     */
    @Around("pt1()")
    public Object aroundPringLog(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方法开始记录日志了。。。最终");
        }
    }
}

9.测试类的代码如下：

package com.txw.test;

import com.txw.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * 测试AOP的配置
 * @author Adair
 */
@SuppressWarnings("all")     // 注解警告信息
public class AOPTest {
    public static void main(String[] args) {
        // 1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2.获取对象
        IAccountService as = (IAccountService)ac.getBean("accountService");
        // 3.执行方法
        as.saveAccount();
    }
}

运行结果如图所示：
在这里插入图片描述

学无止路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring AOP 的三种使用方式(万字长文)
大鹏的博客
06-21 2390
Spring AOP 作为 Spring Framework 的核心模块，对 Spring IOC 加以补充，Spring 内部使用它提供了企业级的服务，如事务、异步、缓存等，同时它也允许用户自定义 Aspect，以便用 AOP 补充对 OOP 的使用。通常情况下，我们会通过 AspectJ 的注解来使用 Spring AOP，那么 Spring 一共提供了哪些使用 AOP 的方式呢？本篇将对其总结，并尝试了解 Spring AOP 的内部实现。
Spring AOP用法详解
最新发布
深圳市多克创新科技有限公司
10-23 977
AOP：Aspect Oriented Programming，中文翻译为”面向切面编程“。面向切面编程是一种编程范式，它作为OOP面向对象编程的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、权限控制、缓存控制、日志打印等等。AOP采取横向抽取机制，取代了传统纵向继承体系的重复性代码
spring18--spring中的通知
月落孤城的博客
04-29 343
1、前置通知 org.springframework.aop.MethodBeforeAdvice * 在目标方法执行前实施增强 2、后置通知 org.springframework.aop.AfterReturningAdvice * 在目标方法执行后实施增强 3、环绕通知 org.aopalliance.intercept.MethodInterceptor * 在目标方法执行前后实...
使用Spring实现Aop三种方法
vengu733的博客
08-05 3173
** 方式一 ：使用spring的AP接口 方式二 ： 自定义来实现AOP (主要是切面定义) 方式三 ：使用注解实现AOP **使用AOP 植入 ，需要导入依赖包aspectj 方式一 ：使用spring的AP接口 定义uservice接口 接口实现类userviceImpl 创建要做代理 为uservice 添加日志 的log类 创建afterlog 类 ben.xml 创建测试： div 自定义一个类 bean.xml 测试结果： 分析： 创建annotation类 bean.xml 测试
Spring框架之AOP详解
qq_45515347的博客
09-05 1949
Spring AOP 详解，并实现demo
Spring AOP中使用args表达式的方法示例
08-25
Spring AOP中使用args表达式的方法示例 Spring AOP（Aspect-Oriented Programming）是一种面向切面编程的技术， args表达式是AOP中的一种表达式，它可以用来指定目标方法的参数类型和数量。下面我们将详细介绍...
spring中AOP个人总结
01-21
spring中AOP个人总结 简介 aop（aspect oriented programming）面向切面编程是spring当中一个重要内容，在学习之后感觉这个思想挺不错的，做个总结 AOP讲解 一、面向切面编程 ​ 听说过面向对象编程（oop），但是...
JavaEE Spring AOP使用
04-16
在Spring AOP中，切面可以由一个或多个通知（advice）组成。 2. **通知（Advice）**：通知是在特定连接点上执行的代码，例如方法调用前后。Spring支持五种类型的通知：前置通知（Before）、后置通知（After）、返回...
线程池中使用spring aop事务增强
08-25
主要介绍了线程池中使用spring aop事务增强,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring Aop使用实例
03-23
**Spring AOP 使用实例** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架的一个重要组成部分，它提供了一种在不修改原有代码的情况下，通过代理方式添加额外功能的技术。这种技术使得我们...
Spring中Aop的使用
a18372016358的博客
02-09 314
Spring中Aop的使用
理解AOP@Before,@After,@AfterReturning,@AfterThrowing执行顺序
Jay Chang
01-06 7155
实现AOP的切面主要有以下几个要素： 使用@Aspect注解将一个java类定义为切面类 使用@Pointcut定义一个切入点，可以是一个规则表达式，比如下例中某个package下的所有函数，也可以是一个注解等。 根据需要在切入点不同位置的切入内容 使用@Before在切入点开始处切入内容 使用@After在切入点结尾处切入内容 使用@AfterReturning在切入点return...
【Spring AOP】Spring AOP快速使用
杜小舟的博客
02-17 1227
Spring Aop的快速使用，用两个简单小案例完成Aop的基本使用。
SpringAOP详细配置与使用
青元子的博客
06-11 5万+
目录 SpringAOP简介 AOP概念 Spring AOP简单流程图 Spring AOP之Annotation 前置通知(Before advice) 返回后通知(After reurning advice) 抛出异常后通知(After throwing advice) 后置通知(After (finally) advice) 环绕通知(Around advice) 引入...
Spring AOP使用示例
热门推荐
最怕一生碌碌无为，还安慰自己平凡可贵
06-13 6万+
AOP:【面向切面编程】 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式。 1、导入aop模块：Spring AOP：（spring-aspects） 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候讲日志进行打印（方法之前、方法运行结束、方法出现异常等) 3、定义一个日志切面类（LOgAspects）；切面类里面...
SpringAOP的操作和具体的使用方法三步走（传统方法）
北极猴Blog
02-15 2066
什么是SpringAOP？ 通俗的话来讲：就是你的已经做好的项目，需要给他增加功能，或者在更新迭代的时候，把以前的老的程序里面的方法做增强的话，最原始的手段是去直接改代码，这样做的感觉是很不友好的，造成代码的侵入性。 而AOP的思想是，不去动原来的代码，而是基于原来代码产生代理对象，通过代理的方法，去包装原来的方法，就完成了对以前方法的增强。换句话说，AOP的底层原理就是动态代理的实现。 关于AO...
Spring的AOP使用实例
惜暮
01-24 1万+
本文主要通过一些实例，一步步逐渐完善一个AOP的例子： 1.简单的AOP日志实现-某方法之前的前后记录日志； 2.简单的AOP日志实现-需要记录方法的运行时间； 3.简单的AOP日志实现-增加检查订单功能； 以上这些例子的AOP相关的配置均使用XML配置实现，bean的配置均使用Java代码实现，稍后会给出AOP注解配置的实现方案。1.某方法之前的前后记录日志（1）entity蛋糕
springboot中aop的应用场景_Spring中使用AOP及SpringBoot集成AOP
weixin_28455801的博客
01-13 349
一、Spring中使用AOP引入Aspect1 2 org.aspectj3 aspectjweaver4 ${aspectj.version}5 创建用于拦截的bean1 public classTestBean {2 private String message = "test bean";34 publicString getMessage() {5 ...
Spring AOP看这篇就够了
ITMuch的专栏
02-01 290
点击上方IT牧场，选择置顶或者星标技术干货每日送达！来源：sf.gg/a/1190000007469968基本知识其实, 接触了这么久的 AOP, 我感觉, AOP 给人难以理解的...
spring的aop使用
08-11
以下是使用Spring的AOP的基本步骤： 1. 添加依赖：在项目的构建文件（如pom.xml）中添加Spring AOP的依赖。 2. 配置切面：创建一个切面类，该类包含横切逻辑的代码。可以使用注解或XML配置来定义切面。 3. 定义...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学无止路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值