Introduction to Spring Framework (Getting Started with Spring Boot)

Remember when we broke up the monolith and your services got their own tiny apartments? Cute. Now they need plumbing, electricity, and a landlord who actually answers emails. That landlord is the Spring Framework. And Spring Boot? That's the property manager who hands you the keys, pre-installs the Wi‑Fi, and says, "Please don't set anything on fire."

This is your high‑energy, no-fluff Introduction to Spring Framework — the foundation under Spring Boot — so your microservices can stop couch-surfing and start thriving.

---

What Is the Spring Framework?

The Spring Framework is a comprehensive programming and configuration model for building modern, Java-based enterprise applications. At its core are two superhero moves:

• Inversion of Control (IoC): The framework creates and wires your objects (called "beans") so you don't have to new Everything Everywhere All at Once.
• Dependency Injection (DI): Instead of classes hunting down their dependencies, those dependencies are delivered to them on a velvet pillow.

Spring: "I'll manage your objects' lifecycle and wiring." You: "So I can focus on actual business logic?" Spring: "Precisely."

A little origin story for flavor:

• Early 2000s Java (a.k.a. "EJB era") was heavy, XML-ridden, and allergic to joy.
• Rod Johnson (hi, Rod) published ideas for lightweight, POJO-based development.
• Spring emerged to make Java development faster, cleaner, and testable — and then took over the enterprise world like a polite, very organized revolution.

Core Spring Modules (Speed-Dating Edition)

Module	What it does	Why you care
Core/Beans/Context	IoC container, bean lifecycle, resource loading	DI magic; the reason Spring exists
AOP	Cross-cutting concerns via proxies	Logging, transactions, security without spamming your code
Data (JDBC/ORM), Transactions	Consistent data access, declarative transactions	Database sanity; @Transactional saves lives
Web (Spring MVC/WebFlux)	REST controllers, reactive stack	Build APIs without crying
Validation	Bean validation (JSR-380)	Keep bad data out politely
Test	Testing utilities, context bootstrapping	Unit and integration tests that don't feel like crime

---

How Does the Spring Framework Work?

Spring is a container that holds and manages your objects. Think: a backstage manager that knows every actor, their cues, and which props they need.

1) Beans and the ApplicationContext

• A bean is just an object managed by Spring.
• The ApplicationContext is Spring's brain. You ask it for beans; it gives you carefully prepared instances.

// Minimal Java-based configuration
@Configuration
@ComponentScan("com.example.demo")
public class AppConfig {}

@Component
class CasualGreetingService implements GreetingService {
    public String greet(String name) { return "Hey, " + name + "!"; }
}

interface GreetingService { String greet(String name); }

public class Demo {
    public static void main(String[] args) {
        try (var ctx = new AnnotationConfigApplicationContext(AppConfig.class)) {
            GreetingService svc = ctx.getBean(GreetingService.class);
            System.out.println(svc.greet("Microservice"));
        }
    }
}

• No new CasualGreetingService() in main. Spring does the wiring. You vibe.

2) Configuration Styles (pick your seasoning)

• Annotations: @Component, @Service, @Repository, @Controller — automatic classpath scanning.
• Java Config: @Configuration + @Bean for explicit control.
• XML: legacy, still supported for archaeology or very special cases.

@Configuration
class Beans {
    @Bean
    public GreetingService greetingService() { return new CasualGreetingService(); }
}

3) Dependency Injection: Constructor FTW

@Service
class WelcomeController {
    private final GreetingService greetingService;

    public WelcomeController(GreetingService greetingService) {
        this.greetingService = greetingService; // injected by Spring
    }

    public String welcome(String name) { return greetingService.greet(name); }
}

• Prefer constructor injection for immutability and testability.
• Need multiple beans of the same type? Use @Qualifier or @Primary like a bouncer for your dependencies.

4) AOP (Add superpowers without touching core logic)

Cross-cutting concerns (logging, transactions, security) are applied via proxies.

@Aspect
@Component
class LogAspect {
    @Before("execution(* com.example..*Service.*(..))")
    public void logBefore() { System.out.println("Service method incoming 🚦"); }
}

• You're not sprinkling System.out.println everywhere. One aspect rules them all.

---

Why Does the Spring Framework Matter for Microservices?

From our microservices module: services should be small, independently deployable, and loosely coupled. Spring is basically engineered for that vibe.

