Quick summary for people who like to ship

Want to prove that dependency injection actually works and not just in conference slides This tiny Spring Boot Hello World example uses a Spring bean and a startup runner to print or serve a greeting on embedded Tomcat It is the kind of minimal setup that teaches IoC without drama

What you need before pretending to be productive

• JDK 8 or later
• Maven or Gradle for dependency management
• Any IDE that will stop crying when you fix imports

Core steps you will actually follow

1. Bootstrap a Spring Boot project using start.spring.io or your IDE and include Spring Web
2. Define a Spring bean with @Component or @Service that returns a greeting string
3. Inject that bean into a runner that implements CommandLineRunner or into a @RestController using constructor injection
4. Start the app by running the main method or using your build tool with the Spring Boot plugin so embedded Tomcat comes alive
5. Verify by watching the console for a println or by hitting the HTTP endpoint if you made a controller

Why this works in plain English

Spring Boot wires a bean you declare into the places you need it This is inversion of control in practice Not magic just configuration and a framework doing the heavy lifting Constructor injection keeps dependencies explicit and easy to test If your app prints Hello World it means the bean was found and injected correctly and Tomcat can serve requests

Example structure without the fluff

// Greeting service as a Spring bean
@Component
public class GreetingService {
    public String greet() {
        return "Hello World"
    }
}

// Runner that executes at startup
@Component
public class AppRunner implements CommandLineRunner {
    private final GreetingService greetingService

    public AppRunner(GreetingService greetingService) {
        this.greetingService = greetingService
    }

    @Override
    public void run(String... args) {
        System.out.println(greetingService.greet())
    }
}

Use a @RestController instead of CommandLineRunner if you prefer to serve the greeting over HTTP Then inject the same GreetingService into the controller constructor and return the greeting from a handler method

Tips that save time and future regret

• Prefer constructor injection because testing gets less awkward and reflection gets less involved
• Let Spring manage beans with @Component or @Service for simple cases
• If you want a web endpoint include Spring Web so embedded Tomcat is added automatically

This minimal example teaches the essentials of Spring Boot dependency injection IoC and lifecycle without pulling you into configuration quicksand Build on it when you are brave enough to add more features and worse dependencies