Spring的核心概念汇总

牧马人Eikko

于 2023-11-02 09:26:23 发布

阅读量195

点赞数 1

分类专栏： Java 文章标签： java spring 后端

本文链接：https://blog.csdn.net/shadowcw/article/details/134170230

版权

Java 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

Spring的核心概念

（一）什么是BeanDefinition

BeanDefinition是Spring框架中的一个概念，用于描述和定义在Spring容器中创建的bean。在Spring中，我们可以通过配置文件或者注解的方式定义BeanDefinition，它包含了一些关键信息，比如bean的类型、依赖关系、作用域等。

BeanDefinition定义了创建一个bean的相关信息，它是Spring容器实例化和管理bean的基础。通过配置BeanDefinition，我们可以定义一个bean的各种属性和行为，然后交由Spring容器来实例化和管理。

在Spring中，BeanDefinition通常由BeanFactory或ApplicationContext来加载和解析。一旦BeanDefinition被解析和加载到Spring容器中，Spring容器就可以根据BeanDefinition的定义来创建相应的bean实例，并按照定义的规则进行初始化、注入依赖、销毁等操作。总之，BeanDefinition是Spring框架中非常重要的一个概念，它提供了灵活而强大的机制来定义和管理bean。

以下是一些常见的BeanDefinition属性：

Bean的Class：指定要创建的bean的类型，可以是具体的类或接口。
Scope（作用域）：指定bean的作用域，例如singleton（单例）、prototype（原型）等。
Constructor arguments（构造函数参数）：指定用于创建bean实例的构造函数参数，可以是常量值、引用其他bean或表达式。
Property values（属性值）：指定bean实例的属性值，可以是常量值、引用其他bean或表达式。
Autowiring mode（自动装配模式）：指定使用自动装配的方式来解析bean的依赖关系。
Lazy initialization（延迟初始化）：指定是否延迟初始化bean，即在第一次使用时才进行实例化操作。
Depends-on（依赖关系）：指定bean之间的依赖关系，确保某个bean在其他bean之前被实例化。
Factory bean and factory method（工厂bean和工厂方法）：指定使用工厂bean和对应的工厂方法来创建bean实例。
Initialization and destruction callbacks（初始化和销毁回调）：指定在bean实例化和销毁时执行的回调方法。
Bean aliases（别名）：为bean指定多个别名，方便使用不同的名称来引用同一个bean。

这些属性可以通过XML配置文件、注解或者编程方式来定义和设置。BeanDefinition提供了丰富的选项和灵活的配置方式，以满足不同场景下的需求。

（二）什么是BeanFactory

Spring的BeanFactory是Spring框架中的一个核心接口，用于管理和获取Bean对象的实例。BeanFactory提供了一种创建、配置和管理Bean的机制，它是Spring IoC容器的基础。

BeanFactory的主要功能包括：

Bean的创建和管理：BeanFactory负责创建和管理Bean的生命周期。它根据配置信息创建Bean的实例，并在需要时进行初始化和销毁。
Bean的依赖注入：BeanFactory负责管理Bean之间的依赖关系。它可以自动将依赖的Bean注入到目标Bean中，实现松耦合的编程。
配置信息的加载和解析：BeanFactory可以加载外部配置文件，如XML配置文件，解析其中的Bean定义和相关的配置信息。它可以根据配置信息创建和配置Bean的实例。
Bean的作用域管理：BeanFactory提供了对Bean的作用域管理。它可以管理单例Bean和原型Bean等不同作用域的Bean实例。

Spring提供了多种实现了BeanFactory接口的容器，包括常用的ApplicationContext。这些容器在BeanFactory的基础上进行了功能扩展，提供了更多的特性和扩展点。

要使用BeanFactory，首先需要在Spring配置文件中定义Bean的配置信息，并通过ApplicationContext或其他实现类来加载配置文件并获取BeanFactory实例。然后可以使用BeanFactory的方法来获取和管理Bean的实例。

