Spring Boot Rest API example

Spring Boot rest API example

Spring Boot offers a fast way to build applications. It looks at your class-path and at the beans you have configured, makes reasonable assumptions about what you are missing, and adds those items. With Spring Boot, you can focus more on business features and less on infrastructure.

The following examples show what Spring Boot can do for you:

Is Spring MVC on the class-path? There are several specific beans you almost always need, and Spring Boot adds them automatically.

 A Spring MVC application also needs a servlet container, so Spring Boot automatically configures embedded Tomcat.

 

In this tutorial we will see spring boot rest api.

What You Need
1. About 15 minutes
2. A favorite text editor or IDE
3. JDK 1.8 or later
3. Maven 3.2+
4. You can also import the code straight into your IDE:
5. Spring Tool Suite (STS)
6. IntelliJ IDEA
7. Eclipse

Here in this article we will use Eclipse

For creating project go to Spring initializer online 

1. Go to URL
2. Select Project as Maven Project.
3. Select language as Java as we are creating the java project.
4. Then select the spring boot latest version.
5. We are using 2.3.1.RELEASE.
6. For Project metataData.
7. input package name as com.javacodestuffs.spring.boot.rest
8. artifactId AS OUR PROJECT NAME - spring-boot-rest-api
 
9. Select Packaging as Jar
10. Select Java version 8
111. Input the dependencies you required for application .

We have added devTool
Spring Web
Spring Data JPA
Generate the project.

It will download project skeleton as zip.

Extract the zip and import it in Eclipse as Maven Project.

Our project skeleton is ready now we can add our classes in It.

 

1). 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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.5.4</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.javacodestuffs.spring.boot.rest</groupId>
	<artifactId>spring-boot-rest-api</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>spring-boot-rest-api</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</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-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		
			<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		
			<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-log4j2</artifactId>
		</dependency>
		
		<!-- apache dependency -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
		</dependency>
	<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		 	</dependency>
		 	
		 	<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.1</version>
</dependency>
		 	
			</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

2). Main class

 
package com.javacodestuffs.spring.boot.rest;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootRestApiApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringBootRestApiApplication.class, args);
	}

}


 

3). Create controller

Create controller EmployeeController.java inside controller package.

  
package com.javacodestuffs.spring.boot.rest.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
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.javacodestuffs.spring.boot.rest.dto.EmployeeDto;
import com.javacodestuffs.spring.boot.rest.dto.ResponseDto;
import com.javacodestuffs.spring.boot.rest.service.EmployeeService;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@RestController
@RequestMapping("api/employee")
public class EmployeeController {
	@Autowired

	private EmployeeService employeeService;

	@PostMapping()
	public ResponseDto<EmployeeDto> createAdditionalVar(@RequestBody @Validated EmployeeDto EmployeeDto) {
		log.info(" EmployeeDto  id: {} ", EmployeeDto);

		return ResponseDto.success("Employee added successfully", employeeService.addEmployee(EmployeeDto));
	}

	@PutMapping()
	public ResponseDto<EmployeeDto> updateAdditionalVar(@RequestBody @Validated EmployeeDto EmployeeDto) {
		log.info(" EmployeeDto  id: {} ", EmployeeDto);

		return ResponseDto.success("Employee updated successfully", employeeService.updateEmployee(EmployeeDto));
	}

	@GetMapping("/uuid/{uuid}")
	public ResponseDto<EmployeeDto> getEmployeeByUUID(@PathVariable String uuid) {
		log.info(" getEmployeeByUUID id: {} ", uuid);
		return ResponseDto.success(" getEmployeeByUUID ", employeeService.getEmployeeByUUID(uuid));
	}

	@GetMapping("/{id}")
	public ResponseDto<EmployeeDto> getEmployeeById(@PathVariable Long id) {
		log.info(" getEmployeeById id: {} ", id);
		return ResponseDto.success(" getEmployeeById ", employeeService.getEmployeeById(id));
	}

