# Spring Boot Made Easy: Beginner's Quick Start Guide

# **Introduction**

Welcome to our quick start guide on **Spring Boot Simplified for Beginners**! Whether you're a seasoned Java developer or just starting, Spring Boot makes building robust applications a breeze. In this guide, we’ll break down everything you need to know to get your first Spring Boot application up and running.

## **What is Spring Boot?**

Spring Boot is an open-source Java-based framework used to create stand-alone, production-grade Spring-based applications quickly and with minimal configuration. It simplifies the process of building applications by providing a suite of tools and libraries that help streamline development.

## **Why Use Spring Boot?**

Spring Boot removes much of the boilerplate configuration required by Spring, allowing you to focus more on developing features and less on setup. It offers a wide range of features, including embedded servers, simplified dependency management, and production-ready metrics.

## **Setting Up Your Development Environment**

### **Installing Java Development Kit (JDK)**

To develop with Spring Boot, you need to have the JDK installed on your machine. Download and install the latest version from the [Oracle JDK](https://www.oracle.com/java/technologies/javase-downloads.html) website.

### **Setting Up an Integrated Development Environment (IDE)**

An IDE helps streamline coding by providing tools and features like code completion, debugging, and version control integration. Eclipse, IntelliJ IDEA, and VS Code are the most popular IDE used by developers for Java. Download and install your preferred IDE.

### **Installing Spring Boot CLI**

Spring Boot CLI is a command-line tool that helps you develop Spring Boot applications. It can be installed via SDKMAN! or manually downloaded from the [Spring Boot website](https://spring.io/tools). Use the following command to install via SDKMAN!:

```bash
sdk install springboot
```

## **Creating Your First Spring Boot Application**

### **Initializing a Project with Spring Initializr**

Spring Initializr is an online tool that helps generate a Spring Boot project structure. Visit [Spring Initializr](https://start.spring.io/), select the desired project options (like dependencies, project name, and packaging), and generate the project. Download the zip file and extract it. Below is the screenshot with very basic Spring web and few database related dependencies required to build REST APIs

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723120798627/2a0235cd-5dd6-4e9e-9fc7-ac4d81265d51.png align="center")

### **Understanding the Project Structure**

The basic Spring boot project structure is similar to the Maven project structure if you are using Maven as a build tool. You can read more about Maven and its project structure [here](https://aneeshthetechmaestro.hashnode.dev/understanding-maven-kickstart-your-journey-to-efficient-project-management). You can see compilation errors in your IDE but if you wait for some time, all dependencies will be downloaded and errors will be gone The generated project structure includes several key components:

* **src/main/java:** Contains your Java source files. It contains the starter class 'SpringDemoApplication' which is the entry point of the application
    
* **src/main/resources:** Contains application properties and static resources.
    
* **pom.xml or build.gradle:** Manages your project's dependencies. Since I selected Maven as option so pom.xml is generated
    
    ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723119964555/01b4716e-aaa3-4520-a74d-347c74397e78.png align="center")
    

## **Spring Boot Annotations**

Annotations in Java are metadata that provide information about the code. They do not directly affect the execution of the code but help in understanding and managing it. Consider annotations as signposts that guide the Spring framework in handling various components and configurations.

Annotation itself is a big topic and you can read more about annotation here

Below are a few annotations to create a REST web service application

**@SpringBootApplication**

This annotation is a single annotation that packages below mentioned annotation. This is the annotation on the starter class 'SpringDemoApplication'

* @Configuration: This annotation tells the spring to make a class as the candidate of bean definitions.
    
* @EnableAutoConfiguration: Enables Spring Boot's auto-configuration mechanism.
    
* @ComponentScan: This annotation tells the spring the starting point for the bean scanning.
    

**@RestController**

This annotation marks the class as a RESTful web service controller. It combines @Controller and @ResponseBody, simplifying the creation of RESTful web services.

**@RequestMapping**

This annotation maps the request handler method to the incoming web request. @Request mapping can be set either to class level or any method level.

## **Building a Simple REST API**

### **Creating a Controller**

Create a new Java class annotated with @RestController in your project’s source directory(i.e src/main/java). This annotation will be available as part of Spring web dependency.

```java
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}
```

### **Defining Endpoints**

Endpoints are defined using **@RequestMapping** or more specific annotations like **@GetMapping**, **@PostMapping**, etc. The example above defines a simple **/hello** endpoint.

### **Testing the API with Postman**

Run the starter class 'SpringDemoApplication' as shown below

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723120460128/ce4d680f-0296-44a3-b56e-5444e6e85f51.png align="center")

Once application is up and running,

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723120604669/e89f457b-d0e4-4db5-ba7f-6ab2adff58e0.png align="center")

Download and install [Postman](https://www.postman.com/downloads/), a [popula](https://www.postman.com/downloads/)r tool for testing APIs. Open Postman, enter the endpoint URL (e.g., [http://localhost:8080/hello](http://localhost:8080/hello)), and send a GET request to see the response.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723120657453/81150863-c433-4cde-8dc6-4867c56cdb62.png align="center")

## **Connecting to a Database**

### **Setting Up a Database**

You can use any relational database like MySQL, PostgreSQL, or H2. For this example, we’ll use H2, an in-memory database that doesn’t require any software installation. Spring boot creates automatically this database in the application memory

### **Configuring Spring Boot for Database Access**

Add the necessary database dependencies to your pom.xml if not added during project creation

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723121060322/6812990a-f104-45b3-9d7c-b679cd73e861.png align="center")

