94 docs tagged with "spring-boot"

The single REST endpoint, full request and response shapes, Bean Validation rules, and what happens when validation fails.

Principles and patterns for designing clear, versioned, and client-friendly REST, gRPC, and GraphQL APIs in Java/Spring Boot services.

Scenario-based walkthrough of designing a production-quality REST API with versioning, pagination, error handling, and rate-limiting headers in Spring Boot 3.

Hands-on examples for externalized configuration using profiles, @ConfigurationProperties, @Value, and startup validation in Spring Boot.

How Spring Boot externalizes configuration using application.properties/yml, profiles, @Value, and @ConfigurationProperties for structured, type-safe config binding.

Hands-on examples showing how Spring Boot auto-configuration works, how to observe it, override it, and write your own.

Patterns for caching application data — cache-aside, write-through, write-behind — eviction policies, TTL design, and cache stampede prevention in Spring Boot with Redis.

Scenario-based walkthrough of implementing cache-aside with Redis in Spring Boot — including TTL configuration, cache eviction, and stampede prevention.

AWS/GCP/Azure, cloud-native patterns, managed services.

Why connection pooling is essential, how HikariCP works, and how to configure it correctly in Spring Boot applications.

Hands-on Spring Boot HikariCP configuration examples, pool monitoring, leak detection, and Kubernetes multi-pod sizing.

How Spring Security prevents Cross-Site Request Forgery attacks with CSRF tokens, when to disable CSRF for REST APIs, and how to configure CORS for Single-Page Applications talking to Spring Boot backends.

Consolidated interview Q&A for the Databases domain — SQL, indexes, transactions, connection pooling, NoSQL, and schema migration — beginner through advanced.

Quick-reference summary of SQL, indexes, transactions, connection pooling, NoSQL trade-offs, and schema migration for Java backend engineers.

Step-by-step runnable examples for MySQL vs PostgreSQL vs H2 — UUID primary keys, H2 compatibility mode, profile-based datasource switching, and Testcontainers.

CI/CD pipelines, monitoring, observability, Spring Boot Actuator.

Core theory behind distributed systems — CAP theorem, consistency models, idempotency, and the Saga pattern for distributed transactions — for Java/Spring Boot backend engineers.

Scenario-based walkthrough of implementing a choreography-based Saga for an e-commerce order flow with idempotent Kafka consumers in Spring Boot.

The entities, DTOs (Java Records), and enums that represent the core concepts of a loan application — and why each was designed the way it was.

How GlobalExceptionHandler uses @RestControllerAdvice to intercept validation failures and unexpected errors and convert them into structured JSON responses.

Hands-on Spring Boot demo of @ControllerAdvice, ProblemDetail error responses, validation error shaping, and the catch-all exception handler pattern.

How to centralise HTTP error responses in Spring Boot — @ExceptionHandler, @ControllerAdvice, ProblemDetail (RFC 7807), and mapping domain exceptions to the right status codes.

How database indexes work, when to add them, how to read EXPLAIN plans, and common indexing pitfalls that hurt performance.

Hands-on examples covering index creation, composite indexes, covering indexes, and reading EXPLAIN plans in PostgreSQL.

How to use @SpringBootTest with TestRestTemplate and WebTestClient to write full-context Spring Boot integration tests.

Hands-on walkthrough of @SpringBootTest with TestRestTemplate, @MockBean for external dependencies, and Testcontainers for real database integration.

Consolidated domain-specific Q&A for Java backend engineering interviews.

How to map Java classes to database tables using @Entity, @Id, @GeneratedValue, and relationship annotations (@OneToMany, @ManyToOne), including fetch type defaults and their implications.

The foundational Java testing framework — lifecycle annotations, assertions, parameterized tests, and test organization.

JSON Web Token structure, signing (symmetric vs. asymmetric), validation, and how to wire stateless JWT authentication into a Spring Boot REST API using Spring Security's OAuth2 Resource Server support.

A Spring Boot REST service that evaluates loan applications using risk classification, EMI calculation, and eligibility rules — covered layer by layer.

An architectural style that structures an application as a collection of small, independently deployable services — each owning its data and business logic.

