【Spring框架四】——Spring AOP 注解实现和xml方式实现1

简介: 【Spring框架四】——Spring AOP 注解实现和xml方式实现

系列文章目录

【Spring框架一】——Spring框架简介

【Spring框架二】——什么是Spring IOC、 什么是Spring 依赖注入

【Spring框架三】——Spirng IOC和DI的实现

Spring AOP 注解实现和xml方式实现

前言

Spring AOP是Spring框架中的核心内容之一,本篇博客主要讲解的是如何使用Spring Aop通过本篇博客能够对什么是Spring AOP以及如何将Spring AOP运行到具体业务有一个清晰的步骤。本篇博客主要从两个维度实现Spring AOP 一个是使用纯xml文件方式,另一个是使用纯注解的方式实现。


一、什么是Spring AOP(Aspect-Oriented Programming)

Spring AOP是面向切面编程的技术,能够对程序进行横切关注点的处理,例如日志记录、安全控制、性能统计、事物处理等。

通过AOP一方面可以将一些与业务无关、但是对业务产生重要影响的公共行为(例如事物管理、日志记录等)从业务逻辑中分离出来,这样可以使程序的模块化程度更高、同时也便于维护和扩展。


Spring AOP通过运行时的动态代理的方式,在不修改原有代码的情况下,将切面逻辑织入到目标对象中,从而实现对目标对象的增强。主要依赖与代理模式和反射机制。


备注:如果想要了解什么是代理,可以访问博主的另外两篇博客


设计模式——代理模式


Java JDK动态代理


什么是横切关注点

corss-cutting concern:指的是一个系统中存在的、多个模块都会用到的,与核心业务逻辑无关的公共关注点。例如:日志记录、性能统计、安全控制。

在传统的面向对象编程中,这些横切关注点都会分散到各个模块中,导致代码复杂、难以维护。

而AOP的目的是将这些横切关注点从核心业务逻辑中分离出来,从而使系统更易于维护和扩展。


二、Spring AOP中的基本概念

结合具体业务的示意图:addUser为原有的具体业务的实现,现在需要在其之前之后等使用Spring AOP切入一个与原有业务无关的校验安全性。

我们通过这个业务来理解Spring AOP的概念

2b44f68e8ab3470b94782ead9b2bf773.png


Cross Cutting Concern

横切性关注点:它是一种独立服务,在我们这个例子中它是检查安全性。它会遍布在系统的处理流程之中。


Aspect

切面: 对横切性关注点的模块化,图中为SecurityHandler


Advice

通知:对横切性关注点的具体实现,常见的通知类型有(Before、After、AfterReturning、AfterThrowing、Around)


Pointcut

切点:它定义了Advice应用到那些JoinPoint上,对Spring来说是方法调用

Spring只支持方法的JoinPoint,但是对于AspectJ这个点也可以是属性修改,如。


Joinpoint

连接点:在程序执行过程中某个特定的点,比如某方法调用的时候或者处理异常的时候。 在Spring AOP中,一个连接点 总是 代表一个方法的执行。 通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知(Advice)的主体部分获得连接点信息。


Weave

织入:将Advice应用到TargetObject上的过程叫织入,Spring支持的是动态织入


TargetObject

目标对象:目标对象是被一个或多个切面所通知的对象。


Proxy

代理:AOP代理是在目标对应和切面之间进行通信的对象;Spring AOP默认使用JDK的动态代理,它的代理是运行时创建,也可以使用CGLIB代理


Introduction

引入:引入允许将新的接口和实现引入到现有的类中,从而为类添加额外的行为。


这些核心概念共同构成了Spring AOP的基础,通过它们可以实现对横切关注点的管理和控制,从而提供横切关注点的复用和模块化。


三、使用xml文件的方式实现Spring AOP

原spring项目的代码结构


c0b64737b2244d71b12b0b618135d75d.png

pom.xml

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.8</version>
        </dependency>
    <!--spring aop -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
    </dependencies>

UserManager类

package com.wangwei.springaop.service;
public interface UserManager {
   public void addUser(String username, String password);
   public void delUser(int userId);
   public int findUserById(int userId);
   public void modifyUser(int userId, String username, String password);
}

UserManagerImpl

package com.wangwei.springaop.service.impl;
import com.wangwei.springaop.service.UserManager;
public class UserManagerImpl implements UserManager {
   public void addUser(String username, String password) {
      System.out.println("---------UserManagerImpl.add()--------");
   }
   public void delUser(int userId) {
      System.out.println("---------UserManagerImpl.delUser()--------");
   }
   public int findUserById(int userId) {
      System.out.println("---------UserManagerImpl.findUserById()--------");
      return userId;
   }
   public void modifyUser(int userId, String username, String password) {
      System.out.println("---------UserManagerImpl.modifyUser()--------");
   }
}