	@DeleteMapping("/{id}")
	public ResponseDto<EmployeeDto> deleteEmployeeById(@PathVariable Long id) {
		log.info(" deleteEmployeeById id: {} ", id);
		employeeService.deleteEmployee(id);
		return ResponseDto.success("Employee deleted successfully");
	}

}

Inside controller we will write endpoints and methods as

  

GET request to /api/employee/ returns a list of employee
GET request to /api/employee/1 returns the employee with Id 1
POST request to /api/employee/ with a employee object as JSON creates a new user
PUT request to /api/employee/3 with a employee object as JSON updates the employee with Id 3
DELETE request to /api/employee/4 deletes the employee with Id 4
DELETE request to /api/employee/ deletes all the employees

 

4) update application.properties

############# Application Context ###############
spring.application.name=spring-boot-rest-api
server.port=9090
server.servlet.context-path=/spring-boot-rest-api


################# MySQL JDBC Connection mChange C3P0 ###############
spring.datasource.driver.class.name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/employeedb?createDatabaseIfNotExist=true&autoReconnect=true&zeroDateTimeBehavior=convertToNull&useSSL=false
spring.datasource.username=root
spring.datasource.password=Root
 

############ Hibernate Configuration ##############
spring.jpa.hibernate.cache.provider_class=org.hibernate.cache.NoCacheProvider
spring.jpa.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.hibernate.show_sql=true
spring.jpa.hibernate.format_sql=false
spring.jpa.hibernate.hbm2ddl.auto=create
spring.jpa.hibernate.order_inserts=true
spring.jpa.hibernate.order_updates=true
spring.jpa.generate-ddl=true
spring.jpa.open-in-view=false
 

 

5) Configure Entity for the Spring Data JPA

Once table is ready, we need to map it a Java object using the JPA. Every field of the Entity is mapped table inside the database .

the base Entity class : AbstractJpaEntity.java

 package com.javacodestuffs.spring.boot.rest.entity;

import java.io.Serializable;
import java.util.Date;
import java.util.UUID;

import javax.persistence.Column;
import javax.persistence.EntityListeners;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.PrePersist;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import org.apache.commons.lang3.StringUtils;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import lombok.experimental.SuperBuilder;

@Getter
@Setter
@ToString
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@EntityListeners({ SpringEntityListener.class })
@MappedSuperclass
@SuppressWarnings("serial")
public abstract class AbstractJpaEntity implements Serializable {

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

	@Column(name = "uuid", columnDefinition = "char(40)", unique = true, nullable = false)
	protected String uuid;

	@Column(name = "created_at", columnDefinition = "DATETIME DEFAULT CURRENT_TIMESTAMP")
	@Temporal(TemporalType.TIMESTAMP)
	protected Date createdAt;

	@Column(name = "updated_at", columnDefinition = "DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
	@Temporal(TemporalType.TIMESTAMP)
	protected Date updatedAt;

	@Builder.Default
	@Column(name = "status", columnDefinition = "bit(1) default 1")
	protected boolean status = true;

	@PrePersist
	private void validationBeforeSaving() {
		if (StringUtils.isBlank(uuid)) {
			uuid = generateUniqueId();
		}
	}

	public static String generateUniqueId() {
		return UUID.randomUUID().toString();
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj == null) {
			return false;
		}
		if (getClass() != obj.getClass()) {
			return false;
		}
		AbstractJpaEntity other = (AbstractJpaEntity) obj;
		if (id == null) {
			if (other.id != null) {
				return false;
			}
		} else if (!id.equals(other.id)) {
			return false;
		}
		if (uuid == null) {
			if (other.uuid != null) {
				return false;
			}
		} else if (!uuid.equals(other.uuid)) {
			return false;
		}
		return true;
	}

}
 

6). Add Entity class : EmployeeEntity.java

package com.javacodestuffs.spring.boot.rest.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.Table;
 

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import lombok.experimental.SuperBuilder;

