Forem: Tien Nguyen

Spring Data REST example

Tien Nguyen — Tue, 21 Nov 2023 04:38:26 +0000

In this tutorial, we're gonna build a Spring Data REST example in Spring Boot CRUD REST API with Maven that uses Spring Data JPA to interact with H2 database without having to manually implement controller and handling HTTP requests. You'll know:

How to configure Spring Data REST, JPA, Hibernate to work with Database
How to define Data Models and Repository interfaces
Way to use Spring Data JPA to interact with H2 Database
How to check CRUD operations with Postman

Spring Data REST

Purpose: Spring Data REST builds on top of Spring Data repositories and exposes them as RESTful services. It automates the process of exposing JPA repositories as RESTful endpoints.
Features:
- Automatic generation of RESTful APIs for Spring Data repositories.
- Supports CRUD operations over HTTP (GET, POST, PUT, DELETE) for entities.
- Follows HATEOAS (Hypermedia as the Engine of Application State) principles, providing discoverable APIs.
- Customization of endpoints and response formats.
Usage: Spring Data REST is used when you want to quickly expose your Spring Data JPA repositories as RESTful services without having to manually implement controllers and handling HTTP requests. It's useful for rapidly building APIs over your data model.

Spring Data REST example

We will build a Spring Boot Data REST example for a Tutorial application in that:

Each Tutorial has id, title, description, published status.
We can create, retrieve, update, delete Tutorials.
We have custom finder methods such as find by published status or by title.

These are REST APIs that we provide:

Methods	Urls	Actions
POST	/api/tutorials	create new Tutorial
GET	/api/tutorials	retrieve all Tutorials
GET	/api/tutorials/:id	retrieve a Tutorial by `:id`
PUT	/api/tutorials/:id	update a Tutorial by `:id`
DELETE	/api/tutorials/:id	delete a Tutorial by `:id`

We also have APIs for:

filtering all published/unpublished Tutorials:
GET /api/tutorials/search/findByPublished?published=[status]
filtering all Tutorials which title contains keyword
/api/tutorials/search/findByTitleContainingIgnoreCase?title=[keyword]

Technology

Java 17 / 11 / 8
Spring Boot 3 / 2 (with Spring Data REST, Spring Data JPA)
H2 Database
Maven

Project Structure

Let me explain it briefly.

– Tutorial data model class corresponds to entity and table tutorials.
– TutorialRepository is an interface that extends JpaRepository for CRUD methods and custom finder methods.
– Configuration for Spring Data REST, Datasource, JPA & Hibernate in application.properties.
– pom.xml contains dependencies for Spring Boot and H2.

We can improve the example by adding Comments for each Tutorial. It is the One-to-Many Relationship and I write a tutorial for this at:
Spring Boot One To Many example with JPA, Hibernate

Or add Tags with Many-to-Many Relationship:
Spring Boot Many to Many example with JPA, Hibernate

Create & Setup Spring Boot project

Use Spring web tool or your development tool (Spring Tool Suite, Eclipse, Intellij) to create a Spring Boot project.

Then open pom.xml and add these 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-data-rest</artifactId>
</dependency>

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Configure Spring Data REST, JPA, h2, Hibernate

Under src/main/resources folder, open application.properties and write these lines.



spring.data.rest.basePath=api

spring.h2.console.enabled=true
# default path: h2-console
spring.h2.console.path=/h2-ui

spring.datasource.url=jdbc:h2:file:./testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto= update

spring.data.rest.basePath: the root URI for Spring Data REST
spring.datasource.url: jdbc:h2:mem:[database-name] for In-memory database and jdbc:h2:file:[path/database-name] for disk-based database.
spring.datasource.username & spring.datasource.password properties are the same as your database installation.
Spring Boot uses Hibernate for JPA implementation, we configure H2Dialect for H2 Database
spring.jpa.hibernate.ddl-auto is used for database initialization. We set the value to update value so that a table will be created in the database automatically corresponding to defined data model. Any change to the model will also trigger an update to the table. For production, this property should be validate.
spring.h2.console.enabled=true tells the Spring to start H2 Database administration tool and you can access this tool on the browser: http://localhost:8080/h2-console.
spring.h2.console.path=/h2-ui is for H2 console's url, so the default url http://localhost:8080/h2-console will change to http://localhost:8080/h2-ui.

You can also alter the following Spring Data REST properties (starting with spring.data.rest.):

defaultPageSize: change the default for the number of items served in a single page.
maxPageSize: change the maximum number of items in a single page.
pageParamName: change the name of the query parameter for selecting pages.
limitParamName: change the name of the query parameter for the number of items to show in a page.
sortParamName: change the name of the query parameter for sorting.
defaultMediaType: change the default media type to use when none is specified.
returnBodyOnCreate: change whether a body should be returned when creating a new entity.
returnBodyOnUpdate: change whether a body should be returned when updating an entity.

Define Data Model

Our Data model is Tutorial with four fields: id, title, description, published.
In model package, we define Tutorial class.

model/Tutorial.java



package com.bezkoder.spring.data.rest.model;

import jakarta.persistence.*;

@Entity
@Table(name = "tutorials")
public class Tutorial {

  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private long id;

  @Column(name = "title")
  private String title;

  @Column(name = "description")
  private String description;

  @Column(name = "published")
  private boolean published;

  public Tutorial() {

  }

  public Tutorial(String title, String description, boolean published) {
    this.title = title;
    this.description = description;
    this.published = published;
  }

  // getters and setters...

}

@Entity annotation indicates that the class is a persistent Java class.
@Table annotation provides the table that maps this entity.
@Id annotation is for the primary key.
@GeneratedValue annotation is used to define generation strategy for the primary key. GenerationType.AUTO means Auto Increment field.
@Column annotation is used to define the column in database that maps annotated field.

Create Repository Interface

Let's create a repository to interact with Tutorials from the database.
In repository package, create TutorialRepository interface that extends JpaRepository.

repository/TutorialRepository.java



package com.bezkoder.spring.data.rest.repository;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;
import org.springframework.web.bind.annotation.CrossOrigin;

import com.bezkoder.spring.data.rest.model.Tutorial;

@RepositoryRestResource(path="tutorials")
public interface TutorialRepository extends JpaRepository<Tutorial, Long> {
  List<Tutorial> findByPublished(boolean published);

  List<Tutorial> findByTitleContainingIgnoreCase(String title);
}

To expose the repository as a RESTful resource, you annotate the repository interface with @RepositoryRestResource. This annotation allows you to customize the RESTful endpoints and behavior, and path defines the base URI path for the resource.

We also define custom finder methods:

findByPublished(): returns all Tutorials with published having value as input published.
findByTitleContaining(): returns all Tutorials which title contains input title.

The implementation is plugged in by Spring Data JPA automatically.

More Derived queries at:
JPA Repository query example in Spring Boot

Custom query with @Query annotation:
Spring JPA @Query example: Custom query in Spring Boot

You can modify this Repository:

to work with Pagination, the instruction can be found at: Spring Boot Pagination & Filter example | Spring JPA, Pageable
or to sort/order by multiple fields with the tutorial: Spring Data JPA Sort/Order by multiple Columns | Spring Boot

You also find way to write Unit Test for this JPA Repository at:
Spring Boot Unit Test for JPA Repository with @DataJpaTest

Configure CORS in Spring Data REST

We add a @CrossOrigin annotation to the repository interface to enable CORS for the whole TutorialRepository repository.

By default, @CrossOrigin allows all origins and HTTP methods.

repository/TutorialRepository.java



// ...
import org.springframework.web.bind.annotation.CrossOrigin;

@CrossOrigin
@RepositoryRestResource(path="tutorials")
public interface TutorialRepository extends JpaRepository<Tutorial, Long> {
  // ...
}

We can provide one origin, restricted to several HTTP methods with a specific max age.



@CrossOrigin(origins = "http://yourdomain.example",
  methods = { RequestMethod.GET, RequestMethod.POST, RequestMethod.DELETE },
  maxAge = 3600)
@RepositoryRestResource(path="tutorials")
public interface TutorialRepository extends JpaRepository<Tutorial, Long> {
  // ...
}

Run & Test

Run Spring Boot application with command: mvn spring-boot:run.

tutorials table will be automatically generated in Database.

Let's open H2 console with url: http://localhost:8080/h2-ui:

For In-memory database:

For on Disk database:

Click on Connect button, then check H2 database, you can see things like this:

Create some Tutorials:

Retrieve all Tutorials:

Retrieve a Tutorial by Id:

Update some Tutorials:

The table data is changed:

Spring Data REST to filter all published Tutorials:

Find all Tutorials which title contains string 'data':

Delete a Tutorial:

Check database and it has been already deleted.

Conclusion

Today we've built a Spring Boot Rest CRUD API using Spring Data REST example and make Spring Data JPA work with H2 Database.

We also see that JpaRepository supports a great way to make CRUD operations and custom finder methods without need of boilerplate code.

Happy learning! See you again.

Source Code

You can find the complete source code for this tutorial on Github.

With Rest Controller: Spring Boot JPA + H2 example: Build a CRUD Rest APIs
Or APIs with GraphQL:Spring Boot + GraphQL example

More JPA queries at:

Validation:
Validate Request Body in Spring Boot

Reactive with R2DBC:
Spring Boot R2DBC + H2 example

Documentation: Spring Boot + Swagger 3 example (with OpenAPI 3)
Caching: Spring Boot Redis Cache example

Spring Boot + GraphQL example

Tien Nguyen — Wed, 15 Nov 2023 03:32:28 +0000

GraphQL is a query language that offers an alternative model to developing APIs (REST, SOAP or gRPC) with detailed description.

In this tutorial, we're gonna build a Spring Boot GraphQL example with H2 database that will expose CRUD APIs to create, read, update and delete objects with the help of graphql-spring-boot-starter and Spring Data JPA.

Overview

We have two data models: Author and Tutorial.

Author {
  id: Long
  name: String
  age: Integer
}

Tutorial {
  id: Long
  title: String
  description: String
  author: Author
}

One Author will have many Tutorials, so it is One-to-Many relationship.

The goal of this example is to build a GraphQL APIs to do CRUD operations with H2 database using only one endpoint: /apis/graphql.

The Spring Boot GraphQL Starter will make GraphQL server running in a short time.

CRUD GraphQL APIs

Create an Author: GraphQL

mutation {
  createAuthor(
    name: "bezkoder",
    age: 27) {
      id name
  }
}

Response

{
  "data": {
    "createAuthor": {
      "id": "1",
      "name": "bezkoder"
    }
  }
}

Create a Tutorial: GraphQL: we want response including Tutorial id, title and author (name)

mutation {
  createTutorial (
    title: "Tutorial #1",
    description: "Description for Tut#1"
    author: 1)
    {
      id title author { name }
    }
}

Response

{
  "data": {
    "createTutorial": {
      "id": "1",
      "title": "Tutorial #1",
      "author": {
        "name": "bezkoder"
      }
    }
  }
}

Read all Authors: GraphQL

{
  findAllAuthors{
    id
    name
    age
  }
}

Response

{
  "data": {
    "findAllAuthors": [
      {
        "id": "1",
        "name": "bezkoder",
        "age": 27
      },
      {
        "id": "2",
        "name": "zKoder",
        "age": 30
      }
    ]
  }
}

Read all Tutorials: GraphQL

{
  findAllTutorials{
    id
    title
    description
    author{
      id
      name
    }
  }
}

Response

{
  "data": {
    "findAllTutorials": [
      {
        "id": "1",
        "title": "Tutorial #1",
        "description": "Description for Tut#1",
        "author": {
          "id": "1",
          "name": "bezkoder"
        }
      },
      {
        "id": "2",
        "title": "Tutorial #2",
        "description": "Description for Tut#2",
        "author": {
          "id": "1",
          "name": "bezkoder"
        }
      },
      {
        "id": "3",
        "title": "Tutorial #3",
        "description": "Description for Tut#3",
        "author": {
          "id": "2",
          "name": "zKoder"
        }
      }
    ]
  }
}

Update a Tutorial: GraphQL

mutation {
  updateTutorial (
    id: 2
    description: "updated Desc Tut#2")
    {
      id title description author { name }
    }
}

Response

{
  "data": {
    "updateTutorial": {
      "id": "2",
      "title": "Tutorial #2",
      "description": "updated Desc Tut#2",
      "author": {
        "name": "bezkoder"
      }
    }
  }
}

Delete a Tutorial: GraphQL

mutation {
  deleteTutorial(id: 1)
}

Response

{
  "data": {
    "deleteTutorial": true
  }
}

Count number of Tutorials: GraphQL

{
  countTutorials
}

Response

{
  "data": {
    "countTutorials": 2
  }
}

If you check H2 database, it will have 2 tables: author and tutorial.
The content inside these tables looks like:

Step by step to build Spring Boot GraphQL example

Technology

Our Spring Boot application will use:

Java 17 / 11 / 8
Spring Boot 3 / 2 (with Spring Web, Spring Data JPA)
graphql-spring-boot-starter 15.0.0
graphql-java-tools 5.2.4
Maven 3.6.1
H2 database

Project Structure

This is folders & files structure for our Spring Boot + GraphQL application:

resources/graphql contains .graphqls files that define GraphQL chemas.
model holds two Entities: Author and Tutorial.
repository contains Repository interfaces to interact with H2 database.
resolver resolves values for query & mutation requests by implementing some Resolver interfaces from GraphQL Java Tools.
application.properties configures Spring Datasource, Spring Data JPA and GraphQL base Url.
pom.xml includes dependencies for the whole project.

Set up the project

Create new Spring Boot project using Spring Tool Suite or going to https://start.spring.io/.

Then add these dependencies to pom.xml file:

<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>com.graphql-java-kickstart</groupId>
    <artifactId>graphql-spring-boot-starter</artifactId>
    <version>15.0.0</version>
</dependency>

<dependency>
    <groupId>com.graphql-java</groupId>
    <artifactId>graphql-java-tools</artifactId>
    <version>5.2.4</version>
</dependency>

<dependency>
    <groupId>com.graphql-java</groupId>
    <artifactId>graphql-java-extended-scalars</artifactId>
    <version>21.0</version>
</dependency>

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Configure Spring Datasource, JPA, GraphQL

Open application.properties and add the following configuration.

spring.h2.console.enabled=true
# default path: h2-console
spring.h2.console.path=/h2-ui

spring.datasource.url=jdbc:h2:file:./testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto= update

# Graphql
graphql.servlet.mapping: /apis/graphql

spring.datasource.url: jdbc:h2:mem:[database-name] for In-memory database and jdbc:h2:file:[path/database-name] for disk-based database.
We configure H2Dialect for H2 Database
spring.h2.console.enabled=true tells the Spring to start H2 Database administration tool and you can access this tool on the browser: http://localhost:8080/h2-console.
spring.h2.console.path=/h2-ui is for H2 console's url, so the default url http://localhost:8080/h2-console will change to http://localhost:8080/h2-ui.

By default, Spring Boot GraphQL starter exposes the GraphQL Service on /graphql endpoint for HTTP POST requests containing the GraphQL payload. In the code above, we config the endpoint with new base url: /apis/graphql.

Extend Scalars for graphql-java Long type

The implementation of GraphQL Java doesn't provide a Long scalar type by default. So we need to use the graphql-java-extended-scalars package that provides a GraphQLLong scalar type definition which represents java.lang.Long.

Open SpringBootGraphqlApplication.java and add a Bean named extendedScalarLong():

@SpringBootApplication
public class SpringBootGraphqlApplication {
  // ...

  @Bean
  public graphql.schema.GraphQLScalarType extendedScalarLong() {
    return graphql.scalars.ExtendedScalars.GraphQLLong;
  }
}

Create GraphQL Schema

We're gonna split up your schema into two .graphqls files. The Spring Boot GraphQL starter will automatically find these schema files.

Under src/main/resources folder, create author.graphqls and tutorial.graphqls files.

author.graphqls

scalar Long

type Author {
    id: ID!
    name: String!
    age: Int
}

# Root
type Query {
    findAllAuthors: [Author]!
    countAuthors: Long!
}

# Root
type Mutation {
    createAuthor(name: String!, age: Int): Author!
}

GraphQL accepts only one root Query and one root Mutation types, so we need to bring all the query and mutation operations into the root Types. But in the schemas above, we want to split the logic for each model. How to do this? We extend the Query and Mutation types.

tutorial.graphqls

type Tutorial {
    id: ID!
    title: String!
    description: String
    author: Author
}

extend type Query {
    findAllTutorials: [Tutorial]!
    countTutorials: Long!
}

extend type Mutation {
    createTutorial(title: String!, description: String, author: ID!): Tutorial!
    updateTutorial(id: ID!, title: String, description: String): Tutorial!
    deleteTutorial(id: ID!): Boolean
}

The "!" at the end of some fields indicates non-nullable type. If we don't use it, GraphQL accepts null value in the response.

Define Data Models

Now we define twom main models with One-to-Many Relationship in model package:

Author: id, name, age
Tutorial: id, title, description, author_id

Author.java

package com.bezkoder.spring.graphql.model;

// import javax.persistence.*;
import jakarta.persistence.*; // for Spring Boot 3

@Entity
public class Author {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private Long id;

  @Column(name = "name", nullable = false)
  private String name;

  @Column(name = "age")
  private Integer age;

  public Author() {
  }

  public Author(Long id) {
    this.id = id;
  }

  public Author(String name, Integer age) {
    this.name = name;
    this.age = age;
  }

  public Long getId() {
    return id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Integer getAge() {
    return age;
  }

  public void setAge(Integer age) {
    this.age = age;
  }

  @Override
  public String toString() {
    return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
  }

}

Tutorial.java

package com.bezkoder.spring.graphql.model;

// import javax.persistence.*;
import jakarta.persistence.*; // for Spring Boot 3

@Entity
public class Tutorial {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private Long id;

  @Column(name = "title", nullable = false)
  private String title;

  @Column(name = "description")
  private String description;

  @ManyToOne
  @JoinColumn(name = "author_id", nullable = false, updatable = false)
  private Author author;

  public Tutorial() {
  }

  public Tutorial(String title, String description, Author author) {
    this.title = title;
    this.description = description;
    this.author = author;
  }

  public Long getId() {
    return id;
  }

