Spring Tutorial for Java Aspirants

Introduction

Getting started with the Spring Framework may be daunting for developers due to complex configuration and some initial “magic” involved with Dependency Injection. Beginners get confused by the learning curve involved and the core understanding required, like the IoC Container and all the annotations.

Our Spring tutorial for Java Aspirants breaks down these tough concepts into clear, practical examples that make enterprise Java development simple. Ready to master Spring Boot, Data, and MVC? Click here to view our complete Java Spring Course Syllabus!

Why Students or Freshers Learn Spring Boot?

Following are the reasons to learn Java Spring:

• Enterprise Standard: The Spring Framework, especially Spring Boot, is the undisputed standard for building scalable and production-ready backend services and APIs in large corporations across the world.
• High Market Demand: Java and Spring are the primary requirements for jobs such as Backend Developer, Full Stack Developer, and Enterprise Software Engineer. This enhances job opportunities with good remuneration.
• Microservices Architecture: Spring Boot makes the creation of microservices-which are modern architectural patterns for cloud-native applications-easier. This makes you relevant to modern cloud roles.
• Comprehensive Ecosystem: Spring has something to offer for everything, starting with data access, security, cloud deployment, and testing; providing a strong, full-stack backbone for back-end development.
• Portability and Scalability: Java is platform-independent and is very scalable, in terms of performance under high volume.

Ready to kickstart your career in the field of enterprise backend development? Download our essential Java Spring & Spring Boot Interview Questions and Answers!

Step-by-Step Spring Tutorial for Java Aspirants

Spring Boot is an evolution of the Spring framework, making it easier to create production-grade, stand-alone Spring applications. It cuts much of the boilerplate configuration; there are many sensible defaults and embedded servers. This tutorial will walk you through setting up your environment and building a simple RESTful Web Service-an API.

Part 1. Installation and Setup

Before delving into Spring, you have to prepare your machine for Java development.

Step 1. Install Java Development Kit (JDK)

• Requirement: Spring Boot 3.x typically requires Java 17 or later.
• Action: Download and install an appropriate JDK (such as Open JDK 21 or Oracle JDK 21).
• Verification: Open a terminal/command prompt and execute java -version. The output should validate your version currently installed.

Step 2. Installation of an Integrated Development Environment

While not strictly required, an integrated development environment such as IntelliJ IDEA Community/Ultimate or Eclipse with Spring Tools 4 or Visual Studio Code with Java extensions will simplify your development tasks substantially.

Step. 3: Create the project using Spring Initializr

Spring Initializr is the fastest way to bootstrap a new Spring Boot project with the proper structure and dependencies.

1. Go to start.spring.io.
2. Project Metadata:
   • Project: Select Maven or Gradle. Usually, Maven is easier for beginners.
   • Language: Choose Java.
   • Spring Boot: Choose the latest stable version. For example, 3.x.
   • Group: Use a unique identifier for your company or organization, for example, com.example.
   • Artifact: Name of your project, for example my-first-api.
   • Packaging: Choose Jar (default for web applications).
   • Java: Select the version you installed, such as 21.
3. Dependencies: Click “Add Dependencies” and search for the following:
   • Spring Web: Used for creating RESTful services with Spring MVC.
4. Click the Generate button. This downloads a .zip file.
5. Unzip the file and then import the project in your IDE.

Part 2. The Major App Parts (Model, Controller)

A common pattern for web applications, even simple APIs is the Model-View-Controller pattern. In API’s you are typically concerned with the Model (the data structure) and the Controller (the endpoint handler).

Step 4: Define the Application’s Data Model (The Model)

The Model is a simple Java class-a so-called POJO, which stands for Plain Old Java Object-representing the data we want to work with. Let’s create a simple Greeting class.

Create a new package (for instance com.example.myfirstapi.model) and add the Greeting.java class there:

package com.example.myfirstapi.model;

public class Greeting {

    private final long id;

    private final String content;

    public Greeting(long id, String content) {

        this.id = id;

        this.content = content;

    }

    public long getId() {

        return id;

    }

