Monthly Archives: November 2010

Java Development with NetBeans and Maven: Part 5

Overview

I hope we are well prepared for moving further to the very powerful “Maven” features, which we have known before, the “site”, especially the “report” integration to the outer world. There are many powerful “Maven Plug-in” provided by the “Maven” itself. You can see further information here. From now on, I will introduce you the “Reporting Plug-ins”.

The Report Plug-ins

Regarding the “Maven Plug-inhere, you may be noticed that there are two plug in which we used before. Guess what? The “project-info-reports”, the “mvn site” command itself and the “surefire-report”, the testing report for our previous JUnit. You already know how easy it is. The rest plug in also be same for sure. One picture can give us a thousand words. Here is my tested template “Project POM File” (pom.xml). Please feel free to modify it so that it is fit for your environment.


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.scc.maven.java</groupId>
    <artifactId>MavenJavaPrj01</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>MavenJavaPrj01</name>
    <url>The Project web site URL</url>
    <description>The SDLC Learning</description>

    <licenses>
        <license>
            <name>Apache 2</name>
            <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
            <distribution>repo</distribution>
            <comments>A business-friendly OSS license</comments>
        </license>
    </licenses>

    <organization>
        <name>The Organization Name</name>
        <url>The Organization web site URL</url>
    </organization>

    <developers>
        <developer>
            <id>The developer id</id>
            <name>The developer name</name>
            <email>The developer email</email>
            <url>The developer web site URL</url>
            <organization>The developer organization</organization>
            <organizationUrl>The organization web site url</organizationUrl>
            <roles>
                <role>Role #1</role>
                <role>Role #2</role>
            </roles>
            <timezone>+7</timezone>
            <properties>
                <picUrl>The developer picture URL</picUrl>
            </properties>
        </developer>
    </developers>

    <issueManagement>
        <system>The issue management system, e.g. Bugzilla, TestTrack, ClearQuest, etc</system>
        <url>The issue management system web site URL</url>
    </issueManagement>

    <ciManagement>
        <system>The CI management system, e.g. Hudson,continuum, etc</system>
        <url>The CI web site URL</url>
        <notifiers>
            <notifier>
                <type>mail</type>
                <sendOnError>true</sendOnError>
                <sendOnFailure>true</sendOnFailure>
                <sendOnSuccess>false</sendOnSuccess>
                <sendOnWarning>false</sendOnWarning>
                <configuration>
                    <address>The sender email address</address>
                </configuration>
            </notifier>
        </notifiers>
    </ciManagement>

    <scm>
        <connection>scm:svn:Path/To/Repository</connection>
        <developerConnection>scm:svn:Path/To/Repository</developerConnection>
        <tag>HEAD</tag>
        <url>The SCM web site URL</url>
    </scm>

    <prerequisites>
        <maven>2.2.1</maven>
    </prerequisites>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.0.2</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <encoding>${project.build.sourceEncoding}</encoding>
                    <includes>
                        <include>
                            **/*TestSuite*.java
                        </include>
                    </includes>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-site-plugin</artifactId>
                <version>2.1.1</version>
                <configuration>
                    <locales>en</locales>
                </configuration>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>${basedir}/src/main/java</directory>
                <includes>
                    <include>log4j.dtd</include>
                    <include>log4j.xml</include>
                </includes>
            </resource>
        </resources>
    </build>
    <reporting>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-project-info-reports-plugin</artifactId>
                <version>2.2</version>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-report-plugin</artifactId>
                <version>2.6</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-changelog-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <username>${svnUser}</username>
                    <password>${svnPassword}</password>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-checkstyle-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <configLocation>config/sun_checks.xml</configLocation>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <version>2.7</version>
                <configuration>
                    <stylesheetfile>${basedir}/src/main/javadoc/stylesheet.css</stylesheetfile>
                    <show>private</show>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jxr-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <linkXref>true</linkXref>
                    <sourceEncoding>utf-8</sourceEncoding>
                    <minimumTokens>100</minimumTokens>
                    <targetJdk>1.5</targetJdk>
                    <excludes>
                        <exclude>**/*Bean.java</exclude>
                        <exclude>**/generated/*.java</exclude>
                    </excludes>
                    <excludeRoots>
                        <excludeRoot>target/generated-sources/stubs</excludeRoot>
                    </excludeRoots>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-pmd-plugin</artifactId>
                <version>2.5</version>
            </plugin>

        </plugins>
    </reporting>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
</project>

How the report is created.

It is simple by using the “mvn site” command, please refer to my previous post.

Are there any outer world plug in?

Yes, sure. Why not? Maven also mentioned in their plug in page as well. Please travel to the lower part of that page you will see the outer world for sure. I hope we are enjoy traveling.

Summary

We have finished preparing our development environment so that we can ensure that there should not be any surprise during the integration with the very powerful “Maven” features, the “site”, especially the “report”. As I’ve mentioned, This is a final article for my first series.

The well preparing will help us to reduce the defect, on the other hand, if the defect is less, the working time is less, too. That mean we will have more time to do other things in my life. For me is writing this blog. Next I will move further to the detailed “Java/JavaEE” development with “Maven” and will do my best to post for sure. Please stay tuned as always.

Java Development with NetBeans and Maven: Part 4

Overview

We have configured our environment so that we can declare our own information outside the “Project POM File” (pom.xml) such as the “Subversion” user id and password, the “Issue Tracker” user id and password. But it is only the “Maven” universe. We live in the bigger one, the integration universe. That means we need to know the other integrated system universe. Even we configure our credential / personal information with purpose to let “Maven” to use them when it connect to each sever. It is just our credential / personal information. Since “Maven” acts as a client, it should provide credential / personal information itself, too. Normally these communication is done via the “SSL”, especially via the “HTTPS”. There are some good practice to which I would like share.

The HTTPS Good Practice For The Client

Most of integration universe has been configured and deployed under the “Apache HTTP” umbrella. As I’ve mentioned before, the “HTTPS” is preferred. This means the “Maven” will connect to them via the “HTTPS”, too. The “Maven” acts as a client, they act as a server for sure. What is the issues? Well, It is a very well known issue.

The Certificate Management For The Client

Normally the server provides its “certificate” to the client for initiating the “SSL” connection. The client will determine if this “certificate” can be trusted. If yes, the conversation will be initiated.

If not the connection will be dropped. We may face a trouble like we cannot connect to server system shows me something about “no trusted certificate found” or other close to this.

The HTTPS Client Configuration Good Practice

I am informing you about the good practice for the client side who would like to connect to the server via “HTTPS”. If the client is a “Java” environment, the “Server Certificate” should be injected to the “truststore”.

The “Server Certificate” is not only limited to the server certificate itself, but also the “Signer Certificate”, too. Please note the “Signer Certificate” is a certificate of the trusted authority who sign the “Server Certificate”. The signer also not be limited at one level, it can be more. It is called “Certificate Chain”. During the checking & verifying If any of “Certificate” inside this “Certificate Chain” is trusted, It will be determined as trusted. This means if we have 3 levels “Certificate Chain”.

The checking step is as following: -

  1. If the level 3rd is trusted, it is determined as trusted. The checking stop here.
  2. If the level 2nd is trusted, it is determined as trusted. The checking stop here.
  3. If the level 1st is trusted, it is determined as trusted. If not the system may show us as “no trusted certificate found”.

For me, I have 2 levels which are created by the “openssl”. Anyhow it can be a 1 level as a self-signed as well.

By default the “truststore” is as following:-

Table 1: The default truststore for JRE

Default Trustsore for JRE

 

<JRE_HOME>/lib/security/cacerts

 

Example: C:/Java.Application/Sun/Java/jre1.6.0_21/lib/security/cacerts

Table 2: The default truststore for JDK

Default Trustsore for JDK

 

<JDK_HOME>/jre/lib/security/cacerts

 

Example: C:/Java.Application/Sun/Java/jdk1.6.0_21/jre/lib/security/cacerts

The injecting certificate command is as following: -

Table 3: The injecting certificate command

The injecting certificate command

 

keytool -importcert -trustcacerts -alias <MY_ALIAS> -file <Certificate> -keystore <Truststore>

 

Example: keytool -importcert -trustcacerts -alias myserver -file server.cer -keystore cacerts

Please note: you may be prompted to enter the password, the default password is changeit”.

Some of them are not default.

Some of them may have their own configuration environment instead, especially the “Subversion Client”. There are 2 types as global for whole client and per-user.

The server-wide

Unix:

/etc/subversion/servers

/etc/subversion/config

/etc/subversion/hairstyles

Windows:

%ALLUSERSPROFILE%\Application Data\Subversion\servers

%ALLUSERSPROFILE%\Application Data\Subversion\config

%ALLUSERSPROFILE%\Application Data\Subversion\hairstyles

REGISTRY:HKLM\Software\Tigris.org\Subversion\Servers

REGISTRY:HKLM\Software\Tigris.org\Subversion\Config

REGISTRY:HKLM\Software\Tigris.org\Subversion\Hairstyles

The per-user

Unix:

~/.subversion/servers

~/.subversion/config

~/.subversion/hairstyles

Windows:

%APPDATA%\Subversion\servers

%APPDATA%\Subversion\config

%APPDATA%\Subversion\hairstyles

REGISTRY:HKCU\Software\Tigris.org\Subversion\Servers

REGISTRY:HKCU\Software\Tigris.org\Subversion\Config

REGISTRY:HKCU\Software\Tigris.org\Subversion\Hairstyles

I prefer to use the per-user instead. Please note, I’m a “Windows Vista”, my configuration home for “Subversion Client” is “C:\Users\Charlee.Ch\AppData\Roaming\Subversion”. Normally the per-user configuration is created automatically by the “Subversion Client”. If the “Subversion Client” does not trust the “Server Certificate”, you may face the message like this, “Server certificate verification failed: issuer is not trusted”. It can be configured easily by using the “Subversion Client” command via a command line, for me it is a dos prompt, as the following:

Table 4: Configure subversion client to trust the server certificate

Configure subversion client to trust the server certificate

 

svn list https://<YOUR_DOMAIN/svn/path/to/repository

 

Example: svn list https://www.mydomain.com/svn/myproject/trunk

During executing this command, you will be prompted about the “Server Certificate”. Please press “p”, for accepting this certificate permanently. Anyhow the system may prompt you to provide the credential, please enter it properly. The top most certificate for the “Server Certificate Chain” will be stored at your local as the following: -

Table 5: The stored server certificate folder

The stored server certificate folder

 

<SVN_CLIENT_HOME>/auth/svn.ssl.server

 

Example: C:\Users\Charlee.Ch\AppData\Roaming\Subversion\auth\svn.ssl.server

Summary

At the moment, we understand that not only our credential / personal information should be configured, but also the “Maven” credential / personal information for itself should be configured, too. This will help us to achieve further integrating more simple and avoid the well know issues, such as the “HTTPS Client Configuration”. We are well prepared and ready for the next step, “Maven” integration with “Subversion” and “Issue Tracker”. I will post it soon, please stay tuned as always.

Java Development with NetBeans and Maven: Part 3

Overview

Since the Maven can integrate to the other system, such as “Issue Tracker“, “Version Control System“, especially the “Repository Manager“, which we will deploy our artifact for sharing to our team. All those target system is usually protected. We must provide the “security information / credential” such as user id and password for accessing it.

Normally we can declare the “security information /credential” inside the “Project POM File” (pom.xml). Please consider, in the real world development environment, they are many people joining the same project. The “Project POM File” (pom.xml) is also shared, too. If we decide to store that security information /credential” at the “Project POM File” (pom.xml). We may face a difficult if everyone keep updating the “Project POM File” (pom.xml) over and over. It would be nice that we can link the personal information, such as the security information /credential“, to the

Project POM File” (pom.xml).

Declare Our Own Information

You may have seen it berfore, The “settings.xml“. Please refer to my previous post, about the “Maven Repository Manager“, the “Artifactory” which can manage the repository and artifact for us. We use the “settings.xml” to notify “Maven” that it should connect to our “Maven Repository Manager“, the “Artifactory” instead of connect to the remote repository in the internet.

Inside the <profile> tag, we can declare a <properties> tag. The element inside this tag can be named any as we need. e.g. <userId>, and we can refer it in the “Project POM File” (pom.xml) by the ${MY_VARIABLE}, e.g. ${userId}. Pleases see further information here.

The we can declare our own “security information /credential” such as <issueUserId>, <issuePassword>,<vcsUserId>, <vcsPassword> and so on, so that we achieve configure our own “security information /credential“.

<profiles>
    <profile>
        ..........
        <id>artifactory</id>
        <properties>
            <svnUser>user1</svnUser>
            <svnPassword>password</svnPassword>
            <bugzillaUser>user2</bugzillaUser>
            <bugzillaPassword>password</bugzillaPassword>
        </properties>
    </profile>
</profiles>

Special Feature for the Maven Repository Manager

We can declare our credential for accessing the “Maven Repository Manager“, please note the “Maven Repository Manager” usually anonymous downloading, but not for deploying.

<servers>
    <server>
        <id>The Reference Id</id>
        <username>User</username>
        <password>password</password>
        <filePermissions>777</filePermissions>
        <directoryPermissions>777</directoryPermissions>
        <!--
        <privateKey>${user.home}/.ssh/id_dsa</privateKey>
        <passphrase>some_passphrase</passphrase>
        <filePermissions>664</filePermissions>
        <directoryPermissions>775</directoryPermissions>
        <configuration></configuration>
        -->
    </server>
</servers>

The password encryption

It can be done by following this document. I will intoduce you an overview.

Create Master Password

Create the master passowrd
mvn –encrypt-master-password <password>

Store it for future referencing

Please create a file named “settings-security.xml” at <USER_HOME>/.m2 and put the following content into it.

<settingsSecurity>
  <master>Master Password</master>
</settingsSecurity>

Encrypt The Password

Create the master passowrd
mvn –encrypt-password <password>

Please copy the encrypted password and paste to the “settings.xml“, the <server> tag.

The Artifactory

If the security is enable for the “Artifactory“, we can not use the “clear password“, or take it to encrypt with the master password. The “Artifactory” encrypted value is required. The step for picking that vaule is as following: -

  1. Please log in to “Maven Repository Manager“, the “Artifactory“.
  2. Go to your profile page by clicking the name displayed at the top-right of the screen.
  3. Enter your current password and press “Unlock” button.
  4. The encrypted password will be displayed at the “Encrypted Password” text box.
  5. Copy the whole displayed value, including the {DESede} or other.
  6. You can use this value at the “settings.xml“, the <server> tag.
  7. You can also “double encrypt” by using the maven encryption, too.

Summary

At the moment we can declare our own information at the “settings.xml” and link it to the “Project POM File” (pom.xml). We also understand the special feature for the “Maven Repository Manager“, the password encryption, including the specific for the “Artifactory“.

Next I will make use of these to integrate with Version Control System, Issue Tracker, especially to create a report and maven site. Please stay tuned as always.

Java Development with NetBeans and Maven: Part 2

Overview

Now we will focus on the further maven configuration. There are a lot of pulgins provided by the Maven. I would like to pay more attention to the unit testing, the Maven Surefire Plugin and Maven Surefire Report Plugin. Normally the JUnit is supported by default. I also prefer the latest JUnit 4.

Not only the unit testing, but also my most favorite library, the Apache Log4J. I will add it to my project at the same time. I cannot live without Log4J.

Adding New Library To The Project

Previously, without Maven, I’ve faced the trouble about managing my java library. I’ve no idea to organize it as the following scenarios: -

  1. Where is the right place to store the library? The my decided shared folder? The Java project folder? The WEB-INF/lib folder?
  2. Should I set the user library inside my IDE? Which IDE should I use? How to share them across my team?
  3. How to use this structure across my team?
  4. How to ensure the completion when we get the source code from repository or version control?
  5. Blah blah blah….

My trouble is solved by the Maven. They are stored and managed transparently by the Local Repository. There is no any stored library inside my project folder. Only the dependency configuration is required.

Let’s try to add the Log4J

I will show how simple it is. Just open the Project POM file (pom.xml) and add the Log4J dependency, inside the <dependencies> tag. Again I prefer the latest version as always.

<dependencies>
    ................
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.16</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

Next we will add the Log4J configuration to our project, by default this configuration file is nice to be stored at the “Project Default Package”, by the way it would be better to be stored at the “CLASSPATH”. Anyhow, regarding to my experience, I prefer to store it at the “Project Default Package”. Please note, it is just a simply copying and pasting to that folder. Then we will configure the Project POM file (pom.xml) so that it knows our configuration by adding the <resources> tag inside the <build> tag.

<resources>
    <resource>
        <directory>${basedir}/src/main/java</directory>
        <includes>
            <include>YOUR_RESOURCE</include>
            <include>YOUR_RESOURCE</include>
        </includes>
    </resource>
</resources>

Please note, you can add more resources as you need.

Writing The Code

I will modify my previous class, the “HelloWorld” application so that it print out the message before returning.

package com.scc.maven.java.prj01;

import org.apache.log4j.Logger;

/**
 * Hello world!
 *
 */
