DEV Community: Ratul sharker

Using LiveReload with Spring boot devtools.

Ratul sharker — Sat, 15 Mar 2025 14:51:12 +0000

Background

Spring boot is a versatile framework to develop web applications. During development time, iteration of code change is a common thing. It is a plus point to see the effect of the code changes as fast as posible. Spring boot devtools enables developer to see the changed output most effectively.

Introducing the livereload into the picture, favors the development cycle. Livereload will automatically detect when to reload the browser intelligently.

What is LiveReload ?

LiveReload is a mechanism, which automatically detects any changes in the source code or any configuration (i.e environment) and then reload the browsers automatically.

To facilitate this feature, two part is necessary in the development system:

Some script in the browser end, which will listen to any changes and reload the browser.
A separate server in spring boot end, to notify the browser whenever code or any configuration has changed or not.

The script in the browser end is already developed as browser extension by developers:

Spring boot devtools ships with live reload server. Look for the log while running a project with spring-boot-devtools included:

2025-03-15T19:39:34.340+06:00  INFO 36364 --- [devtools] [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729

Livereload server uses the web socket for communication from spring boot devtools end to browser extension end.

Project setup

We will start from a scratch spring boot project. Lets head to Spring Initializer and select following dependencies:

Spring Web.
Thyemeleaf.
Spring Boot DevTools.

Extract the downloaded zip and open in your editor of choice. I have opened mine into visual studio code.

Now add an ExampleController.java containing following,

package com.example.devtools;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class ExampleController {

    @GetMapping(path = "/")
    public String index(Model model) {
        return "example";
    }
}

and inside the template folder added example.html.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Example</title>
</head>
<body>
    <h1>Hello world</h1>
</body>
</html>

To run the application from VSCode run option, add following run configuration

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "java",
            "name": "Devtools",
            "request": "launch",
            "mainClass": "com.example.devtools.DevtoolsApplication",
            "projectName": "devtools"
        }
    ]
}

Or the project can ran directly from terminal by following:

cd {PROJECT_DIRECTORY}
./mvnw spring-boot:run

Accessing the http://localhost:8080/ shows following:

Experiencing the LiveReload

Now run your application from run configuration or as maven goal. Open the browser and enable the LiveReload extension. Now do any change in the html and see the updates into the browser.

Look upon changing the html, the spring boot application server does not restarted.

But if we change anything in the java end, which requiring the java program to restart, devtools will automatically detect that and restart the server and browser automatically.

Inspecting the network tabs web socket section shows each reload triggers and data receive from the liverealod server.

Conclusion

Specifically saying for monolith applications, reloading the whole server for a design change is very frustrating, because it requires significant time to restart the application server.

Using the livereload with devtools can significantly reduce the change-checking time during development.

My understanding was wrong about readiness and liveliness probes

Ratul sharker — Tue, 28 Nov 2023 22:30:46 +0000

For measuring a services health, Kubernetes provides probes. By using these probes Kubernetes becomes aware when the container is healthy and un-healthy.

My understanding was ...

I was working on a micro service architecture based spring boot project, which is deployed into Kubernetes cluster.

We used probes to check the health of the services.

What is this probe ?
In the deployment definition, we provide a hook, which can be used to check the healthiness check of the service. There are several configuration of probes, http probes are the most common. Kubelet expect response code HTTP 200 OK to determine a service is working as expected.

There are two common kind of probes:

Readiness probe
Liveliness probe

Readiness Probe
If readiness probe is configured, kubernetes uses this readiness probe to route the traffic to a running container.

Liveliness Probe
If liveliness probe is configured, kubernetes uses this livelines probe to decide whether to keep a container or kill that container.

Our deployment configuration:

One of our deployment configuration is as following:

...
readinessProbe:
  httpGet:
    path: /actuator/health/readiness
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 30
livenessProbe:
  httpGet:
    path: /actuator/health/liveness
    port: 8080    
  initialDelaySeconds: 60
  periodSeconds: 60
...

Readiness probe configuration:
The probe starts firing right after 30 seconds the container is started. After each 30 seconds readiness probe's http call is fired. As the default successThreshold is 1 if container responded with HTTP 2xx then the container is marked as ready and traffic is routed to this container. If container does not return HTTP 2xx then it is retried failureThreshold times, which is defaulted to 3.

So the container gets initial 30(initialDelaySeconds) seconds and 3 (failureThreshold) times 30(periodSeconds) seconds in total 2 minute to get ready.

Liveliness probe configuration:
This probes starts firing after 60 seconds. My understanding was this probe starts firing after the container is marked as ready (This is where i was wrong). After each 60 seconds liveliness probe's http call is fired, failureThreshold defaulted to 3 this probe fires 3 times before killing the container.

So if container does not responded with HTTP 2xx within 60 (initialDelaySeconds) seconds and 3 (failureThreshold) times 60(periodSeconds) seconds in total 4 minutes before killing the container.

Where i was wrong:
My understanding was, liveliness probe is firing after the container passed the readiness probe checking.

Recently one of our service becomes bulky. That service requires around 4+ minute to start responding to any http request.

I was expecting, everything will be turned well without any changes in the readiness & liveliness probes. 2 minutes for readiness probe and 4 minutes for liveliness probe. So container should not get killed by kubelet before 6 minutes.

🚧⚠️ But container was getting killed!!! ⚠️🚧
🚧⚠️ Right after 4 minutes!!! ⚠️🚧

Reality check:

Right after the disaster, i googled, which directs me to this Github issue.

This issue states, readiness & liveliness probes are fired in parallel. Which explains the disaster. Container's liveliness probe check is started right after the container is started. Which explains the reason why my bulky service container was getting killed.

There is a newer probe startup probe (Although it was introduced in 2020, but i was not exposed to this earlier).

After this startup probe passed, the readiness & liveliness probe is fired in parallel.

Better understanding:
To get a better understanding of these probes, i setup a simple nodejs + express project.

server.js

const livelinessResponseStatusCode = parseInt(process.env.LIVELINESS_RESPONSE_STATUS_CODE || "200");
const readinessResponseStatusCode = parseInt(process.env.READINESS_RESPONSE_STATUS_CODE || "200");
const startupResponseStatusCode = parseInt(process.env.START_RESPONSE_STATUS_CODE || "200");

app.get('/liveliness', (req, res) => {
    console.log(`${new Date()} : Liveliness probe fired & returned : ${livelinessResponseStatusCode}` );
    res.status(livelinessResponseStatusCode);
    res.send("");
});