    public String getContent() {

        return content;

    }

}

Step 5: Create the Web Endpoint (The Controller)

The Controller class is mainly responsible for receiving an incoming HTTP request and returning a response. In Spring Boot, it is a simple class with the @RestController annotation.

Create a package, for example, com.example.myfirstapi.controller, and add the class GreetingController.java:

package com.example.myfirstapi.controller;

import com.example.myfirstapi.model.Greeting;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.atomic.AtomicLong;

@RestController

public class GreetingController {

    private static final String template = “Hello, %s!”;

    private final AtomicLong counter = new AtomicLong();

    // Maps HTTP GET requests to the “/greeting” path

    @GetMapping(“/greeting”)

    public Greeting greeting(@RequestParam(value = “name”, defaultValue = “World”) String name) {

        // @RequestParam binds the query parameter ‘name’ (if present) to the ‘name’ argument.

        // If not present, it defaults to “World”.

        return new Greeting(counter.incrementAndGet(), String.format(template, name));

    }

}

• @RestController: A convenience annotation that marks a class as a Controller where every method returns a Domain object instead of a view. It is shorthand for @Controller and @ResponseBody rolled together.
• @GetMapping(“/greeting”): Maps HTTP GET requests at the /greeting path to the greeting() method.
• @RequestParam: Maps the URL query parameter, e.g., ?name=User, to the method parameter.

Step 6: The Main Application Class

When you used Spring Initializr it created a main application class in the root package (for example MyFirstApiApplication.java).

package com.example.myfirstapi;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class MyFirstApiApplication {

    public static void main(String[] args) {

        SpringApplication.run(MyFirstApiApplication.class, args);

    }

}

• @SpringBootApplication: This is the most important annotation. It encapsulates three key annotations:
  • @Configuration: Tags this class as a source of bean definitions for the application context.
  • @EnableAutoConfiguration: Tells Spring Boot to “guess” and configure beans based on classpath contents; for example, sees spring-web and automatically configures Tomcat and Spring MVC.
  • @ComponentScan: Tells Spring to scan the current package and sub-packages for other components, configurations, and services.
• SpringApplication.run(.): This is a static method that initiates a Spring Boot application, builds an instance of an Application Context, and starts up an embedded web server (Tomcat by default).

Part 3. Running and Testing the Application

Step 7: Run the Application

You can run the application directly from your IDE by right-clicking the MyFirstApiApplication.java file and selecting “Run.“

Alternatively, from the command line in the root directory of the project:

• Maven: ./mvnw spring-boot:run (Linux/macOS) or mvnw spring-boot:run (Windows)
• Gradle: ./gradlew bootRun

Your console output should show the embedded Tomcat server starting up on port 8080.

… Tomcat started on port(s): 8080 (http) with context path ‘’

Step 8: Test the API

Open any web browser or any API testing tool like Postman or cURL, and try accessing the following URLs:

Default Request (No Parameter):

• URL: http://localhost:8080/greeting
• Expected Output (JSON): {“id”:1,”content”:”Hello, World!”}

Request with Parameter:

• URL: http://localhost:8080/greeting?name=Beginner
• Expected Output (JSON): {“id”:2,”content”:”Hello, Beginner!”}

Part 4. Advanced Structure (Service Layer)

For larger real-world applications, it’s a good practice to keep the business logic separate from the Controller. This is accomplished by using a Service Layer.

Step 9: Create the Service Component (Business Logic)

The Service class should contain the actual business logic, so that the Controller can stay clean and focused on handling HTTP requests.

Create a new package, for example, com.example.myfirstapi.service, and add the GreetingService.java class:

package com.example.myfirstapi.service;

import com.example.myfirstapi.model.Greeting;

import org.springframework.stereotype.Service;

import java.util.concurrent.atomic.AtomicLong;

@Service

public class GreetingService {

    private static final String template = “Welcome to Spring, %s!”;

    private final AtomicLong counter = new AtomicLong();

    public Greeting generateGreeting(String name) {

        // This is where complex logic/database calls would normally go.

        return new Greeting(counter.incrementAndGet(), String.format(template, name));

    }

}