public class App{
    private static final Logger logger = Logger.getLogger(App.class);
    public String says(String name){
        String message = "Hello " + name;
        logger.info("The saying message is: " + message);
        return message;
    }
}

Create TestSuite

At the moment I will be back the unit testing by adding the “TestSuite” to my project. Normally I name it by add the wording “TestSuite” at the end of the class name. You will see the reason why I do like this.

package com.scc.maven.java.prj01;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;

/**
 *
 * @author Charlee.Ch
 */
@RunWith(Suite.class)
@Suite.SuiteClasses({com.scc.maven.java.prj01.AppTest.class})
public class MyFirstTestSuite {

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() throws Exception {
    }

    @After
    public void tearDown() throws Exception {
    }

}

It has not been finished yet, The Project POM file (pom.xml) need to be modified by mention the “Maven Surefire Pluginat the <plugins> tag and configure it so that it accept my test suite class.

The key is “**/*TestSuite*.java” and it is a reason why I name it as it is.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <includes>
            <include>
                **/*TestSuite*.java
            </include>
        </includes>
    </configuration>
</plugin>

Building & Testing

As I’ve mentioned before, during the “Build” or “Clean and Build” is executed, the unit testing will be executed automatically. If you would like to explicitly execute, just right clicking at your test class and choose “Test File”.