app.get('/readiness', (req, res) => {
    console.log(`${new Date()} : Readiness probe fired & returned : ${readinessResponseStatusCode}`);
    res.status(readinessResponseStatusCode);
    res.send("");
});

app.get('/startup', (req, res) => {
    console.log(`${new Date()} : Startup probe fired & returned : ${startupResponseStatusCode}`);
    res.status(startupResponseStatusCode);
    res.send("");
});

Dockerfile

FROM node:18.17.0-alpine3.18

RUN mkdir /app
WORKDIR /app

COPY . .

RUN npm ci --omit=dev

CMD [ "node", "server.js" ]

k8-probes-without-startup.yaml

# Namespace
apiVersion: v1
kind: Namespace
metadata:
  name: playground

---

# Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: k8-probes-deployment
  namespace: playground
  labels:
    app: k8-probes
spec:
  replicas: 1
  selector:
    matchLabels:
      app: k8-probes
  template:
    metadata:
      labels:
        app: k8-probes
    spec:
      containers:
      - name: k8-probes
        image: ratulsharker/k8-probes:latest
        ports:
        - containerPort: 3000
        livenessProbe:
          httpGet:
            path: /liveliness
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 60
        readinessProbe:
          httpGet:
            path: /readiness
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 30
        env:
        - name: LIVELINESS_RESPONSE_STATUS_CODE
          value: "500"
        - name: READINESS_RESPONSE_STATUS_CODE
          value: "500"
        - name: START_RESPONSE_STATUS_CODE 
          value: "500"

For testing i used killercoda.com.

Cloning the repository

controlplane $ git clone https://github.com/ratulSharker/k8-probes.git
Cloning into 'k8-probes'...
remote: Enumerating objects: 35, done.
remote: Counting objects: 100% (35/35), done.
remote: Compressing objects: 100% (27/27), done.
remote: Total 35 (delta 17), reused 26 (delta 8), pack-reused 0
Unpacking objects: 100% (35/35), 11.87 KiB | 1.98 MiB/s, done.

Getting into the cloned repository:

controlplane $ cd k8-probes/

Running the deployment without startup probe

controlplane $ kubectl apply -f k8-probes-without-startup.yaml 
namespace/playground created
deployment.apps/k8-probes-deployment created
controlplane $ kubectl logs -f deployment/k8-probes-deployment -n playground
Example app listening on port 3000
Tue Nov 28 2023 20:16:23 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:16:53 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:16:53 GMT+0000 (Coordinated Universal Time) : Liveliness probe fired & returned : 500
Tue Nov 28 2023 20:17:15 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:17:23 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:17:53 GMT+0000 (Coordinated Universal Time) : Liveliness probe fired & returned : 500
Tue Nov 28 2023 20:17:53 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:18:23 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:18:43 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:18:53 GMT+0000 (Coordinated Universal Time) : Liveliness probe fired & returned : 500
Tue Nov 28 2023 20:18:53 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:18:53 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:19:23 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500

So it is definite that, liveliness & readiness probes are firing in parallel. Container get restarted eventually after 3 minutes 5 seconds.

Now try with k8-probes-with-startup.yaml

k8-probes-with-startup.yaml

startupProbe:
  httpGet:
    path: /startup
    port: 3000
  initialDelaySeconds: 5
  periodSeconds: 20
env:
...
- name: START_RESPONSE_STATUS_CODE 
  value: "200"

Now before starting the container with startup probe, delete the previous deployment:

controlplane $ kubectl delete deployment k8-probes-deployment -n playground
deployment.apps "k8-probes-deployment" deleted

Running the deployment with startup probe:

controlplane $ kubectl apply -f k8-probes-with-startup.yaml 
namespace/playground unchanged
deployment.apps/k8-probes-deployment created

Inspecing the logs

controlplane $ kubectl logs -f deployment/k8-probes-deployment -n playground
Example app listening on port 3000
Tue Nov 28 2023 20:30:07 GMT+0000 (Coordinated Universal Time) : Startup probe fired & returned : 200
Tue Nov 28 2023 20:30:08 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:30:09 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:30:17 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:30:47 GMT+0000 (Coordinated Universal Time) : Readiness probe fired & returned : 500
Tue Nov 28 2023 20:30:47 GMT+0000 (Coordinated Universal Time) : Liveliness probe fired & returned : 500
... continues to previous pattern

Readiness and Liveliness probe is fired, after the Startup probe is passed.

Now changing the environment START_RESPONSE_STATUS_CODE to 500. Deleting existing deployment, starting the deployment again and inspecting the logs again:

controlplane $ kubectl delete deployment k8-probes-deployment -n playground
deployment.apps "k8-probes-deployment" deleted
controlplane $ kubectl apply -f k8-probes-with-startup.yaml
namespace/playground unchanged
deployment.apps/k8-probes-deployment created
controlplane $ kubectl logs -f deployment/k8-probes-deployment -n playground
Example app listening on port 3000
Tue Nov 28 2023 20:33:36 GMT+0000 (Coordinated Universal Time) : Startup probe fired & returned : 500
Tue Nov 28 2023 20:33:56 GMT+0000 (Coordinated Universal Time) : Startup probe fired & returned : 500
Tue Nov 28 2023 20:34:16 GMT+0000 (Coordinated Universal Time) : Startup probe fired & returned : 500
controlplane $ kubectl get po -n playground
NAME                                    READY   STATUS    RESTARTS      AGE
k8-probes-deployment-76c67669b5-cxl7v   0/1     Running   1 (17s ago)   107s

So if the ready probe is not passed, then readiness and liveliness probe does not fired up. After defaulted failureThreshold(3) failed attempt the container get restarted.

Conclusion:

Final understanding

Startup Probe:
- Fired right after container started.
- If passed, then fires readiness & liveliness (if declared).
- If not passed, then container restarted.
Readiness Probe:
- If startup probe declared then fired after startup passed.
- If startup probe not declared then fired right after container started.
- If passed, then traffics are routed to the container.
Liveliness Probe:
- If startup probe declared then fired after startup passed.
- If startup probe not declared then fired right after container started.
- If passed, then container is kept as it is.
- If not passed, then container get killed.

Repository used in the above cases can be accessed in Github.

CSV Generation From Large JSON Response in Spring

Ratul sharker — Mon, 10 Oct 2022 20:24:51 +0000

Background

With the continuation of Streaming Large JSON Response in Spring and Consume Large JSON Response in Spring now time to put a real world scenario to generate a report based on the received response data. We will be generate a csv (comma separated value) report based on the received response data.

Goal

Consume Large JSON Response in Spring here we received list of Employee pojo which looks like following

