Spring-AOP

最新推荐文章于 2021-07-21 17:49:43 发布
最新推荐文章于 2021-07-21 17:49:43 发布
阅读量76 收藏
点赞数
分类专栏： Spring学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40429067/article/details/112758908
版权
Aop在Spring中的作用
  • 提供声明式事务；允许用户自定义切面
  • 以下名词需要了解下：
    • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
    • 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
    • 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
    • 目标（Target）：被通知对象。（pointcut：在哪个地方执行）
    • 代理（Proxy）：向目标对象应用通知之后创建的对象。
    • 切入点（PointCut）：切面通知 执行的 “地点”的定义。
    • 连接点（JointPoint）：与切入点匹配的执行点。

使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包！

<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

AOP实现方式一：使用Spring的API接口

  1. 业务接口
public interface UserService {
    int add();
    public void delete();
    public void update();
    public void select();
}
  1. 业务接口实现类
public class UserServiceImpl implements UserService{


    @Override
    public int add() {
        System.out.println("增加了一个用户");
        return 1;
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询了一个用户");
    }
}
  1. 前置增强类
public class Log1 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()+"被执行了");
    }
}
  1. 后置增强类
public class Log2 implements AfterReturningAdvice {
    //returnValue 返回值
    //method被调用的方法
    //args 被调用的方法的对象的参数
    //target 被调用的目标对象
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] arg, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"返回结果："+ returnValue);
    }
}
  1. applicationContext.xml 中注册所有类 , 并实现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 https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userservice" class="com.qk.service.UserServiceImpl"></bean>
    <bean id="log1" class="com.qk.log.Log1"></bean>
    <bean id="log2" class="com.qk.log.Log2"></bean>
    <!--aop的配置-->
    <aop:config>
        <!--切入点 expression:表达式匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.qk.service.UserServiceImpl.*(..))"/>
        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
        <aop:advisor advice-ref="log1" pointcut-ref="pointcut"></aop:advisor>
        <aop:advisor advice-ref="log2" pointcut-ref="pointcut"></aop:advisor>
    </aop:config>

</beans>
  1. 测试
@Test
    public void test01(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是一类接口，返回的是代理类
        UserService userservice = context.getBean("userservice", UserService.class);
        userservice.add();

    }

在这里插入图片描述

AOP实现方式二：自定义来实现AOP

  1. 自定义要切入的类，不要实现任何接口
  • 和方式一一样的业务接口
public interface UserService {
    int add();
    public void delete();
    public void update();
    public void select();
}
  • 和方式一一样的业务接口实现类
public class UserServiceImpl implements UserService{


    @Override
    public int add() {
        System.out.println("增加了一个用户");
        return 1;
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询了一个用户");
    }
}
  • 自定义的切入类，不需要继承和实现任何方法
public class Logs {
    public void before(){
        System.out.println("---------方法执行前---------");
    }
    public void after(){
        System.out.println("---------方法执行后---------");
    }
}
  • applicationContext.xml 中注册自定义类和接口实现类 , 使用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 https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userservice" class="com.qk.service.UserServiceImpl"></bean>

    <!--方式二：自定义类-->
    <bean id="logs" class="com.qk.log.Logs"></bean>

    <aop:config>
        <!--自定义切面，ref 要引用的类-->
        <aop:aspect ref="logs">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.qk.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"></aop:before>
            <aop:after method="after" pointcut-ref="point"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>
  • 和方式一一样的测试类
@Test
    public void test01(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口，返回的是代理类
        UserService userservice = context.getBean("userservice", UserService.class);
        userservice.delete();
        userservice.add();
        userservice.update();
        userservice.select();
    }

在这里插入图片描述

AOP实现方式三：使用注解实现AOP

  • 和方式一一样的业务接口
public interface UserService {
    int add();
    public void delete();
    public void update();
    public void select();
}
  • 和方式一一样的业务接口实现类
public class UserServiceImpl implements UserService{


    @Override
    public int add() {
        System.out.println("增加了一个用户");
        return 1;
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询了一个用户");
    }
}
  • 切入类：用注解方式实现
//使用注解方式实现AOP
@Aspect
public class AnnotationPointCut {
    @Before("execution(* com.qk.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=====方法执行前=====");
    }
    @After("execution(* com.qk.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("=====方法执行后=====");
    }
    //在环绕增强中，可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.qk.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("=====环绕前=====");
        //谁被执行了
        //获取签名
        Signature signature = joinPoint.getSignature();
        System.out.println("signature:"+signature);
        Object proceed = joinPoint.proceed();
        
        System.out.println("=====环绕后=====");
    }
}
  • applicationContext.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 https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userservice" class="com.qk.service.UserServiceImpl"></bean>

    <bean id="annotationpointcut" class="com.qk.log.AnnotationPointCut"></bean>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>
  • 测试
@Test
    public void test01(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口，返回的是代理类
        UserService userservice = context.getBean("userservice", UserService.class);
        userservice.delete();
    }

在这里插入图片描述

AOP：在不影响原来业务的情况下，实现动态增强。