```xml
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
	<groupId>com.h2database</groupId>
	<artifactId>h2</artifactId>
	<scope>runtime</scope>
</dependency>
```

### **Creating a Entity Class**

This class models the database table

```java
package com.aneesh.spring_demo;


import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String firstName;
    private String lastName;

    // Constructors
    public User() {}

    public User(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    // toString method
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                '}';
    }
}
```

### **Creating a Repository**

Create a repository interface that extends JpaRepository. This will provide CRUD operations for your entity.

```java
package com.aneesh.spring_demo;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}
```

This interface will provide basic CRUD operations on User

### Updating Controller class

update the controller class to call this repository and return list of User

```java
package com.aneesh.spring_demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class HelloController {
    @Autowired
    UserRepository userRepository;
    @RequestMapping("/hello")
    public List<User> hello() {
       List<User> users= userRepository.findAll();
        return users;
    }
}
```

### **Managing Application Properties**

Till now we have created all the required classes but we haven't provided details of our h2 database. This can be done easily by adding some properties in application. properties

```yaml
spring.application.name=Spring Demo
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto= update

spring.h2.console.enabled=true
```

### Inserting data to h2 DB

We can insert rows into DB 2 ways

1. Create a file named data.sql inside resources folder and run the application. Application will automatically insert the data
    
2. Log into the h2 console from browser( http://localhost:8080/h2-console) after running the application
    

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723126510911/3d12c930-16aa-4aa7-a7da-0ad4460f9c97.png align="center")

Now call the APAI from postman to see the results

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723126669616/0d0b4658-a7d5-4e42-afb9-12bda2e01553.png align="center")

## **Spring Boot Starters**

### **What Are Spring Boot Starters?**

Starters are dependency descriptors that simplify adding jars to your project. For example, spring-boot-starter-web includes all dependencies needed to build a web application.

**Commonly Used Starters**

* spring-boot-starter-web: For building web applications.
    
* spring-boot-starter-data-jpa: For JPA and Hibernate.
    
* spring-boot-starter-security: For Spring Security.
    

## **Spring Boot DevTools**

### **Enabling DevTools**

Add the DevTools dependency to your project for features like automatic restarts and live reloads.

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>
```

### **Benefits of Using DevTools**

DevTools enhances the development experience by providing rapid feedback during code changes without requiring a full application restart.

## **Spring Boot Actuator**

### **Introduction to Spring Boot Actuator**

Spring Boot Actuator provides production-ready features like monitoring and metrics gathering. Add the dependency to your project:

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
```

### **Monitoring and Managing Your Application**

Actuator provides several endpoints (e.g., /actuator/health, /actuator/metrics) to monitor your application's health and metrics.

## **Handling Exceptions**

### **Creating Custom Exception Classes**

Define custom exception classes to handle specific errors.

```java
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}
```

### **Implementing Global Exception Handling**

To implement a global-level exception handler. Use @ ControllerAdvice annotation on the class level

```java
@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<String> handleResourceNotFoundException(ResourceNotFoundException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
    }
}
```

## **Securing Your Application**

### **Introduction to Spring Security**

Spring Security is the feature in the Spring framework that provides security to the exposed resources in the application. Add the Spring Security starter to your project:

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
```

### **Basic Authentication and Authorization**

Configure basic authentication by extending WebSecurityConfigurerAdapter

```java
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        http.authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .httpBasic();
    }
}
```

## **Deploying Your Spring Boot Application**

### **Packaging the Application**

Build tools like Maven or Gradle can be used to package your application into a jar. To learn more about Maven, please have a look at this [post](https://aneeshthetechmaestro.hashnode.dev/understanding-maven-kickstart-your-journey-to-efficient-project-management).

```bash
mvn clean package
```

### **Deploying to a Web Server**

Deploy the JAR file to any web server like Apache Tomcat by placing it in the web server’s webapps directory.

### **Deploying to the Cloud**

Deploy your Spring Boot application to cloud platforms like AWS, Azure, or Google Cloud using their respective services and tools.

## **Spring Boot Best Practices**

### **Code Organization**

Organize your code into packages based on functionality (e.g., controller, service, repository) for better maintainability.

### **Performance Optimization**

Optimize performance by using caching, database connection pooling, and efficient querying.

### **Testing Strategies**

Implement unit tests, integration tests, and end-to-end tests to ensure your application works as expected.

## **Conclusion**

Congratulations! You've now got a basic understanding of how to set up and develop with Spring Boot. From setting up your development environment to building and deploying your first application, you’ve learned the essential steps to get started. Spring Boot simplifies the development process, allowing you to focus on building features and delivering value to your users.

## **FAQs**

1. **What is Spring Boot used for?** Spring Boot is used to create stand-alone, production-grade Spring-based applications quickly and with minimal configuration.
    
2. **How do I install Spring Boot?** You can install Spring Boot CLI via SDKMAN! or manually download it from the Spring Boot website.
    
3. **What is the advantage of using Spring Boot?** Spring Boot simplifies the configuration and setup of Spring applications, reducing development time and effort.
    
4. **Can I use Spring Boot with other databases?** Yes, Spring Boot supports various databases like MySQL, PostgreSQL, MongoDB, and more.
    
5. **Is Spring Boot suitable for beginners?** Absolutely! Spring Boot is designed to simplify the development process, making it an excellent choice for beginners.
    

## **Happy coding with Spring Boot! I hope this guide helps you embark on your spring boot learning journey**