• @Service: A specialized form of @Component, this marks the class as containing business logic. Spring’s component scanning will find this class and register it as a Spring Bean.

Step 10: Inject the Service into the Controller

We refactor the Controller to utilize the new Service layer using one of the key Spring concepts: Dependency Injection (DI).

Update GreetingController.java:

package com.example.myfirstapi.controller;

import com.example.myfirstapi.model.Greeting;

import com.example.myfirstapi.service.GreetingService; // Import the service

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.RestController;

@RestController

public class GreetingController {

    private final GreetingService greetingService; // Declare the service

    // Constructor Injection: Spring automatically provides the GreetingService instance

    public GreetingController(GreetingService greetingService) {

        this.greetingService = greetingService;

    }

    @GetMapping(“/greeting”)

    public Greeting greeting(@RequestParam(value = “name”, defaultValue = “World”) String name) {

        // Delegate the business logic to the Service layer

        return greetingService.generateGreeting(name);

    }

}

• Constructor Injection: By defining a constructor that takes the GreetingService as an argument, we tell Spring, “When you create this GreetingController object, please inject an instance of GreetingService for me.” This is Spring’s IoC Container at work.

Now you can re-run the application and test again. The logic is separated properly this time out, making your application more modular and easier to maintain.

Facing challenges with database integration, security setup, or complex dependency management? Click here to view our Java Spring Challenges and Solutions for Beginners!

Real Time Examples for Spring Tutorial for Learners

Examples of some practical, real-world project ideas utilizing the Java Spring Framework to address common industry needs and solidify foundational concepts include the following:

E-commerce Product Catalog Service (Spring Boot & Spring Data JPA)

• Objective Create a backend API for managing product information, namely, name, description, price, and inventory.
• Spring Concepts Learned:
  • RESTful API Development: @RestController and @RequestMapping annotations for creating GET, POST, PUT, and DELETE endpoints.
  • Persistence: Using Spring Data JPA to interact with a database, such as H2 for development or PostgreSQL for production, to perform common operations such as CRUD.
  • Service Layer: Separating business logic, such as inventory checks, from the controller.
• Real-World Application: The core of any modern retail application or marketplace.

Simple User Authentication Service (Spring Security)

• Objective: Create a service responsible for registering users, logging them in, and protecting access to certain API endpoints.
• Spring Concepts Learned: 
  • Spring Security: Configure basic in-memory or database-backed authentication. 
  • Password Encoding: It securely stores user credentials using the PasswordEncoder bean, such as BCrypt. 
  • Access Control: Using different annotations, such as @PreAuthorize, to allow roles – ADMIN or USER-to access certain resources. 
• Real-World Application: Necessary to secure any modern web application, microservice, or API gateway. 

Asynchronous Notification Queue (Spring Boot & JMS/RabbitMQ)

• Objective: Create a system that, on a user action, like buying something, would asynchronously create an event, such as sending an email with confirmation. 
• Spring Concepts Learned: 
  • Messaging: The integration of Spring Boot with a message broker, for example RabbitMQ; using JMS is also possible. 
  • @EnableJms/@RabbitListener: To create message producers and message consumers that enable reliable decoupling of services and execution of background jobs.
  • Dependency Management: In pom.xml or build.gradle, add the necessary messaging libraries. 
• Real-World Application: This is one of the widest usages for data processing in bulk, sending notifications, or performing delayed tasks without blocking the main application flow. 

Ready to apply these concepts to your own portfolio? Click here for a list of detailed Java Spring Project Ideas along with setup guides!

FAQs About Java Spring Boot Tutorial for Beginners

Conclusion

You now know how to start designing Controllers, the importance of the Service Layer for business logic, and how Dependency Injection can help in simplifying the application architecture. That foundation is important to creating robust, scalable applications. Ready to deep-dive into database integration, security, and advanced Spring patterns?

Enroll in our Advanced Java Spring Boot Professional Course in Chennai to master microservices and secure, production-ready enterprise systems!