Spring Boot 2 Hibernate 5 MySQL CRUD REST API Tutorial

In this tutorial, we will learn how to develop CRUD RESTFul API using Spring boot 2, Hibernate 5, JPA, Maven, and MySQL database.

We will learn end to end RESTFul API development, an overview of Spring Boot features, Exception Handling, JPA Auditing, JUnit testing, testing using Postman Client, etc.


This tutorial is explained in the below Youtube Video:
Subscribe to my youtube channel here at Java Guides - YouTube Channel

Table of Contents

  1. What we’ll build
  2. Tools and Technologies Used
  3. Creating and Importing a Project
  4. Packaging Structure
  5. Configuring MySQL Database
  6. Create a JPA Entity called User.java
  7. Create Spring Data JPA Repository - UserRepository.java
  8. Exception(Error) Handling for RESTful Services
  9. Creating UserController(Contains REST APIs)
  10. Running the Application
  11. Unit Testing REST APIs
  12. Test Using Postman Client
  13. Source Code on Github

1. What we’ll build

We are building a simple User Management Application which has below CRUD Rest APIs.
Following five REST APIs (Controller handler methods) are created for User resource.
Spring Boot 2 Hibernate 5 MySQL CRUD REST API Tutorial

2. Tools and Technologies Used

  • Spring Boot - 2.0.4.RELEASE
  • JDK - 1.8 or later
  • Spring Framework - 5.0.8 RELEASE
  • Hibernate - 5.2.17.Final
  • Maven - 3.2+
  • Spring Data JPA - 2.0.10 RELEASE
  • IDE - Eclipse or Spring Tool Suite (STS)
  • MYSQL - 5.1.47
Note that we have used all the latest versions of all technologies.

3. Creating and Importing a Project

There are many ways to create a Spring Boot application. The simplest way is to use Spring Initializr at http://start.spring.io/, which is an online Spring Boot application generator.
Look at the above diagram, we have specified following details:
  • Generate: Maven Project
  • Java Version: 1.8 (Default)
  • Spring Boot:2.0.4
  • Group: com.companyname
  • Artifact: springbootcrudrest
  • Name: springbootcrudrest
  • Description: Rest API for a Simple User Management Application
  • Package Name : com.companyname.springbootcrudrest
  • Packaging: jar (This is the default value)
  • Dependencies: Web, JPA, MySQL, DevTools
Once, all the details are entered, click on Generate Project button will generate a spring boot project and downloads it. Next, Unzip the downloaded zip file and import it into your favorite IDE.

4. Packaging Structure

Following is the packing structure of our User Management Application -
Let’s understand the details of some of the important files and packages -
  1. pom.xml
  2. resources
  3. SpringBootCrudRestApplication.java
  4. SpringBootCrudRestApplicationTests.java

The 4.1. pom.xml File

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">


    <description>Demo project for Spring Boot</description>

        <relativePath/> <!-- lookup parent from repository -->





From above pom.xml, let's understand few important spring boot features.

Spring Boot Maven plugin

The Spring Boot Maven plugin provides many convenient features:
  • It collects all the jars on the classpath and builds a single, runnable "├╝ber-jar", which makes it more convenient to execute and transport your service.
  • It searches for the public static void main() method to flag as a runnable class.
  • It provides a built-in dependency resolver that sets the version number to match Spring Boot dependencies. You can override any version you wish, but it will default to Boot’s chosen set of versions.


All Spring Boot projects typically use spring-boot-starter-parent as the parent in pom.xml.
The spring-boot-starter-parent  allow you to manage the following things for multiple child projects and modules:
  • Configuration - Java Version and Other Properties
  • Dependency Management - Version of dependencies
  • Default Plugin Configuration

Easy Dependency Management(Spring boot magic)

We added the spring-boot-starter-web dependency, it will by default pull all the commonly used libraries while developing Spring MVC applications, such as spring-webmvc, jackson-json, validation-api, and Tomcat.
We added the spring-boot-starter-data-jpa dependency. This pulls all the spring-data-jpa dependencies and adds Hibernate libraries because most applications use Hibernate as a JPA implementation.

Autoconfiguration(Spring boot magic)

Not only does the spring-boot-starter-web add all these libraries but it also configures the commonly registered beans like DispatcherServlet, ResourceHandlers, MessageSource, etc. with sensible defaults.
We haven’t defined any of the DataSource, EntityManagerFactory, or TransactionManager beans, but they are automatically created. How? If you have any in-memory database drivers like H2 or HSQL in the classpath, then Spring Boot will automatically create an in-memory data source and will register the EntityManagerFactory and TransactionManager beans automatically with sensible defaults. But you are using MySQL, so you need to explicitly provide MySQL connection details. 
You have configured those MySQL connection details in the application.properties file and Spring Boot creates a DataSource using those properties.

