Chapter 01: What is Spring Boot?

• Chapter 01: What is Spring Boot?
  • 1.1 Spring Framework
    • 1.1.1 Inversion of Control (IoC)
    • 1.1.2 Dependency Injection (DI)
    • 1.1.3 Aspect-Oriented Programming (AOP)
    • 1.1.4 Various Modules of the Spring Framework
  • 1.2 Spring Framework vs. Spring Boot
    • 1.2.1 Dependency Management
    • 1.2.2 Auto-configuration
    • 1.2.3 Embedded WAS (Web Application Server)
    • 1.2.4 Monitoring
  • Summary

Welcome to the world of Spring Boot with Kotlin! If you’re reading this, you’re likely looking to build modern, robust backend applications using one of the most powerful framework combinations available today. In this chapter, we’ll explore what makes Spring Boot special and why pairing it with Kotlin creates such a compelling development experience.

1.1 Spring Framework

Before we dive into Spring Boot, let’s understand its foundation: the Spring Framework. Spring has been the backbone of Java enterprise development for nearly two decades, and its core principles remain as relevant today as they were at its inception.

1.1.1 Inversion of Control (IoC)

Inversion of Control is the fundamental principle that powers Spring. Instead of your application code controlling the flow and lifecycle of objects, you delegate this responsibility to the Spring container. Think of it as hiring a skilled manager who handles all the complex coordination while you focus on writing business logic.

In traditional programming, your code might look like this:

class OrderService {
    // We're creating and managing the dependency ourselves
    private val repository = OrderRepository()
    private val emailService = EmailService()

    fun processOrder(order: Order) {
        repository.save(order)
        emailService.sendConfirmation(order)
    }
}

With IoC, Spring takes control:

@Service
class OrderService(
    // Spring injects these dependencies for us
    private val repository: OrderRepository,
    private val emailService: EmailService
) {
    fun processOrder(order: Order) {
        repository.save(order)
        emailService.sendConfirmation(order)
    }
}

Notice how we’re no longer responsible for creating instances? Spring handles that complexity, making our code cleaner and more testable.

1.1.2 Dependency Injection (DI)

Dependency Injection is how Spring implements IoC in practice. It’s the mechanism through which Spring “injects” the dependencies your classes need. In Kotlin, we prefer constructor injection because it plays nicely with Kotlin’s immutability features and null safety.

@Component
class PaymentProcessor(
    // All dependencies are injected through the constructor
    // They're automatically non-null and immutable (val)
    private val paymentGateway: PaymentGateway,
    private val fraudDetector: FraudDetector,
    private val auditLogger: AuditLogger
) {
    fun processPayment(amount: BigDecimal, customerId: String): PaymentResult {
        // Use injected dependencies with confidence - they're guaranteed to be initialized
        val fraudCheck = fraudDetector.checkTransaction(amount, customerId)
        if (fraudCheck.isRisky) {
            auditLogger.logRiskyTransaction(customerId, amount)
            return PaymentResult.DECLINED
        }

        return paymentGateway.charge(amount, customerId)
    }
}

1.1.3 Aspect-Oriented Programming (AOP)

AOP allows us to separate cross-cutting concerns from our business logic. Common examples include logging, security, transactions, and caching. Instead of littering these concerns throughout your code, AOP lets you define them once and apply them declaratively.

// Define an aspect for performance monitoring
@Aspect
@Component
class PerformanceMonitor {

    @Around("@annotation(Monitored)")
    fun measureExecutionTime(joinPoint: ProceedingJoinPoint): Any? {
        val startTime = System.currentTimeMillis()

        return try {
            joinPoint.proceed()
        } finally {
            val executionTime = System.currentTimeMillis() - startTime
            println("${joinPoint.signature.name} executed in ${executionTime}ms")
        }
    }
}

// Use the aspect with a simple annotation
@Service
class CustomerService {

    @Monitored
    fun findCustomerById(id: Long): Customer? {
        // Your business logic here - no timing code needed!
        Thread.sleep(100) // Simulate database call
        return Customer(id, "John Doe")
    }
}

1.1.4 Various Modules of the Spring Framework

Spring isn’t just one monolithic framework; it’s a collection of modules that you can mix and match based on your needs:

• Spring Core: The foundation providing IoC and DI
• Spring MVC: For building web applications and REST APIs
• Spring Data: Simplifies database access with repositories
• Spring Security: Comprehensive security framework
• Spring Cloud: Tools for building distributed systems
• Spring Batch: For batch processing applications
• Spring Integration: Enterprise integration patterns

