For a Java class to be usable as a Java bean, its setter- and getter-method names need to be as per the JavaBean guidelines (also called design patterns) for properties. If such a Java class is instantiable & manageable by the Spring IoC container, it is a Spring bean. To achieve this, the programmer wires the class as a bean definition of a suitable scope by using XML config files or annotations or a mix of both. The programmer can create new Spring beans out of existing Spring beans by wiring further by passing the latter to constructor-arguments of the former either as string-names as <idref> elements or by dependency injection (it can be recursive).

这个答案可以与我的这个SO答案一起阅读，以获得更多的背景信息。

Bean是一个POJO(普通旧Java对象)，由spring容器管理。

默认情况下，Spring容器只创建bean的一个实例。
此bean被缓存在内存中，因此对该bean的所有请求将返回对同一bean的共享引用。

@Bean注释返回一个对象，spring在应用程序上下文中将该对象注册为bean。
方法内部的逻辑负责创建实例。

什么时候使用@Bean注释?

当没有自动配置选项时。 例如，当我们想从第三方库连接组件时，因为源代码不可用，所以我们不能用@Component注释类。

实时场景可能是某人想要连接到Amazon S3桶。 因为源不可用，所以他必须创建一个@bean。

@Bean
public AmazonS3 awsS3Client() {
    BasicAWSCredentials awsCreds = new BasicAWSCredentials(awsKeyId, accessKey);
    return AmazonS3ClientBuilder.standard().withRegion(Regions.fromName(region))
            .withCredentials(new AWSStaticCredentialsProvider(awsCreds)).build();
}

源代码以上的代码-> https://www.devglan.com/spring-mvc/aws-s3-java

因为我上面提到了@Component Annotation。

@Component表示带注释的类是一个“组件”。在使用基于注释的配置和类路径扫描时，这些类被认为是自动检测的候选类。

组件注释将类注册为单个bean。

Spring的XML配置由bean组成，而bean基本上是类。它们只是我们在ApplicationContext中使用的pojo。定义bean可以看作是替换关键字new。所以无论你在应用程序中使用关键字new，比如:

MyRepository myRepository =new MyRepository ();

当你使用关键字new时你可以删除配置并将其放入XML文件中。 所以我们将像这样编码:

<bean name="myRepository " 
      class="com.demo.repository.MyRepository " />

现在我们可以简单地使用Setter注入/构造函数注入。我正在使用Setter注入。

public class MyServiceImpl implements MyService {
    private MyRepository myRepository;
    public void setMyRepository(MyRepository myRepository)
        {
    this.myRepository = myRepository ;
        }
public List<Customer> findAll() {
        return myRepository.findAll();
    }
}

For a Java class to be usable as a Java bean, its setter- and getter-method names need to be as per the JavaBean guidelines (also called design patterns) for properties. If such a Java class is instantiable & manageable by the Spring IoC container, it is a Spring bean. To achieve this, the programmer wires the class as a bean definition of a suitable scope by using XML config files or annotations or a mix of both. The programmer can create new Spring beans out of existing Spring beans by wiring further by passing the latter to constructor-arguments of the former either as string-names as <idref> elements or by dependency injection (it can be recursive).

这个答案可以与我的这个SO答案一起阅读，以获得更多的背景信息。

Spring核心技术参考文档描述了bean是什么。

根据Spring IoC容器和bean的介绍部分(其中“IoC”表示“控制反转”):

在Spring中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是由Spring IoC容器实例化、组装和管理的对象。否则，bean只是应用程序中的众多对象之一。bean以及它们之间的依赖关系反映在容器使用的配置元数据中。

Bean和作用域在Bean作用域部分中描述:

When you create a bean definition, you create 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, as with a class, you can create many object instances 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 control the scope of the objects created from a particular bean definition. This approach is powerful and flexible, because you can 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.

首先让我们来了解一下春天:

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

类比:

Java bean是将许多对象封装到单个对象(bean)中的类。“Bean”这个名称包含了这个标准，它旨在为Java创建可重用的软件组件。

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

类比: 让我们假设农民有一块种种子(或豆子)的农田。 在这里，农民是春天的框架，农田是春天的容器，豆子是春天的豆子，耕种是春天的加工者。

和豆类的生命周期一样，春豆也有自己的生命周期。

img源

下面是Spring中bean生命周期的序列:

Instantiate: First the spring container finds the bean’s definition from the XML file and instantiates the bean. Populate properties: Using the dependency injection, spring populates all of the properties as specified in the bean definition. Set Bean Name: If the bean implements BeanNameAware interface, spring passes the bean’s id to setBeanName() method. Set Bean factory: If Bean implements BeanFactoryAware interface, spring passes the beanfactory to setBeanFactory() method. Pre-Initialization: Also called post process of bean. If there are any bean BeanPostProcessors associated with the bean, Spring calls postProcesserBeforeInitialization() method. Initialize beans: If the bean implements IntializingBean,its afterPropertySet() method is called. If the bean has init method declaration, the specified initialization method is called. Post-Initialization: – If there are any BeanPostProcessors associated with the bean, their postProcessAfterInitialization() methods will be called. Ready to use: Now the bean is ready to use by the application Destroy: If the bean implements DisposableBean, it will call the destroy() method