Employee.java

public class Employee {

    private Long empNo;

    private Date birthDate;

    private String firstName;

    private String lastName;

    private Gender gender;

    private Date hireDate;
}

From here we will be generating a csv file. The goal here to generate the whole csv file in the file system. Then serve the csv file over the network from the file system directly without putting pressure on the heap memory.

Firstly a get request will show a web page, containing the prompt for download the report. Clicking on the prompting button will initiate generating the csv file and end up downloading that file within the browser.

Implementation

First task is easy, designing a landing page with the "Download Report" prompt button.

inside the template folder

employee-report


... CSS details are skipped for focus

<body>
    <a href="/download-employee-report" download>Download Report</a>
</body>

EmployeeController.java

@GetMapping("/employee-report")
public String getReportDownloadPage() {
    return "employee-report";
}

Now running the consumer application, and hitting http://localhost:8081/employee-report will show up following

Now time to implement route /download-employee-report.

Now we need the jackson-dataformat-csv dependency, using maven

pom.xml

<dependencies>
    <dependency>
        <groupId>com.fasterxml.jackson.dataformat</groupId>
        <artifactId>jackson-dataformat-csv</artifactId>
        <version>2.13.0</version>
    </dependency>
</dependencies>

Before doing that we need CSVMapper bean

WebConfig.java

@Configuration
public class WebConfig {

    ... Previous Code

    @Bean
    @Primary
    public ObjectMapper restTemplateObjectMapper(RestTemplate restTemplate) ... Previous Code

    @Bean(name = "csv-mapper")
    public CsvMapper csvMapper() {
        CsvMapper csvMapper = new CsvMapper();        
        return csvMapper;
    }

}

CSVMapper is subclass of ObjectMapper, so break the confusion while bean injection of ObjectMapper, we declared @Primary annotation on top of ObjectMapper bean creation. To inject the CSVMapper bean we need to add @Qualifier("csv-mapper") before bean injection.

Now Injecting the CSVMapper

EmployeeReportService.java

@Service
public class EmployeeReportService {

    private final RestTemplate restTemplate;
    private final ObjectMapper objectMapper;
    private final CsvMapper csvMapper;

    public EmployeeReportService(RestTemplate restTemplate, ObjectMapper objectMapper,
            @Qualifier("csv-mapper") CsvMapper csvMapper) {
        this.restTemplate = restTemplate;
        this.objectMapper = objectMapper;
        this.csvMapper = csvMapper;
    }

    ... Previous Code
}

From Consume Large JSON Response in Spring we already have

EmployeeReportService.java

public Long fetchAllEmployee(Consumer<Employee> employeeConsumer) {

    String url = "http://localhost:8080/employees?stream=true";

    return restTemplate.execute(url, HttpMethod.GET, null, (response) -> {

        Long employeeCount = 0L;

        JsonParser jsonParser = objectMapper.getFactory().createParser(response.getBody());

        if(jsonParser.nextToken() == JsonToken.START_OBJECT) {
            if(jsonParser.nextFieldName() == "employees") {
                if(jsonParser.nextToken() == JsonToken.START_ARRAY) {
                    while(jsonParser.nextToken() != JsonToken.END_ARRAY) {
                        Employee employee = jsonParser.readValueAs(Employee.class);
                        employeeConsumer.accept(employee);
                        employeeCount++;
                    }
                }
            }
        }

        jsonParser.close();

        return employeeCount;
    });

}

It allow us to getting Employee pojo one by one from the response. Now using the above method

EmployeeReportService.java

@Service
public class EmployeeReportService {

    ... Previous Code

    public File prepareEmployeeReportFile() throws IOException {

        CsvSchema schema = csvMapper.schemaFor(Employee.class);

        File tempFile = null;
        FileOutputStream fos = null;

        try {

            tempFile = File.createTempFile("employee", "csv");
            fos = new FileOutputStream(tempFile);
            CsvGenerator csvGenerator = csvMapper.getFactory().createGenerator(fos);
            csvGenerator.setSchema(schema);

            fetchAllEmployee((employee) -> {
                try {
                    csvGenerator.writeObject(employee);
                } catch(IOException ex) {
                    throw new RuntimeException(ex);
                }
            });


        } catch(IOException ex) {
            if(fos != null) {
                fos.close();
            }
            if(tempFile != null) {
                tempFile.delete();
            }
        } finally {
            if(fos != null) {
                fos.close();
            }
        }
        return tempFile;
    }
}

From the top of the view, this method return the temporary csv File generated from the response.

Now explaining step by step.

First declare the schema for the csv file.
Create a temporary file into the file system's temp directory and getting the FileOutputStream.
From the CSVMapper bean and FileOutputStream from previous step, a CSVGenerator is prepared to write csv into the FileOutputStream. Schema generated in the first step, is also set on CSVGenerator.
Using the fetchAllEmployee writing Employee object one by one into the temporary file.
Whole task is wrapped inside try...catch...finally to ensure that any unwanted incident closes the FileOutputStream and deletes the temporary file.
Finally return the temporary file.

Now the /download-employee-report route implementation

EmployeeController.java

@GetMapping("/download-employee-report")
public void downloadEmployeeReport(HttpServletResponse response) throws IOException {

    response.setContentType("application/octet-stream");
    response.setHeader("Content-disposition", "attachment; filename=employees.csv");

    File csvTempFile = employeeReportService.prepareEmployeeReportFile();
    FileInputStream fis = new FileInputStream(csvTempFile);

    IOUtils.copy(fis, response.getOutputStream());

    fis.close();

    //TODO: Need to be more careful about deleting this file.
    csvTempFile.delete();
}

Here, setting the proper headers for file content type and attachment file name. Copying the whole file into the HttpServletResponse's output stream. Thus ensured the whole file is not loaded into memory.

Finally closing the stream and remove the temporary file.

Here the implementation should be more careful, because any sort of IOException can occur during the IOUtils.copy(...).

Securing the implementation will look as follows

FileInputStream fis = null;
try {

    fis = new FileInputStream(csvTempFile);
    IOUtils.copy(fis, response.getOutputStream());

} catch(IOException ex) {
    // Handle the exception
} finally {
    if(fis != null) {
        fis.close();
    }

    if(csvTempFile != null) {
        csvTempFile.delete();
    }    
}

Now running both the server and consumer application with -Xmx32m jvm argument, visit the http://localhost:8081/employee-report route and click the Download Report prompt button. It will initiate a employees.csv file download.

Content of the employees.csv look like following