@Getter
@Setter
@ToString(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@Table(name = "employee")
@Entity(name = "employee")
public class EmployeeEntity extends AbstractJpaEntity {
 
	private static final long serialVersionUID = 1L;
 
 
	@Column(name = "firstName", columnDefinition = "varchar(20)", nullable = false)
	private String firstName;

	@Column(name = "lastName", columnDefinition = "varchar(20)", nullable = false)
	private String lastName;

	@Column(name = "mobile", columnDefinition = "varchar(20)", nullable = false)
	private String mobile;

	@Column(name = "email", columnDefinition = "varchar(20)", nullable = false)
	private String email;

	@Column(columnDefinition = "TEXT", name = "address")
	private String address;
	
	@Column(columnDefinition = "TEXT", name = "department")
	private String department;

}

 

7). Add the EntityListener class to listen Entity changes: SpringEntityListener.java ,is useful for to generate create/update date.

 package com.javacodestuffs.spring.boot.rest.entity;

import java.util.Date;

import javax.persistence.PrePersist;
import javax.persistence.PreUpdate;

import org.apache.commons.lang3.StringUtils;

import com.javacodestuffs.spring.boot.rest.utils.SpringUtils;

/**
 * Entity listener for all Entities/Models
 *
 */
public class SpringEntityListener {

	@PrePersist
	private void beforeInsert(AbstractJpaEntity abstractEntity) {
		if (abstractEntity.getCreatedAt() == null) {
			abstractEntity.setCreatedAt(new Date());
		}
		if (abstractEntity.getUpdatedAt() == null) {
			abstractEntity.setUpdatedAt(new Date());
		}

		if (StringUtils.isBlank(abstractEntity.getUuid())) {
			abstractEntity.setUuid(SpringUtils.generateUniqueId());
		}	

	}

	@PreUpdate
	private void beforeUpdate(AbstractJpaEntity abstractEntity) {
		if (abstractEntity.getCreatedAt() == null) {
			abstractEntity.setCreatedAt(new Date());
		}

		abstractEntity.setUpdatedAt(new Date());
	}
}
 

8). Add Service layer class

package com.javacodestuffs.spring.boot.rest.service;

import com.javacodestuffs.spring.boot.rest.dto.EmployeeDto;

public interface EmployeeService {

	public EmployeeDto addEmployee(EmployeeDto employeeDto);

	public EmployeeDto getEmployeeByUUID(String uuid);

	public EmployeeDto getEmployeeById(Long id);

	public void deleteEmployee(Long id);

	public EmployeeDto updateEmployee(EmployeeDto employeeDto);

}

 

The service layer class : EmployeeServiceImpl.java

package com.javacodestuffs.spring.boot.rest.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.javacodestuffs.spring.boot.rest.adapter.EmployeeAdapter;
import com.javacodestuffs.spring.boot.rest.db.service.EmployeeDbService;
import com.javacodestuffs.spring.boot.rest.dto.EmployeeDto;
import com.javacodestuffs.spring.boot.rest.entity.EmployeeEntity;

import lombok.extern.slf4j.Slf4j;

@Service
@Slf4j
public class EmployeeServiceImpl implements EmployeeService {

	@Autowired
	EmployeeDbService employeeDbService;

	@Override
	public EmployeeDto addEmployee(EmployeeDto employeeDto) {

		EmployeeEntity employeeEntity = EmployeeEntity.builder().address(employeeDto.getAddress())
				.department(employeeDto.getDepartment()).email(employeeDto.getEmail())
				.firstName(employeeDto.getFirstName()).id(employeeDto.getId()).lastName(employeeDto.getLastName())
				.mobile(employeeDto.getMobile()).build();
		EmployeeEntity employeeEntitySaved = employeeDbService.saveEmployee(employeeEntity);
		log.info("employee saved in database {} ", employeeEntitySaved);

		return EmployeeAdapter.getEmployeeDto(employeeEntitySaved);
	}

