Tools | Kode Java - Learn Java by Examples

Creating a simple project using Maven

By Wayan in Maven, Tools Last modified: June 11, 2023 0 Comment

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

By Wayan in JUnit, Tools Last modified: June 11, 2023 0 Comment

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.

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

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.

Introduction to GenMyModel

By Mengjie Zou in Tools, UML Last modified: June 11, 2023 2 Comments

After 3 years of research and development, GenMyModel draws the future of software modeling. GenMyModel is a free browser hosted UML tool for developers and software architects. Its main strength: create UML compliant models online and generate code. Unlike the well known desktop alternatives, it allows you to work on any web browser and from any computer with any OS (Windows, Linux, macOS).

GenMyModel has been released in beta in 2013. It supports for now class and use case diagrams and works with GitHub to host the generated code. You can try GenMyModel here GenMyModel Online UML Tool.

Online UML Tool

Using the App

Log in & create a UML project

The application itself is available at this address: http://app.genmymodel.com/. First thing you see is the connection window where you can sign in with your Google account or sign up with another mail address.

GenMyModel Dashboard

Once you are logged in, you discover your dashboard where you have the choice to create a new project or use one of the existing templates below. When you create a new project, you can then set a title and choose between a public or private project. When you open a project, a new tab appears above for you to easily switch between your class and use case
diagrams.

Public UML Online

Creating class and use case diagrams

When you create a new project, it instantly opens a tab for class diagrams, but you can choose in the File menu to make new use case diagrams.

The vertical toolbar between your whiteboard and the project explorer shows you the different tools to create classes, interfaces, add attributes, make associations and more. For example, if you select the class tool or press ‘C’ (the underlined letters being keyboard shortcuts), you can place a class anywhere on your whiteboard. You can also add several elements at a time by holding Ctrl

Class Diagram Online

You can then select one or more elements and move them on your whiteboard, rearrange links or set a few properties. Same thing goes for use case diagrams.

Change the model properties

The bottom left corner of the application groups all the properties you need for the elements you selected. This way, this small window allows you to set names, types, visibility, multiplicity, comments and a few other settings.

UML Online Property

Those possibilities change according to your selection on your whiteboard or the project explorer.

Code generation and push to GitHub

Generate Java and SQL code

GenMyModel provides code generators:

Java Beans
JPA Beans
Spring Data REST application
Spring Roo
SQL

There are two ways to generate code: with the ‘Tools’ menu or by right-clicking on your model. You can then choose between a direct generation creating a ZIP file with Java, Java JPA or SQL code, or configuring your own saved configuration allowing you to push to your GitHub repositories.

UML Code Generators

Push to GitHub

If you are a GitHub user, you can push your generated code to the hosting service. In the code generation configuration window, you just have to type your repository URL and the branch you would like to send your code to. The first push can take a while, but it is quite fast afterwards.

UML Java Code Generator

Report, image and model export

Export to image and XMI

GenMyModel allows you to export you models to image files in JPEG or SVG, or export to XMI. You can choose either format by right-clicking or with the ‘Tools’ menu.

Export documentation to PDF

You can also export the documentation of your models to a PDF file. Resulting in a document with images of your diagrams and the list of every element and its properties.

UML PDF Export

Share by email

Sharing to social network is planned for the next few months, in the meantime you can share your work by email with the same menu.

Web description for public projects

When creating a project within GenMyModel, you can choose between the public and private options. Private means only you can see and modify the model. Public means you are the only one allowed to modify it but anyone can fork it.

Web pages are automatically created for public projects so that you can share and show what you design. Examples: Class Diagram University Management System

What’s next

The next major release before October 2013 will include:

Realtime collaboration
Java Reverse engineering
Package support for class diagrams and use case diagrams

Technology

GenMyModel is built upon JavaScript and HTML5.

Introduction to Apache Maven

By Wayan in Maven, Tools Last modified: June 11, 2023 0 Comment

In this post you will learn about Apache Maven. What is Maven? In simple words, Maven is a tool that we can use to build and manage a Java based project. Compare to the older type of build tool such as Ant, which is also an Apache project, Maven gives developers a standard way to build projects, a clear definition of the projects consisted of, an easy way to publish project information and an easy management of the project libraries dependency.

In Maven, the project libraries (Jars) will be maintained in the Maven repository and can be shared among projects. We don’t need to include the Jars in the project’s source code, as what we usually do when using tool like Ant. And here are the main objectives of the Apache Maven project:

Making the build process easy.
Providing a uniform build system.
Providing quality project information.
Providing guidelines for best practices development.
Allowing transparent migration to a new features.

After you know a little about Maven, let’s continue to the next step, installing the Apache Maven.

Step 1. Downloading Apache Maven

Go to Apache Maven and from the Get Maven section on the left sidebar click Download link.
Download the appropriate installer for your platform. For example, I am downloading the .zip file. The latest version when this post is written is Maven 3.1.0 (apache-maven-3.1.0-bin.zip).
Extract the downloaded zip file. For example, I am extracting it into D:\Toolbox\apache-maven-3.1.0 directory.

Step 2. Configuring Environment Variables

After extracting Maven distribution you have to define M2_HOME environment variable. The value of this variable is the path to your Maven installation.
You can create environment variable using the following steps:
- Right click on My Computer.
- Select Properties menu.
- Select Advanced system settings.
- In the System Properties window select the Advanced tab and click the Environment Variables button.
- Add the variable in the System variables section.
- Click OK to proceed.
Add the %M2_HOME%\bin; into your PATH environment variable so that you can execute Maven command from any path inside your command prompt. This PATH variable can also be updated in the System variables section.
Open your command prompt and type echo %M2_HOME%. Pressing Enter and you should see the value of the variable printed on the console. For example:

D:\>echo %M2_HOME%
D:\Toolbox\apache-maven-3.1.0

To check if Maven also in your Path variable you can execute echo %PATH% in your command prompt. You should see the path to Maven binary in the Path variable.

D:\>echo %PATH%
D:\Toolbox\apache-maven-3.1.0\bin;C:\Program Files (x86)\Java\jdk1.7.0_13\bin;

Step 3. Running Maven

Now you have Maven installed and configured. Let’s run Maven for the first time.
To run Maven we use the mvn command.
For example to check the version of the Maven we run mvn -version
You will see the following output, more or less, it depends on the JDK version you have in your machine.

D:\>mvn -version
Apache Maven 3.1.0 (893ca28a1da9d5f51ac03827af98bb730128f9f2; 2013-06-28 10:15:32+0800)
Maven home: D:\Toolbox\apache-maven-3.1.0
Java version: 1.7.0_13, vendor: Oracle Corporation
Java home: C:Program Files (x86)\Java\jdk1.7.0_13\jre
Default locale: en_US, platform encoding: Cp1252
OS name: "windows 7", version: "6.1", arch: "x86", family: "windows"

Congratulations! You’ve installed Apache Maven successfully on your development machine. On the next post I will show you how to create a new project using Maven.

Introduction to JetBrains IntelliJ IDEA Community Edition

By Wayan in IntelliJ IDEA, Tools Last modified: June 11, 2023 0 Comment

In this post I will introduce to you the JetBrains IntelliJ IDEA, one the most powerful IDE (Integrated Development Environment) for Java development or other languages that run on the JVM such as Groovy and Scala. IntelliJ IDEA comes in two editions, the IntelliJJ IDEA Ultimate Edition and the IntelliJ IDEA Community Edition.

The IntelliJ IDEA Community Edition is an open source version of Intelli IDEA. That’s mean you can use it for free. If you work with standard Java, Groovy, Scala or mobile development using Android then the Community Edition can be your choice. If you work with in web or Java EE development then the Ultimate Edition is the way to go.

Here are some features that you will get when using the IntelliJ IDEA Community Edition:

An Intelligent code editor that has all the smarts for understanding Java, XML and Groovy code.
Refactorings, code inspections and intentions, super-fast navigation and search
Testing framework integration: JUnit and TestNG
Build tools support: Ant and Maven
Popular version control systems integration: CVS, Subversion and Git
Swing UI designer

After a bit of introduction, let’s begin the installation.

Step 1. Getting the Installation Distribution

Download the installation package of the IntelliJ IDEA Community Edition.
Click Download IntelliJ IDEA Community Edition to go the download page.
On the page you can see two editions, select the Community Edition. The current version available when this post was written is the version 12.1.4. You can also see that the download are available for Windows, Mac OS X and Linux. For this post I will download the Windows version. The download size for the Windows installer is around 130 MB.

Step 2. Install IntelliJ IDEA Community Edition

To begin, double-click the installer you’ve downloaded, for example ideaIC-12.1.4.exe.
You’ll be greeted with the following screen

intellij-idea-community-edition-setup-step-1

IntelliJ IDEA Setup Welcome Screen

Press the Next button to continue.
You’ll be asked the installation location. On Windows it will be defaulted to the C:\Program Files directory.
Press Next for a couple of times until the installation complete.
When you choose to run the IntelliJ IDEA for the first time you’ll get the following screen

Installation Complete Screen

Press OK button to start IntelliJ IDEA for the first time. You will be shown a splash screen right after you press the button and continued by the screen welcoming you to the IDE.

Welcome to IntelliJ IDEA

Step 3. Now you have the IntelliJ IDEA Community Edition installed in your machine. Let’s create your first program using IDEA.

From the Welcome Screen above click the Create New Project menu.
A New Project dialog window will be shown. In this dialog you can do:

Create a New Project Window Dialog

Enter the Project Type, choose Java Module.
Define the Project Name. We’ll just name it HelloWorld.
Choose the Project Location directory.
Select the JDK version you’ll be using.
Press the Next button followed by the Finish button to continue.

Step 4. IntelliJ IDEA Main Window, creating HelloWorld.java

Here is the Main Window of IntelliJ IDEA.

IntelliJ IDEA Community Edition

The bigger screenshot of the project explorer panel.

Project Explorer Window

Before we create a class let’s create a package.
Right-click the src folder, continued by selecting the New and Package menu.
Enter the package name, for instance org.kodejava.introduction
To create a class right click on the newly created package, select New and Java Class menu.
In the Create New Class dialog enter HelloWorld in the Name text field and choose Class from the Kind dropdown selection.
Type the following code in the editor.

package org.kodejava.introduction;

public class HelloWorld {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        HelloWorld hello = new HelloWorld();

        String name = "world";
        hello.setName(name);
        hello.sayHello();
    }

    private void sayHello() {
        System.out.println("Hello " + getName() + "!");
    }
}

Press Shift + F10 or click the green Run button to execute your code.
And we are done!

Other things you can do next is to learn more about the menu and the keyboard shortcuts that you can use while working with the IDE. One good place is to look at the Help, Tip of the Day menu.

That’s finishes our introduction to the IntelliJ IDEA Community Edition IDE. I hope you can continue your learning and this IDE will surely help you to understand Java better. Because it is not just a tool to write code, it will give you a lot of suggestion so that you can always improve your code quality.