我还没有找到一个我能理解的关于春豆的高级定义。我经常在Grails文档和书籍中看到它们的引用，但是我认为理解它们是什么是有益的。那么什么是春豆？如何使用它们？它们与依赖注入有关吗？

The objects that form the backbone of your application and that are
managed by the Spring IoC* container are called beans. A bean is an
object that is instantiated, assembled, and otherwise managed by a
Spring IoC container. These beans are created with the configuration
metadata that you supply to the container, for example, in the form of
XML definitions.

要从SpringSource了解更多关于bean和scope的信息：

When you create a bean definition what you are actually creating is a
recipe for creating actual instances of the class defined by that bean
definition. The idea that a bean definition is a recipe is important,
because it means that, just like a class, you can potentially have
many object instances created from a single recipe.

You can control not only the various dependencies and configuration
values that are to be plugged into an object that is created from a
particular bean definition, but also the scope of the objects created
from a particular bean definition. This approach is very powerful and
gives you the flexibility to choose the scope of the objects you
create through configuration instead of having to 'bake in' the scope
of an object at the Java class level. Beans can be defined to be
deployed in one of a number of scopes

*IOC：控制反转

SpringBean只是由Spring容器管理的对象实例，也就是说，它们是由框架创建和连接的，并放入"对象包"(容器)中，稍后您可以从中获取它们。

"连接"部分是依赖注入的全部内容，它的意思是您可以只说"我需要这个东西"，框架将遵循一些规则来为您提供适当的实例。

对于一个不习惯春天的人来说，我认为维基百科春天的文章有一个很好的描述：

Central to the Spring Framework is its inversion of control container,
which provides a consistent means of configuring and managing Java
objects using reflection. The container is responsible for managing
object lifecycles of specific objects: creating these objects, calling
their initialization methods, and configuring these objects by wiring
them together.

Objects created by the container are also called managed objects or
beans. The container can be configured by loading XML files or
detecting specific Java annotations on configuration classes. These
data sources contain the bean definitions which provide the
information required to create the beans.

Objects can be obtained by means of either dependency lookup or
dependency injection. Dependency lookup is a pattern where a caller
asks the container object for an object with a specific name or of a
specific type. Dependency injection is a pattern where the container
passes objects by name to other objects, via either constructors,
properties, or factory methods.

首先让我们了解春天：

Spring是一个轻量级和灵活的框架。

类比：

bean：是一个对象，在Spring容器中创建、管理和销毁。我们可以通过元数据(XML或注释)将对象注入到Spring容器中，这称为控制反转。

类比：让我们假设农民有一个用种子(或豆类)耕种的农田。在这里，农民是春天的框架，农田是春天的容器，豆类是春天的豆子，种植是春天的处理器。

就像豆子的生命周期一样，春豆也有自己的生命周期。

IMG源

下面是bean在春季的生命周期顺序：

• 实例化：首先，Spring容器从XML文件中找到bean的定义，并实例化bean。

• 填充属性：使用依赖注入，Spring填充bean定义中指定的所有属性。

• 设置bean名称：如果bean实现BeanNameAware接口，spring将bean的id传递给setBeanName()方法。

• 设置bean工厂：如果bean实现BeanFactoryAware接口，那么spring将bean工厂传递给setBeanFactory()方法。

• 预初始化：也称为bean的后处理。如果有任何bean后处理程序与bean关联，Spring将调用postProcesserBeforeInitialization()方法。

• 初始化bean：如果bean实现IntializingBean，则调用其afterPropertySet()方法。如果bean有init方法声明，则调用指定的初始化方法。

• 初始化后：–如果有任何与bean关联的BeanPostProcessors，将调用它们的postProcessAfterInitialization()方法。

• 准备好使用：现在应用程序可以使用bean了

• 销毁：如果bean实现DisposableBean，则调用destroy()方法

嗯，你部分理解。您必须根据自己的需要定制bean，并在需要时通知Spring容器管理它，方法是使用由Martin Fowler(也称为依赖注入(DI))创建的一种普遍称为IOC(控制反转)的方法。

您以某种方式连接bean，这样就不必考虑实例化或评估对bean的任何依赖性。这就是众所周知的好莱坞原则。

除了在这个问题上你会被淹没的链接之外，谷歌是探索更多信息的最佳工具。：)

弹簧有装豆袋的IOC容器，创建、维护、删除是弹簧容器的职责。我们可以通过布线和自动布线将bean放入Spring中。布线意味着我们手动将其配置成XML文件和"自动布线"意味着我们把注释放在Java文件中，然后Spring自动扫描根上下文中的Java配置文件，将其放入弹簧包中。

这是详细的URI，您可以从中获得关于bean的更多信息

• SpringBean只是由SpringIOC容器管理的对象实例。

• SpringIOC容器携带bean包，bean的创建、维护和删除是Spring容器的职责。

• 我们可以通过布线和自动布线将bean放入Spring中。

• 连接意味着我们手动将其配置到XML文件中。

• 自动布线意味着我们将注解放入Java文件中，然后Spring自动扫描根上下文中的Java配置文件，使其放入Spring的包中。

春豆是课程。不是实例化类(使用new)，而是从应用程序上下文将实例作为bean强制转换为类类型，其中bean是在应用程序上下文配置中配置的。这样，整个应用程序在整个应用程序中维护单例作用域实例。所有bean都是在应用程序上下文实例化后按照配置顺序初始化的。即使您的应用程序中没有任何bean，所有bean实例在您创建应用程序上下文之后就已经创建了。

在Spring中，那些构成应用程序主干并由Spring IOC管理的对象容器被称为bean。bean只是一个被实例化、组装或其他方式的对象。由春季国际奥委会集装箱管理；

For Spring, all objects are beans! The fundamental step in the Spring Framework is to define your objects as beans. Beans are nothing but object instances that would be created by the spring framework by looking at their class definitions. These definitions basically form the configuration metadata. The framework then creates a plan for which objects need to be instantiated, which dependencies need to be set and injected, the scope of the newly created instance, etc., based on this configuration metadata.

The metadata can be supplied in a simple XML file, just like in the first chapter. Alternatively, one could provide the metadata as Annotation or Java Configuration.

书：春天

Spring的XML配置由bean组成，bean基本上是类。它们只是我们在应用程序上下文中使用的pojos。定义bean可以被认为是替换关键字new。因此，无论您在应用程序中使用关键字new的地方，都会出现以下情况：

在使用关键字new的地方，您可以查看删除该配置并将其放入XML文件。所以我们会这样编码：

现在我们可以简单地使用setter注入/构造函数注入。我用的是二传针。