Client类

package com.wangwei.springaop.client;
import com.wangwei.springaop.service.UserManager;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Client {
   public static void main(String[] args) {
       //读取xml配置文件,申明工厂
      BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
      //获取beanid为userManager的bean
      UserManager userManager = (UserManager)factory.getBean("userManager");
      userManager.addUser("wangwei", "123");
   }
}

applicationContext.xml


设置标签

<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.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
   <bean id="userManager" class="com.wangwei.springaop.service.impl.UserManagerImpl"/>
</beans>

当前运行的结果


a8d84bbb9cd540e2aefc9e264ae4d00b.png

xml方式实现Spring AOP

目前业务是需要在程序执行addUser()这个方法之前,通过Spring AOP技术切入一个检查安全性的服务。


我们的横切性关注点(Cross Cutting Concern)就是这个检查安全性的服务。

现在我们将这个横切性关注点进行模块化


创建SecurityHandler类,它就代表的是Aspect,是对横切性关注点的模块化。

package com.wangwei.springaop.service.impl;
public class SecurityHandler {
   private void checkSecurity() {
      System.out.println("-------checkSecurity-------");
   }
}

在XML配置文件中进行配置


<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 id="userManager" class="com.wangwei.springaop.service.impl.UserManagerImpl"/>
   <bean id ="securityHandlerAspect" class="com.wangwei.springaop.service.impl.SecurityHandler"/>
<!--   配置切面通知和切点-->
   <aop:config>
      <aop:aspect ref="securityHandlerAspect">
         <aop:before method="checkSecurity" pointcut="execution(* com.wangwei.springaop.service.impl.UserManagerImpl.addUser(..))"/>
      </aop:aspect>
   </aop:config>
</beans>

上面的通知(advice)配置的为Before,

切点它定义了Advice应用到那些JoinPoint上,这里是通过表达式execution定位到连接点(joinPoint)

joinPoin代表一个方法的执行,这里指的是addUser()这个方法的执行。


实现效果:


9c8c0034c98c42bda88d5f6ee5281064.png

补充关于Spring AOP 切入点的表达式

切入点表达式有两部分组成:签名和指示器


签名部分指定了要匹配的连接点的方法签名。

例如:"execution(public * com.example.service…(…))"表示匹配com.example.service包中的所有公共方法。

指示器部分用于进一步细化匹配的连接点。常见的指示器包括:


execution:匹配方法执行连接点。

within:匹配指定类型内的方法执行连接点。

args:匹配参数类型符合指定类型的方法执行连接点。

annotation:匹配带有指定注解的方法执行连接点。

以下是一些切入点表达式的示例:


1.execution(public * com.example.service…(…)):匹配com.example.service包中的所有公共方法。

2.within(com.example.service.*):匹配com.example.service包中所有方法。

3.execution(* com.example.service.UserService.addUser(…)):匹配com.example.service.UserService类的addUser方法。

args(String, *):匹配第一个参数为String类型的方法。

4.annotation(org.springframework.transaction.annotation.Transactional):匹配带有@Transactional注解的方法。

切入点表达式的语法非常灵活,可以根据需要进行组合和定制,以精确地选择要应用切面的连接点。


常用表达式示例

一般用的是execution执行表达式的格式如下:

execution(modifiers-pattern? return-type-pattern declaring-type-pattern? method-name-pattern(param-pattern) throws-pattern?)

其中,各个部分的含义如下:


1.modifiers-pattern(可选):用于匹配方法的修饰符,如

public、protected等。可以使用通配符*匹配任意修饰符。

2.return-type-pattern:用于匹配方法的返回类型,可以是具体的类型或通配符*表示任意类型。

3.declaring-type-pattern(可选):用于匹配方法所在的类的类型,可以是具体的类型或通配符*表示任意类型。

4.method-name-pattern:用于匹配方法的名称,可以是具体的方法名或使用通配符

*匹配任意方法名。

5.param-pattern:用于匹配方法的参数类型,可以是具体的类型、通配符表示任意类型、…表示任意个参数、()表示一个参数,以及(*, *)表示两个参数等。

6.throws-pattern(可选):用于匹配方法可能抛出的异常类型,可以是具体的异常类型或通配符*表示任意异常。

下面是一些示例:

execution(public * com.example.service..(…)):匹配com.example.service包中的所有公共方法。

execution(* com.example.service.UserService.addUser(String, )):匹配com.example.service.UserService类的addUser方法,第一个参数为String类型,第二个参数为任意类型。

execution( com.example.service..(…) throws java.io.IOException):匹配com.example.service包中所有方法,且可能抛出java.io.IOException异常。