-536824800000,10001,Georgi,M,504640800000,Facello
-189669600000,10002,Bezalel,F,473191200000,Simmel
-347522400000,10003,Parto,M,504640800000,Bamford
-505375200000,10004,Chirstian,M,504640800000,Koblick
-473925600000,10005,Kyoichi,M,599594400000,Maliniak
-536824800000,10006,Anneke,F,599594400000,Preusig
-410421600000,10007,Tzvetan,F,599594400000,Zielinski
-378972000000,10008,Saniya,M,756842400000,Kalloufi
... ~300K Entries

So we successfully downloaded the csv file, but without header line nothing is understood.

To appear the header

EmployeeReportService.java

public File prepareEmployeeReportFile() throws IOException {

    CsvSchema schema = csvMapper.schemaFor(Employee.class).withHeader(); // Instruction for header to appear
    ... Previous Code     
}

Now the output becomes

birthDate,empNo,firstName,gender,hireDate,lastName
-536824800000,10001,Georgi,M,504640800000,Facello
-189669600000,10002,Bezalel,F,473191200000,Simmel
-347522400000,10003,Parto,M,504640800000,Bamford
-505375200000,10004,Chirstian,M,504640800000,Koblick
-473925600000,10005,Kyoichi,M,599594400000,Maliniak
-536824800000,10006,Anneke,F,599594400000,Preusig
-410421600000,10007,Tzvetan,F,599594400000,Zielinski
-378972000000,10008,Saniya,M,756842400000,Kalloufi
... ~300K Entries

Now the headers appear. But still few problems

Ordering of the columns are not as expected.
Dates are showing in in-human format.

By default the serial of the column is done in alphabetical order. To serial according to out necessity we need following on top of Employee.java

Employee.java

@Getter
@Setter
@NoArgsConstructor
@JsonPropertyOrder({"empNo", "firstName", "lastName", "gender", "birthDate", "hireDate"})
public class Employee {
    ... Previous Code
}

Doing so the downloaded employees.csv looks like following

empNo,firstName,lastName,gender,birthDate,hireDate
10001,Georgi,Facello,M,-536824800000,504640800000
10002,Bezalel,Simmel,F,-189669600000,473191200000
10003,Parto,Bamford,M,-347522400000,504640800000
10004,Chirstian,Koblick,M,-505375200000,504640800000
10005,Kyoichi,Maliniak,M,-473925600000,599594400000
10006,Anneke,Preusig,F,-536824800000,599594400000
10007,Tzvetan,Zielinski,F,-410421600000,599594400000
10008,Saniya,Kalloufi,M,-378972000000,756842400000
... ~300K Entries

So our column is according to our need.

Now time for the date format. To customise the date format update the CSVMapper bean creation

WebConfig.java

@Bean(name = "csv-mapper")
public CsvMapper csvMapper() {
    CsvMapper csvMapper = new CsvMapper();
    csvMapper.setDateFormat(new SimpleDateFormat("dd MMMM YYYY")); // Setting the date format.
    return csvMapper;
}

Now the downloaded csv looks like following

empNo,firstName,lastName,gender,birthDate,hireDate
10001,Georgi,Facello,M,"28 December 1953","29 December 1986"
10002,Bezalel,Simmel,F,"29 December 1964","30 December 1985"
10003,Parto,Bamford,M,"28 December 1959","29 December 1986"
10004,Chirstian,Koblick,M,"27 December 1954","29 December 1986"
10005,Kyoichi,Maliniak,M,"26 December 1955","01 January 1989"
10006,Anneke,Preusig,F,"28 December 1953","01 January 1989"
10007,Tzvetan,Zielinski,F,"30 December 1957","01 January 1989"
... ~300K Entries

So our expected date format is in action.

Still the header names are not human friendly. i.e instead of empNo "Employee No" is more preferred. To add this customisation, we need to add @JsonGetter in the getter method. We are using lombok, so adding the @JsonGetter will look like following

Employee.java

@Setter
@NoArgsConstructor
@JsonPropertyOrder({"empNo", "firstName", "lastName", "gender", "birthDate", "hireDate"})
public class Employee {

    @Getter(onMethod = @__(@JsonGetter("Employee No")))
    private Long empNo;

    @Getter(onMethod = @__(@JsonGetter("Birth Date")))
    private Date birthDate;

    @Getter(onMethod = @__(@JsonGetter("First Name")))
    private String firstName;

    @Getter(onMethod = @__(@JsonGetter("Last Name")))
    private String lastName;

    @Getter(onMethod = @__(@JsonGetter("Gender")))
    private Gender gender;

    @Getter(onMethod = @__(@JsonGetter("Hire Date")))
    private Date hireDate;
}

Now trying with the csv will give us

"Employee No","First Name","Last Name",Gender,"Birth Date","Hire Date"
,,,,,
,,,,,
,,,,,
,,,,,
,,,,,
,,,,,
,,,,,
... ~300K Entries

Header line is fine, but what happened to our data ?

Remember, the same pojo is used during deserialisation from the API. So we need to be more careful during deserialisation. We also need to update the @Setter with @JsonSetter. Doing so the final pojo will be

Employee.java

@NoArgsConstructor
@JsonPropertyOrder({"empNo", "firstName", "lastName", "gender", "birthDate", "hireDate"})
public class Employee {

    @Getter(onMethod = @__(@JsonGetter("Employee No")))
    @Setter(onMethod = @__(@JsonSetter("empNo")))
    private Long empNo;

    @Getter(onMethod = @__(@JsonGetter("Birth Date")))
    @Setter(onMethod = @__(@JsonSetter("birthDate")))
    private Date birthDate;

    @Getter(onMethod = @__(@JsonGetter("First Name")))
    @Setter(onMethod = @__(@JsonSetter("firstName")))
    private String firstName;

    @Getter(onMethod = @__(@JsonGetter("Last Name")))
    @Setter(onMethod = @__(@JsonSetter("lastName")))
    private String lastName;

    @Getter(onMethod = @__(@JsonGetter("Gender")))
    @Setter(onMethod = @__(@JsonSetter("gender")))
    private Gender gender;

    @Getter(onMethod = @__(@JsonGetter("Hire Date")))
    @Setter(onMethod = @__(@JsonSetter("hireDate")))
    private Date hireDate;
}

Downloading the csv file will be look like