总结来说，Spring的BeanFactory是Spring IoC容器的核心接口，负责创建、管理和配置Bean的实例。它提供了丰富的功能和灵活性，可通过配置文件来定义Bean的配置信息，并通过依赖注入解决Bean之间的依赖关系。

（三）什么是Bean生命周期

在 Spring 框架中，Bean 的生命周期指的是在容器中创建、初始化、使用和销毁 Bean 实例的整个过程。Spring 容器负责管理 Bean 的生命周期，并在适当的时候调用相应的回调方法。

以下是 Bean 的典型生命周期：

实例化：Spring 容器根据配置文件或注解等方式实例化 Bean 对象。
属性赋值：容器将配置的属性值注入到 Bean 的属性中。
自定义初始化方法调用：如果 Bean 配置了自定义的初始化方法（通过

@PostConstruct 注解或实现 InitializingBean 接口），容器将在属性赋值完成后调用该方法。

4.使用 Bean：此时 Bean 对象已经可以被其他对象使用。

5.自定义销毁方法调用：当 Spring 容器关闭或者销毁 Bean 时，如果 Bean 配置了自定义的销毁方法（通过@PreDestroy 注解或实现 DisposableBean 接口），容器将在销毁之前调用该方法。

6.销毁：当 Bean 不再被使用时，Spring 容器销毁该 Bean，释放相关资源。

注意：Spring 容器负责管理 Bean 的生命周期，你可以通过配置文件或注解来定义初始化方法和销毁方法。同时，也可以通过实现相应的接口来定义自定义的初始化和销毁方法。

（四）@Autowired注解是什么？

在 Spring 框架中，@Autowired 是一个用于自动装配依赖关系的注解。它可以应用于构造函数、属性、方法或者参数上。

@Autowired 的工作原理如下：

扫描组件：Spring 容器会扫描被 @Autowired 注解标记的类，寻找需要进行依赖注入的地方。
解析依赖：当 Spring 容器找到需要进行依赖注入的地方时，它会查看被注入的类型，并尝试解析该类型的实例。
自动装配：Spring 容器会根据依赖的类型和名称，在容器中查找匹配的对象进行注入。它支持按类型和按名称进行自动装配。

按类型自动装配：如果容器中存在多个与依赖类型匹配的对象，Spring 会尝试根据类型选择最佳的候选对象进行注入。如果找不到合适的对象或者找到多个匹配的对象，会抛出异常。
按名称自动装配：可以通过在 @Autowired 注解中使用 @Qualifier 注解指定要注入的 bean 的名称，这样可以根据名称匹配进行装配。

4.完成依赖注入：一旦找到了匹配的依赖对象，Spring 就会将其注入到需要的地方（构造函数、属性、方法或者参数）。完成依赖注入后，被注入的对象就可以使用这些依赖了。

以下是使用 @Autowired 的示例：

@Component
public class MyService {

    private final MyRepository myRepository;

    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }

    // 使用 @Autowired 注解进行属性注入
    @Autowired
    private OtherService otherService;

    // 使用 @Autowired 注解进行方法注入
    @Autowired
    public void setDependency(Dependency dependency) {
        // ...
    }
    
    // 使用 @Autowired 注解进行参数注入
    public void doSomething(@Autowired AnotherDependency anotherDependency) {
        // ...
    }
}

在上述示例中，我们使用 @Autowired 注解对构造函数、属性、方法和参数进行注入。

通过标记构造函数，Spring 将会创建 MyService 类的实例的同时，自动解析并注入 MyRepository 类的实例。

通过在属性上标记 @Autowired，Spring 将会自动注入 OtherService 类的实例。

通过在方法上标记 @Autowired，Spring 将会调用该方法并传递 Dependency 类的实例。

通过在方法参数上标记 @Autowired，Spring 将会自动解析并注入 AnotherDependency 类的实例。

需要注意的是，使用 @Autowired 进行自动装配时，被注入的依赖对象需要在 Spring 容器中存在。可以通过 @Component 或其他相关注解将其标记为组件，使其成为 Spring 容器中的一个 bean。

（五）@Resource注解是什么？