• Loose coupling via DI: Swap implementations without a summer of refactoring.
• Consistency across services: Same model for REST, data access, security.
• Testability: You can boot contexts fast, mock beans, and ship stable.
• Cross-cutting concerns: Logging, metrics, tracing, resilience — all standardized.
• Ecosystem: Spring Cloud adds service discovery, config server, circuit breakers, gateways. Chef's kiss.

And Spring Boot layers on:

• Auto-configuration: Sensible defaults based on classpath.
• Starter dependencies: One starter brings the whole squad.
• Embedded servers: Run as fat jars; goodbye, app server.
• Actuator: Health, metrics, info endpoints = observability on day one.

Microservices are independent, but your tooling shouldn't be chaotic. Spring gives you order without the bureaucracy.

---

Examples of Dependency Injection in Spring Framework

Picture a tiny REST-y microservice with Spring MVC.

@RestController
@RequestMapping("/api")
class ApiController {
    private final GreetingService greetingService;

    ApiController(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    @GetMapping("/hello/{name}")
    String hello(@PathVariable String name) {
        return greetingService.greet(name);
    }
}

• You focus on endpoints; Spring autowires the service.
• In Boot, you wouldn't even need the AppConfig — @SpringBootApplication plus component scanning gets it done.

For contrast, the old XML days (for historical drama):

<bean id="greetingService" class="com.example.CasualGreetingService"/>

Now we mostly live in annotation city.

---

Common Mistakes in Spring for Beginners

• Using field injection with @Autowired everywhere. Prefer constructor injection for testability and null-safety.
• Forgetting package structure. @SpringBootApplication scans sub-packages by default; put your main class at the top of your package tree.
• Ignoring bean scopes. Default is singleton; if you need per-request or prototype, specify it.
• Misusing @Transactional. It won’t apply to private methods or self-invocation. Put it on public methods in a proxied bean.
• Circular dependencies. If A needs B and B needs A, the container will give you a stern look. Rethink your design or break via interfaces.
• Not understanding proxies. AOP-based features wrap your beans; calling a proxied method from inside the same class won't trigger the advice.
• Fighting auto-configuration. In Boot, check --debug logs and @ConditionalOn… rules before writing custom beans.

---

Quick Mental Models (So It Sticks)

• IoC Container: A very competent stage manager. You write the play; it places the actors and hands them props on cue.
• DI: Uber Eats for dependencies. You place an order (interface), and it shows up hot (implementation) without you leaving the couch.
• AOP: Instagram filters for methods. One swipe adds logging or transactions across your codebase.
• Spring vs Spring Boot: Spring is the engine; Boot is the car. You can assemble the engine yourself, but why, when Boot hands you a tuned vehicle with cupholders and CarPlay?

---

How Does the Spring Framework Connect to Spring Boot?

This section seals the deal: Boot is a layer on top of Spring Framework that removes boilerplate.

• Boot uses the IoC container, but wires common needs automatically.
• Boot starters are curated dependency bundles so you don’t debug Maven for days.
• Boot’s application.yml externalizes config so the same image runs in dev/stage/prod.
• Actuator exposes /actuator/health, metrics, and info so your microservice isn't a mysterious black box.

Minimal Boot app (yes, this is real):

@SpringBootApplication
public class App {
  public static void main(String[] args) {
    SpringApplication.run(App.class, args);
  }
}

@RestController
class PingController {
  @GetMapping("/ping") String ping() { return "pong"; }
}

Behind the curtain: a full Spring Framework context, auto-configured Tomcat, and a REST controller — in under 20 lines. Your microservice says hi.

---

Key Takeaways from this Introduction to Spring Framework

• The Spring Framework provides IoC/DI and AOP at the core, enabling clean, testable Java apps.
• It standardizes data access, web, transactions, validation, and testing — perfect foundations for microservices.
• Spring Boot builds on Spring to remove ceremony via auto-configuration, starters, and embedded servers.
• Constructor injection, clear package structure, and understanding proxies will save you from 90% of rookie pain.
• You bring business logic; Spring brings infrastructure superpowers.

Powerful insight: Microservices succeed when teams can ship small changes confidently. Spring’s container and ecosystem make that confidence boringly routine — which is exactly what you want.

Next up: we’ll spin your first Spring Boot project, peek at starters and auto-config, and ship a tiny service that actually does something. Snacks encouraged. Confidence mandatory.