"Birth Date","Employee No","First Name",Gender,"Hire Date","Last Name"
"28 December 1953",10001,Georgi,M,"29 December 1986",Facello
"29 December 1964",10002,Bezalel,F,"30 December 1985",Simmel
"28 December 1959",10003,Parto,M,"29 December 1986",Bamford
"27 December 1954",10004,Chirstian,M,"29 December 1986",Koblick
"26 December 1955",10005,Kyoichi,M,"01 January 1989",Maliniak
"28 December 1953",10006,Anneke,F,"01 January 1989",Preusig
... ~300K Entries

Now see the header line is scrambled again. Fixing the values of @JsonPropertyOrder will look like

@NoArgsConstructor
@JsonPropertyOrder({"Employee No", "First Name", "Last Name", "Gender", "Birth Date", "Hire Date"})
public class Employee {
    ... Previous Code
}

Doing so the generated csv will be as follows

"Employee No","First Name","Last Name",Gender,"Birth Date","Hire Date"
10001,Georgi,Facello,M,"28 December 1953","29 December 1986"
10002,Bezalel,Simmel,F,"29 December 1964","30 December 1985"
10003,Parto,Bamford,M,"28 December 1959","29 December 1986"
10004,Chirstian,Koblick,M,"27 December 1954","29 December 1986"
10005,Kyoichi,Maliniak,M,"26 December 1955","01 January 1989"
10006,Anneke,Preusig,F,"28 December 1953","01 January 1989"
... ~300K Entries

Perfect !!!

Still few things are not quiet right, downloading of the csv took long time, but there is no indication that we have clicked the "Download Report" and csv generation is in progress. This issue will be covered in a separate post.

All the code above can be found into my github repository.

Consume Large JSON Response in Spring

Ratul sharker — Sat, 08 Oct 2022 21:01:02 +0000

Background

In the previous post Streaming Large JSON Response in Spring. we generated large json as response. In this article, we will consuming that response, without heap memory overflow.

Goal

In this post, the sole target is to consume that large json response and as an exercise do some basic calculation as a proof of concept about receiving the json response.

As a reference we receive following json contents from the server application

{
    "employees" : [
        {
            "empNo":10001,
            "birthDate":"02 September 1953",
            "firstName":"Georgi",
            "lastName":"Facello",
            "gender":"M",
            "hireDate":"26 June 1986"
        }
        ... ~300K employee entries
    ]
}

We will be counting following

Number of female employee.
Number of male employee.
Total number of employee.

NB: The statistics done with the employee list is for demonstration purpose and no way near to real world scenario. Do not take these examples here literally, like counting the number of total, male and female employees from employee list is not the ideal way. Better calculate at database end using aggregate functions.

We will be creating a simple "Spring Web Application" using

Spring Boot (2.7.4)
Spring Web.
Thymeleaf.
Lombok and Spring Boot Devtools.

Implementation

Start with the enum and pojo declaration

Gender.java

public enum Gender {
    M,F;
}

Employee.java

@Getter
@Setter
@NoArgsConstructor
public class Employee {

    private Long empNo;

    private Date birthDate;

    private String firstName;

    private String lastName;

    private Gender gender;

    private Date hireDate;
}

EmployeeStats.java

@Getter
@Setter
@NoArgsConstructor
public class EmployeeStats {

    private Long totalEmployeeCount;

    private Long femaleEmployeeCount = 0L;

    private Long maleEmployeeCount = 0L;

    private Long reportGenerationDelayInSeconds;

    public void incrementFemaleEmployeeCount() {
        femaleEmployeeCount++;
    }

    public void incrementMaleEmployeeCount() {
        maleEmployeeCount++;
    }
}

Nothing fancy here, just a stats pojo, which will be holding all the statistics with some convenient method for doing the counting.

We will be using RestTemplate for the HTTP communication. So lets configure a bean for RestTemplate

WebConfig.java

@Configuration
public class WebConfig {

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        for(HttpMessageConverter<?> converter : restTemplate.getMessageConverters()) {
            if(converter instanceof MappingJackson2HttpMessageConverter) {
                MappingJackson2HttpMessageConverter jacksonConverter = (MappingJackson2HttpMessageConverter) converter;
                ObjectMapper objectMapper = jacksonConverter.getObjectMapper();
                objectMapper.setDateFormat(new SimpleDateFormat("dd MMMM YYYY"));
            }
        }
        return restTemplate;
    }

    @Bean
    public ObjectMapper restTemplateObjectMapper(RestTemplate restTemplate) {
        for(HttpMessageConverter<?> converter : restTemplate.getMessageConverters()) {
            if(converter instanceof MappingJackson2HttpMessageConverter) {
                return ((MappingJackson2HttpMessageConverter) converter).getObjectMapper();
            }
        }

        return null;
    }
}

Important thing to notice here, we customised the date format for converter MappingJackson2HttpMessageConverter to align with the json response date format.

An extra bean of ObjectMapper is also exposed from the RestTemplate's converter. We will be needing that next, while deserialising the json response.

Receiving response chunk by chunk

Now the most lucrative part of this whole writing, doing the HTTP request and receive the response. From the previous article Streaming Large JSON Response in Spring it is obvious that, loading the whole response in a pojo will exhaust the heap memory. Here we will not receive the whole response at once, we will connect a JsonParser into the response's input stream and parse received json as per our need. Thus we will be moving along with the whole response without actually loading it fully in the memory.

EmployeeReportService.java

@Service
@RequiredArgConstruct
public class EmployeeReportService {

    private final RestTemplate restTemplate;
    private final ObjectMapper objectMapper;

    public Long fetchAllEmployee(Consumer<Employee> employeeConsumer) {

        String url = "http://localhost:8080/employees?stream=true";

        return restTemplate.execute(url, HttpMethod.GET, null, (response) -> {

            Long employeeCount = 0L;

            JsonParser jsonParser = objectMapper.getFactory().createParser(response.getBody());

            if(jsonParser.nextToken() == JsonToken.START_OBJECT) {
                if(jsonParser.nextFieldName() == "employees") {
                    if(jsonParser.nextToken() == JsonToken.START_ARRAY) {
                        while(jsonParser.nextToken() != JsonToken.END_ARRAY) {
                            Employee employee = jsonParser.readValueAs(Employee.class);
                            employeeConsumer.accept(employee);
                            employeeCount++;
                        }
                    }
                }
            }

            jsonParser.close();

            return employeeCount;
        });

    }
}

Actually what is happening here,