@Resource 是一个用于依赖注入的注解，是 JavaX 规范中定义的注解之一。它主要用于在 Java EE 应用程序中进行组件之间的协作和依赖关系的管理。

@Resource 注解可以应用于字段、setter 方法和构造函数上。它的作用是告诉容器在运行时自动注入一个特定的资源或依赖项。

@Resource 注解可以根据名称或类型指定注入的对象。具体来说，它有两个属性可以使用：

name 属性：用于指定要注入的资源或依赖项的名称。如果没有显式指定名称，则默认按照字段或方法的名称进行匹配。
type 属性：用于指定要注入的资源或依赖项的类型。如果存在多个匹配的对象，则会根据类型进行匹配。

以下是使用 @Resource 注解的示例：

@Component
public class MyComponent {
    @Resource
    private MyDependency myDependency;
    
    @Resource(name = "otherDependency")
    private OtherDependency otherDependency;

    @Resource
    public void setAnotherDependency(AnotherDependency anotherDependency) {
        // ...
    }

    // ...
}

在上述示例中，我们使用了 @Resource 注解对字段、setter 方法进行了注入。通过默认的按名称装配，myDependency 和 otherDependency 分别注入了与之匹配的 bean 对象。setAnotherDependency() 方法则根据类型进行了注入。

工作原理：

@Resource 是一种用于依赖注入的注解，它可以在 Spring 中用于注入依赖对象。它的工作原理如下：

通过名称匹配：当 @Resource 注解被用于字段或setter方法时，默认情况下它使用名称匹配的方式来查找要注入的依赖对象。它首先会按照指定的名称（通过 name 属性）去查找对应的 bean 对象。如果找到了与指定名称匹配的 bean 对象，就将其注入到字段或调用相应的 setter 方法。如果按名称无法匹配到对象，那么 @Resource 注解会按照类型来进行匹配。它会尝试查找与字段或方法参数类型匹配的 bean 对象，并进行注入。
按类型匹配：如果 @Resource 注解未指定 name 属性，它将按照字段或方法的名称进行匹配。它首先会尝试按照字段名或方法名去查找对应的 bean 对象，如果找到了与字段或方法名匹配的 bean 对象，就将其注入到字段或调用相应的 setter 方法。
多个候选对象：如果name和type都没有指定，默认按照name匹配，如果匹配到则注入。没有则按照type去匹配，匹配到一个则装配。如果有多个类型匹配，但是名称不匹配则抛出异常。

（六）@Value注解是什么？

@Value 注解是 Spring 框架提供的一种用于属性注入的注解。它允许将值直接注入到字段、方法参数或构造函数参数中，而不需要通过 XML 或 Java 配置文件来配置。

使用 @Value 注解时，可以通过以下方式注入值：

直接注入常量值：可以使用字符串字面值、基本类型、包装类或字符串表达式等常量值进行注入。例如：
```
@Value("Hello, World!")
private String message;

@Value("42")
private int number;
```
注入属性值：可以通过 ${property.name} 的占位符语法来引用配置文件中的属性值。Spring 将会自动将属性值注入到相应的字段或方法参数中。例如：
```
@Value("${app.version}")
private String version;
```
其中，${app.version} 表示从配置文件中获取名为 app.version 的属性值，并将其注入到 version 字段中。
使用 SpEL 表达式：可以使用 Spring Expression Language（SpEL）表达式来计算属性值并进行注入。SpEL 表达式可以进行各种运算和逻辑操作，以及引用其他 bean 的属性。例如：
```
@Value("#{mathUtils.multiply(2, 3)}")
private int result;

@Value("#{user.name}")
private String userName;
```
在上述示例中，#{mathUtils.multiply(2, 3)} 表示调用名为 mathUtils 的 bean 的 multiply 方法来计算值并注入到 result 字段中，而 #{user.name} 表示引用名为 user 的 bean 的 name 属性。

需要注意的是，@Value 注解可以用于字段、方法参数和构造函数参数上，并且可以与 @Autowired 和 @Qualifier 等注解一起使用。

