Spring Framework

Spring Framework provides a reactive abstraction for R2DBC (Reactive Relational Database Connectivity) to standardize access to SQL databases using reactive patterns. The abstraction is divided into two main packages:

• org.springframework.r2dbc.core: Contains the central DatabaseClient class for managing SQL execution, resource lifecycle, and error translation.
• org.springframework.r2dbc.connection: Contains utilities for ConnectionFactory access and implementations for testing or running unmodified R2DBC.

Spring Framework provides several options for making calls to REST endpoints, depending on your concurrency and programming model requirements:

• RestClient: A synchronous client with a fluent API. It is the modern replacement for RestTemplate.
• WebClient: A non-blocking, reactive client with a fluent API, suitable for asynchronous and streaming scenarios.
• RestTemplate: A synchronous client with a template method API. Note: This is deprecated as of Spring Framework 7.0 in favor of RestClient.
• HTTP Service Clients: An annotated interface approach where a proxy is generated to handle requests via an underlying client (RestClient, WebClient, or RestTemplate).

Spring provides several storage integration options for its cache abstraction. To use any of these, you must declare an appropriate CacheManager which controls and manages Cache instances.

Supported integration types include:

• JDK ConcurrentMap-based Cache: Uses ConcurrentHashMap via org.springframework.cache.concurrent. Best for simple/test use cases.
• Ehcache 3.x: Fully JSR-107 compliant; uses standard JSR-107 integration.
• Caffeine: High-performance cache via org.springframework.cache.caffeine.
• GemFire: Scalable, distributed, and disk-backed caching via Spring Data GemFire.
• JSR-107 (JCache): Standardized cache integration via org.springframework.cache.jcache.
• No-Op Cache: A dummy cache used via CompositeCacheManager to handle missing cache definitions without throwing exceptions.

Spring WebFlux is a non-blocking, reactive web framework designed to handle high concurrency with a small number of threads and minimal hardware resources. It is built on the Reactive Streams specification to provide non-blocking back pressure, allowing subscribers to control the rate of data production from publishers.

Key motivations for using WebFlux include:

• Non-blocking I/O: Unlike the synchronous Servlet API, WebFlux is designed for asynchronous runtimes like Netty.
• Functional Programming: It leverages Java 8+ lambda expressions to offer functional web endpoints alongside traditional annotated controllers.
• Scalability: It uses a small, fixed-size thread pool (event loop workers) rather than the large thread pools used by blocking Servlet containers.

Spring's Object-XML Mapping (OXM) support provides a way to convert XML documents to and from Java/Kotlin objects (marshalling and unmarshalling).

Key benefits include:

• Ease of configuration: Marshallers can be configured as standard Spring beans or via XML namespace-based configuration.
• Consistent Interfaces: Spring uses the Marshaller and Unmarshaller abstractions, allowing you to switch underlying frameworks (like JAXB, JiBX, or XStream) with minimal code changes.
• Consistent Exception Hierarchy: Spring wraps underlying framework exceptions into its own hierarchy, with XmlMappingException as the root, ensuring no information is lost while providing a unified error handling model.

Spring Framework is a foundation for building Java enterprise applications.

Key Requirements:

• Java Version: As of Spring Framework 6.0, a minimum of Java 17+ is required.
• Supported Languages: While primarily for Java, it provides support for Groovy and Kotlin as alternative languages on the JVM.

Deployment Models: Spring is flexible across different architectures:

• Traditional Enterprise: Deployed to an application server.
• Cloud-Native/Modern: Deployed as a single JAR with an embedded server (often via Spring Boot).
• Standalone: Used for batch or integration workloads without a web server.

The spring-core module provides abstractions to work with various byte buffer APIs (like Java NIO ByteBuffer, Netty ByteBuf, or Jetty's pooled buffers) to improve performance in network operations.

Key components include:

• DataBufferFactory: Abstracts the creation of data buffers.
• DataBuffer: Represents a byte buffer (may be pooled).
• DataBufferUtils: Utility methods for manipulating data buffers.
• Encoder / Decoder: Strategy interfaces to encode/decode data buffer streams into higher-level objects.

Spring Expression Language (SpEL) is a powerful expression language designed for querying and manipulating an object graph at runtime. While it serves as the foundation for expression evaluation across the entire Spring portfolio (such as in XML or annotation-based bean definitions), it is a technology-agnostic API that can be used independently of Spring.

Key features include:

• Access & Manipulation: Accessing properties, arrays, lists, maps, and performing assignment.
• Operators: Relational, logical, string, mathematical, ternary, Elvis, and safe-navigation operators.
• Construction: Inline lists, inline maps, array construction, and constructor invocation.
• Advanced Logic: Regular expressions, collection projection, collection selection, and user-defined functions.
• Integration: Method invocation, bean references, and templated expressions.

Spring Framework supports the Jakarta Bean Validation API, allowing you to declare validation constraints using annotations on your domain model properties. These constraints are enforced at runtime by a Bean Validation provider (e.g., Hibernate Validator).

Common built-in constraints include:

• @NotNull: Ensures the property is not null.
• @Size(max=n): Ensures the string or collection size does not exceed n.
• @Min(n): Ensures a numeric value is at least n.

Example of a validated model in Java:

public class PersonForm {
	@NotNull
	@Size(max=64)
	private String name;

	@Min(0)
	private int age;
}