Configure The Unit Testing Report

I would like to create a summary report for my unit testing by using the “Maven Surefire Report Plugin”. Please note, the report will be created automatically when the maven site is created, anyhow you can explicitly execute. At the moment I prefer running explicitly.

Configure the Maven Surefire Report Plugin

Firstly we will modify the Project POM file (pom.xml) by adding the <reporting> tag and “Maven Surefire Report Plugin” configuration at the same level of the <build> tag.

<reporting>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-report-plugin</artifactId>
            <version>2.6</version>
        </plugin>
    </plugins>
</reporting>

Add Custom Maven Command

Second I will add the “Custom Maven Command” to the NetBeans Java Project so that the unit testing report can be generated. It is simply action as the following step: -

  1. Go to project properties.
  2. Inside the “Project Properties” windows, under the “Categories”, choose “Actions”.
  3. On the right hand panel, Click “Add Custom..” button.
  4. Enter the “Action Name” as “My.Surefire.Report”.
  5. Enter the “Execure Goal” as “surefire-report:report ”.

Execute The Custom Maven Command

Right click at your project and choose “Custom” –> “My.Surefire.Report”, It will display my previous created “Custom Maven Command”. Please note, the missing resources which are not in your “Local Repository” will be downloaded automatically as usual. The generated report is stored at <Project Folder>/target/site/surefire-report.html. Please look around it.

