Spring Framework Quick Start Manual

Note: This article attempts to integrate and analyze the knowledge system of the Spring framework and add its own understanding to provide a quick start manual for students who are new to the Spring framework. At the same time, it is also to summarize the problems and experiences encountered in work and study to avoid omissions! At the end of the article, Spring learning materials will be attached for everyone to learn~

(Disclaimer: I am a complete novice. Since I need to learn Spring by myself for work, some of my understandings may be biased. Please correct me! Thank you very much!!)

1. Spring’s past and present life

In the era of Java 2 Enterprise Edition (J2EE) , the development of enterprise-level Java applications was very complex and lengthy. Developers need to deal with a large amount of configuration and complex APIs, making development difficult. In J2EE, EJBs become the main model components, but they are complex to use and difficult to maintain. This has led to the need for a more lightweight and easy-to-use development model. As a result, our protagonist today comes into being.

1. Birth

Spring framework was developed by Rod Johnson in 2003. Its goal is to simplify the development of enterprise-level Java applications and provide a more lightweight development model. Its emergence solves a series of problems in J2EE development, including complexity problems, tight coupling problems ( that is, the dependencies between components are hard-coded in the code, making it difficult to conduct and test ), and testing problems ( Spring's DI and IoC patterns Making testing easier, you can use mock objects for unit testing easily ), AOP issues ( Spring has introduced AOP support, allowing these concerns to be exported from the main business logic, making the code more standardized ), data access issues ( Spring provides JDBC templates and ORM integration, simplifying the development of the data access layer ). Its emergence makes supporting enterprise-level applications easier to develop, test and maintain.

2. Overview of Spring Framework

Here I borrow the content and pictures from the book "Spring Revealed" by teacher Wang Fuqiang to summarize. ~~Whisper in a low voice, this book is a must-have for beginners, I love you so much, Teacher Wang, you are my god! ! ! !~~ (Don’t look for resources, haha, let’s continue, there is this book in the link at the end of the article, pick it up yourself)

The picture above is the Spring tree of life (hereinafter referred to as the tree of life ), which will become the core of our quick start manual . Next, we will analyze the contents of the tree of life one by one. Before that, I will list the core components of the current Spring framework, as well as the main projects and modules in the current market , and give my understanding of these contents to help everyone quickly understand the composition of the Spring framework .

2.1 Core components of the Spring framework

Core components of Spring framework
*name*	explain
IoC container (Inversion of Control)	The IoC container is the core of the Spring framework and is responsible for managing and controlling components (such as Java objects) in the application. It implements the concepts of Inversion of Control (IoC) and Dependency Injection (DI), allowing developers to hand over component creation and dependency management to the Spring container. Common Spring IoC containers include BeanFactory and ApplicationContext.
Bean	The IoC container is the core of the Spring framework and is responsible for managing and controlling components (such as Java objects) in the application. It implements the concepts of Inversion of Control (IoC) and Dependency Injection (DI), allowing developers to hand over component creation and dependency management to the Spring container. Common Spring IoC containers include BeanFactory and ApplicationContext.
Dependency Injection (DI)	In Spring, a bean is a manageable object in an application, usually corresponding to an instance of a Java class. These beans are managed by the Spring container and can be defined through configuration files or annotations. Beans are the basic building blocks of Spring applications.
AOP（Aspect-Oriented Programming）	AOP is a programming paradigm that allows developers to separate code in an application by cutting across concerns (such as logging, transaction management, security, etc.). The Spring framework provides AOP support, allowing the logic of cross-cutting concerns to be cut into different locations in the application.
Spring module	The Spring framework includes multiple modules, each of which provides specific functionality, such as Spring MVC for building web applications, Spring Data for simplifying data access, Spring Security for handling security, etc.
Data access and integration	The Spring framework provides integration of different data access technologies and databases, including JDBC, JPA, Hibernate, MongoDB, Redis, etc. These modules simplify the development of data access.
Spring Boot	Spring Boot is a project for quickly building Spring-based applications. It provides automatic configuration, embedded web server and other functions, making application development and deployment simpler.
Spring life cycle and events	The Spring framework provides component life cycle management and event handling mechanisms, allowing developers to define operations to be performed within the Bean life cycle and to listen for and respond to events.

2.2 Main projects and modules of Spring framework currently on the market

1. Spring Framework (Spring Core): The core module of the Spring Framework provides basic functions such as IoC container, dependency injection, and AOP support, and is used to build Java enterprise-level applications. It is the root part of the tree of life.

2. Spring Boot: A project used to quickly build Spring-based applications. It provides automatic configuration, embedded web server and other functions, simplifying application development and deployment. ( At the end of the article, "Spring Boot Practical Combat" is attached )

3. Spring Data: The Spring Data project includes multiple modules to simplify data access, including Spring Data JPA, Spring Data JDBC, Spring Data MongoDB, etc., for interacting with different data stores.

4. Spring Security: Used to handle application security and authentication/authorization issues, including user authentication, role management, and web application security.

5. Spring Cloud: Projects used to build microservice architecture and distributed systems , including service discovery, load balancing, configuration management and other functions.

6. Spring Batch: Used to process large-scale batch processing jobs, such as data import, report generation, etc., providing a scalable batch processing method.

7. Spring Web MVC: A module for building Web applications, providing an implementation of the MVC (Model-View-Controller) pattern for handling Web requests and responses.

8. Spring Data REST: A module used to expose data stored in JPA, MongoDB and other data stores to the client in the form of RESTful API.

9. Spring Integration: Used to build integration between applications and external systems, supporting message-driven applications and enterprise integration patterns.

10. Spring Web Services: Project for building SOAP and RESTful web services, used to create and manage WebService endpoints.

These projects and modules form the core of the Spring framework, covering various areas from application development, data access, security, microservice architecture, integration, batch processing, message processing, etc. We can then choose to integrate these projects and modules to build your own application based on specific needs. That's right! It is to integrate your own applications. It should be noted that the above listed are only the main and more common projects. In order to let everyone understand the outline of spring, they can already meet most application scenarios . However, don't take it for granted that it is the complete picture of the Spring framework. With the development and growth of Spring, there are dozens or hundreds of projects and modules in the Spring framework ecosystem. Interested students can go and find out more, I won’t list them one by one.

2.3 Summary

Everyone! At this point, I believe that if you have not come into contact with Spring students, you must be confused, thinking: "What a mess of professional terms, even if you give an explanation, you don't know what they are used for, your life here is in vain." What’s the use of half a day?” Don't worry, for the time being, you only need to understand a general outline of the previous content, or even just understand what Spring is and that they are all part of the tree of life. The second section will be detailed in detail . Since our purpose is to get started quickly, after knowing its components, we must understand the core of Spring! Then grasp the core, and then learn about the tree of life. So what is the core of Spring? What was the initial design concept of Spring? What's going on? After understanding the above two questions, you will understand the operating logic of Spring, which is very important for our future study!

The core of the Spring framework

It is to split the different functions in Java EE (now commonly referred to as Jakarta EE) and provide a series of independent modules and components. Developers can selectively integrate these modules as needed to build applications while reducing code complexity. Redundancy and complexity. Unlike traditional J2EE application servers, which usually provide a complete set of functions and are not easy to tailor or customize. To put it more simply , it is to divide the large and comprehensive "luxury villa" (Java EE) into countless small and independent "small rooms" (Spring projects and modules) through the Spring core components mentioned before ), then I only need a "toilet" and a "bedroom" (two small projects or modules) to form a small apartment (through integration, you can create your own application). Why can’t I live in a big villa with a monthly salary of 3,000? I can’t say more ~~. I can’t afford the monthly payment!~~ (Reduce the workload of the server).

