{"id":36,"date":"2020-09-13T10:54:48","date_gmt":"2020-09-13T10:54:48","guid":{"rendered":"http:\/\/localhost\/?p=36"},"modified":"2020-10-03T10:38:47","modified_gmt":"2020-10-03T10:38:47","slug":"how-to-create-restful-api-with-springboot-2-spring-data-jpa-and-hibernate-with-mysql-as-database","status":"publish","type":"post","link":"https:\/\/ranjeshviswa.com\/?p=36","title":{"rendered":"Create a REST API with Spring Boot"},"content":{"rendered":"\r\n

Spring Boot is an open source Java -based framework, used to build stand-alone and production ready spring applications.<\/p>\r\n

In this article, we will show you how to build simple REST API from scratch using Spring Boot 2.2.9, Spring Data JPA\/Hibernate with MySQL as database.<\/p>\r\n

Requirement<\/h2>\r\n

We need to create a simple REST API\u00a0 to create, update, delete and get Users and its corresponding\u00a0 purchased Orders.<\/p>\r\n

Maven dependencies<\/h2>\r\n
<dependencies>
    <!--Web-Basic dependencies-->
    <dependency>
        <groupId>org.springframework.boot<\/groupId>
        <artifactId>spring-boot-starter-web<\/artifactId>
    <\/dependency>

    <!--Spring Data JPA-->
    <dependency>
        <groupId>org.springframework.boot<\/groupId>
        <artifactId>spring-boot-starter-data-jpa<\/artifactId>
    <\/dependency>

    <!--MYSQL -->
    <dependency>
        <groupId>mysql<\/groupId>
        <artifactId>mysql-connector-java<\/artifactId>
    <\/dependency>

    <!--Model mapper -->
    <dependency>
        <groupId>org.modelmapper<\/groupId>
        <artifactId>modelmapper<\/artifactId>
        <version>2.3.2<\/version>
    <\/dependency>

    <!--Spring Boot test-->
    <dependency>
        <groupId>org.springframework.boot<\/groupId>
        <artifactId>spring-boot-starter-test<\/artifactId>
        <scope>test<\/scope>
        <exclusions>
            <exclusion>
                <groupId>junit<\/groupId>
                <artifactId>junit<\/artifactId>
            <\/exclusion>
        <\/exclusions>
    <\/dependency>

    <!--Junit 5-->
    <dependency>
        <groupId>org.junit.jupiter<\/groupId>
        <artifactId>junit-jupiter-api<\/artifactId>
        <scope>test<\/scope>
    <\/dependency>
    <dependency>
        <groupId>org.junit.jupiter<\/groupId>
        <artifactId>junit-jupiter-engine<\/artifactId>
        <scope>test<\/scope>
    <\/dependency>

    <!-- In Memory database useful for unit testing-->
    <dependency>
        <groupId>com.h2database<\/groupId>
        <artifactId>h2<\/artifactId>
        <scope>test<\/scope>
    <\/dependency>

<\/dependencies><\/pre>\r\n
Three Layers of Rest Service<\/h2>\r\n
\"\"<\/h3>\r\n
Controller Layer<\/h3>\r\n
It is top most layer and it receives request from client and invokes service layer. The result from service layer is processed and response is sent back to client.<\/p>\r\n
Service Layer<\/h3>\r\n
It is middle layer and is called by Controller layer. It does business operation and calls lowermost data layer.<\/p>\r\n
Data \/ Persistence \/ Repository Layer<\/h3>\r\n
This layer does all interaction\u00a0 with underlying database.<\/p>\r\n
Create Data \/ Persistence \/ Repository Layer<\/h2>\r\n
Implementing persistence \/data layer in Spring is very simple and is two step process.<\/p>\r\n
1. Create Entity Class for User and Order<\/h3>\r\n
@Entity(name = \"users\")
public class User implements Serializable {

    private static final long serialVersionUID = -465L;

    @Id
    @GeneratedValue
    private Long id;

    @Column(nullable = false, length = 50)
    private String firstName;

    @Column(nullable = false, length = 50)
    private String lastName;

    @Column(nullable = false, length = 120)
    private String email;

    @Column(nullable = false, length = 50)
    private String firstLineOfAddress;

    @Column(length = 50)
    private String secondLineOfAddress;

    @Column(nullable = false, length = 50)
    private String town;

    @Column(nullable = false, length = 10)
    private String postCode;
    \/\/ Getters and Setters(Omitted for brevity)
}<\/pre>\r\n
@Entity(name = \"orders\")
public class Order implements Serializable {

    private static final long serialVersionUID = -466L;

    @Id
    @GeneratedValue
    private Long id;

    @Column(nullable = false, length = 120)
    private String description;

    @Column(nullable = false, length = 120)
    private long priceInPence;

    @Column(nullable = false)
    private boolean completedStatus = false;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = \"user_id\", nullable = false)
    @OnDelete(action = OnDeleteAction.CASCADE)
    @JsonIgnore
    private User user;
    \/\/ Getters and Setters(Omitted for brevity)
}<\/pre>\r\n
Above annotations are basically JPA annotations.
@Entity(name = \u201cusers\u201d)<\/strong><\/code>\u00a0<\/strong>tells that data contained in class will be stored in database table \u201cusers\u201d
@Column(nullable = false, length = 50)<\/strong><\/code>\u00a0Indicates column name used in database table. Length indicates permitted column length in table.
Nullable indicates if the column in table can be null or not. Because every user may not have second line of address, we made this field nullable
Domain objects are sometimes stored in http-session for caching\/optimisation purpose, hence making the object\u00a0Serializable<\/strong><\/code>\u00a0is a good practice.
serialVersionUID<\/strong><\/code>\u00a0<\/strong>is usually very big long number.<\/p>\r\n
@ManyToOne(fetch = FetchType.LAZY, optional = false)<\/strong><\/code>\u00a0indicates User to Order is many to one mapping, which means a user can have zero
or many orders. But one order can belong to one user only.
@JoinColumn(name = \u201cuser_id\u201d, nullable = false)<\/strong><\/code>\u00a0indicates Order table will have user_id column which will reference id of users table
@OnDelete(action = OnDeleteAction.CASCADE)<\/strong><\/code>\u00a0indicates that parent user row is deleted in users table, corresponding order row will also
be deleted in the orders table
@JsonIgnore<\/strong><\/code>\u00a0is used to hide the field, when order is serialised into json response body , which is sent to client. We don\u2019t want user details in
order response body<\/p>\r\n
2. Create Repository Interface for User and Order<\/h3>\r\n
@Repository
public interface UserRepository extends CrudRepository<User, Long> {
    Optional<User> findByEmail(String email);
}<\/pre>\r\n
@Repository
public interface OrderRepository extends CrudRepository<Order, Long> {
    Optional<Order> findByIdAndUserId(Long id, Long userId);
    List<Order> findAllByUser(User user);
}<\/pre>\r\n
Spring will automatically implement above interface.<\/p>\r\n
@Repository<\/strong><\/code> is Spring annotation to indicate that it is data layer.<\/p>\r\n
findByEmail<\/strong><\/code> finds User by its email field.<\/p>\r\n
findByIdAndUserId<\/strong><\/code>\u00a0<\/strong>returns order by OrderId and UserId<\/p>\r\n
findAllByUser<\/strong><\/code>\u00a0returns order by user<\/p>\r\n
Create Service Layer<\/h2>\r\n
It s good practice to implement service layer by \u201cprogramming to interface\u201d principle.<\/p>\r\n
Service Interface<\/h3>\r\n
public interface UserService {
    User createUser(User user);
    User updateUser(Long id, User user);
    User patchUpdateUser(Long id, User user);
    User getUserById(Long id);
    List<User> getUsers();
    void deleteUser(Long id);
}

<\/pre>\r\n
public interface OrderService {
    Order createOrder(Long userId, Order order);
    Order updateOrder(Long userId, Long orderId, Order order);
    Order patchUpdateOrder(Long userId, Long orderId, Order order);
    Order getOrder(Long userId, Long orderId);
    List<Order> getAllOrdersByUserId(Long userId);
    void deleteOrder(Long userId, Long orderId);
}<\/pre>\r\n
Service Implementation<\/h3>\r\n
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public User getUserById(Long id) {

        Optional<User> maybeUser = userRepository.findById(id);
        return maybeUser.orElseThrow(() -> new RuntimeException(\"User not found\"));
    }

    @Override
    public User createUser(User user) {

        userRepository.findByEmail(user.getEmail())
                .ifPresent(p -> {
                    throw new RuntimeException(\"User with email \" + p.getEmail() + \" already exists \");
                });
        return userRepository.save(user);

    }

    @Override
    public User updateUser(Long id, User user) {
        User userFound = userRepository.findById(id).orElseThrow(() -> new RuntimeException(\"User not found\"));

        userFound.setFirstName(user.getFirstName());
        userFound.setLastName(user.getLastName());
        userFound.setEmail(user.getEmail());
        userFound.setFirstLineOfAddress(user.getFirstLineOfAddress());
        userFound.setSecondLineOfAddress(user.getSecondLineOfAddress());
        userFound.setTown(user.getTown());
        userFound.setPostCode(user.getPostCode());

        return userRepository.save(userFound);
    }

    @Override
    public User patchUpdateUser(Long id, User user) {
        User userFound = userRepository.findById(id).orElseThrow(() -> new RuntimeException(\"User not found\"));

        ModelMapper modelMapper = new ModelMapper();
        \/\/copy only non null values
        modelMapper.getConfiguration().setSkipNullEnabled(true).setMatchingStrategy(MatchingStrategies.STRICT);

        modelMapper.map(user, userFound);

        return userRepository.save(userFound);
    }

    @Override
    public void deleteUser(Long id) {
        User userFound = userRepository.findById(id).orElseThrow(() -> new RuntimeException(\"User not found\"));
        userRepository.delete(userFound);
    }

    @Override
    public List<User> getUsers() {
        Iterable<User> userIterable = userRepository.findAll();
        return StreamSupport.stream(userIterable.spliterator(), false)
                .collect(Collectors.toList());
    }
}<\/pre>\r\n
@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private UserRepository userRepository;

    @Override
    public Order createOrder(Long userId, Order order) {
        User user = userRepository.findById(userId)
                .orElseThrow(() -> new RuntimeException(\"User with id \" + userId + \" Not found\"));

        order.setUser(user);

        return orderRepository.save(order);
    }

    @Override
    public Order getOrder(Long userId, Long orderId) {

        return orderRepository.findByIdAndUserId(orderId, userId)
                .orElseThrow(() -> new RuntimeException(\"User with id \" + userId + \" and order id \" + orderId + \" Not found\"));
    }

    @Override
    public List<Order> getAllOrdersByUserId(Long userId) {

        User user = userRepository.findById(userId)
                .orElseThrow(() -> new RuntimeException(\"User with id \" + userId + \" Not found\"));

        return orderRepository.findAllByUser(user);

    }

    @Override
    public Order updateOrder(Long userId, Long orderId, Order order) {
        Order orderFound = orderRepository.findByIdAndUserId(orderId, userId)
                .orElseThrow(() -> new RuntimeException(\"User with id \" + userId + \" and order id \" + orderId + \" Not found\"));

        orderFound.setDescription(order.getDescription());
        orderFound.setPriceInPence(order.getPriceInPence());

        return orderRepository.save(orderFound);
    }

    @Override
    public Order patchUpdateOrder(Long userId, Long orderId, Order order) {

        Order orderFound = orderRepository.findByIdAndUserId(orderId, userId)
                .orElseThrow(() -> new RuntimeException(\"User with id \" + userId + \" and order id \" + orderId + \" Not found\"));

        if (order.getDescription() != null)
            orderFound.setDescription(order.getDescription());

        if (order.getPriceInPence() != 0)
            orderFound.setPriceInPence(order.getPriceInPence());

        return orderRepository.save(orderFound);

    }

    @Override
    public void deleteOrder(Long userId, Long orderId) {
        Order order = orderRepository.findByIdAndUserId(orderId, userId)
                .orElseThrow(() -> new RuntimeException(\"User with id \" + userId + \" and order id \" + orderId + \" Not found\"));
        orderRepository.delete(order);
    }
}<\/pre>\r\n
Create Controller Layer<\/h2>\r\n
User Controller<\/h3>\r\n
@RestController
@RequestMapping(\"\/api\/users\")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping(\"\/{id}\")
    public User getUser(@PathVariable Long id) {

        return userService.getUserById(id);
    }

    @GetMapping()
    public List<User> getAllUsers() {
        return userService.getUsers();
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User createdUser = userService.createUser(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(createdUser);
    }

    @PutMapping(\"\/{id}\")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.updateUser(id, user);
    }

    @PatchMapping(\"\/{id}\")
    public User patchUpdateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.patchUpdateUser(id, user);
    }

    @DeleteMapping(\"\/{id}\")
    public ResponseEntity<?> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
    }

}<\/pre>\r\n
Order Controller<\/h3>\r\n
@RestController
@RequestMapping(\"\/api\/users\")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping(\"\/{userId}\/orders\")
    public ResponseEntity<Order> createOrder(@PathVariable Long userId, @RequestBody Order order) {

        Order createdOrder = orderService.createOrder(userId, order);
        return ResponseEntity.status(HttpStatus.CREATED).body(createdOrder);
    }

    @GetMapping(\"\/{userId}\/orders\/{orderId}\")
    public Order getOrder(@PathVariable Long userId, @PathVariable Long orderId) {

        return orderService.getOrder(userId, orderId);
    }

    @PutMapping(\"\/{userId}\/orders\/{orderId}\")
    public Order updateOrder(@PathVariable Long userId, @PathVariable Long orderId, @RequestBody Order order) {
        return orderService.updateOrder(userId, orderId, order);
    }

    @PatchMapping(\"\/{userId}\/orders\/{orderId}\")
    public Order patchUpdateOrder(@PathVariable Long userId, @PathVariable Long orderId, @RequestBody Order order) {
        return orderService.patchUpdateOrder(userId, orderId, order);
    }

    @GetMapping(\"\/{userId}\/orders\")
    public List<Order> getAllOrders(@PathVariable Long userId) {
        return orderService.getAllOrdersByUserId(userId);
    }

    @DeleteMapping(\"\/{userId}\/orders\/{orderId}\")
    public ResponseEntity<?> deleteOrder(@PathVariable Long userId, @PathVariable Long orderId) {
        orderService.deleteOrder(userId, orderId);
        return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
    }
}<\/pre>\r\n
Build and Run application<\/h2>\r\n
mvn spring-boot:run<\/pre>\r\n
Test API manually\u00a0<\/h2>\r\n
We can test REST API manually with Postman . Following shows sample request and responses for various operations<\/p>\r\n
Post User<\/h3>\r\n
http:\/\/localhost:8080\/api\/users<\/p>\r\n
Request Body<\/p>\r\n
{
   \"firstName\":\"Steve\",
   \"lastName\":\"Rob\",
   \"email\":\"steverob@test.com\",
   \"firstLineOfAddress\":\"111 Pinewood Grove\",
   \"secondLineOfAddress\":\"Commercial street\",
   \"town\":\"London\",
   \"postCode\":\"W7 8AG\"
}<\/pre>\r\n
Response<\/p>\r\n

{
   \"id\": 44,
   \"firstName\":\"Steve\",
   \"lastName\":\"Rob\",
   \"email\":\"steverob@test.com\",
   \"firstLineOfAddress\":\"111 Pinewood Grove\",
   \"secondLineOfAddress\":\"Commercial street\",
   \"town\":\"London\",
   \"postCode\":\"W7 8AG\"
}<\/pre>\r\n
Get User<\/h3>\r\n
http:\/\/localhost:8080\/api\/users\/44<\/p>\r\n
Response<\/p>\r\n
{
   \"id\": 44,
   \"firstName\":\"Steve\",
   \"lastName\":\"Rob\",
   \"email\":\"steverob@test.com\",
   \"firstLineOfAddress\":\"111 Pinewood Grove\",
   \"secondLineOfAddress\":\"Commercial street\",
   \"town\":\"London\",
   \"postCode\":\"W7 8AG\"
}<\/pre>\r\n
Put User<\/h3>\r\n
http:\/\/localhost:8080\/api\/users\/44<\/p>\r\n
Request Body<\/p>\r\n
{
   \"firstName\":\"Steveupdated\",
   \"lastName\":\"Robupdated\",
   \"email\":\"steverob@test.com\",
   \"firstLineOfAddress\":\"111 Pinewood Grove\",
   \"secondLineOfAddress\":\"Commercial street\",
   \"town\":\"London\",
   \"postCode\":\"W7 8AG\"
}<\/pre>\r\n
Response<\/p>\r\n
{
   \"id\": 44<\/strong>,
   \"firstName\":\"Steveupdated\",
   \"lastName\":\"Robupdated\",
   \"email\":\"steverob@test.com\",
   \"firstLineOfAddress\":\"111 Pinewood Grove\",
   \"secondLineOfAddress\":\"Commercial street\",
   \"town\":\"London\",
   \"postCode\":\"W7 8AG\"
}<\/pre>\r\n
Patch User<\/h3>\r\n
http:\/\/localhost:8080\/api\/users\/44<\/p>\r\n
Request Body<\/p>\r\n
{
   \"firstName\":\"SteveupdatedAgain\",
   \"lastName\":\"RobupdatedAgain\"
}<\/pre>\r\n
Response<\/p>\r\n
{
   \"id\": 44<\/strong>,
   \"firstName\":\"SteveupdatedAgain\",
   \"lastName\":\"RobupdatedAgain\",
   \"email\":\"steverob@test.com\",
   \"firstLineOfAddress\":\"111 Pinewood Grove\",
   \"secondLineOfAddress\":\"Commercial street\",
   \"town\":\"London\",
   \"postCode\":\"W7 8AG\"
}<\/pre>\r\n
Post Order<\/h3>\r\n
http:\/\/localhost:8080\/api\/api\/users\/44\/orders<\/p>\r\n
Request Body<\/p>\r\n
{
  \"description\":\"Awesome phone\",
  \"priceInPence\":1200<\/strong>,
  \"completedStatus\": false<\/strong>
}<\/pre>\r\n
Response<\/p>\r\n
{
<\/span>   \"id\": 45<\/strong>,
<\/span>   \"description\":\"Awesome phone\",
   \"priceInPence\":1200<\/strong>,
   \"completedStatus\": false<\/strong>
}<\/span><\/pre>\r\n
Get Order<\/h3>\r\n
http:\/\/localhost:8080\/api\/users\/44\/orders\/45<\/p>\r\n
Response<\/p>\r\n
{
<\/span>   \"id\": 45<\/strong>,
<\/span>   \"description\":\"Awesome phone\",
   \"priceInPence\":1200<\/strong>,
   \"completedStatus\": false<\/strong>
}
<\/span><\/pre>\r\n
Complete Source Code Location<\/span><\/h3>\r\n
https:\/\/github.com\/ranjesh1\/spring-boot2-rest-order-services.git<\/p>\r\n
Unit Tests<\/h2>\r\n
Creating unit tests are described in another post ‘Unit Testing with Spring Boot Application<\/a>‘<\/p>\r\n","protected":false},"excerpt":{"rendered":"
Spring Boot is an open source Java -based framework, used to build stand-alone and production ready spring applications. In this article, we will show you how to build simple REST API from scratch using Spring Boot 2.2.9, Spring Data JPA\/Hibernate with MySQL as database. Requirement We need to create a simple REST API\u00a0 to create, … <\/p>\n
Continue reading “Create a REST API with Spring Boot”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":38,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[2,8,3,4],"tags":[],"_links":{"self":[{"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=\/wp\/v2\/posts\/36"}],"collection":[{"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=36"}],"version-history":[{"count":22,"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=\/wp\/v2\/posts\/36\/revisions"}],"predecessor-version":[{"id":141,"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=\/wp\/v2\/posts\/36\/revisions\/141"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=\/wp\/v2\/media\/38"}],"wp:attachment":[{"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=36"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=36"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ranjeshviswa.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=36"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}