Skip to main content
Mapagam

56 SECTIONS · 1063 TOPICS

Spring Boot Roadmap

  1. Setting Up Spring Boot Projects

    1. 1. Creating Project with Spring Initializr
    2. Example: Generate project via curl
    3. 2. Using Spring Boot CLI
    4. 3. Configuring Maven Dependencies
    5. Example: Minimal pom.xml
    6. 4. Configuring Gradle Dependencies
    7. Example: build.gradle.kts
    8. 5. Setting Up Project Structure
    9. Recommended Package Layout
    10. 6. Configuring Application Main Class (@SpringBootApplication)
    11. Example: Main class with SpringApplication
    12. 7. Understanding Auto-Configuration Mechanism
    13. 8. Customizing Application Banner
    14. 9. Using Spring Boot DevTools
    15. Example: DevTools Maven dependency
    16. 10. Configuring Multi-Module Projects
    17. 11. Using Parent POM Inheritance
    18. 12. Managing Dependency Versions

  2. Working with Application Properties

    1. 1. Using application.properties File
    2. 2. Using application.yml Format
    3. Example: Equivalent YAML configuration
    4. 3. Understanding Property Precedence and Override Order
    5. 4. Using Profile-Specific Properties
    6. 5. Binding Properties with @Value Annotation
    7. Example: Constructor injection with @Value
    8. 6. Creating Type-Safe Configuration (@ConfigurationProperties)
    9. Example: ConfigurationProperties as record
    10. 7. Using Environment Variables and System Properties
    11. 8. Validating Configuration Properties (@Validated)
    12. Example: Validated configuration properties
    13. 9. Using Relaxed Binding Rules
    14. 10. Encrypting Sensitive Properties
    15. 11. Loading External Configuration Files
    16. 12. Using Random Values

  3. Managing Application Profiles

    1. 1. Creating Profile-Specific Configurations
    2. 2. Activating Profiles (spring.profiles.active)
    3. 3. Using Multiple Active Profiles
    4. Example: Activate multiple profiles
    5. 4. Setting Default Profile (spring.profiles.default)
    6. 5. Using @Profile Annotation on Beans
    7. Example: Profile-bound bean
    8. 6. Using Profile Groups (spring.profiles.group)
    9. Example: Profile groups for production and qa
    10. 7. Using Profile Expressions (!, &, |)
    11. 8. Loading Profile-Specific YAML Documents
    12. Example: Multi-document YAML per profile
    13. 9. Detecting Active Profiles Programmatically
    14. Example: Read active profiles from Environment
    15. 10. Testing with Specific Profiles (@ActiveProfiles)
    16. Example: Activate test profile

  4. Understanding Application Lifecycle

    1. 1. Understanding Spring Boot Startup Sequence
    2. Boot Startup Phases
    3. 2. Using ApplicationRunner and CommandLineRunner
    4. Example: Seed data on startup
    5. 3. Implementing ApplicationContextInitializer
    6. Example: Inject property source on context init
    7. 4. Using SmartLifecycle for Custom Lifecycle Management
    8. 5. Handling Application Ready Events (ApplicationReadyEvent)
    9. Example: Warm caches on ApplicationReadyEvent
    10. 6. Handling Application Started Events
    11. 7. Handling Context Refresh Events
    12. Example: Handle ContextRefreshedEvent
    13. 8. Implementing Graceful Shutdown
    14. Example: Graceful shutdown with timeout
    15. 9. Using Exit Codes (ExitCodeGenerator)
    16. Example: Custom exit code with ExitCodeGenerator
    17. 10. Configuring Startup Actuator Endpoint
    18. Example: Buffer startup steps for /actuator/startup

  5. Working with Dependency Injection

    1. 1. Understanding Inversion of Control (IoC Container)
    2. 2. Creating Beans with @Component Annotation
    3. 3. Creating Beans with @Service Annotation
    4. Example: Service bean with constructor injection
    5. 4. Creating Beans with @Repository Annotation
    6. 5. Creating Beans with @Controller and @RestController
    7. Example: @Controller returning a view
    8. Example: @RestController returning JSON
    9. 6. Injecting Dependencies with @Autowired
    10. 7. Using Constructor Injection
    11. Example: Multi-dependency constructor injection
    12. 8. Using Setter Injection
    13. Example: Optional setter injection
    14. 9. Using Field Injection
    15. 10. Resolving Multiple Beans (@Qualifier, @Primary)
    16. Example: Primary and qualifier for multiple caches
    17. 11. Understanding Bean Scopes
    18. 12. Using Lazy Initialization (@Lazy)

  6. Configuring Beans and Components

    1. 1. Creating Java Configuration Classes (@Configuration)
    2. 2. Defining Beans with @Bean Methods
    3. Example: @Bean with init and destroy lifecycle
    4. 3. Setting Bean Names and Aliases
    5. 4. Using @ComponentScan for Auto-Detection
    6. Example: Selective component scan with exclusion
    7. 5. Importing Configurations (@Import, @ImportResource)
    8. 6. Using Conditional Beans (@Conditional)
    9. Example: OS-conditional bean
    10. 7. Using @ConditionalOnProperty Annotation
    11. Example: Property-gated feature bean
    12. 8. Using @ConditionalOnClass and @ConditionalOnMissingClass
    13. 9. Using @ConditionalOnBean and @ConditionalOnMissingBean
    14. Example: Default bean when none present
    15. 10. Ordering Beans with @Order and @Priority
    16. 11. Customizing Bean Lifecycle (@PostConstruct, @PreDestroy)
    17. Example: Lifecycle hooks: warm up and flush
    18. 12. Using InitializingBean and DisposableBean Interfaces

  7. Building REST APIs

    1. 1. Creating REST Controllers (@RestController)
    2. Example: CRUD REST controller
    3. 2. Mapping HTTP Requests (@RequestMapping)
    4. 3. Using Specific HTTP Methods
    5. 4. Handling Path Variables (@PathVariable)
    6. Example: Multiple path variables
    7. 5. Handling Query Parameters (@RequestParam)
    8. 6. Handling Request Body (@RequestBody)
    9. Example: Validated request body with Location header
    10. 7. Returning Response Entity (ResponseEntity<T>)
    11. 8. Setting Response Status (@ResponseStatus)
    12. Example: @ResponseStatus on method and exception
    13. 9. Handling HTTP Headers
    14. 10. Using Content Negotiation
    15. 11. Implementing HATEOAS Links
    16. Example: HATEOAS self and collection links
    17. 12. Versioning REST APIs

  8. Handling Request and Response

    1. 1. Using @RequestBody for JSON Deserialization
    2. 2. Using @ResponseBody for JSON Serialization
    3. Example: @ResponseBody on @Controller method
    4. 3. Customizing Jackson ObjectMapper Configuration
    5. Example: Configure ObjectMapper with JavaTimeModule
    6. 4. Handling Date and Time Formats (@JsonFormat)
    7. Example: Format date-time field as ISO string
    8. 5. Ignoring Null Fields (@JsonInclude)
    9. 6. Using Custom Serializers and Deserializers
    10. Example: Custom serializer for value type
    11. 7. Working with Multipart File Uploads (MultipartFile)
    12. Example: Multipart file upload with path traversal guard
    13. 8. Configuring Max File Size
    14. Example: Multipart upload size limits
    15. 9. Handling Form Data (@ModelAttribute)
    16. Example: Form binding with validation
    17. 10. Using HttpServletRequest and HttpServletResponse
    18. 11. Using HttpEntity for Request/Response Handling
    19. Example: Echo request body with custom header

  9. Implementing Data Validation

    1. 1. Using Bean Validation API
    2. 2. Validating Request Body (@Valid, @Validated)
    3. Example: Validate request body
    4. 3. Using Standard Constraints
    5. 4. Using Numeric Constraints
    6. 5. Using Pattern Matching
    7. 6. Creating Custom Validators (ConstraintValidator)
    8. Example: Custom @ValidSku constraint annotation
    9. 7. Handling Validation Errors (BindingResult)
    10. Example: Return field validation errors as map
    11. 8. Customizing Validation Messages
    12. Example: Custom validation message bundle
    13. 9. Using Validation Groups
    14. Example: Validation groups for create vs update
    15. 10. Validating Nested Objects (@Valid on fields)
    16. Example: Nested object and list validation
    17. 11. Using @Validated for Method-Level Validation
    18. Example: Method-level validation on service

  10. Managing Exception Handling

    1. 1. Creating Global Exception Handlers (@ControllerAdvice)
    2. Example: Global exception handler with ProblemDetail
    3. 2. Handling Specific Exceptions (@ExceptionHandler)
    4. 3. Returning Custom Error Responses
    5. Example: Custom error response record
    6. 4. Using ResponseEntityExceptionHandler Base Class
    7. 5. Handling Validation Exceptions
    8. Example: Map validation errors to field messages
    9. 6. Handling HTTP Status Exceptions
    10. 7. Customizing Error Attributes (ErrorAttributes bean)
    11. Example: Inject trace ID into error attributes
    12. 8. Configuring Error Pages (ErrorController)
    13. 9. Logging Exceptions with Context Information
    14. Example: Log unhandled exception with trace context
    15. 10. Using Problem Details (RFC 7807)
    16. Example: RFC 7807 ProblemDetail with type URI
    17. 11. Handling Asynchronous Exception Handling

  11. Working with Spring Data JPA

    1. 1. Configuring Data Source Properties
    2. 2. Creating Entity Classes (@Entity, @Table)
    3. Example: JPA entity with index and audit timestamps
    4. 3. Defining Primary Keys
    5. 4. Mapping Columns (@Column annotations)
    6. 5. Defining Relationships
    7. 6. Creating Repository Interfaces
    8. Example: Repository with derived query methods
    9. 7. Using Derived Query Methods
    10. 8. Writing Custom JPQL Queries (@Query)
    11. Example: Custom JPQL select and update queries
    12. 9. Using Native SQL Queries
    13. Example: Native query with interface projection
    14. 10. Implementing Pagination (Pageable, Page<T>)
    15. Example: Paginate with sort
    16. 11. Implementing Sorting
    17. 12. Using Query by Example
    18. Example: Query by example with null ignore
    19. 13. Using Specifications for Dynamic Queries
    20. Example: Dynamic query with Specification

  12. Working with JPA Entity Relationships

    1. 1. Implementing One-to-One Relationships
    2. Example: Bidirectional one-to-one mapping
    3. 2. Implementing One-to-Many Relationships
    4. 3. Implementing Many-to-One Relationships
    5. Example: Many-to-one with lazy loading
    6. 4. Implementing Many-to-Many Relationships
    7. Example: Many-to-many with join table
    8. 5. Using Bidirectional Relationships
    9. 6. Using Cascade Operations
    10. 7. Configuring Fetch Types (LAZY vs EAGER)
    11. 8. Using @JoinColumn for Foreign Keys
    12. Example: JoinColumn with named FK constraint
    13. 9. Using @JoinTable for Join Tables
    14. 10. Handling Orphan Removal
    15. Example: Cascade delete with orphan removal
    16. 11. Using @EntityGraph for Fetch Optimization
    17. Example: Entity graph to avoid N+1

  13. Working with JPA Entity Lifecycle

    1. 1. Understanding Entity States
    2. Entity State Transitions
    3. 2. Using Lifecycle Callbacks (@PrePersist, @PostPersist)
    4. Example: Auto-set timestamp and UUID on pre-persist
    5. 3. Using @PreUpdate and @PostUpdate Callbacks
    6. 4. Using @PreRemove and @PostRemove Callbacks
    7. Example: Clean up file on entity removal
    8. 5. Using @PostLoad Callback
    9. 6. Creating Entity Listeners (@EntityListeners)
    10. Example: Entity listener for audit events
    11. 7. Using Auditing (@CreatedDate, @LastModifiedDate)
    12. Example: Audit base entity with Spring Data auditing
    13. 8. Enabling JPA Auditing (@EnableJpaAuditing)
    14. 9. Using @CreatedBy and @LastModifiedBy
    15. Example: Current user from SecurityContext for auditing
    16. 10. Implementing Custom Auditing Logic

  14. Working with Transactions

    1. 1. Understanding Transaction Management (@Transactional)
    2. Example: Transactional money transfer
    3. 2. Configuring Transaction Propagation
    4. 3. Setting Transaction Isolation Levels
    5. 4. Configuring Transaction Timeout
    6. Example: Transaction with timeout
    7. 5. Handling Read-Only Transactions
    8. 6. Rolling Back Transactions
    9. Example: Rollback rules and programmatic rollback
    10. 7. Using Programmatic Transactions (TransactionTemplate)
    11. Example: Programmatic REQUIRES_NEW transaction
    12. 8. Understanding Transaction Boundaries
    13. 9. Handling Distributed Transactions (JTA)
    14. 10. Using @Lock for Pessimistic Locking
    15. Example: Pessimistic write lock query
    16. 11. Using @Version for Optimistic Locking
    17. Example: Optimistic lock with @Version
    18. 12. Optimizing Transaction Performance

  15. Managing Database Migrations

    1. 1. Configuring Flyway Migration Tool
    2. 2. Creating Flyway Migration Scripts
    3. Example: Flyway migration: create users table
    4. 3. Using Flyway Callbacks and Placeholders
    5. Example: Flyway schema placeholder
    6. 4. Configuring Liquibase Migration Tool
    7. 5. Creating Liquibase Changesets
    8. Example: Liquibase changeset for users table
    9. 6. Using Liquibase Contexts and Labels
    10. 7. Rolling Back Migrations (Liquibase)
    11. 8. Validating Migration Scripts
    12. 9. Using Baseline on Existing Databases
    13. Example: Flyway baseline for existing schema
    14. 10. Generating DDL from JPA Entities
    15. 11. Using Flyway vs Liquibase Comparison
    16. Flyway
    17. Liquibase

  16. Working with Spring Data REST

    1. 1. Adding Spring Data REST Dependencies
    2. Example: Spring Data REST dependency
    3. 2. Exposing Repository REST Endpoints
    4. Example: Auto-exposed REST repository
    5. 3. Customizing Base Path
    6. Example: Configure Data REST base path
    7. 4. Customizing Resource Names (@RepositoryRestResource)
    8. Example: Custom path, rel, and hide endpoint
    9. 5. Handling Projections and Excerpts
    10. Example: Projection with computed SpEL field
    11. 6. Implementing Custom Handlers (@RepositoryEventHandler)
    12. Example: Auto-assign UUID before create
    13. 7. Securing REST Endpoints
    14. Example: Method-level security on repository
    15. 8. Configuring CORS for REST APIs
    16. 9. Customizing HAL Response Format
    17. 10. Using Search Resources
    18. Example: Expose search endpoint by last name
    19. 11. Pagination and Sorting in Data REST

  17. Implementing Spring Security

    1. 1. Adding Spring Security Dependencies
    2. Example: Spring Security dependencies
    3. 2. Configuring Security Filter Chain
    4. Example: Stateless JWT security filter chain
    5. 3. Using In-Memory Authentication
    6. Example: In-memory users with encoded passwords
    7. 4. Using JDBC Authentication
    8. Example: JDBC-backed user details
    9. 5. Implementing UserDetailsService Interface
    10. Example: Load user from database
    11. 6. Configuring Password Encoders
    12. Example: Delegating password encoder
    13. 7. Securing Endpoints with HTTP Security
    14. 8. Using Method-Level Security
    15. Example: Method security: role and ownership check
    16. 9. Configuring CORS
    17. Example: CORS configuration source bean
    18. 10. Implementing CSRF Protection
    19. 11. Configuring Session Management
    20. 12. Using Security Context (SecurityContextHolder)
    21. Example: Read username and roles from context

  18. Working with JWT Authentication

    1. 1. Understanding JWT Structure
    2. JWT Anatomy
    3. 2. Creating JWT Tokens
    4. Example: Issue JWT with claims and expiry
    5. 3. Validating and Parsing JWT Tokens
    6. Example: JWT decoder with secret key
    7. 4. Implementing JWT Authentication Filter
    8. Example: Configure JWT resource server
    9. 5. Configuring Token Expiration and Refresh
    10. 6. Storing User Details in JWT Claims
    11. Example: Map roles claim to authorities
    12. 7. Handling Token-Based Authorization
    13. Example: Access JWT claims in controller
    14. 8. Implementing Refresh Token Mechanism
    15. Refresh Token Rotation
    16. 9. Securing JWT Secret Keys
    17. 10. Handling Token Revocation Strategies
    18. 11. Using RS256 vs HS256 Algorithms
    19. HS256 (HMAC-SHA256)
    20. RS256 (RSA-SHA256)

  19. Implementing OAuth 2.0 and OpenID Connect

    1. 1. Understanding OAuth 2.0 Flow Types
    2. 2. Configuring OAuth 2.0 Client
    3. Example: OAuth2 client dependency
    4. 3. Registering OAuth 2.0 Providers
    5. Example: Register Google OAuth2 provider
    6. 4. Implementing Authorization Code Flow
    7. Authorization Code Flow
    8. 5. Using OAuth 2.0 Login (oauth2Login())
    9. Example: Enable OAuth2 login with redirect
    10. 6. Accessing Protected Resources
    11. Example: Access OAuth2 token and OIDC user info
    12. 7. Implementing Resource Server
    13. Example: Resource server with JWKS URI
    14. 8. Validating JWT Access Tokens
    15. 9. Configuring OIDC User Info Endpoint
    16. 10. Customizing OAuth 2.0 Success/Failure Handlers
    17. Example: Custom OAuth2 success and failure handlers
    18. 11. Implementing Social Login Integration

  20. Working with Caching

    1. 1. Enabling Caching Support (@EnableCaching)
    2. Example: Enable caching support
    3. 2. Using @Cacheable for Method Results
    4. Example: Cache method result with condition
    5. 3. Using @CachePut for Cache Updates
    6. 4. Using @CacheEvict for Cache Removal
    7. Example: Evict by key and clear all entries
    8. 5. Configuring Cache Names and Keys
    9. 6. Using SpEL in Cache Annotations
    10. 7. Configuring Simple Cache Provider
    11. Example: Simple in-memory cache configuration
    12. 8. Integrating Redis Cache
    13. Example: Redis cache with TTL and JSON serializer
    14. Example: Redis cache type and connection
    15. 9. Integrating Caffeine Cache
    16. Example: Caffeine cache with size and expiry spec
    17. 10. Configuring Cache Expiration and TTL
    18. 11. Using @Caching for Multiple Operations
    19. Example: Combined cache put and evict
    20. 12. Implementing Custom Cache Manager
    21. Example: Two-level Caffeine + Redis cache manager

  21. Implementing Asynchronous Processing

    1. 1. Enabling Async Support (@EnableAsync)
    2. Example: Enable async execution
    3. 2. Creating Async Methods (@Async)
    4. Example: Async email with CompletableFuture
    5. 3. Returning Future and CompletableFuture
    6. 4. Configuring Thread Pool Executor (TaskExecutor)
    7. Example: Thread pool executor for email tasks
    8. Example: Async task pool configuration
    9. 5. Handling Async Exceptions
    10. Example: Handle uncaught async exceptions
    11. 6. Using @Async with Transactions
    12. 7. Implementing Async REST Endpoints
    13. Example: DeferredResult and Callable endpoint
    14. 8. Using WebAsyncTask for Timeouts
    15. Example: Async task with per-request timeout
    16. 9. Configuring Async Request Processing
    17. 10. Using ListenableFuture for Callbacks
    18. 11. Testing Async Methods
    19. Example: Test async method with Awaitility

  22. Working with Scheduled Tasks

    1. 1. Enabling Scheduling (@EnableScheduling)
    2. Example: Enable task scheduling
    3. 2. Creating Scheduled Methods (@Scheduled)
    4. 3. Using Fixed Rate Execution
    5. Example: Fixed-rate scheduled task
    6. 4. Using Fixed Delay Execution
    7. Example: Fixed-delay with initial delay
    8. 5. Using Cron Expressions
    9. Example: Cron expressions with timezone
    10. 6. Configuring Initial Delay
    11. 7. Using Dynamic Scheduling (SchedulingConfigurer)
    12. Example: Dynamic cron from configuration
    13. 8. Configuring Task Scheduler Pool Size
    14. Example: Scheduler pool size configuration
    15. 9. Handling Scheduled Task Exceptions
    16. Example: Safe scheduled task with error logging
    17. 10. Using Time Zones in Cron Expressions
    18. 11. Testing Scheduled Tasks

  23. Working with Events and Listeners

    1. 1. Creating Custom Application Events
    2. Example: POJO event and legacy ApplicationEvent
    3. 2. Publishing Events (ApplicationEventPublisher)
    4. Example: Publish domain event after save
    5. 3. Creating Event Listeners (@EventListener)
    6. Example: Listen for domain event
    7. 4. Using Conditional Event Listening
    8. Example: Conditional event listener with SpEL
    9. 5. Implementing Async Event Handling
    10. Example: Async event handler
    11. 6. Ordering Event Listeners (@Order)
    12. 7. Using Transaction-Bound Events (@TransactionalEventListener)
    13. Example: Post-commit transactional event listener
    14. 8. Listening to Built-in Spring Events
    15. 9. Creating Generic Events (ResolvableTypeProvider)
    16. Example: Generic typed event with ResolvableType
    17. 10. Testing Event Publishing and Handling
    18. Example: Assert published events in test

  24. Implementing Messaging with RabbitMQ

    1. 1. Adding RabbitMQ Dependencies
    2. Example: RabbitMQ AMQP dependency
    3. 2. Configuring RabbitMQ Connection Properties
    4. 3. Creating RabbitTemplate for Sending Messages
    5. Example: Publish message with RabbitTemplate
    6. 4. Defining Queues, Exchanges, and Bindings
    7. Example: Declare queue, exchange, and binding
    8. 5. Sending Messages to Queues (convertAndSend)
    9. Example: Send message with headers and TTL
    10. 6. Creating Message Listeners (@RabbitListener)
    11. Example: Consume messages with concurrency
    12. 7. Configuring Message Converters (Jackson2JsonMessageConverter)
    13. Example: Configure JSON message converter
    14. 8. Handling Message Acknowledgments
    15. Example: Manual acknowledgement mode
    16. 9. Implementing Dead Letter Queues
    17. Example: Dead letter queue configuration
    18. 10. Using Message Properties and Headers
    19. 11. Configuring Retry and Error Handling
    20. Example: Retry with exponential backoff
    21. 12. Using Publisher Confirms and Returns
    22. Example: Publisher confirm and return callbacks

  25. Implementing Messaging with Kafka

    1. 1. Adding Kafka Dependencies
    2. Example: Kafka dependency
    3. 2. Configuring Kafka Producer Properties
    4. Example: Kafka producer with idempotence
    5. 3. Configuring Kafka Consumer Properties
    6. Example: Kafka consumer with manual commit
    7. 4. Creating KafkaTemplate for Sending Messages
    8. Example: Send Kafka message with result callback
    9. 5. Sending Messages to Topics
    10. 6. Creating Kafka Listeners (@KafkaListener)
    11. Example: Consume Kafka record with manual ack
    12. 7. Configuring Consumer Groups
    13. 8. Handling Message Serialization
    14. 9. Managing Offset Commits
    15. 10. Implementing Error Handlers and Retry
    16. Example: Kafka dead letter publisher on failure
    17. 11. Using Kafka Headers and Timestamps
    18. Example: Access Kafka headers in listener
    19. 12. Using Kafka Streams for Processing
    20. Example: Kafka Streams filter to high-value topic

  26. Working with WebSockets

    1. 1. Adding WebSocket Dependencies
    2. Example: WebSocket dependency
    3. 2. Configuring WebSocket Message Broker
    4. Example: Configure STOMP broker over SockJS
    5. 3. Registering STOMP Endpoints
    6. 4. Configuring Message Broker
    7. Example: External RabbitMQ STOMP relay
    8. 5. Creating Message Handlers (@MessageMapping)
    9. Example: Chat message handler with @MessageMapping
    10. 6. Sending Messages to Clients (@SendTo)
    11. 7. Using SimpMessagingTemplate for Broadcasting
    12. Example: Broadcast and user-specific messaging
    13. 8. Handling User-Specific Messages (@SendToUser)
    14. Example: Send reply to user private queue
    15. 9. Implementing WebSocket Interceptors
    16. Example: Authenticate STOMP CONNECT with token
    17. 10. Handling WebSocket Events
    18. 11. Securing WebSocket Endpoints
    19. Example: WebSocket authorization by destination

  27. Building Reactive Applications with WebFlux

    1. 1. Adding Spring WebFlux Dependencies
    2. Example: WebFlux dependency
    3. 2. Understanding Reactive Streams
    4. 3. Using Mono for Single Values
    5. Example: Mono: map and default value
    6. 4. Using Flux for Multiple Values
    7. Example: Flux: filter and limit stream
    8. 5. Creating Reactive REST Controllers
    9. Example: Reactive CRUD controller
    10. 6. Implementing Reactive Repositories
    11. 7. Using Reactive Database Drivers (R2DBC)
    12. Example: R2DBC datasource configuration
    13. 8. Handling Backpressure Strategies
    14. 9. Implementing Server-Sent Events
    15. Example: Server-sent events stream with Flux
    16. 10. Testing Reactive Endpoints (WebTestClient)
    17. Example: Test reactive endpoint with WebTestClient
    18. 11. Using Reactive Operators

  28. Working with Reactive Data Access

    1. 1. Configuring R2DBC Data Source
    2. 2. Creating Reactive Entities (@Table)
    3. Example: R2DBC entity as record
    4. 3. Using ReactiveCrudRepository Interface
    5. Example: Reactive repository with Mono and Flux
    6. 4. Writing Custom Reactive Queries (@Query)
    7. Example: Reactive custom JPQL select and update
    8. 5. Implementing Pagination (Pageable)
    9. Example: Reactive pagination
    10. 6. Using Database Client (DatabaseClient)
    11. Example: Raw SQL query with DatabaseClient
    12. 7. Handling Transactions (TransactionalOperator)
    13. Example: Reactive transactional operator
    14. 8. Implementing Reactive Specifications
    15. 9. Using Reactive Caching
    16. Example: Reactive Redis cache-aside pattern
    17. 10. Testing Reactive Repositories (StepVerifier)
    18. Example: Test reactive repo with StepVerifier
    19. 11. Using R2DBC vs JDBC Comparison
    20. JDBC + JPA
    21. R2DBC

  29. Implementing File Storage and Handling

    1. 1. Configuring File Upload Properties
    2. 2. Handling Multipart File Uploads
    3. Example: Reactive multipart file info
    4. 3. Saving Files to Local Filesystem
    5. Example: Save file with path traversal guard
    6. 4. Generating Unique Filenames (UUID)
    7. 5. Serving Static Files
    8. Example: Serve uploaded files as static resource
    9. 6. Implementing File Download Endpoints
    10. Example: File download with Content-Disposition header
    11. 7. Streaming Large Files
    12. Example: Stream large file to response
    13. 8. Integrating AWS S3 for Cloud Storage
    14. Example: Upload to S3 and generate presigned URL
    15. 9. Using Spring Content for File Management
    16. 10. Validating File Types and Sizes
    17. Example: Validate file type and size
    18. 11. Implementing File Compression
    19. Example: Stream files as ZIP archive

  30. Working with Email Services

    1. 1. Configuring JavaMailSender Properties (SMTP)
    2. Example: SMTP mail server configuration
    3. 2. Sending Simple Text Emails
    4. Example: Send plain text email
    5. 3. Sending HTML Emails (MimeMessage)
    6. Example: Send HTML email with MimeMessage
    7. 4. Using Thymeleaf for Email Templates
    8. Example: Render Thymeleaf email template
    9. 5. Adding Email Attachments
    10. Example: Email attachment and inline image
    11. 6. Sending Emails Asynchronously (@Async)
    12. Example: Send email asynchronously
    13. 7. Configuring Email Authentication
    14. 8. Using Gmail SMTP Server
    15. 9. Handling Email Sending Exceptions
    16. Example: Handle mail send exceptions
    17. 10. Testing Email Functionality (GreenMail)
    18. Example: Test email sending with GreenMail

  31. Working with Template Engines

    1. 1. Configuring Thymeleaf Template Engine
    2. Example: Thymeleaf dependency
    3. 2. Creating Thymeleaf Templates
    4. Example: Basic Thymeleaf template
    5. 3. Using Thymeleaf Expressions
    6. 4. Iterating Collections (th:each)
    7. Example: Iterate list with row status
    8. 5. Conditional Rendering (th:if, th:unless)
    9. 6. Including Fragments (th:fragment, th:replace, th:insert)
    10. Example: Fragment include across templates
    11. 7. Handling Form Binding (th:object, th:field)
    12. Example: Form binding with th:object and th:field
    13. 8. Using FreeMarker as Alternative
    14. Example: FreeMarker template syntax
    15. 9. Using Mustache Templates
    16. 10. Customizing Template Resolver Configuration
    17. Example: Custom template resolver for email

  32. Implementing Internationalization (i18n)

    1. 1. Configuring Message Sources (MessageSource)
    2. Example: Configure reloadable message source
    3. 2. Creating Message Properties Files
    4. Example: Message bundle with plural form
    5. 3. Creating Locale-Specific Files
    6. 4. Resolving Locale (LocaleResolver)
    7. 5. Using Accept-Language Header
    8. Example: Locale from Accept-Language header
    9. 6. Using Session/Cookie Locale Resolver
    10. Example: Locale stored in cookie
    11. 7. Accessing Messages in Controllers
    12. Example: Resolve i18n message in controller
    13. 8. Using Message Keys in Templates
    14. Example: Use message key in Thymeleaf template
    15. 9. Implementing Locale Change Interceptor
    16. Example: Change locale via query parameter
    17. 10. Formatting Dates and Numbers by Locale
    18. 11. Implementing URL-Based Locale Resolution
    19. Example: Resolve locale from URL path segment

  33. Implementing Logging

    1. 1. Understanding Spring Boot Logging Defaults (Logback)
    2. 2. Configuring Log Levels
    3. Example: Log level per package
    4. 3. Using SLF4J Logger Interface
    5. Example: SLF4J parameterised logging
    6. 4. Logging with Different Levels
    7. 5. Configuring Logback XML
    8. Example: Logback JSON encoder for production
    9. 6. Using Log4j2 as Alternative
    10. Example: Switch logging to Log4j2
    11. 7. Logging to Files
    12. Example: Log to file with rolling pattern
    13. 8. Configuring Log Rotation and Archiving
    14. 9. Using MDC for Contextual Logging
    15. Example: Propagate trace ID with MDC filter
    16. 10. Logging HTTP Requests and Responses
    17. 11. Integrating with ELK Stack
    18. ELK Pipeline
    19. 12. Using Structured Logging
    20. Example: Logstash encoder dependency
    21. Example: Structured key-value log entry

  34. Working with Actuator Endpoints

    1. 1. Adding Spring Boot Actuator Dependency
    2. Example: Actuator dependency
    3. 2. Exposing Actuator Endpoints
    4. Example: Expose and configure actuator endpoints
    5. 3. Using Health Endpoint (/actuator/health)
    6. 4. Using Info Endpoint (/actuator/info)
    7. Example: Info endpoint with git and build metadata
    8. 5. Using Metrics Endpoint (/actuator/metrics)
    9. 6. Using Env Endpoint (/actuator/env)
    10. 7. Using Loggers Endpoint (/actuator/loggers)
    11. Example: Change log level at runtime via actuator
    12. 8. Using Thread Dump Endpoint
    13. 9. Using Heap Dump Endpoint
    14. 10. Using Beans Endpoint
    15. 11. Creating Custom Health Indicators
    16. Example: Custom health indicator with latency detail
    17. 12. Creating Custom Metrics (MeterRegistry)
    18. Example: Custom counter and timer metrics
    19. 13. Securing Actuator Endpoints
    20. Example: Restrict actuator to ADMIN role

  35. Implementing Monitoring and Observability

    1. 1. Integrating Micrometer for Metrics
    2. 2. Configuring Prometheus Endpoint
    3. Example: Prometheus registry dependency
    4. Example: Prometheus endpoint with application tags
    5. 3. Exporting Metrics to Grafana
    6. Metrics Pipeline
    7. 4. Using Spring Boot Admin for Monitoring
    8. 5. Implementing Distributed Tracing (Micrometer Tracing)
    9. Example: OpenTelemetry tracing dependencies
    10. Example: Configure trace sampling and OTLP collector
    11. 6. Integrating with Zipkin for Trace Visualization
    12. 7. Configuring APM Tools
    13. 8. Monitoring JVM Metrics
    14. 9. Creating Custom Actuator Endpoints
    15. Example: Custom actuator endpoint with read and write operations
    16. 10. Using Liveness and Readiness Probes
    17. Example: Enable liveness and readiness probes
    18. 11. Implementing Custom Metrics with Tags
    19. Example: Counter metric with endpoint and status tags

  36. Implementing API Documentation

    1. 1. Adding Springdoc OpenAPI Dependencies
    2. Example: Springdoc OpenAPI / Swagger UI dependency
    3. 2. Accessing Swagger UI
    4. 3. Accessing OpenAPI JSON
    5. Example: Configure Swagger UI path and options
    6. 4. Customizing API Info (@OpenAPIDefinition)
    7. Example: API info with contact and server definition
    8. 5. Documenting Operations
    9. Example: Document operation with response codes
    10. 6. Documenting Parameters
    11. Example: Document path parameter
    12. 7. Documenting Request/Response Models
    13. Example: Document response model with @Schema
    14. 8. Grouping APIs with Tags
    15. Example: Tag controller and group API paths
    16. 9. Adding Security Schemes
    17. Example: Bearer JWT security scheme
    18. 10. Customizing Swagger UI Configuration
    19. 11. Excluding Endpoints from Documentation
    20. Example: Hide internal endpoints from Swagger
    21. 12. Using Springdoc vs Springfox Comparison
    22. Springdoc
    23. Springfox

  37. Working with Testing

    1. 1. Using @SpringBootTest for Integration Tests
    2. Example: Integration test with MockMvc
    3. 2. Using @WebMvcTest for Controller Tests
    4. Example: Slice test for controller layer
    5. 3. Using @DataJpaTest for Repository Tests
    6. Example: Repository test against real database
    7. 4. Using @MockBean for Mocking Dependencies
    8. 5. Using MockMvc for REST API Testing
    9. 6. Testing with TestRestTemplate
    10. Example: HTTP client integration test
    11. 7. Using @Sql for Test Data Setup
    12. Example: Load and clean SQL test data
    13. 8. Configuring Test Properties (@TestPropertySource)
    14. Example: Override properties in test
    15. 9. Using Test Slices
    16. 10. Testing Security with @WithMockUser
    17. Example: Security test with mock user and JWT
    18. 11. Writing Unit Tests with JUnit 5 and Mockito
    19. Example: Unit test with Mockito mocks
    20. 12. Using Testcontainers for Integration Tests
    21. Example: Testcontainers with dynamic properties
    22. 13. Testing Async Methods and Events

  38. Implementing Request Filtering and Interception

    1. 1. Creating Servlet Filters (Filter interface)
    2. Example: Request timing filter
    3. 2. Registering Filters with FilterRegistrationBean
    4. Example: Register filter for /api/* with order
    5. 3. Ordering Multiple Filters (@Order)
    6. 4. Creating HandlerInterceptors
    7. Example: Audit interceptor recording start time
    8. 5. Registering Interceptors
    9. Example: Register interceptor with path exclusion
    10. 6. Using preHandle, postHandle, afterCompletion
    11. 7. Implementing Request Logging Filter
    12. Example: Configure Commons request logging filter
    13. 8. Implementing CORS Filter
    14. Example: CORS filter bean
    15. 9. Implementing Rate Limiting Filter
    16. Example: Per-IP rate limit filter with Bucket4j
    17. 10. Handling Filter Exceptions
    18. 11. Using OncePerRequestFilter for Single Execution

  39. Implementing Custom Annotations

    1. 1. Creating Custom Annotations (@interface)
    2. Example: Custom @Auditable meta-annotation
    3. 2. Using Meta-Annotations
    4. 3. Implementing Annotation Processors
    5. 4. Using AOP for Annotation Processing (@Aspect)
    6. Example: AOP audit advice with execution time
    7. 5. Creating Validation Annotations
    8. Example: @StrongPassword validation annotation
    9. 6. Creating Security Annotations
    10. Example: Composed @AdminOrOwner security annotation
    11. 7. Creating Logging Annotations
    12. Example: Log execution time with AOP aspect
    13. 8. Using SpEL in Custom Annotations
    14. Example: SpEL key evaluation in rate limit aspect
    15. 9. Combining Multiple Annotations (@AliasFor)
    16. Example: @AliasFor composed request mapping annotation
    17. 10. Testing Custom Annotations

  40. Working with Aspect-Oriented Programming

    1. 1. Enabling AspectJ Support (@EnableAspectJAutoProxy)
    2. Example: Enable AspectJ auto-proxy
    3. 2. Creating Aspect Classes (@Aspect, @Component)
    4. Example: Aspect bean with ordering
    5. 3. Defining Pointcut Expressions (@Pointcut)
    6. Example: Service method pointcut expression
    7. 4. Implementing Before Advice (@Before)
    8. Example: Before advice: log method entry
    9. 5. Implementing After Advice
    10. Example: After-returning and after-throwing advice
    11. 6. Implementing Around Advice (@Around)
    12. Example: Around advice: measure execution time
    13. 7. Accessing Method Parameters (JoinPoint)
    14. 8. Ordering Multiple Aspects (@Order)
    15. 9. Implementing Cross-Cutting Concerns
    16. 10. Using AspectJ Weaving
    17. Spring AOP (Proxy)
    18. AspectJ (Weaving)
    19. 11. Using this() vs target() in Pointcuts

  41. Implementing Batch Processing

    1. 1. Adding Spring Batch Dependencies (spring-boot-starter-batch)
    2. Example: Spring Batch dependency
    3. 2. Enabling Batch Processing (@EnableBatchProcessing)
    4. Example: Batch application entry point
    5. 3. Creating Job Configuration (Job, Step)
    6. Example: Job and chunk-oriented step
    7. 4. Implementing ItemReader for Data Input
    8. 5. Implementing ItemProcessor for Data Transformation
    9. Example: Normalize and filter items in processor
    10. 6. Implementing ItemWriter for Data Output
    11. Example: Batch writer using JPA repository
    12. 7. Configuring Chunk-Oriented Processing
    13. 8. Using FlatFileItemReader for CSV/TXT
    14. Example: Read CSV with FlatFileItemReader
    15. 9. Using JdbcBatchItemWriter for Database
    16. Example: Batch JDBC writer with named parameters
    17. 10. Implementing Job Parameters (JobParameters)
    18. Example: Build and run job with parameters
    19. 11. Scheduling Batch Jobs (@Scheduled)
    20. Example: Schedule nightly batch job
    21. 12. Monitoring Batch Job Execution (JobRepository)
    22. 13. Implementing Skip and Retry Logic
    23. Example: Fault-tolerant step with skip and retry

  42. Working with GraphQL

    1. 1. Adding Spring GraphQL Dependencies (spring-boot-starter-graphql)
    2. Example: GraphQL starter dependencies
    3. 2. Defining GraphQL Schema (schema.graphqls)
    4. Example: GraphQL schema: types, queries, mutations
    5. 3. Creating Query Resolvers (@QueryMapping)
    6. Example: Query resolvers for book and books
    7. 4. Creating Mutation Resolvers (@MutationMapping)
    8. Example: Mutation resolver: add book
    9. 5. Implementing Data Fetchers (DataFetcher)
    10. Example: Field resolver for book author
    11. 6. Handling Arguments (@Argument)
    12. 7. Using GraphQL Context (GraphQLContext)
    13. Example: Inject user into GraphQL context
    14. 8. Implementing Pagination (Connection pattern)
    15. Example: Cursor-based pagination schema
    16. 9. Implementing Error Handling (GraphQLError)
    17. Example: GraphQL exception resolver
    18. 10. Testing GraphQL Endpoints (GraphQlTester)
    19. Example: Test GraphQL query with GraphQlTester
    20. 11. Integrating with GraphiQL UI
    21. Example: Enable GraphiQL browser UI
    22. 12. Implementing Subscriptions for Real-Time Updates
    23. Example: GraphQL subscription with Flux

  43. Implementing gRPC Services

    1. 1. Adding gRPC Dependencies (grpc-spring-boot-starter)
    2. Example: gRPC server dependency
    3. 2. Defining Protocol Buffers (.proto files)
    4. Example: Proto definition for GreeterService
    5. 3. Generating Java Classes from Proto Files
    6. Example: Protobuf Maven plugin
    7. 4. Creating gRPC Server Services (@GrpcService)
    8. Example: Unary gRPC service implementation
    9. 5. Implementing Unary RPC Methods
    10. 6. Implementing Server Streaming RPC
    11. Example: Server-streaming RPC
    12. 7. Implementing Client Streaming RPC
    13. Example: Client-streaming RPC
    14. 8. Implementing Bidirectional Streaming RPC
    15. Example: Bidirectional streaming RPC
    16. 9. Creating gRPC Clients (gRPC stubs)
    17. Example: gRPC client with blocking stub
    18. 10. Handling gRPC Exceptions and Status Codes
    19. Example: Return gRPC NOT_FOUND status
    20. 11. Implementing gRPC Interceptors
    21. Example: Global gRPC server interceptor

  44. Working with Multiple Data Sources

    1. 1. Configuring Primary Data Source
    2. Example: Primary and secondary datasource config
    3. 2. Configuring Secondary Data Source
    4. Example: Multiple DataSource beans
    5. 3. Creating Multiple EntityManagerFactory Beans
    6. Example: Multiple EntityManagerFactory beans
    7. 4. Creating Multiple TransactionManager Beans
    8. Example: Multiple transaction managers
    9. 5. Separating Entity Packages by Data Source
    10. 6. Using @Primary for Default Data Source
    11. 7. Configuring JPA Repositories for Each Data Source
    12. Example: Route repositories to separate data sources
    13. 8. Handling Transactions Across Data Sources
    14. 9. Using Routing Data Sources (AbstractRoutingDataSource)
    15. Example: Routing DataSource by ThreadLocal key
    16. 10. Testing Multiple Data Sources

  45. Working with External APIs

    1. 1. Creating RestTemplate for HTTP Requests
    2. Example: RestTemplate with timeout and base URL
    3. 2. Using WebClient for Reactive HTTP Requests
    4. Example: WebClient for reactive HTTP calls
    5. 3. Using RestClient for Modern HTTP Requests
    6. Example: RestClient for synchronous HTTP calls
    7. 4. Configuring Connection Timeouts
    8. 5. Handling HTTP Response Codes
    9. Example: Handle 4xx and 5xx with custom exceptions
    10. 6. Using RestTemplate Interceptors
    11. Example: Add bearer auth header via interceptor
    12. 7. Implementing Retry Logic for Failed Requests
    13. Example: Retry with backoff and recover fallback
    14. 8. Using Circuit Breaker with External APIs
    15. Example: Circuit breaker with fallback method
    16. 9. Handling API Authentication
    17. 10. Parsing JSON Responses (Jackson)
    18. Example: Deserialize generic list response
    19. 11. Testing External API Integration (MockRestServiceServer)
    20. Example: Mock REST server in test
    21. 12. Using Feign Client for Declarative REST Clients
    22. Example: Feign declarative HTTP client

  46. Implementing Custom Starters

    1. 1. Understanding Spring Boot Starter Structure
    2. Two-Module Layout
    3. 2. Creating Starter Module (spring-boot-starter-*)
    4. 3. Creating Auto-Configuration Classes (@AutoConfiguration)
    5. Example: Auto-configuration class
    6. 4. Using @ConditionalOnClass for Auto-Configuration
    7. 5. Creating Configuration Properties (@ConfigurationProperties)
    8. Example: Configuration properties as record
    9. 6. Registering Auto-Configuration (spring.factories, AutoConfiguration.imports)
    10. Example: Register auto-configuration via imports file
    11. 7. Implementing Fail-Fast Configuration Validation
    12. Example: Validated configuration properties for starter
    13. 8. Creating Starter Documentation
    14. 9. Publishing Custom Starters
    15. 10. Testing Custom Starters
    16. Example: Test auto-configuration with context runner

  47. Optimizing Performance

    1. 1. Enabling HTTP/2 Support
    2. Example: Enable HTTP/2 with TLS
    3. 2. Configuring GZip Compression (server.compression)
    4. Example: Enable GZip compression
    5. 3. Using Connection Pooling
    6. 4. Optimizing JPA Queries (N+1 problem)
    7. Example: JOIN FETCH to avoid N+1
    8. 5. Using Lazy vs Eager Fetching Strategies
    9. 6. Implementing Database Indexing
    10. Example: Composite index on JPA entity
    11. 7. Using Query Result Caching
    12. Example: Cache service method with Spring Cache
    13. 8. Configuring JVM Memory Settings (-Xmx, -Xms)
    14. 9. Profiling Application Performance
    15. 10. Using @EntityGraph for Fetch Optimization
    16. Example: EntityGraph for eager fetch
    17. 11. Implementing API Response Pagination
    18. Example: Paginated API response
    19. 12. Using Async and Non-Blocking Operations
    20. 13. Optimizing Spring Boot Startup Time

  48. Implementing Resilience Patterns

    1. 1. Adding Resilience4j Dependencies
    2. Example: Resilience4j dependencies
    3. 2. Implementing Circuit Breaker (@CircuitBreaker)
    4. Example: Circuit breaker on external service call
    5. 3. Configuring Circuit Breaker States (open, closed, half-open)
    6. State Machine
    7. Example: Circuit breaker thresholds configuration
    8. 4. Implementing Retry Mechanism (@Retry)
    9. Example: Retry on external service call
    10. 5. Configuring Retry Attempts and Delays
    11. Example: Retry with exponential backoff configuration
    12. 6. Implementing Rate Limiter (@RateLimiter)
    13. Example: Rate limiter: 100 requests per second
    14. Example: Apply rate limiter annotation
    15. 7. Implementing Bulkhead Pattern (@Bulkhead)
    16. Example: Semaphore bulkhead
    17. 8. Implementing Time Limiter (@TimeLimiter)
    18. Example: Time-limit async call
    19. 9. Monitoring Resilience Metrics (Actuator)
    20. 10. Combining Multiple Resilience Patterns
    21. Example: Combine circuit breaker, retry, and bulkhead
    22. 11. Using Fallback Methods

  49. Implementing API Rate Limiting

    1. 1. Using Bucket4j for Rate Limiting
    2. Example: Bucket4j dependencies
    3. 2. Configuring Rate Limits
    4. Example: Token bucket with 100 req/min bandwidth
    5. 3. Implementing Filter-Based Rate Limiting
    6. Example: Per-IP rate limit filter
    7. 4. Using Redis for Distributed Rate Limiting
    8. Example: Distributed rate limit dependencies
    9. 5. Implementing User-Based Rate Limits
    10. Example: Rate limit key: authenticated user or IP
    11. 6. Implementing Endpoint-Specific Rate Limits
    12. Example: Per-endpoint bandwidth limits
    13. 7. Returning Rate Limit Headers (X-RateLimit-*)
    14. 8. Handling Rate Limit Exceeded (429 Too Many Requests)
    15. Example: Respond with 429 Too Many Requests
    16. 9. Implementing Sliding Window Algorithm
    17. 10. Testing Rate Limiting Logic
    18. Example: Test rate limit exceeded

  50. Working with Spring Cloud Configuration

    1. 1. Setting Up Spring Cloud Config Server
    2. Example: Config server dependency
    3. Example: Enable config server
    4. 2. Configuring Config Server with Git Backend
    5. Example: Configure Git-backed config server
    6. 3. Using Config Client in Applications
    7. Example: Config client with fail-fast and retry
    8. 4. Managing Environment-Specific Configurations
    9. 5. Refreshing Configuration (@RefreshScope)
    10. Example: Refresh-scoped bean on POST /actuator/refresh
    11. 6. Encrypting Properties in Config Server
    12. Example: Encrypt and store secrets with config server
    13. 7. Using Config Server with Vault Backend
    14. Example: Vault-backed config server
    15. 8. Implementing Config Server Security
    16. Example: Secure config server with basic auth
    17. 9. Using Bus Refresh for Dynamic Updates
    18. Example: Spring Cloud Bus AMQP dependency
    19. 10. Testing Configuration Management

  51. Implementing Service Discovery

    1. 1. Adding Eureka Server Dependencies
    2. Example: Eureka server dependency
    3. 2. Configuring Eureka Server (@EnableEurekaServer)
    4. Example: Enable Eureka server
    5. Example: Standalone Eureka server configuration
    6. 3. Registering Services with Eureka Client
    7. Example: Eureka client dependency
    8. Example: Register service with Eureka
    9. 4. Using Service Discovery for Load Balancing
    10. Example: Load-balanced REST client via discovery
    11. 5. Implementing Health Checks for Services
    12. Example: Eureka health check integration
    13. 6. Configuring Eureka Client Properties
    14. 7. Using Consul as Alternative Discovery Service
    15. Example: Consul service discovery dependency
    16. Example: Consul discovery configuration
    17. 8. Implementing Client-Side Load Balancing (Spring Cloud LoadBalancer)
    18. 9. Using Service Names for Inter-Service Communication
    19. Example: Feign client with service discovery
    20. 10. Testing Service Discovery Integration

  52. Working with API Gateway

    1. 1. Setting Up Spring Cloud Gateway
    2. Example: API Gateway dependency
    3. 2. Configuring Route Definitions
    4. Example: Configure gateway routes with predicates
    5. 3. Using Predicates for Route Matching
    6. 4. Implementing Route Filters
    7. Example: Define routes via Java DSL
    8. 5. Using Built-in Filters
    9. 6. Creating Custom Gateway Filters (GatewayFilter)
    10. Example: Inject correlation ID at gateway
    11. 7. Implementing Rate Limiting at Gateway
    12. Example: Gateway rate limiter with Redis key resolver
    13. Example: Rate limit key resolver by principal
    14. 8. Configuring CORS at Gateway Level
    15. Example: Global CORS at gateway level
    16. 9. Implementing Authentication at Gateway
    17. Example: Gateway JWT security filter chain
    18. 10. Testing Gateway Routes and Filters
    19. Example: Test gateway route and response headers
    20. 11. Using Gateway with Service Discovery
    21. Example: Auto-route via service discovery

  53. Working with Docker Deployment

    1. 1. Creating Dockerfile for Spring Boot
    2. Example: Minimal Dockerfile with JRE
    3. 2. Using Multi-Stage Builds
    4. Example: Multi-stage Maven build
    5. 3. Building Docker Images (docker build)
    6. Example: Build and tag Docker image
    7. 4. Running Containers (docker run)
    8. Example: Run container with environment variables
    9. 5. Using Docker Compose (docker-compose.yml)
    10. Example: Docker Compose with database health check
    11. 6. Configuring Environment Variables
    12. 7. Managing Container Volumes
    13. Example: Bind mount config and log volume
    14. 8. Using Layered JAR Structure (spring-boot-jarmode-layertools)
    15. Example: Layered JAR Dockerfile
    16. 9. Optimizing Image Size
    17. 10. Publishing Images to Registry
    18. Example: Push image to container registry
    19. 11. Implementing Health Checks in Dockerfile
    20. Example: Dockerfile health check for liveness probe

  54. Deploying to Cloud Platforms

    1. 1. Deploying to AWS Elastic Beanstalk
    2. 2. Deploying to AWS ECS/Fargate
    3. Example: ECS Fargate task definition
    4. 3. Deploying to Heroku (Procfile)
    5. Example: Heroku Procfile
    6. 4. Deploying to Google Cloud Run
    7. Example: Deploy to Google Cloud Run
    8. 5. Deploying to Azure App Service
    9. Example: Deploy to Azure App Service
    10. 6. Deploying to Kubernetes (Deployment, Service)
    11. Example: Kubernetes Deployment manifest
    12. 7. Creating Kubernetes ConfigMaps and Secrets
    13. Example: Create ConfigMap and Secret
    14. 8. Implementing Health Checks for Cloud Platforms
    15. 9. Using Cloud-Native Buildpacks
    16. Example: Build OCI image with Buildpacks
    17. 10. Configuring Auto-Scaling Policies
    18. Example: Horizontal Pod Autoscaler
    19. 11. Using Spring Cloud Kubernetes
    20. Example: Spring Cloud Kubernetes dependencies

  55. Working with Native Images

    1. 1. Understanding GraalVM Native Image
    2. 2. Adding Native Build Tools Plugin
    3. Example: Add native Maven plugin
    4. 3. Configuring Native Image Properties
    5. Example: Configure GraalVM native build arguments
    6. 4. Building Native Images (native-image)
    7. Example: Compile and run native image
    8. 5. Handling Reflection Configuration
    9. Example: Register reflection hints
    10. 6. Configuring Resource Bundles
    11. Example: Register resource and message bundle hints
    12. 7. Optimizing Native Image Startup Time
    13. 8. Using Native Image with Docker
    14. Example: Native image Dockerfile with distroless
    15. 9. Testing Native Images
    16. Example: Run tests in native image
    17. 10. Troubleshooting Native Image Build Issues

  56. Troubleshooting Common Issues

    1. 1. Resolving Bean Creation Exceptions
    2. 2. Fixing Circular Dependency Issues
    3. Example: Fix circular dependency with @Lazy
    4. 3. Debugging Auto-Configuration Problems
    5. 4. Resolving Port Already in Use (server.port)
    6. Example: Find port conflict and use random port
    7. 5. Fixing ClassNotFoundException and NoClassDefFoundError
    8. 6. Debugging Transaction Not Working Issues
    9. 7. Resolving Database Connection Pool Exhaustion
    10. 8. Fixing CORS Errors in Browser
    11. Example: Global CORS mapping via WebMvcConfigurer
    12. 9. Debugging 404 Not Found Errors
    13. 10. Resolving Memory Leaks and OutOfMemoryError
    14. Example: JVM flags for heap dump on OOM
    15. 11. Troubleshooting Slow Application Startup
    16. 12. Fixing LazyInitializationException