Spring framework design concept

1. Loose Coupling: Spring encourages developers to write loosely coupled code, that is, the dependencies between components should be minimized or weakened. This is achieved through dependency injection (Dependency Injection). Developers no longer need to hard-code the relationship between objects, but leave the dependency to the Spring container for management. This helps improve the maintainability and testability of your code. Popular explanation, loose coupling is like unpacking the whole into "building blocks". In programming, loose coupling means that the relationship between components should be like "building blocks" and should not be too tightly glued together. This means you can more easily modify, replace or add components without affecting the entire program. This helps the code be more flexible and easier to maintain. Does this echo the Spring kernel ~~(manual dog head)~~

2. Inversion of Control (IoC): The Spring framework implements the concept of inversion of control, which transfers the power of application control to the framework. Developers no longer need to explicitly create and manage objects, but delegate these tasks to the Spring container through configuration. This way, the framework can better manage component lifecycles and dependencies. The popular explanation is that control has been reversed. For example, you need to make a cup of coffee. In traditional programming, you may need to grind coffee beans, boil water, brew coffee, etc. yourself. It's like you take control of everything and do it yourself. In inversion of control, you simply hand the coffee machine a bag of coffee beans and a glass of water and press a button. The coffee machine knows when to grind beans, when to boil water, and when to brew coffee. You only need to provide the materials and instructions the coffee machine needs. It's as if you no longer control everything yourself but instead hand over control to the coffee machine. In programming, inversion of control means that you give control to a framework or container, which manages the creation and assembly of objects based on your configuration or code. This helps reduce coupling between components, making the code easier to maintain and extend. This echoes the so-called loose coupling