Embedded Servlet Container Support(Spring boot feature)

We added spring-boot-starter-web, which pulls spring-boot-starter-tomcat automatically. When we run the main() method, it starts tomcat as an embedded container so that we don’t have to deploy our application on any externally installed tomcat server. 

What if we want to use a Jetty server instead of Tomcat? You simply exclude spring-boot-starter-tomcat from spring-boot-starter-web and include spring-boot- starter-jetty. That’s it.

4.2. resources/

This directory, as the name suggests, is dedicated to all the static resources, templates and property files.
  • resources/static - contains static resources such as CSS, js, and images.
  • resources/templates - contains server-side templates which are rendered by Spring.
  • resources/application.properties - This file is very important. It contains application-wide properties. Spring reads the properties defined in this file to configure your application. You can define a server’s default port, server’s context path, database URLs etc, in this file.

4.3. SpringBootCrudRestApplication.java

This spring boot application has an entry point Java class called SpringBootCrudRestApplication.java with the public static void main(String[] args) method, which you can run to start the application.
import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

public class SpringBootCrudRestApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootCrudRestApplication.class, args);
@SpringBootApplication is a convenience annotation that adds all of the following:
  • @Configuration tags the class as a source of bean definitions for the application context.
  • @EnableAutoConfiguration tells Spring Boot to start adding beans based on classpath settings, other beans, and various property settings.
  • Normally you would add @EnableWebMvc for a Spring MVC app, but Spring Boot adds it automatically when it sees spring-webmvc on the classpath. This flags the application as a web application and activates key behaviors such as setting up a DispatcherServlet.
  • @ComponentScan tells Spring to look for other components, configurations, and services in the hello package, allowing it to find the controllers.
The main() method uses Spring Boot’s SpringApplication.run() method to launch an application. Did you notice that there wasn’t a single line of XML? No web.xml file either. This web application is 100% pure Java and you didn’t have to deal with configuring any plumbing or infrastructure.

5. Configuring MySQL Database

Since we’re using MySQL as our database, we need to configure the database URL, username, and password so that Spring can establish a connection with the database on startup. Open src/main/resources/application.properties file and add the following properties to it -
spring.datasource.url = jdbc:mysql://localhost:3306/users_database?useSSL=false
spring.datasource.username = root
spring.datasource.password = root

## Hibernate Properties
# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect

# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto = update
Don’t forget to change the spring.datasource.username and spring.datasource.password as per your MySQL installation. Also, create a database named users_database in MySQL before proceeding to the next section.

You don’t need to create any tables. The tables will automatically be created by hibernate from the User entity that we will define in next step. This is made possible by the property spring.jpa.hibernate.ddl-auto = update.

6. Create a JPA Entity called User.java

Let's create User model or domain class with following fields:
  • id - primary key
  • firstName - user first name
  • lastName - user last name
  • emailId - user email ID
  • createdAt - user object created date
  • createdBy - use object created by
  • updatedAt - user object updated by
  • updatedby - user object updated by
package com.companyname.springbootcrudrest.model;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EntityListeners;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

@Table(name = "users")
public class User {

