Table of Contents
1. Overview
This article contains spring boot restful web services with JPA example. We have used MySQL as a database in this example. Spring boot is the first choice to develop Rest Service with JSON. Spring boot makes fast development using easy configuration with minimum requirements. Nowadays Rest API development is very popular because of microservice architecture application development. We have explained this example with different layers like Controller, Service, and Data Access Object layers which are best practice to write API or web application.
2. Example
This example contains Rest Web service CRUD operation with JPA MySQL database. An example is a consist of Controllers which will handle all HTTP request, Service layer will help us to write business logic and DAO or Repository which will communicate with the database and persistence of data. In this example, we have used MySQL as a database.
Spring boot restful web services with JPA example
2.1 pom.xml
spring-boot-starter-data-jpaused for spring boot JPA support.mysql-connector-javaused for the MySQL connection, we may replace any other database connection drivers to change any other database like Postgres, Oracle or any other JPA supported database.
<?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>spring-boot-example</groupId>
<artifactId>spring-boot-hibernate-example</artifactId>
<version>1.0-SNAPSHOT</version>
<description>Spring boot restful web services with JPA example</description>
<!-- Inherit defaults from Spring Boot -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.4.RELEASE</version>
</parent>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
</dependencies>
<!-- Package as an executable jar -->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>2.2 application.properties
spring.datasource.*is data source related properties.spring.jpa.*is JPA related properties.
spring.datasource.url=jdbc:mysql://localhost/demo_database spring.datasource.username=root spring.datasource.password= spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.jpa.show-sql=true spring.jpa.hibernate.ddl-auto=update # Naming strategy spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl # Allows Hibernate to generate SQL optimized for a particular DBMS spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
2.3 SpringBootConfig
package com.javadeveloperzone;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
/**
* Created by Java Developer Zone on 19-07-2017.
*/
@SpringBootApplication
@ComponentScan
// Using a root package also allows the @ComponentScan annotation to be used without needing to specify a basePackage attribute
public class SpringBootConfig {
public static void main(String[] args) throws Exception {
SpringApplication.run(SpringBootConfig.class, args); // it wil start application
}
}
2.4 EmployeeController
@RestControllerwill generate a response in JSON format.@RestControlleris a combination of@Controller+@ResponseBody.@RequestMappingwill handle the specific request, value contains URL path, a method can be GET, POST, DELETE or any other method will is supported by HTTP.- While return
List<Employee>or onlyEmployeeobject then spring boot automatically convert toJSON ArrayandJSONrespectively so we do not worry about to convert objects to JSON which will be managed by spring boot.
package com.javadeveloperzone.controller;
import com.javadeveloperzone.model.Employee;
import com.javadeveloperzone.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* Created by JavaDeveloperZone on 19-07-2017.
*/
@RestController // for rest response
public class EmployeeController {
@Autowired
private EmployeeService employeeService;
// to add new employee
@RequestMapping(value = "save",method = RequestMethod.POST) // or user @PostMapping
public Employee save(Employee employee){
return employeeService.save(employee);
}
// list of all employee
@RequestMapping(value = "listEmployee",method = RequestMethod.GET) // or use @GetMapping
public java.util.List<Employee> listEmployee() {
return employeeService.findAll();
}
// delete specific employee using employee id
@RequestMapping(value = "delete", method = RequestMethod.DELETE) // or use @DeleteMapping
public void delete(@RequestParam("id")long id){
employeeService.delete(id);
}
// search employee start with name
@RequestMapping(value = "startWithName/{name}")
public java.util.List<Employee> findByName(@PathVariable("name")String name){
return employeeService.findEmployeeByEmployeeNameStartingWith(name);
}
// search employee by role
@RequestMapping(value = "findByRole/{role}")
public java.util.List<Employee> findByRole(@PathVariable("role")String role){
return employeeService.findEmployeeByEmployeeRole(role);
}
}
2.5 EmployeeService
Here is the only signature of EmployeService so at time of Autowire spring boot will create Reference to Interface and Object of it’s implementation.
package com.javadeveloperzone.service;
import com.javadeveloperzone.model.Employee;
import java.util.List;
/**
* Created by Lenovo on 04-04-2018.
*/
public interface EmployeeService {
List<Employee> findEmployeeByEmployeeNameStartingWith(String name); // fetch list of Employee which start with
List<Employee> findEmployeeByEmployeeRole(String role); // fetch Employee by role
List<Employee> findAll();
Employee save(Employee employee);
void delete(long employeeId);
}
2.6 EmployeeServiceImpl
Here is actually an implementation of EmployeeService interface, We are just performing CRUD operation so we do not have too much logic for business but we need to write actually business logic over here.
package com.javadeveloperzone.service;
import com.javadeveloperzone.dao.EmployeeDAO;
import com.javadeveloperzone.model.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* Created by Lenovo on 04-04-2018.
*/
@Service
public class EmployeeServiceImpl implements EmployeeService {
@Autowired
private EmployeeDAO employeeDAO;
@Override
public List<Employee> findAll() {
return employeeDAO.findAll();
}
@Override
public List<Employee> findEmployeeByEmployeeNameStartingWith(String name) {
return employeeDAO.findEmployeeByEmployeeNameStartingWith(name);
}
@Override
public List<Employee> findEmployeeByEmployeeRole(String role) {
return employeeDAO.findEmployeeByEmployeeRole(role);
}
@Override
public void delete(long employeeId) {
Employee employee = employeeDAO.findOne(employeeId);
employeeDAO.delete(employee);
}
@Override
public Employee save(Employee employee) {
return employeeDAO.save(employee);
}
}
2.7 EmployeeDAO
Here is Data Access Object, It will communicate with database and convert SQL query result to POJO Class or Model Class. Please note that EmployeDAO is an interface, Then we should have one question how a query will be generated:
- Spring boot automatically generate a query from method name here is
findAllquery will be “SELECT * FROM EMPLOYEE“findEmployeeByEmployeeRolequery will be “SELECT * FROM EMPLOYEE WHERE EMPLOYEE_ROLE =: ROLE“
- So spring JPA will generate a query based on the method name but spring boot JPA provides some standard for the method name. We can also write the custom query to fetch data. Here is more details explanation about spring boot JPA custom query
package com.javadeveloperzone.dao;
import com.javadeveloperzone.model.Employee;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* Created by Java Developer Zone on 03-08-2017.
*/
@Repository
@Transactional
public interface EmployeeDAO extends CrudRepository<Employee,Long> {
List<Employee> findEmployeeByEmployeeNameStartingWith(String name); // fetch list of Employee which start with
List<Employee> findEmployeeByEmployeeRole(String role); // fetch Employee by role
List<Employee> findAll(); // fetch all Employee
}
2.8 Employee
package com.javadeveloperzone.model;
import javax.persistence.*;
/**
* Created by Java Developer Zone on 03-08-2017.
*/
@Entity
@Table(name = "employee")
public class Employee {
@Id // primary key
@GeneratedValue(strategy = GenerationType.IDENTITY) // auto increment
@Column(name = "employeeId")
private long employeeId;
@Column(name = "employeeName")
private String employeeName;
@Column(name = "employeeRole")
private String employeeRole;
public long getEmployeeId() {
return employeeId;
}
public void setEmployeeId(long employeeId) {
this.employeeId = employeeId;
}
public String getEmployeeRole() {
return employeeRole;
}
public void setEmployeeRole(String employeeRole) {
this.employeeRole = employeeRole;
}
public String getEmployeeName() {
return employeeName;
}
public void setEmployeeName(String employeeName) {
this.employeeName = employeeName;
}
}
2.9 Build Application
mvn spring-boot:run
Console log
. ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v1.5.4.RELEASE) 2018-04-04 23:49:05.541 INFO 44300 --- [ main] com.javadeveloperzone.SpringBootConfig : Starting 2018-04-04 23:49:17.174 INFO 44300 --- [ main] o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup 2018-04-04 23:49:17.336 INFO 44300 --- [ main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http) 2018-04-04 23:49:17.367 INFO 44300 --- [ main] com.javadeveloperzone.SpringBootConfig : Started SpringBootConfig in 12.552 seconds (JVM running for 25.492)
2.10 Output
1. Add or Save Employee localhost:8080/save with FORM data.
Spring boot Restful web services with JPA example – add employee
2. list or fetch all Employee. localhost:8080/listEmployee
Spring boot Restful web services with JPA example – Fetch All Employee
3. Delete Employee using localhost:8080/delete?id=18
Spring boot Restful web services with JPA example – Delete Employee
3. Conclusion
In this article, We have learned that spring boot makes our ways easy to build Rest JSON or XML based web services. We have used postman tool to call JSON services. The code has been written in multiple layers so we can reuse of code and easy to understand for other developers also. We can also secure our web services, here is an example of how to secure web services
4. References
5. Source Code
Was this post helpful?
Let us know if you liked the post. That’s the only way we can improve.
