How do I create a simple mail client program in Swing?

The code snippet below show you how to create a simple Java Swing application that can be used to send an e-mail. The program allows user to supply the from email address, to email address, the subject and the message of the email. User need to select the available SMTP server to connect to and provide the username and password for authentication to the mail server.

Here is the user interface of this simple email client:

Simple E-mail Client

Simple E-mail Client

The main routine for sending the email is in the SendEmailActionListener class, which is an implementation of an ActionListener interface that will handle email sending process when Send E-mail button is pressed.

package org.kodejava.mail;

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Properties;

public class SendEmailClient extends JFrame {
    private final JTextField fromField = new JTextField();
    private final JTextField toField = new JTextField();
    private final JTextField subjectField = new JTextField();
    private final JComboBox<String> mailSmtpHostComboBox = new JComboBox<>();
    private final JTextField usernameField = new JTextField();
    private final JPasswordField passwordField = new JPasswordField();
    private final JTextArea contentTextArea = new JTextArea();

    private SendEmailClient() {
        InitializeUI();
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            SendEmailClient client = new SendEmailClient();
            client.setVisible(true);
        });
    }

    private void InitializeUI() {
        setTitle("Send E-mail Client");
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setSize(new Dimension(500, 500));

        getContentPane().setLayout(new BorderLayout());

        // Header Panel
        JPanel headerPanel = new JPanel();
        headerPanel.setLayout(new GridLayout(6, 2));
        headerPanel.add(new JLabel("From:"));
        headerPanel.add(fromField);

        headerPanel.add(new JLabel("To:"));
        headerPanel.add(toField);

        headerPanel.add(new JLabel("Subject:"));
        headerPanel.add(subjectField);

        headerPanel.add(new JLabel("SMTP Server:"));
        headerPanel.add(mailSmtpHostComboBox);
        mailSmtpHostComboBox.addItem("smtp.gmail.com");

        headerPanel.add(new JLabel("Username:"));
        headerPanel.add(usernameField);

        headerPanel.add(new JLabel("Password:"));
        headerPanel.add(passwordField);

        // Body Panel
        JPanel bodyPanel = new JPanel();
        bodyPanel.setLayout(new BorderLayout());
        bodyPanel.add(new JLabel("Message:"), BorderLayout.NORTH);
        bodyPanel.add(contentTextArea, BorderLayout.CENTER);

        JPanel footerPanel = new JPanel();
        footerPanel.setLayout(new BorderLayout());
        JButton sendMailButton = new JButton("Send E-mail");
        sendMailButton.addActionListener(new SendEmailActionListener());

        footerPanel.add(sendMailButton, BorderLayout.SOUTH);

        getContentPane().add(headerPanel, BorderLayout.NORTH);
        getContentPane().add(bodyPanel, BorderLayout.CENTER);
        getContentPane().add(footerPanel, BorderLayout.SOUTH);
    }

    private class SendEmailActionListener implements ActionListener {
        SendEmailActionListener() {
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            Properties props = new Properties();
            props.put("mail.smtp.host", mailSmtpHostComboBox.getSelectedItem());
            props.put("mail.transport.protocol", "smtp");
            props.put("mail.smtp.starttls.enable", "true");
            props.put("mail.smtp.auth", "true");
            props.put("mail.smtp.port", "465");
            props.put("mail.smtp.socketFactory.port", "465");
            props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
            props.put("mail.smtp.ssl.protocols", "TLSv1.2");

            Session session = Session.getDefaultInstance(props);
            try {
                InternetAddress fromAddress = new InternetAddress(fromField.getText());
                InternetAddress toAddress = new InternetAddress(toField.getText());

                Message message = new MimeMessage(session);
                message.setFrom(fromAddress);
                message.setRecipient(Message.RecipientType.TO, toAddress);
                message.setSubject(subjectField.getText());
                message.setText(contentTextArea.getText());

                Transport.send(message, usernameField.getText(),
                        new String(passwordField.getPassword()));
            } catch (MessagingException ex) {
                ex.printStackTrace();
            }
        }
    }
}

Maven Dependencies

<dependencies>
    <dependency>
        <groupId>javax.mail</groupId>
        <artifactId>javax.mail-api</artifactId>
        <version>1.5.6</version>
    </dependency>
    <dependency>
        <groupId>javax.mail</groupId>
        <artifactId>mail</artifactId>
        <version>1.4.7</version>
    </dependency>