3. Aspect-Oriented Programming (AOP): Spring supports AOP, allowing cross-cutting concerns (such as logging, transaction management, security) to be separated from core business logic. This improves the modularity of the code, makes focus clearer, and avoids code duplication. Specifically, aspects define what operations (called advices) are performed at specific points in the program (called join points). For example, an aspect could define a log before every call to a function. This way, when you run your program, the aspect will automatically intercept each function call and perform logging operations when appropriate, without you having to manually add logging code in each function. (This may not seem to be related to the Spring core at first glance, but it actually solves the shortcomings of the old system)

4. Modular design: The Spring framework is designed as a series of independent modules, each module provides specific functions. Developers can selectively integrate these modules according to their needs to build applications. This helps reduce code complexity and improve maintainability.

5. Simplify development: Spring is committed to simplifying the development of enterprise-level applications and provides solutions for many common tasks, such as data access, transaction management, security, etc. This allows developers to focus more on business logic without having to deal with underlying technical details.

6. Flexibility and scalability: The Spring framework is highly customizable and scalable. Developers can use custom components and extension points to adapt to different application needs. Spring also supports integration with other frameworks and libraries, allowing developers to choose the tools that best suit their projects.

7. Test-Driven Development (TDD): Spring encourages the practice of TDD because it provides good support and tools, making it easier to write unit tests and integration tests.

All in all, be sure to keep in mind the picture of the tree of life, and the core of the Spring framework. Now that we already know its framework and operating logic, it’s time to introduce the branches of the tree of life.

2. A one-by-one introduction to Spring’s tree of life

In this part, my purpose is to take you to quickly understand the composition of the tree of life, as shown in the figure Spring tree of life, which will be divided into 6 sections, namely one "trunk" and five "branches". When we finish studying the content of the Tree of Life, congratulations! ! "First glimpse of the door" Hahahahaha!

Also, I am just a beginner. Due to the limitations of my knowledge, it is impossible to cover everything. Let’s discuss more and make progress together! Then, the "Tree of Life" is a picture that exists in the book "Spring Revealed" written by Teacher Wang in 2009. At that time, the now popular Spring Cloud (distributed microservices) had not yet appeared? What I want to say is that we can get started with the tree of life first, and then add branches to the Spring tree of life in our minds! After all, the current development of programming is changing with each passing day, and you need to keep learning, right? Ado! Get some good stuff! !

