DEV Community: Sandro Giacomozzi

How to install Java 13 from AdoptOpenJDK

Sandro Giacomozzi — Fri, 27 Sep 2019 16:05:03 +0000

Introduction

In this tutorial, you will learn how to install Java 13 from AdoptOpenJDK project.

AdoptOpenJDK

AdoptOpenJDK provides rock-solid OpenJDK binaries for the Java ecosystem and also provides infrastructure as code, and a Build farm for builders of OpenJDK, on any platform.

Install

To install, just copy and paste the script above in your linux terminal

wget https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/download/jdk-13%2B33/OpenJDK13U-jdk_x64_linux_hotspot_13_33.tar.gz
sudo tar xvf OpenJDK13U-jdk_x64_linux_hotspot_13_33.tar.gz --directory /usr/lib/jvm/
sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk-13+33/bin/java 2
sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/jdk-13+33/bin/javac 2

Jenv

To use Java 13 without compromising your current installation, simply use Jenv. Take a look at this post if you don't know the project yet:

https://dev.to/sandrogiacom/multiple-jdks-no-problem-1knc

Add Java 13

jenv add /usr/lib/jvm/jdk-13+33

Check if work's

jenv versions

My default (global) Java version is 11.

Test

Create a new directory:

mkdir java-13
cd java-13
java -version

As expected, the console displayed the global version.

λ java -version
openjdk version "11.0.4" 2019-07-16
OpenJDK Runtime Environment AdoptOpenJDK (build 11.0.4+11)
OpenJDK 64-Bit Server VM AdoptOpenJDK (build 11.0.4+11, mixed mode)

To set Java 13 as local, just type:

jenv local 13

And type java -version again:

λ java -version
openjdk version "13" 2019-09-17
OpenJDK Runtime Environment AdoptOpenJDK (build 13+33)
OpenJDK 64-Bit Server VM AdoptOpenJDK (build 13+33, mixed mode, sharing)

The complete source code it's on github:

https://github.com/sandrogiacom/dev-scripts

Conclusion

In this short tutorial, we learned how to install Java 13 from AdoptOpenJDK project.

Enjoy!

How to create and fill out your own PDF form with Java

Sandro Giacomozzi — Sat, 03 Aug 2019 22:23:57 +0000

Introduction

In this tutorial, you will learn how to populate a PDF document with Java using the PDFBox library. In addition you will see how to create your own forms or add editable fields to an existing PDF document.

Creating a simple form

To create a form, let's use LibreOffice Draw.

Display the form toolbar. View Menu > Toolbars > Form Controls.

In a blank document, enter two text fields:

Display the properties of the text field:

Rename the fields to 'txt_1' and 'txt_2' respectively. Also leave the 'Read-only' property as 'Yes'.

Export the document as PDF. Mine is like '/tmp/pdf-java.pdf'

My template looked like this:

Populating the PDF through Java

Create a new maven Java project and add the dependency below:

<dependency>
  <groupId>org.apache.pdfbox</groupId>
  <artifactId>pdfbox</artifactId>
  <version>2.0.16</version>
</dependency>

