Overview

Learning Approach

This By Example series teaches Spring Framework through code-first learning with heavily annotated examples. Each example is self-contained and runnable, demonstrating specific Spring Framework concepts.

Target: 75-90 examples achieving 95% Spring Framework coverage

Annotation Density: 1.0-2.25 comment lines per code line (per example)

Format: All examples in both Java and Kotlin

Why By Example?

Traditional tutorials often provide long explanations before showing code. This approach inverts that pattern:

Code First: Start with working, runnable examples Inline Documentation: Every line annotated with // => explaining what happens Incremental Complexity: Simple examples first, building to advanced patterns Islamic Finance Context: Real-world scenarios (Zakat, Murabaha, Sadaqah)

Structure

Beginner Examples (0-50% Coverage)

Topics Covered:

IoC Container basics
Bean definitions with @Configuration and @Bean
Component scanning with @Component, @Service, @Repository
Dependency injection (constructor, setter, field)
Bean scopes (singleton, prototype)
Lifecycle callbacks (@PostConstruct, @PreDestroy)
Property injection with @Value
Profile-based configuration (@Profile)

Example Count: ~25-30 examples

Skill Level: No prior Spring knowledge required

Intermediate Examples (50-85% Coverage)

Topics Covered:

Advanced dependency injection (qualifiers, primary beans)
Data access with JdbcTemplate
Transaction management (@Transactional)
Spring AOP (aspects, pointcuts, advice types)
Event publishing and handling
SpEL (Spring Expression Language)
Resource handling
Validation with Bean Validation API
Testing with Spring Test framework

Example Count: ~30-35 examples

Skill Level: Completed beginner examples or equivalent knowledge

Advanced Examples (85-95% Coverage)

Topics Covered:

Custom bean post-processors
Advanced AOP (custom annotations, around advice)
Programmatic transaction management
Custom scope implementations
Conditional bean registration
Spring Web MVC (controllers, REST APIs)
Exception handling strategies
Async processing with @Async
Caching with @Cacheable
Integration testing strategies

Example Count: ~20-25 examples

Skill Level: Completed intermediate examples or production Spring experience

Example Format

Each example follows a five-part structure:

1. Concept Introduction

A 1-3 sentence explanation of what the example demonstrates, often including an Islamic finance scenario for real-world context.

2. Heavily Annotated Code

Self-contained, runnable Java and Kotlin implementations with // => annotations on every significant line.

Annotation density: 1.0-2.25 comment lines per code line

Example:

@Service  // => Marks as Spring-managed service component
public class ZakatService {
 
    private final ZakatRepository repository;  // => Final field - immutable
    // => Constructor injection (recommended)
    // => Spring automatically injects repository parameter
    public ZakatService(ZakatRepository repository) {
        this.repository = repository;  // => Dependency injected
    }
 
    @Transactional  // => Transaction boundary
    public void recordPayment(BigDecimal amount) {
        repository.save(new ZakatRecord(amount));  // => Persists within transaction
        // => Auto-commit on success
    }
}