Scenario-based walkthrough of building a two-service Order + Inventory microservices topology with service discovery, Kafka events, and Spring Boot 3.

How to create mock objects, stub method calls, verify interactions, and capture arguments in Java unit tests.

How to test Spring MVC and Spring WebFlux controllers at the HTTP level without starting a real server, using MockMvc and WebTestClient.

Hands-on walkthrough of HTTP-level controller testing with MockMvc and WebTestClient — requests, assertions, security, and validation.

Practical guide to MySQL, PostgreSQL, and H2 for Java developers — architecture differences, UUID handling, H2 for development, and migration paths to production databases.

CAP theorem, BASE properties, and when to choose Redis, MongoDB, Cassandra, or Elasticsearch over a relational database.

Hands-on Spring Boot examples for Redis caching, MongoDB document CRUD, and Spring Cache abstraction.

OAuth2 authorization flows, the resource server and authorization server patterns, OpenID Connect identity layer, and how to configure Spring Boot as an OAuth2 client and resource server.

Auto-generating interactive API documentation for Spring Boot REST APIs using springdoc-openapi — setup, @Operation/@Schema annotations, security schemes, and customisation.

Hands-on Springdoc setup, @Operation/@Schema annotations, JWT security scheme, and production-safe configuration for Spring Boot REST APIs.

Quick-reference summaries for every domain — designed for rapid revision before interviews.

How LoanApplication is mapped to H2 using JPA @Embeddable value objects, @ElementCollection for rejection reasons, and @PrePersist for UUID generation.

What the Loan Application Evaluator does, why it exists, its tech stack, and how to run it locally.

End-to-end Java Spring Boot project walkthroughs — annotated source code deep-dives for interview preparation and real-world learning.

Quick-reference summary of the Loan Application Evaluator project — architecture, key patterns, tech stack decisions, and top interview talking points.

Circuit Breaker, Retry, Bulkhead, Timeout, and Rate Limiter — the five resilience patterns that prevent cascading failures in distributed Spring Boot services, implemented with Resilience4j.

Scenario-based walkthrough of implementing Circuit Breaker, Retry, Bulkhead, and Timeout with Resilience4j in a Spring Boot 3 microservice.

Interview Q&A mapped directly to resume experiences — legacy migration, security hardening, containerization, Apache POI, and behavioral STAR stories.

Horizontal vs vertical scaling, stateless services, read replicas, database sharding, and load balancing — the patterns that allow a Java/Spring Boot system to handle growing traffic.

Scenario-based walkthrough of making a Spring Boot service horizontally scalable — stateless sessions with Redis, connection pool tuning, read replica routing, and async offloading.

Step-by-step Flyway and Liquibase migration examples in Spring Boot — from first migration to rollback-safe production patterns.

How to manage database schema evolution safely in Spring Boot using versioned migrations with Flyway and Liquibase.

How the LoanApplicationService evaluates a loan — risk classification, interest rate calculation, EMI formula, and the two-tier eligibility check — step by step.

Five design principles that make object-oriented code easier to maintain, extend, and test — the foundation of clean Java design.

Auto-configuration, starters, beans, DI, AOP, Actuator, and production-ready patterns.

Spring Boot Actuator exposes built-in HTTP/JMX endpoints for health checks, metrics, environment inspection, and live bean graphs — essential for production monitoring and operations.

Hands-on examples for enabling and securing Actuator endpoints, writing custom health indicators, and exporting metrics with Micrometer/Prometheus.

How Spring Boot uses @EnableAutoConfiguration and @ConditionalOn* annotations to wire beans automatically based on what is on the classpath.

Consolidated interview Q&A for Spring Boot covering auto-configuration, properties, starters, Actuator, and testing — beginner through advanced.

Quick-reference summary of Spring Boot auto-configuration, properties, starters, Actuator, and testing — key concepts, annotations, and interview questions at a glance.

What starters are, how they bundle dependencies and trigger auto-configuration, and what the most common starters wire up in a Spring Boot application.

Hands-on examples exploring what common starters wire up, how to inspect dependencies, and how to swap out components like the embedded server.

How to use @WebMvcTest, @DataJpaTest, and @JsonTest to write fast, focused Spring Boot tests that load only the layers you need.

