This article explains in brief about two features of ANT which are used to monitor the build process: Listeners and Loggers. In the previous articles on ANT we saw that ANT has logging feature(logging using external log4j). If the logger is not specified then ANT uses the DefaultLogger. Along with logger, Ant also has a log message handling category known as a listener. At a low level a logger is in fact a listener with a little difference.

• Logger has the ability to write to log output device, such as a console or a file supplied by the “-logfile” command line argument.
• Another difference is ANT build file can have multiple listeners but only one logger.
• The logger is something which ANT connects to the System.out and System.err streams

The article briefly explains about loggers, listeners and built-in loggers/listeners.

Books:

• Ant: The Definitive Guide
• Apache Maven 2 Effective Implementation

Ant Listeners

A build life has events, which alerts the listener.These events are:

• Build started
• Build finished
• Target started
• Target finished
• Task started
• Task finished
• Message logged

As these events trigger some action in listener, they are used for various recording and maintenance operation. New listeners may be registered on the command line through the -listener argument.

Ant Loggers

A logger is built on top of a listener, extends the capabilities of listeners and logs information about the build. You use a logger whenever you run ANT, whether or not you specify one. If a logger is not specified in ANT, then you are using the DefaultLogger. Loggers have following features:

1. Loggers receive a handle to the standard output and error print streams and hence log information to the console or to a specified file(command for specifying file -logfile).
2. Loggers are aware of logging level (-quiet, -verbose, -debug)
3. Loggers are aware of Emacs-mode

Built-in Listeners/Loggers

In addition to the DefaultLogger, Ant comes with following standard loggers and listeners:

• DefaultLogger
• NoBannerLogger
• MailLogger
• AnsiColorLogger
• XmlLogger
• Log4jListener
• TimestampedLogger
• BigProjectLogger
• ProfileLogger

Here’s a brief overview of what each one does:
(Note:The source file and build file used in all the examples below shown are from previous article(Tutorial of java programming with Apache Ant) )

DefaultLogger

DefaultLogger is used implicitly by ANT unless overridden to use some other logger.Though the logging is not so impressive, but it does its job well. Use the following command-line option to override this logger:
ant -logger org.apache.tools.ant.DefaultLogger

Output

C:\>ant -logger org.apache.tools.ant.DefaultLogger
Buildfile: build.xml
clean:
   [delete] Deleting directory C:\build
compile:
    [mkdir] Created dir: C:\build\classes
    [javac] Compiling 1 source file to C:\build\classes
jar:
    [mkdir] Created dir: C:\build\jar
      [jar] Building jar: C:\build\jar\WelcomeToJavaBeat.jar
run:
     1 0 [main] INFO net.javaBeat.WelcomeToJavaBeat  - Welcome To JavaBeat
main:
BUILD SUCCESSFUL

NoBannerLogger

The NoBannerLogger is very similar to the DefaultLogger, except it omits output from targets that don’t log anything. When you run Ant, the console is printed as follows:
Each target’s name prints at the left-most column, followed by a colon, and then the name of corresponding task is printed in brackets. This occurs even if there is no useful output from any of the tasks.Here at such scenarios NoBannerLogger can be used to suppress output of empty target output.

Use the following command-line switch to use NoBannerLogger:
ant -logger org.apache.tools.ant.NoBannerLogger

Output

C:\>ant -logger org.apache.tools.ant.NoBannerLogger
Buildfile: build.xml
clean:
   [delete] Deleting directory C:\build
compile:
    [mkdir] Created dir: C:\build\classes
    [javac] Compiling 1 source file to C:\build\classes
jar:
    [mkdir] Created dir: C:\build\jar
      [jar] Building jar: C:\build\jar\WelcomeToJavaBeat.jar
run:
     1 0 [main] INFO net.javaBeat.WelcomeToJavaBeat  - Welcome To JavaBeat
BUILD SUCCESSFUL

Here you see that the logger has omitted the main target.

MailLogger

This logger extends the DefaultLogger, such that it captures all the output logged through DefaultLogger,then send a success or failure messages to unique email lists. A group of properties must be set for MailLogger to do its job. These properties can be passed into Ant from the command line using the standard Java -D syntax or statements in your init target or,by specifying a properties file.
The properties are:

• MailLogger.mailhost-Mail server to use.Defaults to “localhost”.
• MailLogger.port -SMTP Port for the Mail server.Defaults to “25″.
• MailLogger.user-user name for SMTP auth.This field is required, if SMTP auth is required on your SMTP server the email message will be then sent using Mime and requires JavaMail
• MailLogger.password-password for SMTP auth.This field is required, if SMTP auth is required on your SMTP server the email message will be then sent using Mime and requires JavaMail.
• MailLogger.ssl-on or true if ssl is needed.This feature requires JavaMail.
• MailLogger.from-You have to set this to a good “from” address
• MailLogger.replyto-You have to set this to a “replyto” address(es),comma-seperated.
• MailLogger.failure.notify-Whether to send an e-mail on build failure; defaults to true
• MailLogger.success.notify-Whether to send an e-mail on build success; defaults to true
• MailLogger.failure.to-A comma-separated list of e-mail addresses to send to on build failure
• MailLogger.success.to-A comma-separated list of e-mail addresses to send to on build success
• MailLogger.failure.subject-The subject of the e-mail on build failure; defaults to “Build Failure”
• MailLogger.success.subject-The subject of the e-mail on build success; defaults to “Build Success”
• MailLogger.failure.body-The fixed body of the e-mail on build failure;default is to send full log output
• MailLogger.success.body-The fixed body of the e-mail on build success;default is to send full log output
• MailLogger.mimeType-MIME-type of the message being sent;defaults to text/plain
• MailLogger.charset-character set of message being sent.
• MailLogger.starttls.enable-on or true if STARTTLS should be supported (requires JavaMail);deafults to “false”
• MailLogger.properties.file-The name of a properties file that contains properties for the logger and which overrides other values.

Use the following command-line option to use this logger:
ant -logger org.apache.tools.ant.listener.MailLogger

AnsiColorLogger

AnsiColorLogger can produce color output(standard ANT output) by prefixing and suffixing ANSI color code escape sequences to it.It extends the DefaultLogger features.You can specify certain ANSI color sequences for different types of messages based on severity. In other words, info messages are a different color than errors. There are lots of codes that you can use to specify which colors you want. Consult the Ant documentation for the full list.

AnsiColorLogger is designed to work on terminals that support ANSI color codes. It works on XTerm, ETerm, Win9x Console (with ANSI.SYS loaded.), etc.

NOTE: It doesn’t work on WinNT and successors, even when a COMMAND.COM console loaded with ANSI.SYS is used.
The recognized keys and their default values are shown below:

 AnsiColorLogger.ERROR_COLOR=2;31
 AnsiColorLogger.WARNING_COLOR=2;35
 AnsiColorLogger.INFO_COLOR=2;36
 AnsiColorLogger.VERBOSE_COLOR=2;32
 AnsiColorLogger.DEBUG_COLOR=2;34

Each key takes as value a color combination defined as Attribute;Foreground;Background.In the above example, background value has not been used.

Command line option to use this logger:
ant -logger org.apache.tools.ant.listener.AnsiColorLogger

Log4jListener

Log4jListener passes events to Log4j for highly customizable logging. Log4j JAR need to be installed and a ‘log4j.xml’ configuration file configured for this listener to work.Each build event is passed to Log4j, using the full classname of the generator of each build event as the Log4j category:

• build started / build finished – org.apache.tools.ant.Project
• target started / target finished – org.apache.tools.ant.Target
• task started / task finished – the fully qualified classname of the task
• message logged – the classname of one of the above, so if a task logs a message, its classname is the Log4j category used, and so on.

All the start events are logged as INFO-level messages; finish events are sent as INFO if they succeed, and ERROR otherwise. Message events are logged according to their Ant logging level, mapping directly to a corresponding Log4j level.

Example:
log4j.xml file:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
   <appender name="fileAppender" class="org.apache.log4j.FileAppender">
   	<param name="Threshold" value="INFO" />
          <param name="File" value="build.log" />
          <param name="Append" value="true" />
          <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%t %-5p %c{2} - %m%n"/>
          </layout>
     </appender>

  <root>
    <priority value ="debug" />
    <appender-ref ref="fileAppender" />
  </root>
</log4j:configuration>

