• 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

<?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>

spring-boot-starter-parent

 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>3.0.4</version>
 </parent>

package com.companyname.springbootcrudrest.model;
import java.util.Date;
import jakarta.persistence.*;
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;
@Entity
@Table(name = "users")
@EntityListeners(AuditingEntityListener.class)
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;
 
 @Id
 @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)
 @CreatedDate
 public Date getCreatedAt() {
 return createdAt;
 }
 public void setCreatedAt(Date createdAt) {
 this.createdAt = createdAt;
 }
 
 @Column(name = "created_by", nullable = false)
 @CreatedBy
 public String getCreatedBy() {
 return createdBy;
 }
 public void setCreatedBy(String createdBy) {
 this.createdBy = createdBy;
 }
 
 @Column(name = "updated_at", nullable = false)
 @LastModifiedDate
 public Date getUpdatedAt() {
 return updatedAt;
 }
 public void setUpdatedAt(Date updatedAt) {
 this.updatedAt = updatedAt;
 }
 
 @Column(name = "updated_by", nullable = false)
 @LastModifiedBy
 public String getUpdatedby() {
 return updatedby;
 }
 public void setUpdatedby(String updatedby) {
 this.updatedby = updatedby;
 }
}

@Entity
@Table(name = "users")
@EntityListeners(AuditingEntityListener.class)
public class User {
 // rest of the code here
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
@SpringBootApplication
@EnableJpaAuditing
public class SpringBootCrudRestApplication {
 public static void main(String[] args) {
 SpringApplication.run(SpringBootCrudRestApplication.class, args);
 }
}

import org.springframework.data.jpa.repository.JpaRepository;
import com.companyname.springbootcrudrest.model.User;
public interface UserRepository extends JpaRepository<User, Long>{
}

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);
@Override
<S extends T> List<S> findAll(Example<S> example);
<S extends T> List<S> findAll(Example<S> example, Sort sort);

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){
 super(message);
 }
}

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) {
 super();
 this.timestamp = timestamp;
 this.message = message;
 this.details = details;
 }
 public Date getTimestamp() {
 return timestamp;
 }
 public String getMessage() {
 return message;
 }
 public String getDetails() {
 return details;
 }
}

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;
@ControllerAdvice
public class GlobalExceptionHandler {
 @ExceptionHandler(ResourceNotFoundException.class)
 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);
 }
 @ExceptionHandler(Exception.class)
 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);
 }
}

package com.companyname.springbootcrudrest.controller;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import jakarta.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;
@RestController
@RequestMapping("/api/v1")
public class UserController {
 
 @Autowired
 private UserRepository userRepository;
 @GetMapping("/users")
 public List<User> getAllUsers() {
 return userRepository.findAll();
 }
 @GetMapping("/users/{id}")
 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);
 }
 @PostMapping("/users")
 public User createUser(@Valid @RequestBody User user) {
 return userRepository.save(user);
 }
 @PutMapping("/users/{id}")
 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.setEmailId(userDetails.getEmailId());
 user.setLastName(userDetails.getLastName());
 user.setFirstName(userDetails.getFirstName());
 user.setUpdatedAt(new Date());
 final User updatedUser = userRepository.save(user);
 return ResponseEntity.ok(updatedUser);
 }
 @DeleteMapping("/user/{id}")
 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));
 userRepository.delete(user);
 Map<String, Boolean> response = new HashMap<>();
 response.put("deleted", Boolean.TRUE);
 return response;
 }
}

8. Running the Application

$ mvn spring-boot:run

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;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringBootCrudRestApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class SpringBootCrudRestApplicationTests {
 @Autowired
 private TestRestTemplate restTemplate;
 @LocalServerPort
 private int port;
 private String getRootUrl() {
 return "http://localhost:" + port;
 }
 @Test
 public void contextLoads() {
 }
 @Test
 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);
 
 assertNotNull(response.getBody());
 }
 @Test
 public void testGetUserById() {
 User user = restTemplate.getForObject(getRootUrl() + "/users/1", User.class);
 System.out.println(user.getFirstName());
 assertNotNull(user);
 }
 @Test
 public void testCreateUser() {
 User user = new User();
 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());
 }
 @Test
 public void testUpdatePost() {
 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);
 }
 @Test
 public void testDeletePost() {
 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 (final HttpClientErrorException e) {
 assertEquals(e.getStatusCode(), HttpStatus.NOT_FOUND);
 }
 }
}

{
 "firstName": "Ramesh",
 "lastName": "fadatare",
 "emailId": "ramesh@gmail.com",
 "createdBy": "Ramesh",
 "updatedby": "Ramesh"
}

{
 "firstName": "Ram",
 "lastName": "Jadhav",
 "emailId": "ramesh123@gmail.com",
 "createdBy": "Ramesh",
 "updatedby": "Ramesh"
}

• Get link
• Facebook
• X
• Pinterest
• Email
• Other Apps