Spring Boot, MySQL, JPA, Hibernate RESTFul CRUD API Tutorial

Author:

🎓Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube


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

In this tutorial, we will use the latest version of Spring Boot 3, Hibernate 6, and Java 17.

Source Code on GitHub

This tutorial is accompanied by a working code exampleon GitHub.

YouTube Video 

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

1. What we’ll build

We are building a simpleUser Management Application which has below CRUD Rest APIs.

We are going to build the following five REST APIs (Controller handler methods) for theUser resource.
Spring Boot 2 Hibernate 5 MySQL CRUD REST API Tutorial

1. Creating Spring Boot Project

There are many ways to create a Spring Boot application. The simplest way is to use Spring Initializr athttp://start.spring.io/, which is an online Spring Boot application generator.
 
Use the following details while creating the Spring Boot project:
  • Generate: Maven Project
  • Java Version: 17 (Default)
  • Spring Boot:3.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, next, 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.

2. Packaging Structure

Following is the packing structure of our User Management Application -

    3. Maven Dependencies - pom.xml

    <?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"><modelVersion>4.0.0</modelVersion><groupId>com.companyname</groupId><artifactId>springbootcrudrest</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging><name>springbootcrudrest</name><description>Demo project for Spring Boot</description><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.4</version><relativePath/> <!-- lookup parent from repository --></parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>17</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-validation</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope></dependency><dependency><groupId>com.mysql</groupId><artifactId>mysql-connector-j</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>
    From the abovepom.xml, let's understand a 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.

    spring-boot-starter-parent

    All Spring Boot projects typically use spring-boot-starter-parent as the parent in pom.xml.
        <parent>        <groupId>org.springframework.boot</groupId>        <artifactId>spring-boot-starter-parent</artifactId>        <version>3.0.4</version>    </parent>
    Thespring-boot-starter-parent allows 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

    spring-boot-starter-web

    We added thespring-boot-starter-web dependency, which will by default pulls all the commonly used libraries while developing Spring MVC applications, such as spring-webmvc, jackson-json, validation-api, and Tomcat.

    spring-boot-starter-data-jpa

    We added thespring-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.

    3. 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 thesrc/main/resources/application.properties file and add the following properties to it -
    spring.datasource.url = jdbc:mysql://localhost:3306/users_database?useSSL=falsespring.datasource.username = rootspring.datasource.password = root## Hibernate Properties# The SQL dialect makes Hibernate generate better SQL for the chosen databasespring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQLDialect# Hibernate ddl auto (create, create-drop, validate, update)spring.jpa.hibernate.ddl-auto = update
    Don’t forget to change thespring.datasource.username andspring.datasource.password as per your MySQL installation. Also, create a database namedusers_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 the next step. This is made possible by the propertyspring.jpa.hibernate.ddl-auto = update.

    4. Create a JPA Entity - User

    Let's create aUser model or domain class with the following fields:
    • id - primary key
    • firstName - user's first name
    • lastName - user last name
    • emailId - user email ID
    • createdAt - user object created date
    • createdBy - use an object created by
    • updatedAt - user object updated by
    • updatedby - user object updated by
    packagecom.companyname.springbootcrudrest.model;importjava.util.Date;importjakarta.persistence.*;importorg.springframework.data.annotation.CreatedBy;importorg.springframework.data.annotation.CreatedDate;importorg.springframework.data.annotation.LastModifiedBy;importorg.springframework.data.annotation.LastModifiedDate;importorg.springframework.data.jpa.domain.support.AuditingEntityListener;@Entity@Table(name="users")@EntityListeners(AuditingEntityListener.class)publicclassUser {privatelong id;privateString firstName;privateString lastName;privateString emailId;privateDate createdAt;privateString createdBy;privateDate updatedAt;privateString updatedby;@Id@GeneratedValue(strategy=GenerationType.AUTO)publiclonggetId() {return id;    }publicvoidsetId(longid) {this.id= id;    }@Column(name="first_name",nullable=false)publicStringgetFirstName() {return firstName;    }publicvoidsetFirstName(StringfirstName) {this.firstName= firstName;    }@Column(name="last_name",nullable=false)publicStringgetLastName() {return lastName;    }publicvoidsetLastName(StringlastName) {this.lastName= lastName;    }@Column(name="email_address",nullable=false)publicStringgetEmailId() {return emailId;    }publicvoidsetEmailId(StringemailId) {this.emailId= emailId;    }@Column(name="created_at",nullable=false)@CreatedDatepublicDategetCreatedAt() {return createdAt;    }publicvoidsetCreatedAt(DatecreatedAt) {this.createdAt= createdAt;    }@Column(name="created_by",nullable=false)@CreatedBypublicStringgetCreatedBy() {return createdBy;    }publicvoidsetCreatedBy(StringcreatedBy) {this.createdBy= createdBy;    }@Column(name="updated_at",nullable=false)@LastModifiedDatepublicDategetUpdatedAt() {return updatedAt;    }publicvoidsetUpdatedAt(DateupdatedAt) {this.updatedAt= updatedAt;    }@Column(name="updated_by",nullable=false)@LastModifiedBypublicStringgetUpdatedby() {return updatedby;    }publicvoidsetUpdatedby(Stringupdatedby) {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.

    How to enable JPA Auditing

    Let's understand important JPA Auditing annotations:
    • @CreatedDate - Declares a field as the one representing the date the entity containing the field was created.
    • @LastModifiedDate - Declares a field as the one representing the date the entity containing the field was recently modified.
    • @CreatedBy- Declares a field as the one representing the principal that created the entity containing the field.
    • @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 ourUser model with the annotation@EntityListeners(AuditingEntityListener.class).
    @Entity@Table(name="users")@EntityListeners(AuditingEntityListener.class)publicclassUser {// rest of the code here}
    2. Enable JPA Auditing in the main application.
    OpenSpringBootCrudRestApplication.java and add a@EnableJpaAuditing annotation.
    importorg.springframework.boot.SpringApplication;importorg.springframework.boot.autoconfigure.SpringBootApplication;importorg.springframework.data.jpa.repository.config.EnableJpaAuditing;@SpringBootApplication@EnableJpaAuditingpublicclassSpringBootCrudRestApplication {publicstaticvoidmain(String[]args) {SpringApplication.run(SpringBootCrudRestApplication.class, args);    }}
    So far we have created aUser model and enabled JPA auditing on it. Next, we need to create a repository to access user records to and from a database.

    5. Create Spring Data JPA Repository - UserRepository

    importorg.springframework.data.jpa.repository.JpaRepository;importcom.companyname.springbootcrudrest.model.User;publicinterfaceUserRepositoryextendsJpaRepository<User,Long>{}
    In the above code, theUserRepository interface extendsJpaRepository which provides below methods to deal with database operations:
    List<T> findAll();List<T> findAll(Sort sort);List<T> findAllById(Iterable<ID> ids);<S extendsT>List<S> saveAll(Iterable<S> entities);void flush();<S extendsT>S saveAndFlush(S entity);void deleteInBatch(Iterable<T> entities);void deleteAllInBatch();T getOne(ID id);@Override<S extendsT>List<S> findAll(Example<S> example);<S extendsT>List<S> findAll(Example<S> example,Sort sort);

    6. Exception(Error) Handling for RESTful Services

    ResourceNotFoundException

    Let's create aResourceNotFoundException class with the following content in it:
    packagecom.companyname.springbootcrudrest.exception;importorg.springframework.http.HttpStatus;importorg.springframework.web.bind.annotation.ResponseStatus;@ResponseStatus(value=HttpStatus.NOT_FOUND)publicclassResourceNotFoundExceptionextendsException{privatestaticfinallong serialVersionUID=1L;publicResourceNotFoundException(Stringmessage){super(message);    }}

    ErrorDetails

    Let's createErrorDetails that we will use to customize the error response structure:
    packagecom.companyname.springbootcrudrest.exception;importjava.util.Date;publicclassErrorDetails {privateDate timestamp;privateString message;privateString details;publicErrorDetails(Datetimestamp,Stringmessage,Stringdetails) {super();this.timestamp= timestamp;this.message= message;this.details= details;    }publicDategetTimestamp() {return timestamp;    }publicStringgetMessage() {return message;    }publicStringgetDetails() {return details;    }}

    GlobalExceptionHandler

    To use ErrorDetails to return the error response, let’s create aGlobalExceptionHandler class annotated with@ControllerAdvice annotation. This class handles exception-specific and global exceptions in a single place.
    packagecom.companyname.springbootcrudrest.exception;importjava.util.Date;importorg.springframework.http.HttpStatus;importorg.springframework.http.ResponseEntity;importorg.springframework.web.bind.annotation.ControllerAdvice;importorg.springframework.web.bind.annotation.ExceptionHandler;importorg.springframework.web.context.request.WebRequest;@ControllerAdvicepublicclassGlobalExceptionHandler {@ExceptionHandler(ResourceNotFoundException.class)publicResponseEntity<?>resourceNotFoundException(ResourceNotFoundExceptionex,WebRequestrequest) {ErrorDetails errorDetails=newErrorDetails(newDate(), ex.getMessage(), request.getDescription(false));returnnewResponseEntity<>(errorDetails,HttpStatus.NOT_FOUND);    }@ExceptionHandler(Exception.class)publicResponseEntity<?>globleExcpetionHandler(Exceptionex,WebRequestrequest) {ErrorDetails errorDetails=newErrorDetails(newDate(), ex.getMessage(), request.getDescription(false));returnnewResponseEntity<>(errorDetails,HttpStatus.INTERNAL_SERVER_ERROR);    }}

    7. Creating UserController(Contains REST APIs)

    Now, it's time to create CRUD Rest APIs for theUser model.
    packagecom.companyname.springbootcrudrest.controller;importjava.util.Date;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importjakarta.validation.Valid;importorg.springframework.beans.factory.annotation.Autowired;importorg.springframework.http.ResponseEntity;importorg.springframework.web.bind.annotation.DeleteMapping;importorg.springframework.web.bind.annotation.GetMapping;importorg.springframework.web.bind.annotation.PathVariable;importorg.springframework.web.bind.annotation.PostMapping;importorg.springframework.web.bind.annotation.PutMapping;importorg.springframework.web.bind.annotation.RequestBody;importorg.springframework.web.bind.annotation.RequestMapping;importorg.springframework.web.bind.annotation.RestController;importcom.companyname.springbootcrudrest.exception.ResourceNotFoundException;importcom.companyname.springbootcrudrest.model.User;importcom.companyname.springbootcrudrest.repository.UserRepository;@RestController@RequestMapping("/api/v1")publicclassUserController {@AutowiredprivateUserRepository userRepository;@GetMapping("/users")publicList<User>getAllUsers() {return userRepository.findAll();    }@GetMapping("/users/{id}")publicResponseEntity<User>getUserById(@PathVariable(value="id")LonguserId)throwsResourceNotFoundException {User user= userRepository.findById(userId)        .orElseThrow(()->newResourceNotFoundException("User not found on ::"+ userId));returnResponseEntity.ok().body(user);    }@PostMapping("/users")publicUsercreateUser(@Valid@RequestBodyUseruser) {return userRepository.save(user);    }@PutMapping("/users/{id}")publicResponseEntity<User>updateUser(@PathVariable(value="id")LonguserId,@Valid@RequestBodyUseruserDetails)throwsResourceNotFoundException {User user= userRepository.findById(userId)          .orElseThrow(()->newResourceNotFoundException("User not found on ::"+ userId));          user.setEmailId(userDetails.getEmailId());        user.setLastName(userDetails.getLastName());        user.setFirstName(userDetails.getFirstName());        user.setUpdatedAt(newDate());finalUser updatedUser= userRepository.save(user);returnResponseEntity.ok(updatedUser);   }@DeleteMapping("/user/{id}")publicMap<String,Boolean>deleteUser(@PathVariable(value="id")LonguserId)throwsException {User user= userRepository.findById(userId)          .orElseThrow(()->newResourceNotFoundException("User not found on ::"+ userId));       userRepository.delete(user);Map<String,Boolean> response=newHashMap<>();       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 - annotation is a short form of @RequestMapping(method=RequestMethod.GET). This annotation is used to map incoming HTTP GET requests to a specific method handler.

    @PostMapping - annotation is a short form of @RequestMapping(method=RequestMethod.POST). This annotation is used to map incoming HTTP POST requests to a specific method handler.

    @PutMapping - annotation is a short form of @RequestMapping(method=RequestMethod.PUT).This annotation is used to map incoming HTTP PUT requests to a specific method handler.

    @DeleteMapping - annotation is a short form of @RequestMapping(method=RequestMethod.DELETE). This annotation is used to map incoming HTTP DELETE requests to a specific method handler.

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

    8. Running the Application

    We have successfully developed all the CRUD Rest APIs for theUser 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
    2. From your IDE, run theSpringBootCrudRestApplication.main() method as a standalone Java class that will start the embedded Tomcat server on port 8080 and point the browser tohttp://localhost:8080/.

        9. Unit Testing REST APIs

        Let's write JUnit test cases for all Rest APIs of theUser entity.
        packagecom.companyname.projectname.springbootcrudrest;import staticorg.junit.Assert.assertEquals;import staticorg.junit.Assert.assertNotNull;importorg.junit.Test;importorg.junit.runner.RunWith;importorg.springframework.beans.factory.annotation.Autowired;importorg.springframework.boot.test.context.SpringBootTest;importorg.springframework.boot.test.web.client.TestRestTemplate;importorg.springframework.boot.web.server.LocalServerPort;importorg.springframework.http.HttpEntity;importorg.springframework.http.HttpHeaders;importorg.springframework.http.HttpMethod;importorg.springframework.http.HttpStatus;importorg.springframework.http.ResponseEntity;importorg.springframework.test.context.junit4.SpringRunner;importorg.springframework.web.client.HttpClientErrorException;importcom.companyname.springbootcrudrest.SpringBootCrudRestApplication;importcom.companyname.springbootcrudrest.model.User;@RunWith(SpringRunner.class)@SpringBootTest(classes=SpringBootCrudRestApplication.class,webEnvironment=SpringBootTest.WebEnvironment.RANDOM_PORT)publicclassSpringBootCrudRestApplicationTests {@AutowiredprivateTestRestTemplate restTemplate;@LocalServerPortprivateint port;privateStringgetRootUrl() {return"http://localhost:"+ port;    }@TestpublicvoidcontextLoads() {    }@TestpublicvoidtestGetAllUsers() {HttpHeaders headers=newHttpHeaders();HttpEntity<String> entity=newHttpEntity<String>(null, headers);ResponseEntity<String> response= restTemplate.exchange(getRootUrl()+"/users",HttpMethod.GET, entity,String.class);           assertNotNull(response.getBody());    }@TestpublicvoidtestGetUserById() {User user= restTemplate.getForObject(getRootUrl()+"/users/1",User.class);System.out.println(user.getFirstName());        assertNotNull(user);    }@TestpublicvoidtestCreateUser() {User user=newUser();        user.setEmailId("admin@gmail.com");        user.setFirstName("admin");        user.setLastName("admin");        user.setCreatedBy("admin");        user.setUpdatedby("admin");ResponseEntity<User> postResponse= restTemplate.postForEntity(getRootUrl()+"/users", user,User.class);        assertNotNull(postResponse);        assertNotNull(postResponse.getBody());    }@TestpublicvoidtestUpdatePost() {int id=1;User user= restTemplate.getForObject(getRootUrl()+"/users/"+ id,User.class);         user.setFirstName("admin1");         user.setLastName("admin2");         restTemplate.put(getRootUrl()+"/users/"+ id, user);User updatedUser= restTemplate.getForObject(getRootUrl()+"/users/"+ id,User.class);         assertNotNull(updatedUser);    }@TestpublicvoidtestDeletePost() {int id=2;User user= restTemplate.getForObject(getRootUrl()+"/users/"+ id,User.class);         assertNotNull(user);         restTemplate.delete(getRootUrl()+"/users/"+ id);try {              user= restTemplate.getForObject(getRootUrl()+"/users/"+ id,User.class);         }catch (finalHttpClientErrorException e) {         assertEquals(e.getStatusCode(),HttpStatus.NOT_FOUND);     }  }}

        Output


        From the above Spring Boot application development let's list out the advantages of using Spring boot.
        • Simpler dependency management
        • Default auto-configuration
        • Embedded web server
        • Application metrics and health checks
        • Advanced externalized configuration

        10. Test Using Postman Client

        1. Create User REST API

        HTTP Method: POST
        RequestURL: http://localhost:8080/api/v1/users
        Request JSON:
        {"firstName":"Ramesh","lastName":"fadatare","emailId":"ramesh@gmail.com","createdBy":"Ramesh","updatedby":"Ramesh"}

        2. Get User by ID REST API

        HTTP Method: GET
        RequestURL: http://localhost:8080/api/v1/users/2

        3. Get all users REST API

        HTTP Method: GET
        Request URL: http://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

        HTTP Method: DELETE 

        12. Source code on GitHub

        The source code of this tutorial is available on myGitHub Repository.

        Related Spring Boot and Microservices Tutorials/Guides:

        The Hidden Magic of Spring Boot: Secrets Every Developer Should KnowWhat Happens When You Hit a Spring Boot REST API Endpoint (Behind the Scenes)Spring Boot Exception HandlingBuild CRUD REST API with Spring Boot, Spring Data JPA, Hibernate, and MySQLSpring Boot DELETE REST API: @DeleteMapping AnnotationSpring Boot PUT REST API — @PutMapping AnnotationSpring Boot POST REST APISpring Boot GET REST API — @GetMapping AnnotationSpring Boot REST API with Request Param | Spring Boot CourseSpring Boot REST API with Path Variable — @PathVariableChapter 13: Understanding @SpringBootApplication Annotation | Spring Boot CourseChapter 5: Create Spring Boot Project and Build Hello World REST API | Spring Boot Course10 Real-World Spring Boot Architecture Tips Every Developer Should FollowTop 10 Spring Boot Tricks Every Java Developer Should KnowDebugging Spring Dependency Injection Issues - Very ImportantCommon Code Smells in Spring Applications — How to Fix ThemSpring Boot + OpenAI ChatGPT API Integration TutorialSpring Boot Course -> New Series on Medium ❤️Spring Boot Microservices with RabbitMQ ExampleReact JS + Spring Boot MicroservicesDockerizing a Spring Boot ApplicationHow to Change the Default Port in Spring BootHow to Change Context Path in Spring BootTop 10 Spring Boot REST API Mistakes and How to Avoid Them (2025 Update)Spring Boot REST API Best PracticesSpring Boot Security Database Authentication Example TutorialSpring Boot Security Form-Based AuthenticationSpring Boot Security In-Memory AuthenticationWhat is Spring Boot Really All About?Why Spring Boot over Spring?Top 10 Spring Boot Key Features That You Should KnowSpring vs Spring BootSetting Up the Development Environment for Spring BootSpring Boot Auto-Configuration: A Quick GuideSpring Boot StartersQuick Guide to Spring Boot Parent StarterSpring Boot Embedded ServersSpring Boot Thymeleaf Hello World ExampleChapter 10: Spring Boot DevTools | Spring Boot CourseChapter 13: Spring Boot REST API That Returns JSON | Spring Boot CourseSpring Boot REST API That Returns List of Java Objects in JSON FormatTop 10 Spring Boot Mistakes and How to Avoid ThemAdvanced Spring Boot Concepts that Every Java Developer Should KnowWhat Are Microservices in Spring Boot?Integrating React Frontend with Spring Boot ChatGPT API (Step-by-Step Guide)Build a Chatbot Using Spring Boot, React JS, and ChatGPT APITop 10 Mistakes in Spring Boot Microservices and How to Avoid Them (With Examples)Spring Boot Security Best Practices: Protecting Your Application from Attacks🔄 Dependency Injection in Spring (Explained with Coding Examples)⚙️ How Spring Container Works Behind the ScenesHow Spring Container Works Behind the Scenes (Spring Container Secrets Revealed!)Spring @Component vs @Bean vs @Service vs @Repository ExplainedHow Component Scanning Works Behind the Scenes in SpringHow Spring Autowiring Works InternallyTop 20 Spring Boot Best Practices for Java DevelopersBuild Spring Boot React Full Stack Project — Todo App [2025 Update]Spring vs Spring MVC vs Spring BootSpring Boot Best Practices: Use DTOs Instead of Entities in API ResponsesSpring Boot DTO Tutorial (Using Java record) – Complete CRUD REST API ImplementationSpring Boot Architecture: Controller, Service, Repository, Database and Architecture FlowJava Stream filter() Method with Real-World ExamplesSpring Boot Auto Configuration Explained | How It WorksSpring Boot Profiles: How to Manage Environment-Based ConfigurationsCreate a Custom Spring Boot Starter | Step-by-Step GuideSpring Boot Starter Modules Explained | Auto-Configuration GuideDeploy Spring Boot Applications with Profile-Based Settings | Step-by-Step GuideSpring Boot Performance Tuning: 10 Best Practices for High PerformanceSpring Boot @ComponentScan Annotation | Customizing Component ScanningDifference Between @RestController and @RequestMapping in Spring BootSpring Boot @Cacheable Annotation – Improve Performance with CachingSpring Boot Redis Cache — @Cacheable Complete GuideWhen to Use @Service, @Repository, @Controller, and @Component Annotations in Spring BootWhy, When, and How to Use @Bean Annotation in Spring Boot AppJava Spring Boot vs. Go (Golang) for Backend Development in 2025Is Autowired Annotation Deprecated in Spring Boot? Everything You Need to Know🚫 Stop Making These Common Mistakes in Spring Boot ProjectsTop 10 Mind-Blowing Spring Boot Tricks for BeginnersWhy Choose Spring Boot Over Spring Framework? | Key Differences and BenefitsHow to Run a Spring Boot Application | 5 Easy Ways for DevelopersWhat is AutoConfiguration in Spring Boot? | Explained with ExampleCustomize Default Configuration in Spring Boot | 5 Proven WaysChapter 12: Understanding SpringApplication.run() Method Internals | Spring Boot CourseWhat is CommandLineRunner in Spring Boot?How to Create Custom Bean Validation in Spring BootCan You Build a Non-Web Application with Spring Boot?How to Disable Auto-Configuration in Spring Boot (Step-by-Step Guide)Top 25 Spring Boot Interview Questions and Answers for BeginnersHow to Use Java Records with Spring BootSpring Boot Constructor Injection Explained with Step-by-Step Example🚫 Stop Using @Transactional Everywhere: Understand When You Actually Need It🚫 Stop Writing Fat Controllers: Follow the Controller-Service-Repository Pattern🚫 Stop Using Field Injection in Spring Boot: Use Constructor Injection🚫 Stop Sharing Databases Between Microservices: Use Database Per Service Pattern10 Java Microservices Best Practices Every Developer Should FollowHow to Choose the Right Java Microservices Communication Style (Sync vs Async)How to Implement Event-Driven Communication in Java Microservices (Step-by-Step Guide with Kafka)Stop Building Tight-Coupled Microservices: Aim for Loose CouplingSpring Boot Microservices E-Commerce Project: Step-by-Step GuideSpring Boot Microservices with RabbitMQ ExampleReact JS + Spring Boot MicroservicesThe Ultimate Microservices Roadmap for Beginners: Building Modern Scalable SystemsWhat Are Microservices in Spring Boot?Top 5 Message Brokers Every Developer Should KnowTop 10 Spring Cloud Microservices Best Practices [Removed Deprecated Features]Best Tools for Microservices Development in 2025How to Break a Monolithic Application into Microservices (E-Commerce Use Case)Monoliths Aren’t Dead — Microservices Are Just OverusedWhen to Break a Monolith: A Developer’s Checklist👑 Java Is Still the King of Microservices — And Here’s the Proof5 Microservices Design Patterns You Must Know in 2025Bulkhead Pattern in Microservices — Improve Resilience and Fault IsolationStrangler Fig Pattern in Microservices — Migrate Monolith to MicroservicesEvent Sourcing Pattern in Microservices (With Real-World Example)Circuit Breaker Pattern in Microservices using Spring Boot 3, WebClient and Resilience4jCQRS Pattern in MicroservicesAggregator Design Pattern in Microservices — A Complete GuideDatabase Per Service Pattern in MicroservicesAPI Gateway Pattern in Microservices — A Complete GuideSaga Pattern in Microservices: A Step-by-Step GuideMicroservices Are a Mess Without These Java Design Patterns️Java Microservices Interview Questions and Answers for FreshersTop Microservices Interview Questions and Answers for Experienced ProfessionalsTop 10 Microservices Design Pattern Interview Questions and AnswersTop Microservices Tricky Interview Questions You Should Know (With Answers)Microservices Best Practices: Building Scalable and Resilient SystemsWhy Microservices Are the Future of Software ArchitectureMicroservices with Spring Cloud: Simplify Your ArchitectureSpring Boot and Microservices Roadmap for Beginners [2025 Update]Best Programming Language for Microservices Project Development in 2025My 50+ Must-Read Microservices Tutorials, Articles and Guides on the Medium Platform

        Comments

        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.

          ReplyDelete

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

          ReplyDelete

        3. here table will be auto created or not?

          ReplyDelete

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

          ReplyDelete
          Replies

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

            Delete

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

            Delete

        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.

          ReplyDelete

        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:




          src/test/resources


          ...


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

          ReplyDelete
          Replies

          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"
            }

            Delete

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

            Delete

        Post a Comment

        Leave Comment

        Spring Boot 3 Paid Course Published for Free
        on myJava Guides YouTube Channel

        Subscribe to my YouTube Channel (165K+ subscribers):
        Java Guides Channel

        Top 10 My Udemy Courses with Huge Discount:
        Udemy Courses - Ramesh Fadatare