（七）FactoryBean是什么？

FactoryBean 是 Spring 框架提供的一个特殊接口，用于创建和管理对象的工厂。它允许我们自定义对象的创建逻辑，并将其交给 Spring 容器进行管理。

FactoryBean 接口需要实现两个方法：

getObject(): 该方法用于创建或返回由工厂管理的对象的实例。在该方法中，我们可以自定义创建对象的逻辑，并返回相应的对象实例。
getObjectType(): 该方法用于声明工厂所创建对象的类型。Spring 在进行依赖注入或自动装配时需要了解对象的类型，而该方法用于提供这个信息。

通过实现 FactoryBean 接口，我们可以在 Spring 容器中将工厂对象本身注册为一个 Bean，并在需要使用被工厂管理的对象的地方引用该工厂 Bean。当需要获取被工厂管理的对象时，Spring 会调用工厂的 getObject() 方法来获取对象的实例。

以下是一个简单示例，说明如何使用 FactoryBean 接口：

首先，创建一个实现 FactoryBean 接口的工厂类 MyFactoryBean，并在 getObject() 方法中定义创建对象的逻辑：

@Component
public class MyFactoryBean implements FactoryBean<MyObject> {

    @Override
    public MyObject getObject() throws Exception {
        // 创建并返回 MyObject 对象
        return new MyObject();
    }

    @Override
    public Class<?> getObjectType() {
        return MyObject.class;
    }
}

在需要使用被工厂管理的对象的地方，通过引用工厂 Bean 的方式获取对象实例：

@Autowired
private MyObject myObject;

通过上述配置和代码，Spring 将会自动调用 MyFactoryBean 的 getObject() 方法来创建 MyObject 对象，并将其注入到 myObject 字段中。

总结而言，FactoryBean 接口允许我们自定义对象的创建逻辑，并将对象交给 Spring 进行管理。它提供了一种灵活的方式来创建特殊类型的 Bean，并与 Spring 的 IoC（控制反转）和 DI（依赖注入）功能无缝结合。

（八）ApplicationContext是什么？

applicationContext 是 Spring 框架中的一个关键组件，它是整个 Spring 应用程序的上下文环境。它负责管理和协调 Spring Bean 的创建、配置和生命周期，以及提供其他高级功能，如依赖注入、切面编程等。

applicationContext 是 Spring 容器的一种具体实现，它是对 BeanFactory 的扩展。与原始的 BeanFactory 相比，applicationContext 提供了更多的企业级特性和高级功能。它是 Spring 应用程序的核心容器，可以通过 XML 配置文件、Java 注解或 Java 代码方式进行配置。

Spring 的 applicationContext 主要有以下几个作用：

Bean 的生命周期管理：

applicationContext 负责在应用程序中创建、初始化和销毁 Bean 实例。它能够自动检测 Bean 的依赖关系，并在需要时按照正确的顺序创建和销毁 Bean。

2.依赖注入（Dependency Injection）：

applicationContext 支持依赖注入，通过自动装配或显式配置，将依赖关系注入到 Bean 中，使得开发者无需手动管理 Bean 之间的依赖关系。

3.配置文件的解析和加载：

applicationContext 负责解析和加载配置文件（如 XML 文件），读取其中定义的 Bean 配置信息，并根据配置信息创建相应的 Bean。

4.AOP（面向切面编程）支持：

applicationContext 提供对 AOP 的支持，可以声明和配置切面、切点和通知，实现横切关注点的模块化开发。

5.事件驱动编程：

applicationContext 支持发布和监听事件。基于观察者模式，我们可以在应用程序中定义自定义事件，并通过 applicationContext 发布事件，其他相关的 Bean 可以通过监听器来处理这些事件。

6.国际化支持：

applicationContext 支持国际化，可以加载不同语言和区域的资源文件，实现国际化的功能。

applicationContext 可以通过不同的实现方式来创建和配置，包括 XML 配置、Java 注解以及基于 Java 代码的配置。无论使用哪种方式，applicationContext 都是 Spring 应用程序的核心组件，负责管理和协调各个 Bean 之间的关系和功能。