    private long id;
    private String firstName;
    private String lastName;
    private String emailId;
    private Date createdAt;
    private String createdBy;
    private Date updatedAt;
    private String updatedby;
    @GeneratedValue(strategy = GenerationType.AUTO)
    public long getId() {
        return id;
    public void setId(long id) {
        this.id = id;
    @Column(name = "first_name", nullable = false)
    public String getFirstName() {
        return firstName;
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    @Column(name = "last_name", nullable = false)
    public String getLastName() {
        return lastName;
    public void setLastName(String lastName) {
        this.lastName = lastName;
    @Column(name = "email_address", nullable = false)
    public String getEmailId() {
        return emailId;
    public void setEmailId(String emailId) {
        this.emailId = emailId;
    @Column(name = "created_at", nullable = false)
    public Date getCreatedAt() {
        return createdAt;
    public void setCreatedAt(Date createdAt) {
       this.createdAt = createdAt;
    @Column(name = "created_by", nullable = false)
    public String getCreatedBy() {
        return createdBy;
    public void setCreatedBy(String createdBy) {
        this.createdBy = createdBy;
    @Column(name = "updated_at", nullable = false)
    public Date getUpdatedAt() {
        return updatedAt;
    public void setUpdatedAt(Date updatedAt) {
        this.updatedAt = updatedAt;
    @Column(name = "updated_by", nullable = false)
    public String getUpdatedby() {
        return updatedby;
    public void setUpdatedby(String updatedby) {
       this.updatedby = updatedby;

All your domain models must be annotated with @Entity annotation. It is used to mark the class as a persistent Java class.

@Table annotation is used to provide the details of the table that this entity will be mapped to.

@Id annotation is used to define the primary key.

@GeneratedValue annotation is used to define the primary key generation strategy. In the above case, we have declared the primary key to be an Auto Increment field.

@Column annotation is used to define the properties of the column that will be mapped to the annotated field. You can define several properties like name, length, nullable, updateable etc.

6.1 How to enable JPA Auditing

Let's understand important JPA Auditing annotations:
  1. @CreatedDate - Declares a field as the one representing the date the entity containing the field was created.
  2. @LastModifiedDate - Declares a field as the one representing the date the entity containing the field was recently modified.
  3. @CreatedBy- Declares a field as the one representing the principal that created the entity containing the field.
  4. @LastModifiedBy - Declares a field as the one representing the principal that recently modified the entity containing the field.
Now, what we want is that these fields should automatically get populated whenever we create or update an entity.
To achieve this, we need to do two things -
  1. Add Spring Data JPA’s AuditingEntityListener to the domain model.
We have already done this in our User model with the annotation @EntityListeners(AuditingEntityListener.class).
@Table(name = "users")
public class User {
 // rest of the code here
  1. Enable JPA Auditing in the main application.
Open SpringBootCrudRestApplication.java and add a @EnableJpaAuditing annotation.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;

public class SpringBootCrudRestApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootCrudRestApplication.class, args);
So far we have created a User model and enabled JPA auditing on it. Next, we need to create a repository to access user records to and from a database.

7. Create Spring Data JPA Repository - UserRepository.java

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

import com.companyname.springbootcrudrest.model.User;

public interface UserRepository extends JpaRepository<User, Long>{

Note that, we have annotated the interface with @Repository annotation. This tells Spring to bootstrap the repository during a component scan.
In the above code, UserRepository interface extends JpaRepository which provides below methods to deal with database operations:
List<T> findAll();
List<T> findAll(Sort sort);
List<T> findAllById(Iterable<ID> ids);
<S extends T> List<S> saveAll(Iterable<S> entities);
void flush();
<S extends T> S saveAndFlush(S entity);
void deleteInBatch(Iterable<T> entities);
void deleteAllInBatch();
T getOne(ID id);
<S extends T> List<S> findAll(Example<S> example);
<S extends T> List<S> findAll(Example<S> example, Sort sort);

8. Exception(Error) Handling for RESTful Services

Spring Boot provides a good default implementation for exception handling for RESTful Services. Let’s quickly look at the default Exception Handling features provided by Spring Boot.

Resource Not Present

Heres what happens when you fire a request to not resource found: http://localhost:8080/some-dummy-url
  "timestamp": 1512713804164,
  "status": 404,
  "error": "Not Found",
  "message": "No message available",
  "path": "/some-dummy-url"
That's a cool error response. It contains all the details that are typically needed.

What happens when we throw an Exception?

Let’s see what Spring Boot does when an exception is thrown from a Resource. we can specify the Response Status for a specific exception along with the definition of the Exception with ‘@ResponseStatus’ annotation.
Lets create a ResourceNotFoundException.java class.
package com.companyname.springbootcrudrest.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends Exception{

    private static final long serialVersionUID = 1L;

    public ResourceNotFoundException(String message){

Customizing Error Response Structure

Default error response provided by Spring Boot contains all the details that are typically needed.
However, you might want to create a framework independent response structure for your organization. In that case, you can define a specific error response structure.
Let’s define a simple error response bean.
package com.companyname.springbootcrudrest.exception;

import java.util.Date;

public class ErrorDetails {
    private Date timestamp;
    private String message;
    private String details;

    public ErrorDetails(Date timestamp, String message, String details) {
        this.timestamp = timestamp;
        this.message = message;
        this.details = details;

    public Date getTimestamp() {
        return timestamp;

    public String getMessage() {
        return message;

    public String getDetails() {
        return details;
To use ErrorDetails to return the error response, let’s create a GlobalExceptionHandler class annotated with @ControllerAdvice annotation. This class handles exception specific and global exception in a single place.
package com.companyname.springbootcrudrest.exception;

import java.util.Date;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;

public class GlobalExceptionHandler {
    public ResponseEntity<?> resourceNotFoundException(ResourceNotFoundException ex, WebRequest request) {
    ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false));
        return new ResponseEntity<>(errorDetails, HttpStatus.NOT_FOUND);

    public ResponseEntity<?> globleExcpetionHandler(Exception ex, WebRequest request) {
        ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false));
        return new ResponseEntity<>(errorDetails, HttpStatus.INTERNAL_SERVER_ERROR);

9. Creating UserController(Contains REST APIs)

Now, it's time to create CRUD Rest APIs for User model.
package com.companyname.springbootcrudrest.controller;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.companyname.springbootcrudrest.exception.ResourceNotFoundException;
import com.companyname.springbootcrudrest.model.User;
import com.companyname.springbootcrudrest.repository.UserRepository;

public class UserController {
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();

    public ResponseEntity<User> getUserById(
    @PathVariable(value = "id") Long userId) throws ResourceNotFoundException {
        User user = userRepository.findById(userId)
        .orElseThrow(() -> new ResourceNotFoundException("User not found on :: "+ userId));
        return ResponseEntity.ok().body(user);

    public User createUser(@Valid @RequestBody User user) {
        return userRepository.save(user);

    public ResponseEntity<User> updateUser(
    @PathVariable(value = "id") Long userId,
    @Valid @RequestBody User userDetails) throws ResourceNotFoundException {
         User user = userRepository.findById(userId)
          .orElseThrow(() -> new ResourceNotFoundException("User not found on :: "+ userId));
        user.setUpdatedAt(new Date());
        final User updatedUser = userRepository.save(user);
        return ResponseEntity.ok(updatedUser);

   public Map<String, Boolean> deleteUser(
       @PathVariable(value = "id") Long userId) throws Exception {
       User user = userRepository.findById(userId)
          .orElseThrow(() -> new ResourceNotFoundException("User not found on :: "+ userId));

       Map<String, Boolean> response = new HashMap<>();
       response.put("deleted", Boolean.TRUE);
       return response;
Let's understand all the annotations used in the UserController
@RequestMapping("/api/v1") - annotation declares that the url for all the apis in this controller will start with /api/v1
@RestController - annotation is a combination of Spring’s @Controller and @ResponseBody annotations.
@GetMapping("/users") - annotation is a short form of @RequestMapping(value="/users", method=RequestMethod.GET).
@GetMapping("/users/{id}") - annotation is a short form of @RequestMapping(value="/users/{id}", method=RequestMethod.GET).
@PostMapping("/users") - annotation is a short form of @RequestMapping(value="/users", method=RequestMethod.POST).
@PutMapping("/users/{id}") - annotation is a short form of @RequestMapping(value="/users/{id}", method=RequestMethod.PUT).
@DeleteMapping("/user/{id}") - annotation is a short form of @RequestMapping(value="/users/{id}", method=RequestMethod.DELETE).

@PathVariable - annotation is used to bind a path variable with a method parameter.

10. Running the Application

We have successfully developed all the CRUD Rest APIs for User model. now it's time to deploy our application in a servlet container(embedded tomcat). Two ways we can start the standalone Spring boot application.
  1. From the root directory of the application and type the following command to run it -
$ mvn spring-boot:run
  1. From your IDE, run the SpringBootCrudRestApplication.main() method as a standalone Java class that will start the embedded Tomcat server on port 8080 and point the browser to http://localhost:8080/.

11.Unit Testing REST APIs

Let's write a JUnit test cases for all Rest APIs of User entity.
package com.companyname.projectname.springbootcrudrest;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.HttpClientErrorException;

import com.companyname.springbootcrudrest.SpringBootCrudRestApplication;
import com.companyname.springbootcrudrest.model.User;

@SpringBootTest(classes = SpringBootCrudRestApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class SpringBootCrudRestApplicationTests {

    private TestRestTemplate restTemplate;

    private int port;

    private String getRootUrl() {
        return "http://localhost:" + port;

    public void contextLoads() {


    public void testGetAllUsers() {
         HttpHeaders headers = new HttpHeaders();
         HttpEntity<String> entity = new HttpEntity<String>(null, headers);

         ResponseEntity<String> response = restTemplate.exchange(getRootUrl() + "/users",
         HttpMethod.GET, entity, String.class);

    public void testGetUserById() {
        User user = restTemplate.getForObject(getRootUrl() + "/users/1", User.class);

    public void testCreateUser() {
        User user = new User();

        ResponseEntity<User> postResponse = restTemplate.postForEntity(getRootUrl() + "/users", user, User.class);

    public void testUpdatePost() {
         int id = 1;
         User user = restTemplate.getForObject(getRootUrl() + "/users/" + id, User.class);

         restTemplate.put(getRootUrl() + "/users/" + id, user);

         User updatedUser = restTemplate.getForObject(getRootUrl() + "/users/" + id, User.class);

    public void testDeletePost() {
         int id = 2;
         User user = restTemplate.getForObject(getRootUrl() + "/users/" + id, User.class);

         restTemplate.delete(getRootUrl() + "/users/" + id);
         try {
              user = restTemplate.getForObject(getRootUrl() + "/users/" + id, User.class);
         } catch (final HttpClientErrorException e) {
         assertEquals(e.getStatusCode(), HttpStatus.NOT_FOUND);

@SpringBootTest(classes = SpringBootCrudRestApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) : Launch the entire Spring Boot Application on a Random Port.


From above Spring Boot application development let's list out advantages of using Spring boot.

  • Simpler dependency management
  • Default auto-configuration
  • Embedded web server
  • Application metrics and health checks
  • Advanced externalized configuration

12. Test Using Postman Client

1. Create User REST API

Request JSON:
    "firstName": "Ramesh",
    "lastName": "fadatare",
    "emailId": "ramesh@gmail.com",
    "createdBy": "Ramesh",
    "updatedby": "Ramesh"

2. Get User by ID REST API

HTTP Method: GET
Request URLhttp://localhost:8080/api/v1/users/2

3. Get all users REST API

HTTP Method: GET
Request URLhttp://localhost:8080/api/v1/users

4. Update User REST API

HTTP Method: GET 
Request JSON:
    "firstName": "Ram",
    "lastName": "Jadhav",
    "emailId": "ramesh123@gmail.com",
    "createdBy": "Ramesh",
    "updatedby": "Ramesh"

5. Delete User REST API


12. Source code on GitHub

The source code of this tutorial is available on my GitHub Repository.

Get source code of this tutorial on my GitHub Repository.

Free Spring Boot Tutorial | Full In-depth Course | Learn Spring Boot in 10 Hours

Watch this course on YouTube at Spring Boot Tutorial | Fee 10 Hours Full Course


  1. I ran this project in IntelliJ and it is giving me following error:

    Error:(16, 43) java: diamond operator is not supported in -source 1.5
    (use -source 7 or higher to enable diamond operator)

    How do I change this?

    Thank you very much.

  2. You should change jdk 1.5 to 1.8. Google it how to configure jdk 1.8 in intellij.

  3. here table will be auto created or not?

  4. Yes, tables will be automatically created as you can see the ddl-auto configuration in application.properties file.

    1. i dont know ,why table is not creating for me

    2. yes.. table will be auto created but not database. you need to create a database first.

  5. I am new with Springboot. I don't even quite get why we use localhost:8080 when using postman to crud our records instead of localhost:3306? I was thinking because we are connecting those records to mysql database and our records should be visible in mysql database, but I couldn't see the update through dbeaver? Thank you.

  6. Great tutorial, but I have this error while I run the test, like this:

    ava.lang.IllegalStateException: Failed to load ApplicationContext

    at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:132)
    at org.springframework.test.context.support.DefaultTestContext.getApplicationContext(DefaultTestContext.java:123)
    at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.injectDependencies(DependencyInjectionTestExecutionListener.java:118)
    at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.prepareTestInstance(DependencyInjectionTestExecutionListener.java:83)
    at org.springframework.boot.test.autoconfigure.SpringBootDependencyInjectionTestExecutionListener.prepareTestInstance(SpringBootDependencyInjectionTestExecutionListener.java:43)
    at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:244)
    at org.springframework.test.context.junit.jupiter.SpringExtension.postProcessTestInstance(SpringExtension.java:98)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeTestInstancePostProcessors$5(ClassBasedTestDescriptor.java:341)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.executeAndMaskThrowable(ClassBasedTestDescriptor.java:346)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeTestInstancePostProcessors$6(ClassBasedTestDescriptor.java:341)
    at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:195)
    at java.base/java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:177)
    at java.base/java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1624)
    at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:484)
    at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:474)
    at java.base/java.util.stream.StreamSpliterators$WrappingSpliterator.forEachRemaining(StreamSpliterators.java:312)
    at java.base/java.util.stream.Streams$ConcatSpliterator.forEachRemaining(Streams.java:735)
    at java.base/java.util.stream.Streams$ConcatSpliterator.forEachRemaining(Streams.java:734)

    I tried to put this on build tag:



    Is there any solution for that scenery? Thanks in advance!

    1. I ran the application but while doing the post, it shows 404. plz helpme out

      "timestamp": "2020-10-27T15:17:43.739+00:00",
      "status": 404,
      "error": "Not Found",
      "message": "",
      "path": "/api/v1/users"

    2. I rearranged the main class, i moved it to the top of the package and now it works...


Post a Comment