35s
关注
专栏目录
图文详解spring的4种事务特性，5种隔离级别，7种传播行为
Jack章臣的博客
04-09 545
什么是事务: 事务是指逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败。 事务特性（4种）: 原子性 （atomicity）:强调事务的不可分割，要么一起成功,要么一起失败。 一致性 （consistency）:事务的执行时，前后数据的完整性保持一致。 隔离性 （isolation）:一个事务执行的过程中,不应该受到其他事务的干扰。 持久性（dur...
Spring 中基于XML配置的AOP
weixin_47371330的博客
10-06 216
Spring 中基于XML配置的AOP 定义好目标对象 ， 注册到Spring容器中 定义好增强对象， 注册到Spring容器中 通过XML进行 AOP 的 织入过程的配置： <!--将包含增强逻辑的类（增强类） 注册到Spring容器中--> <bean id="myAdvice" class="com.example.spring.aop.xml.advice.LogAdvice"/> <!-- aop:config
Spring学习：AOP
qq_22512819的博客
08-15 122
什么是AOP AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。是Spring框架中的一个重要内容。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 主要功能： 日志记录，性能统计，安全控制，事务处理，异常处理等等。 主要意图： 将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为
Spring AOP详解（示例）
xiaoxsen的博客
08-14 2473
一、什么是AOP 　　AOP(Aspect-Oriented Programming), 即 面向切面编程, 它与 OOP( Object-Oriented Programming, 面向对象编程) 相辅相成, 提供了与 OOP 不同的抽象软件结构的视角.在 OOP 中, 我们以类(class)作为我们的基本单元, 而 AOP 中的基本单元是 Aspect(切面)。 二、AOP的优点 　　它
谈谈对Spring的概述、特点、常用及核心技术理解
qq_39529092的博客
05-18 1329
Spring 概述 Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的（替代更加重量级的企业级Java技术， 尤其是EJB），它完成了大量开发中的通用步骤，留给开发者的仅仅是与特定应用相关的部分，从而大大提高了企业应用的开发效率。 spring可以实现java模块化开发，贯穿表现层，业务层，逻辑层，实现了各个层之间的解耦合关系。 Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式如下图：
spring aop注解与xml配置两种方式
weixin_43671743的博客
04-02 321
spring aop切面两种使用方式: 1.使用xml配置文件的方式,个人感觉代码比较清晰,能够体现出明显的层次感 xml文件配置的方式开启aop 我创建的是普通java工程,用到的相关的jar包 和测试相关类:包可以创建maven配置依赖后下载下来自己归类使用 目的就是在指定切点运行指定切面,xml相关配置: 需要注意的是:切面的ref与bean的name属性一致 切点的expression写...
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
spring-aop-5.2.0.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-aop-5.2.0.RELEASE.jar； 赠送原API文档：spring-aop-5.2.0.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.2.0.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.2.0.RELEASE.pom；...
spring-aop-5.0.10.RELEASE-API文档-中文版.zip
04-23
赠送jar包：spring-aop-5.0.10.RELEASE.jar； 赠送原API文档：spring-aop-5.0.10.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.0.10.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.0.10.RELEASE....
spring，spring-aop-5.3.22.jar+aop+IDEA本地包
09-09
spring-aop-5.3.22.jar Spring AOP provides an Alliance-compliant aspect-oriented programming implementation allowing you to define method interceptors and pointcuts to cleanly decouple code that ...
spring-aop-6.0.2.jar
10-25
spring-aop-6.0.2.jar
Spring中AOP的xml配置及实现(详解，含注解)
weixin_45671085的博客
06-09 1383
这里就直接开始讲AOP的xml配置以及如何实现了，如果想要了解AOP中的基础知识，可以去看我的另一篇博客AOP的概念 AOP的实现 业务层需要实现的接口 public interface IAccountService { void saveAccount(); void updateAccount(int i); int deleteAccount(); } 业务层方法 public class AccountServiceImpl implements IAccountS
Spring AOP(面向切面编程)
public_c_lass的博客
02-15 776
1.Spring 的 AOP 简介 1.1 什么是 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻...
Spring中的AOP
qq_43430343的博客
07-21 891
Spring中的AOP 1、AOP相关术语 Joinpoint(连接点): 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。 （业务层接口中所有的方法） Pointcut(切入点): 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。 （被增强的方法） 所有的切入点都是连接点 Advice(通知/增强): 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。 通知的类型：前置通知,后置通知,异常通知,最终通知,环
Spring AOP简单的标签配置和xml配置
uncofish的博客
02-12 517
  标签: import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; @Aspect //what 切面类 @Com...
Spring Aop
muzililee的博客
08-22 274
1.Spring 的 AOP 简介 1.1 什么是 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 1.2 AOP 的作用及其优势 作用：在程
Spring 事务传播特性和隔离级别
古月的博客
02-28 673
Spring 事务传播特性和隔离级别 事务是处理逻辑原子性的保证，作为单个逻辑单元执行一系列操作，要么执行完成要么全部不执行。事务遵循ACID四个特性。 事务的两个重要特性是，事务的传播特性和事务的隔离级别特性。传播级别决定了事务的控制范围，事务隔离级别决定了事务在数据库读写方面的控制范围。 原子性：事务作为一个原子整体，要么执行要么完全不执行 一致性：事务保证数据库状态从一个一致性变为另一...
Spring之AOP在XML中的配置方法
weixin_30604651的博客
07-19 196
AOP 即 Aspect Oriental Program 面向切面编程 先来一个栗子： <aop:config> <aop:pointcut id="loggerCutpoint" expression= "execution(* com.how2java.service.ProductSe...
AOP____Spring Bean及注解配置切面(aop)
a1694375032的博客
08-14 549
一、配置文件配置 <?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="ht...
spring-aop maven
最新发布
12-21
Spring AOP是Spring框架中的一个模块，用于实现面向切面编程（AOP）。在Maven中，你可以通过添加以下Maven坐标来引入Spring AOP依赖： ```xml <groupId>org.springframework <artifactId>spring-aop <version>...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值