Summary

Now we are understand about the further Maven configuration, including with adding new resources, configuring the test suite and especially the unit testing report, plus create a custom maven command inside the NetBeans.

Next I will introduce more Maven Configuration, e.g. creating a site, configuring the version control, configuring the issues tracker, make use of them as a release note, and so on. Please stay tuned as always.

Java Development with NetBeans and Maven: Part 1

Overview

Regarding to my previous post, I’ve finished preparing my environment so that it supports the Maven development. Now I will start preparing my IDE, the NetBeans 6.9.1. By default, it supports the Maven 1.x and 2.x, please note at the moment the supporting Maven 3 is planned for the NetBeans 7.x which is not released yet. If there is any updated, I will post.

NetBeans 6.9.1 Configuration

It is straightforward configuration as the following steps: -

  1. Open the NetBeans IDE
  2. Go to menu “Tools” –> “Options”.
  3. Inside the “Options” window, click “Miscellaneous”.
  4. Choose “Maven” tab.
  5. Enter the “External Maven Home”.
  6. Optional, enter the “Local Repository”. Please note, my previous post also mentions about the maven configuration, the settings.xml. If you set the value here, it is double setting.

Create the first Maven / Java Project

It is simple as usual when you create a project under the NetBeans as the following steps:-

  1. Open the NetBeans IDE
  2. Go to menu “File” –> “New Project…”.
  3. Inside the “New Project” windows, choose “Categories: Maven”, “Project: Maven Project”.
  4. Select the “Maven Quickstart Archetype(1.0)” for the “Maven Archetype”.
  5. Enter the project information as usual. Please decide the suitable value for the “Group Id”, “Version” and “Package”.
  6. After you have finished, the system will download the related resources from the “Maven Repository Manager”, for me, it is “Articatory”. You will see the process via the “NetBeans: Output Panel”.
  7. Please look around your environment for making yourselves to be familiar with this new project type, the project folder.
  8. Not only the project folder, but also your “Local Repository” which is configured either “settings.xml” or the NetBeans options.
  9. Let’s build this empty project. Please look around your environment as well.
  10. You may be wondered that the “settings.xml” display under the “Project: Project Files”, but you cannot find this file from your physical project directory/folder. Please note, it is a relative file to your original “settings.xml”.