Place Log4j JAR in your Ant classpath.Set the following attributes:
set ANT_OPTS=-Dlog4j.debug -Dlog4j.configuration=file:///c:/lib/log4j.xml
To use this listener, use the command:
ant -listener org.apache.tools.ant.listener.Log4jListener

Output in build.log file:

  INFO Project : Build started.
  INFO Target : Target "clean" started.
  INFO Delete : Deleting directory C:\build
  INFO Target : Target "clean" finished.
  INFO Target : Target "compile" started.
  INFO Mkdir : Created dir: C:\build\classes
  INFO Javac : C:\build.xml:21: warning: 'includeantruntime' was not set, defaulting to build.sysclasspath=last; set to false for repeatable builds
  INFO Javac : Compiling 1 source file to C:\build\classes
  INFO Target : Target "compile" finished.
  INFO Target : Target "jar" started.
  INFO Mkdir : Created dir: C:\build\jar
  INFO Jar : Building jar: C:\build\jar\WelcomeToJavaBeat.jar
  INFO Target : Target "jar" finished.
  INFO Target : Target "run" started.
  INFO Java : 0 [main] INFO net.javaBeat.WelcomeToJavaBeat  - Welcome To JavaBeat
  INFO Target : Target "run" finished.
  INFO Target : Target "main" started.
  INFO Target : Target "main" finished.
  INFO Project : Build finished.

XmlLogger

XmlLogger logs all the build information to an XML file. This logger behaves differently depending on whether it is invoked as a listener or a logger.This logger writes to XML file named log.xml, or the value of the XmlLogger.file (set in your init target, at the command line with -D, or in a properties file) property if present, when used as a listener. In logger mode, all output goes to the console or to the file specified in -logfile of command-line option.
You can set a property called ant.XmlLogger.stylesheet to point to the XSLT stylesheet. If you don’t specify a style sheet, the XML file will point to one called log.xsl by default in the current directory(ANT_HOME/etc). If you don’t want stylesheet support built into your XML file, set this property to an empty string “”.
Whether XmlLogger is used as a listener or logger, the output is generated only on build completion, as it buffers the information in order to provide timing information for task, targets, and the project.

Command lines for starting Ant with the XmlLogger in both listener and logger modes are:
ant -listener org.apache.tools.ant.XmlLogger
The output is logged in log.xml

ant -logger org.apache.tools.ant.XmlLogger -logfile output.xml
The output is logged in output.xml

TimestampedLogger
TimestampedLogger includes the build completion time at the final success/failure.It extends the fetaures of DefaultLogger.

To use this listener, use the command:
ant -logger org.apache.tools.ant.listener.TimestampedLogger
Output:

C:\>ant -logger org.apache.tools.ant.listener.TimestampedLogger
Buildfile: C:\build.xml
clean:
    [delete] Deleting directory C:\build
compile:
     [mkdir] Created dir: C:\build\classes
     [javac] C:\build.xml:21: warning: 'includeantruntime' was not set, defaulting to build.sysclasspath=last; set to false for repeatable builds
     [javac] Compiling 1 source file to C:\build\classes
 jar:
     [mkdir] Created dir: C:\build\jar
       [jar] Building jar: C:\build\jar\WelcomeToJavaBeat.jar
 run:
      1 0 [main] INFO net.javaBeat.WelcomeToJavaBeat  - Welcome To JavaBeat

 main:

BUILD SUCCESSFUL - at 1/30/13 12:53 PM
 

BigProjectLogger
BigProjectLogger is used in big projects which build complex systems,especialy those run with continuous integration tools and use subant.

• When entering a child project, prints its name and directory
• When exiting a child project, prints its name
• Includes the name of the project when printing a target
• Omits logging the names of all targets that have no direct task output
• Includes the build finished timestamp of the TimeStamp logger

This is useful when using to build a large project from many smaller projects;the output shows which particular project is building.

To use this listener, use the command:
ant -logger org.apache.tools.ant.listener.BigProjectLogger
Output:

C:\>ant -logger org.apache.tools.ant.listener.BigProjectLogger
Buildfile: C:\build.xml

======================================================================
Entering project
In C:\
======================================================================

WelcomeToJavaBeat.clean:
   [delete] Deleting directory C:\build

