Setting Up a Spring Project

A plain Spring Framework project (without Spring Boot) needs only a JDK, a build tool and one dependency: spring-context. This is the best way to learn the container itself, because nothing is hidden behind auto-configuration. In this lesson you will create a Maven project by hand, understand every line of its pom.xml, see the folder structure, and compile it.

The next lessons then show how Spring Initializr creates a full Spring Boot project in seconds, and how to run your first application in both styles.

What you need first

Install a JDK 17 or newer (see the JDK installation lesson) and confirm that java -version and javac -version work. Then choose Maven or Gradle. The rest of this lesson uses Maven, and the Maven wrapper or a locally installed Maven both work.

The standard folder structure

Maven and Gradle expect the same layout, so learn it once. Java code goes under src/main/java, resources such as properties files go under src/main/resources, and tests go under src/test/java. Your packages then follow the reverse-domain convention.

• pom.xml - the Maven build description at the project root.
• src/main/java/com/webnest/first - your application classes.
• src/main/resources - configuration files, templates and static files.
• src/test/java - unit and integration tests.
• target - build output, created by Maven. Never commit it to Git.

The pom.xml, line by line

The groupId, artifactId and version identify your project. The maven.compiler.release property tells the compiler which Java version to target, and it must not be higher than your installed JDK. The spring.version property keeps the Spring version in one place. The single dependency, org.springframework:spring-context, brings in the container and, transitively, spring-core, spring-beans, spring-aop and spring-expression. You never list those individually.

Why Spring Boot changes the pom

In a Spring Boot project you do not write a Spring version at all. Instead the pom declares spring-boot-starter-parent as its parent, which manages compatible versions for hundreds of libraries, and you add starters such as spring-boot-starter-webmvc. In Spring Boot 4 the web starter is named spring-boot-starter-webmvc (older tutorials call it spring-boot-starter-web), and each starter has a matching -test starter for its tests.

Compile to confirm the setup

Once the files exist, run mvn compile (or ./mvnw compile if you copied a wrapper). The first run downloads Spring and Maven plugins, which can take a minute. A successful build ends with BUILD SUCCESS. If you see an error about the release version, your JDK is older than maven.compiler.release.

Examples

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.webnest</groupId>
    <artifactId>first-spring</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>7.0.9</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
</project>

plugins {
    java
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("org.springframework:spring-context:7.0.9")
}

Exercise

Using the lesson's A complete pom.xml for a plain Spring Framework 7.0 application (verified to build) example, create a small implementation or design sketch that demonstrates A plain Spring project needs a JDK, a build tool and the spring-context dependency.. Add a test case or scenario that would catch Putting Java files directly in the project root or in src/main instead of src/main/java, so the compiler ignores them., and describe the expected result.

Quick quiz

Interview questions