Java · Intermediate
Functional Interfaces and Lambda Expressions
Functional interfaces contain exactly one abstract method and can be implemented using lambda expressions to provide a concise way to represent anonymous functions.
Open snippet →Code library
Intermediate Java exercises
Read these Intermediate Java snippets line by line — each one comes with a written breakdown of what the code does and why.
Java · Intermediate
Immutability with Records
Records are a special kind of class that acts as a transparent carrier for immutable data, automatically generating constructors, accessors, equals, and hashCode.
Open snippet →Java · Intermediate
Stream API for Collection Processing
Streams allow functional-style operations on sequences of elements, such as filtering, mapping, and reducing collections efficiently.
Open snippet →Java · Intermediate
Safely Handling Null with Optional
The Optional class is a container object used to represent the presence or absence of a value, helping to avoid NullPointerExceptions.
Open snippet →Java · Intermediate
Automatic Resource Management
The try-with-resources statement ensures that each resource is closed at the end of the statement, preventing memory leaks and resource exhaustion.
Open snippet →Java · Intermediate
Exception Chaining for Better Debugging
Exception chaining allows you to wrap a low-level exception (like IOException) into a higher-level business exception while preserving the original cause. This keeps the stack trace intact for debu…
Open snippet →Java · Intermediate
Custom Annotations for Metadata
Custom annotations allow you to add metadata to your code that can be processed at runtime via Reflection. This is often used by frameworks for cross-cutting concerns like logging or validation.
Open snippet →Java · Intermediate
Memory Visibility with the volatile Keyword
The volatile keyword ensures that changes to a variable are always visible to all threads immediately. It prevents threads from caching the variable locally, ensuring they always read the latest va…
Open snippet →Java · Intermediate
Generics: Upper Bounded Wildcards
Upper bounded wildcards (? extends T) allow a collection to hold objects of type T or any of its subclasses. This is useful for reading from a collection while maintaining type safety for various n…
Open snippet →Java · Intermediate
The Strategy Pattern using Enums
In Java, Enums can have abstract methods that each constant must implement. This effectively implements the Strategy design pattern, allowing different behaviors to be associated with different enu…
Open snippet →Java · Intermediatespring
Global Exception Handling with @ControllerAdvice
Using @ControllerAdvice allows you to handle exceptions across the entire application in one central place. This separates error logic from business logic.
Open snippet →Java · Intermediatespring
Clean Constructor Dependency Injection
Constructor injection is the preferred way to handle dependencies in Spring. It ensures required dependencies are present and allows for 'final' fields.
Open snippet →Java · Intermediatespring
Testing Controllers with MockMvc
MockMvc allows you to test Spring MVC controllers without starting a full HTTP server. It provides a DSL for performing requests and verifying results.
Open snippet →Java · Intermediatespring
Method-Level Security with @PreAuthorize
Spring Security's @PreAuthorize allows you to define access control rules directly on methods using SpEL (Spring Expression Language).
Open snippet →Java · Intermediatespring
Custom Validation Constraint
Custom constraints allow you to extend Spring's validation capabilities by defining your own annotations. This is useful for complex business rules that aren't covered by standard JSR-303 annotatio…
Open snippet →Java · Intermediatespring
Transaction Propagation: REQUIRES_NEW
Propagation.REQUIRES_NEW creates a separate transaction that is independent of the caller's transaction. If the caller's transaction rolls back, this one will still commit, which is ideal for audit…
Open snippet →Java · Intermediatespring
Performance Optimization with @Cacheable
Spring Cache abstraction allows you to transparently cache expensive operations. Subsequent calls with the same ID will return the cached value instead of executing the method body.
Open snippet →Java · Intermediatespring
Dynamic Filtering with JPA Specifications
JPA Specifications allow you to build dynamic and reusable queries using the Criteria API. This is much more flexible than writing multiple repository methods for every filter combination.
Open snippet →Java · Intermediatespring
Conditional Bean Loading
Conditional beans allow your application to adapt its configuration based on environment variables or property files. This is essential for supporting different cloud providers or local development…
Open snippet →Java · Intermediatespring
Custom Health Indicators with Spring Boot Actuator
Custom health indicators allow you to monitor the status of external dependencies like APIs or databases beyond the default Spring Boot checks. These statuses are exposed via the /actuator/health e…
Open snippet →Java · Intermediatespring
Intercepting Requests with HandlerInterceptor
A HandlerInterceptor allows you to execute logic before or after a request reaches a controller. This is ideal for logging, authentication checks, or adding common headers without cluttering contro…
Open snippet →Java · Intermediatespring
Decoupling Components with Application Events
Application events facilitate loose coupling between components. Instead of calling an email service directly from a registration service, you publish an event that interested listeners can handle…
Open snippet →Java · Intermediatespring
Interface-based Projections in Spring Data JPA
Projections allow you to fetch only specific fields from the database instead of loading entire entities. This reduces memory usage and improves database performance by selecting only needed columns.
Open snippet →Java · Intermediatespring
Handling Lifecycle Hooks with JPA Entity Listeners
Entity Listeners allow you to execute logic at specific points in a JPA entity's lifecycle, such as before persistence or after loading, without modifying the entity class itself.
Open snippet →Java · Intermediatespring
Custom HandlerMethodArgumentResolver for Clean Controllers
Custom argument resolvers allow you to automatically inject complex objects into controller methods based on request data like headers or session attributes. This keeps your controllers clean and r…
Open snippet →Java · Intermediatespring
Aspect-Oriented Programming (AOP) for Performance Monitoring
AOP allows you to separate cross-cutting concerns like logging or timing from your actual business logic. Using the @Around advice, you can intercept method calls, execute logic before and after, a…
Open snippet →Java · Intermediatespring
Type-safe Configuration with @ConfigurationProperties
@ConfigurationProperties provides a type-safe way to map external properties (e.g., from application.yml) into Java objects. This is superior to using @Value because it supports hierarchical struct…
Open snippet →Java · Intermediatespring
Injecting Auth Headers with RestTemplate Interceptors
Interceptors in RestTemplate allow you to apply logic to all outgoing HTTP requests globally. This is ideal for adding authentication tokens, logging request payloads, or handling custom error logi…
Open snippet →Java · Intermediatespring
Dynamic JSON Filtering using @JsonView
@JsonView allows you to control which fields of an object are serialized into JSON depending on the context. You can define marker interfaces to create 'views' (e.g., Public vs. Admin) and apply th…
Open snippet →Java · Intermediatespring
Centralized Error Handling with @RestControllerAdvice
In Spring Boot, @RestControllerAdvice is used to handle exceptions globally across the entire application. Instead of putting try-catch blocks in every controller, this component intercepts specifi…
Open snippet →