What is the order and principle of spring’s startup loading?

In the Spring framework, the startup loading sequence can be divided into the following steps:

1. Load and parse Spring configuration files: Spring framework will load configuration information based on the specified configuration file (such as applicationContext.xml). During the loading process, Spring uses an XML-based parser to parse the configuration file and convert the configuration information into an internal data structure.
2. Creating and initializing Bean definitions: During the configuration file parsing process, Spring will create and initialize Bean definitions. These definitions include the class name, properties, methods, and other configuration information of the Bean.
3. Create and initialize a Bean: Once the Bean definition is created, Spring will instantiate the Bean object based on the definition and call the corresponding initialization method to initialize the Bean. The initialization method can be specified using the init-method property in the configuration file or defined using annotations.
4. Registering Beans: After a Bean is initialized, Spring will register it into the Bean container for other Beans or components to inject or access.
5. The startup loading process is completed when all Beans have been registered in the container by the Spring framework.

When it comes to the start-up loading principle of Spring, it involves its core mechanisms – Inversion of Control (IoC) and Dependency Injection (DI).

IoC refers to delegating the creation of objects and management of dependencies to a container, rather than controlling it within the application itself. Spring’s IoC container is responsible for creating and managing Bean objects, handling processes such as instantiation, initialization, and dependency injection.

DI is a specific implementation of IoC, where the container injects dependent objects into the necessary places without the need for manual acquisition and setting of these objects. Dependency injection can be achieved through methods such as constructor injection, setter injection, and interface injection.

During the startup loading process of Spring, the IoC container is responsible for creating and initializing Bean objects, and satisfying relationships between Beans through dependency injection. By configuring files or annotations, you can specify how Beans are created, how properties are injected, and the dependency relationships. Based on this configuration information, the Spring framework will load and initialize Bean objects in a certain order, as well as resolve dependencies between Beans.