WelcomeToJavaBeat.compile:
    [mkdir] Created dir: C:\build\classes
    [javac] C:\build.xml:21: warning: 'includeantruntime' was not set, defaulting to build.sysclasspath=last; set to false for repeatable builds
    [javac] Compiling 1 source file to C:\build\classes

WelcomeToJavaBeat.jar:
    [mkdir] Created dir: C:\build\jar
      [jar] Building jar: C:\build\jar\WelcomeToJavaBeat.jar

WelcomeToJavaBeat.run:
     1 0 [main] INFO net.javaBeat.WelcomeToJavaBeat  - Welcome To JavaBeat

======================================================================
Exiting project "WelcomeToJavaBeat"
======================================================================

BUILD SUCCESSFUL - at 1/30/13 12:54 PM
Total time: 2 seconds

ProfileLogger
The ProfileLogger is a default logger which adds start time,end time and durations for each task and target.The output contains a timestamp when entering the build, target or task and a timestamp and the needed time when exiting.

To use this listener, use the command:
ant -logger org.apache.tools.ant.listener.ProfileLogger

Output

C:\>ant -logger org.apache.tools.ant.listener.ProfileLogger
Buildfile: C:\build.xml
property: started Wed Jan 30 12:55:11 IST 2013
property: finished Wed Jan 30 12:55:12 IST 2013 (360ms)
property: started Wed Jan 30 12:55:12 IST 2013
property: finished Wed Jan 30 12:55:12 IST 2013 (0ms)
property: started Wed Jan 30 12:55:12 IST 2013
property: finished Wed Jan 30 12:55:12 IST 2013 (0ms)
property: started Wed Jan 30 12:55:12 IST 2013
property: finished Wed Jan 30 12:55:12 IST 2013 (0ms)
property: started Wed Jan 30 12:55:12 IST 2013
property: finished Wed Jan 30 12:55:12 IST 2013 (0ms)
property: started Wed Jan 30 12:55:12 IST 2013
property: finished Wed Jan 30 12:55:12 IST 2013 (0ms)
path: started Wed Jan 30 12:55:12 IST 2013
path: finished Wed Jan 30 12:55:12 IST 2013 (62ms)
Target clean: started Wed Jan 30 12:55:12 IST 2013
delete: started Wed Jan 30 12:55:12 IST 2013
  [delete] Deleting directory C:\build
delete: finished Wed Jan 30 12:55:12 IST 2013 (31ms)
Target clean: finished Wed Jan 30 12:55:12 IST 2013 (31ms)
Target compile: started Wed Jan 30 12:55:12 IST 2013
mkdir: started Wed Jan 30 12:55:12 IST 2013
    [mkdir] Created dir: C:\build\classes
mkdir: finished Wed Jan 30 12:55:12 IST 2013 (47ms)
javac: started Wed Jan 30 12:55:12 IST 2013
    [javac] C:\build.xml:21: warning: 'includeantruntime' was not set, defaulting to build.sysclasspath=last; set to false for repeatable builds
    [javac] Compiling 1 source file to C:\build\classes
javac: finished Wed Jan 30 12:55:13 IST 2013 (782ms)
Target compile: finished Wed Jan 30 12:55:13 IST 2013 (829ms)
Target jar: started Wed Jan 30 12:55:13 IST 2013
mkdir: started Wed Jan 30 12:55:13 IST 2013
    [mkdir] Created dir: C:\build\jar
mkdir: finished Wed Jan 30 12:55:13 IST 2013 (0ms)
jar: started Wed Jan 30 12:55:13 IST 2013
      [jar] Building jar: C:\build\jar\WelcomeToJavaBeat.jar
jar: finished Wed Jan 30 12:55:13 IST 2013 (78ms)
Target jar: finished Wed Jan 30 12:55:13 IST 2013 (93ms)
Target run: started Wed Jan 30 12:55:13 IST 2013
java: started Wed Jan 30 12:55:13 IST 2013
     1 0 [main] INFO net.javaBeat.WelcomeToJavaBeat  - Welcome To JavaBeat
java: finished Wed Jan 30 12:55:14 IST 2013 (844ms)
Target run: finished Wed Jan 30 12:55:14 IST 2013 (859ms)
Target main: started Wed Jan 30 12:55:14 IST 2013
Target main: finished Wed Jan 30 12:55:14 IST 2013 (0ms)
BUILD SUCCESSFUL

