https://blog.devops-monk.com/tags/java/Recent content in Java on Devops MonkHugoen-usSat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/container-reuse/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/container-reuse/The singleton pattern shares a container within a single test run. Container reuse goes further — it keeps the container alive after the JVM exits and reuses it in the next test run. The first run pays the startup cost (8 seconds for Kafka). Every subsequent run skips it entirely. For a developer who runs the test suite dozens of times per day, this saves minutes of waiting. What You&rsquo;ll Learn Enabling container reuse with .https://blog.devops-monk.com/tutorials/testcontainers/flyway-liquibase-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/flyway-liquibase-testing/Database migrations are the most dangerous code in most applications. A failed migration in production means downtime. A migration that succeeds but corrupts data is worse. Testing migrations against the actual target database — not H2, not a manual inspection — is the only way to catch migration bugs before they reach production. This article covers testing Flyway and Liquibase migrations with Testcontainers, verifying schema correctness after migration, and testing rollback scenarios.https://blog.devops-monk.com/tutorials/testcontainers/junit5-lifecycle-annotations/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/junit5-lifecycle-annotations/The biggest performance factor in a Testcontainers test suite is how many times you start and stop containers. Start a PostgreSQL container once per JVM and your tests add 2 seconds to total CI time. Start it once per test method and 50 tests cost 100 seconds. Understanding Testcontainers lifecycle management is how you write fast tests without sacrificing isolation. This article covers all the container lifecycle options in JUnit 5 — from the simplest @Container annotation to the singleton pattern that shares one container across your entire test suite.https://blog.devops-monk.com/tutorials/testcontainers/kafka-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/kafka-testing/@EmbeddedKafka has long been the standard for Kafka testing in Spring Boot. It works, but it runs a different Kafka implementation than production — one that can accept messages and serialize records in ways that a real Kafka broker would not. KafkaContainer runs the same Confluent Kafka image your production environment uses, with the same broker configuration, same partition behavior, and same consumer group offset management. This article shows how to test Kafka producers, consumers, and dead-letter topics with a real broker.https://blog.devops-monk.com/tutorials/testcontainers/keycloak-oauth2-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/keycloak-oauth2-testing/Testing Spring Security with @WithMockUser and SecurityMockMvcRequestPostProcessors.jwt() verifies that your authorization annotations are wired correctly, but it does not test JWT validation, token signing algorithms, issuer URL verification, or clock skew handling. These require a real OAuth2 provider. KeycloakContainer runs a real Keycloak instance in Docker, giving you a complete OIDC server for integration tests. What You&rsquo;ll Learn KeycloakContainer setup from the community module Importing a Keycloak realm for tests Retrieving JWT access tokens programmatically Testing protected endpoints with real JWTs Testing role-based access control (RBAC) Testing token expiry and refresh flows Dependencies KeycloakContainer is not in the Testcontainers core library.https://blog.devops-monk.com/tutorials/testcontainers/localstack-aws-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/localstack-aws-testing/Testing AWS integrations against real AWS services requires IAM credentials, costs money per test run, and creates real side effects (files in S3, messages in SQS). LocalStack runs a local AWS cloud emulator in Docker — the same API, the same response format, but running locally with no AWS account required. This article covers testing S3, SQS, and SNS integrations with LocalStackContainer. What You&rsquo;ll Learn LocalStackContainer setup and @ServiceConnection Creating S3 buckets and testing file upload/download Testing SQS message producers and @SqsListener consumers Testing SNS to SQS subscriptions Creating AWS resources before tests with the AWS SDK Testing DynamoDB operations Dependencies &lt;dependency&gt; &lt;groupId&gt;io.https://blog.devops-monk.com/tutorials/testcontainers/mongodb-nosql-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/mongodb-nosql-testing/MongoDB&rsquo;s document model introduces testing challenges that relational database tests do not have: schema flexibility (different documents can have different fields), aggregation pipelines, geospatial queries, and text search. Testing these against an embedded Flapdoodle MongoDB works for basic CRUD but breaks down for aggregation pipelines, custom index types, and MongoDB-version-specific behavior. This article covers MongoDB testing with a real MongoDB container. What You&rsquo;ll Learn MongoDBContainer setup and @ServiceConnection @DataMongoTest slice testing for repositories Testing aggregation pipelines Testing compound indexes and text indexes Querying documents with MongoTemplate Testing document validation rules Dependencies &lt;dependency&gt; &lt;groupId&gt;org.https://blog.devops-monk.com/tutorials/testcontainers/mysql-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/mysql-testing/MySQL is still the most widely deployed relational database in Java applications. Its SQL dialect, strict mode behavior, and character set handling differ from both H2 and PostgreSQL in ways that matter for real applications. This article covers MySQL testing with Testcontainers — from basic setup to MySQL-specific features and the STRICT_TRANS_TABLES mode that catches data truncation bugs H2 silently ignores. What You&rsquo;ll Learn MySQLContainer setup and configuration @ServiceConnection with MySQL MySQL strict mode and why it matters for tests Character set and collation configuration Testing MySQL-specific SQL functions MariaDB as an alternative Dependencies &lt;dependency&gt; &lt;groupId&gt;org.https://blog.devops-monk.com/tutorials/testcontainers/parallel-test-execution/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/parallel-test-execution/A test suite with 50 integration test classes runs sequentially in 10 minutes. Configured for parallel execution across 4 threads, it completes in 3 minutes. Parallel test execution with Testcontainers requires careful data isolation — tests running simultaneously against the same database will step on each other&rsquo;s data without it. This article covers JUnit 5 parallel configuration, container sharing strategies, and data isolation techniques. What You&rsquo;ll Learn JUnit 5 parallel execution configuration with junit-platform.https://blog.devops-monk.com/tutorials/testcontainers/postgresql-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/postgresql-testing/Testing database code against H2 gives you a false sense of security. PostgreSQL has different behavior for ON CONFLICT, RETURNING, JSON operators, full-text search, and dozens of other features. A JPA query that works in H2 dialect may fail against real PostgreSQL. This article shows how to test your Spring Data JPA repositories, custom queries, and database constraints against a real PostgreSQL instance using Testcontainers. What You&rsquo;ll Learn @ServiceConnection — the Spring Boot 3.https://blog.devops-monk.com/tutorials/testcontainers/rabbitmq-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/rabbitmq-testing/RabbitMQ&rsquo;s exchange-queue model, routing keys, dead-letter exchanges, and message TTL are features that cannot be tested with mocks. The broker&rsquo;s routing logic — topic exchange patterns, fanout behavior, message acknowledgment, and requeue behavior on rejection — all require a real broker. This article covers RabbitMQ integration testing with RabbitMQContainer. What You&rsquo;ll Learn RabbitMQContainer setup and @ServiceConnection Configuring exchanges, queues, and bindings for tests Testing @RabbitListener consumers with Awaitility Testing dead-letter exchange and dead-letter queue routing Testing message TTL and automatic expiry Testing acknowledgment modes Dependencies &lt;dependency&gt; &lt;groupId&gt;org.https://blog.devops-monk.com/tutorials/testcontainers/redis-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/redis-testing/Redis cache testing with a real Redis instance catches behaviors that embedded or mocked alternatives cannot: TTL expiry timing, cache eviction under memory pressure, cluster failover behavior, and the exact serialization format that Redis stores data in. This article covers testing Spring Cache, Spring Session, and distributed locks against a real Redis container. What You&rsquo;ll Learn Redis GenericContainer setup and @ServiceConnection (Spring Boot 3.2+) Testing Spring Cache with @Cacheable, @CacheEvict, and @CachePut Verifying TTL expiry behavior Testing Spring Session with Redis Testing distributed locks with Redisson or Spring Integration Dependencies &lt;dependency&gt; &lt;groupId&gt;org.https://blog.devops-monk.com/tutorials/testcontainers/setup-testcontainers-java/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/setup-testcontainers-java/Setting up Testcontainers takes about five minutes. The dependencies are on Maven Central, the BOM manages all version alignment, and Spring Boot 3 has first-class support that eliminates most of the configuration boilerplate. By the end of this article, you will have a Spring Boot project with Testcontainers running, a PostgreSQL container backing your first integration test, and a clear understanding of how to add any additional container module. What You&rsquo;ll Learn How the Testcontainers BOM works and why you need it Which dependencies to add for Spring Boot, PostgreSQL, and JUnit 5 How to configure Maven and Gradle for Testcontainers tests How to set up Logback so you can see container startup logs How @ServiceConnection eliminates @DynamicPropertySource boilerplate in Spring Boot 3.https://blog.devops-monk.com/tutorials/testcontainers/singleton-containers/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/singleton-containers/With 20 integration test classes, each starting its own PostgreSQL container, you pay 20 container starts at 2 seconds each — 40 seconds of pure overhead before a single assertion runs. The singleton pattern starts one container per JVM, shares it across all test classes, and cuts that 40 seconds to 2. This is the most impactful performance optimization for large Testcontainers test suites. What You&rsquo;ll Learn The singleton pattern using a static initializer block Abstract base class design for sharing containers and @DynamicPropertySource Why you must not combine @Testcontainers/@Container with the singleton pattern Spring TestContext caching — how it works and how to maximize reuse The @ImportTestcontainers approach for Spring Boot 3.https://blog.devops-monk.com/tutorials/testcontainers/spring-boot-testing-slices/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/spring-boot-testing-slices/@SpringBootTest starts the full application context — all beans, all auto-configurations, all datasources, all message listeners. That is 10–30 seconds of startup time for every test class that needs it. Spring Boot&rsquo;s test slices load a subset of the application context — only the beans relevant to what you are testing. Repository tests that once took 15 seconds with @SpringBootTest take 2 seconds with @DataJpaTest. This article covers all the major test slices and how to combine them with Testcontainers.https://blog.devops-monk.com/tutorials/testcontainers/testcontainers-cicd/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/testcontainers-cicd/Testcontainers tests that run perfectly on your developer laptop can fail in CI for environmental reasons — Docker daemon availability, image pull timeouts, port conflicts, and resource limits. This final article covers production-ready CI/CD configuration for Testcontainers in GitHub Actions, GitLab CI, and Jenkins, plus Spring Boot 3.1&rsquo;s development-time container support. What You&rsquo;ll Learn GitHub Actions configuration for Testcontainers (zero extra setup on ubuntu-latest) GitLab CI configuration with Docker-in-Docker Jenkins configuration with Docker socket mounting TestApplication — running your app locally with containers instead of a real database .https://blog.devops-monk.com/tutorials/testcontainers/wait-strategies/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/wait-strategies/A container being started does not mean it is ready to accept connections. Docker marks the container as running the moment the entrypoint process starts. PostgreSQL needs another second or two to initialize storage, bind to port 5432, and start accepting connections. If your test code tries to connect before the database is ready, you get Connection refused. The wrong solution is Thread.sleep(5000). That is a fixed delay: too short on a slow machine, too long on a fast one.https://blog.devops-monk.com/tutorials/testcontainers/unit-integration-system-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/unit-integration-system-testing/&ldquo;We have 90% test coverage&rdquo; means nothing if 90% of your tests are mocking away the parts that matter. A codebase full of unit tests that mock every dependency can have excellent coverage numbers while completely missing bugs that manifest when real components interact. Understanding the difference between unit tests, integration tests, and system tests — and when to use each — is the foundation of a test suite that actually finds bugs.https://blog.devops-monk.com/tutorials/testcontainers/what-is-testcontainers/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/what-is-testcontainers/Your CI pipeline goes green. You deploy to staging. The application crashes on startup because Flyway migrations fail against MySQL — but all your tests used H2. Your team has seen this before. Tests that pass on every machine, fail in production. Not because the business logic was wrong, but because the test infrastructure was fake. This is the problem Testcontainers was built to solve. This article covers what Testcontainers is, why traditional approaches to integration testing fall short, and how Testcontainers gives you test environments that match production — automatically, repeatably, with no shared test database to maintain.https://blog.devops-monk.com/tutorials/testcontainers/wiremock-testing/Sat, 23 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/testcontainers/wiremock-testing/Most Spring Boot applications call external APIs — payment gateways, shipping providers, notification services, CRM systems. Testing these integrations is hard because external APIs have rate limits, authentication requirements, and a habit of being unavailable at exactly the wrong moment. WireMock runs a real HTTP server in a Docker container, accepts your requests, and returns whatever responses you configure. This article covers WireMock as a Testcontainer for testing Spring Boot REST client integrations.https://blog.devops-monk.com/tutorials/java25/aot-compilation/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/aot-compilation/The Java Startup Problem Java&rsquo;s performance story has always had one weak spot: startup time. When a JVM starts, it: Loads and verifies class bytecode Interprets bytecode (slow) Profiles which methods are called most (warm-up) Compiles hot methods to native code via JIT (takes time and CPU) Eventually reaches peak throughput This process takes seconds for large applications. For a Spring Boot application, typical warm-up to peak throughput can take 10–30 seconds.https://blog.devops-monk.com/tutorials/java25/compact-object-headers/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/compact-object-headers/What Is an Object Header? Every single Java object — every String, every Integer, every record, every array — carries a header that the JVM uses for bookkeeping. Your code never sees this header; it lives alongside the object&rsquo;s fields in memory. Before Java 25, on a 64-bit JVM, the header occupied 96 to 128 bits (12–16 bytes): ┌─────────────────────────────────────────────────────────┐ │ Mark Word (64 bits) │ │ ─ identity hash code │ │ ─ lock state (biased lock / thin lock / fat lock) │ │ ─ GC age bits │ ├─────────────────────────────────────────────────────────┤ │ Class Pointer (32 bits compressed / 64 bits full) │ │ ─ pointer to the object&#39;s class (Klass* in HotSpot) │ └─────────────────────────────────────────────────────────┘ With UseCompressedOops (default), the class pointer is compressed to 32 bits, giving a 96-bit (12-byte) header.https://blog.devops-monk.com/tutorials/java25/compact-source-files/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/compact-source-files/The Ceremony Problem When a student writes their first Java program, they copy this boilerplate: public class HelloWorld { public static void main(String[] args) { System.out.println(&#34;Hello, World!&#34;); } } Three layers of ceremony for one line of logic: A public class whose name must match the filename A public static void main(String[] args) signature with specific keywords The actual code, buried inside two levels of braces This has been the #1 on-ramp friction point in Java for 30 years.https://blog.devops-monk.com/tutorials/java25/flexible-constructor-bodies/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/flexible-constructor-bodies/The Old Rule That Caused So Much Pain From Java 1.0 through Java 24, a constructor that extended another class had one rigid rule: super(...) or this(...) must be the first statement in the constructor body. This was enforced by the compiler. Not because of a deep technical reason — but because the JVM specification had always required that the superclass be fully initialized before the subclass could do anything with the object.https://blog.devops-monk.com/tutorials/java25/generational-shenandoah/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/generational-shenandoah/GC Background: Why Generations Matter The Generational Hypothesis is the foundation of most modern GC design: Most objects die young. In a typical Java application, the vast majority of objects are short-lived: request/response objects, DTOs, builder instances, stream pipeline intermediates. They are created, used briefly, and then immediately eligible for collection. A GC that knows about this pattern can be far more efficient than one that treats all objects equally:https://blog.devops-monk.com/tutorials/java25/security-kdf-pem/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/security-kdf-pem/Overview Java 25 ships two important security additions: JEP 510 — Key Derivation Function (KDF) API — Final. A standard API for HKDF, PBKDF2, and other KDFs. JEP 470 — PEM Encodings of Cryptographic Objects — Preview. Read and write .pem files without third-party libraries. These fill two long-standing gaps: Java had the underlying crypto but no clean standard API for key derivation and PEM I/O. Part 1: Key Derivation Function API (JEP 510) What Is Key Derivation?https://blog.devops-monk.com/tutorials/java25/java25-overview/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/java25-overview/Why Java 25 Matters Java 25 was released on September 16, 2025 — exactly two years after Java 21, following the cadence Oracle committed to when it moved to a two-year LTS cycle. But Java 25 is not just &ldquo;Java 21 with more stuff&rdquo;. It is the release where four years of preview work finally becomes production API. Features that Java developers have been testing since Java 21 — Scoped Values, Flexible Constructor Bodies, Module Import Declarations, Compact Source Files — all graduate to final status.https://blog.devops-monk.com/tutorials/java25/module-import-declarations/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/module-import-declarations/The Problem: Import Hell Every Java developer has experienced this. You open a file and before you see a single line of business logic, you wade through a wall of imports: import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.Set; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; import java.util.stream.Collectors; import java.util.stream.Stream; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.https://blog.devops-monk.com/tutorials/java25/primitive-patterns/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/primitive-patterns/Note: JEP 507 is a preview feature in Java 25 (3rd preview). Enable it with --enable-preview at compile and runtime. It is expected to finalize in Java 26 or 27. The Asymmetry in Pattern Matching Java 21 gave us pattern matching for switch and instanceof. It is a great feature — but it had a glaring asymmetry: it only worked with reference types. Object obj = 42; // Java 21: works fine if (obj instanceof Integer i) { System.https://blog.devops-monk.com/tutorials/java25/scoped-values/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/scoped-values/The ThreadLocal Problem ThreadLocal has been the standard way to pass contextual data through a call chain without polluting method signatures since Java 1.2. Every Java developer has seen it used for things like: Web request context (user ID, correlation ID, tenant ID) Database transaction binding Security principal propagation Logging MDC (Mapped Diagnostic Context) Here is the classic pattern: public class RequestContext { // ThreadLocal stores one value per thread private static final ThreadLocal&lt;String&gt; CURRENT_USER = new ThreadLocal&lt;&gt;(); public static void set(String userId) { CURRENT_USER.https://blog.devops-monk.com/tutorials/java25/java25-setup/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/java25-setup/Installing Java 25 Option 1: SDKMAN! (Recommended) SDKMAN! is the easiest way to install and switch between Java versions on macOS and Linux. # Install SDKMAN! if you don&#39;t have it curl -s &#34;https://get.sdkman.io&#34; | bash source &#34;$HOME/.sdkman/bin/sdkman-init.sh&#34; # List available Java 25 distributions sdk list java | grep &#34;25&#34; # Install Eclipse Temurin 25 (open-source, most common) sdk install java 25-tem # Set as default globally sdk default java 25-tem # Verify java -version # openjdk version &#34;25&#34; 2025-09-16 Switch between versions per project:https://blog.devops-monk.com/tutorials/java25/structured-concurrency/Sun, 10 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java25/structured-concurrency/Note: JEP 505 is a preview feature in Java 25 (5th preview). Enable with --enable-preview. The API has been stable for several rounds and is expected to finalize in Java 26. The Problem with Unstructured Concurrency Classic Java concurrency with ExecutorService is unstructured: you submit tasks, and those tasks have no formal relationship with the code that submitted them. This causes three recurring problems: Problem 1: Partial failure leaves orphaned tasks ExecutorService exec = Executors.https://blog.devops-monk.com/tutorials/spring-data-jpa/mapped-superclass/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/mapped-superclass/Introduction Almost every entity in a real application shares a few common fields: id, createdAt, updatedAt, and perhaps version. Writing these in every entity class is repetitive and error-prone. @MappedSuperclass lets you define them once in a base class that all entities extend — without creating a parent table or any inheritance mapping in the database. What Is @MappedSuperclass? @MappedSuperclass marks a class whose field mappings are inherited by subclass entities.https://blog.devops-monk.com/tutorials/spring-kafka/sendto-kafkahandler/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/sendto-kafkahandler/@SendTo — Chaining Listeners @SendTo on a @KafkaListener method automatically sends the return value to another Kafka topic. This is how you build event pipelines without manually calling KafkaTemplate.send() in your listener. flowchart LR T1["orders\n(OrderPlacedEvent)"] T2["orders-confirmed\n(OrderConfirmedEvent)"] T3["inventory-events\n(StockReservedEvent)"] T1 -->|"@KafkaListener\n@SendTo"| L1["confirmOrder()"] L1 --> T2 T2 -->|"@KafkaListener\n@SendTo"| L2["reserveStock()"] L2 --> T3 Basic @SendTo @KafkaListener(topics = &#34;orders&#34;, groupId = &#34;confirmation-service&#34;) @SendTo(&#34;orders-confirmed&#34;) public OrderConfirmedEvent onOrder(OrderPlacedEvent event) { // Return value is automatically sent to &#34;orders-confirmed&#34; return new OrderConfirmedEvent( event.https://blog.devops-monk.com/tutorials/spring-data-jpa/transactional-propagation-isolation/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/transactional-propagation-isolation/What @Transactional Does @Transactional tells Spring to wrap the annotated method in a database transaction. Spring opens the transaction before the method starts and commits (or rolls back) when it ends. The annotation works via an AOP proxy — understanding this proxy model is essential for avoiding the most common @Transactional bugs. The AOP Proxy Model Spring creates a proxy around your bean. When code outside the bean calls a @Transactional method, the call goes through the proxy, which manages the transaction:https://blog.devops-monk.com/tutorials/spring-security/actuator-security-production/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/actuator-security-production/The Actuator Security Problem Spring Boot Actuator exposes endpoints that reveal sensitive information about your application — environment variables, configuration properties, heap dumps, thread dumps, and the ability to shut down the application remotely. An exposed /actuator/env endpoint can leak database passwords, API keys, and JWT signing secrets. An exposed /actuator/shutdown is a denial-of-service button. Actuator security is not optional in production. Actuator Endpoints and Their Risk Level Endpoint Exposes Risk /actuator/health Application health Low — often public /actuator/info App metadata Low /actuator/metrics JVM/HTTP metrics Medium — business data /actuator/env All configuration properties (including secrets) Critical /actuator/configprops All @ConfigurationProperties values Critical /actuator/loggers Log levels (writable) High /actuator/heapdump Full JVM heap as a file Critical /actuator/threaddump Thread state Medium /actuator/mappings All URL mappings Medium — reveals API surface /actuator/shutdown Kills the JVM Critical /actuator/auditevents Security events High Step 1: Expose Only What You Need By default, only health is exposed over HTTP.https://blog.devops-monk.com/tutorials/java8/streams-advanced/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/streams-advanced/flatMap in Depth The Collectors API covers perhaps 90% of real-world aggregation needs, but the moment you need something beyond grouping, partitioning, or joining, the custom Collector is there. Understanding flatMap and the full Collectors toolkit — including when to write your own — separates competent Java 8 developers from those who still reach for a for loop whenever a problem gets slightly unusual. flatMap is the most powerful transformation in the Streams API.https://blog.devops-monk.com/tutorials/spring-data-jpa/auditing/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/auditing/Why Auditing Matters Production systems must answer: &ldquo;Who changed this? When? What did it look like before?&rdquo; Without auditing infrastructure, you add created_at, updated_at, created_by, updated_by columns manually to every entity — dozens of lines of boilerplate repeated everywhere. Spring Data JPA auditing fills these fields automatically. Hibernate Envers goes further: it captures every revision of every entity in separate audit tables. Spring Data JPA Auditing Enable Auditing @Configuration @EnableJpaAuditing(auditorAwareRef = &#34;auditorProvider&#34;) public class JpaAuditingConfig { @Bean public AuditorAware&lt;String&gt; auditorProvider() { return () -&gt; Optional.https://blog.devops-monk.com/tutorials/spring-security/authentication-manager-provider/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/authentication-manager-provider/The Authentication Delegation Chain Spring Security separates requesting authentication from performing authentication. A filter receives a username and password — but it does not check them itself. It passes the request to AuthenticationManager, which delegates to one or more AuthenticationProvider instances: flowchart LR F[Authentication Filter\nForm Login / Basic / JWT] -->|UsernamePasswordToken| AM[AuthenticationManager\nProviderManager] AM -->|try each provider| AP1[DaoAuthenticationProvider\nfor DB users] AM -->|try each provider| AP2[LdapAuthenticationProvider\nfor LDAP users] AM -->|try each provider| AP3[Custom Provider\nfor API key] AP1 -->|if supported| UDS[UserDetailsService\nloadUserByUsername] UDS --> DB[(Database)] AP1 -->|verify password| PE[PasswordEncoder] AP1 -->|success| Token[Authenticated Token] Token --> F This chain is the core of Spring Security&rsquo;s extensibility — you can plug in any number of authentication mechanisms without touching the filter or the rest of the framework.https://blog.devops-monk.com/tutorials/spring-kafka/avro-schema-registry/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/avro-schema-registry/Why Avro and Schema Registry? JSON has no schema enforcement — a producer can change a field name and silently break every consumer. Avro + Schema Registry solves this: Avro gives you a compact binary format with a schema definition Schema Registry stores and versions schemas, enforces compatibility rules, and prevents breaking changes from reaching consumers flowchart LR subgraph Producer["Order Service"] E["OrderPlacedEvent"] -->|"KafkaAvroSerializer"| SR["Schema Registry\n(register/lookup schema)"] SR --> Bytes["[schema_id (4 bytes)] + [avro payload]"https://blog.devops-monk.com/tutorials/spring-data-jpa/basic-entity-mapping/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/basic-entity-mapping/Introduction Entity mapping is the process of telling Hibernate how your Java class corresponds to a database table, and how each field maps to a column. JPA provides a rich set of annotations for this — from the minimal @Entity and @Id to the detailed @Column with constraints. This article covers every annotation and attribute you need to map entities precisely and confidently. @Entity @Entity marks a class as a JPA entity — a Java object that maps to a database table.https://blog.devops-monk.com/tutorials/spring-batch/spring-batch-best-practices/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/spring-batch-best-practices/Introduction This is the final article in the Spring Batch Tutorial series. It consolidates every hard-won lesson into actionable checklists — use it as a review before deploying a new batch job to production, or as a reference when debugging an existing one. Part 1: Job Design Always design for restartability Every step that writes to a database uses idempotent SQL (ON DUPLICATE KEY UPDATE or WHERE NOT EXISTS) Every ItemReader has a unique .https://blog.devops-monk.com/tutorials/spring-data-jpa/cascade-types-orphan-removal/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/cascade-types-orphan-removal/Introduction Cascade types control which persistence operations (save, merge, delete, refresh) propagate from a parent entity to its associated children. orphanRemoval controls what happens when a child is removed from the parent&rsquo;s collection. Getting cascade wrong is one of the most common causes of unexpected deletes and data integrity issues in JPA applications. The Six Cascade Types cascade = CascadeType.PERSIST // propagate persist (save new entity) cascade = CascadeType.MERGE // propagate merge (re-attach detached entity) cascade = CascadeType.https://blog.devops-monk.com/tutorials/java11/collection-factory-methods/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/collection-factory-methods/Why Collection Factory Methods? Before Java 9, creating a small immutable collection was tedious: // Java 8 — three lines, two classes, mutable intermediate List&lt;String&gt; names = Collections.unmodifiableList( Arrays.asList(&#34;Alice&#34;, &#34;Bob&#34;, &#34;Charlie&#34;) ); // Java 8 — even worse for Map Map&lt;String, Integer&gt; scores = new HashMap&lt;&gt;(); scores.put(&#34;Alice&#34;, 90); scores.put(&#34;Bob&#34;, 85); Map&lt;String, Integer&gt; immutableScores = Collections.unmodifiableMap(scores); JEP 269 (Java 9) introduced static factory methods that create truly immutable collections with a single expression:https://blog.devops-monk.com/tutorials/java8/collections-maps/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/collections-maps/Overview Java 8 didn&rsquo;t just add Streams — it also enhanced the existing Iterable, Collection, List, and Map interfaces with default methods that cover the most common imperative patterns. Understanding these methods lets you write cleaner code even without streams. The three methods worth memorising immediately are computeIfAbsent (the most useful new Map method), merge (for accumulation patterns), and removeIf (eliminating the iterator-based removal pattern). Together they eliminate the most common sources of verbose boilerplate in collection-heavy code.https://blog.devops-monk.com/tutorials/java8/completablefuture/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/completablefuture/The Problem with Future&lt;T&gt; Fetching a product page on an e-commerce site requires at least three data sources: product details, live pricing, and inventory availability. Done sequentially, a 200 ms call to each service adds up to 600 ms. Done in parallel with a properly composed CompletableFuture pipeline, the wall-clock time drops to roughly the slowest of the three — around 200 ms. This article shows exactly how to build that pipeline and everything else you need to write robust async code in Java 8.https://blog.devops-monk.com/tutorials/spring-kafka/consumer-bean-configuration/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/consumer-bean-configuration/Why @Bean Configuration? application.properties covers the common cases. But real applications need multiple listener factories — one for orders with manual acknowledgment and concurrency 3, another for analytics events with batch listening and different deserializers. @Bean configuration gives you a factory per use case, full IDE support, and the ability to wire in custom components like error handlers and interceptors. The Factory Relationship flowchart TD CF["ConsumerFactory\n(connection + deserialization config)"] LCF["ConcurrentKafkaListenerContainerFactory\n(container behaviour config)"https://blog.devops-monk.com/tutorials/spring-kafka/consumer-groups-offsets/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/consumer-groups-offsets/What Is a Consumer Group? A consumer group is a set of consumer instances that jointly consume a topic. Kafka assigns each partition to exactly one consumer within the group at a time. This is what enables parallel processing: multiple consumers in the same group read different partitions simultaneously. flowchart LR subgraph Topic["Topic: orders — 4 partitions"] P0["Partition 0"] P1["Partition 1"] P2["Partition 2"] P3["Partition 3"] end subgraph CG["Consumer Group: inventory-service"] C1["https://blog.devops-monk.com/tutorials/spring-kafka/consumer-groups/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/consumer-groups/Consumer Group Fundamentals A consumer group is how Kafka distributes work across multiple consumers. Each partition in a topic is assigned to exactly one consumer instance in the group at any given time. flowchart TB subgraph Topic["Topic: orders — 6 partitions"] P0["P0"] P1["P1"] P2["P2"] P3["P3"] P4["P4"] P5["P5"] end subgraph CG1["Group: inventory-service (3 instances)"] I1["Instance 1\nP0, P1"] I2["Instance 2\nP2, P3"] I3["Instance 3\nP4, P5"] end subgraph CG2["Group: notification-service (1 instance)"] N1["Instance 1\nP0,P1,P2,P3,P4,P5"] end P0 & P1 --> I1 P2 & P3 --> I2 P4 & P5 --> I3 P0 & P1 & P2 & P3 & P4 & P5 --> N1 Both groups receive all events — they are independent.https://blog.devops-monk.com/tutorials/java17/deserialization-filters/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/deserialization-filters/Finalized in Java 17 (JEP 415). Extends JEP 290 (Java 9), which introduced the basic deserialization filter API. Why Deserialization Is Dangerous Java object deserialization (ObjectInputStream.readObject()) is one of the most exploited attack surfaces in Java. When a Java application deserializes untrusted bytes, the JVM instantiates arbitrary classes and calls their methods as a side effect — before your application code even sees the result. Attackers craft gadget chains: sequences of serializable classes in common libraries (Apache Commons Collections, Spring Framework, etc.https://blog.devops-monk.com/tutorials/spring-security/cors-configuration/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/cors-configuration/What Is CORS? The Same-Origin Policy (SOP) is a browser security rule: JavaScript on app.example.com cannot read responses from api.example.com — different subdomain, different origin. Without this, any website could use a visitor&rsquo;s authenticated session to silently call other sites on their behalf. CORS (Cross-Origin Resource Sharing) is the mechanism by which a server explicitly relaxes SOP for trusted origins. When a browser sees a cross-origin request, it checks whether the server has granted permission before allowing JavaScript to read the response.https://blog.devops-monk.com/tutorials/spring-security/csrf-protection/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/csrf-protection/What Is a CSRF Attack? Cross-Site Request Forgery (CSRF) tricks an authenticated user&rsquo;s browser into making an unintended request to your application. The attack: Alice is logged into bank.com — her browser holds a valid session cookie Alice visits evil.com evil.com contains &lt;img src=&quot;https://bank.com/transfer?to=attacker&amp;amount=5000&quot;&gt; Alice&rsquo;s browser fires the request, automatically attaching her bank.com session cookie bank.com receives an authenticated request that Alice never intended to make The attack works because browsers automatically send cookies with cross-origin requests.https://blog.devops-monk.com/tutorials/spring-data-jpa/custom-queries-jpql-native-sql/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/custom-queries-jpql-native-sql/Why @Query Exists Derived query methods (Article 17) are great for simple conditions, but they break down fast. A method like findByOrderStatusAndCustomerCityAndPriceBetweenOrderByCreatedAtDesc is unreadable and still cannot express a JOIN or aggregation. @Query lets you write the exact JPQL or SQL you need, attached directly to a repository method — keeping your repository clean while giving you full query control. JPQL vs Native SQL JPQL Native SQL Language Entity/field names Table/column names Database portable Yes No JOIN FETCH Yes No Window functions No Yes Full-text search No Yes Complex analytics Limited Full power Start with JPQL.https://blog.devops-monk.com/tutorials/spring-kafka/custom-serializers/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/custom-serializers/When to Write a Custom Serializer Spring Kafka ships JSON and Avro support. You need a custom serializer when: Your team uses Protobuf or MessagePack and wants native support You need a compact binary format for high-throughput topics (pricing ticks, sensor readings) You&rsquo;re integrating with a legacy system that publishes a fixed binary protocol You want deterministic serialization for event deduplication or content-addressed storage The Serializer and Deserializer Interfaces // org.https://blog.devops-monk.com/tutorials/spring-data-jpa/custom-type-conversions/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/custom-type-conversions/Introduction JPA handles most Java types automatically — String, Integer, LocalDate, BigDecimal. But what about a Java enum? A List&lt;String&gt; stored as JSON? A custom Money type? JPA&rsquo;s AttributeConverter and @Enumerated let you control exactly how any Java type maps to a database column. Mapping Enums with @Enumerated Java enums are common in domain models. JPA maps them with @Enumerated: public enum OrderStatus { PENDING, CONFIRMED, SHIPPED, DELIVERED, CANCELLED } public enum ProductStatus { ACTIVE, INACTIVE, DISCONTINUED } @Column(length = 20, nullable = false) @Enumerated(EnumType.https://blog.devops-monk.com/tutorials/java8/date-time-api/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/date-time-api/Why java.util.Date Had to Go If you have ever tracked down a bug caused by a SimpleDateFormat shared across threads, or spent an afternoon understanding why a Calendar.get(Calendar.MONTH) returns 0 for January, you will appreciate why JSR-310 was one of the most eagerly anticipated Java 8 features. The new java.time API is not a patch on the old API — it is a complete redesign that makes an entire class of date and time bugs impossible by construction.https://blog.devops-monk.com/tutorials/spring-kafka/dead-letter-topics/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/dead-letter-topics/What Is a Dead Letter Topic? When a record fails processing and retries are exhausted, you have two options: skip it (losing the data) or park it somewhere for inspection and reprocessing. A dead-letter topic (DLT) is that parking lot — a Kafka topic that holds records that could not be processed, enriched with error metadata headers. flowchart LR subgraph Main["orders topic"] R1["record: offset 42\n(bad data)"] end subgraph DLT["orders.DLT topic"] R2["https://blog.devops-monk.com/tutorials/java8/default-static-methods/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/default-static-methods/The Problem: Evolving Interfaces Without Breaking Implementations Default methods solved a problem that had blocked the Java Collections team from improving the core APIs for years: how do you add methods to an interface without breaking every existing implementation? The answer Java 8 gave — concrete implementations on the interface itself — has wider implications than just Collection.stream(). It is the mechanism behind the fluent Comparator API, the Predicate composition methods, and the design pattern of composable interface contracts.https://blog.devops-monk.com/tutorials/spring-data-jpa/derived-query-methods/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/derived-query-methods/Introduction Spring Data JPA can generate JPQL queries directly from method names. You declare a method like findByStatusAndPriceGreaterThan, and Spring Data parses the name, derives the query, and generates the implementation. No SQL, no @Query, no boilerplate. How Derived Query Parsing Works Spring Data JPA splits method names into a subject and a predicate: findBy Email And Status ↑ ↑ ↑ ↑ subject property operator property The subject determines the operation type (find, count, exists, delete).https://blog.devops-monk.com/tutorials/spring-data-jpa/dirty-checking-flush-modes/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/dirty-checking-flush-modes/The Persistence Context Revisited Article 3 introduced the persistence context — the in-memory cache of managed entities. This article goes deeper: how does the persistence context detect changes? When does it flush them to the database? And how can you tune this behaviour? Dirty Checking When you modify a managed entity, you don&rsquo;t call save() or update(). You simply change the field: @Transactional public void giveDiscount(Long productId, BigDecimal discount) { Product product = productRepository.https://blog.devops-monk.com/tutorials/spring-security/domain-object-acl/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/domain-object-acl/What ACLs Solve Role-based access control answers: &ldquo;Can this user perform this action?&rdquo; ACLs answer: &ldquo;Can this user perform this action on this specific object?&rdquo; Consider a document management system: Alice owns Document #42 — she can read and edit it Bob is a reviewer on Document #42 — he can read it but not edit Carol has no permission on Document #42 — she gets a 403 This cannot be expressed with roles alone.https://blog.devops-monk.com/tutorials/spring-kafka/dynamic-listeners/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/dynamic-listeners/Why Dynamic Listeners? @KafkaListener is declared at compile time. Some scenarios require listeners created at runtime: Multi-tenant SaaS — each tenant onboards to their own topic; you can&rsquo;t redeploy to add @KafkaListener for each new tenant Feature flags — enable or disable a listener without a deployment Plugin systems — modules register their own topic subscriptions when loaded Admin APIs — operators subscribe to new topics via a REST endpoint ConcurrentMessageListenerContainer The core building block is ConcurrentMessageListenerContainer — the same class @KafkaListener uses internally, but constructed and started manually:https://blog.devops-monk.com/tutorials/spring-data-jpa/embedded-types-value-objects/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/embedded-types-value-objects/Introduction Not every concept in your domain deserves its own table. An Address — street, city, state, postal code — is a value object: it has no identity of its own, it belongs to an entity. JPA&rsquo;s @Embeddable lets you model this as a separate Java class while storing it in the owning entity&rsquo;s table. What Is an Embeddable? An @Embeddable class is a Java class whose fields are mapped to columns in the owning entity&rsquo;s table — not a separate table.https://blog.devops-monk.com/tutorials/java17/enhanced-prng/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/enhanced-prng/Finalized in Java 17 (JEP 356). The Problem with Java&rsquo;s Old PRNG API Java&rsquo;s random number generation before Java 17 had several problems: 1. java.util.Random has poor statistical properties. The default PRNG algorithm is a 48-bit linear congruential generator (LCG). It fails many statistical tests (spectral test, birthday test). Its 2^48 period is short — exhaustible in seconds on modern hardware. 2. No common interface. java.util.Random, java.util.concurrent.ThreadLocalRandom, java.util.SplittableRandom, and java.https://blog.devops-monk.com/tutorials/spring-data-jpa/entity-graphs-batch-loading/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/entity-graphs-batch-loading/The Problem @EntityGraph Solves JOIN FETCH in @Query solves N+1 but creates inflexibility: the fetch plan is baked into the query. Two different use cases — an order detail page (needs items + customer) and an order list page (needs only customer) — require two different queries with different JOIN FETCHes. @EntityGraph separates the fetch plan from the query. You define what to load at the call site, and Spring Data JPA generates the appropriate JOIN.https://blog.devops-monk.com/tutorials/spring-data-jpa/entity-lifecycle-states/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/entity-lifecycle-states/Introduction Every JPA entity is always in one of four states. The state determines whether Hibernate is tracking the entity, whether changes are detected automatically, and what operations are valid. Understanding these states explains a large class of JPA bugs — especially the dreaded LazyInitializationException and detached entity errors. The Four States new Customer() │ │ persist / save() ▼ TRANSIENT ──────────────────────► MANAGED (not tracked) (tracked by persistence context) │ │ evict / clear / close ▼ DETACHED (no longer tracked) │ │ merge() ▼ MANAGED (re-attached) MANAGED ─── remove / delete() ──► REMOVED (delete scheduled, still in context) 1.https://blog.devops-monk.com/tutorials/spring-kafka/error-handling-basics/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/error-handling-basics/What Happens When a Listener Throws? Without an error handler, an uncaught exception from @KafkaListener causes the container to log the error and retry the same record on the next poll — indefinitely. One bad record can block an entire partition forever. DefaultErrorHandler fixes this: it retries a configurable number of times with backoff, then calls a ConsumerRecordRecoverer (e.g. send to a dead-letter topic) and moves on. DefaultErrorHandler — The Modern API Spring Kafka 2.https://blog.devops-monk.com/tutorials/spring-data-jpa/fetch-types-eager-vs-lazy/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/fetch-types-eager-vs-lazy/Introduction Every relationship in JPA has a fetch type: either EAGER (load immediately with the parent) or LAZY (load only when accessed). The defaults are counterintuitive, and getting fetch types wrong is one of the top causes of performance problems and LazyInitializationException in JPA applications. Default Fetch Types Annotation Default fetch type Performance risk @ManyToOne EAGER Loads related entity on every query — can be expensive @OneToOne EAGER Same — loads profile/address on every customer load @OneToMany LAZY Correct default — collections are only loaded when needed @ManyToMany LAZY Correct default The defaults for @ManyToOne and @OneToOne are EAGER — a poor choice that the JPA spec made for historical reasons.https://blog.devops-monk.com/tutorials/java11/files-io-api/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/files-io-api/The Problem: File IO Boilerplate Reading a file&rsquo;s content in Java 8 required several lines of boilerplate, even for simple tasks: // Java 8 — read entire file as String String content; try (var reader = new BufferedReader(new FileReader(&#34;config.txt&#34;))) { content = reader.lines().collect(Collectors.joining(&#34;\n&#34;)); } // Java 8 — write a String to a file try (var writer = new BufferedWriter(new FileWriter(&#34;output.txt&#34;))) { writer.write(content); } Java 11 reduced this to one-liners.https://blog.devops-monk.com/tutorials/spring-kafka/message-filtering/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/message-filtering/Why Filter at the Container Level? Multiple consumers can share a topic. The inventory service only cares about PLACED orders; the analytics service wants everything. Rather than putting if (event.getStatus() != PLACED) return; at the top of every listener, Spring Kafka lets you filter records before they reach your method — keeping business logic clean and making the filter reusable across listeners. How RecordFilterStrategy Works flowchart LR Broker -->|"poll() → [r1, r2, r3, r4]"https://blog.devops-monk.com/tutorials/java11/flight-recorder/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/flight-recorder/What Is Java Flight Recorder? Java Flight Recorder (JFR) is a low-overhead, always-on profiling and diagnostics framework built into the JVM. It was a commercial feature of Oracle JDK until JEP 328 (Java 11) open-sourced it as part of OpenJDK. JFR collects data about JVM internals and application behaviour — method profiling, allocation, GC pauses, thread states, I/O, lock contention — with a typical overhead of 1–2% in production. This makes it fundamentally different from traditional profilers (JProfiler, YourKit): those profilers cause 10–50% overhead, making them impractical for production.https://blog.devops-monk.com/tutorials/java17/foreign-function-memory/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/foreign-function-memory/Incubator Feature in Java 17 (JEP 412 — First Incubator). Package: jdk.incubator.foreign. Requires --add-modules jdk.incubator.foreign at compile and runtime. This API evolved significantly across Java 18 (JEP 419), 19 (JEP 424), 20 (JEP 434), and was finalized in Java 22 (JEP 454). See the Java 21 article series for the final API. This article covers the Java 17 incubator version and the Project Panama vision. Why Replace JNI? Java Native Interface (JNI) has been the way to call native code from Java since Java 1.https://blog.devops-monk.com/tutorials/java21/foreign-function-memory/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/foreign-function-memory/Preview Feature in Java 21 — Finalized in Java 22 (JEP 454). The API shown here is the Java 21 preview version; it is nearly identical to the final API. Why Replace JNI? Java Native Interface (JNI) has been the standard way to call native code since Java 1.1. It works but is notoriously painful: Requires writing C wrapper code for every native call Native method signatures must exactly match Java declarations (or you get silent crashes) Memory management is manual — leak native memory once and you have a slow memory leak JNI calls disable JIT optimizations around the call site Debugging native crashes through JNI is extremely difficult The Foreign Function &amp; Memory (FFM) API replaces all of this: call native functions directly from Java, manage native memory safely with automatic lifetime management, and do it without writing a single line of C.https://blog.devops-monk.com/tutorials/spring-security/form-login/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/form-login/Form Login: The Classic Web Authentication Flow Form login is the traditional authentication mechanism for server-rendered web applications. The user fills in a username and password form, the server verifies credentials, creates a session, and returns a session cookie. All subsequent requests carry that cookie. sequenceDiagram participant Browser participant SSF as Spring Security Filters participant AM as AuthenticationManager participant SS as HTTP Session Store participant Controller Browser->>SSF: GET /dashboard (unauthenticated) SSF->>SS: Save original request (RequestCache) SSF-->>Browser: 302 Redirect to /login Browser->>SSF: GET /login SSF-->>Browser: 200 HTML login page Browser->>SSF: POST /login {username, password} SSF->>AM: authenticate(UsernamePasswordToken) AM-->>SSF: Authentication (success) SSF->>SS: Store SecurityContext in session SSF-->>Browser: 302 Redirect to /dashboard\nSet-Cookie: JSESSIONID=abc123 Browser->>SSF: GET /dashboard (JSESSIONID cookie) SSF->>SS: Load SecurityContext from session SSF->>Controller: Request with authenticated user Controller-->>Browser: 200 Dashboard HTML Minimal Configuration @Configuration @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { http .https://blog.devops-monk.com/tutorials/java8/functional-interfaces/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/functional-interfaces/What Is a Functional Interface? Functional interfaces are the type system bridge that makes lambda expressions work in Java 8. Without them, the compiler would have no way to know what type to assign to a lambda. Once you understand how the 43 built-in interfaces in java.util.function are organised — and when to write your own — you will find that the same patterns (compose, chain, validate, transform) appear everywhere in a Java 8 codebase.https://blog.devops-monk.com/tutorials/java11/garbage-collection/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/garbage-collection/GC Changes Across Java 9–11 Release Change JEP Java 9 G1GC becomes the default GC JEP 248 Java 9 Unified GC logging (-Xlog:gc*) JEP 271 Java 10 Parallel Full GC for G1 JEP 307 Java 10 Application Class-Data Sharing (AppCDS) JEP 310 Java 11 Epsilon: No-Op GC JEP 318 Java 11 ZGC: Scalable Low-Latency GC (experimental) JEP 333 G1GC as Default (JEP 248, Java 9) G1 (Garbage-First) replaced Parallel GC as the default on systems with ≥2 CPUs and ≥2 GB heap.https://blog.devops-monk.com/tutorials/java21/generational-zgc/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/generational-zgc/Why GC Still Matters in 2024 Even with better APIs and faster hardware, garbage collection pauses remain one of the top causes of latency spikes in Java services. A 200ms GC pause in a payment processing service is a customer-visible failure. A 50ms pause in a trading system is a missed execution window. Java 21 delivers Generational ZGC — the most capable GC Java has ever shipped — as a production-ready, non-preview feature.https://blog.devops-monk.com/tutorials/spring-kafka/deserialization-errors/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/deserialization-errors/The Problem: Poison Pills at Deserialization Time A malformed byte sequence — truncated JSON, wrong Avro schema, corrupt payload — throws an exception during deserialization, before the listener method is called. Without special handling, this record blocks the partition indefinitely: the consumer fetches it, fails to deserialize, and fetches it again on the next poll. sequenceDiagram participant Broker participant Container participant Deserializer loop forever without ErrorHandlingDeserializer Container->>Broker: poll() Broker-->>Container: [good-record, CORRUPT-RECORD, good-record] Container->>Deserializer: deserialize(CORRUPT-RECORD) Deserializer-->>Container: JsonProcessingException 💥 Note over Container: Partition blocked — same record on every poll end ErrorHandlingDeserializer solves this by catching the deserialization exception and wrapping it in a DeserializationException that the listener container can route to the error handler.https://blog.devops-monk.com/tutorials/spring-security/how-spring-security-works/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/how-spring-security-works/Why Spring Security Is Hard to Learn Spring Security is not complex because the concepts are complex. Authentication and authorization are straightforward ideas. Spring Security is hard because it hides its machinery: a request comes in, something happens, an endpoint is secured or not — and without knowing the internal architecture, the behaviour feels magical and the configuration feels arbitrary. This article removes the magic. By the end, you will have the mental model needed to understand every other concept in this series.https://blog.devops-monk.com/tutorials/spring-security/http-authorization/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/http-authorization/HTTP Authorization: The Last Line of Defense AuthorizationFilter is the last filter in the Spring Security chain. After all authentication filters have run (and either set an Authentication or left it as anonymous), AuthorizationFilter makes the final access decision: allow or deny. The rules you write in authorizeHttpRequests() are evaluated in order, first match wins. flowchart TD Request[HTTP Request] --> Auth[AuthorizationFilter] Auth --> Rules{Evaluate rules\nin order} Rules -->|Rule 1 matches| Decision1{Allowed?https://blog.devops-monk.com/tutorials/spring-security/http-basic-authentication/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/http-basic-authentication/What Is HTTP Basic Authentication? HTTP Basic is the simplest authentication scheme defined in the HTTP specification (RFC 7617). The client encodes username:password in Base64 and sends it in the Authorization header with every request: Authorization: Basic YWxpY2U6c2VjcmV0 ↑ Base64(&#34;alice:secret&#34;) Important: Base64 is encoding, not encryption. Anyone who intercepts the request can decode the credentials instantly. HTTP Basic must only be used over HTTPS. sequenceDiagram participant Client as API Client participant SSF as Spring Security Filters participant AM as AuthenticationManager Client->>SSF: GET /api/data\n(no Authorization header) SSF-->>Client: 401 Unauthorized\nWWW-Authenticate: Basic realm="https://blog.devops-monk.com/tutorials/java11/http-client-api/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/http-client-api/Why a New HTTP Client? HttpURLConnection — Java&rsquo;s HTTP API since Java 1.1 — has deep design problems: Mutable shared state makes it error-prone in multithreaded code No built-in HTTP/2 support No built-in async; non-blocking requires manual thread management Clunky API: setDoOutput(true), getOutputStream(), connect() in sequence No support for reactive streams JEP 321 (Java 11) standardised the HTTP Client API that was incubating since Java 9. The new API lives in java.https://blog.devops-monk.com/tutorials/spring-kafka/idempotent-producer/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/idempotent-producer/The Duplicate Problem With acks=all and retries enabled, a produce request might be acknowledged by the broker, but the acknowledgment is lost in the network before reaching the producer. The producer, seeing no response, retries — sending the same record again. The broker writes it a second time. The consumer sees a duplicate. sequenceDiagram participant Producer participant Leader as Broker (Leader) Producer->>Leader: ProduceRequest: OrderPlaced (orderId=1001) Leader->>Leader: Write record at offset 42 ✓ Leader--xProducer: ProduceResponse LOST (network failure) Note over Producer: No ack received — retrying Producer->>Leader: ProduceRequest: OrderPlaced (orderId=1001) [RETRY] Leader->>Leader: Write record at offset 43 ✓ (DUPLICATE!https://blog.devops-monk.com/tutorials/spring-data-jpa/inheritance-strategies/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/inheritance-strategies/Introduction Object-oriented code uses inheritance to share behaviour. Relational databases have no concept of inheritance. JPA bridges this gap with three strategies for mapping a class hierarchy to tables. Understanding when each is appropriate prevents schema headaches and performance problems. The Domain Example An e-commerce system has different types of discount: Discount (abstract) ├── PercentageDiscount (e.g., 10% off) └── FixedAmountDiscount (e.g., $5 off) All discounts share: id, name, validFrom, validUntil. PercentageDiscount adds: percentage (e.https://blog.devops-monk.com/tutorials/spring-data-jpa/introduction-jpa-hibernate-spring-data/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/introduction-jpa-hibernate-spring-data/Introduction Every Spring Boot application that touches a relational database eventually encounters three terms used almost interchangeably: JPA, Hibernate, and Spring Data JPA. They are related but distinct, and understanding the difference is essential before writing a single line of mapping code. This article explains what each one is, how they fit together, and why this stack is the dominant approach to Java database access. The Problem: Object-Relational Impedance Mismatch Java applications work with objects: classes, inheritance, collections, references.https://blog.devops-monk.com/tutorials/java11/java11-overview/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/java11-overview/Why Java 11 Matters Java 8 was released in March 2014. It dominated enterprise Java for nearly a decade, but it misses a decade&rsquo;s worth of language improvements, API modernisation, JVM advances, and security hardening. Java 11 (September 2018) is the first Long-Term Support release after Java 8, and it packages three releases of evolution into a single supported baseline. For most teams the question is not whether to upgrade, but how.https://blog.devops-monk.com/tutorials/java11/production-best-practices/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/production-best-practices/Production Readiness Checklist [ ] JDK distribution chosen and version pinned [ ] Heap and Metaspace sized correctly [ ] GC selected and tuned for your workload [ ] Container-aware JVM flags set [ ] AppCDS archive built for faster startup [ ] JFR always-on recording configured [ ] GC logging enabled with rotation [ ] Security-related algorithms locked down [ ] Thread and connection pool sizes verified [ ] JVM exit flags prevent silent crashes Baseline JVM Flags for Java 11 Start with these flags and tune from here:https://blog.devops-monk.com/tutorials/java17/production-best-practices/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/production-best-practices/Production Baseline JVM Flags Start every Java 17 production deployment with this baseline: java \ # GC — choose one (see GC section) -XX:+UseG1GC \ -XX:MaxGCPauseMillis=200 \ \ # Heap sizing -Xms4g -Xmx4g \ \ # GC logging — essential for diagnosis -Xlog:gc*:file=/var/log/app/gc.log:time,uptime,level,tags:filecount=5,filesize=20m \ \ # OOM diagnostics -XX:+HeapDumpOnOutOfMemoryError \ -XX:HeapDumpPath=/var/log/app/heap-dump.hprof \ -XX:+ExitOnOutOfMemoryError \ \ # Metaspace -XX:MaxMetaspaceSize=512m \ \ # Code cache -XX:ReservedCodeCacheSize=512m \ \ # JFR — always-on profiling -XX:StartFlightRecording=duration=0,filename=/var/log/app/profile.https://blog.devops-monk.com/tutorials/java17/java17-overview/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/java17-overview/Java 17: The Landmark LTS Java 17 was released on September 14, 2021 as a Long-Term Support (LTS) release. It is the successor to Java 11 (released September 2018) as the recommended production baseline for enterprise and cloud Java deployments. Between Java 11 and Java 17, six non-LTS releases (Java 12 through 16) delivered a continuous stream of language improvements on a six-month cadence. Java 17 is where five of the most important new features — Records, Sealed Classes, Pattern Matching for instanceof, Text Blocks, and Switch Expressions — all reached their final, production-ready status simultaneously.https://blog.devops-monk.com/tutorials/java21/production-best-practices/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/production-best-practices/The Production Mindset Migrating to Java 21 unlocks new capabilities, but production readiness requires deliberate configuration. The JVM defaults are conservative — designed to work reasonably across a wide range of workloads, not to be optimal for any specific one. This article covers: Which JVM flags to set for every production Java 21 deployment GC selection and tuning for different workload profiles Virtual thread configuration and monitoring Container-aware JVM settings Observability and profiling Startup and memory optimization JVM Flags: The Production Baseline Start every Java 21 production deployment with this baseline flag set:https://blog.devops-monk.com/tutorials/java21/java21-overview/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/java21-overview/Why Java 21 Is Different Every third Java release is an LTS — Long-Term Support. Java 21 is the fourth LTS after Java 8, 11, and 17. But unlike previous LTS releases, which were largely incremental, Java 21 delivers features that fundamentally change how you write concurrent code, how the JVM manages memory and GC, and how Java competes with dynamic languages for expressiveness. Three years of Project Loom work lands as Virtual Threads — production-ready, requiring zero framework changes for most Spring Boot or Jakarta EE applications.https://blog.devops-monk.com/tutorials/java8/java8-best-practices/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/java8-best-practices/Introduction Java 8 introduced a fundamentally different programming model. The features — lambdas, streams, Optional, CompletableFuture — interact with each other in ways that produce clean, readable code when used correctly and confusing, brittle code when used incorrectly. This article consolidates the most important production-ready guidance from across the series into a single reference, along with the migration checklist for moving a Java 7 codebase to Java 8. Streams Best Practices Do: Use streams for transformations and aggregations // Good: filter → transform → collect List&lt;String&gt; premiumNames = customers.https://blog.devops-monk.com/tutorials/java8/java8-overview/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/java8-overview/Before We Start — Feel the Difference You&rsquo;re about to learn Java 8. Before diving into history and theory, let&rsquo;s just feel what changed. Here&rsquo;s the same task written in Java 7 and Java 8: Task: Find all names that start with &ldquo;A&rdquo;, uppercase them, sort them, and collect into a list. // Java 7 — 10 lines, two passes, one temporary variable, zero joy List&lt;String&gt; result = new ArrayList&lt;&gt;(); for (String name : names) { if (name.https://blog.devops-monk.com/tutorials/java17/jdk-encapsulation-removed-apis/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/jdk-encapsulation-removed-apis/Overview Java 17 includes several platform changes that can break existing code during migration. This article covers four JEPs that affect compatibility: JEP Change Impact 403 Strongly Encapsulate JDK Internals HIGH — breaks libraries using internal APIs 407 Remove RMI Activation LOW — niche feature, deprecated since Java 15 411 Deprecate Security Manager MEDIUM — some applications use SecurityManager 306 Restore Always-Strict Floating-Point LOW — affects numeric edge cases JEP 403: Strongly Encapsulate JDK Internals What Changed In Java 8 and earlier, code could access any JDK internal API via reflection — setAccessible(true) bypassed access controls.https://blog.devops-monk.com/tutorials/spring-kafka/json-serialization/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/json-serialization/The Serialization Problem Kafka stores bytes. KafkaTemplate&lt;String, OrderPlacedEvent&gt; needs to turn your Java object into bytes for the producer, and @KafkaListener needs to turn those bytes back into the right Java class on the consumer. Spring Kafka ships JsonSerializer and JsonDeserializer built on Jackson to handle this — but they have several sharp edges that break in real multi-service deployments. How Spring Kafka JSON Serialization Works flowchart LR subgraph Producer["Order Service"https://blog.devops-monk.com/tutorials/java8/jvm-improvements/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/jvm-improvements/PermGen Removal: The End of a Classic Error OutOfMemoryError: PermGen space was the Java error that launched a thousand Stack Overflow questions. Application servers would run fine for hours and then fall over during a hot redeploy. The fix — adding more -XX:MaxPermSize — was a band-aid. Java 8 removed the underlying problem entirely. Before Java 8, the JVM heap was divided into several regions. One of them — Permanent Generation (PermGen) — held class metadata, interned strings, and bytecode.https://blog.devops-monk.com/tutorials/spring-security/jwt-authentication/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/jwt-authentication/What Is JWT? JWT (JSON Web Token, RFC 7519) is a compact, URL-safe token format for representing claims between two parties. It is the standard for stateless REST API authentication — the server issues a signed token at login, and the client presents it on every subsequent request. No session, no cookie, no server-side state. JWT Structure A JWT has three Base64URL-encoded parts separated by dots: eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJhbGljZSIsInJvbGVzIjpbIlJPTEVfVVNFUiJdfQ.signature Header Payload Signature block-beta columns 3 A["https://blog.devops-monk.com/tutorials/spring-kafka/kafka-architecture/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/kafka-architecture/The Cluster: Brokers and the Controller A Kafka cluster is a group of servers, each called a broker. Brokers store data and serve producer/consumer requests. One broker in the cluster acts as the controller — it manages partition leadership, handles broker joins and departures, and coordinates rebalancing. In KRaft mode (Kafka 3.3+, the default from Kafka 4.0), the controller is built into Kafka itself — no ZooKeeper needed. flowchart TB subgraph Cluster["https://blog.devops-monk.com/tutorials/spring-kafka/kafka-consumer-basics/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/kafka-consumer-basics/How @KafkaListener Works @KafkaListener is a Spring Kafka annotation that registers a method as a Kafka consumer. Under the hood, Spring Kafka creates a ConcurrentMessageListenerContainer — a managed thread pool that continuously polls the broker and dispatches records to your method. flowchart LR Broker["Kafka Broker"] subgraph Container["ConcurrentMessageListenerContainer"] T1["Poll Thread 1\n(Partition 0)"] T2["Poll Thread 2\n(Partition 1)"] T3["Poll Thread 3\n(Partition 2)"] end Method["@KafkaListener\nvoid onOrderPlaced(...)"] Broker -->|"fetch records"| T1 Broker -->|"fetch records"| T2 Broker -->|"https://blog.devops-monk.com/tutorials/spring-kafka/kafka-producer-basics/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/kafka-producer-basics/How a Spring Kafka Producer Works KafkaTemplate is the central Spring Kafka class for sending messages. It wraps the native Kafka KafkaProducer, manages serialization, and provides a Spring-friendly API for sending records. flowchart LR App["Your Service\n(OrderService)"] KT["KafkaTemplate\n(Spring Kafka)"] Buffer["Producer Buffer\n(RecordAccumulator)"] Sender["Sender Thread\n(NetworkClient)"] Broker["Kafka Broker\n(Leader Partition)"] App -->|"send(topic, key, value)"| KT KT -->|serialize + route| Buffer Buffer -->|batch when full\nor linger.ms elapsed| Sender Sender -->|ProduceRequest| Broker Broker -->|ProduceResponse| Sender Sender -->|callback| App The send is asynchronous by default — KafkaTemplate.https://blog.devops-monk.com/tutorials/spring-kafka/kafka-streams/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/kafka-streams/Kafka Streams vs @KafkaListener @KafkaListener is a consumer — it reads records and processes them one by one or in batches. Kafka Streams is a stream processing library — it builds a topology of transformations that runs continuously, with built-in state stores, windowed aggregations, and join operations. Aspect @KafkaListener Kafka Streams Processing model Consume and process Topology of operators Stateful processing Manual (external DB) Built-in state stores (RocksDB) Windowed aggregations Manual Native (time, session, hopping) Joins Manual KStream-KTable, KStream-KStream Fault tolerance Committed offsets Changelog topics + offsets Use when Imperative event handling Stream transformations and aggregations Maven Dependency &lt;dependency&gt; &lt;groupId&gt;org.https://blog.devops-monk.com/tutorials/spring-kafka/transactions-eos/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/transactions-eos/Why Transactions? At-least-once delivery means a record can be processed and produced more than once after a crash. For most applications, idempotent consumers handle this. But when you need a hard guarantee — either the produce happens and the offset commits, or neither does — you need Kafka transactions. Common scenarios: Consume → transform → produce (read from one topic, write to another) where partial completion is unacceptable Exactly-once aggregations in financial or billing systems Atomic multi-topic produce where records to multiple topics must all land or none land How Kafka Transactions Work sequenceDiagram participant Producer participant Broker participant Consumer Producer->>Broker: initTransactions() [registers transactional.https://blog.devops-monk.com/tutorials/spring-kafka/kafka-admin/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/kafka-admin/Why Manage Topics Programmatically? CLI commands work for one-time setup. Production services need: Startup validation — verify required topics exist before the application starts Auto-provisioning — create topics at deployment time with correct config Dynamic tenant onboarding — create per-tenant topics at runtime Config drift detection — compare actual topic config against expected values Spring Kafka provides KafkaAdmin for declarative topic management and AdminClient for imperative operations. KafkaAdmin — Declarative Topic Creation Declare NewTopic beans — Spring Kafka creates them at startup if they don&rsquo;t exist:https://blog.devops-monk.com/tutorials/java21/kem-api/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/kem-api/Why Post-Quantum Cryptography Now? Classical public-key cryptography (RSA, ECDH) relies on mathematical problems that are hard for classical computers — factoring large integers or solving the discrete logarithm problem. A sufficiently powerful quantum computer running Shor&rsquo;s algorithm could solve these problems efficiently, breaking all existing RSA and ECC-based security. Quantum computers capable of breaking 2048-bit RSA don&rsquo;t exist yet. But &ldquo;harvest now, decrypt later&rdquo; attacks are real: adversaries intercept and store encrypted traffic today, planning to decrypt it once quantum computers mature.https://blog.devops-monk.com/tutorials/java8/lambdas/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/lambdas/The Problem Lambdas Solve Every Java 7 developer has written the same five lines of boilerplate to sort a list or run a background task. Lambda expressions eliminate that ceremony entirely — and once you understand target typing, closures, and composition, you will find yourself reaching for them in every layer of a codebase: validation pipelines, event systems, retry logic, and beyond. Before Java 8, passing behaviour as a value required an anonymous inner class:https://blog.devops-monk.com/tutorials/spring-security/ldap-authentication/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/ldap-authentication/LDAP in the Enterprise LDAP (Lightweight Directory Access Protocol) is the standard protocol for directory services. Microsoft Active Directory, OpenLDAP, and many other enterprise identity providers use LDAP. If your application must authenticate users from a corporate directory, LDAP integration is the path. sequenceDiagram participant Client participant SpringSecurity as Spring Security participant LDAP as LDAP / Active Directory Client->>SpringSecurity: POST /login {username, password} SpringSecurity->>LDAP: Bind as service account (manager DN) LDAP-->>SpringSecurity: Bind success SpringSecurity->>LDAP: Search for user:\n(uid=alice,ou=users,dc=example,dc=com) LDAP-->>SpringSecurity: User DN found SpringSecurity->>LDAP: Bind as user (verify password) LDAP-->>SpringSecurity: Bind success = password correct SpringSecurity->>LDAP: Search groups for user LDAP-->>SpringSecurity: Groups: [cn=developers, cn=devops] SpringSecurity->>SpringSecurity: Map groups to roles SpringSecurity-->>Client: Authentication success (ROLE_DEVELOPER, ROLE_DEVOPS) Dependencies &lt;!https://blog.devops-monk.com/tutorials/spring-data-jpa/many-to-many-relationships/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/many-to-many-relationships/Introduction A many-to-many relationship means records in table A can relate to many records in table B, and vice versa. Products have many tags; tags apply to many products. In SQL this requires a join table. In JPA, @ManyToMany and @JoinTable handle this automatically — but when you need extra data on the join (like a creation date or a relevance score), you need a different approach. Simple @ManyToMany: Product and Tag products (*) ──── product_tags ──── (*) tags The product_tags join table has two columns: product_id and tag_id.https://blog.devops-monk.com/tutorials/spring-kafka/message-headers/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/message-headers/What Are Kafka Record Headers? Every Kafka record carries a list of Header objects — key-value pairs of String key and byte[] value. They sit outside the message payload and are ideal for: Trace propagation — carry X-Trace-Id / X-Span-Id across service boundaries Correlation IDs — link a response to a request in async flows Routing metadata — signal which region, tenant, or feature flag applies Schema type hints — __TypeId__ (set automatically by JsonSerializer) Event versioning — indicate schema version without modifying the payload flowchart LR subgraph Record["https://blog.devops-monk.com/tutorials/java8/method-references/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/method-references/What Are Method References? Method references are a signal to the reader: &ldquo;this lambda does exactly one thing — it calls this existing method.&rdquo; When the entire body of a lambda is a single method call, replacing it with a method reference removes noise without losing information. Knowing which of the four kinds to apply in each context is what separates fluent Java 8 code from code that merely uses the syntax.https://blog.devops-monk.com/tutorials/spring-security/method-security/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/method-security/Why Method Security Exists URL-based authorization in authorizeHttpRequests() protects HTTP endpoints, but it has blind spots: The same service method may be called from multiple controllers, scheduled tasks, or message listeners — none of which pass through the HTTP filter chain Fine-grained rules based on method arguments or return values cannot be expressed as URL patterns Authorization logic spread across a large security config is hard to read alongside the code it protects Method security moves the authorization decision to the method itself.https://blog.devops-monk.com/tutorials/java11/migration-guide/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/migration-guide/Migration Overview Migrating from Java 8 to Java 11 is the most common Java upgrade scenario. The migration has two distinct phases: Make it compile and run — fix incompatibilities introduced by Java 9–11 Modernise the code — adopt var, List.of(), String.isBlank(), and other new APIs Phase 1 is mandatory and blocks the upgrade. Phase 2 is optional and can happen incrementally. This guide focuses entirely on Phase 1. The 10-Step Migration Checklist [ ] 1.https://blog.devops-monk.com/tutorials/java17/migration-guide/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/migration-guide/Why Migrate to Java 17? Java 17 is the current recommended enterprise LTS. Key reasons to migrate now: Spring Boot 3.x requires Java 17 — the entire Spring ecosystem is moving here Java 11 extended support ends around 2026 depending on your vendor Java 8 mainstream support ended in 2019; extended support ended 2030 for Oracle JDK but active vulnerability exposure is increasing Language features: Records, Sealed Classes, Text Blocks, Pattern Matching, Switch Expressions — all available in Java 17 Security: Strong JDK encapsulation closes years of internal API exposure used in exploits Recommended Migration Path Java 8 → Java 11 → Java 17 Do not jump directly from Java 8 to Java 17 in one step if your codebase is large or has many third-party dependencies.https://blog.devops-monk.com/tutorials/java21/migration-guide/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/migration-guide/Why Migrate Now? Java 21 is the current Long-Term Support (LTS) release, and it is the most feature-rich LTS since Java 8. LTS releases receive security patches and bug fixes for years. Java 11, the previous widely-used LTS, reached its extended support window end depending on your vendor. Java 8 mainstream support ended in 2019. More concretely, Java 21 brings: Virtual Threads — drop-in replacement for platform threads, enabling massive concurrency without reactive rewrites Pattern Matching for switch and records — eliminating entire categories of verbose, error-prone instanceof/cast chains Sequenced Collections — a unified API for ordered collection types Generational ZGC — sub-millisecond GC pauses at any heap size These are not incremental improvements.https://blog.devops-monk.com/tutorials/java11/module-system/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/module-system/The Problem JPMS Solves Before Java 9, the JDK had no real notion of encapsulation at the library level. public meant accessible to everyone — including internal JDK classes like sun.misc.Unsafe and com.sun.internal.*. Large codebases suffered from: No reliable encapsulation: Any public class in any JAR was reachable from any other JAR. Classpath hell: Duplicate or conflicting classes from different JARs led to unpredictable behaviour. Monolithic JDK: The entire 60+ module JDK had to ship with every application.https://blog.devops-monk.com/tutorials/spring-kafka/monitoring/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/monitoring/What to Monitor in Kafka Production Kafka applications need visibility into: Consumer lag — how many records are unprocessed per partition Throughput — records produced and consumed per second Error rates — listener exceptions, DLT records, retry counts Producer latency — time from send() to broker acknowledgment Rebalance frequency — high rebalance rate signals consumer instability Dependencies &lt;!-- Micrometer Prometheus registry --&gt; &lt;dependency&gt; &lt;groupId&gt;io.micrometer&lt;/groupId&gt; &lt;artifactId&gt;micrometer-registry-prometheus&lt;/artifactId&gt; &lt;/dependency&gt; &lt;!-- Spring Boot Actuator --&gt; &lt;dependency&gt; &lt;groupId&gt;org.https://blog.devops-monk.com/tutorials/spring-security/multi-factor-authentication/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/multi-factor-authentication/Why MFA Matters A password alone is a single point of failure. Phishing, credential stuffing, and password reuse mean that knowing a password is not proof of identity. Multi-factor authentication requires something the user knows (password) and something they have (phone, hardware key) — compromising one factor is no longer sufficient. TOTP: Time-Based One-Time Passwords TOTP (RFC 6238) generates a 6-digit code that changes every 30 seconds, derived from a shared secret and the current time.https://blog.devops-monk.com/tutorials/spring-batch/multi-threaded-steps/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/multi-threaded-steps/Introduction A single-threaded Spring Batch step processes one chunk at a time — read N items, process N items, write N items, repeat. For large data sets this is a bottleneck. Spring Batch offers two in-JVM scaling options: Approach How it works Use when Multi-threaded step Multiple threads each process independent chunks Reader is thread-safe (JdbcPagingItemReader) AsyncItemProcessor Processing runs concurrently; writes remain sequential I/O-bound processors (REST calls, slow enrichment) This article covers both, plus the thread-safety requirements you must meet.https://blog.devops-monk.com/tutorials/java8/new-apis/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/new-apis/Base64 Before Java 8, Base64 encoding required a third-party library (Apache Commons Codec, Guava) or the internal sun.misc.BASE64Encoder class — an API that was never officially supported and was deliberately restricted from Java 9 onwards. Java 8 standardised encoding in java.util.Base64, which covers standard, URL-safe, and MIME variants and can wrap streams for large payloads. Java 8 added java.util.Base64 to the standard library. Three Encoders // Standard Base64 (RFC 4648) Base64.https://blog.devops-monk.com/tutorials/java11/string-methods/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/string-methods/New String Methods in Java 11 Java 11 added six new instance methods to java.lang.String. None require any imports — they are part of the standard String class. Method Returns Description isBlank() boolean True if string is empty or contains only whitespace lines() Stream&lt;String&gt; Stream of lines split by line terminators strip() String Removes leading and trailing Unicode whitespace stripLeading() String Removes leading Unicode whitespace only stripTrailing() String Removes trailing Unicode whitespace only repeat(int n) String Returns the string repeated n times isBlank() Returns true if the string is empty or contains only whitespace characters as defined by Character.https://blog.devops-monk.com/tutorials/spring-kafka/non-blocking-retries/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/non-blocking-retries/The Blocking Retry Problem DefaultErrorHandler retries by seeking back to the failed offset. While retrying, no other records from that partition are consumed — the partition is blocked. For a topic with high throughput, one slow retry can cause significant consumer lag. flowchart TD subgraph Blocking["Blocking Retry (DefaultErrorHandler)"] B1["poll() → [r50, r51, r52, r53]"] B2["process r50 ✓"] B3["process r51 ✗ — retry"] B4["wait 10s... retry r51 ✗"] B5["wait 20s... retry r51 ✗"https://blog.devops-monk.com/tutorials/spring-security/oauth2-fundamentals/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/oauth2-fundamentals/OAuth2 in One Sentence OAuth2 lets a user grant a third-party application limited access to their account on another service — without giving the third party their password. Classic example: &ldquo;Sign in with Google.&rdquo; Your app never sees the user&rsquo;s Google password. Google verifies the user&rsquo;s identity and gives your app a token with limited permissions. The Four OAuth2 Roles flowchart TD RO["**Resource Owner**\nThe user who owns the data\n(e.g. Alice, the Google account owner)"https://blog.devops-monk.com/tutorials/spring-security/oauth2-login/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/oauth2-login/What OAuth2 Login Does OAuth2LoginConfigurer implements the Authorization Code flow for user authentication. When a user clicks &ldquo;Sign in with Google&rdquo;: Spring redirects to Google&rsquo;s /authorize endpoint User authenticates on Google and grants consent Google redirects back to your app with a code Spring exchanges the code for tokens (back channel) Spring fetches the user profile from /userinfo Spring creates an OAuth2User and stores it in the SecurityContext Dependencies &lt;dependency&gt; &lt;groupId&gt;org.https://blog.devops-monk.com/tutorials/spring-security/oauth2-resource-server/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/oauth2-resource-server/What Is a Resource Server? In OAuth2, a Resource Server is an API that accepts access tokens and returns protected resources. It doesn&rsquo;t issue tokens — that&rsquo;s the Authorization Server&rsquo;s job. The Resource Server just validates tokens and enforces access control. flowchart LR Client[API Client\nor SPA/Mobile] -->|"1. POST /token\n{client_id, secret}"| AS[Authorization Server\nGoogle / Okta / Custom] AS -->|"2. access_token"| Client Client -->|"3. GET /api/products\nAuthorization: Bearer {token}"| RS[Your Spring Boot API\nResource Server] RS -->|"https://blog.devops-monk.com/tutorials/spring-kafka/offset-management/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/offset-management/Why Offset Management Matters The committed offset determines what happens when a consumer restarts. If the offset is committed too early, a crash before processing completes means events are lost. If it is committed too late, a crash after processing but before committing means events are re-processed. flowchart TD subgraph TooEarly["Commit too early → Data Loss"] E1["Commit offset 43"] --> E2["Process record 42"] --> E3["Crash!"] E4["Restart: resume from 43"] --> E5["https://blog.devops-monk.com/tutorials/spring-data-jpa/one-to-many-many-to-one/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/one-to-many-many-to-one/Introduction The one-to-many relationship is the most common in any domain model. An Order has many OrderItems. A Category has many Products. A Customer has many Orders. Understanding @OneToMany and @ManyToOne well — especially bidirectional mapping, collection types, and cascade configuration — is foundational to any JPA application. The Domain Example orders (1) ──────────────── (*) order_items An order has many order items. Each order item belongs to exactly one order.https://blog.devops-monk.com/tutorials/spring-data-jpa/one-to-one-relationships/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/one-to-one-relationships/Introduction A one-to-one relationship means one record in table A corresponds to exactly one record in table B. In JPA this is modelled with @OneToOne. Understanding where the foreign key lives, which side &ldquo;owns&rdquo; the relationship, and how cascade operations work is essential before moving to the more complex @OneToMany and @ManyToMany. The Domain Example In the e-commerce system, a Customer has one CustomerProfile containing their preferences and biography. A profile belongs to exactly one customer.https://blog.devops-monk.com/tutorials/spring-data-jpa/optimistic-pessimistic-locking/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/optimistic-pessimistic-locking/The Lost Update Problem Two users edit the same product simultaneously: Time User A User B T1 Load product (price=999) Load product (price=999) T2 Change price to 899 T3 Change price to 799 T4 Save → UPDATE price=899 T5 Save → UPDATE price=799 User A&rsquo;s change is silently overwritten. This is the lost update problem. Both JPA locking strategies prevent it — in different ways. Optimistic Locking with @Version Optimistic locking assumes conflicts are rare.https://blog.devops-monk.com/tutorials/java8/optional/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/optional/The Problem Optional Solves NullPointerException is the most common runtime exception in Java, and it is almost always avoidable. Optional&lt;T&gt; is not a magic fix — used incorrectly it becomes a more verbose null check. Used correctly, it encodes the possibility of absence directly in the type system, so callers can never &ldquo;forget&rdquo; to handle the empty case. This article covers both how to use Optional and — critically — how not to.https://blog.devops-monk.com/tutorials/spring-data-jpa/pagination-sorting/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/pagination-sorting/Why Pagination Matters Returning all rows from a database table is one of the most common production incidents. A query that works in development with 100 rows silently becomes a 10-second, 2 GB memory spike when production has 2 million rows. Pagination limits how many rows travel from the database to the application at a time. Spring Data JPA makes pagination a first-class feature — pass a Pageable to any repository method and get a Page&lt;T&gt; back.https://blog.devops-monk.com/tutorials/java8/parallel-streams/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/parallel-streams/How Parallel Streams Work Parallel streams are one of Java 8&rsquo;s most misused features. It is tempting to add .parallel() to any slow stream pipeline, but the performance characteristics are counterintuitive: parallel can make things slower for small data, and adding blocking I/O inside a parallel stream can stall the entire JVM. This article explains the mechanics, the cases where parallel genuinely helps, and the patterns to avoid. A parallel stream splits its source into sub-sequences, processes each sub-sequence on a separate thread, and merges the results.https://blog.devops-monk.com/tutorials/spring-batch/partitioning/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/partitioning/Introduction Multi-threaded steps (Article 20) run multiple chunks concurrently from a single reader. Partitioning is different — it splits the data into independent slices before processing starts, then runs each slice as its own StepExecution with its own reader, processor, writer, and metadata. This gives you: True independence between partitions — one partition&rsquo;s failure doesn&rsquo;t affect others A separate StepExecution row per partition in BATCH_STEP_EXECUTION — full visibility into per-partition progress The ability to distribute partitions across multiple JVMs (remote partitioning, covered in Article 22) Partitioning Architecture ManagerStep (PartitionStep) │ ├── Partitioner → creates N ExecutionContexts (one per partition) ├── PartitionHandler → distributes partitions to workers │ └── Worker Steps (run per partition) ├── ItemReader → reads only its slice of data ├── ItemProcessor └── ItemWriter The manager step runs once: it calls Partitioner.https://blog.devops-monk.com/tutorials/spring-security/password-encoding/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/password-encoding/Why Passwords Must Be Hashed Storing plaintext passwords is a critical security failure. When a database is breached, attackers immediately have every user&rsquo;s password — and because people reuse passwords, those credentials work on other sites too. Password hashing is not encryption. Encryption is reversible. Hashing is one-way: you can verify a password by hashing it and comparing to the stored hash, but you cannot recover the original password from the hash.https://blog.devops-monk.com/tutorials/spring-security/password-management/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/password-management/Secure Registration Registration is where passwords enter your system. Get it wrong here and no amount of downstream security saves you. The Registration Flow User submits form → Validate password strength → Check username/email uniqueness → Encode password with PasswordEncoder → Persist user (disabled) → Send verification email → User clicks link → enable account Registration Endpoint @RestController @RequestMapping(&#34;/auth&#34;) public class RegistrationController { private final UserService userService; private final PasswordEncoder passwordEncoder; @PostMapping(&#34;/register&#34;) public ResponseEntity&lt;Void&gt; register(@Valid @RequestBody RegistrationRequest request) { userService.https://blog.devops-monk.com/tutorials/java17/pattern-matching-instanceof/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/pattern-matching-instanceof/Finalized in Java 16 (JEP 394). Available in all Java 16+ releases, including Java 17. Previous previews: Java 14 (JEP 305) and Java 15 (JEP 375). The Problem: The instanceof-Cast Dance Every Java developer has written this pattern: // Java 11 — check, then cast if (obj instanceof String) { String s = (String) obj; // cast is logically redundant System.out.println(s.toUpperCase()); } The instanceof check already verified the type. The cast on the next line is conceptually redundant — the compiler could infer that obj is a String in the if body.https://blog.devops-monk.com/tutorials/java17/pattern-matching-switch-preview/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/pattern-matching-switch-preview/Preview Feature in Java 17 (JEP 406 — First Preview). Requires --enable-preview. This feature evolved through Java 18 (JEP 420), Java 19 (JEP 427), Java 20 (JEP 433), and was finalized in Java 21 (JEP 441). The Java 21 final version has minor syntax differences from this Java 17 preview — documented below. Enabling Preview Features Pattern matching for switch requires --enable-preview in Java 17. Add to your build tool:https://blog.devops-monk.com/tutorials/java21/pattern-matching-switch/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/pattern-matching-switch/The Problem: Cascading instanceof Chains Any Java codebase handling multiple subtypes has code like this: // Java 16 and earlier — the bad old way static double calculateArea(Shape shape) { if (shape instanceof Circle) { Circle c = (Circle) shape; return Math.PI * c.radius() * c.radius(); } else if (shape instanceof Rectangle) { Rectangle r = (Rectangle) shape; return r.width() * r.height(); } else if (shape instanceof Triangle) { Triangle t = (Triangle) shape; return 0.https://blog.devops-monk.com/tutorials/spring-kafka/listener-lifecycle/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/listener-lifecycle/Why Control Container Lifecycle? A running listener consumes from Kafka continuously. In production you need to: Pause consumption when a downstream service is overloaded (back-pressure) Resume once the downstream recovers Stop a container entirely during maintenance or feature flag toggles Restart after a configuration change without redeploying Spring Kafka exposes all of this through KafkaListenerEndpointRegistry and the container&rsquo;s own lifecycle API. Container States stateDiagram-v2 [*] --> Running : start() Running --> Paused : pause() Paused --> Running : resume() Running --> Stopped : stop() Stopped --> Running : start() Paused --> Stopped : stop() Running — polling Kafka, dispatching to listener Paused — broker connection maintained, consumer heartbeat sent, no new records fetched Stopped — consumer thread terminated, partitions released back to group Paused is preferable to stopped for temporary throttling: it avoids a rebalance and keeps the consumer&rsquo;s partition assignment intact.https://blog.devops-monk.com/tutorials/spring-batch/performance-tuning/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/performance-tuning/Introduction A poorly tuned batch job can be 10–100x slower than a well-tuned one. The biggest gains come from a handful of settings — chunk size, MySQL JDBC rewrite, connection pool alignment, and avoiding unnecessary object creation. This article covers each systematically. Chunk Size — The Most Impactful Setting Chunk size determines how many items are processed per transaction. Too small = too many round trips to the database. Too large = long transactions, high memory pressure, slower rollback on failure.https://blog.devops-monk.com/tutorials/spring-data-jpa/primary-keys-generated-values/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/primary-keys-generated-values/Introduction Primary key choice affects performance, scalability, and application design. This article covers every strategy JPA supports — from the simple AUTO_INCREMENT to UUID and composite keys — with the trade-offs of each. IDENTITY Strategy (MySQL AUTO_INCREMENT) GenerationType.IDENTITY delegates key generation to the database column&rsquo;s auto-increment feature. This is the standard for MySQL. @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; Generated DDL (when ddl-auto=create): id BIGINT NOT NULL AUTO_INCREMENT How IDENTITY works with Hibernate IDENTITY has one important behaviour: Hibernate cannot batch INSERT statements when using IDENTITY.https://blog.devops-monk.com/tutorials/spring-kafka/producer-bean-configuration/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/producer-bean-configuration/Why @Bean Configuration? application.properties is convenient for a single producer, but insufficient when you need: Multiple producers with different serializers (e.g. one for JSON events, one for Avro) Different settings per environment built at runtime (not just property substitution) Producers sending to different clusters (e.g. primary + DR cluster) Programmatic validation of configuration at startup flowchart TB subgraph PropertiesApproach["application.properties Approach"] P1["Single producer config\nspring.kafka.producer.*\n✓ Simple\n✗ One producer only\n✗ No runtime logic"] end subgraph BeanApproach["https://blog.devops-monk.com/tutorials/spring-kafka/producer-acknowledgments/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/producer-acknowledgments/What Are Acknowledgments? When a producer sends a record to a Kafka broker, it can wait for confirmation that the write was received and replicated before considering the send &ldquo;complete.&rdquo; The acks setting controls how much confirmation the producer requires. flowchart LR Producer["Producer"] Leader["Partition Leader\n(Broker 1)"] F1["Follower\n(Broker 2)"] F2["Follower\n(Broker 3)"] Producer -->|"ProduceRequest"| Leader Leader -->|"replicate"| F1 Leader -->|"replicate"| F2 Leader -->|"ProduceResponse ✓"| Producer style Producer fill:#3b82f6,color:#fff style Leader fill:#10b981,color:#fff The acknowledgment is the broker&rsquo;s confirmation to the producer.https://blog.devops-monk.com/tutorials/spring-kafka/producer-retries/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/producer-retries/Why Producers Need Retries Network errors, leader elections, and broker restarts are normal events in a distributed system. Without retries, a transient broker hiccup causes permanent data loss from the producer&rsquo;s perspective. With retries, the producer automatically re-sends failed records until either the broker accepts them or a timeout deadline is reached. sequenceDiagram participant Producer participant Leader as Leader (Broker 1) participant NewLeader as New Leader (Broker 2) Producer->>Leader: ProduceRequest (offset 42) Note over Leader: Broker 1 crashes mid-write Leader--xProducer: No response (timeout) Note over Producer: retry.https://blog.devops-monk.com/tutorials/spring-data-jpa/projections-dtos/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/projections-dtos/The Over-Fetching Problem By default, findAll() loads every column for every entity. A Product entity with 20 fields loads all 20 columns — even when a dropdown menu only needs id and name. This wastes bandwidth, memory, and query time. Projections let you define what shape the result should take, and Spring Data JPA generates a query that fetches only those columns. Interface Projections The simplest projection: declare an interface with getter methods matching entity field names.https://blog.devops-monk.com/tutorials/spring-security/reactive-security-webflux/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/reactive-security-webflux/Reactive vs. Servlet Security Spring Security&rsquo;s standard configuration targets Servlet-based applications (Spring MVC). Reactive applications built with Spring WebFlux run on a non-blocking event loop — there is no thread-per-request model, so ThreadLocal-based SecurityContextHolder does not work. Spring Security provides a parallel reactive stack: Servlet Reactive SecurityFilterChain SecurityWebFilterChain HttpSecurity ServerHttpSecurity SecurityContextHolder ReactiveSecurityContextHolder UserDetailsService ReactiveUserDetailsService AuthenticationManager ReactiveAuthenticationManager @EnableWebSecurity @EnableWebFluxSecurity @EnableMethodSecurity @EnableReactiveMethodSecurity Dependencies &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-webflux&lt;/artifactId&gt; &lt;/dependency&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt; &lt;/dependency&gt; Spring Security auto-configures reactive security when WebFlux is on the classpath.https://blog.devops-monk.com/tutorials/java21/record-patterns/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/record-patterns/Records Recap Records (Java 16, JEP 395) are transparent carriers of immutable data: record Point(int x, int y) {} record ColoredPoint(Point point, String color) {} record Line(Point start, Point end) {} The compiler generates a constructor, accessor methods (x(), y()), equals, hashCode, and toString. Before Java 21, accessing record components required calling accessor methods: Object obj = new ColoredPoint(new Point(3, 4), &#34;red&#34;); if (obj instanceof ColoredPoint cp) { int x = cp.https://blog.devops-monk.com/tutorials/java17/records/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/records/Finalized in Java 16 (JEP 395). Available in all Java 16+ releases, including Java 17. Previous previews: Java 14 (JEP 359) and Java 15 (JEP 384). The Problem: Data Classes in Java Writing a simple immutable data class in Java 11 requires significant boilerplate: public final class Point { private final int x; private final int y; public Point(int x, int y) { this.x = x; this.y = y; } public int x() { return x; } public int y() { return y; } @Override public boolean equals(Object o) { if (this == o) return true; if (!https://blog.devops-monk.com/tutorials/spring-security/refresh-tokens/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/refresh-tokens/Why Refresh Tokens? Short-lived access tokens (15–60 minutes) limit the damage if a token is stolen — it expires quickly. But forcing users to log in every hour is terrible UX. Refresh tokens solve this: a long-lived token (7–30 days) stored securely lets the client silently obtain a new access token when the old one expires. The user stays logged in indefinitely without re-entering credentials. sequenceDiagram participant Client participant AuthServer as Auth Endpoint participant API as Protected API Client->>AuthServer: POST /api/auth/login AuthServer-->>Client: {accessToken: exp 15min, refreshToken: exp 7d} Note over Client,API: Normal API usage (15 min) Client->>API: GET /api/data\nAuthorization: Bearer {accessToken} API-->>Client: 200 OK Note over Client,API: Access token expires Client->>API: GET /api/data\nAuthorization: Bearer {expiredToken} API-->>Client: 401 Unauthorized Note over Client,API: Silent token refresh Client->>AuthServer: POST /api/auth/refresh\n{refreshToken} AuthServer-->>Client: {newAccessToken, newRefreshToken} Client->>API: GET /api/data\nAuthorization: Bearer {newAccessToken} API-->>Client: 200 OK Token Rotation: Every Refresh Issues a New Refresh Token Token rotation is the critical security mechanism: every time a refresh token is used, the server issues a new refresh token and invalidates the old one.https://blog.devops-monk.com/tutorials/spring-batch/remote-partitioning-kafka/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/remote-partitioning-kafka/Introduction Local partitioning (Article 21) runs all workers on one JVM. When a single machine is the bottleneck — CPU, memory, or network bandwidth — you need workers on separate machines. Spring Batch Integration provides two patterns for this: Pattern What distributes Coordinator controls Workers do Remote Partitioning Partition descriptors (small messages) Data splitting, aggregation Full read-process-write per partition Remote Chunking Actual items (larger messages) Reading Processing + writing only Remote partitioning is the more common choice — workers read directly from the database/file, so only small partition metadata crosses the network.https://blog.devops-monk.com/tutorials/java11/removed-deprecated-apis/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/removed-deprecated-apis/Removal Timeline API Deprecated In Removed In JEP Java EE modules (JAXB, JAX-WS, etc.) Java 9 Java 11 JEP 320 JavaFX Bundled with Java 9 Unbundled in Java 11 — Nashorn JavaScript Engine Java 11 Java 15 JEP 335 Pack200 tools and API Java 11 Java 14 JEP 336 javah tool Java 9 Java 10 JEP 313 sun.misc.BASE64Encoder/Decoder Java 8 Java 11 Encapsulation Thread.destroy(), Thread.stop(Throwable) Old Java 11 — Applet API Java 9 Java 17 JEP 289 Java EE Modules Removed (JEP 320) The six Java EE modules that shipped with Java SE 6–10 were removed from Java 11.https://blog.devops-monk.com/tutorials/spring-data-jpa/repository-interfaces/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/repository-interfaces/Introduction Spring Data JPA&rsquo;s repository abstraction eliminates the DAO boilerplate that every Java application used to require. You declare an interface, extend one of the repository base interfaces, and Spring generates a complete implementation at startup — find, save, delete, count, and more — with zero code written. The Repository Hierarchy Repository&lt;T, ID&gt; ← Marker interface — no methods │ └── CrudRepository&lt;T, ID&gt; ← Basic CRUD: save, find, delete, count │ └── PagingAndSortingRepository&lt;T, ID&gt; ← + findAll(Pageable), findAll(Sort) │ └── JpaRepository&lt;T, ID&gt; ← + flush, saveAndFlush, deleteInBatch Each interface adds more operations.https://blog.devops-monk.com/tutorials/spring-kafka/request-reply/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/request-reply/When Kafka Needs to Be Synchronous Kafka is designed for asynchronous event streaming. But some flows genuinely need a response: a payment validation service that must confirm before the order proceeds, or a pricing engine that must return the current price before checkout completes. ReplyingKafkaTemplate gives you a blocking send-and-receive call over Kafka without leaving the Kafka ecosystem. How Request-Reply Works sequenceDiagram participant Requester as "Order Service\n(ReplyingKafkaTemplate)" participant Broker participant Replier as "https://blog.devops-monk.com/tutorials/spring-kafka/retryable-exceptions/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/retryable-exceptions/Transient vs Permanent Failures Not every exception is worth retrying. Retrying a NullPointerException or a schema validation error wastes time and delays other records. Retrying a database timeout or a downstream HTTP 503 is exactly right — the error is temporary and will likely resolve. flowchart TD Ex["Exception in listener"] Q{"Transient?\n(DB timeout, HTTP 503,\nnetwork blip)"} Q -->|Yes| Retry["Retry with BackOff"] Q -->|No| Skip["Call recoverer immediately\n(no retries wasted)"] Retry -->|"still failing after\nmax retries"https://blog.devops-monk.com/tutorials/spring-security/role-based-access-control/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/role-based-access-control/Roles vs. Authorities: The Distinction That Matters Spring Security uses one interface for both roles and authorities: GrantedAuthority. Both are just strings. The difference is convention. Authority: a fine-grained permission string — user:read, report:export, order:cancel Role: a coarse-grained label that groups authorities — ROLE_ADMIN, ROLE_MANAGER, ROLE_USER The ROLE_ prefix is the only mechanical difference. When you call hasRole(&quot;ADMIN&quot;), Spring Security prepends ROLE_ automatically and checks for ROLE_ADMIN. When you call hasAuthority(&quot;ROLE_ADMIN&quot;) you must include the prefix yourself.https://blog.devops-monk.com/tutorials/spring-batch/scheduling-batch-jobs/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/scheduling-batch-jobs/Introduction A batch job that only runs manually is barely useful. Production jobs run on a schedule — nightly, hourly, after a file arrives. Spring Boot provides three scheduling options: Option Persistence Clustered Use when @Scheduled No No Simple cron on a single node Quartz Scheduler Yes (DB) Yes HA scheduling, persistent triggers External scheduler (Kubernetes CronJob, Airflow) Varies Yes Complex pipelines, dependency management @Scheduled — Simple Cron Trigger The simplest approach: annotate a method with @Scheduled and run the job from it.https://blog.devops-monk.com/tutorials/java21/scoped-values/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/scoped-values/Preview Feature — Requires --enable-preview at compile and runtime. The ThreadLocal Problem at Scale ThreadLocal has been the standard way to pass context (request ID, user session, database transaction) implicitly through a call stack without threading it through every method signature. It works well with a few hundred platform threads. With virtual threads, it breaks down. Problem 1 — Memory overhead with inheritance When you create a child thread with InheritableThreadLocal, Java copies the thread-local map from parent to child:https://blog.devops-monk.com/tutorials/java17/sealed-classes/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/sealed-classes/Finalized in Java 17 (JEP 409). This is the headline language feature of the Java 17 LTS release. Previous previews: Java 15 (JEP 360) and Java 16 (JEP 397). The Problem: Open Hierarchies Are Hard to Reason About In Java, any class can be extended by default. This openness is flexible but has costs. Consider a Shape interface used in a drawing application: // Java 11 — anyone can implement Shape public interface Shape { double area(); } At runtime, a Shape instance could be a Circle, a Rectangle, a Triangle, or anything else in the classpath.https://blog.devops-monk.com/tutorials/spring-data-jpa/second-level-cache/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/second-level-cache/Cache Layers in Hibernate Hibernate has two cache levels: Level Scope Lifetime Shared? First-level cache One Session (one transaction) Transaction No — per session Second-level cache SessionFactory Application lifetime Yes — across sessions The first-level cache (Article 24) prevents repeated reads within one transaction. The second-level cache prevents repeated reads across transactions — once an entity is loaded, it stays in the shared cache until evicted. When to Use the Second-Level Cache Good candidates:https://blog.devops-monk.com/tutorials/spring-security/security-headers/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/security-headers/Why Security Headers Matter Security headers tell browsers how to behave when handling your content. They stop entire classes of attacks — XSS, clickjacking, protocol downgrade, information leakage — with a few lines of configuration. They cost nothing at runtime and are one of the highest-value-per-effort security improvements available. Spring Security&rsquo;s Default Headers Spring Security adds a set of secure headers by default. You do not need any explicit configuration to get them:https://blog.devops-monk.com/tutorials/java11/security-tls13/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/security-tls13/Security Improvements Across Java 9–11 JEP Release Feature JEP 287 Java 9 SHA-3 hash algorithms JEP 273 Java 9 DRBG-based SecureRandom JEP 288 Java 9 Disable SHA-1 certificates JEP 324 Java 11 Key Agreement with Curve25519 and Curve448 JEP 329 Java 11 ChaCha20 and Poly1305 cryptographic algorithms JEP 332 Java 11 Transport Layer Security (TLS) 1.3 JEP 181 Java 11 Nest-Based Access Control TLS 1.3 (JEP 332) TLS 1.3 is the current version of the Transport Layer Security protocol, finalised in RFC 8446 (August 2018).https://blog.devops-monk.com/tutorials/spring-security/security-context-authentication/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/security-context-authentication/The SecurityContext Is the Source of Truth Every security decision in Spring Security ultimately comes down to one question: &ldquo;What Authentication object is stored in the SecurityContext?&rdquo; Does the user have ROLE_ADMIN? → check Authentication.getAuthorities() What is the user&rsquo;s ID? → cast Authentication.getPrincipal() to UserDetails Is the user logged in at all? → check Authentication.isAuthenticated() Understanding the SecurityContext and Authentication is not optional — it underlies everything. The Object Hierarchy classDiagram class SecurityContextHolder { -strategy: SecurityContextHolderStrategy +getContext() SecurityContext +setContext(SecurityContext context) +clearContext() +getContextHolderStrategy() SecurityContextHolderStrategy } class SecurityContext { <> +getAuthentication() Authentication +setAuthentication(Authentication authentication) } class Authentication { <> +getPrincipal() Object +getCredentials() Object +getAuthorities() Collection~GrantedAuthority~ +getDetails() Object +isAuthenticated() boolean +getName() String } class UsernamePasswordAuthenticationToken { +UsernamePasswordAuthenticationToken(principal, credentials) +UsernamePasswordAuthenticationToken(principal, credentials, authorities) } class GrantedAuthority { <> +getAuthority() String } class SimpleGrantedAuthority { -role: String +getAuthority() String } SecurityContextHolder --> SecurityContext SecurityContext --> Authentication Authentication <|.https://blog.devops-monk.com/tutorials/spring-security/security-filter-chain-config/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/security-filter-chain-config/The Modern Configuration Model Spring Security 6.x dropped WebSecurityConfigurerAdapter. The new model uses a SecurityFilterChain @Bean directly. This is not just a syntax change — it&rsquo;s a fundamentally cleaner design: Old approach New approach Extend WebSecurityConfigurerAdapter @Bean SecurityFilterChain method Override configure(HttpSecurity) Accept HttpSecurity parameter Chain with .and() Lambda DSL — each concern is a separate block One class per application Multiple beans, one per URL namespace Implicit global AuthenticationManager Explicit AuthenticationManager bean // OLD — don&#39;t do this @Configuration public class OldSecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.https://blog.devops-monk.com/tutorials/spring-kafka/seeking-offsets/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/seeking-offsets/Why Seek Instead of Reset? Offset management (auto-commit vs manual acknowledgment) controls when offsets advance during normal processing. Seeking is different: it lets you reposition the consumer to any offset — past or future — programmatically, without touching the committed offset in __consumer_offsets. Common scenarios: Replay from the beginning — reprocess all historical events after a bug fix Resume from a known-good offset — skip a poison pill that&rsquo;s blocking the consumer Time-based replay — reprocess everything since yesterday 09:00 Startup positioning — always start from the end, ignoring backlog on first launch How Kafka Seeking Works flowchart LR subgraph Broker["https://blog.devops-monk.com/tutorials/spring-kafka/producer-keys-headers-partitioning/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/producer-keys-headers-partitioning/Why Partitioning Strategy Matters How you route messages to partitions determines: Ordering: only messages in the same partition are ordered relative to each other Parallelism: how evenly work is distributed across consumers Hot spots: if one key generates 90% of traffic, one partition (and one consumer) gets 90% of the load flowchart TD subgraph Routing["Message Routing Decision"] Msg["Message"] HasKey{Has key?} HasPartition{Explicit partition?} KeyHash["hash(key) % numPartitions\n→ deterministic, same partition always"] RoundRobin["Sticky partitioning\n(batch to same partition,\nthen round-robin)"https://blog.devops-monk.com/tutorials/java21/sequenced-collections/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/sequenced-collections/The 30-Year Gap in the Collections API Java&rsquo;s Collections Framework has a fundamental inconsistency: there is no uniform way to access the first or last element of an ordered collection. Before Java 21: // List — index-based var list = List.of(&#34;a&#34;, &#34;b&#34;, &#34;c&#34;); String first = list.get(0); // first element String last = list.get(list.size() - 1); // last element — verbose, error-prone // Deque — special methods Deque&lt;String&gt; deque = new ArrayDeque&lt;&gt;(List.https://blog.devops-monk.com/tutorials/spring-security/session-management/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/session-management/How Spring Security Uses Sessions For form login and traditional web applications, Spring Security stores the Authentication object in the HTTP session. On every request, SecurityContextPersistenceFilter (Spring Security 5) or SecurityContextHolderFilter (Spring Security 6) loads the SecurityContext from the session and puts it in the SecurityContextHolder. For stateless APIs using JWT or OAuth2 Bearer tokens, no session is created — the token is verified on every request. Session Creation Policy Control when Spring Security creates sessions:https://blog.devops-monk.com/tutorials/java11/java11-setup/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/java11-setup/Choosing a JDK Distribution Java 11 is available from multiple OpenJDK distributions. All are TCK-certified and binary-compatible; the differences are support timelines and add-ons. Distribution Vendor Java 11 Support Until Notes Eclipse Temurin Adoptium Oct 2027 Community standard, most downloaded Amazon Corretto Amazon Aug 2024 (free), extended via AWS Best choice for AWS workloads Azul Zulu Azul Systems 2026+ Wide platform coverage Microsoft Build of OpenJDK Microsoft 2024 Best for Azure Oracle JDK 11 Oracle Oct 2024 (free LTS) Commercial support until 2026 GraalVM CE 21 Oracle/GraalVM Community Native image + polyglot; JDK 21-based For most teams: Eclipse Temurin 11 — widest platform support, longest free support window, backed by a vendor-neutral foundation.https://blog.devops-monk.com/tutorials/java17/java17-setup/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/java17-setup/JDK Distribution Options Multiple vendors ship Java 17 JDK builds. All pass the TCK (Technology Compatibility Kit) — they are functionally equivalent for development. Distribution Provider Notes Eclipse Temurin Adoptium / Eclipse Recommended default; fully open-source Amazon Corretto AWS Free; optimized for AWS Lambda and EC2 Microsoft Build of OpenJDK Microsoft Windows and Azure optimized Oracle JDK 17 Oracle Free for development; commercial license for production Azul Zulu Azul Commercial support available; free binaries GraalVM CE 22.https://blog.devops-monk.com/tutorials/java21/java21-setup/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/java21-setup/Choosing a JDK Distribution Java 21 is open source (OpenJDK). Multiple vendors distribute binaries, all built from the same source with identical features. Choose based on your support requirements: Distribution Vendor Free LTS Support Notes Eclipse Temurin Adoptium Yes 2028+ Recommended for most developers OpenJDK Oracle/Community Yes 6 months only Reference implementation, no LTS Oracle JDK Oracle Yes (NFTC) 2031 Identical to OpenJDK since Java 17 Amazon Corretto AWS Yes 2030+ Good for AWS deployments Microsoft Build of OpenJDK Microsoft Yes Long-term Good for Azure deployments Azul Zulu Azul Yes/Paid Long-term Includes Zing JVM variant GraalVM Oracle Yes Long-term Adds native-image, polyglot Recommendation: Eclipse Temurin for local development; match your cloud provider&rsquo;s JDK for production (Corretto on AWS, Microsoft OpenJDK on Azure).https://blog.devops-monk.com/tutorials/java8/java8-setup/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/java8-setup/Choosing a Java 8 Distribution Getting your environment right before writing a single line of code saves hours of debugging compiler errors and version conflicts later. This article covers every distribution option, all three major build tools, and both popular IDEs — including the specific settings that trip up most developers when first configuring Java 8. Oracle stopped providing free Java 8 updates for commercial use in January 2019. Multiple vendors now ship free, production-quality Java 8 builds:https://blog.devops-monk.com/tutorials/spring-data-jpa/setup-spring-boot-spring-data-jpa/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/setup-spring-boot-spring-data-jpa/Introduction This article builds the project foundation used throughout the entire series. By the end, you will have a running Spring Boot 3.3 application connected to MySQL 8.x with Hibernate 6, a proper connection pool, schema management via Flyway, and SQL logging configured so you can see exactly what Hibernate sends to the database. Project Setup Maven pom.xml &lt;?xml version=&#34;1.0&#34; encoding=&#34;UTF-8&#34;?&gt; &lt;project xmlns=&#34;http://maven.apache.org/POM/4.0.0&#34; xmlns:xsi=&#34;http://www.w3.org/2001/XMLSchema-instance&#34; xsi:schemaLocation=&#34;http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd&#34;&gt; &lt;modelVersion&gt;4.0.0&lt;/modelVersion&gt; &lt;parent&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-parent&lt;/artifactId&gt; &lt;version&gt;3.https://blog.devops-monk.com/tutorials/spring-data-jpa/specifications-criteria-api/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/specifications-criteria-api/Why Specifications Derived query methods and @Query annotations work for fixed queries. But what happens when the user can filter by any combination of 10 fields — some optional, some not? // Wrong approach — combinatorial explosion List&lt;Product&gt; findByName(String name); List&lt;Product&gt; findByNameAndPrice(String name, BigDecimal price); List&lt;Product&gt; findByNameAndPriceAndCategory(...); // ... you&#39;d need 2^10 = 1024 methods The Specification pattern solves this. Each filter condition is a reusable Specification&lt;T&gt; object. You compose them with and(), or(), and not() at runtime, and Spring Data JPA generates the correct query.https://blog.devops-monk.com/tutorials/spring-security/spring-authorization-server/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/spring-authorization-server/What Is Spring Authorization Server? Spring Authorization Server (SAS) is an official Spring project that implements OAuth 2.1 and OpenID Connect 1.0 as a Spring Boot application. It provides a complete authorization server you can host yourself — issuing tokens for your own clients and APIs. Use it when: You want SSO across your own microservices You cannot use a hosted provider (Okta, Auth0) due to compliance or cost You need complete control over token format and claims You&rsquo;re building a platform where other apps authenticate against your identity service Architecture flowchart TD SPA[SPA / Mobile App\nOAuth2 Client] -->|Authorization Code + PKCE| SAS Service[Backend Service\nClient Credentials| SAS] SAS[Spring Authorization Server\nIssues tokens] RS1[Your REST API\nResource Server] -->|Validates JWT| SAS RS2[Another API\nResource Server] -->|Validates JWT| SAS SAS -->|Signs tokens with| PK[Private Key\nJWK Set at /.https://blog.devops-monk.com/tutorials/spring-kafka/production-best-practices/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/production-best-practices/Before You Ship This is the checklist distilled from everything in this series. Work through it before your first production deployment. Each item links to the article where it&rsquo;s covered in depth. Producer Checklist Durability # Never lose data on leader failure spring.kafka.producer.acks=all # At least 2 brokers must acknowledge every write spring.kafka.producer.properties.min.insync.replicas=2 # Enables exactly-once message delivery (required for transactions) spring.kafka.producer.properties.enable.idempotence=true Do: Set acks=all and min.insync.replicas=2 for any topic that carries business data.https://blog.devops-monk.com/tutorials/spring-security/spring-security-best-practices/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/spring-security-best-practices/Using This Reference This is the final article in the Spring Security series. It is a consolidated reference — not a tutorial. Come back to this checklist before every launch and when reviewing a new codebase. Each item links back to the relevant article in the series. 1. Keep Spring Security Updated Security vulnerabilities in Spring Security itself are rare but severe when they occur. A dependency that is one minor version behind can expose known CVEs.https://blog.devops-monk.com/tutorials/java11/stream-optional-enhancements/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/stream-optional-enhancements/Stream API — New Methods (Java 9) Java 9 added four new instance methods to Stream&lt;T&gt;. All are terminal-ish or intermediate operations that make common patterns expressible without workarounds. takeWhile(Predicate) Returns elements from the beginning of the stream as long as the predicate holds, then stops. The first element that fails the predicate (and all subsequent elements) are discarded. Stream.of(1, 2, 3, 4, 5, 1, 2) .takeWhile(n -&gt; n &lt; 4) .https://blog.devops-monk.com/tutorials/java8/streams-introduction/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java8/streams-introduction/The Problem Streams Solve Java loops are not wrong — they are often the right tool. But when a computation is a multi-step pipeline of filter → transform → aggregate, a loop hides the structure of the computation in a tangle of temporary variables and mutated collections. The Streams API makes the structure explicit, lets the JVM optimise it, and composes naturally with lambdas and method references. Consider filtering a list of orders to find the names of active premium customers who spent over $500, sorted alphabetically:https://blog.devops-monk.com/tutorials/java21/structured-concurrency/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/structured-concurrency/Preview Feature — Requires --enable-preview at compile and runtime. The API stabilized significantly from Java 21 through 24 and will be finalized in a future release. The Unstructured Concurrency Problem When you submit tasks to an ExecutorService, the tasks are logically related but structurally unconnected — the executor doesn&rsquo;t know they belong together: // Unstructured concurrency — looks simple, hides serious problems ExecutorService executor = Executors.newCachedThreadPool(); Future&lt;Order&gt; orderFuture = executor.https://blog.devops-monk.com/tutorials/java17/switch-expressions/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/switch-expressions/Finalized in Java 14 (JEP 361). Available in all Java 14+ releases, including Java 17. Previous previews: Java 12 (JEP 325) and Java 13 (JEP 354). The Problem with Switch Statements Java&rsquo;s traditional switch statement has two well-known pain points: Pain 1: Fall-Through // Java 11 — easy to introduce fall-through bugs switch (day) { case MONDAY: result = &#34;Start of work week&#34;; break; // easy to forget this case TUESDAY: result = &#34;Weekday&#34;; // no break — falls through to WEDNESDAY case case WEDNESDAY: result = &#34;Hump day&#34;; break; default: result = &#34;Other&#34;; } A missing break causes the next case to execute unexpectedly.https://blog.devops-monk.com/tutorials/spring-kafka/testing-kafka/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/testing-kafka/Two Testing Strategies Strategy Speed Fidelity Use when @EmbeddedKafka Fast (~2s startup) In-process broker, not 100% identical Unit/integration tests — CI fast path KafkaContainer (Testcontainers) Slower (~10s startup) Real Kafka broker in Docker Acceptance tests, DLT/transaction validation Use both: @EmbeddedKafka for the bulk of tests, KafkaContainer for the smoke suite that validates real-broker behaviour. Test Dependencies &lt;dependency&gt; &lt;groupId&gt;org.springframework.kafka&lt;/groupId&gt; &lt;artifactId&gt;spring-kafka-test&lt;/artifactId&gt; &lt;scope&gt;test&lt;/scope&gt; &lt;/dependency&gt; &lt;dependency&gt; &lt;groupId&gt;org.testcontainers&lt;/groupId&gt; &lt;artifactId&gt;kafka&lt;/artifactId&gt; &lt;scope&gt;test&lt;/scope&gt; &lt;/dependency&gt; &lt;dependency&gt; &lt;groupId&gt;org.awaitility&lt;/groupId&gt; &lt;artifactId&gt;awaitility&lt;/artifactId&gt; &lt;scope&gt;test&lt;/scope&gt; &lt;/dependency&gt; @EmbeddedKafka — Fast Integration Tests Testing a Producer @SpringBootTest @EmbeddedKafka( partitions = 1, topics = {&#34;orders&#34;}, brokerProperties = {&#34;log.https://blog.devops-monk.com/tutorials/spring-data-jpa/testing-spring-data-jpa/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/testing-spring-data-jpa/Why Test JPA Code? Unit tests with mocked repositories verify your service logic but nothing about the database. They won&rsquo;t catch: Wrong column mapping Constraint violations N+1 queries introduced by a new lazy association Transactions that silently don&rsquo;t roll back Queries that fail on the real database but pass on H2 Testing against a real database — or at minimum a database-compatible in-memory store — is necessary. Spring Boot&rsquo;s @DataJpaTest and Testcontainers make this practical.https://blog.devops-monk.com/tutorials/spring-security/testing-spring-security/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/testing-spring-security/Why Security Tests Are Non-Negotiable A security configuration that is never tested is a security configuration that is probably wrong. URL patterns have subtle ordering rules. Method security annotations are silently ignored if @EnableMethodSecurity is missing. CSRF tokens must be present in the right form. Testing is the only way to know your authorization rules are actually enforced. Test Dependencies &lt;dependency&gt; &lt;groupId&gt;org.springframework.security&lt;/groupId&gt; &lt;artifactId&gt;spring-security-test&lt;/artifactId&gt; &lt;scope&gt;test&lt;/scope&gt; &lt;/dependency&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-test&lt;/artifactId&gt; &lt;scope&gt;test&lt;/scope&gt; &lt;/dependency&gt; @WithMockUser The simplest way to simulate an authenticated user.https://blog.devops-monk.com/tutorials/java17/text-blocks/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java17/text-blocks/Finalized in Java 15 (JEP 378). Available in all Java 15+ releases, including Java 17. Previous previews: Java 13 (JEP 355) and Java 14 (JEP 368). The Problem: Embedded Strings in Java Writing multi-line strings in Java has always been painful: // JSON — a wall of escape sequences and concatenation String json = &#34;{\n&#34; + &#34; \&#34;name\&#34;: \&#34;Alice\&#34;,\n&#34; + &#34; \&#34;role\&#34;: \&#34;engineer\&#34;,\n&#34; + &#34; \&#34;active\&#34;: true\n&#34; + &#34;}&#34;; // SQL — unreadable indentation and newlines String sql = &#34;SELECT u.https://blog.devops-monk.com/tutorials/spring-data-jpa/n-plus-one-problem-solutions/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/n-plus-one-problem-solutions/What Is the N+1 Problem? The N+1 problem occurs when loading a list of N entities triggers N additional queries to load their associations — one query per entity. Example: load 50 orders, then access each order&rsquo;s customer: SELECT * FROM orders; -- 1 query SELECT * FROM customers WHERE id = 1; -- query for order 1&#39;s customer SELECT * FROM customers WHERE id = 2; -- query for order 2&#39;s customer SELECT * FROM customers WHERE id = 3; -- query for order 3&#39;s customer .https://blog.devops-monk.com/tutorials/spring-data-jpa/persistence-context-entity-lifecycle/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/persistence-context-entity-lifecycle/Introduction The persistence context is the single most important concept in JPA. Everything else — lazy loading, dirty checking, transaction scope, detached entity exceptions — only makes sense once you understand what the persistence context is and how it works. Many JPA bugs come from developers not understanding this concept. Understand it well and the rest of JPA becomes predictable. What Is the Persistence Context? The persistence context is an in-memory map of entities managed by the current EntityManager.https://blog.devops-monk.com/tutorials/spring-security/security-filter-chain/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/security-filter-chain/Every Filter Has a Job The Spring Security filter chain is not a monolith — it&rsquo;s 15-20 individual filters, each responsible for exactly one concern. Understanding each filter&rsquo;s job means you can: Know exactly where in the chain a request fails Add your own filter in the right position Remove filters you don&rsquo;t need for performance Debug authentication and authorization problems The Complete Filter Order Spring Security defines a strict ordering for its filters.https://blog.devops-monk.com/tutorials/java11/tooling-jshell-jlink/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/tooling-jshell-jlink/Overview Java 9 and 11 added three tools that change how you write, test, and deploy Java code: Tool JEP Release Purpose JShell JEP 222 Java 9 Interactive REPL for Java code jlink JEP 282 Java 9 Build minimal custom JRE images Single-file programs JEP 330 Java 11 Run .java files directly JShell — Interactive Java REPL JShell is Java&rsquo;s Read-Eval-Print Loop: a command-line tool for evaluating Java expressions, statements, methods, and classes interactively, without creating a project.https://blog.devops-monk.com/tutorials/spring-data-jpa/transaction-boundaries-pitfalls/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-data-jpa/transaction-boundaries-pitfalls/Transaction Boundaries A transaction boundary is the point where a transaction starts and where it ends. In Spring, boundaries are defined by @Transactional on service methods. HTTP Request └── Controller (no transaction) └── @Transactional Service method ← transaction OPENS here ├── Repository call 1 ├── Repository call 2 └── method returns ← transaction COMMITS here Everything inside the @Transactional method runs in the same database transaction. The persistence context (first-level cache) lives for the duration of that transaction.https://blog.devops-monk.com/tutorials/java21/unnamed-classes/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/unnamed-classes/Preview Feature — Requires --enable-preview at compile and runtime. The Boilerplate Problem Teaching Java to a beginner means explaining class declarations, access modifiers, static, and String[] before they can print &ldquo;Hello, World!&rdquo;: // Traditional Java — 4 concepts before printing one line public class HelloWorld { public static void main(String[] args) { System.out.println(&#34;Hello, World!&#34;); } } Every word carries meaning, but that meaning is irrelevant until the student understands OOP, the JVM class model, and program entry points.https://blog.devops-monk.com/tutorials/java21/unnamed-patterns/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/unnamed-patterns/Preview Feature — Requires --enable-preview at compile and runtime. The _ identifier was reserved in Java 9; this JEP gives it formal semantics. The Problem: Forced Naming of Unused Things When pattern matching, you often care about only some components of a matched structure. But the syntax forces you to name everything: record Point(int x, int y) {} record ColoredPoint(Point point, String color) {} record Box(ColoredPoint cp, int weight) {} // You only care about the color — but must name everything else if (obj instanceof Box(ColoredPoint(Point(int x, int y), String color), int weight)) { System.https://blog.devops-monk.com/tutorials/java11/var-keyword/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java11/var-keyword/What var Does var is a reserved type name (not a keyword) introduced in Java 10 (JEP 286). It instructs the compiler to infer the type of a local variable from its initialiser. The inferred type is fixed at compile time — var does not make Java dynamically typed. // Before var ArrayList&lt;String&gt; names = new ArrayList&lt;String&gt;(); Map&lt;String, List&lt;Integer&gt;&gt; scores = new HashMap&lt;String, List&lt;Integer&gt;&gt;(); // With var var names = new ArrayList&lt;String&gt;(); var scores = new HashMap&lt;String, List&lt;Integer&gt;&gt;(); After compilation, both forms produce identical bytecode.https://blog.devops-monk.com/tutorials/java21/vector-api/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/vector-api/Preview Feature in Java 21 — The Vector API has been in preview since Java 16 (JEP 338). JEP 448 is the sixth preview iteration in Java 21. The API is stable and production-usable with --enable-preview; finalization is pending Project Valhalla value types. What Is SIMD and Why Does It Matter? Modern CPUs can perform the same arithmetic operation on multiple data values in a single instruction. This is called SIMD — Single Instruction, Multiple Data.https://blog.devops-monk.com/tutorials/java21/virtual-threads/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/java21/virtual-threads/The Platform Thread Problem Every Java thread since Java 1.0 maps 1:1 to an OS thread. OS threads are heavy: Stack memory: 512 KB – 2 MB per thread (configurable with -Xss, default 512 KB on Linux) Context switch cost: ~1–10 μs per switch (kernel mode transition + cache invalidation) Hard limit: A 64-bit machine with 8 GB RAM can support roughly 8,000–16,000 OS threads before running out of stack memory This limit shapes how Java servers are built.https://blog.devops-monk.com/tutorials/spring-kafka/what-is-apache-kafka/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-kafka/what-is-apache-kafka/The Problem Kafka Solves Imagine an e-commerce platform. A customer places an order. What needs to happen next? Inventory must be reserved Payment must be charged A confirmation email must be sent The warehouse must be notified to pick and pack Analytics must record the sale Fraud detection must evaluate the transaction One request. Six downstream systems. In a traditional REST architecture, the Order Service calls each of those six services directly — synchronously, one after another.https://blog.devops-monk.com/tutorials/spring-security/x509-certificate-authentication/Mon, 04 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-security/x509-certificate-authentication/What Is X.509 Authentication? X.509 authentication (also called mutual TLS or mTLS) uses digital certificates instead of passwords. The client presents a certificate during the TLS handshake. The server verifies the certificate against a trusted Certificate Authority (CA) and extracts the user identity from the certificate&rsquo;s Common Name (CN) or Subject Alternative Name (SAN). sequenceDiagram participant Client as Client (with certificate) participant Server as Spring Boot Server Client->>Server: TLS ClientHello Server->>Client: TLS ServerHello + Server Certificate Server->>Client: CertificateRequest (ask for client cert) Client->>Server: Client Certificate + CertificateVerify Server->>Server: Verify against trusted CA Server->>Server: Extract CN from certificate: "https://blog.devops-monk.com/tutorials/spring-batch/advanced-processors/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/advanced-processors/Introduction Real batch jobs often need more than one transformation step per item. You might validate first, then normalize, then enrich, then convert to the output type. CompositeItemProcessor chains multiple single-responsibility processors together. For I/O-bound enrichment steps, AsyncItemProcessor runs processing concurrently on a thread pool — giving you parallelism without rewriting your step as multi-threaded. CompositeItemProcessor CompositeItemProcessor chains a list of processors. The output of each processor becomes the input to the next.https://blog.devops-monk.com/tutorials/spring-batch/advanced-writers/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/advanced-writers/Introduction The previous article covered the two most common writers: FlatFileItemWriter for files and JdbcBatchItemWriter for database inserts. This article covers advanced scenarios: Persisting JPA entities with JpaItemWriter Writing to multiple destinations simultaneously with CompositeItemWriter Routing items to different writers based on content with ClassifierCompositeItemWriter Building custom writers for REST APIs, message queues, and cloud storage Combining a writer with a post-step cleanup tasklet JpaItemWriter JpaItemWriter calls EntityManager.merge() on each item.https://blog.devops-monk.com/tutorials/spring-batch/chunk-oriented-processing/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/chunk-oriented-processing/The read-process-write loop is at the heart of almost every Spring Batch job. Understanding exactly how it works — where transactions begin and end, what gets rolled back on failure, and how Spring Batch knows where to restart — makes everything else in the framework click into place. This article goes deep on chunk-oriented processing: the execution model, the three interfaces, the counters that track progress, and how to size chunks correctly.https://blog.devops-monk.com/tutorials/spring-batch/job-step-configuration/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/job-step-configuration/Introduction So far every example has had a single step. Real batch jobs usually have multiple steps — validate input, import data, generate a report, send a notification, clean up temp files. Spring Batch&rsquo;s JobBuilder DSL lets you compose these steps into flows with conditional branching, parallel execution, and decision logic. This article covers: Linear multi-step jobs Conditional step transitions using ExitStatus JobExecutionDecider for runtime branching Parallel flows with split Nested jobs with FlowStep The Flow abstraction for reusable step sequences Linear Multi-Step Job The simplest multi-step job runs steps in sequence.https://blog.devops-monk.com/2026/05/spring-boot-auto-configuration-deep-dive/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/2026/05/spring-boot-auto-configuration-deep-dive/&ldquo;Spring Boot is magic&rdquo; is something you hear a lot. Add spring-boot-starter-data-jpa and suddenly you have a working DataSource, a JpaTransactionManager, and a LocalContainerEntityManagerFactoryBean — without writing a single @Bean method. Understanding how this actually works turns the magic into a tool you can control, debug, and extend. The Entry Point: @EnableAutoConfiguration @SpringBootApplication is a shorthand for three annotations: @Configuration @EnableAutoConfiguration // this is the one that matters here @ComponentScan public class MyApplication { public static void main(String[] args) { SpringApplication.https://blog.devops-monk.com/tutorials/spring-batch/introduction-to-spring-batch/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/introduction-to-spring-batch/Every application has a class of work that doesn&rsquo;t fit the request-response model: process 2 million orders overnight, generate 500,000 monthly statements, migrate 10 years of legacy data before Monday morning. This work needs to be reliable, restartable after failures, and fast enough to finish in the available window. That&rsquo;s what Spring Batch is built for. This article covers what Spring Batch is, when to use it, and how its architecture works.https://blog.devops-monk.com/tutorials/spring-boot/introduction-to-spring-boot/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-boot/introduction-to-spring-boot/You want to build a Java web application or REST API. You&rsquo;ve heard everyone uses Spring Boot. But what is it exactly, and why does it exist? This article answers that — clearly — before writing a single line of code. What Is Spring Boot? Spring Boot is an opinionated framework for building Spring-based Java applications with minimal configuration. Break that down: Spring-based — it sits on top of the Spring Framework, which has been the dominant Java application framework since 2003 Minimal configuration — you describe what you want (a web app, a database connection), and Spring Boot figures out how to set it up Opinionated — it makes sensible default choices so you don&rsquo;t have to make every decision yourself The one-line version: Spring Boot lets you go from a blank project to a running application in minutes, with production-ready defaults built in.https://blog.devops-monk.com/tutorials/spring-batch/job-parameters-execution-context/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/job-parameters-execution-context/Introduction Two mechanisms let you pass information into and through a Spring Batch job: JobParameters — input values provided at launch time (a date, a file path, a run ID). They are immutable and persisted to BATCH_JOB_EXECUTION_PARAMS. ExecutionContext — a key-value map that steps can read and write during execution. It is persisted after each chunk commit, enabling restartability. Understanding both is essential for building jobs that can be safely re-run, restarted after failure, and parameterised for different data sets.https://blog.devops-monk.com/tutorials/spring-batch/job-repository-batch-metadata/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/job-repository-batch-metadata/Introduction Every time Spring Batch runs a job it records the run&rsquo;s history in a set of relational tables. This metadata is not optional — it is what makes Spring Batch reliable. Without it there would be no restart capability, no duplicate-run prevention, and no audit trail. Understanding the metadata layer is essential for debugging failures, building monitoring dashboards, and designing restartable jobs. In this article you will learn: The role of JobRepository and JobExplorer in the Spring Batch architecture The six metadata tables — their schema, purpose, and relationships How Spring Batch uses these tables to enable restartability How to query batch history directly in MySQL How to access metadata programmatically with JobExplorer Key changes in Spring Batch 5 (removed MapJobRepositoryFactoryBean, new testing approach) All examples use Spring Boot 3.https://blog.devops-monk.com/tutorials/spring-batch/listeners/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/listeners/Introduction Spring Batch emits lifecycle events at every stage of execution — before and after a job runs, before and after each step, before and after each chunk, and before and after each individual read/process/write call. Listeners let you hook into these events without modifying your core batch logic. Common uses: Log start/end times and item counts Send success/failure notifications (Slack, email, PagerDuty) Publish metrics to Prometheus or CloudWatch Log every skipped item to a dead-letter table Reset resources before a step begins Listener Hierarchy Job ├── JobExecutionListener beforeJob / afterJob │ └── Step ├── StepExecutionListener beforeStep / afterStep ├── ChunkListener beforeChunk / afterChunk / afterChunkError ├── ItemReadListener beforeRead / afterRead / onReadError ├── ItemProcessListener beforeProcess / afterProcess / onProcessError └── ItemWriteListener beforeWrite / afterWrite / onWriteError └── SkipListener onSkipInRead / onSkipInWrite / onSkipInProcess JobExecutionListener @Component public class ImportJobListener implements JobExecutionListener { private static final Logger log = LoggerFactory.https://blog.devops-monk.com/tutorials/spring-boot/spring-boot-jspecify-null-safety/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-boot/spring-boot-jspecify-null-safety/NullPointerException is the most common runtime error in Java. JSpecify is the standardized solution — annotate your APIs and get compile-time null safety. Spring Framework 7 adopts JSpecify throughout, and your code can too. The Problem // Is this safe? You don&#39;t know without reading the implementation. public Order findById(UUID id) { return repository.findById(id).orElse(null); // returns null! } // The caller has no warning: Order order = service.findById(id); order.cancel(); // ← NullPointerException if not found Without null annotations, every method call is potentially null — you write defensive code everywhere, or you miss a case and get a NPE in production.https://blog.devops-monk.com/tutorials/spring-batch/reading-flat-files/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/reading-flat-files/Introduction Flat files — CSV exports, fixed-width mainframe feeds, pipe-delimited data dumps — are the most common input source for batch jobs. Spring Batch&rsquo;s FlatFileItemReader handles all of them. It is restartable out of the box: it persists its line-number position in the ExecutionContext so that a restarted job resumes exactly where it crashed. In this article you will build a complete order-import job that reads a CSV file and inserts rows into a MySQL orders table.https://blog.devops-monk.com/tutorials/spring-batch/reading-external-sources/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/reading-external-sources/Introduction Not all batch input comes from files or databases. You may need to pull orders from an e-commerce API, sync products from a supplier feed, or process CSV exports stored in Amazon S3. Spring Batch provides MultiResourceItemReader for S3 files and a clean ItemReader interface for anything else. In this article you will build: A custom ItemReader that pages through a REST API An S3 reader that downloads files on demand A composite reader that merges multiple sources into one step The ItemReader Contract The entire ItemReader interface is one method:https://blog.devops-monk.com/tutorials/spring-batch/reading-from-mysql/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/reading-from-mysql/Introduction Most real batch jobs read from a database, not a file. Spring Batch provides two JDBC readers for this: Reader Strategy Thread-safe Use when JdbcCursorItemReader Open a server-side cursor, stream rows No Single-threaded step, huge result sets JdbcPagingItemReader Execute LIMIT / OFFSET queries in a loop Yes Multi-threaded steps, sorted data Both handle restartability automatically and both work with any DataSource — including MySQL. JdbcCursorItemReader How it works The reader opens a single JDBC ResultSet on Step.https://blog.devops-monk.com/tutorials/spring-batch/reading-with-jpa/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/reading-with-jpa/Introduction When your application already uses JPA/Hibernate, JpaPagingItemReader lets you read data using JPQL queries and mapped entities instead of raw JDBC. You get the full object graph, type-safe queries, and familiar entity lifecycle — but you also inherit JPA&rsquo;s pitfalls: the N+1 problem, session-per-read overhead, and first-level cache growth. This article covers: When to choose JpaPagingItemReader over JdbcPagingItemReader Setting up the reader with JPQL and named queries Fetching associations to avoid N+1 Clearing the persistence context to prevent memory leaks A complete order-processing example with MySQL When to Use JpaPagingItemReader Use it when:https://blog.devops-monk.com/tutorials/spring-batch/retry-logic/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/retry-logic/Introduction Batch jobs interact with databases, REST APIs, and file systems — all of which fail transiently. A MySQL deadlock resolves itself in milliseconds. A network timeout to an external service clears up in seconds. Retrying these transient failures automatically is far better than failing the entire job and requiring a manual restart. Spring Batch has built-in retry support at the step level, integrated with its transaction management. This article covers everything you need to configure robust retry behaviour.https://blog.devops-monk.com/tutorials/spring-batch/skip-logic-restartability/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/skip-logic-restartability/Introduction Retry handles transient failures. Skip handles permanent ones — bad data rows, constraint violations, malformed records that will never succeed no matter how many times you retry. Skip logic lets your job continue processing good records while recording bad ones for human review. This article covers: Configuring skip for specific exception types Custom SkipPolicy for fine-grained control Dead-letter table pattern for tracking skipped items Stopping a job intentionally vs failing it Handling abandoned executions Designing jobs that restart safely after any failure Basic Skip Configuration return new StepBuilder(&#34;importOrdersStep&#34;, jobRepository) .https://blog.devops-monk.com/tutorials/spring-batch/spring-boot-spring-batch-setup/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/spring-boot-spring-batch-setup/Article 2 showed how chunk processing works conceptually. This article sets up the real project you&rsquo;ll build on for the rest of the series — complete Maven configuration, MySQL metadata tables, multiple ways to trigger jobs, and correct use of JobParameters. Everything in this article is production-ready from the start. Project Dependencies Add spring-boot-starter-batch to your Maven project. That one starter brings in everything you need. &lt;?xml version=&#34;1.0&#34; encoding=&#34;UTF-8&#34;?&gt; &lt;project xmlns=&#34;http://maven.https://blog.devops-monk.com/2026/05/spring-boot-migration-guide/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/2026/05/spring-boot-migration-guide/Many teams are still running Spring Boot 2.7.x. Spring Boot 2.x reached end of life in November 2023, which means no more security patches. The jump to 4.0 is two generations, and the breaking changes are real — but they are also well-documented and mostly automatable. This guide walks through the migration in stages: 2.x → 3.0 first, then 3.x incremental updates, then 4.0. Each section lists what breaks and how to fix it.https://blog.devops-monk.com/2026/05/spring-boot-4-complete-guide/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/2026/05/spring-boot-4-complete-guide/Spring Boot 4.0 was released on November 20, 2025. It is built on Spring Framework 7 and represents the most significant shift in the Spring ecosystem since the Jakarta EE migration in Spring Boot 3. The headline change is full modularisation — the single spring-boot-autoconfigure JAR has been split into 70+ granular modules. But that is just the start. This guide covers every change that matters, what breaks on upgrade, and what is genuinely new and useful.https://blog.devops-monk.com/tutorials/spring-boot/spring-boot-project-structure/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-boot/spring-boot-project-structure/A Spring Boot project looks simple on the surface but has a specific structure with specific conventions. Understanding it upfront saves hours of confusion later. The Standard Layout order-service/ ├── pom.xml ├── mvnw # Maven Wrapper script (Unix) ├── mvnw.cmd # Maven Wrapper script (Windows) ├── .mvn/ │ └── wrapper/ │ └── maven-wrapper.properties └── src/ ├── main/ │ ├── java/ │ │ └── com/devopsmonk/orderservice/ │ │ └── OrderServiceApplication.java │ └── resources/ │ ├── application.https://blog.devops-monk.com/2026/05/spring-boot-vs-quarkus/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/2026/05/spring-boot-vs-quarkus/Every year, someone asks: &ldquo;Should we use Spring Boot or Quarkus?&rdquo; In 2026, both frameworks are mature, both run natively, and both work well on Kubernetes. The differences come down to developer experience, ecosystem size, and specific performance characteristics. This is an honest comparison with real numbers, not marketing claims. The Frameworks at a Glance Spring Boot 4 (November 2025): Built on Spring Framework 7. The de-facto standard for enterprise Java.https://blog.devops-monk.com/tutorials/spring-batch/tasklets/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/tasklets/Introduction Not every step in a batch job reads-processes-writes a stream of items. Sometimes you need to: Delete yesterday&rsquo;s temp files before reading today&rsquo;s data Truncate a staging table before loading new data Call a stored procedure to aggregate results Send an email or Slack notification after processing Execute a DDL statement to add an index These operations do not have items — they are single units of work. Spring Batch handles them with the Tasklet interface.https://blog.devops-monk.com/tutorials/spring-batch/testing-spring-batch/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/testing-spring-batch/Introduction Spring Batch jobs are code — they need tests. Without tests you will catch errors in production. With tests you catch them in CI. Spring Batch has a dedicated testing module that provides @SpringBatchTest, JobLauncherTestUtils, and JobRepositoryTestUtils. These tools let you: Run a complete job in a test and assert on its BatchStatus Launch individual steps and inspect StepExecution counters Test readers, processors, and writers in complete isolation This article covers all three levels: unit, integration, and database integration with Testcontainers.https://blog.devops-monk.com/2026/05/spring-boot-interview-questions/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/2026/05/spring-boot-interview-questions/These are the questions that actually come up in Spring Boot interviews — at startups, scale-ups, and large enterprises. Each answer explains the concept clearly, with the level of depth an interviewer expects from a mid-level or senior developer. Questions are grouped by topic. For junior roles, focus on sections 1–3. For senior roles, everything here is fair game. Section 1: Core Fundamentals Q1. What is the difference between Spring and Spring Boot?https://blog.devops-monk.com/tutorials/spring-batch/item-processor/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/item-processor/Introduction ItemProcessor&lt;I, O&gt; sits between the reader and the writer. It receives one item at a time and returns a transformed item — or null to filter the item out entirely. Processors are optional: if your job reads and writes the same type with no transformation needed, you can omit them. The processor interface is one method: public interface ItemProcessor&lt;I, O&gt; { O process(I item) throws Exception; } Return a processed item to pass it to the writer.https://blog.devops-monk.com/tutorials/spring-boot/spring-boot-4-whats-new/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-boot/spring-boot-4-whats-new/Spring Boot 4.0 (November 2025) is a major release built on Spring Framework 7 and Java 17+. It&rsquo;s the most significant Spring release since Boot 3&rsquo;s Jakarta EE migration. This article covers every change that affects a practicing developer. Minimum Requirements Spring Boot 3.x Spring Boot 4.0 Java 17 17 (baseline), 21 recommended Spring Framework 6.x 7.x Jakarta EE 10 11 Tomcat 10.x 11.x Hibernate 6.x 7.x Gradle (if used) 7.https://blog.devops-monk.com/tutorials/spring-batch/writing-files-databases/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-batch/writing-files-databases/Introduction After reading and processing data, your batch job needs to write results somewhere. Spring Batch provides two essential writers: FlatFileItemWriter — writes items to CSV or any delimited/formatted flat file JdbcBatchItemWriter — writes items to a database using JDBC batch inserts/updates Both are transactional and restartable. This article covers both in depth, plus transaction semantics you must understand to avoid duplicates and partial writes. How Writers Work in Spring Batch Writers receive a Chunk&lt;O&gt; — a list of all items processed in the current transaction.https://blog.devops-monk.com/tutorials/spring-boot/first-spring-boot-application/Sun, 03 May 2026 00:00:00 +0000https://blog.devops-monk.com/tutorials/spring-boot/first-spring-boot-application/In this article you&rsquo;ll create a Spring Boot application, add a REST endpoint, and run it — all in under 10 minutes. Then you&rsquo;ll understand exactly what each piece does. What you&rsquo;ll build: A Spring Boot app that responds to GET /hello with &quot;Hello, Spring Boot!&quot;. Prerequisites JDK 21 or higher installed (java -version to verify) Maven 3.9+ installed (mvn -version to verify) An IDE — IntelliJ IDEA (recommended), VS Code with Java extension, or Eclipse Step 1: Generate the Project Go to start.