	@Override
	public EmployeeDto getEmployeeByUUID(String uuid) {

		EmployeeEntity employeeEntity = employeeDbService.findEmployeeByUUID(uuid);
		log.info("Get employee by uuid from database {} ", employeeEntity);
		return EmployeeAdapter.getEmployeeDto(employeeEntity);
	}

	@Override
	public EmployeeDto getEmployeeById(Long id) {
		EmployeeEntity employeeEntity = employeeDbService.getEmployeeById(id);
		log.info("Get EmployeeById from database {} ", employeeEntity);
		return EmployeeAdapter.getEmployeeDto(employeeEntity);
	}

	@Override
	public void deleteEmployee(Long id) {
		employeeDbService.deleteEmployee(id);

	}

	@Override
	public EmployeeDto updateEmployee(EmployeeDto employeeDto) {

		EmployeeEntity employeeEntity = employeeDbService.updateEmployee(employeeDto);

		return EmployeeAdapter.getEmployeeDto(employeeEntity);
	}

}

9). Add the database service layer class : EmployeeServiceImpl.java

package com.javacodestuffs.spring.boot.rest.db.service;

 
import com.javacodestuffs.spring.boot.rest.dto.EmployeeDto;
import com.javacodestuffs.spring.boot.rest.entity.EmployeeEntity;

public interface EmployeeDbService {

	EmployeeEntity saveEmployee(EmployeeEntity employeeEntity);

	EmployeeEntity findEmployeeByUUID(String uuid);

	EmployeeEntity getEmployeeById(Long id);

	void deleteEmployee(Long id);

	EmployeeEntity updateEmployee(EmployeeDto employeeDto);

}

 

EmployeeDbServiceImpl.java

 package com.javacodestuffs.spring.boot.rest.db.service;

import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.javacodestuffs.spring.boot.rest.dto.EmployeeDto;
import com.javacodestuffs.spring.boot.rest.entity.EmployeeEntity;
import com.javacodestuffs.spring.boot.rest.exception.NoRecordException;
import com.javacodestuffs.spring.boot.rest.repository.EmployeeRepository;

@Service
public class EmployeeDbServiceImpl implements EmployeeDbService {

	@Autowired
	EmployeeRepository employeeRepository;

	@Override
	public EmployeeEntity saveEmployee(EmployeeEntity entity) {
		EmployeeEntity employeeEntity = employeeRepository.saveAndFlush(entity);
		return employeeEntity;
	}

	@Override
	public EmployeeEntity findEmployeeByUUID(String uuid) {
		EmployeeEntity employeeEntity = employeeRepository.findFirstByUuid(uuid);
		return employeeEntity;
	}

	@Override
	public EmployeeEntity getEmployeeById(Long id) {
		Optional<EmployeeEntity> employeeEntity = employeeRepository.findById(id);

		if (employeeEntity.isPresent()) {
			return employeeEntity.get();
		} else {
			throw new NoRecordException("Employee not Found!");
		}

	}

	@Override
	public void deleteEmployee(Long id) {
		Optional<EmployeeEntity> employeeEntity = employeeRepository.findById(id);
		if (employeeEntity.isPresent()) {
			employeeRepository.delete(employeeEntity.get());
		} else {
			throw new NoRecordException("Employee not Found!");
		}

	}

	@Override
	public EmployeeEntity updateEmployee(EmployeeDto employeeDto) {
		Optional<EmployeeEntity> employeeEntity = employeeRepository.findById(employeeDto.getId());
		EmployeeEntity employeeEntityUpdate = employeeEntity.get();
		if (employeeDto.getDepartment() != null) {
			employeeEntityUpdate.setDepartment(employeeDto.getDepartment());
		}
		if (employeeDto.getFirstName() != null) {
			employeeEntityUpdate.setFirstName(employeeDto.getFirstName());

		}

		if (employeeDto.getLastName() != null) {
			employeeEntityUpdate.setLastName(employeeDto.getLastName());
		}

		if (employeeDto.getMobile() != null) {
			employeeEntityUpdate.setMobile(employeeDto.getMobile());
		}

		return employeeRepository.saveAndFlush(employeeEntityUpdate);

	}

}

 