如何获得环境变量？

在 Spring 中，可以通过 ApplicationContext 来获取环境变量。ApplicationContext 接口继承了 EnvironmentCapable 接口，因此可以使用 getEnvironment() 方法来访问环境对象 Environment。

下面是通过 ApplicationContext 获取环境变量的代码示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {
    @Autowired
    private ApplicationContext applicationContext;
    
    public void printEnvironmentVariable(String variableName) {
        Environment environment = applicationContext.getEnvironment();
        String value = environment.getProperty(variableName);
        System.out.println("Environment variable " + variableName + ": " + value);
    }
}

在上述示例中，我们通过 getEnvironment() 方法获得了环境对象 Environment，然后使用 getProperty() 方法根据变量名获取相应的环境变量的值。

需要注意的是，为了使用 getEnvironment() 方法，需要将 ApplicationContext 注入到你的组件中。可以通过 @Autowired 注解或者其他方式进行注入。

另外，如果你只是想获取系统环境变量，你也可以直接使用 System.getenv("variableName") 方法来获取环境变量。

Event事件是什么？

在 Spring 框架中，事件（Event）是一种基于观察者模式的机制，用于实现模块之间的松耦合通信。Spring 的事件机制允许应用程序中的不同组件发布和监听事件，从而实现模块之间的消息传递和交互。

事件由事件源（Event Source）发起，可以是任何对象。当事件源发生特定的状态或动作时，它会创建并发布一个事件（Event）。事件包含了与事件发生相关的信息，可以是简单的消息或更复杂的数据结构。

其他组件可以通过订阅事件来监听事件的发生，并根据需要做出相应的响应。在 Spring 中，事件的订阅和监听是通过定义和注册事件监听器（Event Listener）来实现的。

使用 Spring 的事件机制，你可以将应用程序的不同组件解耦，实现模块之间的解耦通信。例如，当某个业务操作完成时，你可以发布一个相应的事件，而不需要直接调用其他组件的方法。其他组件只需要监听该事件，就能够得到通知并执行相应的逻辑。

以下是使用 Spring 事件机制的一般步骤：

定义事件：创建一个继承自 ApplicationEvent
声明事件发布者：在需要发布事件的类中注入 ApplicationEventPublisher
发布事件：在适当的时机，通过调用 ApplicationEventPublisher publishEvent()
定义事件监听器：创建一个实现 ApplicationListener
注册事件监听器：使用 @EventListener
监听事件：当事件被发布时，事件监听器会自动被触发，执行相应的业务逻辑。

通过以上步骤，你可以实现组件间的解耦通信，让应用程序的不同部分可以更灵活、可扩展地进行交互和响应。

总结而言，Spring 的事件机制是一种基于观察者模式的机制，通过发布-订阅模式实现组件间的解耦通信。通过定义事件、事件监听器以及发布和监听事件，你可以实现模块间的松耦合，并在特定情况下通知其他组件进行响应。

（九）依赖注入是什么？

依赖注入（Dependency Injection，简称 DI）是一种设计模式和编程技术，用于降低组件之间的耦合性。在依赖注入中，一个对象（被依赖的对象）的依赖关系由外部容器来定义和注入，而不是由对象自身来创建或查找依赖对象。

简单来说，依赖注入就是将一个对象所依赖的其他对象通过构造方法、属性或方法参数的方式传递进来，而不是对象自己创建或查找这些依赖对象。

举个例子来说明依赖注入的概念：

假设有一个 UserService 类依赖于 UserRepository 类来进行用户数据的访问和操作。传统的方式是在 UserService 类中直接创建一个 UserRepository 对象：

public class UserService {
    private UserRepository userRepository;

    public UserService() {
        // 直接在 UserService 中创建 UserRepository 对象
        this.userRepository = new UserRepository();
    }

    // 使用 userRepository 进行业务操作
    // ...
}

