Spring AOP 注解指南

最新推荐文章于 2024-06-21 12:12:54 发布
最新推荐文章于 2024-06-21 12:12:54 发布
阅读量1k 收藏 20
点赞数 22
分类专栏： java 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49376454/article/details/139730463
版权

Spring高手之路19——Spring AOP注解指南

1. 背景

  在现代软件开发中，面向切面编程（AOP）是一种强大的编程范式，允许开发者跨越应用程序的多个部分定义横切关注点（如日志记录、事务管理等）。本文将介绍如何在Spring框架中通过AspectJ注解以及对应的XML配置来实现AOP，在不改变主业务逻辑的情况下增强应用程序的功能。

2. 基于 AspectJ 注解来实现 AOP

对于一个使用Maven的Spring项目，需要在pom.xml中添加以下依赖：

<dependencies>    <dependency>        <groupId>org.springframework</groupId>        <artifactId>spring-context</artifactId>        <version>5.3.10</version>    </dependency>    <dependency>        <groupId>org.aspectj</groupId>        <artifactId>aspectjrt</artifactId>        <version>1.9.6</version>    </dependency>    <dependency>        <groupId>org.aspectj</groupId>        <artifactId>aspectjweaver</artifactId>        <version>1.9.6</version>    </dependency></dependencies>

复制代码

确保版本号与使用的Spring版本相匹配，可以自行调整。

  1. 创建业务逻辑接口 MyService：

package com.example.demo.aop;

public interface MyService {    void performAction();}

复制代码

  1. 创建业务逻辑类 MyServiceImpl.java：

package com.example.demo.aop;
import org.springframework.stereotype.Service;
@Servicepublic class MyServiceImpl implements MyService {    @Override    public void performAction() {        System.out.println("Performing an action in MyService");    }}

复制代码

  1. 定义切面

创建切面类MyAspect.java，并使用注解定义切面和通知：

package com.example.demo.aop;
import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.springframework.stereotype.Component;
@Aspect@Componentpublic class MyAspect {
    @Before("execution(* com.example.demo.aop.MyServiceImpl.performAction(..))")    public void logBeforeAction() {        System.out.println("Before performing action");    }}

复制代码

  @Aspect注解是用来标识一个类作为AspectJ切面的一种方式，这在基于注解的AOP配置中是必需的。它相当于XML配置中定义切面的方式，但使用注解可以更加直观和便捷地在类级别上声明切面，而无需繁琐的XML配置。

  1. 配置 Spring 以启用注解和 AOP

  创建一个Java配置类来代替XML配置，使用@Configuration注解标记为配置类，并通过@ComponentScan注解来启用组件扫描，通过@EnableAspectJAutoProxy启用AspectJ自动代理：

package com.example.demo.config;
import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration@ComponentScan("com.example")@EnableAspectJAutoProxypublic class AppConfig {}

复制代码

  @EnableAspectJAutoProxy注解在Spring中用于启用对AspectJ风格的切面的支持。它告诉Spring框架去寻找带有@Aspect注解的类，并将它们注册为Spring应用上下文中的切面，以便在运行时通过代理方式应用这些切面定义的通知（Advice）和切点（Pointcuts）。

  如果不写@EnableAspectJAutoProxy，Spring将不会自动处理@Aspect注解定义的切面，则定义的那些前置通知（@Before）、后置通知（@After、@AfterReturning、@AfterThrowing）和环绕通知（@Around）将不会被自动应用到目标方法上。这意味着定义的AOP逻辑不会被执行，失去了AOP带来的功能增强。

  @Before 注解定义了一个前置通知（Advice），它会在指定方法执行之前运行。切点表达式execution(* com.example.demo.aop.MyServiceImpl.performAction(..))精确地定义了这些连接点的位置。在这个例子中，切点表达式指定了MyServiceImpl类中的performAction方法作为连接点，而@Before注解标识的方法（logBeforeAction）将在这个连接点之前执行，即logBeforeAction方法（前置通知）会在performAction执行之前被执行。

  1. 创建主类和测试 AOP 功能

主程序如下：

package com.example.demo;
import com.example.demo.aop.MyService;import com.example.demo.config.AppConfig;import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {    public static void main(String[] args) {        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);        MyService service = context.getBean(MyService.class);        service.performAction();    }}

复制代码

运行结果如下：

