Spring Bean Instantiation and Dependency Injection

In the Spring framework, a Bean refers to an object managed by the Spring container. The Spring container is responsible for creating, configuring, and managing the lifecycle of Bean objects. The Spring container can instantiate Beans in several ways, including:

  1. Constructor Injection: Instantiate by calling the constructor of the Bean to create its instance. Spring's Dependency Injection (DI) mechanism can be used to pass instances of other Beans into this constructor to satisfy the Bean's dependencies.
  2. Factory Method Instantiation: Instantiate by calling a static factory method within the Bean class to create its instance. Spring's DI mechanism can be used to pass instances of other Beans into the factory method to satisfy the Bean's dependencies.
  3. Instance Factory Method Instantiation: Instantiate by calling an instance factory method within a Bean factory class to create its instance. Spring's DI mechanism can be used to pass instances of other Beans into the factory method to satisfy the Bean's dependencies.
  4. Factory Bean Instantiation: Instantiate by calling the getObject() method of a Factory Bean that implements the FactoryBean interface. The FactoryBean interface allows developers to customize the Bean instantiation process. When creating a Bean using this approach, the & symbol must be prefixed to the Bean name to indicate that the factory Bean instance itself is being retrieved rather than the Bean instance created by the factory method.

Bean Assembly

Bean assembly in Spring refers to combining different components (Beans) within an application to form a complete system. Spring provides several ways to achieve Bean assembly, including:

  1. XML-based Assembly: Define Beans using <bean> elements in XML configuration files and set Bean property values or dependencies using <property> elements.
  2. Java-based Assembly: Define Beans using the @Bean annotation within Java configuration classes (typically annotated with @Configuration) and set Bean dependencies using the @Autowired annotation or constructor arguments.
  3. Annotation-based Assembly: Identify a class as a Bean by applying specific annotations (such as @Component, @Service, @Repository, @Controller, etc.) to the Bean class, and set Bean dependencies using the @Autowired annotation or constructor arguments.
  4. Hybrid Assembly of Java-based and XML-based: You can mix Java configuration classes and XML configuration files to define Beans, using <bean> elements and @Bean annotations to set Bean property values or dependencies.

Spring offers several common auto-configuration methods:

  1. By Type: The Spring container automatically injects the Bean into places where it is needed based on its type. If multiple matching Beans exist, an exception will be thrown. This is the default auto-configuration method.
  2. By Name: The Spring container automatically injects the Bean into places where it is needed based on its name. Note that the Bean name must match the name of the dependency property or the constructor parameter name.
  3. Constructor Injection: The Spring container automatically looks for a matching constructor and assembles dependencies based on the type and name of the constructor parameters. Constructor injection ensures that dependencies are satisfied at the time of Bean instantiation.
  4. Setter Method Injection: The Spring container automatically looks for a matching setter method and injects the dependent Bean into the corresponding property. Setter method injection allows dependencies to be set dynamically after the Bean is instantiated.
  5. Annotation-based: Spring supports marking Beans for auto-configuration using annotations. Common annotations include @Autowired, @Resource, and @Inject. By adding these annotations to properties, constructors, or methods that require dependencies, the Spring container can automatically complete the assembly.

When performing Bean assembly, keep the following points in mind:

  1. The dependency relationships of Beans must be set correctly; otherwise, the application may fail to run properly.
  2. When using auto-configuration, pay attention to whether there are multiple qualifying Bean instances to avoid auto-configuration errors.
  3. When using XML configuration files, pay attention to namespace declarations and DTD version numbers to prevent configuration file parsing errors.
  4. When using annotation-based assembly, pay attention to the scope and usage of annotations to avoid incorrect annotation usage.