上述代码中，UserService 类直接在构造方法中创建了一个 UserRepository 对象。这样做会导致 UserService 类与 UserRepository 类高度耦合，难以进行单元测试和灵活地替换或扩展依赖对象。

而通过使用依赖注入，我们可以将 UserRepository 对象通过构造方法或属性注入到 UserService 中：

public class UserService {
    private UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        // 通过构造方法注入 UserRepository 对象
        this.userRepository = userRepository;
    }

    // 使用 userRepository 进行业务操作
    // ...
}

在上述代码中，通过构造方法将 UserRepository 对象作为参数传递进来。这样，UserService 不再负责创建 UserRepository 的实例，而是依赖于外部容器（如 Spring 容器）来提供所需要的依赖对象。

在使用框架（如 Spring）进行依赖注入时，我们可以通过配置文件、注解或代码方式来声明依赖关系，然后框架会自动将依赖对象注入到相应的类中。

依赖注入有助于实现松散耦合、模块化和可测试性。它使得组件间只关注自身的核心功能，而不需要关心依赖对象的创建和管理，从而提高了代码的可维护性和可扩展性。

总结而言，依赖注入是一种通过将依赖对象从外部注入到对象中的方式，降低了对象间的耦合性，提高了代码的灵活性和可测试性。

（十）BeanPostProcessor 是什么？

BeanPostProcessor 是 Spring 框架中的一个接口，用于在 bean 的初始化前后进行额外的处理操作。通过实现 BeanPostProcessor 接口，可以对 bean 进行自定义修改或扩展。

BeanPostProcessor 接口定义了两个方法：

postProcessBeforeInitialization(Object bean, String beanName): 在 bean 的初始化之前调用。可以在这个方法中对 bean 进行一些预处理操作或修改。
postProcessAfterInitialization(Object bean, String beanName): 在 bean 的初始化之后调用。可以在这个方法中对 bean 进行一些后处理操作或修改。

示例代码如下所示：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 在 bean 初始化之前的额外处理
        if (ProductionCapacityCollect.class.equals(bean.getClass())) {
            ProductionCapacityCollect b = (ProductionCapacityCollect) bean;
            b.setSupplierId("123456");
            log.info("\n>>>>设置初始化信息信息");
            return b;
        }
        // 可以根据实际需求修改或扩展 bean 对象
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 在 bean 初始化之后的额外处理
        // 可以根据实际需求修改或扩展 bean 对象
        return bean;
    }
}

在上述示例中，我们创建了一个名为 MyBeanPostProcessor 的类，并实现了 BeanPostProcessor 接口。在接口的两个方法中，我们可以按需对 bean 进行预处理和后处理。

当 Spring IoC 容器初始化 bean 时，会自动应用注册的 BeanPostProcessor 实现类进行处理。你只需将该实现类声明为一个 Spring bean，并确保它被扫描到或者手动进行配置。

通过使用 BeanPostProcessor，可以在 bean 初始化的不同阶段对其进行修改或扩展。例如，可以在 postProcessBeforeInitialization() 方法中对属性进行一些定制化设置，或者在 postProcessAfterInitialization() 方法中添加额外的功能。

需要注意的是，BeanPostProcessor 执行顺序是基于其在容器中的顺序。如果有多个 BeanPostProcessor 实现类，它们会依次应用于每个 bean。（使用@Order注解）

重点：

如果需要使用BeanPostProcessor对某个Bean进行预处理或者后处理，需要在对应的Bean上加上@Component注解，将该Bean交给Spring容器进行创建才能生效

在实际开发过程中，BeanPostProcessor 接口的使用场景有很多，例如：