1. "Trunk part" (Spring's IoC container)

Spring's IoC container is one of the core components of the Spring framework. IoC stands for "Inversion of Control". The IoC container is a container responsible for managing the life cycle and dependencies of various components (objects) in the application. The basic idea is to shift the responsibility for object creation and management from application code to the container to achieve loose coupling and better maintainability.

The entire Spring framework is built on the Core core module, which is the foundation of the entire framework.

Detailed explanation of IoC container:

1. Creation and management of objects: The IoC container is responsible for creating, initializing, configuring, and managing objects (commonly called Beans) in the application. Developers only need to define the rules for these beans without creating them themselves. In this way, the object creation process is encapsulated in the container, so that developers do not need to care about the instantiation of the object.

2. Dependency Injection (DI): The IoC container is responsible for managing dependencies between objects through the dependency injection mechanism. Dependency means that an object may depend on other objects, and the IoC container will inject these dependencies into the object without requiring the object to create or find the dependent object itself. This reduces the coupling between objects, making the system more flexible and maintainable.

3. Configuration: Developers tell the IoC container how to create and assemble beans through configuration files (usually XML files or annotations) or Java code. The configuration file contains the definition of the Bean, including class name, attribute values, dependencies and other information. The IoC container instantiates and configures beans based on configuration files.

4. Bean scope: The IoC container manages the life cycle and scope of Bean. Spring supports different scopes, including Singleton, Prototype, Session, Request, etc. Developers can configure the scope of the Bean as needed.

5. Life cycle management: The IoC container manages the complete life cycle of the Bean, including instantiation, initialization, use and destruction. Developers can define initialization methods and destruction methods, and the container will call these methods at appropriate times.

6. AOP integration: The IoC container is integrated with AOP, allowing developers to integrate the logic of cross-cutting concerns into Bean methods without modifying the Bean code. This provides a more flexible way to handle cross-cutting concerns such as transaction management, logging, etc.

7. Container type: Spring provides two main types of IoC containers: BeanFactory and ApplicationContext. BeanFactory is a more basic container that provides lazy loading and lazy loading functions and is suitable for resource-constrained environments. ApplicationContext is an extension of BeanFactory and provides more functions, such as internationalization, event publishing, application-level context information, etc.

2. Spring AOP framework - "Twigs"

In the Spring framework, AOP (Aspect-Oriented Programming) is a programming paradigm used to handle cross-cutting concerns in applications, such as logging, transaction management, security, etc. AOP allows these concerns to be separated from the core business logic of the application to improve the modularity and maintainability of the code.

AOP explained in detail

1. Aspect: Aspect is the core component of AOP, which defines where and when the logic of cross-cutting concerns is executed. Aspects usually include pointcuts and advice.

2. Pointcut: A pointcut is an expression that defines where in the application (methods, classes, packages, etc.) the logic of cross-cutting concerns should be executed. The pointcut determines where the aspect's advice is applied to the target object.

3. Advice: Advice is the specific logic in the aspect, which defines when to perform the operation at the entry point. Spring provides different types of notifications, including pre-notifications, post-notifications, wrap-around notifications, exception notifications and final notifications. Each notification type is executed at different time points at the entry point.

4. Join Point: A join point is a specific point in the application that can be notified, usually a method call or an exception thrown. Pointcuts are a subset of join points.

5. Weaving of aspects: Weaving is the process of connecting aspects with the target object (or target method) of the application. Weaving can occur at different stages such as compile time, class loading time, and runtime.

6. Target Object: The target object is the original object in the application and usually contains the core business logic. Aspect's advice affects the behavior of the target object.

7. Introduction: Introduction allows aspects to introduce new methods and properties to the target object. These methods and properties do not exist on the target object. This can be used to add functionality to the target object.

8. Aspect priority: If there are multiple aspects in the application, they may execute at the same entry point. In this case, you can define priorities for the aspects to determine which aspect should be executed first.

9. XML configuration and annotation configuration: Spring allows AOP aspects and notifications to be defined through XML configuration files or annotations. The XML configuration method uses <aop:config>elements, while the annotation configuration method uses @Aspectannotations and related annotations.

Summary: AOP is widely used in various application scenarios in Spring, for example, processing transactions, recording logs in web applications, or performing permission checks in terms of security. This makes the focus of the application clearer and also helps reduce code duplication.

3. Spring access data (DAO) - "Twig"

In the Spring framework, DAO (Data Access Object) is a design pattern used to encapsulate code that interacts with a data store (usually a database). The main purpose of DAO is to separate data access logic from business logic to improve the modularity, maintainability and testability of the code.

DAO explained in detail

1. Encapsulation of data access logic: DAO is mainly responsible for encapsulating data access logic, including database query, update, insertion and deletion operations. These operations typically involve code that interacts with the database, such as SQL queries or persistence operations performed using an ORM (Object Relational Mapping) framework.

2. Separate data storage details: One of the design goals of DAO is to separate data storage details (such as database engines, SQL statements, etc.) from the business logic of the application. This means that the business logic does not need to know the specific details of the data storage, thus improving the loose coupling of the code.

3. Abstract data access interface: DAO usually defines a set of interfaces that describe methods of data access operations, such as finding users, saving orders, etc. These interfaces allow the business layer to perform data access operations by calling DAO methods without knowing the underlying database details.

4. Spring’s support for DAO: The Spring framework provides powerful support for DAO, including the integration of JDBC (Java Database Connectivity) and ORM (Object Relational Mapping). Spring's JDBC module provides a set of template classes that simplify JDBC operations, JdbcTemplatee.g. Spring also supports integrated ORM frameworks, such as Hibernate, JPA, MyBatis, etc., to simplify database access and management.

5. Exception handling: DAO usually captures exceptions that may be thrown by underlying database operations and converts them into more specific exceptions so that the application can better handle error conditions.

6. Transaction management: In database operations, transaction management is very important. DAO is often used together with Spring's transaction management to ensure that database operations can be performed within the context of a transaction, thereby ensuring data consistency and integrity.

7. Ease of testing: Since DAO separates data access logic from business logic, it is easier to unit test DAO. You can write test cases against the DAO interface without relying on the actual database.

Summary: DAO in Spring is a design pattern for handling data access logic. It provides a maintainable, testable, and loosely coupled way to interact with data storage by abstracting away data storage details. The Spring framework provides powerful tools and support, allowing developers to easily create and manage DAOs, and integrates a variety of data access technologies to make data access more convenient.

4. Transaction Management (ORM) in Spring - "Twigs"

In the Spring framework, ORM (Object-Relational Mapping) is a technology used for data mapping between relational databases and object-oriented programming languages. The goal of ORM is to make the mapping between the database and the object model simpler, allowing developers to use an object-oriented approach to access and operate the database.

ORM explained in detail

1. Data object mapping: ORM enables developers to use an object-oriented approach to process data by mapping rows of database tables to objects in object-oriented programming languages. Each database table is typically mapped to a class, and the table's columns are mapped to attributes of the class.

2. ORM framework: The Spring framework supports the integration of multiple ORM frameworks, including Hibernate, Java Persistence API (JPA), MyBatis, etc. These ORM frameworks allow developers to abstract database operations into method calls on objects without the need to write raw SQL statements.

3. Entity class (Entity): In ORM, entity class represents the structure of the database table and is used to represent and operate data in the application. Attributes of entity classes usually correspond to columns of database tables.

4. Relationship mapping: The ORM framework allows developers to define relationships between entities, such as one-to-many, many-to-one, many-to-many, etc. relationships. These relationships can be defined through annotations or XML configuration.

5. Persistence Context: ORM framework usually maintains a persistence context, which is the middle layer between the application and the database. The persistence context is responsible for managing the state of entity objects, including load, update, save, and delete operations.

6. Transaction management: ORM frameworks are usually integrated with Spring's transaction management to ensure that database operations are performed within the context of transactions. This ensures data consistency and integrity.

7. Query language: ORM framework usually provides a query language that allows developers to query the database in an object-oriented manner. These query languages can use an object-oriented model without the need to write raw SQL queries.

8. Caching: ORM frameworks usually support caching mechanisms, allowing the results of database queries to be cached in the application to improve performance.

9. Cross-database compatibility: ORM frameworks usually provide compatibility across different database systems, allowing applications to switch between different databases without modifying a large amount of code.

Summary: Using ORM, developers can handle database operations more easily, reduce repetitive work related to the database, and improve the maintainability and readability of the code. Spring's ORM support makes integrating ORM frameworks easier and provides a powerful way to access and manipulate databases.

5. Spring's Web MVC framework - "Twigs"

Spring's Web MVC framework is a Model-View-Controller (MVC) architecture for developing Web applications. It is designed to help developers build flexible, maintainable and scalable Web applications.

Web MVC explained in detail

1. MVC architecture: MVC is a software design pattern commonly used to build Web applications. It divides applications into three core components, as shown in the following table:

Model	Models represent the application's data and business logic. In Spring's Web MVC, the model is usually a POJO (Plain Old Java Object) class, which is responsible for managing data and business logic.
View	A view is a presentation of a user interface, usually an HTML page or other type of UI interface. The view is responsible for presenting the model's data to the user.
Controller	The controller is responsible for receiving requests from the user, calling the appropriate model to handle the request, and selecting the appropriate view to render the response.

2. DispatcherServlet: Spring's Web MVC framework handles all requests through a front-end controller called DispatcherServlet. DispatcherServlet receives HTTP requests and dispatches the requests to the appropriate controller based on the requested URL.

3. Controller: The controller is a component that processes requests. It receives user requests and executes corresponding business logic based on the content of the request. Controllers are typically Spring-managed Java classes that map URLs and methods through annotations or configuration to determine which controller handles which request.

4. Model: The model represents the data of the application. It is usually a POJO class and is responsible for managing data and business logic. Controllers can query or modify data in the model and pass it to the view for rendering.

5. View Resolver: The view resolver is responsible for parsing the view name returned by the controller into the actual view object. Spring supports different types of views, including JSP, Thymeleaf, FreeMarker, etc.

6. Data binding and validation: Spring's Web MVC framework supports data binding, allowing HTTP request parameters to be bound to model objects, and supports data validation to ensure data integrity and validity.

7. Interceptors: Interceptors allow developers to insert custom logic at different stages of request processing. Interceptors can be used for authentication, logging, performance monitoring, and more.

8. Internationalization and localization: Spring's Web MVC framework provides internationalization and localization support, allowing developers to provide different views or messages according to the user's language and region.

9. RESTful support: Spring's Web MVC framework also supports building RESTful web services, allowing developers to create RESTful-style APIs.

10. File upload: The framework provides convenient file upload support and allows processing file upload requests.

11. Security: Spring's Web MVC framework integrates Spring Security, providing powerful security features, including authentication and authorization.

Summary: Spring's Web MVC framework is a powerful and flexible web application framework that follows the MVC pattern, divides applications into models, views, and controllers, and provides a series of features to simplify the development of web applications. Its design goal is to make the development of web applications more modular, maintainable and extensible. Due to its wide range of features and flexibility, it is very useful when building various types of web applications.

6. Spring framework’s integration and support for J2EE services – “Twigs”

Specific related J2EE integration support projects (split small houses)

JDBC integration: Spring provides strong support for JDBC (Java Database Connectivity), simplifying database access and management. Spring's JdbcTemplateand NamedParameterJdbcTemplateother template classes make database operations easier while providing exception handling and resource management.
JPA integration: Spring integrates Java Persistence API (JPA), allowing developers to use JPA for object-relational mapping (ORM). Spring supports multiple JPA implementations, such as Hibernate, EclipseLink, etc., and provides annotation-driven configuration.
JMS integration: Spring supports Java Message Service (JMS) integration, allowing developers to create and manage message-driven applications. Spring JmsTemplatesimplifies sending and receiving JMS messages while providing transaction management.
JTA integration: Spring supports Java Transaction API (JTA) integration, allowing developers to program in a distributed transaction environment. Spring provides declarative transaction management, and transactions can be defined through annotations or XML configuration.
EJB integration: Spring allows the integration of Enterprise JavaBeans (EJB) and Spring applications. EJB services can be injected into Spring beans through Spring's LocalSessionFactoryBeanand other tools.LocalStatelessSessionProxyFactoryBean
Servlet integration: Spring provides deep integration with the Java Servlet API, including DispatcherServletserving as a front-end controller for handling web requests and supporting the construction of RESTful services.
Web Services Integration: Spring supports the development and integration of Web services, including SOAP and RESTful style services. The Spring Web Services framework simplifies the creation and management of web service endpoints.
Security integration: Spring Security is a sub-project of the Spring framework that provides powerful security support for authentication, authorization and security configuration. It can be integrated with J2EE container security mechanisms, such as role-based access control.
JNDI integration: Spring supports the integration of Java Naming and Directory Interface (JNDI), allowing developers to access and manage JNDI resources, such as data sources, message queues, etc.
Spring Boot: Spring Boot is a sub-project of the Spring ecosystem that greatly simplifies the development and deployment of Spring applications, including automatic configuration and embedded servers, making it easier for developers to build independent, self-contained J2EE applications.
Cloud native support: Spring Cloud is an ecosystem of Spring designed specifically for building cloud native applications and microservices. It provides integration of multiple cloud services, including service discovery, configuration management, load balancing, etc.
RMI integration: Spring supports remote method invocation (RMI) integration, allowing developers to create distributed applications and call remote object methods through RMI.
JMX integration: Spring supports Java Management Extensions (JMX) integration, allowing developers to expose Spring-managed beans as manageable MBeans to monitor and manage applications.
WebSocket integration: Spring provides support for WebSocket for building real-time web applications, allowing two-way communication between the server and client.
Spring Batch: Spring Batch is a sub-project of Spring used for developing batch applications. It supports large-scale data processing, job scheduling and error handling.
Spring Integration: Spring Integration is a sub-project of Spring used for building enterprise integration applications. It provides a modular way to handle message and event-driven integration.
Spring Data: Spring Data is a sub-project of Spring designed to simplify the development of data access layers. It supports multiple data storage technologies such as relational databases, NoSQL databases and search engines.
Spring WebFlux: Spring WebFlux is Spring's reactive programming model for building responsive web applications, suitable for high concurrency and low latency scenarios.
Spring Cloud Stream: Spring Cloud Stream is a sub-project of Spring for building event-driven microservice applications and provides integration with message brokers.
Spring Security OAuth: Spring Security OAuth is a sub-project of Spring that implements the OAuth 2.0 authorization protocol and is used to build secure authentication and authorization mechanisms.
Spring Boot Admin: An open source project used to monitor and manage Spring Boot applications, providing a visual management interface and real-time monitoring functions.
Spring Data Redis: A subproject of Spring that simplifies integration and operation with Redis databases.
Spring Cloud Config: A project for centrally managing configuration information and distributing it to multiple microservices.
Spring Cloud Sleuth: A project for distributed tracing and logging that helps solve troubleshooting problems in microservices architectures.
Spring Cloud Netflix: Integrates multiple open source projects developed by Netflix, including Eureka (service discovery), Zuul (API gateway), Hystrix (circuit breaker), etc.
Spring Security SAML: A Spring Security extension that supports Security Assertion Markup Language (SAML) for implementing single sign-on (SSO) and authentication.
Spring WebSocket: Spring's WebSocket support is used to build WebSocket applications for real-time two-way communication.
Spring Mobile: Spring extension that supports mobile devices to adapt to different mobile devices and browsers.
Spring Shell: A library for creating command line applications that makes it easy to build interactive command line interfaces.
Spring LDAP: Spring's LDAP (Lightweight Directory Access Protocol) integration for communicating with LDAP directories.
Spring AMQP: For integration with Advanced Message Queuing Protocol (AMQP)-compatible message middleware, supporting message publishing and subscription.
Spring Cloud Data Flow: A framework for building data integration and data flow processing, supporting data pipelines and batch processing.
Spring Retry: Spring's retry mechanism is used to handle the failure of method calls. Retry strategies and rollback strategies can be configured.
Spring Web Services Security: Security extension for Spring Web Services used to secure and encrypt web service communications.
Spring Social: A project that supports social media integration, allowing applications to interact with social media platforms.
Spring Kafka: A project used to integrate with Apache Kafka message middleware, supporting real-time data stream processing.
Spring Cloud Bus: A message bus for distributed applications for the propagation and refresh of configuration changes.
Spring Cloud Vault: For projects integrating with HashiCorp Vault for security and key management.
Spring Web Flow: A subproject of Spring for building process-based web applications, suitable for complex workflows.
Spring Cloud Contract: A tool for contract testing and verification between microservices, supporting contract-driven development.

Here I have listed so many Spring framework’s integration and support for J2EE services (detached small houses). In fact, this is just the tip of the iceberg. In general , the Spring framework provides extensive integration and support for Java enterprise applications. Support enables developers to easily integrate with J2EE services and technologies, while providing higher levels of abstraction and development tools to simplify complexity, improve maintainability, and promote the adoption of best practices. This makes Spring one of the preferred frameworks for building modern enterprise-level applications.

at last

Attached is the Spring learning material, you can pick it up yourself!

Spring learning books