Spring Boot Introduction

No, you can start with Spring Boot directly. Most developers today learn Spring through Spring Boot, because it lets you build something working right away.

As you progress, learn the core Spring ideas underneath, because Spring Boot uses them everywhere:

• Beans and the application context.
• Dependency injection: how objects receive what they need.
• Annotations such as @Component, @Service and @Autowired.

Knowing these makes it much easier to understand what Spring Boot does automatically, and to fix problems when something does not work as expected.

Yes. Spring Boot is open source under the Apache License 2.0. You can use it in personal, commercial and closed-source projects at no cost.

The free community releases receive updates and security fixes for a limited time after each version. Companies that need longer support for older versions can buy commercial support, but most projects simply upgrade to newer free versions.

Current Spring Boot versions (3.x and later) require Java 17 or newer. The older 2.x line worked with Java 8 and 11, but it no longer receives free updates.

For new projects, choose a long-term support (LTS) Java release such as Java 21. LTS versions receive updates for years, which makes them safer for production.

Both work equally well with Spring Boot, and Spring Initializr can generate either one.

If you are just starting, choose Maven, since most examples, including the ones on this site, use it. If your team already uses Gradle, use that.

It means Spring Boot makes sensible choices for you by default, based on what most applications need. For example:

• The web starter uses Tomcat as the server.
• JSON is handled with Jackson.
• Logging uses Logback.
• The server listens on port 8080.

These are only defaults, not rules. You can change any of them with a property, a dependency change, or your own configuration. The idea is: start fast with good choices, and override what you need.

You can change almost any default, usually in one of three ways:

1. Set a property in application.properties, such as server.port=9090. Most defaults have a matching property.
2. Define your own bean. When you create a bean of the same type, Spring Boot’s automatic one steps aside.
3. Swap a dependency, for example excluding Tomcat and adding Jetty instead.

@Configuration
public class JsonConfig {

    // Your own ObjectMapper replaces the one Spring Boot would create
    @Bean
    public ObjectMapper objectMapper() {
        return JsonMapper.builder()
                .findAndAddModules()
                .build();
    }
}

Yes. If you leave out the web starter, no web server starts, and the application simply runs its code. Use a CommandLineRunner for code that should run at startup:

@SpringBootApplication
public class ReportApplication implements CommandLineRunner {

    private final ReportService reportService;

    public ReportApplication(ReportService reportService) {
        this.reportService = reportService;
    }

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

    @Override
    public void run(String... args) {
        reportService.generateMonthlyReport(); // runs once, then the app exits
    }
}

Spring Boot is also widely used for batch jobs, scheduled tasks and applications that process messages from queues.

Yes, although a runnable JAR is simpler and more common. To build a WAR, change the packaging and extend SpringBootServletInitializer:

<packaging>war</packaging>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

@SpringBootApplication
public class GreetingApplication extends SpringBootServletInitializer {

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

Use this only when your company requires an existing application server. For new deployments, especially containers and cloud platforms, a JAR is easier.

Another program, often a previous run of your own application, is already using port 8080. You have three options:

• Stop the other program. Check your IDE for an application that is still running.
• Find what is using the port:

# macOS / Linux
lsof -i :8080

# Windows
netstat -ano | findstr :8080

• Use a different port for your application:

server.port=8081

Setting server.port=0 picks a random free port, which is handy for tests.

No. Spring Boot became famous with microservices because it makes small, independent services easy to build and run. It works just as well for:

• Monoliths: one larger application containing many features.
• Modular monoliths: one application split into clear internal modules.
• Internal tools, batch jobs and back-office systems.

Many teams start with a single well-structured Spring Boot application and only split it into microservices when there is a clear need.

At startup, Spring Boot scans classes, creates beans and runs auto-configuration, which takes time and memory. Common ways to improve it:

• Remove starters you do not use. Each one brings more auto-configuration.
• Enable lazy initialization during development with spring.main.lazy-initialization=true, so beans are created only when needed.
• Use a newer Java version, which usually starts faster and uses memory more efficiently.
• Build a native image with GraalVM for very fast startup and low memory use, at the cost of a longer build.

./mvnw -Pnative native:compile

It is the parent of your pom.xml, and it gives your project three things:

• Dependency versions: hundreds of libraries with versions that are tested together, which is why starters need no version number.
• Sensible build settings, such as the Java version and UTF-8 encoding.
• Plugin setup for building the runnable JAR.

If your project must use another parent, import the spring-boot-dependencies BOM in <dependencyManagement> instead to get the same version management.

Both do exactly the same job; the choice is about style:

# application.properties
server.port=9090
spring.application.name=greeting-service

# application.yml
server:
  port: 9090
spring:
  application:
    name: greeting-service

Properties files are flat and simple. YAML groups related settings and suits long configurations, but its indentation must be exact. Pick one per project and stick to it.

DevTools speeds up development. It restarts your application automatically when you recompile code, and turns off template caching so page changes show immediately. Add it as an optional dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

Never use it in production. DevTools switches itself off automatically when the application runs from a packaged JAR with java -jar, but marking it optional also keeps it out of the final build.

Version numbers follow the pattern major.minor.patch, for example 3.5.2:

New minor versions come out about twice a year. Upgrade regularly, one minor version at a time, read the release notes, and run your tests. Adding the spring-boot-properties-migrator dependency temporarily reports renamed or removed properties at startup.

Any modern Java IDE works. Popular choices:

• IntelliJ IDEA: the Community edition is free; the paid Ultimate edition adds extra Spring support.
• Eclipse with Spring Tools: free, with Spring-specific features.
• Visual Studio Code: free and lightweight, with the Java and Spring Boot extension packs.

All of them can create projects through Spring Initializr and run the main class with one click. Use whichever you are most comfortable with.

Yes. Spring Boot fully supports Kotlin, and Spring Initializr can generate a Kotlin project. The same controller looks like this:

@RestController
class GreetingController {

    @GetMapping("/hello")
    fun hello(@RequestParam(defaultValue = "World") name: String) =
        mapOf("message" to "Hello, $name!")
}

Groovy is also supported. Java remains the most common choice, with the most examples and answers available online.

Spring Boot can build a container image for you, with no Dockerfile needed, as long as Docker is running on your machine:

./mvnw spring-boot:build-image
docker run -p 8080:8080 greeting:0.0.1-SNAPSHOT

If you prefer to write your own Dockerfile, a minimal one copies the JAR into a Java runtime image:

FROM eclipse-temurin:21-jre
COPY target/greeting-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

• Spring MVC is the part of the Spring Framework that handles web requests: controllers, request mapping and views.
• Spring Boot is not a web framework itself. It sets up and runs Spring applications, including Spring MVC.

When you add spring-boot-starter-web, you are using Spring MVC to write controllers, while Spring Boot configures it, adds JSON support and starts Tomcat. So you usually use them together rather than choosing between them.

Pick something small that touches the main building blocks, and grow it step by step:

1. A to-do list API: REST endpoints to create, list, update and delete tasks.
2. Add a database with Spring Data JPA, using the built-in H2 database at first.
3. Add validation, so a task cannot have an empty title.
4. Add exception handling, returning a clear 404 for unknown tasks.
5. Write tests for the service and the controller.
6. Add Actuator and package the app as a JAR or Docker image.

Each step has its own tutorial in the Spring Boot tutorial series.