3. XML 实现和注解实现 AOP 的代码对比

  对于上面的代码，我们将原有基于注解的AOP配置改写为完全基于XML的形式，方便大家对比。首先需要移除切面类和业务逻辑类上的所有Spring相关注解，然后在XML文件中配置相应的bean和AOP逻辑。

移除注解首先，我们移除业务逻辑类和切面类上的所有注解。

MyService.java (无变化，接口保持原样):

package com.example.demo.aop;
public interface MyService {    void performAction();}

复制代码

MyServiceImpl.java (移除 @Service 注解):

package com.example.demo.aop;
public class MyServiceImpl implements MyService {    @Override    public void performAction() {        System.out.println("Performing an action in MyService");    }}

复制代码

MyAspect.java (移除 @Aspect 和 @Component 注解，同时去掉方法上的 @Before 注解):

package com.example.demo.aop;
public class MyAspect {    public void logBeforeAction() {        System.out.println("Before performing action");    }}

复制代码

XML 配置

接下来，删除AppConfig配置类，在Spring的XML配置文件中定义beans和AOP配置。

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                           http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 定义业务逻辑bean -->    <bean id="myService" class="com.example.demo.aop.MyServiceImpl"/>
    <!-- 定义切面 -->    <bean id="myAspect" class="com.example.demo.aop.MyAspect"/>
    <!-- AOP配置 -->    <aop:config>        <aop:aspect id="aspect" ref="myAspect">            <aop:pointcut id="serviceOperation" expression="execution(* com.example.demo.aop.MyService.performAction(..))"/>            <aop:before pointcut-ref="serviceOperation" method="logBeforeAction"/>        </aop:aspect>    </aop:config></beans>

复制代码

  在这个XML配置中，我们手动注册了MyServiceImpl和MyAspect作为beans，并通过<aop:config>元素定义了AOP逻辑。我们创建了一个切点serviceOperation，用于匹配MyService.performAction(..)方法的执行，并定义了一个前置通知，当匹配的方法被调用时，MyAspect的logBeforeAction方法将被执行。

主类和测试 AOP 功能

主类DemoApplication的代码不需要改变，只是在创建ApplicationContext时使用XML配置文件而不是Java配置类：

package com.example.demo;
import com.example.demo.aop.MyService;import org.springframework.context.support.ClassPathXmlApplicationContext;
public class DemoApplication {    public static void main(String[] args) {        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");        MyService service = context.getBean(MyService.class);        service.performAction();    }}

复制代码

运行结果是一样的

4. AOP 通知讲解

  在Spring AOP中，通知（Advice）定义了切面（Aspect）在目标方法调用过程中的具体行为。Spring AOP支持五种类型的通知，它们分别是：前置通知（Before）、后置通知（After）、返回通知（After Returning）、异常通知（After Throwing）和环绕通知（Around）。通过使用这些通知，开发者可以在目标方法的不同执行点插入自定义的逻辑。

  • @Before（前置通知）

前置通知是在目标方法执行之前执行的通知，通常用于执行一些预处理任务，如日志记录、安全检查等。

@Before("execution(* com.example.demo.aop.MyServiceImpl.performAction(..))")public void logBeforeAction() {    System.out.println("Before performing action");}

复制代码

  • @AfterReturning（返回通知）

返回通知在目标方法成功执行之后执行，可以访问方法的返回值。

@AfterReturning(pointcut = "execution(* com.example.demo.aop.MyServiceImpl.performAction(..))", returning = "result")public void logAfterReturning(Object result) {    System.out.println("Method returned value is : " + result);}

复制代码

  这里在@AfterReturning注解中指定returning = "result"时，Spring AOP框架将目标方法的返回值传递给切面方法的名为result的参数，因此，切面方法需要有一个与之匹配的参数，类型兼容目标方法的返回类型。如果两者不匹配，Spring在启动时会抛出异常，因为它无法将返回值绑定到切面方法的参数。

  • @AfterThrowing（异常通知）

异常通知在目标方法抛出异常时执行，允许访问抛出的异常。

@AfterThrowing(pointcut = "execution(* com.example.demo.aop.MyServiceImpl.performAction(..))", throwing = "ex")public void logAfterThrowing(JoinPoint joinPoint, Throwable ex) {    String methodName = joinPoint.getSignature().getName();    System.out.println("@AfterThrowing: Exception in method: " + methodName + "; Exception: " + ex.toString());}

复制代码