Configure the Java Source Code Version and File Encoding

By default it is set to support the java 1.3 we will change it to either 5, 6 or 7. At the moment, I prefer 1.6 with UTF-8 encoding. The step is as following: -

  1. Go to project properties.
  2. Inside the “Project Properties” windows, under the “Categories”, choose “Source”.
  3. Set “Source/Binary Format” to “1.6”.
  4. Set “Encoding” to “UTF-8”.

The Downloading Action

The Maven will download only the missing resources which are not in your “Local Repository”. Please look around your project POM file (pom.xml) or see further information here.

The First Java Class

The “HelloWorld” is still nice as always. The java class is created inside the project automatically. We will make some modifying over it by creating a method named “says” which receives the String parameter named “name” and return String which we say.

package com.scc.maven.java.prj01;
/**
* Hello world!
*
*/
public class App{
   public String says(String name){
      return "Hello " + name;
   }
}

How we can test it.

It is not a good practice to create the main method for testing. I encourage you to use the JUnit. By default the predefined is JUnit verion 3.8.1, I would like to use the latest version, at the moment, it is version 4.8.2.

Configure the JUnit

Please open your project POM file (pom.xml), it is under your “Project: Project Files”, go to the <dependencies> tag. You will see the Junit configuration. Just change it to 4.8.2. Please note, the automation completion is applied here, too.