We initiate the HTTP request using the RestTemplate and pass a ResponseExtractor implementation.
The ResponseExtractor implementation starts with getting the inputStream from the response body.
Prepared a JsonParser using the objectMapper configured before and inputStream from the response body.
Then some trivial checking (starting of object { token check, starting the field "employees" token, starting of the array [ token), then we start reading the employee object one by one, until we find the end of the array token ].
We pass the parsed employee object to the consumer, to process the employee as per the callee need and doing some trivial counting to return later.
At the end close() the jsonParser.

Using the response

Now time to calculate the statistics based on the received employee one by one

EmployeeReportService.java

@Service
public class EmployeeReportService {

    .... Previous Code

    public EmployeeStats prepareEmployeeStats() {
        final Long startTime = System.currentTimeMillis();
        final EmployeeStats employeeStats = new EmployeeStats();

        final Long totalEmployeeCount = fetchAllEmployee((employee) -> {
            switch (employee.getGender()) {
                case F:
                    employeeStats.incrementFemaleEmployeeCount();
                    break;
                case M:
                    employeeStats.incrementMaleEmployeeCount();
                    break;
            }
        });

        final Long endTime = System.currentTimeMillis();

        employeeStats.setReportGenerationDelayInSeconds((endTime - startTime) / 1000);
        employeeStats.setTotalEmployeeCount(totalEmployeeCount);

        return employeeStats;
    }
}

Above method is pretty much self explained. It's using our previously declared fetchAllEmployee method to fetch all the employee and counting based on declared rule. To keep track of the required time to prepare the statistics, we also calculated the number of seconds required to generate the statistics.

Now the controller for rendering the statistics into the browser

EmployeeController.java

@Controller
@RequiredArgsConstructor
public class EmployeeController {

    private final EmployeeReportService employeeReportService;

    @GetMapping("/employee-stats")
    public String getEmployeeStats(Model model) {
        EmployeeStats employeeStats = employeeReportService.prepareEmployeeStats();
        model.addAttribute("stat", employeeStats);
        return "employee-stats";
    }
}

and the template

employee-stats.html


... Html

<table border="6">
    <thead>
        <th>Reference</th>
        <th>Value</th>
    </thead>
    <tbody>
        <tr>
            <!-- Because ladies first :) -->
            <td>Female Employee Count</td>
            <td class="value" th:text="${stat.femaleEmployeeCount}"></td>
        </tr>
        <tr>
            <td>Male Employee Count</td>
            <td class="value" th:text="${stat.maleEmployeeCount}"></td>
        </tr>
        <tr>
            <td>Total Employee Count</td>
            <td class="value" th:text="${stat.totalEmployeeCount}"></td>
        </tr>
        <tr>
            <td>Preparation Delay</td>
            <td class="value" th:text="${stat.reportGenerationDelayInSeconds + ' seconds'}"></td>
        </tr>
    </tbody>
</table>

... More Html

And the last thing is

server.port=8081

So our consumer application is running on port 8081.

Output

Both Server & Consumer application is running with jvm arg -Xmx32m to demonstrate the heap size limitation.

Clearly the response took longer than the expected because of the way we are counting these values. This example is just for demonstration purpose and to keep the scope of this writing small.

All the code above can be found into my github repository.

CSV Generation From Large JSON Response in Spring this post coveres more appropriate usage of this streaming based response consuming.

Streaming Large JSON Response in Spring.

Ratul sharker — Fri, 07 Oct 2022 19:26:51 +0000

Introduction

Reading data from the database and generating response in Spring works like a charm. But things get messy when we tried to return large data set as a response.

Setup

As a sample data set i am using datacharmer/test_db. It has following tables

+--------------+------------------+
| table_name   |          records |
+--------------+------------------+
| employees    |           300024 |
| departments  |                9 |
| dept_manager |               24 |
| dept_emp     |           331603 |
| titles       |           443308 |
| salaries     |          2844047 |
+--------------+------------------+

Our goal is to return ~300K employees in the json response.

I am using:

MySQL (v8.0.19) as database
Spring Boot (2.7.4)
Spring Web.
Spring Data JPA.
Lombok & Spring boot dev tools.

To talk with database, following is a enum and a entity

Gender.java

public enum Gender {
    M,F;
}

Employee.java

@Entity
@Getter
@Setter
@Table(name = "employees")
public class Employee {

    @Id
    private Long empNo;

    @Column(nullable = false)
    private Date birthDate;

    @Column(nullable = false)
    private String firstName;

    @Column(nullable = false)
    private String lastName;

    @Column(nullable = false)
    @Enumerated(EnumType.STRING)
    private Gender gender;

    @Column(nullable = false)
    private Date hireDate;
}

Here isn't much to describe about the entity. One thing is intentional that is, i just specified the @Id annotation here, without specifying the generation strategy, because i am interested in reading the already generated rows, instead of writing one.

Traditional Way

Declare everything layer by layer. At first declare a Repository, Service and a Controller as follows

EmployeeRepository.java

public interface EmployeeRepository extends JpaRepository<Employee, Long> {

}

EmployeeService.java

@Service
@Transactional(readOnly = true)
@RequiredArgsConstructor
public class EmployeeService {

    private final EmployeeRepository employeeRepository;

    public List<Employee> findAllAtOnce() {
        return employeeRepository.findAll();
    }
}

EmployeeController.java

@RestController
@RequiredArgsConstructor
public class EmployeeController {

    private final EmployeeService employeeService;

    @GetMapping(value = "/employees", params = {"at-once"})
    public List<Employee> allEmployeeAtOnce() {
        return employeeService.findAllAtOnce();
    }
}

Now run the spring boot project and start your favourite terminal to do some curl request

curl http://localhost:8080/employees?at-once=true > response.json

We are requesting all 300K employees and save it into response.json file.

So we are getting a 45MB of response. Part of this response looks like following

[
  {
    "empNo":10001,
    "birthDate":"1953-09-01T18:00:00.000+00:00",
    "firstName":"Georgi",
    "lastName":"Facello",
    "gender":"M",
    "hireDate":"1986-06-25T18:00:00.000+00:00"
  },
  ...
]

So it seems we are done here. But wait, if the response itself is 45MB alone, then how much memory is needed to generate this response ? All the employee objects and the response itself needed to be in memory at once.

Let's try our program, limiting the heap size by providing the jvm argument -Xmx64M. We are limiting jvm heap size upto 64MB. Now trying to curl again

Overall logs outputs following:

2022-10-07 02:22:52.322 ERROR 6010 --- [nio-8080-exec-1] o.h.engine.jdbc.spi.SqlExceptionHelper   : Java heap space
2022-10-07 02:23:15.497 ERROR 6010 --- [alina-utility-1] o.a.coyote.http11.Http11NioProtocol      : Error processing async timeouts