自定义初始化逻辑：可以利用 postProcessBeforeInitialization() 方法进行一些自定义的初始化逻辑，例如执行一些预处理操作，或者对属性进行检查和设置。
自定义后处理逻辑：可以利用 postProcessAfterInitialization() 方法进行一些自定义的后处理逻辑，例如添加额外的功能、动态代理等操作。
属性加密或解密：可以通过 BeanPostProcessor 对属性进行加密或解密的操作。在 postProcessBeforeInitialization() 或 postProcessAfterInitialization() 方法中，对特定的属性进行加解密处理。
AOP 框架的集成：可以使用 BeanPostProcessor 来实现基于动态代理的 AOP（面向切面编程），例如通过 postProcessAfterInitialization() 方法对目标对象进行代理，并在方法调用前后添加一些切面逻辑。
数据库事务管理：可以通过 BeanPostProcessor 实现事务管理，例如在 postProcessAfterInitialization() 方法中，对标记有特定注解的 bean 进行事务代理的处理。
Bean 配置的定制化：可以利用 BeanPostProcessor 对特定的 bean 进行自定义配置，例如根据某些条件动态地修改 bean 的属性或行为。
静态类中，设置属性值：静态类的成员属性是属于类级别的，而不是对象级别的，因此不能直接使用@Value注解进行属性值的注入。可以使用BeanPostProcessor实现静态属性的注入。

需要注意的是，BeanPostProcessor 的使用需要谨慎，过度使用可能会导致代码复杂性增加。应该根据实际需求，遵循适度使用的原则。

（十一）AOP是什么？

Spring AOP（面向切面编程）是Spring框架中的一个重要模块，用于实现横切关注点的模块化和复用。它允许开发人员通过将横切关注点（例如日志记录、事务管理、安全性等）从核心业务逻辑中分离出来，以提高代码的可维护性和重用性。

在Spring AOP中，横切关注点通过切面（Aspect）来定义，切面是一组通知（Advice）和切点（Pointcut）的结合体。通知定义了在特定切点上执行的逻辑，而切点则规定了在哪些连接点（Join Point）上应用该通知。

连接点是应用程序中可以插入切面的执行点，例如方法调用、方法执行、异常处理等。在Spring AOP中，连接点由切点定义，切点使用表达式语言（如AspectJ表达式）来指定连接点。

通过Spring AOP，您可以将通用的横切关注点应用到多个目标对象上，而无需修改这些目标对象的代码。这种解耦的方式大大简化了代码的编写和维护，提高了系统的可扩展性和灵活性。

总结来说，Spring AOP是Spring框架中的一个模块，用于实现横切关注点的模块化和复用，它通过切面、通知和切点来实现对应用程序中特定连接点的拦截和处理。

补充：

@After和@AfterReturning是两个常用的通知类型，用于在目标方法执行后进行处理。它们的主要区别如下：

执行时机：

@After注解的通知方法会在目标方法执行后无论是否抛出异常都会执行。
@AfterReturning注解的通知方法只会在目标方法正常返回时执行。

参数传递：

@After注解的通知方法可以访问目标方法的参数，可以通过JoinPoint参数获取目标方法的参数值。
@AfterReturning注解的通知方法不能直接访问目标方法的参数，如果需要访问参数，可以使用@AfterReturning注解的returning属性来指定一个参数，用于接收目标方法的返回值。

异常处理：

@After注解的通知方法会在目标方法抛出异常时也执行。
@AfterReturning注解的通知方法只在目标方法正常返回时执行，不会执行目标方法抛出异常时。

综上所述，@After通知适用于无论目标方法是否发生异常，都需要执行相关处理逻辑的情况，可以获取到方法的返回值以及参数信息；而@AfterReturning通知适用于只在目标方法正常返回时执行处理逻辑的情况，可以获取到方法的返回值，但无法获取到方法的参数信息和抛出的异常。

牧马人Eikko

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring的核心概念汇总

Spring的BeanFactory是Spring框架中的一个核心接口，用于管理和获取Bean对象的实例。BeanFactory提供了一种创建、配置和管理Bean的机制，它是Spring IoC容器的基础。Bean的创建和管理：BeanFactory负责创建和管理Bean的生命周期。它根据配置信息创建Bean的实例，并在需要时进行初始化和销毁。Bean的依赖注入：BeanFactory负责管理Bean之间的依赖关系。它可以自动将依赖的Bean注入到目标Bean中，实现松耦合的编程。
复制链接

扫一扫