Create a Java class with the code below:

    public static void main(String[] args) {
        try {
            PDDocument pDDocument = PDDocument.load(new File("/tmp/pdf-java.pdf"));
            PDAcroForm pDAcroForm = pDDocument.getDocumentCatalog().getAcroForm();
            PDField field = pDAcroForm.getField("txt_1");
            field.setValue("This is a first field printed by Java");
            field = pDAcroForm.getField("txt_2");
            field.setValue("This is a second field printed by Java");
            pDDocument.save("/tmp/pdf-java-output.pdf");
            pDDocument.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Run the program and see the result:

Remember, the ending file was saved to: "/tmp/pdf-java-output.pdf".

The complete source code it's on github:

https://github.com/sandrogiacom/pdf-java

Conclusion

In this short tutorial, we learned how to populate a PDF from a PDF template created with LibreOffice Draw. Use your creativity to create beautiful templates, do automation, create batch files and more.

Leave in the comments what your use case would be.

See you soon!

Kubernetes for Java Developers - Debug Application

Sandro Giacomozzi — Thu, 11 Jul 2019 18:03:56 +0000

Debug application

At this point, we deployed our application within a local cluster. But now we have a problem. How do I debug my application that is inside the docker that is inside the kubernetes that is inside a virtual machine?

Prepare to debug

In this case, we will use a remote Java debug.

First step:

Prepare your Dockerfile:

FROM openjdk:11.0.3-jdk-slim
RUN mkdir /usr/myapp
COPY target/java-kubernetes.jar /usr/myapp/app.jar
WORKDIR /usr/myapp
EXPOSE 8080
ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -jar app.jar" ]

This ENTRYPOINT allows you to pass options to the java through $JAVA_OPTS environment variable.

Second step:

Changing app-configmap.yaml file to fill $JAVA_OPTS.

JAVA_OPTS: "-agentlib:jdwp=transport=dt_socket,address=*:5005,server=y,suspend=n -Xms256m -Xmx512m -XX:MaxMetaspaceSize=128m"

Third step:

Building and deploy app:

mvn clean install
eval $(minikube -p dev.to docker-env) && docker build --force-rm -t java-k8s .
kubectl apply -f kubernetes/app/

Fourth step:

Exposing debug port to localhost:

Get pods:

kubectl get pods -n dev-to

NAME                     READY   STATUS    RESTARTS   AGE
myapp-7796bc89bf-h2f82   1/1     Running   0          3h3m

Expose pod 5005 port:

kubectl port-forward -n dev-to myapp-7796bc89bf-h2f82 5005:5005
Forwarding from 127.0.0.1:5005 -> 5005
Forwarding from [::1]:5005 -> 5005

Change your pod name as necessary.

Create a remote debug on your IDE:

On IntelliJ, go to Run/Debug Configurations.

Add new remote configuration like this:

After that, run the configuration. You should see the message below:

Connected to the target VM, address: 'localhost:5005', transport: 'socket'

Check if works:

Now, you can set a breakpoint in the HelloController.

minikube -p dev.to service -n dev-to myapp --url
http://192.168.99.100:32301

curl http://192.168.99.100:32301/hello

Conclusion

In this part, we learned about how to debug application inside a local kubernetes cluster.

In the next part, we will see some good practices and how to access application with friendly URL using Ingress.

See you soon!

Kubernetes for Java Developers - Deploy Application

Sandro Giacomozzi — Sun, 07 Jul 2019 13:33:41 +0000

Hello Java Dev

This is the third part of the series Kubernetes for Java Developers. Before continue, check the first and second part.

In this tutorial, we learn about to building and run application inside a kubernetes cluster.

At this point, we have a Java application running in docker that uses a mysql database running on docker too.

Prepare the environment for the big moment

Check if you have the necessary tools before continue.

Just check:

make --version

minikube version

kubectl version

vboxmanage --version

If you don't have one of the tools above, please go to part one, follow the instructions and return here.

Or just type:

make check

The command above needs to be executed in the root of the project. Please clone it if you don't have it yet:

https://github.com/sandrogiacom/java-kubernetes

Prepare demo application

Go to java-kubernetes directory and type make to see all make options.

Create minikube machine

make k-setup starts minikube, enable ingress and create namespace "dev-to".

Create kubernetes resources

Check kubernetes folder with subdirectories app and mysql.

app-configmap.yaml

Application configurations with environment variables.

apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp
  namespace: dev-to
data:
  DATABASE_SERVER_NAME: "mysql"
  DATABASE_USER_NAME: "myapp"
  DATABASE_USER_PASSWORD: "myapp_pwd"

app-deployment.yaml

Deployment creates one replicated pod. For more information please check documentation.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
  namespace: dev-to
  labels:
    app: myapp
spec:
  selector:
    matchLabels:
      app: myapp
  template:
      metadata:
        labels:
          app: myapp
      spec:
        containers:
          - name: myapp
            image: java-k8s:latest
            imagePullPolicy: Never
            ports:
              - containerPort: 8080
                name: http
            envFrom:
              - configMapRef:
                  name: myapp

The important part here is the template that defines the name of docker image, http port and source of environment variables.

app-service.yaml

An abstract way to expose an application running on a set of Pods as a network service.

kind: Service
apiVersion: v1
metadata:
  name: myapp
  namespace: dev-to
spec:
  selector:
    app: myapp
  type: NodePort
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080

In mysql folder, we have only deployment and service files, because environment variables are in the same file.

Deploy database

make k-deploy-db create mysql deployment and service.

Check if the service is running:

kubectl get pods -n dev-to

Access database in localhost:

kubectl port-forward -n dev-to <pod_name> 3306:3306

Build application and docker image

make k-build-app build app and create docker image inside minikube machine.

make k-deploy-app deploy app on cluster.

Check if services is running:

kubectl get pods -n dev-to

Check app url

Minikube gives you the host and port to which you will access.

Type:
minikube -p dev.to service -n dev-to myapp --url

Address below will be different for you!

http://192.168.99.133:30343

curl -X GET http://192.168.99.133:30343/persons

To open app directly in web browser:
minikube -p dev.to service -n dev-to myapp

Conclusion

In this part, we learned about how to build and deploy application inside a local kubernetes cluster.

In the next part, we will see how to debug our application and some good practices for microservices.

See you soon!

Bonus

Create all in one step

To create world, just copy and paste command below on terminal. Make sure that you are in the root of the project.

make k-all

Kubernetes for Java Developers - Creating a docker image

Sandro Giacomozzi — Sun, 30 Jun 2019 20:16:53 +0000

Welcome back

On first tutorial of this series, we learn about set up a local kubernetes environment.
At this point, we have a Java application that uses a mysql database running on docker.
To package our application inside a docker image, we need to create a Dockerfile.

Create a Dockerfile

Dockerfile definition:

FROM openjdk:11.0.3-jdk-slim
RUN mkdir /usr/myapp
COPY target/java-kubernetes-0.0.1-SNAPSHOT.jar /usr/myapp/app.jar
WORKDIR /usr/myapp
EXPOSE 8080
CMD ["java", "-Xms128m", "-Xmx256m", "-jar", "app.jar"]

Use Make to automate tasks

Make is a tool which controls the generation of executables and other non-source files of a program from the program's source files.
We will use make to automate maven and docker commands in this project.
Check your make installation. Type make --version on terminal. If none happens, please install make before continue.

Create a Makefile

Creating a Makefile on the same Dockerfile directory.
Check out the complete Makefile on github: https://github.com/sandrogiacom/java-kubernetes/blob/master/Makefile

The importance parts are:

build:
    mvn clean install; \
    docker build --force-rm -t java-k8s .

run-db:
    make stop-db; \
    make rm-db; \
    docker run --name mysql57 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -e MYSQL_USER=java -e MYSQL_PASSWORD=1234 -e MYSQL_DATABASE=k8s_java -d mysql/mysql-server:5.7

run-app:
    make stop-app; \
    make rm-app; \
    docker run --name myapp -p 8080:8080 -d -e DATABASE_SERVER_NAME=mysql57 --link mysql57:mysql57 java-k8s:latest

build: Run maven and create a docker image with the name "java-k8s"
run-db: Start a new mysql database container
run-app: Start a new application container

In this order, type:

make build
make run-db
make run-app

Obs: Wait 30 seconds between run:db and run:app to make time to start up database.

To see logs of applicaton, type:

docker logs -f myapp

And CTRL+C to exit log mode.

Type docker ps to see the containers running

Check
http://localhost:8080/persons

To stop applicaton and database, type:

make stop-app
make stop-db

Please clone the complete demo app at:

https://github.com/sandrogiacom/java-kubernetes

Have fun!

See you on the next part. Deploy your app into kubernetes cluster.

Kubernetes for Java Developers - Setup

Sandro Giacomozzi — Thu, 27 Jun 2019 20:40:14 +0000

Kubernetes is a portable, extensible open-source platform for managing containerized workloads and services, that facilitates both declarative configuration and automation. It has a large, rapidly growing ecosystem. Kubernetes services, support, and tools are widely available.

Introduction

The technology area is cyclical, from time to time the same technologies come back, with different names. (Heidemann, Vanei)

If you are over 35, you have seen many technologies being reinvented. In this case, we'll talk about application servers. As we can see in this article of @rafabene. Why Kubernetes is The New Application Server

As developers, we want to run the code on our machine, to have the control in our hands.
But now, applications are not only running on Docker containers. There are a number of things we need to worry about.

In this tutorial you will learn how to prepare the local environment for a kubernetes cluster. This is the first post of a series about Java and Kubernetes.

Prerequisites

Docker

Docker is an open source software platform to create, deploy and manage virtualized application containers on a common operating system (OS), with an ecosystem of allied tools.

Minikube

Minikube implements a local Kubernetes cluster on macOS, Linux, and Windows.

Kubectl

The Kubernetes command-line tool, kubectl, allows you to run commands against Kubernetes clusters.

VirtualBox (Optional)

The Kubernetes cluster running inside a Virtual Machine
https://www.virtualbox.org/

If you don't have any of these tools, this can help you:

sandrogiacom / k8s

Kubernetes resources

k8s

Kubernetes development tools

Docker
Kubectl
Minikube
Kubens
Stern
VirtualBox
OpenShift

Clone this repository

git clone https://github.com/sandrogiacom/k8s.git

Prerequisite

Make

sudo apt install make

sudo pacman -S make

Install tools

All tools

make install-all OS=deb

Separate tools

Docker

make install-docker OS=deb

VirtualBox

make install-vbox OS=deb

Kubectl

make install-kubectl OS=deb

Minikube

make install-minikube OS=deb

OpenShift

make install-oc OS=deb

Os Types

deb: Deabian , Mint, Ubuntu
arch: Arch Linux

View on GitHub

Check if works

Type:

$ minikube version
minikube version: v1.1.1

$ kubectl version
Client Version: version.Info{Major:"1", Minor:"14", GitVersion:"v1.14.2"...

$ virtualbox

Start minikube

To start minikube, just type minikube start on the terminal.
The command above creates the virtual machine with default values:
If you want to start with different flags, type minikube start -h to complete list

The most important flags, is:

--vm-driver: VM driver is one of: virtualbox parallels vmwarefusion kvm xhyve hyperv hyperkit kvm2 vmware none. default "virtualbox"
--memory int: Amount of RAM allocated to the minikube VM in MB (default 2048)
--cpus int: Number of CPUs allocated to the minikube VM (default 2)
--profile: The name of the minikube VM being used. This can be modified to allow for multiple minikube instances to be run independently (default "minikube")

minikube start -p dev.to --cpus 2 --memory=4096

Dashboard

minikube -p dev.to dashboard

You can use Dashboard to get an overview of applications running on your cluster, as well as for creating or modifying individual Kubernetes resources (such as Deployments, Jobs, DaemonSets, etc).

Create a namespace

It's a good practice to create a namespace for separating your workspace. Type:

kubectl create namespace dev-to

Enable ingress

minikube -p dev.to addons enable ingress

Ingress exposes HTTP and HTTPS routes from outside the cluster to services within the cluster. Traffic routing is controlled by rules defined on the Ingress resource.

Stop minikube machine

minikube -p dev.to stop

Destroy minikube machine

minikube -p dev.to delete

Conclusion

To be continued...

In this tutorial, we learn how to start a local kubernetes cluster and prepare to deploy our own application. In the next post, we will prepare a Java application to be deployed in the Kubernetes cluster.

See you soon.

References

https://github.com/arun-gupta/kubernetes-for-java-developers

https://github.com/arun-gupta/kubernetes-java-sample/blob/master/workshop.adoc#create-kubernetes-cluster

https://developers.redhat.com/blog/2018/06/28/why-kubernetes-is-the-new-application-server/

Multiple JDKs? No problem!

Sandro Giacomozzi — Mon, 17 Jun 2019 18:28:53 +0000

Have you had problems with several versions of Java on your machine? Do you lose time configuring the environment variables? There is an elegant solution in the Linux world and it is called jEnv.

Motivation

You need to maintain your Java programs written in Java 8 or even lower. Develop applications with Java 11 and still try Java 12 or 13. Certainly you will have problems.

Scenario

Assuming you already have a development environment with Java 8 and Maven. In the examples, I'll be using Linux Mint.
It is common to have problems when we have more than one version of Java on the same machine. To solve this, we end up doing several scripts to change JAVA_HOME, using the alternatives framework and we often need to restart the user session for the changes to take effect.

Installing OpenJDK 11 with JDK 8

The idea is to keep the current version of your Java, install JDK 11 and run one version or another as the project needs. We'll see how easy it is to manage this with some tools. When I refer to Java 11, JDK or OpenJDK, I will always be referring to OpenJDK 11.

Download OpenJDK:

$ wget https://download.java.net/java/GA/jdk11/13/GPL/openjdk-11.0.1_linux-x64_bin.tar.gz
$ sudo tar xvf openjdk-11.0.1_linux-x64_bin.tar.gz --directory /usr/lib/jvm/

After that, if you run the command java -version you will see that nothing has changed and we continue with Java 8:

$ java -version
java version "1.8.0_191" Java(TM) SE Runtime Environment (build 1.8.0_191-b12)Java HotSpot(TM) 64-Bit Server VM (build 25.191-b12, mixed mode)

Maven is still there with the current Java:

$ mvn -version
Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-17T15:33:14-03:00) Maven home: /opt/maven Java version: 1.8.0_191, vendor: Oracle Corporation, runtime: /usr/lib/jvm/java-8-oracle/jre

To check if Java 11 is ok, just run the command:

$ /usr/lib/jvm/jdk-11.0.1/bin/java -version
openjdk version "11.0.1" 2018-10-16 OpenJDK Runtime Environment 18.9 (build 11.0.1+13) OpenJDK 64-Bit Server VM 18.9 (build 11.0.1+13, mixed mode)

Ready! We have both versions of Java on the same machine, now what?

Assuming most of our projects will be with Java 8 for some time, let's define this version as "global" and Java 11 as the "local" version.

jEnv

jEnv is a command-line tool to help you forget how to set the JAVA_HOME environment variable. It is a tool that allows you to configure Java versions in a global or local way.
Assuming we already have Java 8 installed and configured using it with maven for example.

Installing jEnv:

This tool is only available for Linux and Mac. To install on Linux, follow the steps below (assuming you have git installed):

$ git clone https://github.com/gcuisinier/jenv.git ~/.jenv

$ echo 'export PATH="$HOME/.jenv/bin:$PATH"' >> ~/.bash_profile
$ echo 'eval "$(jenv init -)"' >> ~/.bash_profile

If you use Zsh:

$ echo 'export PATH="$HOME/.jenv/bin:$PATH"' >> ~/.zshrc
$ echo 'eval "$(jenv init -)"' >> ~/.zshrc

Close the terminal and open it again. Run the jenv command

If everything is ok, you should see the message jenv + version. Ex: jenv 0.5.1-5-gaf89d78

If it does not work, perform step 2, for bashrc instead of bash_profile

$ echo 'export PATH="$HOME/.jenv/bin:$PATH"' >> ~/.bashrc
$ echo 'eval "$(jenv init -)"' >> ~/.bashrc

Adding Java versions to jEnv:

Java 8:

$ jenv add /usr/lib/jvm/java-8-oracle

Java 11:

$ jenv add /usr/lib/jvm/jdk-11.0.1

Check java versions:

$ jenv versions
  system
  11.0
  11.0.1 (set by /home/sandro/.jenv/version)
  1.8
  1.8.0.191

Running

Assuming you need to keep Java 8 as default for legacy applications and use Java 11 in certain projects or directories.

Defining a global version:

$ jenv global 1.8.0.191

Defining the local version (per directory):

$ jenv local 11.0.1

Conclusion

We install Java 11 without compromising the environment that is already working with Java 8. We install and configure the jEnv tool, generate and compile a Java 11 project. In the next post, we will analyze a Java 8 application and see if we can run it in Java 11.

If you have any questions or problems, leave a comment. Thanks for reading.

References

http://www.jenv.be/

Run MySQL on Docker and use in your Java App

Sandro Giacomozzi — Wed, 12 Jun 2019 17:16:08 +0000

Running MySQL in Docker is very useful to use in development. In this tutorial, we will see how easy it is to start MySQL in Docker and use it in our Java application with Spring Boot.

Prepare

First, you need a docker runtime on you machine. If you don't have it, please install following this docker documentation: https://docs.docker.com/install/

Start Mysql container

To start the container, type the command below in your terminal:

docker run --name mysql57 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=1234 -d mysql/mysql-server:5.7

The command above, pulled image if not found in local repository and run mysql container in detached mode. Configure local port equals to container port and set root password to 1234.

Check your container running:

docker ps
CONTAINER ID        IMAGE                 COMMAND                  CREATED             STATUS                   PORTS                               NAMES
380eca8a553c        mysql/mysql-server:5.7    "/entrypoint.sh mysq…"   8 minutes ago       Up 8 minutes (healthy)   0.0.0.0:3306->3306/tcp, 33060/tcp   mysql

As we can see, mysql5.7 is running on localhost:3306
At this point, you have a local mysql server without install it.

Note: You will not have external access to the container with root user.

Create a database

Type:

docker exec -it mysql57 bash

This command access the mysql container and allow to execute commands on database. Inside a container, type:

mysql -h localhost -u root -p

Remember, the password is 1234. First, we need to create a user for out-of-container access because root access is not allowed:

CREATE USER 'demo_java' IDENTIFIED BY 'java';
grant all on *.* to 'demo_java'@'%' identified by '1234';
FLUSH PRIVILEGES;

To create a database, paste DDL bellow:

CREATE DATABASE hello_java CHARACTER SET utf8 COLLATE utf8_general_ci;

Next, type:

show databases;
+--------------------+
| Database           |
+--------------------+
| hello_java         |
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.00 sec)

Create a database automatically

Another way to start a database and automatic create a hello_java database and demo_java user:

docker run --name mysql57 -p 3306:3306 \
-e MYSQL_ROOT_PASSWORD=1234 \
-e MYSQL_USER=demo_java \
-e MYSQL_PASSWORD=1234 \
-e MYSQL_DATABASE=hello_java \
-d mysql/mysql-server:5.7

With the above command, you do not have to enter the database and create a database and a user. Cool, is not it?

Create Demo App

Go to https://start.spring.io/ and create a demo app with the Web and Jpa dependencies.

Import application in your IDE and follow steps below:

1 - Edit application.properties file:

spring.datasource.url=jdbc:mysql://localhost:3306/hello_java
spring.datasource.username=demo_java
spring.datasource.password=1234
spring.jpa.hibernate.ddl-auto=update

spring.jpa.hibernate.ddl-auto=update creates the person table if it doesn't exist.

Note: It's not recommended to use in production.

2 - Edit pom.xml file and add mysql connector java

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

3 - Add domain, service and persistence classes:
Domain

Repository

Service

4 - Change main class to create two new Person:

Run Demo App

Start demo app just running a main class:

Application is running and data is persistent in database

Bonus

To expose your data as a Rest endpoint, just add this dependency:

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

Access http://localhost:8080/persons

And Wow! Your data exposed as json.

Source code

sandrogiacom / database-demo

database-demo

Source code for the post: Run MySQL on Docker and use in your Java App

https://dev.to/sandrogiacom/run-mysql-on-docker-and-use-in-your-java-app-jpn

View on GitHub

Monitoring Java Microservices with JavaMelody

Sandro Giacomozzi — Sat, 08 Jun 2019 19:04:51 +0000

Javamelody is an open source project that helps you get metrics from your service. With it you can discover possible failures before sending you code to production. It is very easy to include in your application and in this tutorial, we will show you how to do it.

Creating Demo App

Let's start creating a spring boot application. Access https://start.spring.io/ to generate our demo app. You can use your own package name on Group field.

And add only Web dependency

And then, generate project.

A zip file will be generated with our project and can be imported into your preferred IDE.
A generated project looks like this:

If you prefer to use this demo code, clone the github project:
https://github.com/sandrogiacom/javamelody-spring-demo

Add JavaMelody dependency

Now, let's add javamelody's spring boot dependency

<dependency>
    <groupId>net.bull.javamelody</groupId>
    <artifactId>javamelody-spring-boot-starter</artifactId>
    <version>1.77.0</version>
</dependency>

Run app

Next you can run your spring-boot application and open http://localhost:8080/monitoring to browse the monitoring reports.

The metrics will begin to be captured, but we still do not have code in our application. Let's create a rest endpoint.

Create a Rest Controller

Add a new class HelloController as below:

@RestController
@RequestMapping("/hello")
public class HelloController {
    @GetMapping
    public String sayHello() {
        return "Hello JavaMelody!";
    }
}

Restart your application and open http://localhost:8080/hello
Run this URL many times. After that, open http://localhost:8080/monitoring again.

Results

As you can see, the metrics began to be collected:

More JavaMelody Resources

JavaMelody has many, many features such as:

Plugins: (Jenkins, JIRA, Bamboo, Liferay, Alfresco, Sonar, Grails)
PDF report generation (Weekly, daily or monthly reports by mail)
Scripts and alerts (Jenkins with Groovy)
Centralized Monitoring Server
Real User Monitoring
Database monitoring
Sending metrics to AWS CloudWatch, Graphite
Custom reports, styles, icons and other resources

Conclusion

JavaMelody helps you anticipate problems with your application. For best results, use with some stress tool, such as JMeter.

sandrogiacom / javamelody-spring-demo

How to monitoring your spring boot app with Javamelody

javamelody-spring-demo

How to monitoring your spring boot app with Javamelody

https://dev.to/sandrogiacom/monitoring-java-microservices-with-javamelody-1ndg

View on GitHub