  在@AfterThrowing注解的方法中包含JoinPoint参数是可选的，当想知道哪个连接点（即方法）引发了异常的详细信息时非常有用，假设有多个方法可能抛出相同类型的异常，而我们想在日志中明确指出是哪个方法引发了异常。通过访问JoinPoint提供的信息，可以记录下引发异常的方法名称和其他上下文信息，从而使得日志更加清晰和有用。

  • @After（后置通知）

后置通知在目标方法执行之后执行，无论方法执行是否成功，即便发生异常，仍然会执行。它类似于finally块。

@After("execution(* com.example.demo.aop.MyServiceImpl.performAction(..))")public void logAfter() {    System.out.println("After performing action");}

复制代码

  • @Around（环绕通知）

环绕通知围绕目标方法执行，可以在方法调用前后执行自定义逻辑，同时决定是否继续执行目标方法。环绕通知提供了最大的灵活性和控制力。

@Around("execution(* com.example.demo.aop.MyServiceImpl.performAction(..))")public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {    System.out.println("Before method execution");    Object result = joinPoint.proceed(); // 继续执行目标方法    System.out.println("After method execution");    return result;}

复制代码

接下来，我们来演示一下，全部代码如下：

服务接口（MyService.java）:

package com.example.demo.aop;
public interface MyService {    String performAction(String input);}

复制代码

服务实现（MyServiceImpl.java）:

修改performAction方法，使其在接收到特定输入时抛出异常

package com.example.demo.aop;
import org.springframework.stereotype.Service;
@Servicepublic class MyServiceImpl implements MyService {    @Override    public String performAction(String input) {        System.out.println("Performing action with: " + input);        if ("error".equals(input)) {            throw new RuntimeException("Simulated error");        }        return "Processed " + input;    }}

复制代码

完整的切面类（包含所有通知类型）

切面类（MyAspect.java） - 保持不变，确保包含所有类型的通知：

package com.example.demo.aop;
import org.aspectj.lang.JoinPoint;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.*;import org.springframework.stereotype.Component;
@Aspect@Componentpublic class MyAspect {
    @Before("execution(* com.example.demo.aop.MyService.performAction(..))")    public void beforeAdvice(JoinPoint joinPoint) {        System.out.println("@Before: Before calling performAction");    }
    @After("execution(* com.example.demo.aop.MyService.performAction(..))")    public void afterAdvice(JoinPoint joinPoint) {        System.out.println("@After: After calling performAction");    }
    @AfterReturning(pointcut = "execution(* com.example.demo.aop.MyService.performAction(..))", returning = "result")    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {        System.out.println("@AfterReturning: Method returned value is : " + result);    }
    @AfterThrowing(pointcut = "execution(* com.example.demo.aop.MyService.performAction(..))", throwing = "ex")    public void afterThrowingAdvice(JoinPoint joinPoint, Throwable ex) {        String methodName = joinPoint.getSignature().getName();        System.out.println("@AfterThrowing: Exception in method: " + methodName + "; Exception: " + ex.toString());    }
    @Around("execution(* com.example.demo.aop.MyService.performAction(..))")    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {        System.out.println("@Around: Before method execution");        Object result = null;        try {            result = proceedingJoinPoint.proceed();        } catch (Throwable throwable) {          // 如果执行方法出现异常，打印这里            System.out.println("@Around: Exception in method execution");            throw throwable;        }        // 如果执行方法正常，打印这里        System.out.println("@Around: After method execution");        return result;    }}

复制代码

这里要强调几点：

  1. @Around环绕通知常见用例是异常捕获和重新抛出。在这个例子中，我们通过ProceedingJoinPoint的proceed()方法调用目标方法。如果目标方法执行成功，记录执行后的消息并返回结果。如果在执行过程中发生异常，在控制台上打印出异常信息，然后重新抛出这个异常。这样做可以确保异常不会被吞没，而是可以被上层调用者捕获或由其他异常通知处理。

  2. @AfterThrowing注解标明这个通知只有在目标方法因为异常而终止时才会执行。throwing属性指定了绑定到通知方法参数上的异常对象的名称。这样当异常发生时，异常对象会被传递到afterThrowingAdvice方法中，方法中可以对异常进行记录或处理。

  3. @AfterThrowing和@AfterReturning通知不会在同一个方法调用中同时执行。这两个通知的触发条件是互斥的。@AfterReturning 通知只有在目标方法成功执行并正常返回后才会被触发，这个通知可以访问方法的返回值。@AfterThrowing 通知只有在目标方法抛出异常时才会被触发，这个通知可以访问抛出的异常对象。

  4. 假设想要某个逻辑总是在方法返回时执行，不管是抛出异常还是正常返回，则考虑放在@After或者@Around通知里执行。

配置类

package com.example.demo.config;
import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration@ComponentScan("com.example")@EnableAspectJAutoProxypublic class AppConfig {}

复制代码

测试不同情况

为了测试所有通知类型的触发，在主类中执行performAction方法两次：一次传入正常参数，一次传入会导致异常的参数。

主程序如下：

package com.example.demo;
import com.example.demo.aop.MyService;import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {    public static void main(String[] args) {        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);        MyService service = context.getBean(MyService.class);
        try {            // 正常情况            System.out.println("Calling performAction with 'test'");            service.performAction("test");
            // 异常情况            System.out.println("\nCalling performAction with 'error'");            service.performAction("error");        } catch (Exception e) {            System.out.println("Exception caught in DemoApplication: " + e.getMessage());        }    }}

复制代码

在这个例子中，当performAction方法被第二次调用并传入"error"作为参数时，将会抛出异常，从而触发@AfterThrowing通知。

运行结果如下：

5. AOP 时序图

  这里展示在Spring AOP框架中一个方法调用的典型处理流程，包括不同类型的通知（Advice）的执行时机。

  1. 客户端调用方法：

  • 客户端（Client）发起对某个方法的调用。这个调用首先被AOP代理（AOP Proxy）接收，这是因为在Spring AOP中，代理负责在真实对象（Target）和外界之间进行中介。

  1. 环绕通知开始 (@Around)：

  • AOP代理首先调用切面（Aspect）中定义的环绕通知的开始部分。环绕通知可以在方法执行前后执行代码，并且能决定是否继续执行方法或直接返回自定义结果。这里的“开始部分”通常包括方法执行前的逻辑。

  1. 前置通知 (@Before)：

  • 在目标方法执行之前，执行前置通知。这用于在方法执行前执行如日志记录、安全检查等操作。

  1. 执行目标方法：

  • 如果环绕通知和前置通知没有中断执行流程，代理会调用目标对象（Target）的实际方法。

  1. 方法完成：

  • 方法执行完成后，控制权返回到AOP代理。这里的“完成”可以是成功结束，也可以是抛出异常。

  1. 返回通知或异常通知：

  • 返回通知 (@AfterReturning)：如果方法成功完成，即没有抛出异常，执行返回通知。这可以用来处理方法的返回值或进行某些后续操作。

  • 异常通知 (@AfterThrowing)：如果方法执行过程中抛出异常，执行异常通知。这通常用于异常记录或进行异常处理。

  1. 后置通知 (@After)：

  • 独立于方法执行结果，后置通知总是会执行。这类似于在编程中的finally块，常用于资源清理。

  1. 环绕通知结束 (@Around)：

  • 在所有其他通知执行完毕后，环绕通知的结束部分被执行。这可以用于执行清理工作，或者在方法执行后修改返回值。

  1. 返回结果：

  • 最终，AOP代理将处理的结果返回给客户端。这个结果可能是方法的返回值，或者通过环绕通知修改后的值，或者是异常通知中处理的结果。

  • ```python
class BertPooler(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
        self.activation = nn.Tanh()

    def forward(self, hidden_states):
        # We "pool" the model by simply taking the hidden state corresponding
        # to the first token.
        first_token_tensor = hidden_states[:, 0]
        pooled_output = self.dense(first_token_tensor)
        pooled_output = self.activation(pooled_output)
        return pooled_output
from transformers.models.bert.configuration_bert import *
import torch
config = BertConfig.from_pretrained("bert-base-uncased")
bert_pooler = BertPooler(config=config)
print("input to bert pooler size: {}".format(config.hidden_size))
batch_size = 1
seq_len = 2
hidden_size = 768
x = torch.rand(batch_size, seq_len, hidden_size)
y = bert_pooler(x)
print(y.size())
```

Yuki-^_^
关注
  • 22
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring高手之路19——Spring AOP注解指南
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
06-02 1万+
在本文中，我们将深入探索Spring AOP（面向切面编程）的核心概念及其在现代Spring应用中的实际应用。从基本的注解使用到复杂的切面配置，本文将一步步指导你如何利用Spring AOP提升代码的模块化，帮助你在Spring开发路上更进一步。
java spring aop实例_Spring AOP+AspectJ注解实例
weixin_39669761的博客
02-24 110
常见AspectJ的注解：@Before–方法执行前运行@After–运行在方法返回结果后@AfterReturning–运行在方法返回一个结果后，在拦截器返回结果。@AfterThrowing–运行方法在抛出异常后，@Around–围绕方法执行运行，结合以上这三个通知。注意SpringAOP 中没有 AspectJ 支持，请阅读内置 SpringAOP 例子。1. 目录...
Spring AOP官网学习
qq_28849581的博客
10-07 862
Spring AOP官网学习 5.1 AOP概念 让我们从定义一些核心的AOP概念和术语开始。这些术语并不是spring特有的。不幸的是，AOP术语不是特别直观。 1.Aspect(方面):跨多个类的关注点的模块化。事务管理是企业级Java应用程序中横切关注点的一个很好的例子。在Spring AOP中，方面是通过使用常规类(基于模式的方法)或使用@Aspect注释的常规类(@AspectJ风格)来实现的。 2.(Join point)连接点:程序执行期间的一个点，例如方法执行或异常处理期间的一个点。在Spr
Spring 闯关指南：AOP
我与风来
02-27 339
简单地说了下 aop，也希望你能有所收获。
Spring 开发指南
03-11
**Spring 开发指南** Spring Framework 是一个开源的Java平台，它为构建企业级应用程序提供了全面的基础设施。由Rod Johnson创建并首次在《Expert One-on-One J2EE Design and Development》一书中提出，Spring的...
spring开发指南
06-10
在学习 Spring 开发指南时，会逐步了解如何配置 Spring 容器、声明 Bean、使用注解进行 DI、实现 AOP 切面、集成数据库、构建 MVC 应用，以及利用其他 Spring 模块进行复杂系统的构建。文档还可能包含实际项目中的...
Spring、Spring Boot和TestNG测试指南1
08-04
【Spring、Spring Boot和TestNG测试指南1】 本指南旨在帮助开发者更好地理解和使用Spring、Spring Boot框架中的TestNG测试工具。TestNG是一个功能强大的测试框架，它提供了比JUnit更多的功能，如并行测试、测试配置...
SPRING 开发指南
08-28
从Spring 2.5开始，Spring引入了注解驱动的配置，允许开发者在类或方法级别使用注解来声明Bean及其依赖。例如，`@Component`、`@Service`、`@Repository`和`@Controller`用于标记组件，`@Autowired`用于自动装配...
corespring5certificationindetail.pdf
08-29
《核心Spring 5认证详解》 本书由Ivan Krizsan撰写，专注于Spring框架的核心5.0认证。...总体来说，《核心Spring 5认证详解》是一本实用的备考指南，为准备Spring认证的开发者提供了有针对性的学习路径和实践指导。
基于springboot的美食推荐商城源码数据库
s123456sj的博客
06-15 1003
此美食推荐商城利用当下成熟完善的SSM框架，使用跨平台的可开发大型商业网站的Java语言，以及最受欢迎的RDBMS应用软件之一的Mysql数据库进行程序开发。实现了用户在线选择试题并完成答题，在线查看考核分数。管理员管理购物车管理、字典管理、公告信息管理、留言板管理、美食管理、美食收藏管理、美食评价管理、美食订单管理、商家管理、用户管理、管理员管理等功能。
Spring 循环依赖详解
Java领域优秀创作者
06-15 937
在Spring框架中，依赖注入（Dependency Injection, DI）是其核心功能之一，它通过配置来管理对象的创建和它们之间的依赖关系。然而，在复杂的应用程序中，开发人员有时会遇到循环依赖的问题，即Bean A依赖于Bean B，而Bean B又依赖于Bean A。如果不加以处理，这种情况会导致应用程序无法启动。在本文中，我们将深入探讨Spring循环依赖的原理、处理机制、最佳实践以及可能遇到的问题。
springboot“漫画之家”系统 LW+PPT+源码
u014445459的博客
06-17 854
链接：https://pan.baidu.com/s/1ihILTui-XEFdC15mcOB0vA?pwd=ewry提取码：ewry由于本系统是作为毕业设计系统，且系统本身存在一些技术层面的缺陷，并不能直接用于商业用途，只想要通过该系统的开发提高自身学术水平，不需要特定服务器等额外花费。所有创造及工作过程仅需在个人电脑上就能实现，使用到的软件大多为开源软件，所以经济成本并不高，可以轻易实现。
【SpringBoot】SpringBoot：实现文件上传和下载功能
Easonmax的博客
06-15 846
在现代应用中，用户需要上传各种类型的文件，如图片、文档、视频等，或者下载生成的报告和数据文件。SpringBoot通过其强大的生态系统和简化的配置，能够高效地实现文件上传和下载功能。在完成文件上传和下载功能的开发后，应该进行充分的测试，确保所有功能都能正常工作。通过这种方式，可以确保应用的各个部分在开发过程中得到充分的测试，减少上线后的问题。通过本文的介绍，我们了解了如何使用SpringBoot实现文件上传和下载。为了方便管理上传的文件，我们需要在项目中配置文件存储的位置。这将文件上传目录设置为。
SpringCloud Alibaba Sentinel基础入门与安装
小小默：进无止境
06-19 269
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件，主要以流量为切入点，从流量路由、流量控制、流量整形、熔断降级、系统自适应过载保护、热点流量防护等多个维度来帮助开发者保障微服务的稳定性。
JAVA学习笔记DAY6——SSM_Spring
weixin_47227105的博客
06-13 736
Spring Ioc容器是复杂容器。一个项目project拆分成多个模块module。配置方式包括三种：xml、注解、配置类。从文件结构的角度看，框架=jar包+是SSM的一种简化，快速创建服务。用来维护不同服务的相互调用。控制层组件 Servlet。业务逻辑层 Service。持久化层组件 Dao。
Springboot拓展之整合邮件 JavaMail的使用与实操
最新发布
牛马程序员的博客
06-21 916
这个依赖使我们去springboot的。这里面写了规范 很多依赖的坐标 可以直接导入 而不会出现版本冲突的问题 第二步做配置 我们要去邮箱客户端进行配置
SpelExpressionParser评估SpEL(Spring Expression Language)表达式的解析器
weixin_45822542的博客
06-19 353
是Spring中用于解析和评估SpEL(Spring Expression Language)表达式的解析器,SpEL是一种强大且灵活的表达式语言,广泛用于Spring框架中,以便在运行时解析和评估表达式。合理使用 SpEL 能够极大地增强应用程序的灵活性和动态性。:支持对集合和数组的操作,如过滤,投影,索引等;:提供了一些内置函数,如字符串操作,日期操作等;可以解析复杂的表达式,并在运行时对其进行评估;:可以通过表达式访问对象的属性和方法;:支持常见的数学,逻辑和关系运算符;:可以在表达式中调用方法;
springBoot多数据源使用、配置
qx020814的博客
06-12 464
又参加了一个新的项目，虽然是去年做的项目，拿来复用改造，但是也学到了很多。这个项目会用到其他项目的数据，如果调用他们的接口取数据，我还是觉得太麻烦了。打算直接配置多数据源。使用@DS("数据源名称") ，就能指定使用某一个数据源。就是配置两个数据库信息，后续使用@DS("数据源名称")配置了druid之后，项目运行起来就能访问,然后去另一个数据库系统中取出数据。,可以看见有两个数据源可以使用。所以就去了解和学习了一下。
springaop注解
07-27
Spring AOP注解是一种使用注解方式实现AOP的方法。在Spring框架中，可以使用注解来定义切面、切入点和通知等元素，从而实现对目标方法的增强处理。常用的注解包括： 1. @Aspect: 用于定义切面类，通常是一个带有切入点和通知的类。 2. @Pointcut: 用于定义切入点，可以通过表达式指定要拦截的方法。 3. @Before: 在目标方法执行之前执行的通知。 4. @After: 在目标方法执行之后执行的通知。 5. @AfterReturning: 在目标方法返回结果后执行的通知。 6. @AfterThrowing: 在目标方法抛出异常后执行的通知。 7. @Around: 在目标方法执行前后都执行的通知。 Spring AOP注解可以通过配置文件或者使用@ComponentScan注解来启用。在使用注解方式实现AOP时，可以更加简洁和灵活地定义切面和通知，提高了代码的可读性和可维护性。 #### 引用[.reference_title] - *1* [spring注解:spring aop注解详解](https://blog.csdn.net/weixin_37862824/article/details/122397507)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值