10). Add DTO class : EmployeeDto.java

 package com.javacodestuffs.spring.boot.rest.dto;

import java.util.Date;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import lombok.experimental.SuperBuilder;

@Getter
@Setter
@ToString(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class EmployeeDto {
	private Long id;

	private String employeeUuid;

	private String firstName;

	private String lastName;

	private String mobile;

	private String email;

	private String address;

	private String department;

	private Date createdAt;
  
	private Date updatedAt;
	
	private boolean status;
}

 

ResponseDto.java

 package com.javacodestuffs.spring.boot.rest.dto;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
@NoArgsConstructor
public class ResponseDto<T> {

	private boolean status;

	private String message;

	private String id;

	private String errorCode;

	private T data;

	private int httpStatusCode;

	private ResponseDto(boolean status) {
		this.status = status;
	}

	protected ResponseDto(boolean status, String message) {
		this(status);
		this.message = message;
	}

	protected ResponseDto(boolean status, String message, T data) {
		this(status, message);
		this.data = data;
	}

	private ResponseDto(boolean status, String message, T data, String id) {
		this(status, message, data);
		this.id = id;
	}

	private ResponseDto(boolean status, String message, T data, String id, String errorCode) {
		this(status, message, data, id);
		this.errorCode = errorCode;
	}

	public static <T> ResponseDto<T> success(T data) {
		return new ResponseDto<>(true, null, data);
	}

	public static <T> ResponseDto<T> success(String message) {
		return new ResponseDto<>(true, message, null);
	}

	public static <T> ResponseDto<T> success(String message, T data) {
		return new ResponseDto<>(true, message, data);
	}

	public static <T> ResponseDto<T> success(String message, T data, String id) {
		return new ResponseDto<>(true, message, data, id);
	}

	public static <T> ResponseDto<T> success(String message, T data, String id, String errorCode) {
		return new ResponseDto<>(true, message, data, id, errorCode);
	}

	public static <T> ResponseDto<T> failure(String message) {
		return new ResponseDto<>(false, message);
	}

	public static <T> ResponseDto<T> failure(String message, String id) {
		return new ResponseDto<>(false, message, null, id);
	}

	public static <T> ResponseDto<T> failure(String message, String id, String errorCode) {
		return new ResponseDto<>(false, message, null, id, errorCode);
	}

	public static <T> ResponseDto<T> failure(String message, T data) {
		return new ResponseDto<>(false, message, data);
	}

	public static <T> ResponseDto<T> failure(String message, T data, String id) {
		return new ResponseDto<>(false, message, data, id);
	}

	public static <T> ResponseDto<T> failure(String message, T data, String id, String errorCode) {
		return new ResponseDto<>(false, message, data, id, errorCode);
	}

}
 

11). Add Exception class for Exception handling : NoRecordException.java

 package com.javacodestuffs.spring.boot.rest.exception;
public class NoRecordException extends RuntimeException {

	private static final long serialVersionUID = -3368655266237942363L;

	public NoRecordException(String message) {
		super(message);
	}

	public NoRecordException(Throwable cause) {
		super(cause);
	}

	public NoRecordException(String message, Throwable cause) {
		super(message, cause);
	}

}
 

12). Add the JpaRepositories

 package com.javacodestuffs.spring.boot.rest.core.sqljpa.entity;
 
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.NoRepositoryBean;

import com.javacodestuffs.spring.boot.rest.entity.AbstractJpaEntity;

import java.io.Serializable;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Optional;

@NoRepositoryBean
public interface AbstractJpaRepository<T extends AbstractJpaEntity, I extends Serializable> extends JpaRepository<T, I>, JpaSpecificationExecutor<T> {