  public String getTitle() {
    return title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public String getDescription() {
    return description;
  }

  public void setDescription(String description) {
    this.description = description;
  }

  public Author getAuthor() {
    return author;
  }

  public void setAuthor(Author author) {
    this.author = author;
  }

  @Override
  public String toString() {
    return "Tutorial [id=" + id + ", title=" + title + ", description=" + description + ", author=" + author + "]";
  }

}

Create Repositories

In repository package, create two interfaces that implement JpaRepository.

AuthorRepository.java

package com.bezkoder.spring.graphql.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import com.bezkoder.spring.graphql.model.Author;

public interface AuthorRepository extends JpaRepository<Author, Long> {

}

TutorialRepository.java

package com.bezkoder.spring.graphql.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import com.bezkoder.spring.graphql.model.Tutorial;

public interface TutorialRepository extends JpaRepository<Tutorial, Long> {

}

Once we extends the JpaRepository, Spring Data JPA will automatically generate implementation with find, save, delete, count methods for the entities.

Implement GraphQL Root Query Resolver

Every field in the schema root query should have a method in the Query Resolver class with the same name.

Now look back to the schemas we defined above.

# author.graphqls
type Query {
    findAllAuthors: [Author]!
    countAuthors: Long!
}

# tutorial.graphqls
extend type Query {
    findAllTutorials: [Tutorial]!
    countTutorials: Long!
}

This Query class implements GraphQLQueryResolver. We don't want to use GraphQLLong for countAuthors and countTutorials return type, so we alias it by using newAliasedScalar("Long").

resolver/Query.java

package com.bezkoder.spring.graphql.resolver;

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

import com.bezkoder.spring.graphql.model.Author;
import com.bezkoder.spring.graphql.model.Tutorial;
import com.bezkoder.spring.graphql.repository.AuthorRepository;
import com.bezkoder.spring.graphql.repository.TutorialRepository;
import graphql.kickstart.tools.GraphQLQueryResolver;
import graphql.scalars.ExtendedScalars;
import graphql.schema.GraphQLScalarType;

@Component
public class Query implements GraphQLQueryResolver {
  private AuthorRepository authorRepository;
  private TutorialRepository tutorialRepository;

  GraphQLScalarType longScalar = ExtendedScalars.newAliasedScalar("Long")
          .aliasedScalar(ExtendedScalars.GraphQLLong)
          .build();

  @Autowired
  public Query(AuthorRepository authorRepository, TutorialRepository tutorialRepository) {
    this.authorRepository = authorRepository;
    this.tutorialRepository = tutorialRepository;
  }

  public Iterable<Author> findAllAuthors() {
    return authorRepository.findAll();
  }

  public Iterable<Tutorial> findAllTutorials() {
    return tutorialRepository.findAll();
  }

  public long countAuthors() {
    return authorRepository.count();
  }

  public long countTutorials() {
    return tutorialRepository.count();
  }

}

Implement GraphQL Root Mutation Resolver

Mutation class will implement GraphQLMutationResolver.
Just like Query Resolver, every field in the schema mutation query should have a method in the Mutation Resolver class with the same name.

resolver/Mutation.java

package com.bezkoder.spring.graphql.resolver;

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

import com.bezkoder.spring.graphql.model.Author;
import com.bezkoder.spring.graphql.model.Tutorial;
import com.bezkoder.spring.graphql.repository.AuthorRepository;
import com.bezkoder.spring.graphql.repository.TutorialRepository;
import graphql.kickstart.tools.GraphQLMutationResolver;
import jakarta.persistence.EntityNotFoundException;

@Component
public class Mutation implements GraphQLMutationResolver {
  private AuthorRepository authorRepository;
  private TutorialRepository tutorialRepository;

  @Autowired
  public Mutation(AuthorRepository authorRepository, TutorialRepository tutorialRepository) {
    this.authorRepository = authorRepository;
    this.tutorialRepository = tutorialRepository;
  }

  public Author createAuthor(String name, Integer age) {
    Author author = new Author();
    author.setName(name);
    author.setAge(age);

    authorRepository.save(author);

    return author;
  }

  public Tutorial createTutorial(String title, String description, Long authorId) {
    Tutorial tutorial = new Tutorial();
    tutorial.setAuthor(new Author(authorId));
    tutorial.setTitle(title);
    tutorial.setDescription(description);

    tutorialRepository.save(tutorial);

    return tutorial;
  }

  public boolean deleteTutorial(Long id) {
    tutorialRepository.deleteById(id);
    return true;
  }

  public Tutorial updateTutorial(Long id, String title, String description) throws EntityNotFoundException {
    Optional<Tutorial> optTutorial = tutorialRepository.findById(id);

    if (optTutorial.isPresent()) {
      Tutorial tutorial = optTutorial.get();

      if (title != null)
        tutorial.setTitle(title);
      if (description != null)
        tutorial.setDescription(description);

      tutorialRepository.save(tutorial);
      return tutorial;
    }

    throw new EntityNotFoundException("Not found Tutorial to update!");
  }

}

Implement GraphQL Field Resolver

For complex fields like author in Tutorial, we have to resolve the value of those fields.
TutorialResolver implements GraphQLResolver interface and has getAuthor() method.

resolver/TutorialResolver.java

package com.bezkoder.spring.graphql.resolver;

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

import com.bezkoder.spring.graphql.model.Author;
import com.bezkoder.spring.graphql.model.Tutorial;
import com.bezkoder.spring.graphql.repository.AuthorRepository;
import graphql.kickstart.tools.GraphQLResolver;

@Component
public class TutorialResolver implements GraphQLResolver<Tutorial> {
  @Autowired
  private AuthorRepository authorRepository;

  public TutorialResolver(AuthorRepository authorRepository) {
    this.authorRepository = authorRepository;
  }