Summary

Books:

• Ant: The Definitive Guide
• Apache Maven 2 Effective Implementation

To summarize,we saw the difference between loggers and listerners.Each built-in logger and listerner is expalined in brief with a simple example.For any further queries please leave your comments.

Task 1: Create a simple java program(WelcomeToJavaBeat) and run it from command prompt

1. Create the following directory structure ( here [basedir] can be any directory):[basedir]\src\net\javaBeat
   [basedir]\build\classes
   [basedir]\build\jarFolder build contains all the generated files.Folder [basedir]\build\classes shall include all compiled files and [basedir]\build\jar folder shall contain the JAR-file.
2. Create a simple java program(WelcomeToJavaBeat.java) in [basedir]\src\net\javaBeat and run it from command prompt.

   package net.javaBeat;
   public class WelcomeToJavaBeat {
       public static void main(String[] args) {
           System.out.println("Welcome To JavaBeat");
       }
   }

3. Compile and run the code as follows:
   javac -sourcepath src -d build\classes src\net\javaBeat\WelcomeToJavaBeat.java
   java -cp build\classes net.javaBeat.WelcomeToJavaBeat
   The second command runs the application by calling the class fileOutput:

   Welcome To JavaBeat

Task2: Build the JAR and use the JAR to run the WelcomeToJavaBeat application

Build a JAR file for the java application and use the JAR command to run the application

1. Create a manifest file.
   • echo Main-Class: net.javaBeat.WelcomeToJavaBeat>myManifest:
   • Do not have blanks around the “>”sign in the echo Main-Class instruction because it would falsify it.
   • This command creates a myManifest file in the [basedir]
2. Create the JAR. (Don’t miss the “dot” at the end of the command.)
   • jar cfm build\jar\WelcomeToJavaBeat.jar myManifest -C build\classes .
3. Run the application.
   • java -jar build\jar\WelcomeToJavaBeat.jar

Task3: Use Apache Ant to create a buildfile for WelcomeToJavaBeat application

Ant uses build.xml as the name for a build file by default, so our [basedir]\build.xml would be as follows. It’s a good practice to have a “clean” target, which deletes all the existing stuff from the directories. The clean target must be the first task to be running after starting the Ant script.

<project>

    <target name="clean">
        <delete dir="build"/>
    </target>

    <target name="compile">
        <mkdir dir="build/classes"/>
        <javac srcdir="src" destdir="build/classes"/>
    </target>

    <target name="jar">
        <mkdir dir="build/jar"/>
        <jar destfile="build/jar/WelcomeToJavaBeat.jar" basedir="build/classes">
            <manifest>
                <attribute name="Main-Class" value="net.javaBeat.WelcomeToJavaBeat"/>
            </manifest>
        </jar>
    </target>

    <target name="run">
        <java jar="build/jar/WelcomeToJavaBeat.jar" fork="true"/>
    </target>

</project>

Use the following command to compile,package and run the application:
ant compile jar run

The above build file can be enhanced as follows:

• Many a times we reference the same directories and main-class.We can address this problem using properties.
• jar-name are hard coded,which can be taken care of by using a special property – an attribute of the <project>-tag
• While invocation we need to remember right order of build steps.This can be dealt with by using dependencies.

<project name="WelcomeToJavaBeat" basedir="." default="main">

    <property name="src.dir"     value="src"/>
    <property name="build.dir"   value="build"/>
    <property name="classes.dir" value="${build.dir}/classes"/>
    <property name="jar.dir"     value="${build.dir}/jar"/>
    <property name="main-class"  value="net.javaBeat.WelcomeToJavaBeat"/>

   <target name="clean">
        <delete dir="${build.dir}"/>
    </target>

    <target name="compile">
        <mkdir dir="${classes.dir}"/>
        <javac srcdir="${src.dir}" destdir="${classes.dir}"/>
    </target>

    <target name="jar" depends="compile">
        <mkdir dir="${jar.dir}"/>
        <jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}">
            <manifest>
                <attribute name="Main-Class" value="${main-class}"/>
            </manifest>
        </jar>
    </target>

    <target name="run" depends="jar">
        <java jar="${jar.dir}/${ant.project.name}.jar" fork="true"/>
    </target>

    <target name="clean-build" depends="clean,jar"/>

    <target name="main" depends="clean,run"/>