</dependencies>

Maven Central Maven Central

What are the system properties used for sending email?

Here are a list of system properties that can be used to send an e-mail using the JavaMail API.

Property Default Value Description
mail.host Define the host name of the mail server.
mail.smtp.host Define the host name of the SMTP server; this will overrides the mail.host for SMTP connections only.
mail._protocol_.host Define the host name of the specified protocol (POP, IMAP); this will overrides the mail.host.
mail.user Define the default username sent to all mail servers.
mail._protocol_.user Define the default username for the specified protocol; this will overrides the mail.user for the specified protocol.
mail.smtp.port 25 Define the SMTP port on which the SMTP server is listening.
mail._protocol_.port Default port for the corresponding protocol Define the port on which the servers for the specified protocol is listening.
mail.smtp.starttls.enable Upgrade the regular SMTP connection on the usual port to an encrypted (TLS or SSL) connection.
mail.smtp.connectiontimeout Infinite Define the number of milliseconds to wait for a connection timeout.
mail.debug false Define parameter for disabling or enabling information debugging.
mail.from Define the e-mail address to use in the From header.
mail.mime.charset file.encoding Define the default character set used to send messages.
mail.alternates Define other email address for the current that will not to be included when replying to a message.
mail._protocol_.class Define the fully package qualified class name of the provider for the specified protocol.
mail.transport.protocol First transport provider in the configuration file Define default protocol with which to send messages.
mail.transport.protocol.address-type Define the message transport protocol such as SMTP for the specified address type, for example mail.transport.protocol.rfc822.
mail.replayallcc false Put all recipients in the CC list of the reply message instead of the TO field when replying to all.

How do I send an HTML email?

The following code snippets show you how to send an HTML e-mail. We begin by defining the e-mail information such as the from address, to address and the subject. The next step it to create a Properties that will be used to create a mail Session object. Having a Session object we can then create a Message using the MimeMessage.

We use the MimeMessage.setContent(Object, String) to set the html content of the email. Do not forget to set the content type to text/html and also supply the character set, in the example we use charset=utf-8.

package org.kodejava.mail;

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import java.util.Properties;

public class SendHTMLEmail {
    public static void main(String[] args) {
        String from = "[email protected]";
        String to = "[email protected]";
        String subject = "Hello";

        Properties props = new Properties();
        props.put("mail.smtp.host", "smtp.gmail.com");
        props.put("mail.transport.protocol", "smtp");
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.smtp.port", "587");
        props.put("mail.smtp.ssl.protocols", "TLSv1.2");
        Session session = Session.getDefaultInstance(props);

        try {
            InternetAddress fromAddress = new InternetAddress(from);
            InternetAddress toAddress = new InternetAddress(to);

            Message message = new MimeMessage(session);
            message.setFrom(fromAddress);
            message.setRecipient(Message.RecipientType.TO, toAddress);
            message.setSubject(subject);

            String sb = "<head>" +
                    "<style type=\"text/css\">" +
                    "  .red { color: #f00; }" +
                    "</style>" +
                    "</head>" +
                    "<h1 class=\"red\">" + message.getSubject() + "</h1>" +
                    "<p>" +
                    "Lorem ipsum dolor sit amet, <em>consectetur</em> adipisicing elit, " +
                    "sed do eiusmod tempor incididunt ut labore et dolore magna <strong>" +
                    "aliqua</strong>.</p>";
            message.setContent(sb, "text/html; charset=utf-8");
            message.saveChanges();

            // Send the message to the recipient. You also need to specify the username 
            // and password to authenticate to the mail server.
            Transport.send(message, "kodejava", "password");
        } catch (MessagingException e) {
            e.printStackTrace();
        }
    }
}

Maven Dependencies

<dependencies>
    <dependency>
        <groupId>javax.mail</groupId>
        <artifactId>javax.mail-api</artifactId>
        <version>1.5.6</version>
    </dependency>
    <dependency>
        <groupId>javax.mail</groupId>
        <artifactId>mail</artifactId>
        <version>1.4.7</version>
    </dependency>
</dependencies>

Maven Central Maven Central

How do I read last n characters from a file?