Each module is designed to work seamlessly with the others, creating a cohesive ecosystem for building enterprise applications.

1.2 Spring Framework vs. Spring Boot

Now that we understand Spring Framework, let’s explore what Spring Boot brings to the table. Spring Boot isn’t a replacement for Spring Framework—it’s an opinionated layer on top that eliminates much of the configuration burden.

1.2.1 Dependency Management

Remember the days of dependency hell? Spring Boot’s dependency management makes that a thing of the past. Instead of manually managing compatible versions of dozens of libraries, Spring Boot provides carefully curated dependency groups called “starters.”

Traditional Spring approach:

// build.gradle.kts - Manual dependency management
dependencies {
    implementation("org.springframework:spring-webmvc:5.3.23")
    implementation("org.springframework:spring-context:5.3.23")
    implementation("com.fasterxml.jackson.core:jackson-databind:2.13.4")
    implementation("org.hibernate:hibernate-core:5.6.12.Final")
    implementation("org.apache.tomcat.embed:tomcat-embed-core:9.0.68")
    // ... many more with version compatibility concerns
}

Spring Boot approach:

// build.gradle.kts - Simplified with starters
dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    // That's it! All compatible versions are managed for you
}

1.2.2 Auto-configuration

This is where Spring Boot truly shines. Auto-configuration intelligently configures your application based on the dependencies you’ve included. Add a database driver to your classpath? Spring Boot automatically configures a DataSource. Include Spring Security? You get a basic security setup out of the box.

// Just by having this in your dependencies:
// implementation("org.springframework.boot:spring-boot-starter-data-jpa")
// implementation("org.postgresql:postgresql")

// Spring Boot automatically configures:
// - DataSource with connection pooling
// - EntityManagerFactory
// - TransactionManager
// - Repository scanning

// You can just start using it:
@Repository
interface UserRepository : JpaRepository<User, Long> {
    fun findByEmail(email: String): User?
}

// No XML configuration, no @Bean definitions needed!

1.2.3 Embedded WAS (Web Application Server)

Gone are the days of building WAR files and deploying to external application servers. Spring Boot embeds the server right in your application, making it a self-contained, runnable JAR.

@SpringBootApplication
class Application

fun main(args: Array<String>) {
    runApplication<Application>(*args)
    // That's it! Your application starts with an embedded Tomcat server
    // No external server setup required
}

This approach offers several advantages:

• Simplified deployment: Just run java -jar your-app.jar
• Consistent environments: The same server runs in development and production
• Container-friendly: Perfect for Docker and Kubernetes deployments
• Version control: Server version is managed like any other dependency

1.2.4 Monitoring

Spring Boot Actuator provides production-ready monitoring features out of the box. With minimal configuration, you get health checks, metrics, and operational insights.

// Just add the dependency:
// implementation("org.springframework.boot:spring-boot-starter-actuator")

// Configure what to expose in application.yml:

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  metrics:
    export:
      prometheus:
        enabled: true

// Now you have endpoints like:
// - /actuator/health - Application health status
// - /actuator/metrics - Application metrics
// - /actuator/info - Application information
// - /actuator/prometheus - Metrics in Prometheus format

// You can also add custom health indicators:
@Component
class DatabaseHealthIndicator(
    private val dataSource: DataSource
) : HealthIndicator {

    override fun health(): Health {
        return try {
            dataSource.connection.use { connection ->
                if (connection.isValid(1)) {
                    Health.up()
                        .withDetail("database", "PostgreSQL")
                        .withDetail("status", "Connected")
                        .build()
                } else {
                    Health.down()
                        .withDetail("error", "Invalid connection")
                        .build()
                }
            }
        } catch (e: Exception) {
            Health.down(e).build()
        }
    }
}

Summary

In this chapter, we’ve explored the foundations of Spring Boot and how it builds upon the Spring Framework to provide a streamlined development experience. We’ve seen how:

• Spring Framework provides the core features like IoC, DI, and AOP that power enterprise Java applications
• Spring Boot eliminates configuration complexity through intelligent defaults and auto-configuration
• Dependency management is simplified through carefully curated starter dependencies
• Embedded servers make deployment straightforward and consistent
• Production-ready features like monitoring come built-in with Spring Boot Actuator

The combination of Spring Boot’s productivity features with Kotlin’s expressive syntax creates a powerful platform for building modern applications. In the next chapter, we’ll dive deeper into the foundational knowledge you’ll need before starting development, including REST API design, design patterns, and Kotlin-specific features that make Spring Boot development even more enjoyable.