java.util.concurrent.ExecutionException: java.lang.OutOfMemoryError: Java heap space
        at java.base/java.util.concurrent.FutureTask.report(FutureTask.java:122) ~[na:na]
        at java.base/java.util.concurrent.FutureTask.get(FutureTask.java:191) ~[na:na]
        at org.apache.coyote.AbstractProtocol.startAsyncTimeout(AbstractProtocol.java:632) ~[tomcat-embed-core-9.0.65.jar:9.0.65]
        at org.apache.coyote.AbstractProtocol.lambda$start$0(AbstractProtocol.java:617) ~[tomcat-embed-core-9.0.65.jar:9.0.65]
        at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:515) ~[na:na]
        at java.base/java.util.concurrent.FutureTask.runAndReset(FutureTask.java:305) ~[na:na]
        at java.base/java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:305) ~[na:na]
        at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128) ~[na:na]
        at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628) ~[na:na]
        at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61) ~[tomcat-embed-core-9.0.65.jar:9.0.65]
        at java.base/java.lang.Thread.run(Thread.java:834) ~[na:na]
Caused by: java.lang.OutOfMemoryError: Java heap space
        at java.base/java.util.concurrent.ConcurrentHashMap$KeySetView.iterator(ConcurrentHashMap.java:4627) ~[na:na]
        at java.base/java.util.Collections$SetFromMap.iterator(Collections.java:5567) ~[na:na]
        at org.apache.coyote.AbstractProtocol.lambda$startAsyncTimeout$1(AbstractProtocol.java:640) ~[tomcat-embed-core-9.0.65.jar:9.0.65]
        at org.apache.coyote.AbstractProtocol$$Lambda$1112/0x00000008008c2440.run(Unknown Source) ~[na:na]
        ... 7 common frames omitted

Clearly loading so much objects at once and keeping large serialised json buffer in memory are the culprits here.

We can do better.

Streaming Way

Let's point out, where are so much memories are used ?

When we read the managed entities from the database via JPA.
When generating the json response.

Now can we read the managed entities at application ease ?

Easiest way to do so is reading the employee list, page by page. Let's say page size is 10K. First read the 1-10K employee, then read the 10001-20K employee and so forth. Reading all the 300K entries. In this approach we are keeping 10K records in memory at once. Downside of this approach is that, database has to run the query every time. If the employee list is filtered by complicated condition and ordered, then it will run that complicated condition and ordering each time a page is retrieved.

Another way is to stream the result set into the application as per application ease, instead of reading the whole result set at once. Spring data jpa's JpaRepository already supports streaming result set.

EmployeeRepository.java

public interface EmployeeRepository extends JpaRepository<Employee, Long> {

    @QueryHints(
        value = {
            @QueryHint(name = "org.hibernate.fetchSize", value = Integer.MIN_VALUE + "" )
        }
    )
    @Query("SELECT e FROM Employee e")
    public Stream<Employee> streamAll();
}

Few word about fetch size
In general fetch size defines, how many records to pull from database to the application server. But it depends on the database vendor and the database driver you are using. If nothing specified MySql fetch all the rows at once. For fetching one row at a time ‘Integer.MIN_VALUE’ is expected in the fetch size parameter.

More about MySQL fetch size.

More about fetch size in MySql and other databases are specified in a future post

So now we are fetching one record at a time from our database. Pressure from our java heap space is relieved.

Now time to design the service layer to safely fetch the records and output it into the http response in json format.

EmployeeService.java

@Service
@Transactional(readOnly = true)
@RequiredArgsConstructor
public class EmployeeService {

    private final EmployeeRepository employeeRepository;
    private ObjectMapper objectMapper;


    @PostConstruct
    public void postConstruct() {
        objectMapper = new ObjectMapper();
    }

        .... previous code

    public void findAllStreaming(OutputStream outputStream) throws IOException {
        Stream<Employee> employees = employeeRepository.streamAll();

        JsonGenerator jsonGenerator = objectMapper.getFactory().createGenerator(outputStream);

        try {

            jsonGenerator.writeStartArray();

            Iterator<Employee> employeeIterator = employees.iterator();
            while(employeeIterator.hasNext()) {
                Employee employee = employeeIterator.next();
                jsonGenerator.writeObject(employee);
            }

            jsonGenerator.writeEndArray();

        } catch(Exception ex) {
            throw ex;
        } finally {

            if(employees != null) {
                employees.close();
            }

            if(jsonGenerator != null)  {
                jsonGenerator.close();
            }
        }
    }
}

To put things simply, this method findAllStreaming() takes an OutputStream to write the whole json response into. To write json into the stream chunk by chunk we are using JsonGenerator. JsonGenerator is provided by Jackson-Core. More detailed about how to write stream event is covered in this blog post by the author of the library.

We start by writing the start of the array token into the string which outputs json array start ([) into the output stream. Then we write the employee object which we get by stream from the database. After writing all the employee object into the stream we then close the array operator by writing json array end (]) into the stream.

Now time to connect the controller with the newly written method.

@RestController
@RequiredArgsConstructor
public class EmployeeController {

    private final EmployeeService employeeService;

        ... Previous Code

    @GetMapping(value = "/employees", params = "stream")
    public void streamAllEmployee(HttpServletResponse response) throws IOException {
        response.setHeader(HttpHeaders.CONTENT_ENCODING, MediaType.APPLICATION_JSON_VALUE);
        employeeService.findAllStreaming(response.getOutputStream());
    }
}

Now trying with the -Xmx64m jvm arg

We are still struggling, with the memory overflow issue. What could go wrong here ?

If we look closely, inside the streaming portion

Iterator<Employee> employeeIterator = employees.iterator();
while(employeeIterator.hasNext()) {
    Employee employee = employeeIterator.next();
    jsonGenerator.writeObject(employee);
}

We are fetching entities here from database. Each time a new entity is being generated. Hibernate return's persistent entity every time. So our persistent context is full of entity objects.

We can directly @Autowired the EntityManager and call detach on it. But we can do better. We can introduce our own custom BaseRepository equipped with detach method.

BaseRepository.java

@NoRepositoryBean
public interface BaseRepository<T, ID> extends JpaRepository<T, ID> {

    public void detach(T entity);
}

BaseRepositoryImpl.java

public class BaseRepositoryImpl<T, ID> extends SimpleJpaRepository<T, ID> implements BaseRepository<T, ID> {

    private final EntityManager entityManager;

    public BaseRepositoryImpl(JpaEntityInformation<T, ID> entityInformation, EntityManager entityManager) {
        super(entityInformation, entityManager);
        this.entityManager = entityManager;
    }

