Spring Boot
Lộ trình phát triển toàn diện Spring Boot theo tiêu chuẩn quốc tế nilbuild/developer-roadmap
Hướng dẫn từng bước từ nền tảng đến chuyên sâu giúp bạn làm chủ Spring Boot. Tích hợp tài liệu lý thuyết, bài viết thực chiến, video tham khảo và bài tập lập trình trực tiếp trên IDE.
Nền Tảng & Khái Niệm Cốt Lõi
Giai đoạn 1 tập trung hoàn thiện 12 chủ đề then chốt.
Actuators
Actuators are a set of built-in endpoints in Spring Boot that expose information about a running application, such as health status, metrics, environment properties, and active beans. They work as HTTP or JMX endpoints, like `/actuator/health` or `/actuator/metrics`, that can be enabled or disabled individually through configuration. Teams use actuators to monitor and manage applications in production without writing custom monitoring code.
Annotations
OAnnotations are metadata markers placed on classes, methods, or fields that tell Spring how to treat a piece of code, such as `@Component` to register a bean or `@Autowired` to inject a dependency. Spring Boot relies heavily on annotations to reduce configuration files, using ones like `@SpringBootApplication` to bootstrap an entire application with sensible defaults. They are processed at startup to wire beans, map requests, and configure behavior without extra boilerplate.
Architecture
Spring's architecture is built around a container that manages application objects, called beans, and wires their dependencies together. It follows a modular design, split into core modules for dependency injection, data access, web, and testing, so applications can use only the parts they need. Spring Boot builds on top of this architecture by adding auto-configuration and embedded servers, letting applications run with minimal setup.
Architecture
The Spring MVC (Model-View-Controller) is a web application framework that is part of the Spring Framework. It is designed to make it easy to build web applications using the MVC design pattern.
Authentication
Spring Security is a framework for securing Java-based applications. One of its core features is authentication, which is the process of verifying that a user is who they claim to be. Spring Security provides a wide range of options for implementing authentication, including support for traditional username/password-based authentication as well as more modern alternatives such as OAuth and JSON Web Tokens (JWT).
Authorization
Spring Security supports a variety of authentication mechanisms, such as username and password authentication, OAuth2, and more. Once a user is authenticated, Spring Security can then be used to authorize that user's access to specific resources or functionality. There are several annotations that can be used to control access to specific methods or classes.
Autoconfiguration
Spring Boot's Autoconfiguration is a powerful and convenient feature that makes it easy to configure beans and other components in your application based on the presence of certain dependencies and properties. It saves developer's time by reducing the need for boilerplate configuration code, and can be fine-tuned through properties and annotations, to provide a fine-grained control over the auto-configurations.
Cloud Config
Spring Cloud Config is a library for managing configuration properties for distributed applications. It allows developers to externalize configuration properties for an application, so that they can be easily changed without modifying the application's code. It also provides a centralized server for storing and managing configuration properties for multiple applications, making it easy to update and rollback configurations across different environments.
Components
The Spring MVC (Model-View-Controller) framework has several key components that work together to handle the requests and generate the appropriate responses in a web application. There are other supporting components that are used to manage the lifecycle of the application's objects, such as the Spring IoC container and different interceptors that provides additional functionality, such as caching and security.
Configuration
Spring Core Configuration is the process of configuring the Spring Framework, which involves specifying the various configuration details required for an application to function properly. This can include setting up beans, specifying bean dependencies, configuring aspect-oriented programming (AOP) aspects, and more. Configuration can be done through Java code, XML files, or using annotations in the code.
Dependency Injection
Spring Boot uses the Spring Framework's Inversion of Control (IoC) container to manage objects and their dependencies. The IoC container is responsible for creating objects, wiring them together, and managing their lifecycle. When an object is created, its dependencies are also created and injected into the object.
Embedded Server
Spring Boot's Embedded Server feature is a convenient and powerful feature that allows you to run a web server directly within your application, without the need to deploy it to a separate standalone web server. This makes it easy to develop, test, and deploy web applications, and it's also lightweight, easy to start and stop, and easy to configure.
Kỹ Năng Trọng Tâm & Thực Hành
Giai đoạn 2 tập trung hoàn thiện 12 chủ đề then chốt.
Entity lifecycle
Entity lifecycle describes the different states an object managed by Hibernate can go through: transient, persistent, detached, and removed. A transient entity exists only in memory and is not tracked by Hibernate, while a persistent entity is attached to a session and synchronized with the database. Knowing these states helps developers understand when changes to an object are actually saved, and when it needs to be reattached or merged back into a session.
Eureka
Eureka is a service discovery tool from Netflix, integrated into Spring Cloud, that lets microservices register themselves and find other services by name instead of hardcoded addresses. Each service instance registers with a Eureka server on startup and sends periodic heartbeats to confirm it is still available. Other services query the Eureka server to look up healthy instances of a service before making a request, which supports load balancing and failover.
Hibernate
Hibernate is a Java framework that provides an object-relational mapping to an object-oriented model to the relational database. It means hibernate provides from Java classes to database tables and also provides data querying and retrieval facility.
Introduction
Spring Boot is an extension of the Spring Framework that simplifies the creation of production-ready Java applications. It removes the need for manual configuration by providing sensible defaults, embedded servers, and auto-configuration based on the libraries present in the classpath. Developers use it to build stand-alone applications and microservices without writing large amounts of boilerplate setup code.
JPA Test
Spring JPA (Java Persistence API) is a library that makes it easy to work with databases and other data stores in a Spring application. Spring JPA uses the Java Persistence API (JPA) to interact with databases and provides an abstraction layer to work with different data stores.
JSP Files
JSP (JavaServer Pages) files are templates that mix HTML with Java code to generate dynamic web pages on the server before sending them to the browser. A JSP file is compiled into a servlet the first time it is requested, and its output is combined with data passed from a controller to render the final page. Spring MVC can use JSP as a view technology, though many modern applications favor other templating engines or return JSON instead of server-rendered pages.
JWT Authentication
Spring Security can be used to implement JWT Authentication and Authorization to your APIs. The library provides a JWT-based authentication filter that you can add to your API endpoints. The filter will check the JWT that is included in the request header, and if it is valid, it will set the authentication information in the security context. You can then use the security context to perform authorization checks on the API endpoints.
Micrometer
Micrometer is a vendor-neutral metrics facade for Java and the default metrics library in Spring Boot. It exposes application metrics — timers, gauges, counters, and histograms — through a unified API that can report to backends such as Prometheus, Datadog, or Graphite, and integrates with Spring Boot Actuator.
Microservices
Spring Microservices is a framework that makes it easier to build and manage microservices-based applications using the Spring Framework. Microservices is an architectural style in which a large application is built as a collection of small, independently deployable services. Each service has a narrowly defined responsibility and communicates with other services through APIs.
Mock MVC
Spring's MockMvc is a class that allows you to test Spring MVC controllers without the need for an actual web server. It is part of the Spring Test module, which provides a set of testing utilities for Spring applications.
@MockBean Annotation
`MockBean` is a Spring annotation that can be used to create a mock implementation of a bean in the Spring application context. When a test is annotated with MockBean, Spring creates a mock implementation of the specified bean and adds it to the application context. The mock bean can then be used to replace the real bean during testing.
OAuth2
Spring Security OAuth2 library provides support for both the authorization code grant type (for web apps) and the implicit grant type (for single-page apps). You can also use Spring Security to protect your resources and to configure your application as an OAuth2 resource server. The OAuth2 authentication process can be complex and time-consuming, but the Spring Security OAuth2 library makes it easy to get started by providing a set of convenient configuration classes and annotations.
Kiến Trúc Nâng Cao & Tối Ưu
Giai đoạn 3 tập trung hoàn thiện 12 chủ đề then chốt.
Relationships
Using hibernate, if we want to have relationship between two entities, there must exist a foreign key relationship between the tables, we call it as Referential integrity. The main advantage of having relationship between objects is, we can do operation on one object, and the same operation can transfer onto the other object in the database.
Servlet
A servlet is a Java class that handles requests and generates responses within a web server, following the Java Servlet API. It works by receiving an HTTP request from a servlet container, such as Tomcat, processing it through a `service` method, and writing back a response. Spring MVC builds on top of servlets, using a single central servlet, `DispatcherServlet`, to route requests to application code instead of requiring developers to write servlets directly.
Spring AOP
Spring AOP (Aspect-Oriented Programming) lets developers add behavior to existing code without changing it directly, by defining cross-cutting concerns like logging, security, or transaction management as separate aspects. It works by intercepting method calls through proxies and applying the extra logic before, after, or around the original method. Spring uses AOP internally for features such as `@Transactional`, and developers can define their own aspects for reusable functionality.
Spring Bean Scope
In the Spring Framework, a bean is an object that is instantiated, assembled, and managed by the Spring IoC container. One of the key features of the Spring container is its ability to manage the lifecycle of beans, which includes creating, configuring, and destroying beans as necessary. One way the container can control the lifecycle of a bean is by specifying its scope.
Spring Boot Starters
Spring Boot starters are a set of convenient dependency descriptors that you can include in your application. They provide a variety of functionality, such as security, data access, and web services, and help to minimize the amount of boilerplate code and configuration you need to write.
Circuit Breaker
Spring Cloud Circuit Breaker is a library for managing the fault tolerance of microservices-based applications using the Circuit Breaker pattern. The Circuit Breaker pattern is a design pattern that helps to prevent cascading failures and improve the resilience of distributed systems. It does this by introducing a "circuit breaker" proxy in front of a service that can detect when the service is unresponsive or has failed, and stop routing traffic to it temporarily, in order to allow the service to recover.
Spring Cloud Gateway
Spring Cloud Gateway is a Spring Framework library for building API gateways. An API gateway is a service that acts as an intermediary between an application and a set of microservices. The API gateway is responsible for request routing, composition, and protocol translation, among other things. It can also perform tasks such as authentication, rate limiting, and caching.
Spring Cloud OpenFeign
Spring Cloud OpenFeign is a library for creating declarative REST clients in Spring applications. It allows developers to easily make HTTP requests to other microservices or remote services, without having to manually write the low-level code to handle the requests and responses. OpenFeign is built on top of the OpenFeign declarative HTTP client, which is a simple, lightweight library for creating HTTP clients in Java.
Spring Cloud
Spring Cloud is a collection of libraries and tools for building cloud-native applications using the Spring Framework. It provides a set of abstractions and implementations for common patterns and best practices used in cloud-based applications, such as service discovery, configuration management, and circuit breaker patterns, among others.
Spring Data JDBC
Spring Data JDBC is a lightweight alternative to Spring Data JPA that maps Java objects to database tables using plain JDBC instead of a full ORM like Hibernate. It follows a simpler model, where entities are loaded and saved as a whole aggregate without lazy loading or a persistence context to track changes. Developers choose it when they want more predictable SQL behavior and less complexity than a full JPA implementation offers.
Spring Data JPA
Spring Data JPA is a library that makes it easy to implement Java Persistence API (JPA) based repositories (a fancy word for "DAO") for Spring applications. It's an abstraction on top of JPA that allows you to use a simpler and more convenient API for performing CRUD (Create, Read, Update, Delete) operations on databases. Spring Data JPA also provides additional functionality such as pagination, dynamic query generation, and more.
Spring Data Mongodb
Spring Data MongoDB is a module that provides an abstraction for working with MongoDB, a document-oriented NoSQL database, using the same repository pattern as other Spring Data modules. It maps Java objects to MongoDB documents and lets developers query data using repository method names or the `MongoTemplate` class for more complex operations. Applications use it to store and retrieve flexible, schema-less data without writing raw MongoDB driver code.
Hệ Sinh Thái & Triển Khai Thực Tế
Giai đoạn 4 tập trung hoàn thiện 10 chủ đề then chốt.
Spring Data
Spring Data is a collection of projects for data access in Spring-based applications. It provides a common interface for working with various types of data stores, including relational databases, NoSQL data stores, and cloud-based data services. The goal of Spring Data is to simplify data access in Spring applications by providing a consistent, high-level repository programming model across different data stores and data access technologies. This can help developers write less boilerplate code and focus on business logic, while still being able to take advantage of the full power of the underlying data store.
Spring IOC
Spring IOC (Inversion of Control) is the principle behind Spring's container, where the framework, not the application code, controls the creation and lifecycle of objects. The container reads configuration metadata, whether from annotations or XML, to know which beans to create and how to connect them. This approach lets developers focus on business logic while Spring handles object instantiation and wiring.
Spring MVC
Spring MVC is a web framework within Spring that follows the Model-View-Controller pattern to build web applications and REST APIs. A central component called `DispatcherServlet` receives incoming requests and routes them to the appropriate controller, which processes the request and returns a model and view or a JSON response. It handles common web concerns such as URL mapping, form binding, and validation, so developers can focus on writing controller and business logic.
Spring MVC
Spring MVC is a web framework built on the Servlet API that implements the Model-View-Controller design pattern to help developers build flexible and loosely coupled web applications. It provides a structured way to handle HTTP requests by using a central DispatcherServlet that routes incoming traffic to appropriate handler methods, which then process data and return a response, such as a rendered HTML view or raw JSON data.
Spring security
Spring Security is a framework for securing Java-based applications. It is a powerful and highly customizable authentication and access-control framework that can be easily integrated with a wide variety of applications, including web applications and RESTful web services. Spring Security provides a comprehensive security solution for both authentication and authorization, and it can be used to secure applications at both the web and method level.
@SpringBootTest annotation
`@SpringBootTest` This annotation is used to create a fully-configured instance of the Spring ApplicationContext for testing. It can be used to test the application's components, including controllers, services, and repositories, in a real application environment.
Terminology
Spring Boot terminology includes core concepts such as beans, application context, dependency injection, and auto-configuration. A bean is an object managed by the Spring container, while the application context is the environment that holds and wires these beans together. These terms appear throughout Spring documentation and describe how the framework organizes and manages application components.
Testing
Spring provides a set of testing utilities that make it easy to test the various components of a Spring application, including controllers, services, repositories, and other components. It has a rich set of testing annotations, utility classes and other features to aid in unit testing, integration testing and more.
Transactions
A transaction is a group of database operations that are executed as a single unit, so that either all of them succeed or none of them take effect. Spring manages transactions declaratively through the `@Transactional` annotation, which wraps a method in a transaction and rolls back changes if an exception occurs. This keeps data consistent even when multiple related operations, like debiting one account and crediting another, need to happen together.
Why Spring
Spring reduces the complexity of building Java applications by handling object creation, dependency wiring, and configuration through its container. It offers a consistent programming model across web, data access, security, and messaging, so teams do not need to combine unrelated libraries by hand. Companies use it because it scales from small services to large enterprise systems while keeping code testable and loosely coupled.