</project>

To invoke the buildfile, type ant at the command line. This runs the main target in the buildfile.Note that the project tag defines the default task as main.

Output:

C:\>ant
Buildfile: build.xml

clean:

compile:
    [mkdir] Created dir: C:\build\classes
[javac] Compiling 1 source file to C:\build\classes

jar:
    [mkdir] Created dir: C:\build\jar
      [jar] Building jar: C:\build\jar\WelcomeToJavaBeat.jar

run:</pre>
<code>Welcome To JavaBeat</code>

<code>main:</code>

<code>BUILD SUCCESSFUL</code>

Task4: Build WelcomeToJavaBeat application to include external library(log4j) and hence create Apache Ant buildfile for this application</b></h3>Store external libraries in a new directory lib. Log4J can be downloaded from the Apache site. Create the lib directory and extract the log4j-1.2.17.jar into that lib-directory. Modify java source to use this library and also modify the buildfile so that this library could be accessed during compilation and run.evised Java Source:

 package net.javaBeat;

 import org.apache.log4j.BasicConfigurator;
 import org.apache.log4j.Logger;

 public class WelcomeToJavaBeat {

 static Logger logger = Logger.getLogger(WelcomeToJavaBeat.class);
 public static void main(String[] args) {
 BasicConfigurator.configure();
 logger.info("Welcome To JavaBeat");// the old System Out-statement
 }
}

Revised buildfile:

<project name="WelcomeToJavaBeat" basedir="." default="main">

    <property name="src.dir"     value="src"/>
    <property name="build.dir"   value="build"/>
    <property name="classes.dir" value="${build.dir}/classes"/>
    <property name="jar.dir"     value="${build.dir}/jar"/>
    <property name="lib.dir"     value="lib"/>
    <property name="main-class"  value="net.javaBeat.WelcomeToJavaBeat"/>

    <path id="classpath">
            <fileset dir="${lib.dir}" includes="**/*.jar"/>
    </path>

   <target name="clean">
        <delete dir="${build.dir}"/>
    </target>

    <target name="compile">
        <mkdir dir="${classes.dir}"/>
        <javac srcdir="${src.dir}" destdir="${classes.dir}" classpathref="classpath"/>
    </target>

    <target name="jar" depends="compile">
        <mkdir dir="${jar.dir}"/>
        <jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}">
            <manifest>
                <attribute name="Main-Class" value="${main-class}"/>
            </manifest>
        </jar>
    </target>

    <target name="run" depends="jar">
    	<java fork="true" classname="${main-class}">
                <classpath>
                    <path refid="classpath"/>
                    <path location="${jar.dir}/${ant.project.name}.jar"/>
                </classpath>
        </java>

    </target>
    <target name="clean-build" depends="clean,jar"/>
    <target name="main" depends="clean,run"/>
</project>

Following are the steps to modify the buildfile:

• add property name lib.dir
• add path element for classpath to include JARs in lib.dir
• in the compile target, add classpathref to use the classpath which points to the external library JAR.
• modify run task, such that it refers to the main-class,finds the project JAR and uses the classpath with the JARs in the library.

Run ant and the following output would be displayed:

C:\>ant
Buildfile: build.xml

clean:
   [delete] Deleting directory C:\build

compile:
    [mkdir] Created dir: C:\build\classes
[javac] Compiling 1 source file to C:\build\classes

jar:
    [mkdir] Created dir: C:\build\jar
      [jar] Building jar: C:\build\jar\WelcomeToJavaBeat.jar

run:
     




[main] INFO net.javaBeat.WelcomeToJavaBeat - Welcome To JavaBeat main: BUILD SUCCESSFUL

Summary

We saw stepwise to build a simple java application through command prompt.Then created buildfile to run this simple java application.Further we enhanced the application to include logging using external jar(log4j).We also modified the buildfile to include the external jars.On similar lines we can enhance this appliction to include Junit(testing tool).

If you have any questions, please write it in the comments section. If you are interested in receiving the future articles on Java, please subscribe here.