Spring beans are classes. Instead of instantiating a class (using new), you get an instance as a bean cast to your class type from the application context, where the bean is what you configured in the application context configuration. This way, the whole application maintains singleton-scope instance throughout the application. All beans are initialized following their configuration order right after the application context is instantiated. Even if you don't get any beans in your application, all beans instances are already created the moment after you created the application context.

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.

书:Just Spring

Spring beans are classes. Instead of instantiating a class (using new), you get an instance as a bean cast to your class type from the application context, where the bean is what you configured in the application context configuration. This way, the whole application maintains singleton-scope instance throughout the application. All beans are initialized following their configuration order right after the application context is instantiated. Even if you don't get any beans in your application, all beans instances are already created the moment after you created the application context.

就Spring引导应用程序而言，bean只是一个Java对象，它是在应用程序启动时由Spring框架创建的。

对象的用途可以是任何东西——配置、服务、数据库连接工厂等等——Spring并不关心这些。

大多数bean依赖于其他bean才能工作，例如实体管理器可能需要一个数据库连接。Spring框架能够找出如何将bean自动连接在一起。从应用程序开发人员的角度来看，您只需声明所需的bean，它们就会“神奇地”出现在您的应用程序中，随时可以使用。

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 bean只是由Spring容器管理的实例对象，也就是说，它们是由框架创建和连接的，并放入一个“对象袋”(容器)中，您以后可以从那里获取它们。

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

对于那些不习惯Spring的人来说，我认为Wikipedia 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.