Spring Boot

Fundamentals

Definition

Spring Boot is a open-source framework built on top of the Spring platform. Its primary goal is to simplify the development of Java applications, particularly microservices, by providing autoconfiguration and reducing boilerplate code

Modules

• Core Modules
  • Core: Central module providing the basic functionalities and configuration for Spring Boot applications
  • Autoconfigure: Automatically configures Spring and 3rd-party libraries based on classpath contents, other beans, and various property settings
• Web Modules
  • Web: Provides support for building web applications using Spring MVC
  • Webflux: Provides support for reactive programming with Spring WebFlux, allowing you to build non-blocking, event-driven applications
• Data Modules
  • Data JPA: Provides support for Java Persistence API (JPA) to interact with relational databases
  • Data MongoDB: Offers support for MongoDB, allowing you to work with NoSQL databases
  • Data Redis: Provides integration with Redis, a powerful in-memory data structure store
  • Data JDBC: Simplifies working with JDBC-based data access and relational databases without using JPA
• Security Modules
  • Security: Provides security features for Spring Boot applications, including authentication, authorization, and encryption
  • OAuth2: Offers support for implementing OAuth 2.0 authentication and authorization mechanisms
• Messaging Modules:
  • AMQP: Provides support for messaging with RabbitMQ using the Advanced Message Queuing Protocol (AMQP)
  • Kafka: Offers support for messaging with Apache Kafka, a distributed streaming platform
• Testing Modules
  • Test: Offers testing support for Spring Boot applications, including unit, integration, and end-to-end testing
  • Test Starter: Includes dependencies for testing, such as JUnit, Mockito, and Spring Test
• Cloud Modules
  • Spring Cloud Config: Provides centralized external configuration management for distributed systems
  • Spring Cloud Netflix: Integrates Spring applications with Netflix OSS components, such as Eureka for service discovery, Ribbon for client-side load balancing, Hystrix for circuit breaking, and Zuul for API gateway
  • Spring Cloud Stream: Offers support for building event-driven microservices with Spring Integration
  • Spring Cloud Function: Provides a programming model and runtime support for serverless functions in Spring Boot applications
• Monitoring and Management Modules
  • Actuator: Provides features for monitoring and managing Spring Boot applications, including health checks, metrics, and environment details

Optimization

Aspect	Definition	Benefits	Example
Lazy Bean Initialization	Load bean only when needed	Reduces memory footprint	// Load bean when it is needed, ideal for optional features @Lazy @Bean // Load bean only if a given bean is missing @Bean @ConditionalOnMissingBean // Load bean based on app config, ideal for optional features @Configuration @ConditionalOnProperty(name = "feature.enabled", havingValue = "true") // Load bean based on classpath, for scenarios where certain classes are expected to be present @Configuration @ConditionalOnClass(name = "com.example.SomeClass") // Load bean based on classpath, for scenarios where certain classes are missing @Configuration @ConditionalOnMissingClass(name = "com.example.SomeExcludedClass")
Minimize Auto-Configuration	Disable unnecessary auto-configurations	Reduces startup time	spring: autoconfigure: exclude: org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration
Dependencies	Include only essential dependencies	Reduces startup time and application size	// use maven-dependency-plugin to analyze dependencies mvn dependency:analyze // use maven-enforcer-plugin to enforce dependencies mvn enforcer:enforce // use maven-dependency-plugin to exclude dependencies mvn dependency:tree -DexcludeTransitive=true // check dependencies versions mvn versions:display-dependency-updates // check plugins versions mvn versions:display-version-updates
Classpath Scanning	Limit classpath scanning to only necessary packages	Reduces startup time	@SpringBootApplication(scanBasePackages = "com.example")
Garbage Collection Tuning	Enable garbage collection	Reduce memory usage and improves performance	// Garbage-First (G1) Collector -XX:+UseG1GC // Set min and max heap size equal for stable heap usage during runtime -Xms=2G -Xmx=2G // Set max pause time for garbage collection based on the project performance -XX:MaxGCPauseMillis=500 // Disable explicit GC calls -XX:+DisableExplicitGC // Enable string deduplication to reduce memory usage -XX:+UseStringDeduplication // Enable parallel GC for faster garbage collection -XX:+ParallelRefProcEnabled // Set max size for class metadata -XX:MaxMetaspaceSize=256M // Set max tenuring threshold based on the project performance -XX:MaxTenuringThreshold=15 // Set number of threads for garbage collection -XX:ConcGCThreads=2 // Set initial heap occupancy -XX:InitiatingHeapOccupancyPercent=25
HTTP Compression	Enable HTTP compression	Reduces network traffic	# based on the project specification lz4 or other compression algorithm can be used spring: http: gzip: enabled: true mime-types: application/json min-gzip-size: 1024 deflate-compression-level: 6
JVM Version	Use a compatible latest JVM for best performance	Improves overall performance
GraalVM Native Image	Scale Zero (low memory footprint and fast startup time). With tradeoffs: Slow compilation Additional metadata required for reflection, proxies, and resources Closed world assumptions. Bean conditions fixed at build time. No dynamic class loading	Improves startup time and application size
Virtual Threads (JDK 21+)	Reduces the cost of server applications written in thread-per-request style to scale with near-optimal hardware utilization	Reduces memory footprint and improves performance	var thread = Thread.ofVirtual().start(() -> System.out.println("Hello"));
JIB	JIB (Java Image Builder) is a build tool for containerization that produces highly optimized build images	Reduces startup time, application size, and overall performance
JVM Memory Management	Use JVM Memory Calculator to estimate memory usage	Reduces memory footprint
Compiler Optimization	Enhances performance by using multiple levels of compilation	Reduces build time	// Enhances performance by using multiple levels of compilation JAVA_OPTS: -XX:+TieredCompilation // Limits compilation to the first tier, balancing performance and compilation time JAVA_OPTS: -XX:TieredStopAtLevel=1 // Compile with multiple threads (1C is 1 thread per CPU core) mvn -T 1C clean install
Threads Memory Management	Control memory allocation per thread	Reduces memory footprint and improves performance	// Control memory allocation per thread JAVA_OPTS: -Xss256k
Connection Pooling	Connection pooling reduces network traffic	Improves performance and reduces initial database connection time	spring: datasource: type: com.zaxxer.hikari.HikariDataSource hikari: maximum-pool-size: 10 minimum-idle: 5 idle-timeout: 30000 connection-test-query: SELECT 1