目录
相关文章
|
4天前
|
XML Java 开发者
Spring Boot中的AOP实现
Spring AOP(面向切面编程)允许开发者在不修改原有业务逻辑的情况下增强功能,基于代理模式拦截和增强方法调用。Spring Boot通过集成Spring AOP和AspectJ简化了AOP的使用,只需添加依赖并定义切面类。关键概念包括切面、通知和切点。切面类使用`@Aspect`和`@Component`注解标注,通知定义切面行为,切点定义应用位置。Spring Boot自动检测并创建代理对象,支持JDK动态代理和CGLIB代理。通过源码分析可深入了解其实现细节,优化应用功能。
|
1月前
|
XML 安全 Java
|
4天前
|
开发框架 运维 监控
Spring Boot中的日志框架选择
在Spring Boot开发中,日志管理至关重要。常见的日志框架有Logback、Log4j2、Java Util Logging和Slf4j。选择合适的日志框架需考虑性能、灵活性、社区支持及集成配置。本文以Logback为例,演示了如何记录不同级别的日志消息,并强调合理配置日志框架对提升系统可靠性和开发效率的重要性。
|
26天前
|
设计模式 XML Java
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能,依赖注入功能
本文详细介绍了Spring框架的核心功能,并通过手写自定义Spring框架的方式,深入理解了Spring的IOC(控制反转)和DI(依赖注入)功能,并且学会实际运用设计模式到真实开发中。
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能,依赖注入功能
|
12天前
|
存储 安全 Java
Spring Boot 3 集成Spring AOP实现系统日志记录
本文介绍了如何在Spring Boot 3中集成Spring AOP实现系统日志记录功能。通过定义`SysLog`注解和配置相应的AOP切面,可以在方法执行前后自动记录日志信息,包括操作的开始时间、结束时间、请求参数、返回结果、异常信息等,并将这些信息保存到数据库中。此外,还使用了`ThreadLocal`变量来存储每个线程独立的日志数据,确保线程安全。文中还展示了项目实战中的部分代码片段,以及基于Spring Boot 3 + Vue 3构建的快速开发框架的简介与内置功能列表。此框架结合了当前主流技术栈,提供了用户管理、权限控制、接口文档自动生成等多项实用特性。
53 8
|
21天前
|
Java 开发者 Spring
理解和解决Spring框架中的事务自调用问题
事务自调用问题是由于 Spring AOP 代理机制引起的,当方法在同一个类内部自调用时,事务注解将失效。通过使用代理对象调用、将事务逻辑分离到不同类中或使用 AspectJ 模式,可以有效解决这一问题。理解和解决这一问题,对于保证 Spring 应用中的事务管理正确性至关重要。掌握这些技巧,可以提高开发效率和代码的健壮性。
66 13
|
1月前
|
IDE Java 测试技术
互联网应用主流框架整合之Spring Boot开发
通过本文的介绍,我们详细探讨了Spring Boot开发的核心概念和实践方法,包括项目结构、数据访问层、服务层、控制层、配置管理、单元测试以及部署与运行。Spring Boot通过简化配置和强大的生态系统,使得互联网应用的开发更加高效和可靠。希望本文能够帮助开发者快速掌握Spring Boot,并在实际项目中灵活应用。
53 5
|
1月前
|
缓存 Java 数据库连接
Spring框架中的事件机制:深入理解与实践
Spring框架是一个广泛使用的Java企业级应用框架,提供了依赖注入、面向切面编程(AOP)、事务管理、Web应用程序开发等一系列功能。在Spring框架中,事件机制是一种重要的通信方式,它允许不同组件之间进行松耦合的通信,提高了应用程序的可维护性和可扩展性。本文将深入探讨Spring框架中的事件机制,包括不同类型的事件、底层原理、应用实践以及优缺点。
71 8
|
4月前
Micronaut AOP与代理机制:实现应用功能增强,无需侵入式编程的秘诀
AOP(面向切面编程)能够帮助我们在不修改现有代码的前提下,为应用程序添加新的功能或行为。Micronaut框架中的AOP模块通过动态代理机制实现了这一目标。AOP将横切关注点(如日志记录、事务管理等)从业务逻辑中分离出来,提高模块化程度。在Micronaut中,带有特定注解的类会在启动时生成代理对象,在运行时拦截方法调用并执行额外逻辑。例如,可以通过创建切面类并在目标类上添加注解来记录方法调用信息,从而在不侵入原有代码的情况下增强应用功能,提高代码的可维护性和可扩展性。
96 1
|
2月前
|
安全 Java 编译器
什么是AOP面向切面编程?怎么简单理解?
本文介绍了面向切面编程(AOP)的基本概念和原理,解释了如何通过分离横切关注点(如日志、事务管理等)来增强代码的模块化和可维护性。AOP的核心概念包括切面、连接点、切入点、通知和织入。文章还提供了一个使用Spring AOP的简单示例,展示了如何定义和应用切面。
287 1
什么是AOP面向切面编程?怎么简单理解?