	T findFirstByUuid(String uuid);

	T findFirstByUuidAndStatus(String uuid, boolean status);

	List<T> findByUuidIn(Collection<String> uuids);

	List<T> findByUuidInAndStatus(Collection<String> uuids, boolean status);

	Page<T> findByStatus(boolean status, Pageable pageable);

	List<T> findByStatus(boolean status);

	long countByStatus(boolean status);

	Boolean existsByUuid(String uuid);

	Boolean existsByUuidAndStatus(String uuid, boolean status);

	List<T> findByUpdatedAtBetween(Date fromDate, Date toDate);

	List<T> findByIdBetween(I fromId, I toId);

	Optional<T> findByUuidAndStatus(String uuid , boolean status);

}
 

EmployeeRepository.java

 package com.javacodestuffs.spring.boot.rest.repository;

import org.springframework.stereotype.Repository;

import com.javacodestuffs.spring.boot.rest.core.sqljpa.entity.AbstractJpaRepository;
//import com.javacodestuffs.spring.boot.rest.core.sqljpa.entity.AbstractJpaRepository;
import com.javacodestuffs.spring.boot.rest.entity.EmployeeEntity;
 
 
@Repository
public interface EmployeeRepository extends AbstractJpaRepository<EmployeeEntity,Long>  {

}

 

13). Finally we need to add Adapter class to convert EmployeeEntity to EmployeeDto : EmployeeAdapter.java

 package com.javacodestuffs.spring.boot.rest.adapter;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import org.apache.commons.collections4.CollectionUtils;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.javacodestuffs.spring.boot.rest.dto.EmployeeDto;
import com.javacodestuffs.spring.boot.rest.entity.EmployeeEntity;

import lombok.experimental.UtilityClass;
import lombok.extern.log4j.Log4j2;

@UtilityClass
@Log4j2
public class EmployeeAdapter {
	ObjectMapper mapper = new ObjectMapper();

	public static EmployeeDto getEmployeeDto(EmployeeEntity employeeEntity) {

		log.info("EmployeeEntity Email {}", employeeEntity.getEmail());
		return EmployeeDto.builder().address(employeeEntity.getAddress()).email(employeeEntity.getEmail())
				.id(employeeEntity.getId()).department(employeeEntity.getDepartment())
				.employeeUuid(employeeEntity.getUuid()).firstName(employeeEntity.getFirstName())
				.lastName(employeeEntity.getLastName()).mobile(employeeEntity.getMobile())
				.status(employeeEntity.isStatus()).createdAt(employeeEntity.getCreatedAt())
				.updatedAt(employeeEntity.getUpdatedAt()).build();

	}

	public static List<EmployeeDto> getListingEmployeeDtos(List<EmployeeEntity> employeeEntity) {

		if (CollectionUtils.isEmpty(employeeEntity)) {
			return new ArrayList<>();
		}
		return employeeEntity.stream().map(EmployeeAdapter::getEmployeeDto).collect(Collectors.toList());

	}

}
 

13). Postman Request's

Postman Request for AddEmployee

 

RequestBody and URL

http://localhost:9090/spring-boot-rest-api/api/employee

{
"firstName":"Bala",
"lastName":"K",
"mobile":"1234567890",
"email":"bala@gmail.com",
"address":"Pune",
"department":"Admin"
}
 

Postman Request for GetEmployee

 

Postman Request for UpdateEmployee

 

Postman Request for DeleteEmployee

 

Questions/Articles related to Spring Boot Rest API example

Difference Between @ComponentScan and @EnableAutoConfiguration in Spring Boot
Spring Boot command line runner Example
Run Spring Boot App Without Web a Server
Spring Cloud AWS – S3 upload/download Examples
Spring Boot Custom Banner

In this article, we have seen Spring Boot rest API with Example. All source code in the article can be found in the GitHub repository.