  public Author getAuthor(Tutorial tutorial) {
    return authorRepository.findById(tutorial.getAuthor().getId()).orElseThrow(null);
  }
}

If the client want to get a Tutorial without author field, the GraphQL Server will never do the work to retrieve it. So the getAuthor() method above will never be executed.

Run & Check result

Run Spring Boot application with command: mvn spring-boot:run

Tables will be automatically generated in Database.
If you check H2 database (by open browser with url: http://localhost:8080/h2-ui/):

Click on Connect button, and you can see them.

For checking result, you can use Postman to make HTTP POST request to http://localhost:8080/apis/graphql.

Conclusion

As an alternative approach to REST APIs, GraphQL minimize complexity between client & server.

Today we've learned how to use Spring Boot GraphQL Starter and the GraphQL Java Tools to build GraphQL Apis. Our Spring Boot project also can communicate with H2 database using Spring Data JPA.

Happy learning! See you again.

Source Code

You can find the complete source code for this tutorial on Github.

Other databases:

Security: Spring Boot Security: Login and Registration example with JWT
Unit Test: @DataJpaTest example for Spring Data Repository
Documentation: Spring Boot + Swagger 3 example (with OpenAPI 3)
Caching: Spring Boot Redis Cache example

Docker Compose: MongoDB and Spring Boot example

Tien Nguyen — Sat, 04 Nov 2023 02:27:51 +0000

Docker provides lightweight containers to run services in isolation from our infrastructure so we can deliver software quickly. In this tutorial, I will show you how to dockerize Spring Boot and MongoDB example using Docker Compose.

Overview

Assume that we have a Spring Boot Application working with MongoDB database.
The problem is to containerize a system that requires more than one Docker container:

Spring Boot for Rest API
MongoDB for database

Docker Compose helps us setup the system more easily and efficiently than with only Docker. We're gonna following these steps:

Create Spring Boot App working with MongoDB database.
Create Dockerfile for Spring Boot App.
Write Docker Compose configurations in YAML file.
Set Spring Boot Docker Compose Environment variables.
Run the system.

Directory Structure:

Create Spring Boot App

You can read and get Github source code from one of following tutorials:

Using the code base above, we put the Spring Boot project in bezkoder-app folder without the need of resources/application.properties. It is because Environment variables will be exported to .env file.

Create Dockerfile for Spring Boot App

Dockerfile defines a list of commands that Docker uses for setting up the Spring Boot application environment. So we put the file in bezkoder-app folder.

Because we will use Docker Compose, we won't define all the configuration commands in this Dockerfile.

bezkoder-app/Dockerfile

# FROM maven:3.8.2-jdk-8 # for Java 8
FROM maven:3.8.5-openjdk-17

WORKDIR /bezkoder-app
COPY . .
RUN mvn clean install

CMD mvn spring-boot:run

Let me explain some points:

FROM: install the image of the Maven - JDK version.
WORKDIR: path of the working directory.
COPY: copy all the files inside the project directory to the container.
RUN: execute a command-line inside the container: mvn clean install to install the dependencies in pom.xml.
CMD: run script mvn spring-boot:run after the image is built.

Write Docker Compose configurations

On the root of the project directory, we're gonna create the docker-compose.yml file. Follow version 3 syntax defined by Docker:

version: "3.8"

services:
  mongo_db:
    image: mongo:5.0.2
    restart: unless-stopped
    env_file: ./.env
    environment:
      - MONGO_INITDB_ROOT_USERNAME=$MONGODB_USER
      - MONGO_INITDB_ROOT_PASSWORD=$MONGODB_PASSWORD
    ports:
      - $MONGODB_LOCAL_PORT:$MONGODB_DOCKER_PORT
    volumes:
      - db:/data/db
  app:
    depends_on:
      - mongo_db
    build: ./bezkoder-app
    restart: on-failure
    env_file: ./.env
    ports:
      - $SPRING_LOCAL_PORT:$SPRING_DOCKER_PORT
    environment:
      SPRING_APPLICATION_JSON: '{
          "spring.data.mongodb.uri" : "mongodb://$MONGODB_USER:$MONGODB_PASSWORD@mongo_db:$MONGODB_DOCKER_PORT/$MONGODB_DATABASE?authSource=admin"
        }'
    volumes:
      - .m2:/root/.m2
    stdin_open: true
    tty: true

volumes:
  db:

mongo_db:
- image: official Docker image
- restart: configure the restart policy
- env_file: specify our .env path that we will create later
- environment: provide setting using environment variables
- ports: specify ports will be used
- volumes: map volume folders
app:
- depends_on: dependency order, mongo_db is started before app
- build: configuration options that are applied at build time that we defined in the Dockerfile with relative path
- environment: environmental variables that Spring Boot application uses
- stdin_open and tty: keep open the terminal after building container

You should note that the host port (LOCAL_PORT) and the container port (DOCKER_PORT) is different. Networked service-to-service communication uses the container port, and the outside uses the host port.

Docker Compose Environment variables

In the service configuration, we used environmental variables defined inside the .env file. Now we start writing it.

.env

MONGODB_USER=root
MONGODB_PASSWORD=123456
MONGODB_DATABASE=bezkoder_db
MONGODB_LOCAL_PORT=7017
MONGODB_DOCKER_PORT=27017

SPRING_LOCAL_PORT=6868
SPRING_DOCKER_PORT=8080

Run the Spring Boot microservice with Docker Compose

We can easily run the whole with only a single command:
docker compose up

Docker will pull the MongoDB and Maven images (if our machine does not have it before).

The services can be run on the background with command:
docker compose up -d

$ docker compose up -d
[+] Running 11/11
 ✔ mongodb 10 layers [⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿]      0B/0B      Pulled                                                                                                                                                    
   ✔ 35807b77a593 Pull complete                                                                                                                                                                                     
   ✔ 664b0ebdcc07 Pull complete                                                                                                                                                                    
   ✔ d598f4d3c081 Pull complete                                                                                                                                                                      
   ✔ 291455135b00 Pull complete                                                                                                                                                              
   ✔ b46409342f13 Pull complete                                                                                                                                                                      
   ✔ ff2b9c6e6f3a Pull complete                                                                                                                                                              
   ✔ 149f6335fc27 Pull complete                                                                                                                                                                    
   ✔ baeb6f3bec76 Pull complete                                                                                                                                                                        
   ✔ 8617caab2de5 Pull complete                                                                                                                                                                       
   ✔ 067d70de7828 Pull complete                                                                                                                                                             
[+] Building 87.9s (9/9) FINISHED                                                                                                                                                                               docker:default
 => [app internal] load .dockerignore                                                                                                                                                         
 => => transferring context: 2B                                                                                                                                                                        
 => [app internal] load build definition from Dockerfile                                                                                                                                                
 => => transferring dockerfile: 238B                                                                                                                                                        
 => [app internal] load metadata for docker.io/library/maven:3.8.5-openjdk-17                                                                                                                            
 => [app 1/4] FROM docker.io/library/maven:3.8.5-openjdk-17@sha256:3a9c30b3af6278a8ae0007d3a3bf00fff80ec3ed7ae4eb9bfa1772853101549b                                                                     
 => [app internal] load build context                                                                                                                                                                            
 => => transferring context: 31.57kB                                                                                                                                                             
 => CACHED [app 2/4] WORKDIR /bezkoder-app                                                                                                                                                           
 => [app 3/4] COPY . .                                                                                                                                                                         
 => [app 4/4] RUN mvn clean install                                                                                                                                                                  
 => [app] exporting to image                                                                                                                                                                                 
 => => exporting layers                                                                                                                                                                              
 => => writing image sha256:c2f10209e87c064f039545b2e6812c9c15a405120d595d7e1ff888bd3cce267f                                                                                                            
 => => naming to docker.io/library/spring-boot-mongodb-app                                                                                                                                          
[+] Running 4/4                                                                                                                                                                                                                
 ✔ Network spring-boot-mongodb_default      Created                                                                                                                                            
 ✔ Volume "spring-boot-mongodb_db"          Created                                                                                                                                                     
 ✔ Container spring-boot-mongodb-mongodb-1  Started                                                                                                                                                  
 ✔ Container spring-boot-mongodb-app-1      Started

Now you can check the current working containers:

$ docker ps
CONTAINER ID   IMAGE                     COMMAND                  CREATED         STATUS         PORTS                                         NAMES
88af893b2a53   spring-boot-mongodb-app   "/usr/local/bin/mvn-…"   2 minutes ago   Up 2 minutes   0.0.0.0:6868->8080/tcp, :::6868->8080/tcp     spring-boot-mongodb-app-1
4ef8f9734878   mongo:5.0.2               "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes   0.0.0.0:7017->27017/tcp, :::7017->27017/tcp   spring-boot-mongodb-mongodb-1

And Docker images:

$ docker images
REPOSITORY                 TAG       IMAGE ID       CREATED         SIZE
spring-boot-mongodb-app    latest    c2f10209e87c   2 minutes ago   912MB
mongo                      5.0.2     0bcbeb494bed   2 years ago     684MB

Send a HTTP request to the Spring Boot - MongoDB system:

Check MongoDB Database:

$ docker exec -ti spring-boot-mongodb-mongodb-1 /bin/bash
root@2d71784ae3a9:/# mongo -u root -p 123456 --authenticationDatabase admin
MongoDB shell version v5.0.2
connecting to: mongodb://127.0.0.1:27017/?authSource=admin&compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("742022a6-49ed-42dd-9a53-0fd156f234ec") }
MongoDB server version: 5.0.2

> show dbs
admin        0.000GB
bezkoder_db  0.000GB
config       0.000GB
local        0.000GB
> use bezkoder_db
switched to db bezkoder_db
> show collections
tutorials
> db.tutorials.find()
{ "_id" : ObjectId("6541dff55fa4083bdb3d0422"), "title" : "Docker Compose MongoDB Spring Boot", "description" : "Tut#1 Description", "published" : false, "_class" : "com.bezkoder.spring.data.mongodb.model.Tutorial" }

Stop the Application

Stopping all the running containers is also simple with a single command:
docker compose down

$ docker compose down
 ✔ Container spring-boot-mongodb-app-1       Removed
 ✔ Container spring-boot-mongodb-mongo_db-1  Removed
 ✔ Network spring-boot-mongodb_default       Removed

If you need to stop and remove all containers, networks, and all images used by any service in docker-compose.yml file, use the command:
docker compose down --rmi all

$ docker compose down --rmi all
[+] Running 5/5
 ✔ Container spring-boot-mongodb-app-1       Removed
 ✔ Container spring-boot-mongodb-mongo_db-1  Removed
 ✔ Image spring-boot-mongodb-app:latest      Removed
 ✔ Image mongo:5.0.2                         Removed
 ✔ Network spring-boot-mongodb_default       Removed

Conclusion

Today we've successfully created Docker Compose file for MongoDB and Spring Boot example. Now we can connect Spring Boot to MongoDB with Docker on a very simple way: docker-compose.yml.

You can apply this way to one of following project:

Happy Learning! See you again.

Source Code

The source code for this tutorial can be found at Github.

Documentation: Spring Boot + Swagger 3 example (with OpenAPI 3)
Caching: Spring Boot Redis Cache example

Dockerize Nodejs and Postgres example

Tien Nguyen — Thu, 19 Oct 2023 02:35:36 +0000

Docker provides lightweight containers to run services in isolation from our infrastructure so we can deliver software quickly. In this tutorial, I will show you how to dockerize Nodejs Express and Postgres example using Docker Compose.

Dockerizing Node.js and Postgres Overview

Assume that we have a Nodejs Application working with Postgres database.
The problem is to containerize a system that requires more than one Docker container:

Node.js Express for API
PostgreSQL for database

Docker Compose helps us setup the system more easily and efficiently than with only Docker. We're gonna following these steps:

Create Nodejs App working with Postgres database.
Create Dockerfile for Nodejs App.
Write Docker Compose configurations in YAML file.
Set Environment variables for Docker Compose
Run the system.

Directory Structure:

Create Nodejs App

You can read and get Github source code from one of following tutorials:

Using the code base above, we put the Nodejs project in bezkoder-app folder and modify some files to work with environment variables.

Firstly, let's add dotenv module into package.json.



{
  ...
  "dependencies": {
    "dotenv": "^10.0.0",
    ...
  }
}

Next we import dotenv in server.js and use process.env for setting port.



require("dotenv").config();
..
// set port, listen for requests
const PORT = process.env.NODE_DOCKER_PORT || 8080;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}.`);
});

Then we change modify database configuration and initialization.

app/config/db.config.js



module.exports = {
  HOST: process.env.DB_HOST,
  USER: process.env.DB_USER,
  PASSWORD: process.env.DB_PASSWORD,
  DB: process.env.DB_NAME,
  port: process.env.DB_PORT,
  dialect: "postgres",
  pool: {
    max: 5,
    min: 0,
    acquire: 30000,
    idle: 10000
  }
};

app/models/index.js



const dbConfig = require("../config/db.config.js");

const Sequelize = require("sequelize");
const sequelize = new Sequelize(dbConfig.DB, dbConfig.USER, dbConfig.PASSWORD, {
  host: dbConfig.HOST,
  dialect: dbConfig.dialect,
  port: dbConfig.port,
  operatorsAliases: false,

  pool: {
    max: dbConfig.pool.max,
    min: dbConfig.pool.min,
    acquire: dbConfig.pool.acquire,
    idle: dbConfig.pool.idle
  }
});

...

We also need to make a .env sample file that shows all necessary arguments.

bezkoder-app/.env.sample



DB_HOST=localhost
DB_USER=postgres
DB_PASSWORD=123456
DB_NAME=bezkoder_db
DB_PORT=5432

NODE_DOCKER_PORT=8080

Create Dockerfile for Nodejs App

Dockerfile defines a list of commands that Docker uses for setting up the Node.js application environment. So we put the file in bezkoder-app folder.

Because we will use Docker Compose, we won't define all the configuration commands in this Dockerfile.

bezkoder-app/Dockerfile



FROM node:14

WORKDIR /bezkoder-app
COPY package.json .
RUN npm install
COPY . .
CMD npm start

Let me explain some points:

FROM: install the image of the Node.js version.
WORKDIR: path of the working directory.
COPY: copy package.json file to the container, then the second one copies all the files inside the project directory.
RUN: execute a command-line inside the container: npm install to install the dependencies in package.json.
CMD: run script npm start after the image is built.

Write Docker Compose configurations

Let's make Nodejs connect with PostgreSQL using Docker.

On the root of the project directory, we're gonna create the docker-compose.yml file. Follow version 3 syntax defined by Docker:



version: '3.8'

services: 
    postgresdb:
    app:

volumes:

version: Docker Compose file format version will be used.
services: individual services in isolated containers. Our application has two services: app (Nodejs) and postgresdb (Postgres database).
volumes: named volumes that keeps our data alive after restart.

Let's implement the details.

docker-compose.yml



version: '3.8'

services:
  postgresdb:
    image: postgres
    restart: unless-stopped
    env_file: ./.env
    environment:
      - POSTGRES_USER=$POSTGRESDB_USER
      - POSTGRES_PASSWORD=$POSTGRESDB_ROOT_PASSWORD
      - POSTGRES_DB=$POSTGRESDB_DATABASE
    ports:
      - $POSTGRESDB_LOCAL_PORT:$POSTGRESDB_DOCKER_PORT
    volumes:
      - db:/var/lib/postgres
  app:
    depends_on:
      - postgresdb
    build: ./bezkoder-app
    restart: unless-stopped
    env_file: ./.env
    ports:
      - $NODE_LOCAL_PORT:$NODE_DOCKER_PORT
    environment:
      - DB_HOST=postgresdb
      - DB_USER=$POSTGRESDB_USER
      - DB_PASSWORD=$POSTGRESDB_ROOT_PASSWORD
      - DB_NAME=$POSTGRESDB_DATABASE
      - DB_PORT=$POSTGRESDB_DOCKER_PORT
    stdin_open: true
    tty: true

volumes: 
  db:

postgresdb:
- image: official Docker image
- restart: configure the restart policy
- env_file: specify our .env path that we will create later
- environment: provide setting using environment variables
- ports: specify ports will be used
- volumes: map volume folders
app:
- depends_on: dependency order, postgresdb is started before app
- build: configuration options that are applied at build time that we defined in the Dockerfile with relative path
- environment: environmental variables that Node application uses
- stdin_open and tty: keep open the terminal after building container

Docker Compose Environment variables with Postgres

In the service configuration, we used environmental variables defined inside the .env file. Now we start writing it.

.env



POSTGRESDB_USER=postgres
POSTGRESDB_ROOT_PASSWORD=123456
POSTGRESDB_DATABASE=bezkoder_db
POSTGRESDB_LOCAL_PORT=5433
POSTGRESDB_DOCKER_PORT=5432

NODE_LOCAL_PORT=6868
NODE_DOCKER_PORT=8080

Run Nodejs Postgres with Docker Compose

We can easily run the whole with only a single command:
docker compose up

Docker will pull the PostgreSQL and Node.js images (if our machine does not have it before).

The services can be run on the background with command:
docker compose up -d



$ docker compose up -d
[+] Running 14/14
 ✔ postgresdb 13 layers [⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿]      0B/0B      Pulled                                                                                                                                                              
   ✔ a378f10b3218 Pull complete                                                                                                                                                                                              
   ✔ 2ebc5690e391 Pull complete                                                                                                                                                                                              
   ✔ 8fe57f734687 Pull complete                                                                                                                                                                                              
   ✔ a2ddbb09cd9a Pull complete                                                                                                                                                                                             
   ✔ 5a2499e87ab8 Pull complete                                                                                                                                                                                             
   ✔ a45f5c4adf1b Pull complete                                                                                                                                                                                             
   ✔ 178017fd978e Pull complete                                                                                                                                                                                             
   ✔ 428dff1cb77d Pull complete                                                                                                                                                                                             
   ✔ 4667364adfc4 Pull complete                                                                                                                                                                                             
   ✔ 4eea1f5281a9 Pull complete                                                                                                                                                                                             
   ✔ 369467411787 Pull complete                                                                                                                                                                                             
   ✔ 51184495a2bc Pull complete                                                                                                                                                                                             
   ✔ d3e246f01410 Pull complete                                                                                                                                                                                             
[+] Building 77.4s (10/10) FINISHED                                                                                                                                                                                docker:default
 => [app internal] load build definition from Dockerfile                                                                                                                                                                     
 => => transferring dockerfile: 179B                                                                                                                                                                                         
 => [app internal] load .dockerignore                                                                                                                                                                                        
 => => transferring context: 2B                                                                                                                                                                                              
 => [app internal] load metadata for docker.io/library/node:14                                                                                                                                                              
 => [app 1/5] FROM docker.io/library/node:14@sha256:a158d3b9b4e3fa813fa6c8c590b8f0a860e015ad4e59bbce5744d2f6fd8461aa                                                                                                        
 => => resolve docker.io/library/node:14@sha256:a158d3b9b4e3fa813fa6c8c590b8f0a860e015ad4e59bbce5744d2f6fd8461aa                                                                                                             
 => => sha256:3d2201bd995cccf12851a50820de03d34a17011dcbb9ac9fdf3a50c952cbb131 10.00MB / 10.00MB                                                                                                                             
 => => sha256:2cafa3fbb0b6529ee4726b4f599ec27ee557ea3dea7019182323b3779959927f 2.21kB / 2.21kB                                                                                                                               ...
 => => extracting sha256:0c8cc2f24a4dcb64e602e086fc9446b0a541e8acd9ad72d2e90df3ba22f158b3                                                                                                                                    
 => => extracting sha256:0d27a8e861329007574c6766fba946d48e20d2c8e964e873de352603f22c4ceb                                                                                                                                    
 => [app internal] load build context                                                                                                                                                                                        
 => => transferring context: 17.47kB                                                                                                                                                                                         
 => [app 2/5] WORKDIR /bezkoder-app                                                                                                                                                                                          
 => [app 3/5] COPY package.json .                                                                                                                                                                                            
 => [app 4/5] RUN npm install                                                                                                                                                                                               
 => [app 5/5] COPY . .                                                                                                                                                                                                       
 => [app] exporting to image                                                                                                                                                                                                 
 => => exporting layers                                                                                                                                                                                                      
 => => writing image sha256:4571b91ea16b395b5e00833cc5770695f07250627ebceee1d5125660b93abd00                                                                                                                                 
 => => naming to docker.io/library/node-postgres-app                                                                                                                                                                         
[+] Running 4/4
 ✔ Network node-postgres_default         Created                                                                                                                                                                             
 ✔ Volume "node-postgres_db"             Created                                                                                                                                                                             
 ✔ Container node-postgres-postgresdb-1  Started                                                                                                                                                                             
 ✔ Container node-postgres-app-1         Started

Now you can check the current working containers:



$ docker ps
CONTAINER ID   IMAGE               COMMAND                  CREATED         STATUS         PORTS                                       NAMES
4b781fa774f6   node-postgres-app   "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes   0.0.0.0:6868->8080/tcp, :::6868->8080/tcp   node-postgres-app-1
d268e1be7e80   postgres            "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes   0.0.0.0:5433->5432/tcp, :::5433->5432/tcp   node-postgres-postgresdb-1

And Docker images:



$ docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
node-postgres-app     latest    4571b91ea16b   3 minutes ago   943MB
postgres              latest    f7d9a0d4223b   4 weeks ago     417MB

Send a HTTP request to the Nodejs - Postgres application:

Check Postgres Database:



$ docker exec -ti node-postgres-postgresdb-1 /bin/bash
root@eba893d13a10:/# psql bezkoder_db postgres
psql (16.0 (Debian 16.0-1.pgdg120+1))
Type "help" for help.

bezkoder_db=# SELECT * FROM tutorials;
 id |          title          |    description    | published |         createdAt          |         updatedAt          
----+-------------------------+-------------------+-----------+----------------------------+----------------------------
  1 | Docker Postgres Express | Tut#1 Description | f         | 2023-10-14 10:13:17.432+00 | 2023-10-14 10:13:17.432+00
(1 row)

Stop the Application

Stopping all the running containers is also simple with a single command:
docker compose down



$ docker compose down
 ✔ Container node-postgres-app-1         Removed                                                                                                                                                                  
 ✔ Container node-postgres-postgresdb-1  Removed                                                                                                                                                                   
 ✔ Network node-postgres_default         Removed

If you need to stop and remove all containers, networks, and all images used by any service in docker-compose.yml file, use the command:
docker compose down --rmi all

Conclusion

Today we've successfully created Docker Compose file for Postgres and Nodejs application. Now we can deploy Nodejs Express and Postgres with Docker on a very simple way: docker-compose.yml.

You can apply this way to one of following project:

Happy Learning! See you again.

Source Code

The source code for this tutorial can be found at Github.

If you want to add Comments for each Tutorial. It is the One-to-Many Relationship there is a tutorial:
Node.js Sequelize Associations: One-to-Many example
(the tutorial uses MySQL but you can easily change the configuration for PostgreSQL)

Or you can add Tags for each Tutorial and add Tutorials to Tag (Many-to-Many Relationship):
Node.js Sequelize Associations: Many-to-Many example

Global Exception Handler in Spring Boot

Tien Nguyen — Wed, 11 Oct 2023 03:23:00 +0000

In this tutorial, we're gonna look at an Spring Boot example that uses @ControllerAdvice and @ExceptionHandler for global exception handling in Spring Boot.

More Practice:

Unit Test:

Exception handling Problem

We've created Rest Controller for CRUD Operations and finder method.
Let look at the code:
(step by step to build the Rest APIs is in:



@RestController
public class TutorialController {

  @Autowired
  TutorialRepository tutorialRepository;

  @GetMapping("/tutorials")
  public ResponseEntity<List<Tutorial>> getAllTutorials(@RequestParam(required = false) String title) {
    try {
      ...
      return new ResponseEntity<>(tutorials, HttpStatus.OK);
    } catch (Exception e) {
      return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
    }
  }

  @GetMapping("/tutorials/{id}")
  public ResponseEntity<Tutorial> getTutorialById(@PathVariable("id") long id) {
    Optional<Tutorial> tutorialData = tutorialRepository.findById(id);

    if (tutorialData.isPresent()) {
      return new ResponseEntity<>(tutorialData.get(), HttpStatus.OK);
    } else {
      return new ResponseEntity<>(HttpStatus.NOT_FOUND);
    }
  }

  @PutMapping("/tutorials/{id}")
  public ResponseEntity<Tutorial> updateTutorial(@PathVariable("id") long id, @RequestBody Tutorial tutorial) {
    Optional<Tutorial> tutorialData = tutorialRepository.findById(id);

    if (tutorialData.isPresent()) {
      ...
      return new ResponseEntity<>(tutorialRepository.save(_tutorial), HttpStatus.OK);
    } else {
      return new ResponseEntity<>(HttpStatus.NOT_FOUND);
    }
  }

  ...

  @DeleteMapping("/tutorials/{id}")
  public ResponseEntity<HttpStatus> deleteTutorial(@PathVariable("id") long id) {
    try {
      tutorialRepository.deleteById(id);
      return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    } catch (Exception e) {
      return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
    }
  }

  @DeleteMapping("/tutorials")
  public ResponseEntity<HttpStatus> deleteAllTutorials() {
    // try and catch
  }

  @GetMapping("/tutorials/published")
  public ResponseEntity<List<Tutorial>> findByPublished() {
    // try and catch
  }
}

You can see that we use try/catch many times for similar exception (INTERNAL_SERVER_ERROR), and there are also many cases that return NOT_FOUND.

Is there any way to keep them simple, any way to attach the error response message smartly and flexibility?
Let's solve the problem now.

Exception Handler with Controller Advice in Spring

Spring supports exception handling by a global Exception Handler (@ExceptionHandler) with Controller Advice (@ControllerAdvice). This enables a mechanism that makes ResponseEntity work with the type safety and flexibility of @ExceptionHandler:



@ControllerAdvice
public class ControllerExceptionHandler {

  @ExceptionHandler(value = {ResourceNotFoundException.class, CertainException.class})
  public ResponseEntity<ErrorMessage> resourceNotFoundException(ResourceNotFoundException ex, WebRequest request) {
    ErrorMessage message = new ErrorMessage(
        status,
        date,
        ex.getMessage(),
        description);

    return new ResponseEntity<ErrorMessage>(message, HttpStatus.NOT_FOUND);
  }
}

The @ControllerAdvice annotation is specialization of @Component annotation so that it is auto-detected via classpath scanning. A Controller Advice is a kind of interceptor that surrounds the logic in our Controllers and allows us to apply some common logic to them.

Its methods (annotated with @ExceptionHandler) are shared globally across multiple @Controller components to capture exceptions and translate them to HTTP responses. The @ExceptionHandler annotation indicates which type of Exception we want to handle. The exception instance and the request will be injected via method arguments.

By using two annotations together, we can:

control the body of the response along with status code
handle several exceptions in the same method

@ResponseStatus

In the example above, we use @ControllerAdvice for REST web services and return ResponseEntity object additionally.

Spring also provides @ResponseBody annotation which tells a controller that the object returned is automatically serialized into JSON and passed it to the HttpResponse object. This way does not require ResponseEntity but you need to use @ResponseStatus to set the HTTP status code for that exception.



@ControllerAdvice
@ResponseBody
public class ControllerExceptionHandler {

  @ExceptionHandler(ResourceNotFoundException.class)
  @ResponseStatus(value = HttpStatus.NOT_FOUND)
  public ErrorMessage resourceNotFoundException(ResourceNotFoundException ex, WebRequest request) {
    ErrorMessage message = new ErrorMessage(...);
    return message;
  }
}

Setup Spring Boot Project

You can follow step by step, or get source code in one of following posts:

The Spring Project contains structure that we only need to add some changes to make the pagination work well.

Or you can get the new Github source code at the end of this tutorial.

The final project structure will be like this:

Define Error Response Message

We want to create a our own message response structure instead of using default error response provided by Spring Boot.
Let's define a specific error response structure.

exception/ErrorMessage.java



package com.bezkoder.spring.exhandling.exception;

import java.util.Date;

public class ErrorMessage {
  private int statusCode;
  private Date timestamp;
  private String message;
  private String description;

  public ErrorMessage(int statusCode, Date timestamp, String message, String description) {
    this.statusCode = statusCode;
    this.timestamp = timestamp;
    this.message = message;
    this.description = description;
  }

  public int getStatusCode() {
    return statusCode;
  }

  public Date getTimestamp() {
    return timestamp;
  }

  public String getMessage() {
    return message;
  }

  public String getDescription() {
    return description;
  }
}

Create Custom Exception

We're gonna throw an exception for Resource not found in Spring Boot controller.
Lets create a ResourceNotFoundException class that extends RuntimeException.

exception/ResourceNotFoundException.java



package com.bezkoder.spring.exhandling.exception;

public class ResourceNotFoundException extends RuntimeException {

  private static final long serialVersionUID = 1L;

  public ResourceNotFoundException(String msg) {
    super(msg);
  }
}

Create Controller Advice with @ExceptionHandler

Now we're gonna create a special class which is annotated by @ControllerAdvice annotation. This class handles specific exception (ResoureNotFoundException) and global Exception in only one place.

exception/ControllerExceptionHandler.java



package com.bezkoder.spring.exhandling.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;

import com.bezkoder.spring.exhandling.exception.ErrorMessage;
import com.bezkoder.spring.exhandling.exception.ResourceNotFoundException;

@ControllerAdvice
public class ControllerExceptionHandler {

  @ExceptionHandler(ResourceNotFoundException.class)
  public ResponseEntity<ErrorMessage> resourceNotFoundException(ResourceNotFoundException ex, WebRequest request) {
    ErrorMessage message = new ErrorMessage(
        HttpStatus.NOT_FOUND.value(),
        new Date(),
        ex.getMessage(),
        request.getDescription(false));

    return new ResponseEntity<ErrorMessage>(message, HttpStatus.NOT_FOUND);
  }

  @ExceptionHandler(Exception.class)
  public ResponseEntity<ErrorMessage> globalExceptionHandler(Exception ex, WebRequest request) {
    ErrorMessage message = new ErrorMessage(
        HttpStatus.INTERNAL_SERVER_ERROR.value(),
        new Date(),
        ex.getMessage(),
        request.getDescription(false));

    return new ResponseEntity<ErrorMessage>(message, HttpStatus.INTERNAL_SERVER_ERROR);
  }
}

Modify Controller for using @ControllerAdvice

Our Rest Controller now doesn't have try/catch block, and it will throw ResourceNotFoundException where we want to send NOT_FOUND notification in response message.

controller/TutorialController.java



package com.bezkoder.spring.exhandling.controller;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.CrossOrigin;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.bezkoder.spring.exhandling.exception.ResourceNotFoundException;
import com.bezkoder.spring.exhandling.model.Tutorial;
import com.bezkoder.spring.exhandling.repository.TutorialRepository;

@CrossOrigin(origins = "http://localhost:8081")
@RestController
@RequestMapping("/api")
public class TutorialController {

  @Autowired
  TutorialRepository tutorialRepository;

  @GetMapping("/tutorials")
  public ResponseEntity<List<Tutorial>> getAllTutorials(@RequestParam(required = false) String title) {
    List<Tutorial> tutorials = new ArrayList<Tutorial>();

    if (title == null)
      tutorialRepository.findAll().forEach(tutorials::add);
    else
      tutorialRepository.findByTitleContaining(title).forEach(tutorials::add);

    if (tutorials.isEmpty()) {
      return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }

    return new ResponseEntity<>(tutorials, HttpStatus.OK);
  }

  @GetMapping("/tutorials/{id}")
  public ResponseEntity<Tutorial> getTutorialById(@PathVariable("id") long id) {
    Tutorial tutorial = tutorialRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("Not found Tutorial with id = " + id));

    return new ResponseEntity<>(tutorial, HttpStatus.OK);
  }

  @PostMapping("/tutorials")
  public ResponseEntity<Tutorial> createTutorial(@RequestBody Tutorial tutorial) {
    Tutorial _tutorial = tutorialRepository.save(new Tutorial(tutorial.getTitle(), tutorial.getDescription(), false));
    return new ResponseEntity<>(_tutorial, HttpStatus.CREATED);
  }

  @PutMapping("/tutorials/{id}")
  public ResponseEntity<Tutorial> updateTutorial(@PathVariable("id") long id, @RequestBody Tutorial tutorial) {
    Tutorial _tutorial = tutorialRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("Not found Tutorial with id = " + id));

    _tutorial.setTitle(tutorial.getTitle());
    _tutorial.setDescription(tutorial.getDescription());
    _tutorial.setPublished(tutorial.isPublished());

    return new ResponseEntity<>(tutorialRepository.save(_tutorial), HttpStatus.OK);
  }

  @DeleteMapping("/tutorials/{id}")
  public ResponseEntity<HttpStatus> deleteTutorial(@PathVariable("id") long id) {
    tutorialRepository.deleteById(id);

    return new ResponseEntity<>(HttpStatus.NO_CONTENT);
  }

  @DeleteMapping("/tutorials")
  public ResponseEntity<HttpStatus> deleteAllTutorials() {
    tutorialRepository.deleteAll();

    return new ResponseEntity<>(HttpStatus.NO_CONTENT);
  }

  @GetMapping("/tutorials/published")
  public ResponseEntity<List<Tutorial>> findByPublished() {
    List<Tutorial> tutorials = tutorialRepository.findByPublished(true);

    if (tutorials.isEmpty()) {
      return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }

    return new ResponseEntity<>(tutorials, HttpStatus.OK);
  }

}

Run and Test

We finish implementing CRUD REST APIs and exception handling for it.
Run Spring Boot application with command: mvn spring-boot:run.

Get a non-existent tutorial:

Update a non-existent tutorial:

Create tutorial with wrong fields:

Delete a non-existent tutorial:

Conclusion

Today we've built Global Exception Handling class for Spring Boot Rest APIs using @ControllerAdvice and @ExceptionHandler. Now you can create your own custom exception handler class or handle global exception in single place at ease.

If you want to add Pagination to this Spring project, you can find the instruction at:
Spring Boot Pagination & Filter example | Spring JPA, Pageable

To sort/order by multiple fields:
Spring Data JPA Sort/Order by multiple Columns | Spring Boot

Or way to write Unit Test:

You can also know how to deploy this Spring Boot App on AWS (for free) with this tutorial.
Dockerize with Docker Compose: Spring Boot and MySQL example
Or: Docker Compose: Spring Boot and Postgres example

Happy learning! See you again.

Source Code

You can find the complete source code for this tutorial on Github.

You can also use @RestControllerAdvice in Spring Boot

Documentation: Spring Boot + Swagger 3 example (with OpenAPI 3)
Caching: Spring Boot Redis Cache example
Validation: Validate Request Body in Spring Boot

Docker Compose: Spring Boot and Postgres example

Tien Nguyen — Sun, 08 Oct 2023 02:53:56 +0000

Overview

Assume that we have a Spring Boot Application working with Postgres database.
The problem is to containerize a system that requires more than one Docker container:

Spring Boot for Rest API
Postgres for database

Docker Compose helps us setup the system more easily and efficiently than with only Docker. We're gonna following these steps:

Create Spring Boot App working with Postgres database.
Create Dockerfile for Spring Boot App.
Write Docker Compose configurations in YAML file.
Set Spring Boot Docker Compose Environment variables.
Run the system.

Directory Structure:

Create Spring Boot App

You can read and get Github source code from one of following tutorials:

Create Dockerfile for Spring Boot App

Dockerfile defines a list of commands that Docker uses for setting up the Spring Boot application environment. So we put the file in bezkoder-app folder.

Because we will use Docker Compose, we won't define all the configuration commands in this Dockerfile.

bezkoder-app/Dockerfile



# FROM maven:3.8.2-jdk-8 # for Java 8
FROM maven:3.8.5-openjdk-17

WORKDIR /bezkoder-app
COPY . .
RUN mvn clean install

CMD mvn spring-boot:run

Let me explain some points:

FROM: install the image of the Maven - JDK version.
WORKDIR: path of the working directory.
COPY: copy all the files inside the project directory to the container.
RUN: execute a command-line inside the container: mvn clean install to install the dependencies in pom.xml.
CMD: run script mvn spring-boot:run after the image is built.

Write Docker Compose configurations

On the root of the project directory, we're gonna create the docker-compose.yml file. Follow version 3 syntax defined by Docker:



version: '3.8'

services: 
    postgresdb:
    app:

volumes:

version: Docker Compose file format version will be used.
services: individual services in isolated containers. Our application has two services: app (Spring Boot) and postgresdb (PostgreSQL database).
volumes: named volumes that keeps our data alive after restart.

Let's implement the details.

docker-compose.yml



version: "3.8"

services:
  postgresdb:
    image: postgres
    restart: unless-stopped
    env_file: ./.env
    environment:
      - POSTGRES_USER=$POSTGRESDB_USER
      - POSTGRES_PASSWORD=$POSTGRESDB_ROOT_PASSWORD
      - POSTGRES_DB=$POSTGRESDB_DATABASE
    ports:
      - $POSTGRESDB_LOCAL_PORT:$POSTGRESDB_DOCKER_PORT
    volumes:
      - db:/var/lib/postgres
  app:
    depends_on:
      - postgresdb
    build: ./bezkoder-app
    restart: on-failure
    env_file: ./.env
    ports:
      - $SPRING_LOCAL_PORT:$SPRING_DOCKER_PORT
    environment:
      SPRING_APPLICATION_JSON: '{
        "spring.datasource.url"  : "jdbc:postgresql://postgresdb:$POSTGRESDB_DOCKER_PORT/$POSTGRESDB_DATABASE",
        "spring.datasource.username" : "$POSTGRESDB_USER",
        "spring.datasource.password" : "$POSTGRESDB_ROOT_PASSWORD",
        "spring.jpa.properties.hibernate.dialect" : "org.hibernate.dialect.PostgreSQLDialect",
        "spring.jpa.hibernate.ddl-auto" : "update"
      }'
    volumes:
      - .m2:/root/.m2
    stdin_open: true
    tty: true

volumes:
  db:

postgresdb:
- image: official Docker image
- restart: configure the restart policy
- env_file: specify our .env path that we will create later
- environment: provide setting using environment variables
- ports: specify ports will be used
- volumes: map volume folders
app:
- depends_on: dependency order, postgresdb is started before app
- build: configuration options that are applied at build time that we defined in the Dockerfile with relative path
- environment: environmental variables that Spring Boot application uses
- stdin_open and tty: keep open the terminal after building container

Docker Compose Environment variables

In the service configuration, we used environmental variables defined inside the .env file. Now we start writing it.

.env



POSTGRESDB_USER=postgres
POSTGRESDB_ROOT_PASSWORD=123456
POSTGRESDB_DATABASE=bezkoder_db
POSTGRESDB_LOCAL_PORT=5433
POSTGRESDB_DOCKER_PORT=5432

SPRING_LOCAL_PORT=6868
SPRING_DOCKER_PORT=8080

Run the Spring Boot microservice with Docker Compose

We can easily run the whole with only a single command:
docker compose up

Docker will pull the PostgreSQL and Maven images (if our machine does not have it before).

The services can be run on the background with command:
docker compose up -d



$ docker compose up -d
[+] Running 14/14
 ✔ postgresdb 13 layers [⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿]      0B/0B      Pulled                                                                                                                                                               30.0s 
   ✔ a803e7c4b030 Pull complete                                                                                                                                                                                               
   ✔ 009c876521a0 Pull complete                                                                                                                                                                                               
   ✔ 9c412905cca2 Pull complete                                                                                                                                                                                               
   ✔ 6463d4bf467a Pull complete                                                                                                                                                                                              
   ✔ bd8b983728ed Pull complete                                                                                                                                                                                              
   ✔ febc167f3560 Pull complete                                                                                                                                                                                              
   ✔ d73c81c4ade3 Pull complete                                                                                                                                                                                              
   ✔ 34b3b0ac6e9e Pull complete                                                                                                                                                                                              
   ✔ 9bd86d074f4e Pull complete                                                                                                                                                                                              
   ✔ 406f63329750 Pull complete                                                                                                                                                                                              
   ✔ ec40772694b7 Pull complete                                                                                                                                                                                              
   ✔ 7d3dfa1637e9 Pull complete                                                                                                                                                                                              
   ✔ e217ca41159f Pull complete                                                                                                                                                                                              
[+] Building 2.9s (9/9) FINISHED                                                                                                                                                                                    
 => [app internal] load build definition from Dockerfile                                                                                                                                                                      
 => => transferring dockerfile: 231B                                                                                                                                                                                          
 => [app internal] load .dockerignore                                                                                                                                                                                         
 => => transferring context: 2B                                                                                                                                                                                               
 => [app internal] load metadata for docker.io/library/maven:3.8.5-openjdk-17                                                                                                                                                 
 => [app 1/4] FROM docker.io/library/maven:3.8.5-openjdk-17@sha256:3a9c30b3af6278a8ae0007d3a3bf00fff80ec3ed7ae4eb9bfa1772853101549b                                                                                           
 => [app internal] load build context                                                                                                                                                                                         
 => => transferring context: 1.94kB                                                                                                                                                                                           
 => [app 2/4] WORKDIR /bezkoder-app                                                                                                                                                                                    
 => [app 3/4] COPY . .                                                                                                                                                                                                 
 => [app 4/4] RUN mvn clean install                                                                                                                                                                                    
 => [app] exporting to image                                                                                                                                                                                                  
 => => exporting layers                                                                                                                                                                                                       
 => => writing image sha256:bb65745b652009fa4bf508b771c9abc5e90f257f9efde63251df8c0a74c672d7                                                                                                                                  
 => => naming to docker.io/library/spring-boot-postgres-app                                                                                                                                                                   
[+] Running 2/1
 ✔ Container spring-boot-postgres-postgresdb-1  Created                                                                                                                                                                       
 ✔ Container spring-boot-postgres-app-1         Created                                                                                                                                                                       
Attaching to spring-boot-postgres-app-1, spring-boot-postgres-postgresdb-1
...
spring-boot-postgres-postgresdb-1  | PostgreSQL init process complete; ready for start up.
spring-boot-postgres-postgresdb-1  | 
spring-boot-postgres-postgresdb-1  | 
spring-boot-postgres-postgresdb-1  | 2023-10-03 03:35:18.102 UTC [1] LOG:  starting PostgreSQL 16.0 (Debian 16.0-1.pgdg120+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 12.2.0-14) 12.2.0, 64-bit
spring-boot-postgres-postgresdb-1  | 2023-10-03 03:35:18.102 UTC [1] LOG:  listening on IPv4 address "0.0.0.0", port 5432
spring-boot-postgres-postgresdb-1  | 2023-10-03 03:35:18.102 UTC [1] LOG:  listening on IPv6 address "::", port 5432
spring-boot-postgres-postgresdb-1  | 2023-10-03 03:35:18.105 UTC [1] LOG:  listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
spring-boot-postgres-postgresdb-1  | 2023-10-03 03:35:18.109 UTC [64] LOG:  database system was shut down at 2023-10-03 03:35:18 UTC
spring-boot-postgres-postgresdb-1  | 2023-10-03 03:35:18.113 UTC [1] LOG:  database system is ready to accept connections
spring-boot-postgres-app-1         | [INFO] Scanning for projects...
spring-boot-postgres-app-1         | [INFO] 
spring-boot-postgres-app-1         | [INFO] --------------< com.bezkoder:spring-boot-jpa-postgresql >---------------
spring-boot-postgres-app-1         | [INFO] Building spring-boot-jpa-postgresql 0.0.1-SNAPSHOT
spring-boot-postgres-app-1         | [INFO] --------------------------------[ jar ]---------------------------------
spring-boot-postgres-app-1         | [INFO] 
spring-boot-postgres-app-1         | [INFO] >>> spring-boot-maven-plugin:3.1.0:run (default-cli) > test-compile @ spring-boot-jpa-postgresql >>>
...
spring-boot-postgres-app-1         | 2023-10-03T03:41:46.545Z  INFO 59 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
spring-boot-postgres-app-1         | 2023-10-03T03:41:46.551Z  INFO 59 --- [           main] s.j.p.SpringBootJpaPostgresqlApplication : Started SpringBootJpaPostgresqlApplication in 2.188 seconds (process running for 2.354)

Now you can check the current working containers:



$ docker ps
CONTAINER ID   IMAGE                      COMMAND                  CREATED         STATUS         PORTS                                       NAMES
9c3d10422b09   spring-boot-postgres-app   "/usr/local/bin/mvn-…"   2 minutes ago   Up 2 minutes   0.0.0.0:6868->8080/tcp, :::6868->8080/tcp   spring-boot-postgres-app-1
ed0b41f7f1c8   postgres                   "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes   0.0.0.0:5433->5432/tcp, :::5433->5432/tcp   spring-boot-postgres-postgresdb-1

And Docker images:



$ docker images
REPOSITORY                 TAG            IMAGE ID       CREATED         SIZE
spring-boot-postgres-app   latest         bb65745b6520   5 minutes ago   962MB
postgres                   latest         2d74f8a2591c   6 minutes ago   417MB

Send a HTTP request to the Spring Boot - Postgres system:

Check Postgres Database:



$ docker exec -ti spring-boot-postgres-postgresdb-1 /bin/bash
root@8869979fbd27:/# psql bezkoder_db postgres
psql (16.0 (Debian 16.0-1.pgdg120+1))
Type "help" for help.

bezkoder_db=# SELECT * FROM tutorials;
 id |    description    | published |                title                 
----+-------------------+-----------+--------------------------------------
  1 | Tut#1 Description | f         | bezkoder Docker Spring Boot Postgres
(1 row)

Stop the Application

Stopping all the running containers is also simple with a single command:
docker compose down



$ docker compose down
 ✔ Container spring-boot-postgres-app-1         Removed                                                                                                                                                      
 ✔ Container spring-boot-postgres-postgresdb-1  Removed                                                                                                                                                      
 ✔ Network spring-boot-postgres_default         Removed

If you need to stop and remove all containers, networks, and all images used by any service in docker-compose.yml file, use the command:
docker compose down --rmi all

Conclusion

Today we've successfully created Docker Compose file for Spring Boot application and Postgres. Now we can connect Spring Boot to PostgreSQL with Docker on a very simple way: docker-compose.yml.

You can apply this way to one of following project:

If you want to deploy the system on AWS, please visit:
Deploy Spring Boot App on AWS – Elastic Beanstalk

Happy Learning! See you again.

Source Code

The source code for this tutorial can be found at Github.

Documentation: Spring Boot + Swagger 3 example (with OpenAPI 3)
Caching: Spring Boot Redis Cache example

Docker Node.js and MongoDB example

Tien Nguyen — Mon, 11 Sep 2023 03:57:51 +0000

Docker provides lightweight containers to run services in isolation from our infrastructure so we can deliver software quickly. In this tutorial, I will show you how to dockerize Nodejs Express and MongoDB example using Docker Compose.

Dockerize fullstack:

Docker Compose: React + Node.js Express + MongoDB

Node.js Express and MongoDB with Docker Overview

Assume that we have a Nodejs Application working with MongoDB database.
The problem is to containerize a system that requires more than one Docker container:

Node.js Express for API
MongoDB for database

Docker Compose helps us setup the system more easily and efficiently than with only Docker. We're gonna following these steps:

Create Nodejs App working with MongoDB database.
Create Dockerfile for Nodejs App.
Write Docker Compose configurations in YAML file.
Set Environment variables for Docker Compose
Run the system.

Directory Structure:

Create Nodejs App

You can read and get Github source code from one of following tutorials:

Using the code base above, we put the Nodejs project in bezkoder-app folder and modify some files to work with environment variables.

Firstly, let's add dotenv module into package.json.



{
  ...
  "dependencies": {
    "dotenv": "^10.0.0",
    ...
  }
}

Next we import dotenv in server.js and use process.env for setting port.



require("dotenv").config();
..
// set port, listen for requests
const PORT = process.env.NODE_DOCKER_PORT || 8080;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}.`);
});

Then we change modify database configuration and initialization.

app/config/db.config.js



const {
  DB_USER,
  DB_PASSWORD,
  DB_HOST,
  DB_PORT,
  DB_NAME,
} = process.env;

module.exports = {
  url: `mongodb://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}?authSource=admin`
};

We also need to make a .env sample file that shows all necessary arguments.

bezkoder-app/.env.sample



DB_HOST=localhost
DB_USER=root
DB_PASSWORD=123456
DB_NAME=bezkoder_db
DB_PORT=27017

NODE_DOCKER_PORT=8080

Create Dockerfile for Nodejs App

Dockerfile defines a list of commands that Docker uses for setting up the Node.js application environment. So we put the file in bezkoder-app folder.

Because we will use Docker Compose, we won't define all the configuration commands in this Dockerfile.

bezkoder-app/Dockerfile



FROM node:14

WORKDIR /bezkoder-app
COPY package.json .
RUN npm install
COPY . .
CMD npm start

Let me explain some points:

FROM: install the image of the Node.js version.
WORKDIR: path of the working directory.
COPY: copy package.json file to the container, then the second one copies all the files inside the project directory.
RUN: execute a command-line inside the container: npm install to install the dependencies in package.json.
CMD: run script npm start after the image is built.

Write Docker Compose configurations

On the root of the project directory, we're gonna create the docker-compose.yml file. Follow version 3 syntax defined by Docker:



version: '3.8'

services: 
    mongodb:
    app:

volumes:

version: Docker Compose file format version will be used.
services: individual services in isolated containers. Our application has two services: app (Nodejs) and mongodb (MongoDB database).
volumes: named volumes that keeps our data alive after restart.

Let's implement the details.

docker-compose.yml



version: "3.8"

services:
  mongodb:
    image: mongo:5.0.2
    restart: unless-stopped
    env_file: ./.env
    environment:
      - MONGO_INITDB_ROOT_USERNAME=$MONGODB_USER
      - MONGO_INITDB_ROOT_PASSWORD=$MONGODB_PASSWORD
    ports:
      - $MONGODB_LOCAL_PORT:$MONGODB_DOCKER_PORT
    volumes:
      - db:/data/db
  app:
    depends_on:
      - mongodb
    build: ./bezkoder-app
    restart: unless-stopped
    env_file: ./.env
    ports:
      - $NODE_LOCAL_PORT:$NODE_DOCKER_PORT
    environment:
      - DB_HOST=mongodb
      - DB_USER=$MONGODB_USER
      - DB_PASSWORD=$MONGODB_PASSWORD
      - DB_NAME=$MONGODB_DATABASE
      - DB_PORT=$MONGODB_DOCKER_PORT
    stdin_open: true
    tty: true

volumes:
  db:

mongodb:
- image: official Docker image
- restart: configure the restart policy
- env_file: specify our .env path that we will create later
- environment: provide setting using environment variables
- ports: specify ports will be used
- volumes: map volume folders
app:
- depends_on: dependency order, mongodb is started before app
- build: configuration options that are applied at build time that we defined in the Dockerfile with relative path
- environment: environmental variables that Node application uses
- stdin_open and tty: keep open the terminal after building container

Docker Compose Environment variables with MongoDB

In the service configuration, we used environmental variables defined inside the .env file. Now we start writing it.

.env



MONGODB_USER=root
MONGODB_PASSWORD=123456
MONGODB_DATABASE=bezkoder_db
MONGODB_LOCAL_PORT=7017
MONGODB_DOCKER_PORT=27017

NODE_LOCAL_PORT=6868
NODE_DOCKER_PORT=8080

Run Nodejs MongoDB with Docker Compose

We can easily run the whole with only a single command:
docker compose up

Docker will pull the MongoDB and Node.js images (if our machine does not have it before).

The services can be run on the background with command:
docker compose up -d



$ docker compose up -d
Creating network "node-mongodb_default" with the default driver
Creating volume "node-mongodb_db" with default driver
Pulling mongodb (mongo:5.0.2)...
5.0.2: Pulling from library/mongo
16ec32c2132b: Pull complete
6335cf672677: Pull complete
cbc70ccc8ebe: Pull complete
0d1a3c6bd417: Pull complete
960f3b9b27d3: Pull complete
aff995a136b4: Pull complete
4249be7550a8: Pull complete
cc105ff5aa3c: Pull complete
82819807d07a: Pull complete
81447d2c233f: Pull complete
Digest: sha256:54d24682d00278f64bf21ff62b7ee62b59dae50f65139831a884b345922b0f8a
Status: Downloaded newer image for mongo:5.0.2
Building app
Sending build context to Docker daemon  19.46kB
Step 1/6 : FROM node:14
14: Pulling from library/node
eb18d230e067: Pull complete 
83600c1b4583: Pull complete 
4ae15c65bfa0: Pull complete 
c19c058edda5: Pull complete 
05cdaa0fd103: Pull complete 
8461dcff50c4: Pull complete 
84be4117f79d: Pull complete 
4ccb803887fd: Pull complete 
ab52680a5469: Pull complete 
Digest: sha256:c1fa7759eeff3f33ba08ff600ffaca4558954722a4345653ed1a0d87dffed9aa
Status: Downloaded newer image for node:14
 ---> 256d6360f157
Step 2/6 : WORKDIR /bezkoder-app
 ---> Running in 71b4b2e9dd6c
Removing intermediate container 71b4b2e9dd6c
 ---> 194372d3695c
Step 3/6 : COPY package.json .
 ---> 093f866b404a
Step 4/6 : RUN npm install
 ---> Running in 025f0f0365a9
npm notice created a lockfile as package-lock.json. You should commit this file.
npm WARN node-express-mongodb@1.0.0 No repository field.

added 81 packages from 128 contributors and audited 81 packages in 6.902s

2 packages are looking for funding
  run `npm fund` for details

found 0 vulnerabilities

Removing intermediate container 025f0f0365a9
 ---> 2f04aeaa93b1
Step 5/6 : COPY . .
 ---> 50e31a045a02
Step 6/6 : CMD npm start
 ---> Running in 7353ac17fa02
Removing intermediate container 7353ac17fa02
 ---> bd9d66054ea2
Successfully built bd9d66054ea2
Successfully tagged node-mongodb_app:latest
WARNING: Image for service app was built because it did not already exist. To rebuild this image you must use `docker compose build` or `docker compose up --build`.
Creating node-mongodb_mongodb_1 ... done
Creating node-mongodb_app_1     ... done

Now you can check the current working containers:



$ docker ps
CONTAINER ID   IMAGE              COMMAND                  CREATED         STATUS         PORTS                                         NAMES
42b9271dd73f   node-mongodb_app   "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes   0.0.0.0:6868->8080/tcp, :::6868->8080/tcp     node-mongodb_app_1
e17bf545c0ba   mongo:5.0.2        "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes   0.0.0.0:7017->27017/tcp, :::7017->27017/tcp   node-mongodb_mongodb_1

And Docker images:



$ docker images
REPOSITORY            TAG            IMAGE ID       CREATED         SIZE
node-mongodb_app      latest         bd9d66054ea2   5 minutes ago   960MB
node                  14             256d6360f157   6 minutes ago   944MB
mongo                 5.0.2          269b735e72cb   6 minutes ago   682MB

Let's send an HTTP request to check the Express Rest API:

And the MongoDB database also:

Stop the Application

Stopping all the running containers is also simple with a single command:
docker compose down



$ docker compose down
Stopping node-mongodb_app_1     ... done
Stopping node-mongodb_mongodb_1 ... done
Removing node-mongodb_app_1     ... done
Removing node-mongodb_mongodb_1 ... done
Removing network node-mongodb_default

If you need to stop and remove all containers, networks, and all images used by any service in docker-compose.yml file, use the command:
docker compose down --rmi all



$ docker compose down --rmi all
Stopping node-mongodb_app_1     ... done
Stopping node-mongodb_mongodb_1 ... done
Removing node-mongodb_app_1     ... done
Removing node-mongodb_mongodb_1 ... done
Removing network node-mongodb_default
Removing image mongo:5.0.2
Removing image node-mongodb_app

Conclusion

Today we've successfully created Docker Compose file for Nodejs and MongoDB application. Now we can deploy Nodejs Express and MongoDB with Docker on a very simple way: docker-compose.yml.

You can apply this way to one of following project:

Or Dockerize fullstack:

Docker Compose: React + Node.js Express + MongoDB

Happy Learning! See you again.

Source Code

The source code for this tutorial can be found at Github.

Spring Boot Thymeleaf File Upload example

Tien Nguyen — Thu, 31 Aug 2023 01:17:41 +0000

In this tutorial, I will show you how to implement file upload with Thymeleaf and Bootstrap in a Spring Boot project. We also use Spring Web MultipartFile interface to handle HTTP multi-part requests.

Fullstack:

Associations:

Thymeleaf File Upload Overview

Our Spring Boot + Thymeleaf File Upload example will have following features:

uploading File to a static folder in the Server
downloading File from server with the link
getting list of Files' information (file name & url)

Here is the File Upload Form:

If the File exceeds specific maximum size:

This is the static folder that stores all uploaded files:

You can see list of uploaded files with download links:

In this tutorial, I don't explain way to delete File. If you want to know that, just visit:
Spring Boot Delete File example with Thymeleaf

Or adding Pagination with following tutorial:
Spring Boot Thymeleaf Pagination example

Project Structure

Let me explain it briefly.

FileInfo contains information of the uploaded file.
FilesStorageService helps us to initialize storage, save new file, load file, get list of Files' info, delete files.
FileController uses FilesStorageService to handle file upload/download and template requests.
FileUploadExceptionAdvice handles exception when the controller processes file upload.
template stores HTML template files for the project.
application.properties contains configuration for Servlet Multipart.
uploads is the static folder for storing files.
pom.xml for Spring Boot dependency.

Create & Setup Spring Boot project

Use Spring web tool or your development tool (Spring Tool Suite, Eclipse, Intellij) to create a Spring Boot project.

Then open pom.xml and add dependencies for Spring Web, Thymeleaf, Bootstrap, Jquery:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>bootstrap</artifactId>
    <version>4.6.2</version>
</dependency>

<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>jquery</artifactId>
    <version>3.6.1</version>
</dependency>

<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>webjars-locator-core</artifactId>
</dependency>

Create Service for File Storage

First we need an interface that will be autowired in the Controller.
In service folder, create FilesStorageService interface like following code:

service/FilesStorageService.java

package com.bezkoder.spring.thymeleaf.file.upload.service;

import java.nio.file.Path;
import java.util.stream.Stream;

import org.springframework.core.io.Resource;
import org.springframework.web.multipart.MultipartFile;

public interface FilesStorageService {
  public void init();

  public void save(MultipartFile file);

  public Resource load(String filename);

  public void deleteAll();

  public Stream<Path> loadAll();
}

Now we create implementation of the interface.

service/FilesStorageServiceImpl.java

package com.bezkoder.spring.thymeleaf.file.upload.service;

import java.io.IOException;
import java.net.MalformedURLException;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;

import org.springframework.core.io.Resource;
import org.springframework.core.io.UrlResource;
import org.springframework.stereotype.Service;
import org.springframework.util.FileSystemUtils;
import org.springframework.web.multipart.MultipartFile;

@Service
public class FilesStorageServiceImpl implements FilesStorageService {
  private final Path root = Paths.get("./uploads");

  @Override
  public void init() {
    try {
      Files.createDirectories(root);
    } catch (IOException e) {
      throw new RuntimeException("Could not initialize folder for upload!");
    }
  }

  @Override
  public void save(MultipartFile file) {
    try {
      Files.copy(file.getInputStream(), this.root.resolve(file.getOriginalFilename()));
    } catch (Exception e) {
      if (e instanceof FileAlreadyExistsException) {
        throw new RuntimeException("A file of that name already exists.");
      }

      throw new RuntimeException(e.getMessage());
    }
  }

  @Override
  public Resource load(String filename) {
    try {
      Path file = root.resolve(filename);
      Resource resource = new UrlResource(file.toUri());

      if (resource.exists() || resource.isReadable()) {
        return resource;
      } else {
        throw new RuntimeException("Could not read the file!");
      }
    } catch (MalformedURLException e) {
      throw new RuntimeException("Error: " + e.getMessage());
    }
  }

  @Override
  public void deleteAll() {
    FileSystemUtils.deleteRecursively(root.toFile());
  }

  @Override
  public Stream<Path> loadAll() {
    try {
      return Files.walk(this.root, 1).filter(path -> !path.equals(this.root)).map(this.root::relativize);
    } catch (IOException e) {
      throw new RuntimeException("Could not load the files!");
    }
  }
}

Create Controller for File Upload

In controller package, we create FileController.

controller/FileController.java

package com.bezkoder.spring.thymeleaf.file.upload.controller;
// ...
import com.bezkoder.spring.thymeleaf.file.upload.service.FilesStorageService;

@Controller
public class FileController {

  @Autowired
  FilesStorageService storageService;

  @GetMapping("/")
  public String homepage() {
    return "redirect:/files";
  }

  @GetMapping("/files/new")
  public String newFile(Model model) {
    return "upload_form";
  }

  @PostMapping("/files/upload")
  public String uploadFile(Model model, @RequestParam("file") MultipartFile file) {
    ...

    return "upload_form";
  }

  @GetMapping("/files")
  public String getListFiles(Model model) {
    ...

    return "files";
  }

  @GetMapping("/files/{filename:.+}")
  public ResponseEntity<Resource> getFile(@PathVariable String filename) {
    ...

    // return File
  }
}

@Controller annotation is used to define a controller.
@GetMapping and @PostMapping annotation is for mapping HTTP GET & POST requests onto specific handler methods and returning appropriate template files.
We use @Autowired to inject implementation of FilesStorageService bean to local variable.

Setup the Template

In src/main/resources folder, create folder and file as following structure:

Header and Footer

We will use Thymeleaf Fragments (th:fragment) to reuse some common parts such as header and footer.
Let's write HTML code for them.

fragments/footer.html

<footer class="text-center">
  Copyright &copy; BezKoder
</footer>

And header that contains the navigation bar:
fragments/header.html

<header th:fragment="header">
  <nav class="navbar navbar-expand-md bg-dark navbar-dark mb-3">
    <a class="navbar-brand" th:href="@{/files}">
      BezKoder
    </a>
    <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#topNavbar">
      <span class="navbar-toggler-icon"></span>
    </button>
    <div class="collapse navbar-collapse" id="topNavbar">
      <ul class="navbar-nav">
        <li class="nav-item">
          <a class="nav-link" th:href="@{/files/new}">Upload</a>
        </li>
        <li class="nav-item">
          <a class="nav-link" th:href="@{/files}">Files</a>
        </li>
      </ul>
    </div>
  </nav>
</header>

Now we need to create HTML files, then import Thymeleaf fragments, Bootstrap, jQuery and Font Awesome.

File Upload Form

upload_form.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  <meta name="viewport" content="width=device-width,initial-scale=1.0,minimum-scale=1.0" />
  <title>BezKoder - Thymeleaf File Upload example</title>
  <link rel="stylesheet" type="text/css" th:href="@{/webjars/bootstrap/css/bootstrap.min.css}" />
  <script type="text/javascript" th:src="@{/webjars/jquery/jquery.min.js}"></script>
  <script type="text/javascript" th:src="@{/webjars/bootstrap/js/bootstrap.min.js}"></script>
</head>

<body>
  <div th:replace="fragments/header :: header"></div>

  -- file upload form --

  <div th:replace="fragments/footer :: footer"></div>
</body>

</html>

List of Files

files.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  <meta name="viewport" content="width=device-width,initial-scale=1.0,minimum-scale=1.0" />
  <title>BezKoder - Thymeleaf File Upload example</title>

  <link rel="stylesheet" type="text/css" th:href="@{/webjars/bootstrap/css/bootstrap.min.css}" />
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.2.0/css/all.min.css"
    integrity="sha512-xh6O/CkQoPOWDdYTDqeRdPCVd1SpvCA9XXcUnZS2FmJNp1coAFzvtCN9BmamE+4aHK8yyUHUSCcJHgXloTyT2A=="
    crossorigin="anonymous" referrerpolicy="no-referrer" />
  <script type="text/javascript" th:src="@{/webjars/jquery/jquery.min.js}"></script>
  <script type="text/javascript" th:src="@{/webjars/bootstrap/js/bootstrap.min.js}"></script>
</head>

<body>
  <div th:replace="fragments/header :: header"></div>

  -- list of files display --

  <div th:replace="fragments/footer :: footer"></div>
</body>

</html>

Implement File Upload function

We use @GetMapping and @PostMapping annotation is for mapping HTTP GET & POST requests onto specific handler methods:

GET /files/new: newFile() - return upload_form.html template
POST /files/upload: uploadFile() - upload a File

FileController.java

import com.bezkoder.spring.thymeleaf.file.upload.service.FilesStorageService;

@Controller
public class FileController {

  @Autowired
  FilesStorageService storageService;

  @GetMapping("/files/new")
  public String newFile(Model model) {
    return "upload_form";
  }

  @PostMapping("/files/upload")
  public String uploadFile(Model model, @RequestParam("file") MultipartFile file) {
    String message = "";

    try {
      storageService.save(file);

      message = "Uploaded the file successfully: " + file.getOriginalFilename();
      model.addAttribute("message", message);
    } catch (Exception e) {
      message = "Could not upload the file: " + file.getOriginalFilename() + ". Error: " + e.getMessage();
      model.addAttribute("message", message);
    }

    return "upload_form";
  }
}

upload_form.html

<div class="container" style="max-width: 500px">
  <h3 class="mb-3">Thymeleaf File Upload example</h3>

  <form
    id="uploadForm"
    method="post"
    th:action="@{/files/upload}"
    enctype="multipart/form-data">
    <input id="input-file" type="file" name="file" />
    <button class="btn btn-sm btn-outline-success float-right" type="submit">
      Upload
    </button>
  </form>

  <div
    th:if="${message != null}"
    class="alert alert-secondary alert-dismissible fade show text-center message mt-3"
    role="alert">
    [[${message}]]
    <button type="button" class="close btn-sm" data-dismiss="alert" aria-label="Close">
      <span aria-hidden="true">&times;</span>
    </button>
  </div>
</div>

Display List of Files

Firstly, we need to create FileInfo model which has fields: name & url.

model/FileInfo.java

package com.bezkoder.spring.thymeleaf.file.upload.model;

public class FileInfo {

  private String name;
  private String url;

  public FileInfo(String name, String url) {
    this.name = name;
    this.url = url;
  }

  public String getName() {
    return this.name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getUrl() {
    return this.url;
  }

  public void setUrl(String url) {
    this.url = url;
  }
}

In the Controller, we will return List of FileInfo objects as model Attribute.
@GetMapping and @PostMapping annotation is for mapping HTTP GET & POST requests onto specific handler methods:

GET /files: getListFiles() - return files.html template
GET /files/[filename]: getFile() - download a File by filename

FileController.java

import com.bezkoder.spring.thymeleaf.file.upload.model.FileInfo;
import com.bezkoder.spring.thymeleaf.file.upload.service.FilesStorageService;

@Controller
public class FileController {

  @Autowired
  FilesStorageService storageService;

  // ...

  @GetMapping("/")
  public String homepage() {
    return "redirect:/files";
  }

  @GetMapping("/files")
  public String getListFiles(Model model) {
    List<FileInfo> fileInfos = storageService.loadAll().map(path -> {
      String filename = path.getFileName().toString();
      String url = MvcUriComponentsBuilder
          .fromMethodName(FileController.class, "getFile", path.getFileName().toString()).build().toString();

      return new FileInfo(filename, url);
    }).collect(Collectors.toList());

    model.addAttribute("files", fileInfos);

    return "files";
  }

  @GetMapping("/files/{filename:.+}")
  public ResponseEntity<Resource> getFile(@PathVariable String filename) {
    Resource file = storageService.load(filename);

    return ResponseEntity.ok()
        .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + file.getFilename() + "\"").body(file);
  }
}

files.html

<div class="container-fluid" style="max-width: 600px; margin: 0 auto;">
  <h2 class="text-center">List of Files</h2>

  <div th:if="${files.size() > 0}">
    <table class="table table-hover">
      <thead class="thead-light">
        <tr>
          <th scope="col">File Name</th>
          <th scope="col">Link</th>
          <th scope="col">Actions</th>
        </tr>
      </thead>
      <tbody>
        <tr th:each="file : ${files}">
          <td>[[${file.name}]]</td>
          <td><a th:href="@{${file.url}}">Download</a></td>
          <td>
            <a th:href="@{'/files/delete/' + ${file.name}}" th:fileName="${file.name}" id="btnDelete"
              title="Delete this file" class="fa-regular fa-trash-can icon-dark btn-delete"></a>
          </td>
        </tr>
      </tbody>
    </table>
  </div>

  <div th:unless="${files.size() > 0}">
    <span>No files found!</span>
  </div>
</div>

For deleting file, kindly visit following tutorial:
Spring Boot Delete File example with Thymeleaf

Configure Multipart File for Servlet

Let's define the maximum file size that can be uploaded in application.properties as following:

spring.servlet.multipart.max-file-size=1MB
spring.servlet.multipart.max-request-size=1MB

– spring.servlet.multipart.max-file-size: max file size for each request.
– spring.servlet.multipart.max-request-size: max request size for a multipart/form-data.

Handle File Upload Exception

This is where we handle the case in that a request exceeds Max Upload Size. The system will throw MaxUploadSizeExceededException and we're gonna use @ControllerAdvice with @ExceptionHandlerannotation for handling the exceptions.

exception/FileUploadExceptionAdvice.java

package com.bezkoder.spring.thymeleaf.file.upload.exception;

import org.springframework.web.multipart.MaxUploadSizeExceededException;

import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class FileUploadExceptionAdvice {

  @ExceptionHandler(MaxUploadSizeExceededException.class)
  public String handleMaxSizeException(Model model, MaxUploadSizeExceededException e) {
    model.addAttribute("message", "File is too large!");

    return "upload_form";
  }
}

Initialize Storage

We need to run init() method of FilesStorageService (and also deleteAll() if necessary). So open ThymeleafFileUploadApplication.java and implement CommandLineRunner for run() method like this:

package com.bezkoder.spring.thymeleaf.file.upload;

import javax.annotation.Resource;

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

import com.bezkoder.spring.thymeleaf.file.upload.service.FilesStorageService;

@SpringBootApplication
public class ThymeleafFileUploadApplication implements CommandLineRunner {

  @Resource
  FilesStorageService storageService;

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

  @Override
  public void run(String... arg) throws Exception {
//    storageService.deleteAll();
    storageService.init();
  }
}

Run the Spring Boot File Upload example

Run Spring Boot application with command: mvn spring-boot:run.

Source Code

You can find the complete source code for this tutorial on Github.

For deleting file:
Spring Boot Delete File example with Thymeleaf

Conclusion

Today we've learned how to create Spring Boot Thymeleaf File Upload Application with multipart files and get files' information with static folder.

For upload multiple Files at once:
Spring Boot Multiple File upload with Thymeleaf

Or fullstack with frontend:

You can also know way to upload an Excel/CSV file and store the content in MySQL database with the post:

If you want to store files in database like this:

You can find instruction at:
Spring Boot Upload/Download File to/from Database example

Happy Learning! See you again.

Docker MERN stack example

Tien Nguyen — Wed, 23 Aug 2023 03:22:26 +0000

Docker provides lightweight containers to run services in isolation from our infrastructure so we can deliver software quickly. In this tutorial, I will show you how to dockerize MERN stack Application (React + Node.js + Express + MongoDB) example using Docker Compose and Nginx.

MERN stack Application with Docker Overview

Assume that we have a fullstack React + Nodejs Express + MongoDB Application (MERN stack).
The problem is to containerize a system that requires more than one Docker container:

React for UI
Node.js Express for API
MongoDB for database

Docker Compose helps us setup the system more easily and efficiently than with only Docker. We're gonna following these steps:

Setup Nodejs App working with MongoDB database.
Create Dockerfile for Nodejs App.
Setup React App.
Create Dockerfile for React App.
Write Docker Compose configurations in YAML file.
Set Environment variables for Docker Compose
Run the system.

Directory Structure:

Setup Nodejs App

You can read and get Github source code from one of following tutorials:

Using the code base above, we put the Nodejs project in bezkoder-api folder and modify some files to work with environment variables.

Firstly, let's add dotenv module into package.json.

{
  ...
  "dependencies": {
    "dotenv": "^10.0.0",
    ...
  }
}

Next we import dotenv in server.js and use process.env for setting up CORS and port.

require("dotenv").config();
...
var corsOptions = {
  origin: process.env.CLIENT_ORIGIN || "http://localhost:8081"
};

app.use(cors(corsOptions));
..
// set port, listen for requests
const PORT = process.env.NODE_DOCKER_PORT || 8080;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}.`);
});

Then we change modify database configuration and initialization.

app/config/db.config.js

const {
  DB_USER,
  DB_PASSWORD,
  DB_HOST,
  DB_PORT,
  DB_NAME,
} = process.env;

module.exports = {
  url: `mongodb://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}?authSource=admin`
};

We also need to make a .env sample file that shows all necessary arguments.

bezkoder-api/.env.sample

DB_HOST=localhost
DB_USER=root
DB_PASSWORD=123456
DB_NAME=bezkoder_db
DB_PORT=27017

NODE_DOCKER_PORT=8080

CLIENT_ORIGIN=http://127.0.0.1:8081

Create Dockerfile for Nodejs App

Dockerfile defines a list of commands that Docker uses for setting up the Node.js application environment. So we put the file in bezkoder-api folder.

Because we will use Docker Compose, we won't define all the configuration commands in this Dockerfile.

bezkoder-api/Dockerfile

FROM node:14

WORKDIR /bezkoder-api
COPY package.json .
RUN npm install
COPY . .
CMD npm start

Let me explain some points:

FROM: install the image of the Node.js version.
WORKDIR: path of the working directory.
COPY: copy package.json file to the container, then the second one copies all the files inside the project directory.
RUN: execute a command-line inside the container: npm install to install the dependencies in package.json.
CMD: run script npm start after the image is built.

Setup React App

You can read and get Github source code from one of following tutorials:

Using the code base above, we put the React project in bezkoder-ui folder and do some work.

Firstly, let's remove .env file because we're gonna work with environment variable from Docker.

Then we open http-common.js for updating baseURL of axios instance with process.env.REACT_APP_API_BASE_URL.

import axios from "axios";

export default axios.create({
  baseURL: process.env.REACT_APP_API_BASE_URL || 'http://localhost:8080/api',
  headers: {
    "Content-type": "application/json"
  }
});

Create Dockerfile for React App

We're gonna deploy the React app behind an Nginx server.

Same as Nodejs, we put Dockerfile inside bezkoder-ui folder.

bezkoder-upi/Dockerfile

# Stage 1
FROM node:14 as build-stage

WORKDIR /bezkoder-ui
COPY package.json .
RUN npm install
COPY . .

ARG REACT_APP_API_BASE_URL
ENV REACT_APP_API_BASE_URL=$REACT_APP_API_BASE_URL

RUN npm run build

# Stage 2
FROM nginx:1.17.0-alpine

COPY --from=build-stage /bezkoder-ui/build /usr/share/nginx/html
EXPOSE $REACT_DOCKER_PORT

CMD nginx -g 'daemon off;'

There are two stage:

Stage 1: Build the React application
- FROM: install the image of the Node.js version.
- WORKDIR: path of the working directory.
- COPY: copy package.json file to the container, then the second one copies all the files inside the project directory.
- RUN: execute a command-line inside the container: npm install to install the dependencies in package.json.
- ARG and ENV: get argument and set environment variable (prefix REACT_APP_ is required).
- run script npm run build after the image is built, the product will be stored in build folder.
Stage 2: Serve the React application with Nginx
- install the image of the nginx alpine version.
- copy the react build from Stage 1 into /usr/share/nginx/html folder.
- expose port (should be 80) to the Docker host.
- daemon off; directive tells Nginx to stay in the foreground.

Write Docker Compose for MERN application

On the root of the project directory, we're gonna create the docker-compose.yml file for the MERN stack. Follow version 3 syntax defined by Docker:

version: '3.8'

services: 
    mongodb:
    bezkoder-api:
    bezkoder-ui:

volumes:

networks:

version: Docker Compose file format version will be used.
services: individual services in isolated containers. Our application has three services: bezkoder-ui (React), bezkoder-api (Nodejs) and mongodb (MongoDB database).
volumes: named volumes that keeps our data alive after restart.
networks: facilitate communication between containers

Let's implement the details.

docker-compose.yml

version: '3.8'

services:
  mongodb:
    image: mongo:5.0.2
    restart: unless-stopped
    env_file: ./.env
    environment:
      - MONGO_INITDB_ROOT_USERNAME=$MONGODB_USER
      - MONGO_INITDB_ROOT_PASSWORD=$MONGODB_PASSWORD
    ports:
      - $MONGODB_LOCAL_PORT:$MONGODB_DOCKER_PORT
    volumes:
      - db:/data/db
    networks:
      - backend

  bezkoder-api:
    depends_on:
      - mongodb
    build: ./bezkoder-api
    restart: unless-stopped
    env_file: ./.env
    ports:
      - $NODE_LOCAL_PORT:$NODE_DOCKER_PORT
    environment:
      - DB_HOST=mongodb
      - DB_USER=$MONGODB_USER
      - DB_PASSWORD=$MONGODB_PASSWORD
      - DB_NAME=$MONGODB_DATABASE
      - DB_PORT=$MONGODB_DOCKER_PORT
      - CLIENT_ORIGIN=$CLIENT_ORIGIN
    networks:
      - backend
      - frontend

  bezkoder-ui:
    depends_on:
      - bezkoder-api
    build:
      context: ./bezkoder-ui
      args:
        - REACT_APP_API_BASE_URL=$CLIENT_API_BASE_URL
    ports:
      - $REACT_LOCAL_PORT:$REACT_DOCKER_PORT
    networks:
      - frontend  

volumes: 
  db:

networks:
  backend:
  frontend:

mongodb:
- image: official Docker image
- restart: configure the restart policy
- env_file: specify our .env path that we will create later
- environment: provide setting using environment variables
- ports: specify ports will be used
- volumes: map volume folders
- networks: join backend network
bezkoder-api:
- depends_on: dependency order, mongodb service is started before bezkoder-api
- build: configuration options that are applied at build time that we defined in the Dockerfile with relative path
- environment: environmental variables that Node application uses
- networks: join both backend and frontent networks
bezkoder-ui:
- depends_on: start after bezkoder-api
- build-args: add build arguments - environment variables accessible only during the build process
- networks: join only frontent network

Docker Compose Environment variables

In the service configuration, we used environmental variables defined inside the .env file. Now we start writing it.

.env

MONGODB_USER=root
MONGODB_PASSWORD=123456
MONGODB_DATABASE=bezkoder_db
MONGODB_LOCAL_PORT=7017
MONGODB_DOCKER_PORT=27017

NODE_LOCAL_PORT=6868
NODE_DOCKER_PORT=8080

CLIENT_ORIGIN=http://127.0.0.1:8888
CLIENT_API_BASE_URL=http://127.0.0.1:6868/api

REACT_LOCAL_PORT=8888
REACT_DOCKER_PORT=80

Run MERN stack with Docker Compose

We can easily run the whole with only a single command:
docker-compose up

Docker will pull the MongoDB and Node.js images (if our machine does not have it before).

The services can be run on the background with command:
docker-compose up -d

$ docker-compose up -d
Creating network "react-node-mongodb_backend" with the default driver
Creating network "react-node-mongodb_frontend" with the default driver
Creating volume "react-node-mongodb_db" with default driver
Pulling mongodb (mongo:5.0.2)...
5.0.2: Pulling from library/mongo
16ec32c2132b: Pull complete
6335cf672677: Pull complete
cbc70ccc8ebe: Pull complete
0d1a3c6bd417: Pull complete
960f3b9b27d3: Pull complete
aff995a136b4: Pull complete
4249be7550a8: Pull complete
cc105ff5aa3c: Pull complete
82819807d07a: Pull complete
81447d2c233f: Pull complete
Digest: sha256:93ea50c5f15f9814870b3509449d327c5bc4d38f2b17c20acec528472811a723
Status: Downloaded newer image for mongo:5.0.2
Building bezkoder-api
Sending build context to Docker daemon  20.48kB
Step 1/6 : FROM node:14
 ---> 256d6360f157
Step 2/6 : WORKDIR /bezkoder-api
 ---> Running in 630b36161cfc
Removing intermediate container 630b36161cfc
 ---> cce099c5509c
Step 3/6 : COPY package.json .
 ---> 966883cd8e24
Step 4/6 : RUN npm install
 ---> Running in 246256e84187
npm notice created a lockfile as package-lock.json. You should commit this file.
npm WARN node-express-mongodb@1.0.0 No repository field.

added 82 packages from 128 contributors and audited 82 packages in 8.017s

2 packages are looking for funding
  run `npm fund` for details

found 0 vulnerabilities

Removing intermediate container 246256e84187
 ---> bdab72a5d37b
Step 5/6 : COPY . .
 ---> e9069d0ee44a
Step 6/6 : CMD npm start
 ---> Running in 6f63286cae18
Removing intermediate container 6f63286cae18
 ---> 65452914f005
Successfully built 65452914f005
Successfully tagged react-node-mongodb_bezkoder-api:latest
WARNING: Image for service bezkoder-api was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Building bezkoder-ui
Sending build context to Docker daemon  67.07kB
Step 1/12 : FROM node:14 as build-stage
 ---> 256d6360f157
Step 2/12 : WORKDIR /bezkoder-ui
 ---> Running in e135a434b996
Removing intermediate container e135a434b996
 ---> 80292facc18b
Step 3/12 : COPY package.json .
 ---> 595fbe352edd
Step 4/12 : RUN npm install
 ---> Running in 9d8ef80ff165

added 1661 packages from 793 contributors and audited 1666 packages in 115.944s

94 packages are looking for funding
  run `npm fund` for details

found 10 vulnerabilities (1 low, 5 moderate, 4 high)
  run `npm audit fix` to fix them, or `npm audit` for details
Removing intermediate container 9d8ef80ff165
 ---> 18a4f1382bc7
Step 5/12 : COPY . .
 ---> f99e2a8ef053
Step 6/12 : ARG REACT_APP_API_BASE_URL
 ---> Running in 47dca1457fb2
Removing intermediate container 47dca1457fb2
 ---> 8986f1482c8d
Step 7/12 : ENV REACT_APP_API_BASE_URL=$REACT_APP_API_BASE_URL
 ---> Running in 95687ba2d936
Removing intermediate container 95687ba2d936
 ---> 7a20778bca2b
Step 8/12 : RUN npm run build
 ---> Running in d0074ed04394

> react-crud@0.1.0 build /bezkoder-ui
> react-scripts build

Creating an optimized production build...
Compiled successfully.

File sizes after gzip:

  52.78 KB  build/static/js/2.c9e8967b.chunk.js
  22.71 KB  build/static/css/2.fa6c921b.chunk.css
  2.39 KB   build/static/js/main.aae2fe51.chunk.js
  776 B     build/static/js/runtime-main.99b514f4.js
  144 B     build/static/css/main.9c6cdb86.chunk.css

The project was built assuming it is hosted at /.
You can control this with the homepage field in your package.json.

The build folder is ready to be deployed.
You may serve it with a static server:

  npm install -g serve
  serve -s build

Find out more about deployment here:

  bit.ly/CRA-deploy

Removing intermediate container d0074ed04394
 ---> 9cd424a1901b
Step 9/12 : FROM nginx:1.17.0-alpine
 ---> bfba26ca350c
Step 10/12 : COPY --from=build-stage /bezkoder-ui/build /usr/share/nginx/html
 ---> 2b4cbdbd908e
Step 11/12 : EXPOSE $REACT_DOCKER_PORT
 ---> Running in ced23b1795d6
Removing intermediate container ced23b1795d6
 ---> 2850341d70f0
Step 12/12 : CMD nginx -g 'daemon off;'
 ---> Running in d596e17eec46
Removing intermediate container d596e17eec46
 ---> fef41917c48b
Successfully built fef41917c48b
Successfully tagged react-node-mongodb_bezkoder-ui:latest
WARNING: Image for service bezkoder-ui was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Creating react-node-mongodb_mongodb_1 ... done
Creating react-node-mongodb_bezkoder-api_1 ... done
Creating react-node-mongodb_bezkoder-ui_1  ... done

Now you can check the current working containers:

$ docker ps
CONTAINER ID   IMAGE                             COMMAND                  CREATED        STATUS         PORTS                                         NAMES
c9ee5ce3c370   react-node-mongodb_bezkoder-ui    "/bin/sh -c 'nginx -…"   Up 2 minutes   Up 2 minutes   0.0.0.0:8888->80/tcp, :::8888->80/tcp         react-node-mongodb_bezkoder-ui_1
f0c7d4174bdb   react-node-mongodb_bezkoder-api   "docker-entrypoint.s…"   Up 2 minutes   Up 2 minutes   0.0.0.0:6868->8080/tcp, :::6868->8080/tcp     react-node-mongodb_bezkoder-api_1
2f8390fc81dd   mongo:5.0.2                       "docker-entrypoint.s…"   Up 2 minutes   Up 2 minutes   0.0.0.0:7017->27017/tcp, :::7017->27017/tcp   react-node-mongodb_mongodb_1

And Docker images:

$ docker images
REPOSITORY                        TAG      IMAGE ID       CREATED         SIZE
react-node-mongodb_bezkoder-ui    latest   fef41917c48b   3 minutes ago   22MB
react-node-mongodb_bezkoder-api   latest   65452914f005   6 minutes ago   961MB
mongo                             5.0.2    269b735e72cb   7 minutes ago   682MB

Test the React UI:

MongoDB Database:

And Node.js Express API:

Stop the Application

Stopping all the running containers is also simple with a single command:
docker-compose down

$ docker-compose down
Stopping react-node-mongodb_bezkoder-ui_1  ... done
Stopping react-node-mongodb_bezkoder-api_1 ... done
Stopping react-node-mongodb_mongodb_1      ... done
Removing react-node-mongodb_bezkoder-ui_1  ... done
Removing react-node-mongodb_bezkoder-api_1 ... done
Removing react-node-mongodb_mongodb_1      ... done
Removing network react-node-mongodb_backend
Removing network react-node-mongodb_frontend

If you need to stop and remove all containers, networks, and all images used by any service in docker-compose.yml file, use the command:
docker-compose down --rmi all

Conclusion

Today we've successfully created MERN application with Docker and Nginx. Now we can deploy MERN stack: React + Nodejs Express and MongoDB on a very simple way: docker-compose.yml.

You can apply this way to one of following project:

Happy Learning! See you again.

Source Code

The source code for this tutorial can be found at Github.

JPA @ManyToOne example in Spring Boot

Tien Nguyen — Mon, 07 Aug 2023 01:26:10 +0000

In this tutorial, I will show you how to implement Spring Data JPA Many-to-One example in Spring Boot for One-To-Many mapping using @ManyToOne annotation. You'll know:

How to configure Spring Data, JPA, Hibernate to work with Database
How to define Data Models and Repository interfaces for JPA One-To-Many relationship using @ManyToOne
Way to use Spring JPA to interact with Database for Many-to-One association
Way to create Spring Rest Controller to process HTTP requests

JPA @ManyToOne is appropriate way for One To Many mapping in Spring

In a relational database, a One-to-Many relationship between table A and table B indicates that one row in table A links to many rows in table B, but one row in table B links to only one row in table A.

For example, you need to design data model for a Tutorial Blog in which One Tutorial has Many Comments. So this is a One-to-Many association.

You can map the child entities as a collection (List of Comments) in the parent object (Tutorial), and JPA/Hibernate provides the @OneToMany annotation for that case: only the parent-side defines the relationship. We call it unidirectional @OneToMany association.

For tutorial, please visit: JPA One To Many Unidirectional example.

Similarly, when only the child-side manage the relationship, we have unidirectional Many-to-One association with @ManyToOne annotation where the child (Comment) has an entity object reference to its parent entity (Tutorial) by mapping the Foreign Key column (tutorial_id).

The most appropriate way to implement JPA/Hibernate One To Many mapping is unidirectional Many-to-One association with @ManyToOne because:

With @OneToMany, we need to declare a collection (Comments) inside parent class (Tutorial), we cannot limit the size of that collection, for example, in case of pagination.
With @ManyToOne, you can modify the Repository:
- to work with Pagination
- or to sort/order by multiple fields

JPA ManyToOne example

We're gonna create a Spring project from scratch, then we implement JPA/Hibernate Many to One Mapping with tutorials and comments table as following:

We also write Rest Apis to perform CRUD operations on the Comment entities.

These are APIs that we need to provide:

Methods	Urls	Actions
POST	/api/tutorials/:id/comments	create new Comment for a Tutorial
GET	/api/tutorials/:id/comments	retrieve all Comments of a Tutorial
GET	/api/comments/:id	retrieve a Comment by `:id`
PUT	/api/comments/:id	update a Comment by `:id`
DELETE	/api/comments/:id	delete a Comment by `:id`
DELETE	/api/tutorials/:id	delete a Tutorial (and its Comments) by `:id`
DELETE	/api/tutorials/:id/comments	delete all Comments of a Tutorial

Assume that we've had tutorials table like this:

Here are the example requests:

Create new Comments: POST /api/tutorials/[:id]/comments

comments table after that:

Retrieve all Comments of specific Tutorial: GET /api/tutorials/[:id]/comments

Delete all Comments of specific Tutorial: DELETE /api/tutorials/[:id]/comments

Check the comment table, all Comments of Tutorial with id=2 were deleted:

Delete a Tutorial: DELETE /api/tutorials/[:id]

All Comments of the Tutorial with id=3 were CASCADE deleted automatically.

Let's build our Spring Boot @ManyToOne CRUD example.

Spring Boot ManyToOne example

Technology

Java 17 / 11 / 8
Spring Boot 3 / 2 (with Spring Web MVC, Spring Data JPA)
H2/PostgreSQL/MySQL
Maven

Project Structure

Let me explain it briefly.

– Tutorial, Comment data model class correspond to entity and table tutorials, comments.
– TutorialRepository, CommentRepository are interfaces that extends JpaRepository for CRUD methods and custom finder methods. It will be autowired in TutorialController, CommentController.
– TutorialController, CommentController are RestControllers which has request mapping methods for RESTful CRUD API requests.
– Configuration for Spring Datasource, JPA & Hibernate in application.properties.
– pom.xml contains dependencies for Spring Boot and MySQL/PostgreSQL/H2 database.

– About exception package, to keep this post straightforward, I won't explain it. For more details, you can read following tutorial:
@RestControllerAdvice example in Spring Boot

Create & Setup Spring Boot project

Use Spring web tool or your development tool (Spring Tool Suite, Eclipse, Intellij) to create a Spring Boot project.

Then open pom.xml and add these 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>

We also need to add one more dependency.

If you want to use MySQL:

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

or PostgreSQL:

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

or H2 (embedded database):

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Configure Spring Datasource, JPA, Hibernate

Under src/main/resources folder, open application.properties and write these lines.

For MySQL:

spring.datasource.url=jdbc:mysql://localhost:3306/testdb?useSSL=false
spring.datasource.username=root
spring.datasource.password=123456

spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect

# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto=update

For PostgreSQL:

spring.datasource.url=jdbc:postgresql://localhost:5432/testdb
spring.datasource.username=postgres
spring.datasource.password=123

spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto=update

spring.datasource.username & spring.datasource.password properties are the same as your database installation.
Spring Boot uses Hibernate for JPA implementation, we configure MySQLDialect for MySQL or PostgreSQLDialect for PostgreSQL
spring.jpa.hibernate.ddl-auto is used for database initialization. We set the value to update value so that a table will be created in the database automatically corresponding to defined data model. Any change to the model will also trigger an update to the table. For production, this property should be validate.

For H2 database:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update

spring.h2.console.enabled=true
# default path: h2-console
spring.h2.console.path=/h2-ui

spring.datasource.url: jdbc:h2:mem:[database-name] for In-memory database and jdbc:h2:file:[path/database-name] for disk-based database.
We configure H2Dialect for H2 Database
spring.h2.console.enabled=true tells the Spring to start H2 Database administration tool and you can access this tool on the browser: http://localhost:8080/h2-console.
spring.h2.console.path=/h2-ui is for H2 console's url, so the default url http://localhost:8080/h2-console will change to http://localhost:8080/h2-ui.

Define Data Model for JPA ManyToOne mapping

In model package, we define Tutorial and Comment class.

Tutorial has four fields: id, title, description, published.

model/Tutorial.java

package com.bezkoder.spring.hibernate.onetomany.model;

import jakarta.persistence.*;

@Entity
@Table(name = "tutorials")
public class Tutorial {

  @Id
  @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "tutorial_generator")
  private long id;

  @Column(name = "title")
  private String title;

  @Column(name = "description")
  private String description;

  @Column(name = "published")
  private boolean published;

  public Tutorial() {

  }

  public Tutorial(String title, String description, boolean published) {
    this.title = title;
    this.description = description;
    this.published = published;
  }

  // getters and setters
}

@Entity annotation indicates that the class is a persistent Java class.
@Table annotation provides the table that maps this entity.
@Id annotation is for the primary key.
@GeneratedValue annotation is used to define generation strategy for the primary key. GenerationType.SEQUENCE means using database sequence to generate unique values.
We also indicate the name of the primary key generator. If you don't give it the name, id value will be generated with hibernate_sequence table (supplied by persistence provider, for all entities) by default.
@Column annotation is used to define the column in database that maps annotated field.

The Comment class has the @ManyToOne annotation for many-to-one relationship with the Tutorial entity. optional element is set to false for non-null relationship.

model/Comment.java

package com.bezkoder.spring.hibernate.onetomany.model;

import jakarta.persistence.*;

import org.hibernate.annotations.OnDelete;
import org.hibernate.annotations.OnDeleteAction;

import com.fasterxml.jackson.annotation.JsonIgnore;

@Entity
@Table(name = "comments")
public class Comment {
  @Id
  @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "comment_generator")
  private Long id;

  @Lob
  private String content;

  @ManyToOne(fetch = FetchType.LAZY, optional = false)
  @JoinColumn(name = "tutorial_id", nullable = false)
  @OnDelete(action = OnDeleteAction.CASCADE)
  @JsonIgnore
  private Tutorial tutorial;

  // getters and setters
}

We also use the @JoinColumn annotation to specify the foreign key column (tutorial_id). If you don't provide the JoinColumn name, the name will be set automatically.

@JsonIgnore is used to ignore the logical property used in serialization and deserialization.

We also implement cascade delete capabilities of the foreign-key with @OnDelete(action = OnDeleteAction.CASCADE).

We set the @ManyToOne with FetchType.LAZY for fetch type:

By default, the @ManyToOne association uses FetchType.EAGER for fetch type but it is bad for performance:

public class Comment {
  ...

  @ManyToOne(fetch = FetchType.EAGER, optional = false)
  @JoinColumn(name = "tutorial_id", nullable = false)
  @OnDelete(action = OnDeleteAction.CASCADE)
  private Tutorial tutorial;

  ...
}

Create Repository Interfaces for ManyToOne mapping

Let's create a repository to interact with database.
In repository package, create TutorialRepository and CommentRepository interfaces that extend JpaRepository.

repository/TutorialRepository.java

package com.bezkoder.spring.hibernate.onetomany.repository;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;

import com.bezkoder.spring.hibernate.onetomany.model.Tutorial;

public interface TutorialRepository extends JpaRepository<Tutorial, Long> {
  List<Tutorial> findByPublished(boolean published);

  List<Tutorial> findByTitleContaining(String title);
}

repository/CommentRepository.java

package com.bezkoder.spring.hibernate.onetomany.repository;

import java.util.List;

import jakarta.transaction.Transactional;

import org.springframework.data.jpa.repository.JpaRepository;

import com.bezkoder.spring.hibernate.onetomany.model.Comment;

public interface CommentRepository extends JpaRepository<Comment, Long> {
  List<Comment> findByTutorialId(Long postId);

  @Transactional
  void deleteByTutorialId(long tutorialId);
}

Now we can use JpaRepository's methods: save(), findOne(), findById(), findAll(), count(), delete(), deleteById()... without implementing these methods.

We also define custom finder methods:

findByPublished(): returns all Tutorials with published having value as input published.
findByTitleContaining(): returns all Tutorials which title contains input title.
findByTutorialId(): returns all Comments of a Tutorial specified by tutorialId.
deleteByTutorialId(): deletes all Comments of a Tutorial specified by tutorialId.

The implementation is plugged in by Spring Data JPA automatically.

Now we can see the pros of @ManyToOne annotation.

With @OneToMany, we need to declare a collection inside parent class, we cannot limit the size of that collection, for example, in case of pagination.
With @ManyToOne, you can modify Repository:
- to work with Pagination, the instruction can be found at: Spring Boot Pagination & Filter example | Spring JPA, Pageable
- or to sort/order by multiple fields: Spring Data JPA Sort/Order by multiple Columns | Spring Boot
Please notice that above tutorials are for TutorialRepository, you need to apply the same way for CommentRepository .

More Derived queries at:
JPA Repository query example in Spring Boot

Custom query with @Query annotation:
Spring JPA @Query example: Custom query in Spring Boot

You also find way to write Unit Test for this JPA Repository at:
Spring Boot Unit Test for JPA Repository with @DataJpaTest

Create Spring Rest APIs Controller

Finally, we create controller that provides APIs for CRUD operations: creating, retrieving, updating, deleting and finding Tutorials and Comments.

controller/TutorialController.java

package com.bezkoder.spring.hibernate.onetomany.controller;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.CrossOrigin;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.bezkoder.spring.hibernate.onetomany.exception.ResourceNotFoundException;
import com.bezkoder.spring.hibernate.onetomany.model.Tutorial;
import com.bezkoder.spring.hibernate.onetomany.repository.TutorialRepository;

@CrossOrigin(origins = "http://localhost:8081")
@RestController
@RequestMapping("/api")
public class TutorialController {

  @Autowired
  TutorialRepository tutorialRepository;

  @GetMapping("/tutorials")
  public ResponseEntity<List<Tutorial>> getAllTutorials(@RequestParam(required = false) String title) {
    List<Tutorial> tutorials = new ArrayList<Tutorial>();

    if (title == null)
      tutorialRepository.findAll().forEach(tutorials::add);
    else
      tutorialRepository.findByTitleContaining(title).forEach(tutorials::add);

    if (tutorials.isEmpty()) {
      return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }

    return new ResponseEntity<>(tutorials, HttpStatus.OK);
  }

  @GetMapping("/tutorials/{id}")
  public ResponseEntity<Tutorial> getTutorialById(@PathVariable("id") long id) {
    Tutorial tutorial = tutorialRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("Not found Tutorial with id = " + id));

    return new ResponseEntity<>(tutorial, HttpStatus.OK);
  }

  @PostMapping("/tutorials")
  public ResponseEntity<Tutorial> createTutorial(@RequestBody Tutorial tutorial) {
    Tutorial _tutorial = tutorialRepository.save(new Tutorial(tutorial.getTitle(), tutorial.getDescription(), true));
    return new ResponseEntity<>(_tutorial, HttpStatus.CREATED);
  }

  @PutMapping("/tutorials/{id}")
  public ResponseEntity<Tutorial> updateTutorial(@PathVariable("id") long id, @RequestBody Tutorial tutorial) {
    Tutorial _tutorial = tutorialRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("Not found Tutorial with id = " + id));

    _tutorial.setTitle(tutorial.getTitle());
    _tutorial.setDescription(tutorial.getDescription());
    _tutorial.setPublished(tutorial.isPublished());

    return new ResponseEntity<>(tutorialRepository.save(_tutorial), HttpStatus.OK);
  }

  @DeleteMapping("/tutorials/{id}")
  public ResponseEntity<HttpStatus> deleteTutorial(@PathVariable("id") long id) {
    tutorialRepository.deleteById(id);

    return new ResponseEntity<>(HttpStatus.NO_CONTENT);
  }

  @DeleteMapping("/tutorials")
  public ResponseEntity<HttpStatus> deleteAllTutorials() {
    tutorialRepository.deleteAll();

    return new ResponseEntity<>(HttpStatus.NO_CONTENT);
  }

  @GetMapping("/tutorials/published")
  public ResponseEntity<List<Tutorial>> findByPublished() {
    List<Tutorial> tutorials = tutorialRepository.findByPublished(true);

    if (tutorials.isEmpty()) {
      return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }

    return new ResponseEntity<>(tutorials, HttpStatus.OK);
  }
}

controller/CommentController.java

package com.bezkoder.spring.hibernate.onetomany.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.CrossOrigin;
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.bezkoder.spring.hibernate.onetomany.exception.ResourceNotFoundException;
import com.bezkoder.spring.hibernate.onetomany.model.Comment;
import com.bezkoder.spring.hibernate.onetomany.repository.CommentRepository;
import com.bezkoder.spring.hibernate.onetomany.repository.TutorialRepository;

@CrossOrigin(origins = "http://localhost:8081")
@RestController
@RequestMapping("/api")
public class CommentController {

  @Autowired
  private TutorialRepository tutorialRepository;

  @Autowired
  private CommentRepository commentRepository;

  @GetMapping("/tutorials/{tutorialId}/comments")
  public ResponseEntity<List<Comment>> getAllCommentsByTutorialId(@PathVariable(value = "tutorialId") Long tutorialId) {
    if (!tutorialRepository.existsById(tutorialId)) {
      throw new ResourceNotFoundException("Not found Tutorial with id = " + tutorialId);
    }

    List<Comment> comments = commentRepository.findByTutorialId(tutorialId);
    return new ResponseEntity<>(comments, HttpStatus.OK);
  }

  @GetMapping("/comments/{id}")
  public ResponseEntity<Comment> getCommentsByTutorialId(@PathVariable(value = "id") Long id) {
    Comment comment = commentRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("Not found Comment with id = " + id));

    return new ResponseEntity<>(comment, HttpStatus.OK);
  }

  @PostMapping("/tutorials/{tutorialId}/comments")
  public ResponseEntity<Comment> createComment(@PathVariable(value = "tutorialId") Long tutorialId,
      @RequestBody Comment commentRequest) {
    Comment comment = tutorialRepository.findById(tutorialId).map(tutorial -> {
      commentRequest.setTutorial(tutorial);
      return commentRepository.save(commentRequest);
    }).orElseThrow(() -> new ResourceNotFoundException("Not found Tutorial with id = " + tutorialId));

    return new ResponseEntity<>(comment, HttpStatus.CREATED);
  }

  @PutMapping("/comments/{id}")
  public ResponseEntity<Comment> updateComment(@PathVariable("id") long id, @RequestBody Comment commentRequest) {
    Comment comment = commentRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("CommentId " + id + "not found"));

    comment.setContent(commentRequest.getContent());

    return new ResponseEntity<>(commentRepository.save(comment), HttpStatus.OK);
  }

  @DeleteMapping("/comments/{id}")
  public ResponseEntity<HttpStatus> deleteComment(@PathVariable("id") long id) {
    commentRepository.deleteById(id);

    return new ResponseEntity<>(HttpStatus.NO_CONTENT);
  }

  @DeleteMapping("/tutorials/{tutorialId}/comments")
  public ResponseEntity<List<Comment>> deleteAllCommentsOfTutorial(@PathVariable(value = "tutorialId") Long tutorialId) {
    if (!tutorialRepository.existsById(tutorialId)) {
      throw new ResourceNotFoundException("Not found Tutorial with id = " + tutorialId);
    }

    commentRepository.deleteByTutorialId(tutorialId);
    return new ResponseEntity<>(HttpStatus.NO_CONTENT);
  }
}

Conclusion

Today we've built a Spring Boot CRUD example using Spring Data JPA, Hibernate Many To One relationship with MySQL/PostgreSQL/embedded database (H2).

We also see that @ManyToOne annotation is the most appropriate way for implementing JPA One To Many Mapping, and JpaRepository supports a great way to make CRUD operations, custom finder methods without need of boilerplate code.

Custom query with @Query annotation:
Spring JPA @Query example: Custom query in Spring Boot

If you want to add Pagination to this Spring project, you can find the instruction at:
Spring Boot Pagination & Filter example | Spring JPA, Pageable

To sort/order by multiple fields:
Spring Data JPA Sort/Order by multiple Columns | Spring Boot

Handle Exception for this Rest APIs is necessary:

Or way to write Unit Test for the JPA Repository:
Spring Boot Unit Test for JPA Repository with @DataJpaTest

You can also know:

Validate Request Body in Spring Boot
how to deploy this Spring Boot App on AWS (for free) with this tutorial.
dockerize with Docker Compose: Spring Boot and MySQL example
way to upload an Excel file and store the data in MySQL database with this post
upload CSV file and store the data in MySQL with this post.

Happy learning! See you again.

Source Code

You can find the complete source code for this tutorial on Github.

Using @OneToMany instead: JPA One To Many Unidirectional example
Many-to-Many: JPA Many to Many example with Hibernate in Spring Boot
One-to-One: JPA One To One example with Hibernate in Spring Boot

You can apply this implementation in following tutorials:

More Derived queries at:
JPA Repository query example in Spring Boot

Documentation: Spring Boot + Swagger 3 example (with OpenAPI 3)
Caching: Spring Boot Redis Cache example

Angular 16 Pagination example

Tien Nguyen — Sat, 05 Aug 2023 01:13:25 +0000

In this tutorial, I will show you how to make Angular 16 Pagination example with existing API (server-side pagination) using ngx-pagination.

Fullstack with Node.js Express:
Server side Pagination with Node.js and Angular

Fullstack with Spring Boot:
Spring Boot + Angular: Server side Pagination example

Overview of Angular 16 Pagination example

One of the most important things to make a website friendly is the response time, and pagination comes for this reason. For example, this bezkoder.com website has hundreds of tutorials, and we don’t want to see all of them at once. Paging means displaying a small number of all, by a page.

Assume that we have tutorials table in database like this:

Our Angular 16 app will display the result with pagination:

You can change to a page with larger index:

Or change quantity of items per page:

Or paging with filter:

The API for this Angular client can be found at one of following posts:

These Servers will exports API for pagination (with/without filter), here are some url samples:

/api/tutorials?page=1&size=5
/api/tutorials?size=5: using default value for page
/api/tutorials?page=1: using default value for size
/api/tutorials?title=data&page=1&size=3: pagination & filter by title containing 'data'

This is structure of the response (server-side pagination) for the HTTP GET request:

{
    "totalItems": 8,
    "tutorials": [...],
    "totalPages": 3,
    "currentPage": 1
}

This is a kind of server-side paging, where the server sends just a single page at a time. ngx-pagination supports this scenario, so We actually only need to use tutorials and totalItems when working with this library.

ngx-pagination with Angular 16

ngx-pagination provides NgxPaginationModule for displaying pagination with numbers and responsive style.

There are 2 main things that we're gonna use:

PaginatePipe: placed at the end of an ngFor expression

<your-element *ngFor="let item of collection | paginate: { id: 'foo',
                                                      itemsPerPage: pageSize,
                                                      currentPage: page,
                                                      totalItems: total }">...</your-element>

Use the id if you need to support more than one instance of pagination at a time.

PaginationControlsComponent: a default component for displaying pagination controls

<pagination-controls></pagination-controls>

For example, this is the default display for simple pagination-controls above:

We can customize the label displayed on the "previous"/"next" link using previousLabel/nextLabel, and enable "responsive" to hide individual page links on small screens.

<pagination-controls
  previousLabel="Prev"
  nextLabel="Next"
  responsive="true"
></pagination-controls>

For handling page changes, we pass handlePageChange to pageChange.
Notice that count is totalItems in the API response, and page is the current page.

<pagination-controls
  (pageChange)="handlePageChange($event)"
></pagination-controls>

<ul>
  <li
    *ngFor="let tutorial of tutorials | paginate: {
              itemsPerPage: pageSize,
              currentPage: page,
              totalItems: count
            }"
  >
    {{ tutorial.title }}
  </li>
</ul>

@Component(...)
export class TutorialsListComponent {
  ...
  page = 1;

  handlePageChange(event) {
    this.page = event;
  }

}

pageChange is the expression invoked whenever the page changes via a click on the pagination controls. The $event argument will be the number of the new page.

There are more attributes that ngx-pagination supports:

<pagination-controls  id="some_id"
                      (pageChange)="pageChanged($event)"
                      (pageBoundsCorrection)="pageChanged($event)"
                      maxSize="9"
                      directionLinks="true"
                      autoHide="true"
                      responsive="true"
                      previousLabel="Previous"
                      nextLabel="Next"
                      screenReaderPaginationLabel="Pagination"
                      screenReaderPageLabel="page"
                      screenReaderCurrentLabel="You're on page">
</pagination-controls>

You can find the details at: https://www.npmjs.com/package/ngx-pagination.

Technology

Angular 16
RxJS 7
ngx-pagination 6

Setup Angular 16 Pagination Project

Let's open cmd and use Angular CLI to create a new Angular Project as following command:

ng new angular-16-pagination-example
? Would you like to add Angular routing? Yes
? Which stylesheet format would you like to use? CSS

You can follow step by step, or get source code in this post:
Angular 16 CRUD example with Web API

The Angular 16 Project contains structure that we only need to add some changes (in tutorials-list component and tutorial.service.ts) to make the pagination work well.

Or you can get the new Github source code at the end of this tutorial.

Setup ngx-pagination for Angular 16 Pagination example

We need to install ngx-pagination with command:
npm install ngx-pagination

Then open app.module.ts and import it:

...
import { HttpClientModule } from '@angular/common/http';
import { NgxPaginationModule } from 'ngx-pagination';

@NgModule({
  declarations: [ ... ],
  imports: [
    ...
    NgxPaginationModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }

Create Data Service

This service will use Angular HttpClient to send HTTP requests.

services/tutorial.service.ts

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { Tutorial } from '../models/tutorial.model';

const baseUrl = 'http://localhost:8080/api/tutorials';

@Injectable({
  providedIn: 'root'
})
export class TutorialService {

  constructor(private http: HttpClient) { }

  getAll(params: any): Observable<any> {
    return this.http.get<any>(baseUrl, { params });
  }

  // other CRUD operations
}

In the code above, you can see that we pass params object to GET method.
The params object will have one, two or all fields: title, page, size.

Create Angular 16 Component with Pagination

This component has:

a search bar for finding Tutorials by title.
a select element for quantity of items per page.
a PaginationControlsComponent component
a tutorials array displayed as a list on the left.
a selected Tutorial which is shown on the right.

components/tutorials-list/tutorials-list.component.html

<div class="list row">
  <div class="col-md-8">
    <div class="input-group mb-3">
      <input
        type="text"
        class="form-control"
        placeholder="Search by title"
        [(ngModel)]="title"
      />
      <div class="input-group-append">
        <button
          class="btn btn-outline-secondary"
          type="button"
          (click)="searchTitle()"
        >
          Search
        </button>
      </div>
    </div>
  </div>

  <div class="col-md-12">
    <pagination-controls
      previousLabel="Prev"
      nextLabel="Next"
      [responsive]="true"
      (pageChange)="handlePageChange($event)"
    ></pagination-controls>
  </div>

  <div class="col-md-6">
    <h4>Tutorials List</h4>

    <ul class="list-group">
      <li
        class="list-group-item"
        *ngFor="
          let tutorial of tutorials | paginate : {
                  itemsPerPage: pageSize,
                  currentPage: page,
                  totalItems: count
                };
          let i = index
        "
        ...
      >
        {{ tutorial.title }}
      </li>
    </ul>
  </div>
  ...

  <div class="mt-3">
    ...

    Items per Page:
    <select (change)="handlePageSizeChange($event)">
      <option *ngFor="let size of pageSizes" [ngValue]="size">
        {{ size }}
      </option>
    </select>
  </div>
</div>

We will have following variables:

search and display Tutorials:
- title
- tutorials
- currentTutorial and currentIndex
pagination:
- page: current page
- count: total pages
- pageSize: number of items in each page

For pagination, we're gonna use TutorialService.getAll() methods.

components/tutorials-list/tutorials-list.component.ts

import { Component, OnInit } from '@angular/core';
import { Tutorial } from 'src/app/models/tutorial.model';
import { TutorialService } from 'src/app/services/tutorial.service';

@Component({
  selector: 'app-tutorials-list',
  templateUrl: './tutorials-list.component.html',
  styleUrls: ['./tutorials-list.component.css']
})
export class TutorialsListComponent implements OnInit {

  tutorials: Tutorial[] = [];
  currentTutorial: Tutorial = {};
  currentIndex = -1;
  title = '';

  page = 1;
  count = 0;
  pageSize = 3;
  pageSizes = [3, 6, 9];

  constructor(private tutorialService: TutorialService) { }

  ngOnInit(): void {
    this.retrieveTutorials();
  }

  getRequestParams(searchTitle: string, page: number, pageSize: number): any {
    let params: any = {};

    if (searchTitle) {
      params[`title`] = searchTitle;
    }

    if (page) {
      params[`page`] = page - 1;
    }

    if (pageSize) {
      params[`size`] = pageSize;
    }

    return params;
  }

  retrieveTutorials(): void {
    const params = this.getRequestParams(this.title, this.page, this.pageSize);

    this.tutorialService.getAll(params)
    .subscribe(
      response => {
        const { tutorials, totalItems } = response;
        this.tutorials = tutorials;
        this.count = totalItems;
        console.log(response);
      },
      error => {
        console.log(error);
      });
  }

  handlePageChange(event: number): void {
    this.page = event;
    this.retrieveTutorials();
  }

  handlePageSizeChange(event: any): void {
    this.pageSize = event.target.value;
    this.page = 1;
    this.retrieveTutorials();
  }

  ...

  searchTitle(): void {
    this.page = 1;
    this.retrieveTutorials();
  }
}

Let me explain some lines of code.

In the retrieveTutorials() method:

We get title, page, pageSize value and transform them into params object:

{
    "title": searchTitle,
    "page": page - 1,
    "size": pageSize
}

We use tutorials and totalItems as count value from the response data:

{
    "totalItems": 8,
    "tutorials": [...],
    "totalPages": 3,
    "currentPage": 1
}

handlePageChange() and handlePageSizeChange() methods are for setting new page and pageSize, then we invoke retrieveTutorials() that updates the tutorials List when pagination information changes.

Run Angular 16 Pagination example

First you need to run the Server at one of following posts:

Then you can run our App with command: ng serve --port 8081.
If the process is successful, open Browser with Url: http://localhost:8081/ and check it.

Conclusion

Today we've built a Angular 16 Pagination example that consume API (server-side pagination) successfully with ngx-pagination. I hope you apply it in your project at ease.

Happy learning, see you again!

Source Code

You can find the complete source code for this tutorial on Github.

Express Typescript example

Tien Nguyen — Wed, 02 Aug 2023 02:08:27 +0000

Express is one of the most popular web frameworks for Node.js that supports routing, middleware, view system... In this tutorial, I will show you how to build Node.js Rest Api example using Express and Typescript.

Express Typescript example

We will build Node.js Rest Api using Typescript that handles GET/POST/PUT/DELETE Http requests.

First, we start with an Express web server. Next, we write the controller. Then we define routes for handling all CRUD operations:

The following table shows overview of the Rest APIs that will be exported:

Methods	Urls	Actions
GET	api/tutorials	get all Tutorials
GET	api/tutorials/:id	get Tutorial by `id`
POST	api/tutorials	add new Tutorial
PUT	api/tutorials/:id	update Tutorial by `id`
DELETE	api/tutorials/:id	remove Tutorial by `id`

Finally, we're gonna test the Express Typescript Rest Api using Postman.

Our project structure will be like this:

Create Node.js Typescript application

Open terminal/console, then create a folder for our application:



$ mkdir express-typescript-example
$ cd express-typescript-example

Initialize the Node.js application with a package.json file:



npm init

package name: (express-typescript-example) express-typescript-example
version: (1.0.0)
description: Rest API using Node.js, TypeScript, Express
entry point: (index.js) server.js
test command:
git repository:
keywords: nodejs, typescript, express, restapi, rest api, crud
author: bezkoder
license: (ISC)
About to write to D:\Projects\NodeTs\node-js-typescript-express-mysql\package.json:

{
  "name": "express-typescript-example",
  "version": "1.0.0",
  "description": "Rest API using Node.js, TypeScript, Express",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "nodejs",
    "typescript",
    "express",
    "restapi",
    "rest",
    "api",
    "crud"
  ],
  "author": "bezkoder",
  "license": "ISC"
}

Is this OK? (yes)

Add Express and Typescript into Node.js Project

We need to install necessary modules: express, typescript, cors, ts-node, @types/node, @types/express and @types/cors.

Run the command:



npm install typescript ts-node @types/node @types/express @types/cors --save-dev
npm install express cors

The package.json file should look like this:



{
  "name": "express-typescript-example",
  "version": "1.0.0",
  "description": "Rest API using Node.js, TypeScript, Express",
  "main": "server.ts",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "express",
    "typescript",
    "rest",
    "api",
    "restapi",
    "node",
    "nodejs",
    "crud"
  ],
  "author": "bezkoder",
  "license": "ISC",
  "devDependencies": {
    "@types/cors": "^2.8.13",
    "@types/express": "^4.17.17",
    "@types/node": "^20.3.3",
    "ts-node": "^10.9.1",
    "typescript": "^5.1.6"
  },
  "dependencies": {
    "cors": "^2.8.5",
    "express": "^4.18.2"
  }
}

Next, we generate a tsconfig.json file with command:



./node_modules/.bin/tsc --init

Open tsconfig.json and modify the content like this:



{
  "compilerOptions": {
    /* Language and Environment */
    "target": "es2016",                               /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
    "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
    "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */

    /* Modules */
    "module": "commonjs",                             /* Specify what module code is generated. */
    "resolveJsonModule": true,                        /* Enable importing .json files. */

    /* Emit */
    "outDir": "./build",                              /* Specify an output folder for all emitted files. */

    /* Interop Constraints */
    "esModuleInterop": true,                          /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
    "forceConsistentCasingInFileNames": true,         /* Ensure that casing is correct in imports. */

    /* Type Checking */
    "strict": true,                                   /* Enable all strict type-checking options. */

    /* Completeness */
    "skipLibCheck": true                              /* Skip type checking all .d.ts files. */
  }
}

To work with TypeScript, we need TypeScript compiler (tsc), which converts TypeScript code into JavaScript (inside ./build folder). TypeScript files have the .ts extension. Once compiled to JavaScript, we can run the resulting JavaScript files using a JavaScript runtime environment or include them in web applications.

So we modify "scripts" property of package.json file by adding build, dev and start like this:



{
  ...
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "build": "tsc",
    "dev": "node ./build/server.js",
    "start": "tsc && npm run dev"
  }
  ...
}

Create Express Typescript server

In src folder, create index.ts file that export Server class.



import express, { Application } from "express";
import cors, { CorsOptions } from "cors";

export default class Server {
  constructor(app: Application) {
    this.config(app);
  }

  private config(app: Application): void {
    const corsOptions: CorsOptions = {
      origin: "http://localhost:8081"
    };

    app.use(cors(corsOptions));
    app.use(express.json());
    app.use(express.urlencoded({ extended: true }));
  }
}

What we do are:

import express, and cors modules:
- Express is for building the Rest Apis
- cors provides Express middleware to enable CORS with various options.
define constructor() method that receives Express Application object as parameter.
in constructor(), we call config() method that adds body-parser (json and urlencoded) and cors middlewares using app.use() method. Notice that we set origin: http://localhost:8081.

We continue to create server.ts outside the src folder.



import express, { Application } from "express";
import Server from "./src/index";

const app: Application = express();
const server: Server = new Server(app);
const PORT: number = process.env.PORT ? parseInt(process.env.PORT, 10) : 8080;

app
  .listen(PORT, "localhost", function () {
    console.log(`Server is running on port ${PORT}.`);
  })
  .on("error", (err: any) => {
    if (err.code === "EADDRINUSE") {
      console.log("Error: address already in use");
    } else {
      console.log(err);
    }
  });

In the code, we:

create an Express application using express().
initialize a Server object with an Application object
listen on port 8080 for incoming requests.

Let's run the app with command: npm run start.



$ npm run start

> express-typescript-example@1.0.0 start
> tsc && npm run dev

> express-typescript-example@1.0.0 dev
> node ./build/server.js

Server is running on port 8080.

Working with Express Router in Typescript

To handle HTTP requests, we create a new Router object using express.Router() function.

In src/routes folder, create home.routes.ts file that exports Router object.



import { Router } from "express";
import { welcome } from "../controllers/home.controller";

class HomeRoutes {
  router = Router();

  constructor() {
    this.intializeRoutes();
  }

  intializeRoutes() {
    this.router.get("/", welcome);
  }
}

export default new HomeRoutes().router;

router.get("/", welcome) is for handling Http GET requests with welcome as handler function.

In src/controllers/home.controller.ts, we export welcome function.



import { Request, Response } from "express";

export function welcome(req: Request, res: Response): Response {
  return res.json({ message: "Welcome to bezkoder application." });
}

Next we create Routes class in src/routes/index.ts.



import { Application } from "express";
import homeRoutes from "./home.routes";

export default class Routes {
  constructor(app: Application) {
    app.use("/api", homeRoutes);
  }
}

Then we import Routes into Server class's constructor() method and initialize a new Routes object.



// ...
import Routes from "./routes";

export default class Server {
  constructor(app: Application) {
    this.config(app);
    new Routes(app);
  }

  private config(app: Application): void {
    // ...
  }
}

Let's stop and re-start the server. Open your browser with url http://localhost:8080/api, you will see:

Handling GET-POST-PUT-DELETE requests with Express Typescript

Now we implement more routes to Routes class that follows APIs:

Methods	Urls	Actions
GET	api/tutorials	get all Tutorials
GET	api/tutorials/:id	get Tutorial by `id`
POST	api/tutorials	add new Tutorial
PUT	api/tutorials/:id	update Tutorial by `id`
DELETE	api/tutorials/:id	remove Tutorial by `id`

In src/routes/index.ts, add middleware function for "/api/tutorials" endpoint.



import { Application } from "express";
import homeRoutes from "./home.routes";
import tutorialRoutes from "./tutorial.routes";

export default class Routes {
  constructor(app: Application) {
    app.use("/api", homeRoutes);
    app.use("/api/tutorials", tutorialRoutes);
  }
}

We continue to define the above TutorialRoutes class which initializes a TutorialController object that provides CRUD operation methods. It exports Router object.

src/routes/tutorial.routes.ts



import { Router } from "express";
import TutorialController from "../controllers/tutorial.controller";

class TutorialRoutes {
  router = Router();
  controller = new TutorialController();

  constructor() {
    this.intializeRoutes();
  }

  intializeRoutes() {
    // Create a new Tutorial
    this.router.post("/", this.controller.create);

    // Retrieve all Tutorials
    this.router.get("/", this.controller.findAll);

    // Retrieve a single Tutorial with id
    this.router.get("/:id", this.controller.findOne);

    // Update a Tutorial with id
    this.router.put("/:id", this.controller.update);

    // Delete a Tutorial with id
    this.router.delete("/:id", this.controller.delete);
  }
}

export default new TutorialRoutes().router;

In src/controllers/tutorial.controller.ts, we define and export TutorialController class that has create, findAll, findOne, update, delete methods.



import { Request, Response } from "express";

export default class TutorialController {
  async create(req: Request, res: Response) {
    try {
      res.status(201).json({
        message: "create OK",
        reqBody: req.body
      });
    } catch (err) {
      res.status(500).json({
        message: "Internal Server Error!"
      });
    }
  }

  async findAll(req: Request, res: Response) {
    try {
      res.status(200).json({
        message: "findAll OK"
      });
    } catch (err) {
      res.status(500).json({
        message: "Internal Server Error!"
      });
    }
  }

  async findOne(req: Request, res: Response) {
    try {
      res.status(200).json({
        message: "findOne OK",
        reqParamId: req.params.id
      });
    } catch (err) {
      res.status(500).json({
        message: "Internal Server Error!"
      });
    }
  }

  async update(req: Request, res: Response) {
    try {
      res.status(200).json({
        message: "update OK",
        reqParamId: req.params.id,
        reqBody: req.body
      });
    } catch (err) {
      res.status(500).json({
        message: "Internal Server Error!"
      });
    }
  }

  async delete(req: Request, res: Response) {
    try {
      res.status(200).json({
        message: "delete OK",
        reqParamId: req.params.id
      });
    } catch (err) {
      res.status(500).json({
        message: "Internal Server Error!"
      });
    }
  }
}

Run and Check

Run the Node.js Express Typescript Rest APIs with command:
npm run start

GET http://localhost:8080/api/tutorials

GET http://localhost:8080/api/tutorials/[id]

POST http://localhost:8080/api/tutorials

PUT http://localhost:8080/api/tutorials/[id]

DELETE http://localhost:8080/api/tutorials/[id]

Conclusion

Today, we've learned how to create Node.js Rest Apis with an Express Typescript web server. We also know way to write a controller and define routes for handling all CRUD operations.

Happy learning! See you again.

Source code

You can find the complete source code for this example on Github.

With Database:

Forem: Tien Nguyen

Spring Data REST example

Spring Data REST

Spring Data REST example

Technology

Project Structure

Create & Setup Spring Boot project

Configure Spring Data REST, JPA, h2, Hibernate

Define Data Model

Create Repository Interface

Configure CORS in Spring Data REST

Run & Test

Conclusion

Further Reading

Source Code

Spring Boot + GraphQL example

Spring Boot GraphQL example

Overview

CRUD GraphQL APIs

Step by step to build Spring Boot GraphQL example

Technology

Project Structure

Set up the project

Configure Spring Datasource, JPA, GraphQL

Extend Scalars for graphql-java Long type

Create GraphQL Schema

Define Data Models

Create Repositories

Implement GraphQL Root Query Resolver

Implement GraphQL Root Mutation Resolver

Implement GraphQL Field Resolver

Run & Check result

Conclusion

Further Reading

Source Code

Docker Compose: MongoDB and Spring Boot example

Overview

Create Spring Boot App

Create Dockerfile for Spring Boot App

Write Docker Compose configurations

Docker Compose Environment variables

Run the Spring Boot microservice with Docker Compose

Stop the Application

Conclusion

Source Code

Dockerize Nodejs and Postgres example

Dockerizing Node.js and Postgres Overview

Create Nodejs App

Create Dockerfile for Nodejs App

Write Docker Compose configurations

Docker Compose Environment variables with Postgres

Run Nodejs Postgres with Docker Compose

Stop the Application

Conclusion

Source Code

Global Exception Handler in Spring Boot

Exception handling Problem

Exception Handler with Controller Advice in Spring

@ResponseStatus

Setup Spring Boot Project

Define Error Response Message

Create Custom Exception

Create Controller Advice with @ExceptionHandler

Modify Controller for using @ControllerAdvice

Run and Test

Conclusion

Further Reading

Source Code

Docker Compose: Spring Boot and Postgres example

Overview

Create Spring Boot App

Create Dockerfile for Spring Boot App

Write Docker Compose configurations

Docker Compose Environment variables

Run the Spring Boot microservice with Docker Compose

Stop the Application

Conclusion

Source Code

Docker Node.js and MongoDB example

Node.js Express and MongoDB with Docker Overview