Loading Initial Data with Spring Boot

In this tutorial, we will learn how to load initial data into a Spring Boot application using various approaches. Initializing a database with data is often necessary for testing or for setting up a new application instance with default values.

We will cover the following methods:

1. Using data.sql and schema.sql files
2. Using Application Runner
3. Using Command Line Runner

Prerequisites

• JDK 17 or later
• Maven or Gradle
• IDE (IntelliJ IDEA, Eclipse, etc.)

Step 1: Set Up a Spring Boot Project

1.1 Create a New Spring Boot Project

Use Spring Initializr to create a new project with the following dependencies:

• Spring Web
• Spring Data JPA
• H2 Database

1.2 Configure application.properties

Set up the application properties for your project.

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=create-drop

Explanation:

• spring.datasource.url=jdbc:h2:mem:testdb: Configures an in-memory H2 database.
• spring.datasource.driverClassName=org.h2.Driver: Specifies the driver class.
• spring.datasource.username=sa: Sets the database username.
• spring.datasource.password=password: Sets the database password.
• spring.jpa.database-platform=org.hibernate.dialect.H2Dialect: Specifies the database platform.
• spring.h2.console.enabled=true: Enables the H2 database console.
• spring.jpa.hibernate.ddl-auto=create-drop: Creates and drops the database schema automatically.

Step 2: Define the Entity

Create a simple entity class for demonstration purposes.

package com.example.demo;

import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity
public class Product {

    @Id
    private Long id;
    private String name;
    private Double price;

    // Constructors
    public Product() {
    }

    public Product(Long id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

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

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}

Step 3: Load Initial Data Using data.sql and schema.sql Files

Spring Boot will automatically load schema.sql to create tables and data.sql to populate them with initial data.

3.1 Create schema.sql

Create a file named schema.sql in the src/main/resources directory.

CREATE TABLE product (
    id BIGINT PRIMARY KEY,
    name VARCHAR(255),
    price DOUBLE
);

3.2 Create data.sql

Create a file named data.sql in the src/main/resources directory.

INSERT INTO product (id, name, price) VALUES (1, 'Product 1', 10.0);
INSERT INTO product (id, name, price) VALUES (2, 'Product 2', 20.0);
INSERT INTO product (id, name, price) VALUES (3, 'Product 3', 30.0);

Step 4: Load Initial Data Using Application Runner

Application Runner is a functional interface used to run a block of code when the application starts.

4.1 Create Product Repository

Create a repository interface to manage Product entities.

package com.example.demo;

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

public interface ProductRepository extends JpaRepository<Product, Long> {
}

4.2 Create Data Loader with Application Runner

Create a data loader class that implements ApplicationRunner.

package com.example.demo;

import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DataLoader {

    @Bean
    ApplicationRunner init(ProductRepository repository) {
        return args -> {
            repository.save(new Product(4L, "Product 4", 40.0));
            repository.save(new Product(5L, "Product 5", 50.0));
            repository.save(new Product(6L, "Product 6", 60.0));
        };
    }
}

Step 5: Load Initial Data Using Command Line Runner

Command Line Runner is another functional interface that can be used to run code after the application context is loaded.

5.1 Create Data Loader with Command Line Runner

Create a data loader class that implements CommandLineRunner.

package com.example.demo;

import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CommandLineDataLoader {

    @Bean
    CommandLineRunner initDatabase(ProductRepository repository) {
        return args -> {
            repository.save(new Product(7L, "Product 7", 70.0));
            repository.save(new Product(8L, "Product 8", 80.0));
            repository.save(new Product(9L, "Product 9", 90.0));
        };
    }
}

Step 6: Testing the Application

6.1 Create a REST Controller

Create a REST controller to verify the data has been loaded.

package com.example.demo;

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

import java.util.List;

@RestController
public class ProductController {

    @Autowired
    private ProductRepository productRepository;

    @GetMapping("/products")
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }
}

6.2 Run the Application

Run the Spring Boot application and navigate to http://localhost:8080/products to see the loaded data.

Conclusion

You have successfully learned how to load initial data into a Spring Boot 3.2 application using different approaches. These methods are useful for setting up default values, populating test data, and ensuring that your application starts with the necessary data.