But later when I realized that there is no such need to create Netbeans projects from Maven pom, I was thrilled. Maven, is a first . . . → Read More: NetBeans and Maven – A quick start guide]]> A few months ago, I was reading the book “Wicket in Action”. I was new to Wicket and Maven then. I followed the instructions given in the book to create a maven project. The book went one step further and explained how to create eclipse and idea projects from the pom, but nothing was mentioned about NetBeans. I felt sad that there is no maven plugin out there to create projects that NetBeans can understand.

But later when I realized that there is no such need to create Netbeans projects from Maven pom, I was thrilled. Maven, is a first class citizen in NetBeans. Any Maven project “is a” NetBeans project.

Over the months, as I continued to learn and use Maven, NetBeans made the the learning curve easy. So I thought of putting up this post to benefit new Maven users.

Setup

If you are using Maven for the first time, you may want to download and install it on your machine.

Though NetBeans comes with an embedded Maven instance (version 3.0-SNAPSHOT in NetBeans 6.9 at the time of writing this post), it’s still a good idea to have your own Maven instance, so that you can use it outside the IDE as well.

Installing Maven is quite easy. Download the latest Maven distribution (version 2.2.1 at the time of writing) and follow the installation instructions for your operating system.

Now, let’s quickly dive into action by firing up the IDE and create a new Maven project.

Creating a new Maven project

Open NetBeans IDE and click “File -> New Project” and then choose “Maven” as the category and “Maven Project” as the project type.

In the next step, select “Maven Quickstart Archetype” as the maven archetype.

Finally, enter other details of your project and finish the wizard.

That should leave you with a new Maven project with a structure similar to this:

One thing I like about NetBeans is that it always gives you some workable defaults whether it’s a web project or a simple java project.

No difference here. Just right click the java source file the IDE generated for you to watch your Maven project in action.

And this is the default “pom.xml” the IDE generated for you:

<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>examples.maven</groupId>
<artifactId>hellomaven</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>hellomaven</name>
<url>http://maven.apache.org</url>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>

</project>

If you know Maven already, you know what’s happening. Even if you are new to Maven, there is nothing to worry. Every Maven project needs a few mandatory definitions and that’s what you are seeing now.

Improving the default project

There are a couple of things we can improve in this project. First let us cleanup the “pom.xml”. As you can see, a depedency to junit 3.8.1 has been declared in the pom. That’s pretty archaic and let us change the junit version to the latest available version.

You need not scratch your head to figure out what’s the latest version of junit. The IDE is right there to help you. Keep the cursor near the version element and invoke the code completion by pressing the appropriate key. (In my case it’s CTRL + SPACE). Now, the IDE should give you a list of available junit versions in the default Maven remote repository.

Choose the latest available junit version and save the details.

Let us rewrite the test case making use of the recent junit enhancements. Delete the existing unit test class and create a new one by right clicking the java source file and then selecting “Tools -> Create Junit Tests”. You should see the IDE displaying a dialog saying that it cannot create junit 4.x tests.

There is nothing wrong with the IDE here. Because JUnit 4.x makes use of annotations and hence need a Java source level of 1.5 or above. By default, Maven doesn’t assume your source files to be 1.5 compatible, so you need to tell Maven exactly what Java source version you would be using in your projects. Doing that is quite simple. Open the project’s “pom.xml” in the editor and define the Java source level like this.

<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>examples.maven</groupId>
<artifactId>hellomaven</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>hellomaven</name>
<url>http://maven.apache.org</url>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
</plugins>
</build>

</project>

You should be able to create JUnit 4.x tests from the IDE now.

Applying “Test Driven Development” to our project, let us create an unit test for an non-existent method in the java source.

And now write the actual method in the java source so that the IDE doesn’t complain about the errors in our unit test.

protected String sayHello(String input)
{
String output = "Hello " + input;
return output;
}

Go back to the unit test and run it.(I usually type CTRL + F6 to run the unit tests). Congrats! Your Maven project is seriously ready for prime time.

Do not take me wrong but it’s really a good practice to write unit tests for everything and that’s why I bothered you with this stuff.

Don’t use System.out.println!

Though we are already familiar with dependencies, we only used JUnit which is a test dependency. And this is a good time to dive into the dependency hell by introducing our next dependency to this little project, “slf4j” or “Simple Logging Facade for Java”.

It’s hard to imagine any project without “logging” and our example project is no exception. (Heck, what’s there to log in this project???)

And with “slf4j” gaining wide spread adoption, let us make use of it. “slf4j” doesn’t tie our application to any logging framework (other than itself ). It’s something like “jpa”. It gives you the freedom to choose your own logging provider. (My current favourite is logback)

Enough talking, let us starting using logging in our project.

To justify the use of logging, let us create some opportunity by updating our “main” method.

public static void main(String[] args)
{
if(args != null && args.length > 0)
{
System.out.println(new App().sayHello(args[0]));
}else{
System.out.println("You have to pass atleast one argument to get a warm response from me!");
}
}

Time to fix those “System.out.println” calls by using slf4j. Create a slf4j Logger instance.

That’s obvious. By no way the IDE can figure out what is happening here apart from resolving the “Logger” to java.util.logging which is not our objective.

Now click the edison’s bulb in the gutter to see what magic the IDE has under it’s hat.

Select the option “Search Dependency at Maven Repositories…”. The IDE should popup a window with the possible matching artifacts.

Scroll to the bottom and locate “slf4j-api” and click “Add”. This will add the latest version of slf4j-api as a dependency. If you want to be more specific on the version, you can expand the slf4j-api node and choose the appropriate version.

Go back to your “pom.xml” and see a new dependency for “slf4j-api” has been added. If you don’t want all this hassle, you can straight away add the following snippet in your pom.xml to add a dependency for slf4j-api.

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.1</version>
<type>jar</type>
</dependency>

Fix your imports in the source file and you are set to use slf4j.

Now change the reference to “System.out.println” with appropriate logging calls.

public static void main(String[] args)
{
if(args != null && args.length > 0)
{
logger.info(new App().sayHello(args[0]));
}else{
logger.warn("You have to pass atleast one argument to get a warm response from me!");
}
}

Run your main class to ensure that everything is fine.

That’s not we expected. Nothing is logged! There is nothing wrong with this phenomenon as we haven’t defined any logging provider yet. Remember, slf4j is just a specification.

Okay, it’s time to add a logging provider and with all the bias let us choose “logback” for this purpose. (Please feel free to use your preferred logging provider.)

Slf4j has a bunch of adapters for popular logging frameworks like “log4j” and “jul” (java.util.logging). (Please don’t raise flame wars by asking whether “jul” is really popular!)

If log4j is your cup of tea or coffee, please go ahead and check the slf4j manuals for further reference.

I’ll use “logback” for this example and let us add the dependencies for that now. Right click the “Libraries” node of your project and click “Add Dependency”.

The IDE should popup a window now where you can search the dependencies you want to add by typing the respective name in the “Query” field.

To use logback in your project, you need to add the dependency “logback-classic”. (This will automatically add the transitive dependency “logback-core”)

Expand the respective node, choose the version you want and click “OK” to add them to the project.

You can see the added dependencies in the “Libraries” node of the project.

Again, if you are not a big fan of wizards, you can drop in the following snippet in the pom.xml straight away.

<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>0.9.24</version>
</dependency>

That’s it. If you run the main class now, the logging calls should be negotiated properly.

To remove a dependency, you can either right click the respective dependency in the “Libraries” node and then click “Remove dependency” or edit your pom.xml and delete the respective reference to the dependency. It’s upto you.

To keep this post live up to it’s title, I’ll not discuss the tons of other Maven related stuffs NetBeans has. I’ll probably cover some of them in a later post.

For the sake of completeness, here is the final pom.xml:

<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>examples.maven</groupId>
<artifactId>hellomaven</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>hellomaven</name>
<url>http://maven.apache.org</url>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.8.1</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.1</version>
<type>jar</type>
</dependency>

<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>0.9.24</version>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
</plugins>
</build>

</project>

And the java source file:

package examples.maven.hellomaven;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
* Hello world!
*
*/
public class App
{
private static final Logger logger = LoggerFactory.getLogger(App.class);

public static void main(String[] args)
{
if(args != null && args.length > 0)
{
logger.info(new App().sayHello(args[0]));
}else{
logger.warn("You have to pass atleast one argument to get a warm response from me!");
}
}

protected String sayHello(String input)
{
String output = "Hello " + input;
return output;
}
}

The Junit test class:

package examples.maven.hellomaven;

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

/**
 *
 * @author james
 */
public class AppTest
{
 public AppTest()
 {
 }

 @Test
 public void testSayHello()
 {
 App app = new App();
 String input = "Maven";
 String expected = "Hello " + input;
 String result = app.sayHello(input);
 assertEquals(expected, result);
 }
}

As you have seen above, NetBeans offers great support out-of-the-box for Maven. No plugins required. If you are not a NetBeans user but use Maven, I recommend you to give it a try. You’ll not be disappointed.

Thanks for reading patiently and please leave your comments if you have any.

Subversion is arguably the most popular version control system as of now. No wonder NetBeans has very good support for Subversion. I personally feel that a java developer must be familiar with both these tools. This article shall help you to get started with both these tools.

Objectives:

- To create a simple java project in NetBeans.

- To import the java project into the subversion repository.

- To commit the changes made in a java source file.

- To view the revision history of a java source file which was changed.

- To rollback to the previous . . . → Read More: Subversion and NetBeans – A quick start guide]]> Introduction:

Subversion is arguably the most popular version control system as of now. No wonder NetBeans has very good support for Subversion. I personally feel that a java developer must be familiar with both these tools. This article shall help you to get started with both these tools.

Objectives:

- To create a simple java project in NetBeans.

- To import the java project into the subversion repository.

- To commit the changes made in a java source file.

- To view the revision history of a java source file which was changed.

- To rollback to the previous revision of the java source file.

Requirements:

- NetBeans 6.1 Beta or NetBeans 6.0

- Subversion

- TortoiseSVN

- Though not mandatory, but a basic knowledge of subversion concepts.

Note: You can read this article to learn how to install/configure Subversion and TortoiseSVN.

Step 1:

Create a new “Java Application” project called “SimpleLogin”.

Step 2:

Create a new JFrame called “LoginFrame” under the package “org.example.simplelogin” and add the necessary components as shown below.

Step 3:

Name the swing components accordingly.

Your application should like this now on preview:

Step 4:

Create a java class named “LoginService” under the package “org.example.simplelogin”.

Step 5:

Add the following code to the LoginService class.

Here we are defining a simple method which shall return true if the username is “guest” and the password is “password”.

Step 6:

Now open “LoginFrame.java” and add the following methods.

The above methods are self explanatory. We are just doing a simple validation and calling the login method we defined previously in the class LoginService.

Step 7:

Now double click the login “button” in the design mode of LoginFrame.java to create the event handling method named “loginButtonActionPerformed”. Add the following code to call the “performLogin” method.

That’s it.

Step 8:

Run the project.

If you enter the username as “guest” and password as “password”, you will get an output like this.

Otherwise, you will be getting an output like this.

Ok, our simple login application is ready for prime time . Now let us import this project into a subversion repository.

Step 9:

Create an empty folder called “MyRepository” in a preferred location.

Step 10:

Create a subversion repository in the empty “MyRepository” folder as mentioned below, by right clicking anywhere inside the windows explorer.

Accept the default option (FSFS) in the “Create Repository” window.

That’s it. Your repository should be ready when you press “OK” and it should look something like this.

Step 11:

Let us import the NetBeans project we have created into the subversion repository. Right click the NetBeans project we have created and then click “Versioning -> Import into Subversion Repository”.

NetBeans will prompt you with a window. Enter the path of your repository as shown below.

Click the “Next” button and enter the “Repository Folder” name into which you would like to import your project. To make things simple, let us enter our NetBeans project name itself as the “Repository Folder” name. Also enter a small description about this import activity as shown below.

We are almost there. Click the “Next” button and the IDE will show a window like this.

Accept the default entries and click “Finish”. Congratulations! you have imported your project successfully into the subversion repository.

Right click anywhere in your desktop/windows explorer and click “TortoiseSVN -> Repo-Browser” and then enter the path of your subversion repository. You can see all your project files sitting comfortably inside the subversion repository.

Step 12:

Let us play around with some more cool subversion integration features offered by NetBeans. Open the class “LoginService.java” and change the value of “DUMMY_PASSWORD” from “password” to “guest”.

You can see the IDE markup a blue shade near the line you made the change. This indicates that your source file has got something different than the version in the repository. You can also note that the IDE change your java source file name’s font-color to blue.

Let us turn our focus to the editor window again. Click the blue stripe shown by the IDE near the  place where you made changes to the source file. The IDE will popup a small hint-window.

You can see the previous value of the DUMMY_PASSWORD there. The IDE also provides you a set of buttons to revert back the changes or to have a “diff” view on the changes made. Let us explore the “diff’ functionality of the IDE first by clicking the “diff” button.

The IDE will display the “diff” view of the “working copy” and the “HEAD” revision (the latest committed version) in the repository.

From the above figure, you can see the current and previous value of the string DUMMY_PASSWORD. Now you can revert back to the old value of “DUMMY_PASSWORD” by clicking the replace  button (displayed like an arrow)

When you press the “replace” button, the IDE will replace the “current” value with the “original” value.

The “diff” view provided by the IDE will be very useful to examine and compare the changes made to the “working copy”  alongwith the option to revert back to the original version in the repository. But if all you need is to quickly revert back some change to the original version in the repository, you can click on the blue strip in the source code and click the “revert” button.

That’s cool, right?

Step 13:

Enough playing. Now let us commit the changes we made in our source file. Ensure that the source file you are willing to commit is in focus and click the menu “Versioning -> Commit”

When you click the “Commit” menu item, the IDE will prompt you with a window to enter the “message” for this commit operation. Enter a commit message and click the “Commit” button.

Step 14:

Let us explore the history of our source file and see the the changes we made all along. Click the “Versioning -> Search History” menu.

The IDE will display all the versions of the source file.

In the “Search History” window, the IDE offers two views, “summary” view and “diff” view. By default, the IDE displays the “summary” view. The “diff” view contains more information.

You can straightaway “revert” or “rollback” to previous revisions just by right clicking a particular revision.

Nice, isn’t it? There are still a lot more cool subversion features offered by NetBeans. I will blog more about that later. I hope the information provided here was useful to you.

Read also: “NetBeans and Maven – A quick start guide”

SolitaryGeek Poll

TortoiseSVN and Apache comes to your aid. TortoiseSVN is a powerful tool for Subversion, which helps you to issue most of the subversion commands from your windows explorer. Subversion has an inbuilt “svnserve” utility which helps you to expose your repository to remote users, but it’s highly recommended to use the flexible Apache Web Server for this purpose. Subversion comes . . . → Read More: Extending Subversion by using TortoiseSVN]]> Though Subversion is a powerful version control system, it’s command-line based interface may not appeal to some users who used other version control systems like Visual Source Safe. And what if you want to remotely access your repository as well?

TortoiseSVN and Apache comes to your aid. TortoiseSVN is a powerful tool for Subversion, which helps you to issue most of the subversion commands from your windows explorer. Subversion has an inbuilt “svnserve” utility which helps you to expose your repository to remote users, but it’s highly recommended to use the flexible Apache Web Server for this purpose. Subversion comes with it’s own apache modules to expose your repository to remote users. However, in this article we will not focus on Apache. I’m planning to write about the apache integration in my next post. Please be patient

Objective:

In this article you will learn how to install Subversion and TortoiseSVN and use them to create a repository, import files into the repository and view the repository.

Step 1: Install Subversion

Download subversion windows installer for Apache 2.2.x. (Download the file called “svn-x.y.z-setup.exe” and run the installer. Installing should be a straight forward option.

You might see the following windows. They are self explanatory.

Now you should have subversion successfully installed in your machine. To verify that, open the command prompt and type “svn –version”. If you see something like below, pat your head, you have successfully installed subversion.

If you couldn’t see the above mentioned message, you might want to check your “Path” environment variable and add your subversion installation directory to the “Path”.

Step 2: Install TortoisSVN

Download TortoiseSVN from here.

That’s it. Now the installer setup might prompt you to restart your system to complete the installation process. Accept it.

Step 3: Create a Subversion Repository

Now, it’s time to create a subversion repository. Though it’s possible to use the subversion’s “svnadmin” command to create the repository, we will use TortoiseSVN to achieve that.

3a) First, choose a appropriate location to keep all your repositories. In my case it’s “F:\Subversion”. Let us call this folder as REPOSITORY_ROOT. Now, let us create an empty directory called “MyRepository” inside REPOSITORY_ROOT. It should look something like this:

3b) Now, right click inside the folder REPOSITORY_ROOT\MyRepository, and click “TortoiseSVN -> Create repository here” menu.

3c) TortoisSVN will now prompt you with a message box like this:

Leave the default option (Native file system), and click “OK”. You can see a bunch of files inside the “MyRepository” folder like this:

Great!! This is your subversion repository.

Step 4: Import files into your subversion repository

4a) Let us add some files inside our newly created subversion repository. Right click a folder of your choice and click “TortoiseSVN -> Import”

4b) Enter the appropriate repository path where you would like to import these files into. In my case it’s “file:///f:/subversion/myrepository/photos”.

4C) When you press “OK”, TortoiseSVN will import all the files/folders inside the folder which you selected for the import operation into the subversion repository.

4D) Press “OK”. Now we have finished importing the files into our new subversion repostiory. It’s now time to view the content of our repository.

Step 5: Viewing the content of your subversion repository

5a) TortoiseSVN provides a nice “Repository Browser” option to view the content of your subversion repository. Right anywhere in your explorer window/desktop and click “TortoiseSVN -> Repo-browser”.

5B) Enter the url of your subversion repository. In my case, it’s “file:///f:/subversion/myrepository” and click “OK”.

5C) That’s it, now TortoiseSVN will list down all the files inside your repository.

Summary:

In this article, you learned to:

- install Subversion

- install TortoiseSVN

- create a new repository using TortoiseSVN

- import files into the subversion repository using TortoiseSVN

- view the content of the subversion repository using TortoiseSVN

What next?

I initially thought of even writing about installing, configuring apache/websvn in this article itself. But it already took me nearly 3 hours to finish writing this. So please bear with me. I’ll come with a Part II of this article where you will learn how to use apache/websvn along with subversion to make the interaction with your version control system a pleasure. See you again.

Added on August 2, 2008:

I have written an article named “Extending Subversion with Apache“. This article is about setting up Apache http server and configuring it to access subversion repositories. It also deals how to setup Authentication and Access control for your subversion repositories using Apache. Hope you find it useful.

SolitaryGeek Poll