Hands-on walkthrough of @WebMvcTest, @DataJpaTest, and @JsonTest with realistic Order API examples.

How to test Spring Boot applications using @SpringBootTest, test slices (@WebMvcTest, @DataJpaTest), @MockBean, and Testcontainers for integration tests with real infrastructure.

Hands-on examples for @SpringBootTest, @WebMvcTest, @DataJpaTest, @MockBean, and Testcontainers in a realistic order service project.

How Spring's cache abstraction works with @Cacheable, @CacheEvict, @CachePut, and @Caching, plus integrating Caffeine and Redis as backing stores.

Hands-on examples for @Cacheable, @CacheEvict, @CachePut, Caffeine, and Redis cache configuration in a Spring Boot application.

Consolidated interview Q&A for Spring Data JPA covering JPA mapping, repositories, transactions, N+1, projections, and caching — beginner through advanced.

How Spring Data JPA's repository interfaces (CrudRepository, JpaRepository) eliminate DAO boilerplate through query method derivation and @Query for JPQL and native SQL.

How Spring MVC processes HTTP requests — DispatcherServlet, @RestController, request mapping, parameter binding, and ResponseEntity patterns used in everyday Spring Boot APIs.

Hands-on Spring MVC examples covering DispatcherServlet internals, parameter binding, validation, content negotiation, and interceptors.

How Spring Security authenticates users — UserDetailsService, PasswordEncoder, AuthenticationManager, and the authentication flow from credentials to SecurityContext.

How Spring Security enforces access control — URL-based rules with requestMatchers, method-level security with @PreAuthorize and @Secured, and the role vs. authority distinction.

How Spring Security's ordered chain of servlet filters intercepts every HTTP request and applies authentication and authorization before the request reaches your controller.

Core SQL syntax and concepts — SELECT, JOIN types, GROUP BY, window functions, and subqueries — with Spring Boot JDBC context.

Hands-on SQL examples covering JOINs, GROUP BY, window functions, and subqueries in a Spring Boot JDBC context.

High-level architecture, microservices, distributed systems, SOLID principles, caching, reliability patterns, API design, and scalability for Java/Spring Boot engineers.

Consolidated interview Q&A for System Design — covering SOLID principles, microservices, API design, caching, reliability patterns, distributed systems, and scalability.

Quick-reference summary of System Design concepts — SOLID, microservices, API design, caching, reliability patterns, distributed systems, and scalability — with top interview questions.

How to use Testcontainers to run real PostgreSQL, MySQL, Redis, and Kafka instances inside Docker containers during Java tests.

Hands-on examples for running PostgreSQL, Redis, and Kafka in Docker containers during tests, with Spring Boot 3.1+ @ServiceConnection.

Unit testing, integration testing, Testcontainers, Mockito, JUnit 5.

Consolidated interview Q&A for Java Testing covering JUnit 5, Mockito, Spring Boot test slices, integration tests, Testcontainers, MockMvc, and WebTestClient.

Quick-reference summary of Java testing concepts — JUnit 5, Mockito, Spring Boot test slices, integration tests, Testcontainers, MockMvc, and WebTestClient.

How LoanApplicationService is unit-tested with JUnit 5 and Mockito — covering risk classification, EMI calculation, and all eligibility rules using @Nested test classes.

Database transactions, the four ACID properties, isolation levels, and how deadlocks occur — with Spring @Transactional context.

Hands-on examples of Spring @Transactional — propagation, isolation levels, deadlock handling, and common pitfalls.

Consolidated interview Q&A for the Web & REST domain — HTTP fundamentals, REST design, Spring MVC, exception handling, WebFlux, and OpenAPI — beginner through advanced.

Quick-reference summary of HTTP fundamentals, REST design, Spring MVC, exception handling, WebFlux, and OpenAPI for Java backend engineers.

Hands-on Spring WebFlux examples covering Mono/Flux basics, annotated controllers, functional routing, parallel I/O with Mono.zip, and SSE streaming.

Spring WebFlux — the reactive, non-blocking alternative to Spring MVC — covering Mono, Flux, functional endpoints, backpressure, and when to choose reactive over the blocking model.