In the following post you will learn how to read last n characters from a file. The JDK 7 introduces a new SeekableByteChannel interface which allows its implementation to change the position and the size of the byte channel. One of its implementation is the FileChannel class (java.nio.channels.FileChannel).

The FileChannel class make it possible to get hold the current position of where we are going to read from or write to a file. The code snippet below shows you how you can read the last 1000 characters from a log file.

package org.kodejava.io;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class FileReadLastNCharacters {
    public static void main(String[] args) {
        // Defines the path to the log file and creates a ByteBuffer.
        Path logPath = Paths.get("C:/tools/apache-tomcat-10.0.11/logs/catalina.out");
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        try {
            // Creates FileChannel and open the file channel for read access.
            FileChannel channel = FileChannel.open(logPath, StandardOpenOption.READ);

            // Read a sequence of bytes from the channel into the buffer starting
            // at given file position, which is the channel size - 1000. Because
            // we are going to read the last 1000 characters from the file.
            channel.read(buffer, channel.size() - 1000);
            System.out.println("Characters = " + new String(buffer.array()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

The steps in the code snippet above are:

  • Get the path to the log file.
  • Create a ByteBuffer, a buffer where the read bytes to be transferred.
  • Using the FileChannel.open() method we open a file to be read and return a FileChannel object.
  • The read() method of the FileChannel reads a sequence of bytes from the channel and transfer them to the given buffer starting and the position defined by channel.size() - 1000. This method returns the number of bytes read, possible zero, or -1 if the given position is greater than or equal to the file’s current size.
  • Print out the buffered string.

Java SE Installation Tutorial

Summary: This tutorial is about Java Development Kit (JDK) Standard Edition installation guide. After reading and executing this tutorial you will be able to install the JDK and setting the basic configuration for running the Java compiler from the command line. You will also learn how to create, compile and run a simple Hello World program written in Java.

Download The JDK

When this tutorial is written, the latest JDK is version 7 Update 45. To download the Java SE Development Kit 7 (JDK 7) click to following URL: Java SE Downloads. Make sure you choose the Windows version and download the JDK and not the JRE. The JDK installer will have the JRE included.

Installing The JDK

After downloading you will have a file called jdk-7u45-windows-i586.exe. Executing this file, either by double-click the file or running it from the command prompt, will begin the installation process. You will see the following screens during the installation process:

Installation Wizard Welcome Screen

Installation Wizard Welcome Screen

To continue the installation click the Next button shown in the screen above. This action will bring you to the feature’s selection screen in the installation wizard shown below.

Features Selection

Features Selection

In the feature’s selection screen above you will be able to choose which features to install. For the simplicity of this tutorial we will choose to install the entire features. We will also use the default installation path. In Windows operating system the default path is C:\Program Files (x86)\Java\jdk1.7.0_45. Click the Next button to continue to the next step.

Installation Progress

Installation Progress

The screen above shows the progress status of the JDK installation. Depending on your computer speed this process may take a couple of minutes to finish. Wait for the next screen to show up.

JRE Installation Screen

JRE Installation Screen

As stated above that the JRE is included within the JDK installer, the screen above show you the JRE installation wizard. We will use the default path as shown above C:\Program Files (x86)\Java\jre7. Click the Next button to continue to the next step.

JRE Installation Progress

JRE Installation Progress

The screen above shows the status of the JRE installation. Depending on your computer speed this process may take some other minutes to complete. When the JRE installation complete you will see the next screen.

JDK Installation Completed

JDK Installation Completed

Seeing the screen above means that your JDK installation is completed. Click the Finish button to exit the installation Wizard.

Configuring The JDK

Now you have the JDK installed on your system. Configuring the JDK so that you can run the javac and java commands from the command prompt is another important steps. A lot of beginners faced with a problem that the javac command is not recognized because they did not configure the path correctly. To validate your installation type the javac command in the command prompt. At first, you will see the following screen as the command output.

javac command is not recognized

javac command is not recognized

To make the javac command run properly you need to update the PATH environment variable to include the Java binary installation path. The following steps will show you how to configure the PATH environment variable.

  • Open your Windows Explorer, you can use the Windows + E shortcut.
  • Right click on Computer icon and choose the Properties menu.
  • Click Advanced system setting from the Task list.
  • In the System Properties window choose the Advanced tab.
  • Click the Environment Variables button.
  • In the Environment Variables windows you will see two sections. User variables and System variables.
  • Find the Path variable and click the Edit button.
  • In the Edit User Variable screen, update the current variable value by adding the path to JDK bin folder, in our case the path will be C:\Program Files (x86)\Java\jdk1.7.0_45\bin;. You should add this information at the beginning at the beginning to make sure it will be picked first.
  • Press the OK button to update the User Variable.
  • Press the OK button to finish the Environment Variables setting.
  • Press the OK button on the System Properties window to close it.

Now you can open a new command prompt window and type the javac command. You will see that the javac command is now run as expected. You can type javac -version to check the version of your JDK.

Java Command Recognized

Java Command Recognized

Creating The HelloWorld.java

Now you have the JDK installed and configured properly. Let’s now create our first Java program, the famous Hello World program. Let’s begin.

  • Open a command prompt window.
  • Create a directory C:\HelloWorld\src.
  • Go to the src directory and create another directory call program.
  • Go to the program directory.
  • Create the HelloWorld.java source file by typing notepad.exe HelloWorld.java.
  • The Notepad program will show a dialog saying that the HelloWorld.java file is not found.
  • Press the Yes button for creating the file.
  • Type the following code in the Notepad editor.
package program;

public class HelloWorld {
   public static void main(String[] args) {
       System.out.println("Hello World");
   }
}
  • Click the Save menu to save your program.
  • Click the Exit menu to exit from the Notepad program.
  • Type the dir command, and you will see that you have created a file called HelloWorld.java.

Compiling Java Source File

Up to this step you have created your first Java program. Before running the program you need to compile it. The compilation process compiles your Java source file into something called the Java bytecode. The bytecode is an intermediate language that makes the Java program portable across different platform.

To compile the program do the following step:

  • Go to the C:\HelloWorld\src\program directory.
  • Type javac HelloWorld.java to compile the source code.
  • A successful compilation will produce a HelloWorld.class file. This class file is your binary HelloWorld program, and it is ready to be executed.
Compiling Hello World

Compiling Hello World

Running the Program

Now you are in the final step of the tutorial. Running the HelloWorld program. Here are the final step you need to run:

  • Go to the C:\HelloWorld\src directory.
  • Type java program.HelloWorld without the .class extension to run the program.
  • You will see that the Hello World string printed on the screen.
Running Hello World

Running Hello World

That’s all for now, see you on another tutorial.

How do I compress or zip a directory recursively?

In this example you are going to learn how to zip or compress a directory recursively. The zip file format allows us to compress multiple files. We use the java.util.zip.ZipOutputStream to compress the file. Each entry in the zip file is represented by the java.util.zip.ZipEntry class.

To compress a directory we must first get all the list of files in the specified directory and including all files in the subdirectory. In the example this task is handled by the getFileList() method. This method store the file list in the fileList variable to be use later during the compression process to create the ZipEntry.

Below is the code example showing you how to compress multiple files using zip.

package org.kodejava.util.zip;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipDirectoryExample {
    private final List<String> fileList = new ArrayList<>();

    public static void main(String[] args) {
        String dir = "D:/Data";
        String zipFile = "D:/Data.zip";

        ZipDirectoryExample zip = new ZipDirectoryExample();
        zip.compressDirectory(dir, zipFile);
    }

    private void compressDirectory(String dir, String zipFile) {
        File directory = new File(dir);
        getFileList(directory);

        try (FileOutputStream fos = new FileOutputStream(zipFile);
             ZipOutputStream zos = new ZipOutputStream(fos)) {

            for (String filePath : fileList) {
                System.out.println("Compressing: " + filePath);

                // Creates a zip entry.
                String name = filePath.substring(directory.getAbsolutePath().length() + 1);

                ZipEntry zipEntry = new ZipEntry(name);
                zos.putNextEntry(zipEntry);

                // Read file content and write to zip output stream.
                try (FileInputStream fis = new FileInputStream(filePath)) {
                    byte[] buffer = new byte[1024];
                    int length;
                    while ((length = fis.read(buffer)) > 0) {
                        zos.write(buffer, 0, length);
                    }

                    // Close the zip entry.
                    zos.closeEntry();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Get files list from the directory recursive to the subdirectory.
     */
    private void getFileList(File directory) {
        File[] files = directory.listFiles();
        if (files != null && files.length > 0) {
            for (File file : files) {
                if (file.isFile()) {
                    fileList.add(file.getAbsolutePath());
                } else {
                    getFileList(file);
                }
            }
        }

    }
}

The code snippet above will compress the D:\Data directory, and it will produce a zip file called Data.zip. When running the program you can see something like this in the console:

Compressing: D:\Data\Aa.txt
Compressing: D:\Data\AA1a1.txt
Compressing: D:\Data\Bb.txt
Compressing: D:\Data\Cc.txt
Compressing: D:\Data\CC1c1.txt
Compressing: D:\Data\Dd.txt

How do I decompress a GZip file in Java?

In the previous example we have learn how to compress a file in GZIP format. To get the file back to its original version we will now learn how to decompress the gzip file. Just like the previous example, we are also going to use the FileInputStream and FileOutputStream class to read the compressed source file and to write out the decompressed file. While GZipOutputStream was used to create the gzip file, the GZipInputStream is the class that handles the decompression.

Here is your code snippet:

package org.kodejava.util.zip;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.GZIPInputStream;

public class GZipDecompressExample {
    public static void main(String[] args) {
        // GZip input and output file.
        String sourceFile = "output.gz";
        String targetFile = "data-1.txt";

        try (
                // Create a file input stream to read the source file.
                FileInputStream fis = new FileInputStream(sourceFile);

                // Create a gzip input stream to decompress the source
                // file defined by the file input stream.
                GZIPInputStream gzis = new GZIPInputStream(fis);

                // Create file output stream where the decompression result
                // will be stored.
                FileOutputStream fos = new FileOutputStream(targetFile)) {

            // Create a buffer and temporary variable used during the
            // file decompress process.
            byte[] buffer = new byte[1024];
            int length;

            // Read from the compressed source file and write the
            // decompress file.
            while ((length = gzis.read(buffer)) > 0) {
                fos.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

How do I compress a file in Gzip format?

In this code example we will learn how to compress a file using the gzip compression. By its nature, gzip can only compress a single file, you can not use it for compressing a directory and all the files in that directory.

Classes that you will be using to compress a file in gzip format includes the GZipOutputStream, FileInputStream and FileOutputStream classes. The steps for compressing a file described in the comments of the code snippet below.

package org.kodejava.util.zip;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.GZIPOutputStream;

public class GZipCompressExample {
    public static void main(String[] args) {
        // GZip input and output file.
        String sourceFile = "data.txt";
        String targetFile = "output.gz";

        try (
                // Create a file input stream of the file that is going to be
                // compressed.
                FileInputStream fis = new FileInputStream(sourceFile);

                // Create a file output stream then write the gzip result into
                // a specified file name.
                FileOutputStream fos = new FileOutputStream(targetFile);

                // Create a gzip output stream object with file output stream
                // as the argument.
                GZIPOutputStream gzos = new GZIPOutputStream(fos)) {

            // Define buffer and temporary variable for iterating the file
            // input stream.
            byte[] buffer = new byte[1024];
            int length;

            // Read all the content of the file input stream and write it
            // to the gzip output stream object.
            while ((length = fis.read(buffer)) > 0) {
                gzos.write(buffer, 0, length);
            }

            // Finish file compressing and close all streams.
            gzos.finish();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Creating a simple project using Maven

In this post you will learn how to create a simple project, a Hello World project using Maven. If you haven’t installed Maven in your machine you can read Introduction to Apache Maven posted earlier in this blog. In this post you will see what the basic configuration for creating a maven project. Such as the basic of pom.xml file and how maven structure the directory of our project files.

At this time we won’t use any special IDE such as Eclipse, Netbeans or IntelliJ to create our project. We’ll just work using a simple text editor and the command prompt. Let us begin.

Step 1 – Create a project directory and the pom.xml file.

  • Create a directory where you will place the project files. As an example I’ll create my project in D:\Projects\HelloWorld.
  • Create a file called pom.xml in the HelloWorld directory. POM stands for Project Object Model, and it represents a Maven project.
  • Type the following information in the pom.xml file.
<project>
    <groupId>org.kodejava</groupId>
    <artifactId>HelloWorld</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <modelVersion>4.0.0</modelVersion>
</project>
  • At this point we have our pom.xml file created. What you’ve seen above is the simplest example of a pom file. And here is a brief description of the pom file above:
    • groupId: the unique id of a Maven project. Typically, it uses your company name domain in reverse order just like how you would create a package for your Java project. For example here I use org.kodejava.
    • artifactId: is the name of the project, we’ll be using HelloWorld.
    • version: is the version number of our project.
    • packaging: the project artifact type. In this case we will ask Maven to package our example as a jar file.
    • modelVersion: is the version of the POM file we are using for this project.

Maven works by applying a concept called convention over configuration. This will apply for example on how the directory of a project is structured. All Maven project will use the same directory for organising the files in the project. There is a directory for Java source codes, unit testing codes, configuration files, etc. This will make easier for developer to jump from one Maven project to the other projects. Now let us continue to the next step.

Step 2 – Create the HelloWorld class.

  • Create a directory for Java source code in the project root directory. Actually you’ll create three directories. These directories are src\main\java.
  • Create a file HellWorld.java under the java directory you’ve created above.
  • Type the following code for the HelloWorld class.
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}
  • Now we have our class created we can start to use maven to build our project. But before we do let see what you should have after finishing these steps. You should see that you have a project structure that similar the screen capture below:

Maven HelloWorld

Steps 3 – Compiling the Project.

At this time we have our first Maven project created, and we are ready to build it. To build this basic project we don’t have to add anything to Maven. It already comes with a predefined sets of build related task such as clean, compile, test, package, etc.

  • Open a Command Prompt and go to your project directory. You should be in the HelloWorld directory where you can see the pom.xml file.
  • To compile your project type mvn compile in the command prompt.
D:\Projects\HelloWorld>mvn compile
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building HelloWorld 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] Compiling 1 source file to D:\Projects\HelloWorld\target\classes
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.405s
[INFO] Finished at: Tue Sep 24 10:18:10 CST 2013
[INFO] Final Memory: 7M/23M
[INFO] ------------------------------------------------------------------------
D:\Projects\HelloWorld>
  • What you see above is the typical result of a success build. You might see longer message such as information about the artifact downloaded by Maven during the compile process.
  • If you list the project directory you’ll see a new directory called targetclasses is created. And inside the classes directory you’ll find your HelloWorld.class file.
  • To run the class cd to targetclasses and type java HelloWorld.

Steps 4 – Clean and Package the Project.

  • Now if you want to clean your previous built project you can use mvn clean. Make sure you are executing this command from the project root directory where the pom.xml file is located.
  • Executing this command will give you the similar output like this.
D:\Projects\HelloWorld>mvn clean
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building HelloWorld 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.4.1:clean (default-clean) @ HelloWorld ---
[INFO] Deleting D:\Projects\HelloWorld\target
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 0.353s
[INFO] Finished at: Tue Sep 24 10:29:16 CST 2013
[INFO] Final Memory: 4M/15M
[INFO] ------------------------------------------------------------------------
D:\Projects\HelloWorld>
  • As you can see it deleted the previously created target directory.
  • In the pom.xml file we have defined the packaging of our project as jar file. So let’s create it now.
  • To package a Maven project type mvn package command.
D:\Projects\HelloWorld>mvn package
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Building HelloWorld 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] Compiling 1 source file to D:\Projects\HelloWorld\target\classes
[INFO] skip non existing resourceDirectory D:\Projects\HelloWorld\src\test\resources
[INFO] --- maven-compiler-plugin:2.3.2:testCompile (default-testCompile) @ HelloWorld ---
[INFO] No sources to compile
[INFO] --- maven-surefire-plugin:2.7.2:test (default-test) @ HelloWorld ---
[INFO] No tests to run.
[INFO] Surefire report directory: D:\Projects\HelloWorld\target\surefire-reports
[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
There are no tests to run.
Results :
Tests run: 0, Failures: 0, Errors: 0, Skipped: 0
[INFO] --- maven-jar-plugin:2.3.1:jar (default-jar) @ HelloWorld ---
[INFO] Building jar: D:\Projects\HelloWorld\target\HelloWorld-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.040s
[INFO] Finished at: Tue Sep 24 10:32:41 CST 2013
[INFO] Final Memory: 8M/20M
[INFO] ------------------------------------------------------------------------
D:\Projects\HelloWorld>
  • The mvn package gives you a longer console output. From the output above you can see that executing the package command made Maven to compile the Java source code, unit test source code (we don’t have it at this time). It also runs the unit test and finally build the jar file.
  • The jar file is created under the target directory and named HelloWorld-1.0-SNAPSHOT.jar. The name comes from the artifactId, version and packaging information defined in the pom.xml file.

That are all the steps that you need to create and manage a simple project using Maven. We start by creating a pom.xml file and then create a directory structure for storing our classes file. And then we learn how to compile, clean and package our Maven project. In the next Maven post we’ll learn more on Maven dependency management and starting to use an IDE to set up our Maven project.

Thank your for reading and see you on the next Maven post.

Introduction to JUnit

In this post we will start to learn about JUnit Framework. JUnit is a framework for unit testing Java applications. It was developed by Kent Back and Erich Gamma to help developers to create a better applications. JUnit has become the standard tool used by developers when it comes to unit testing.

Every day, when you create an application from the smallest one, that consist of a single class to a project of a large application, your development workflow will always be the same. You will begin by writing a small code, compile it, run the code and finally test it. And you will mostly find that things doesn’t work as expected at first. So you’ll go back to your favorite IDE, check what the error was, and you will repeat the process, code, compile, run and test, until you get the result that you want.

We can do this steps manually. For example when you have a console application you will typically run the code, check the result printed out on the console screen to find out if the program return the correct result. When you find the error you will fix it and re-run the code again and again. This kind of test seems like a time-consuming activity, tiresome and even make you bored. And instead of testing the code you are testing your ability to test. Because you have to check whether the output printed in the console is correct or not.

Here is a simple example of a very simple calculator that know how to add two numbers and how you are testing it using a simple main class in a console application.

package org.kodejava.junit;

public class Calculator {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int a = 10;
        int b = 15;
        int c = Calculator.add(a, b);

        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);

        if (c == 25) {
            System.out.println("Test success!");
        } else {
            System.out.println("Test failed!");
        }
    }
}
Testing your ability to test.

Testing your ability to test.

To make life easier JUnit framework comes with great help to overcome these problems. You can tell JUnit framework to test your code by creating a unit tests. You will create a class that test your code, you’ll define your testing criteria in this unit testing class. You can execute these unit testing, and it will report whether the tests pass or fail. And you can run it as many times as you’ll like to see if the test still pass after you modified parts of your code.

Now, let see how JUnit can help us to test the previous calculator code. Before creating the unit test class we need to download the JUnit library from the website at JUnit, follow the link to download page and download the jars. There are two main jar files that you need to download, the junit.jar and hamcrest-core.jar. When you are using and IDE, the JUnit usually installed as part of the IDE such as NetBeans, Eclipse or IntelliJ IDEA.

Let’s write the unit testing code.

package org.kodejava.junit;

import org.junit.Test;
import static org.junit.Assert.*;

public class CalculatorTest {
    @Test
    public void addTwoNumbersTest() {
        int a = 10;
        int b = 15;
        assertEquals(25, Calculator.add(a, b));
    }
}

From this code snippet what you can see is:

  • We create a class called CalculatorTest. We usually name the unit test class with the same name with the class under test but suffix it with Test.
  • We create a test method called addTwoNumberTest(). You can name your test method as descriptive as possible. This will have you understand what the method is trying to test.
  • To make a method a unit test method we add the @Test annotation to it. This annotation will tell the JUnit framework that the annotated method is a part of the unit testing it should execute on our behalf.
  • In the test method body we use the assertEquals() method to check the test result. In this case we expect 25 is returned when the Calculaor.add() method add two numbers, the a + b.

After you create the unit testing class, let’s compile it and this JUnit test from the command prompt. Remember to have also the class under test, which is the Calculator class beside your unit testing class. To execute JUnit test you can type the following command.

java -cp .;junit-4.13.2.jar org.junit.runner.JUnitCore org.kodejava.junit.CalculatorTest

I am intentionally place the junit.jar file in the root of my work directory so that I can make the -cp option short. The classpath options tell Java where to look the required class files.

Executing JUnit Test

Executing JUnit Test

That is all for the bit of introduction to JUnit. In the coming post I will write more about JUnit and how to use other available annotation, so you can write a better test.