    public BaseRepositoryImpl(Class<T> domainClass, EntityManager em) {
        super(domainClass, em);
        this.entityManager = em;
    }

    @Override
    public void detach(T entity) {
        entityManager.detach(entity);
    }   
}

StreamJsonResponseServerApplication.java

@SpringBootApplication
@EnableJpaRepositories(repositoryBaseClass = BaseRepositoryImpl.class)
public class StreamJsonResponseServerApplication {

    ... Previous Code

}

Now update the EmployeeRepository.java

public interface EmployeeRepository extends BaseRepository<Employee, Long> {
    ... Previous Code
}

And inside the service

Iterator<Employee> employeeIterator = employees.iterator();
while(employeeIterator.hasNext()) {
    Employee employee = employeeIterator.next();     
    employeeRepository.detach(employee); // Removing entity object from persistent context.
    jsonGenerator.writeObject(employee);
}

Now try again with the curl

So we the response landed successfully.

I even tried with extreme situation by passing -Xmx32m as jvm argument. It also works like charm.

Portion of the downloaded json looks like following

[
    {
        "empNo":10001,
        "birthDate":-515397600000,
        "firstName":"Georgi",
        "lastName":"Facello",
        "gender":"M",
        "hireDate":"26 June 1986"
    }
    ...
]

Downsides

In this approach, servlet containers thread pool can be drained out under heavy load, as these responses taking longer that usual. Application managed thread can be used in returning the response, which will be covered in details in a future post.

Bonus

In order to bring some customisation in the json format is quite easy.

Say we want a custom format in the date then inside the EmployeeService.java

@PostConstruct
public void postConstruct() {
    objectMapper = new ObjectMapper();
    objectMapper.setDateFormat(new SimpleDateFormat("dd MMMM YYYY"));
}

It outputs following json

[
    {
        "empNo":10001,
        "birthDate":"02 September 1953",
        "firstName":"Georgi",
        "lastName":"Facello",
        "gender":"M",
        "hireDate":"26 June 1986"
    }
    ...
]

Another thing like we want to restructure the json, so that instead of returning the employees inside of an array, we want a json object inside which a employees keys will be present holding to the list of employees. For that we could customise the method findAllStreaming accordingly

try {
    jsonGenerator.writeStartObject();            
    jsonGenerator.writeArrayFieldStart("employees");
    Iterator<Employee> employeeIterator = 
    employees.iterator();
    while(employeeIterator.hasNext()) {
        Employee employee = employeeIterator.next();
        employeeRepository.detach(employee);
        jsonGenerator.writeObject(employee);
    }

    jsonGenerator.writeEndArray();
    jsonGenerator.writeEndObject(); 
} ... Previous Code

Which generates following

{
    "employees" : [
        {
            "empNo":10001,
            "birthDate":"02 September 1953",
            "firstName":"Georgi",
            "lastName":"Facello",
            "gender":"M",
            "hireDate":"26 June 1986"
        }
        ...
    ]
}

All the code is shared into my github repository.

Want to know, how to consume this large json responses without hitting the jvm heap boundary ? Read Consume Large JSON Response in Spring.

Dockerize PHP Application

Ratul sharker — Thu, 25 Aug 2022 20:57:00 +0000

Dockerize an application comes up with many benefits. Modern micro service architecture requires application to be containerised. It also minimise the gap between production environment and development environment. Developer can up and running with all the dependencies with a single command.

While dockerize, development of compiled language can suffer from various problems. One of the major bottleneck is inspect the change set after a minor change. There are many hot reload options available out there for different stacks, but mostly very slow and buggy. Sometimes change sets are not propagated properly causing unnecessary hassle.

Besides scripting language like PHP does not suffer from these problem. As long as files are inside the apache's serving directory all the changes is visible to the apache server. To say briefly apache spawn a php process to a particular .php file specified in the request path.

So how we can get benefitted with it while developing using docker container ?

Let's start how can we leverage the power of containerisation with docker for PHP application.

You can check this repository or start from scratch. Our directory structure will look like following.

.
├── src
│   └── index.php
├── Dockerfile
└── docker-compose.yml

Inside the index.php an awesome script is written, which looks like:

<?php echo "Hello world\n"; ?>

Now for dockerize the application, a Dockerfile is necessary. We need php and apache pre installed docker image. php:apache-buster image such an image we are looking for.

Using that image as base image, our Dockerfile will look like following

FROM php:apache-buster

COPY ./src/* /var/www/html

CMD ["apache2-foreground"]

Right after the base image FROM command, we copied our content of src folder inside the /var/www/html from where apache serves files while requesting.

The last line actually running apache in foreground. Actually i copied it from the base image php:apache-buster 😉.

So the definition for our image is ready.

Now time for local orchestration file docker-compose.yml. This file dictates the configuration to ran the image.

version: '3.2'
services:
  awesome-app:
    build:
      context: .
      dockerfile: Dockerfile
    image: awesome-app:latest
    ports:
    - 80:80
    volumes:
    - type: bind
      source: ./src
      target: /var/www/html

Here what is done, a service is declared named awesome-app. This service will build image using the Dockerfile we just finished writing. We named the image awesome-app and tagged it with latest. Exposed the port 80 to the host so that apache can be accessed from the host.

The last part is the trickiest one, we mount a volume which connects the hosts ./src (our source directory) to container's /var/www/html (directory where apache serves from). This volume mounting will make sure, any change done inside the ./src will be seen by the apache.

Now time for testing. To test everything is working as expected we will do followings

Starting awesome-app.
Check existing output.
Change code.
Inspect changed output.

1. Starting awesome-app

To start my awesome-app we will use docker-compose

docker-compose up -d

This will create a awesome-app container in the background

2. Check existing output

To inspect the output of existing codebase i will use curl

curl -i http://localhost

HTTP/1.1 200 OK
Date: Thu, 25 Aug 2022 19:27:35 GMT
Server: Apache/2.4.38 (Debian)
X-Powered-By: PHP/8.1.9
Content-Length: 12
Content-Type: text/html; charset=UTF-8

Hello world

3. Change code:

Now i will modify code inside index.php

<?php echo "My Awesome app says hello world\n"; ?>

4. Inspect changed output.

curl -i http://localhost

HTTP/1.1 200 OK
Date: Thu, 25 Aug 2022 19:37:24 GMT
Server: Apache/2.4.38 (Debian)
X-Powered-By: PHP/8.1.9
Content-Length: 32
Content-Type: text/html; charset=UTF-8

My Awesome app says hello world

See, it just like developing PHP application locally with all the benefits of docker.

All the above codes is available in my github repository.