The automatic completion may seem not working. Please open the “Maven Repository Browser” by going to menu “Window” –> “Other”. Click the “Update Indexes” button, or right click and choose “Update Indexes”.

The system will download the new configure resources automatically as always. Please look around your environment.

Cautions

This action requires the internet accessing, the downloaded indexes is quite big. Around 200-300 MB or more. You may copy from the one who already loaded by copying and pasting to your machine.

Path for copying and pasting the Remote Maven Indexes

<USER_HOME>\.netbeans\6.9\var\cache\mavenindex

Example: C:\Users\Charlee.Ch\.netbeans\6.9\var\cache\mavenindex

Create a Unit Testing

The java class which is a unit testing is also created inside the project as well. It is just testing the “says” method for ensuring the returned value.

package com.scc.maven.java.prj01;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 * Unit test for simple App.
 */
public class AppTest{

    public AppTest(){
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() {
    }

    @After
    public void tearDown() {
    }

    /**
     * Test saying
     */
    @Test
    public void testAppSaying(){
        App app = new App();
        String message = app.says("Charlee");
        assertEquals(message, "Hello Charlee");
    }
}

Building & Testing

Just right click at your project and choose “Build” or “Clean and Build”. The system will build your project, including with executing your unit testing automatically. Please look around your environment.

You can execute the unit testing explicitly by right clicking at your test class and choose “Test File”.

Summary

At the moment we configure the NetBeans IDE so that it can work with Maven. Not only preparation, but we also create a simple java project plus the unit testing. During these actions we will see the Maven behavior, e.g. downloading the missing resources. Especially we have looked our environment, the Local Repository.

Next I will introduce you about adding the other library to our project. I focus on our most famous one, the Apache Log4J. Please stay tuned as always.

Follow

Get every new post delivered to your Inbox.

Join 119 other followers

%d bloggers like this: