Spring Framework is built on top of servlets. This particular web framework comes with very essential features with which we can develop efficient and effective web applications. On top of Spring Framework, Spring Boot was released in April 2014. The main aim behind the Spring Boot was the feature of Auto-Configuration. Spring MVC ( Model View Controller ) is the sub-domain or sub-project of the Spring Framework which is embedded in Spring’s ‘Web Starter’ dependency. It is used for developing web applications. Web Starter also contains features for developing REST API. We use it to return the data or list of data instead of the HTML pages.
The data which is retrieved from a data source can be very large that it will be inconvenient to list all of them, that too directly. This retrieved or returned data can be controlled in a number of ways. For example, to limit the entities or objects return, the way they are sorted, etc. Here, Pagination comes into action.
Features of the Pagination
- Limit output to the respective set of items.
- Can traverse from one set of items to another set.
- Can handle the large offsets of data values.
- The output can be ordered. For eg – Ascending or Descending according to some property.
Working of Pagination using Spring’s REST API
Project Structure – Maven
A. File: pom.xml (Configuration of the application)
XML
<?xml version="1.0" encoding="UTF-8"?> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.6.4</version> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>sia</groupId> <artifactId>GFG-Pagination</artifactId> <version>0.0.1-SNAPSHOT</version> <name>GFG-Pagination</name> <description>GFG</description> <properties> <java.version>11</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> <optional>true</optional> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <excludes> <exclude> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </exclude> </excludes> </configuration> </plugin> </plugins> </build></project> |
B. GfgPaginationApplication.java
Java
// Java Program to Illustrate Bootstrapping of Applicationpackage gfg;// Importing required classesimport org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;// Annotation@SpringBootApplication// Classpublic class GfgPaginationApplication { // Main driver method public static void main(String[] args) { SpringApplication.run( GfgPaginationApplication.class, args); }} |
C. application.properties ( Configuration of the Properties )
- This file contains all the properties and their values that are required to build a Datasource object.
- The Datasource object is provided by the ‘Spring Data JPA’ dependency.
- The Spring Data JPA has the default implementation of the Hibernate.
- This file also contains some Hibernate properties.
- The Datasource object built is then used by the MySQL Driver to connect to the database.
- Therefore, we can also interact with the respective database.
Overview of MySQL database entity entries
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/userdetails spring.datasource.username=root spring.datasource.password=password spring.jpa.show-sql=true spring.jpa.hibernate.ddl-auto=update spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
D. UserEntity.java
This class is mapped to a table in a database.
1. Persistence Annotations:
- @Entity – It specifies that the class is an Entity. The ‘name’ attribute is used to map the Class name to the table name in the database if they are not the same.
- @Id – It specifies that the property it is applied on acts as a primary key for the respective table with which we can access the database.
2. Lombok Annotations
- @Data – It automatically generates Getter and Setter methods for all the fields at runtime.
- @RequiredArgsConstructor – It generates constructors for all required fields i.e The fields with keyword final or @NonNull annotation. If no such fields are present then a zero arguments constructor is created. This annotation is a part of @Data annotation.
The object of this class will be returned as a JSON response by the REST API.
Example:
Java
// Java Program to Illustrate Model Datapackage gfg;// Importing required classesimport javax.persistence.Entity;import javax.persistence.Id;import lombok.Data;import lombok.RequiredArgsConstructor;// Annotation@Data@RequiredArgsConstructor@Entity(name = "user")// Classpublic class UserEntity { @Id String user; String username; String password;} |
E. File: UserRepository.java
- This interface is used to work with databases without the need to write the cumbersome JDBC ( Java Database Connectivity ) methods.
- This interface extends ‘Interface JpaRepository<T, ID>’, Where T is an Object type and ID is the type of a primary key.
Note: JpaRepository has 4 superinterfaces QueryByExampleExecutor<T>, Repository<T,ID>, CrudRepository<T,ID> and PagingAndSortingRepository<T, ID> which is the one that provides essential Pagination features.
CrudRepository provides the generalized JDBC methods which run SQL scripts to interact with the databases.
(Create, Read, Update, Delete).
public interface PagingAndSortingRepository<T,ID> extends CrudRepository<T,ID>
Methods of PagingAndSortingRepository interface are as follows:
|
Method |
Description |
|---|---|
| Page<T> findAll(Pageable pageable) | Returns a Page of entities meeting the paging restriction provided in the Pageable object. |
| Iterable<T> findAll(Sort sort | Returns all entities sorted by the given options. |
Example:
Java
// Java Program to Illustrate Data Repositorypackage gfg;// Importing required classesimport org.springframework.data.jpa.repository.JpaRepository;// Interfacepublic interface UserRepository extends JpaRepository<UserEntity, String> {} |
F. File: PagedRestController.java
- This controller class returns a list of UserEntities objects as a response.
- Here, a Pageable object is created using PageRequest.of() factory method.
- This method accepts 3 arguments:
- A number of a respective page.
- Number of entries to retrieve per page.
- Sorting technique.
This object of Pageable is passed to the findAll() method of PagingAndSortingRepository<T, ID> which accepts the same respective object and returns a Page object. Then the items retrieved from the Page object are eventually returned.
Example:
Java
// Java Program to Illustrate REST APIpackage gfg;// Importing required classesimport java.util.List;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.data.domain.Page;import org.springframework.data.domain.PageRequest;import org.springframework.data.domain.Pageable;import org.springframework.data.domain.Sort;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestController@RequestMapping("/get")public class PagedRestController { // links automatically created repository bean in // Spring Application context @Autowired UserRepository data; @GetMapping("/page-One") public List<UserEntity> getPageOne() { // First page with 5 items Pageable paging = PageRequest.of( 0, 5, Sort.by("user").ascending()); Page<UserEntity> page = data.findAll(paging); // Retrieve the items return page.getContent(); } @GetMapping("/page-Two") public List<UserEntity> getPageTwo() { // Second page with another 5 items Pageable paging = PageRequest.of( 1, 5, Sort.by("user").ascending()); Page<UserEntity> page = data.findAll(paging); // Retrieve the items return page.getContent(); }} |
Output 1:
Items in First Page
Output 2:
Items in Second Page
Conclusion:
- As most industries work with large datasets, REST APIs are very popular and widely used as they help in returning data responses.
- Therefore, for them, Pagination becomes a very crucial feature for them to apply.
- It also helps to build a good and manageable UI ( User Interface).
