SolitaryGeek » Java

What Java Look and Feel do you use?

James — Mon, 09 Nov 2009 15:10:32 +0000

Quite some time back, I read an article titled “20+ Free Look and Feel Libraries For Java Swing“. I have evaluated most of the libraries mentioned in that article. Personally, I prefer the System look and feel that is bundled in the JRE. However, I like Substance, PGS and JGoodies as well. Which one do you use? Curious to know.

Note: There is a poll embedded within this post, please visit the site to participate in this post's poll.

Developing A Simple Java Application With Spring

James — Tue, 03 Nov 2009 16:12:23 +0000

Introduction
Spring is a powerful application framework that can be used across any layer in your application. For example, you can use Spring to manage only your data access layer or you can use Spring to provide remote services for your swing client. In this article, I will explain how to get started with Spring by developing a simple java application.

Requirements
1. Your favorite IDE
2. Latest Spring framework.

(Note: This article makes use of Spring framework 2.5.6 which is the current production release)

The Application
We are going to develop a simple application that fetches and display the list of registered users. The application consists of just two interfaces, their implementation.

The DAO layer
Let us now develop the DAO layer of the application. This layer consists of just one interface “UserDao” and it’s implementation “UserDaoImpl”. The interface consists of just one method named “getUsers()”. Let us quickly develop them.

Listing 1. UserDao

package com.springapp.dao;
import java.util.Iterator;

/**
 *
 * @author James
 */
public interface UserDao
{
    Iterator getUsers();
}

Listing 2. UserDaoImpl


package com.springapp.dao;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 *
 * @author James
 */
public class UserDaoImpl implements UserDao
{
    public Iterator getUsers()
    {
        List users = new ArrayList();
        users.add("Gavin King");
        users.add("Geertjan");
        users.add("Mike Keith");
        users.add("James");
        return users.iterator();
    }
}

Nothing fancy here. The implementation is pretty straight forward, though in a real environment you might fetch those details from the database using ORM frameworks like JPA.

The Service Layer

We will encapsulate the service layer from the dao implementaion by writing code against the interface UserDao. We will follow the same pattern we used in developing the dao layer and write the interface UserService and it’s implementation UserServiceImpl.

Listing 3. UserService


package com.springapp.service;

import java.util.Iterator;

/**
 *
 * @author James
 */
public interface UserService
{
    Iterator getUsers();
}

Listing 4. UserServiceImpl


package com.springapp.service;

import com.springapp.dao.UserDao;
import java.util.Iterator;

/**
 *
 * @author James
 */
public class UserServiceImpl implements UserService
{
    private UserDao userDao;

    public Iterator getUsers()
    {
        return userDao.getUsers();
    }

    public void setUserDao(UserDao userDao)
    {
        this.userDao = userDao;
    }
}

Kindly notice that both the service layer classes and dao layer classes are Spring agnostic. That’s the beauty of Spring. Spring is less invasive. Most of the application code can be developed without knowing anything about Spring.

The Client

Now we need someone to make use of our service layer and we will waste no time in developing the client for our service. We can just write a junit test class to invoke our service but I prefer to write a simple java class to be the client. Though our client will be a simple POJO class, you can easily replace it with a Swing or Web front end. Enough talking, let us dive into action! We will first develop our client as a normal java class without using Spring.

Standard Client

Listing 5. StandardUserServiceClient


package com.springapp;

import com.springapp.dao.UserDao;
import com.springapp.dao.UserDaoImpl;
import com.springapp.service.UserServiceImpl;
import java.util.Iterator;

/**
 *
 * @author James
 */
public class StandardUserServiceClient
{

    private UserServiceImpl userService;

    public StandardUserServiceClient()
    {
        userService = new UserServiceImpl();
        UserDao userDao = new UserDaoImpl();
        userService.setUserDao(userDao);
    }

    private void fetchUsers()
    {
        Iterator users = userService.getUsers();
        while (users.hasNext())
        {
            System.out.println(users.next());
        }
    }

    public static void main(String[] args)
    {
        StandardUserServiceClient client = new StandardUserServiceClient();
        client.fetchUsers();
    }
}

Hmm, there you can see our client code is “coupled” tightly with the service and dao implementations. That’s where Spring comes to our rescue. Spring will dynamically “inject” the implemenations so our application will remain “loosely” coupled.

Spring Client

But how will Spring know about our implementations? We need to inform Spring a little about our application and define the “hotspots” where it can dynamically “inject” the dependencies or implementations. Spring expects these details in a configuration file and let us quickly write that. Create a package called “resources” and create a xml file called “applicationContext.xm” inside it.

Listing 6. applicationContext.xml

In the “applicationContext.xml” file we defiend two beans named “userDao” and “userService”. We also specified their implementations using the “class” attribute. Also notice that we are setting the property “userDao” in the “UserServiceImpl” class with “UserDaoImpl” by referencing it’s name “userDao”. Pretty straighforward!

Now it’s time to churn out our Spring client.

Listing 7. SpringUserServiceClient


package com.springapp;

import com.springapp.service.UserService;
import java.util.Iterator;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 *
 * @author James
 */
public class SpringUserServiceClient
{
    private UserService userService;

    public SpringUserServiceClient()
    {
        //initialize the spring container
        ApplicationContext context = new ClassPathXmlApplicationContext("resources/applicationContext.xml");
        userService = (UserService) context.getBean("userService");
    }

    private void fetchUsers()
    {
        Iterator users = userService.getUsers();
        while(users.hasNext())
        {
            System.out.println(users.next());
        }
    }

    public static void main(String[] args)
    {
        SpringUserServiceClient client = new SpringUserServiceClient();
        client.fetchUsers();
    }
}

A couple of details about this class:

The ApplicationContext interface helps us to plug into the Spring container and lookup the classes we need by using the name we defined in the xml file.
There are many implementataions of ApplicationContext available in Spring. One of the most widely used implementation is “ClassPathXmlApplicationContext”. It is used to load Spring configuration files found in classpath.

As seen from Listing 7, Spring helps us to program to interfaces and develop loosely coupled applications. As a result, applications become more testable as there are no external dependencies like application server. It is also very easy to switch the implementations effortlessly. For example, in our sample application you can easily write a UserDaoMockImpl and use it in your test cases effortlessly.

Project Structure

Here is the complete application looks like:

Developing A Simple Pluggable Java Application

James — Sun, 20 Sep 2009 15:23:12 +0000

Most of the applications we use on daily basis are pluggable. Popular applications like Firefox, Eclipse, NetBeans, JEdit, Wordpress, Hudson are all pluggable. In fact, pluggability has played a major part in the success of most of these applications. Why not make the Java applications we develop pluggable as well? Yes, we get pluggability out of the box, if our applications are based on a rich client platform like NetBeans or Eclipse. But for some reasons if you decide not to use those platforms, it doesn’t mean that they should not be pluggable. In this article, we will learn how to write a simple pluggable application that will load it’s plugins dynamically.

The API
First, let us define a plugin interface that should be implemented by all the plugins of our application. We are going to keep it very simple. Create a project called “plugin-api” in your favorite IDE and create the interface “ApplicationPlugin”.


package com.pluggableapp.plugins.api;

public interface ApplicationPlugin
{
    String getName();
    void init();
}

The Plugins

Writing the plugins now is very easy. Our plugins need to implement the plugin interface and follow a simple convention to make it easy for our applications to find them later. Create a project called “plugin-a” and develop our first plugin.


package com.pluggableapp.plugins;

import com.pluggableapp.plugins.api.ApplicationPlugin;
import java.util.logging.Logger;

public class PluginA implements ApplicationPlugin
{
    private static Logger logger = Logger.getLogger(PluginA.class.getName());

    public String getName()
    {
        return "Plugin A";
    }

    public void init()
    {
        logger.info(getName() + " initialized!");
    }
}

Now create a directory called “META-INF/services” inside the source directory and create a file with the name “com.pluggableapp.plugins.api.ApplicationPlugin” (This is the fully qualified name of the plugin interface). The file should contain the name of the actual plugin inside it. In our case, the text is “com.pluggableapp.plugins.PluginA”.

Repeat these steps to create PluginB.

The Application

It’s time to create the application that will consume the plugins we created. First let us create a class to add the plugin jars to the classpath dynamically.


package com.pluggableapp;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.logging.Logger;

public class ClasspathUtils
{

 private static Logger logger = Logger.getLogger(ClasspathUtils.class.getName());
 // Parameters
 private static final Class[] parameters = new Class[]
 {
     URL.class
 };

 /**
 * Adds the jars in the given directory to classpath
 * @param directory
 * @throws IOException
 */
 public static void addDirToClasspath(File directory) throws IOException
 {
     if (directory.exists())
     {
         File[] files = directory.listFiles();
         for (int i = 0; i < files.length; i++)
         {
             File file = files[i];
             addURL(file.toURI().toURL());
         }
     }
     else
     {
         logger.warning("The directory \"" + directory + "\" does not exist!");
     }
}

 /**
 * Add URL to CLASSPATH
 * @param u URL
 * @throws IOException IOException
 */
 public static void addURL(URL u) throws IOException
 {
     URLClassLoader sysLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
     URL urls[] = sysLoader.getURLs();
     for (int i = 0; i < urls.length; i++)
     {
         if (urls[i].toString().equalsIgnoreCase(u.toString()))
         {
             logger.info("URL " + u + " is already in the CLASSPATH");
             return;
         }
     }
     Class sysclass = URLClassLoader.class;
     try
     {
         Method method = sysclass.getDeclaredMethod("addURL", parameters);
         method.setAccessible(true);
         method.invoke(sysLoader, new Object[]
         {
             u
         });
     } catch (Throwable t)
     {
         t.printStackTrace();
         throw new IOException("Error, could not add URL to system classloader");
     }
  }
}

Now create an interface called “PluginService” to define the methods needed to load and initialize the plugins.


package com.pluggableapp;

import com.pluggableapp.plugins.api.ApplicationPlugin;
import java.util.Iterator;

public interface PluginService
{
    Iterator getPlugins();
    void initPlugins();
}

As of version 1.6, the Java runtime ships with a class called “ServiceLoader” to easily find and load plugins. Let us now write a implementation called “StandardPluginService” and make use of the facilities built into the java runtime.


package com.pluggableapp;

import com.pluggableapp.PluginService;
import com.pluggableapp.plugins.api.ApplicationPlugin;
import java.util.Iterator;
import java.util.ServiceLoader;
import java.util.logging.Logger;

public class StandardPluginService implements PluginService
{
    private static StandardPluginService pluginService;
    private ServiceLoader serviceLoader;
    private Logger logger = Logger.getLogger(getClass().getName());

    private StandardPluginService()
    {
        //load all the classes in the classpath that have implemented the interface
        serviceLoader = ServiceLoader.load(ApplicationPlugin.class);
    }

    public static StandardPluginService getInstance()
    {
        if(pluginService == null)
        {
            pluginService = new StandardPluginService();
        }
        return pluginService;
    }

    public Iterator getPlugins()
    {
        return serviceLoader.iterator();
    }

    public void initPlugins()
    {
        Iterator iterator = getPlugins();
        if(!iterator.hasNext())
        {
            logger.info("No plugins were found!");
        }
        while(iterator.hasNext())
        {
            ApplicationPlugin plugin = iterator.next();
            logger.info("Initializing the plugin " + plugin.getName());
            plugin.init();
        }
    }
}

Feel free to write your own implementation if needed. For example you can easily write an implementation based on the NetBeans API.

Write a factory class named “PluginServiceFactory” to create “PluginService” objects.


package com.pluggableapp;

import com.pluggableapp.*;
import com.pluggableapp.StandardPluginService;
import com.pluggableapp.PluginService;
import java.io.File;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

public class PluginServiceFactory
{
    public static PluginService createPluginService()
    {
        addPluginJarsToClasspath();
        return StandardPluginService.getInstance();
    }

    private static void addPluginJarsToClasspath()
    {
        try
        {
            //add the plugin directory to classpath
            ClasspathUtils.addDirToClasspath(new File("plugins"));
        } catch (IOException ex)
        {
            Logger.getLogger(PluginServiceFactory.class.getName()).log(
                Level.SEVERE, null, ex);
        }
    }
}

That’s it. All we need to do now is to write a class that will invoke the “PluginServiceFactory”.


package com.pluggableapp;

import com.pluggableapp.plugins.api.ApplicationPlugin;
import java.util.Iterator;
import java.util.logging.Logger;

public class Main
{

    private static Logger logger = Logger.getLogger(Main.class.getName());

    /**
    * @param args the command line arguments
    */
    public static void main(String[] args)
    {
        loadPlugins();
    }

    private static void loadPlugins()
    {
        PluginService pluginService = PluginServiceFactory.createPluginService();
        pluginService.initPlugins();
    }
}

Before we build and see the application in action, create a directory called “plugins” and put all plugin jars there.

And this is what you might see when you run our pluggable application.

Now feel free to create as many plugins you want to write and just drop them in the “plugins” directory and restart the “pluggable” application to see your “home grown” plugins in action!

Resources

Creating Extensible Applications With the Java Platform – John O’Conner

Developing a Java Plugin Framework

How to Create a Pluggable Photo Album in Java – Geertjan

Five different uses of Java Applets

James — Sat, 22 Aug 2009 09:54:42 +0000

In a world where everyone is using technologies like Flash, Silverlight etc to present rich content, are Java Applets still used? Are they still relevant? The answer is – “Yes”. Apart from being used primarily for playing online games, Java Applets are still used in many different ways. Here I would like to highlight a few applications that put Applets to good use.

1. Online Office Suite
ThinkFree is a very popular and professional online office suite based on Java Applet and Ajax.

2. Virtualization
JPC or Java PC Emulator is a pure java based virtualization software that can be used to boot your virtual computers right inside the browser. Yes they run as “Java Applets” inside the browser.

3. Remote Desktop Viewer
Products like TightVNC and UltraVNC provide a java applet based client to view remote desktops.

4. (Web) Operating System
iCloud, is an web operating sytem that makes use of XML and Java Applet Technology (atleast for Firefox).

5. File Upload

Facebook uses a beautifully designed Java Applet to upload photos to facebook photo albums.
net2ftp is a web based ftp client that makes use of tiny Java Applet to “drag and drop” files from local computer to the browser and upload them to the remote ftp server.

If you have come across any website that make use of Java Applets, please share your thoughts in the comments.

Hudson CI Server – A quick start guide

James — Fri, 24 Jul 2009 14:53:26 +0000

Introduction

Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily – leading to multiple integrations per day.
- Martin Fowler

Hudson is a popular open-source continuous integration server used by many organizations like Redhat JBoss. Though there are many well known and well established open-source projects like CruiseControl, Continnum and some commercial offerings like Bamboo, what makes Hudson special is it’s powerful yet easy to use web interface, it’s simplicity and it’s extensible architecture with many plugins.

Objective

The objective of this tutorial is to setup, configure and learn to use Hudson by building “Apache Commons IO“, a well known java project.

Requirements

Hudson
Subversion (or any other version control system like CVS, Mercurial, Git if you want to build your own project)
(Optional) Tomcat or Glassfish
Apache Ant (or Maven)

Installation and Starting Hudson

Installing Hudson is super easy. Just download the war file, open your terminal/command-prompt and issue the command “java -jar hudson.war”. Now point your browser to http://localhost:8080. That was easy, right?

Hudson has an embedded servlet container called “Winstone” which works much like a standard servlet container like Tomcat by serving your JSP pages and servlets.

If you want Hudson to start on a different port, say 8180, issue the following command,
java -jar hudson.war –httpPort=8180

Ofcourse you can deploy Hudson to Tomcat, Glassfish or any other supported servlet containers. The following guides can be useful in that case:

More container specific guides can be found from this hudson wiki.

Once you started Hudson or deployed it to a servlet container, this is what you might see in your browser when you start Hudson for the first time.

Hudson Home Directory

All your Hudson jobs/settings are stored in the Hudson home directory. If you did not specify one, Hudson shall assume some defaults like ~/.hudson in Linux or your respective home directory in Windows. It’s ok to go ahead with the defaults while you test drive Hudson but once you are done, I strongly recommend you to define a Hudson home directory of your choice, preferrably on a separate partition or drive. This will ensure that all your Hudson configuration/jobs are intact in case of any system crash.

Say, suppose your home directory is “/hudson” (in Linux), this is how you will define the Hudson home directory,

If you are using the embedded servlet container, start it by specifying the java system property “HUDSON_HOME”,
java -DHUDSON_HOME=/hudson -jar hudson.war

If you are using Tomcat, follow the explanations in this wiki. However, if you run Tomcat as a windows service, you need to do some tweaking to let Tomcat set this property. In that case, you will be better off if you start Tomcat using it’s batch file and set the property right there. (Or if you managed to run Tomcat as a Windows Service and still able to define the Hudson home correctly, why don’t you share your views with us?)

If you are using Glassfish, go to admin console and add the JVM option -DHUDSON_HOME=/hudson. More detailed explanations can be found on this wiki.

Just remember that the idea is to define a system property “HUDSON_HOME” through any of the possible ways.

This is how the Hudson home directory shall look like.

Manage Hudson

Hudson provides an easy to use web interface to manage the configurations needed to administer a continuous integration server. Let us do some basic configurations to get Hudson ready.

Start Hudson and click the “Manage Hudson” link located on the left.

Now click “Configure System”. Hudson will display a page where you can configure things like access control, JDK, Ant, Email Settings etc.

Access Control

We will enable security to secure our Hudson setup. Otherwise anybody can go and meddle with your Hudson jobs. If you don’t want that to happen, check the “Enable Security” checkbox.

[smartads]

Once security is enabled, we need to tell Hudson the type of “Access Control” we want to use. Let us choose the Security Realm as “Hudson’s own user database” and leave the option “Enable users to signup” as checked. (If you do not check the “sign up” option here, Hudson is definitely going to whack you later!. ) Under the “Authorization” section, choose “Matrix-based Security”.

Now add an user called “administrator” and give the necessary privileges. ENSURE THAT YOU GIVE “ADMINISTER” PRIVILEGES TO THIS USER or else, you may not able to access the administrative console once security and access control are enabled. (Again, if you miss it, Hudson is gonna whack you!)

Hudson will display an error symbol near the user we just added. That’s because the user does not exist in the system. Do not bother, we will create the user a little later. Now go ahead and add users who might be accessing Hudson. Give appropriate access controls to the users and do not give full access to everyone. That will eventually create a system that is difficult to manage.

Configure JDK

Done with security? Now we need to configure the JDK which Hudson shall use to build the jobs. Find out the section “JDK” in the same page. Click the “Add JDK” button and then enter the details of your JDK.

Configure Ant

We need to tell Hudson where Ant is located. Find out the section called “Ant”, click “Add Ant” and enter the respective details.

(Follow the same procedure, if you want to configure Maven.)

That’s it! Hudson is now almost ready for prime time. Feel free to configure the Email Settings as well with the appropriate values. When you are done, press the “Save” button to save all the changes you have made.

Once you press the “Save” button, Hudson will redirect you to a login page.

Manage Users

Click the “Signup” link at the top right corner of Hudson and register a new user called “administrator” (or whatever name you gave in the “Access Control” section).

Hudson will automatically login the user provided the user was already configured in the “Access Control” section. Once a new user (administrator) is registered in the system, Hudson will provide an option called “Manage Users” in the “Manage Hudson” page.

You can now create other users from this page.

You will be using this page to manage all your Hudson users. Looks like we have covered quite a lot of information. It’s time now to create some jobs and see Hudson in action.

Creating Job

That’s the core feature of Hudson. Hudson jobs can fetch the source code from a repository, execute your build scripts, run your tests, prepare javadoc, notify you in case of any failure, archive the build artifacts and much more. That’s where you can really see the power of Hudson. Enough talking, let us explore these Hudson features now by creating a job.

The Hudson job which we are going to create now is going to be very simple and is capable of doing the following:

Checkout the source code of apache commons-io project using subversion
Run the build script (build.xml in case of Ant, pom.xml for Maven)
Archive the build output

Create a job by clicking the link “New Job” on the left. Give a name for the job, select the option “Build a free-style software project” and then press “OK”.

Configure Job

Hudson will create a new empty job for us which we need to configure.

Let us configure the repository for this job first. Go to the section “Source Code Management”, choose the option “Subversion” and enter the repository url as “http://svn.apache.org/repos/asf/commons/proper/io/trunk“. Enter the “Local module directory” as “.”

Look for the section called “Build”. Click the button “Add build step” and select “Invoke Ant”. Leave the rest to default. (Maven users, choose the appropriate action)

Go to the section “Post-build Actions”. Select the checkbox “Archive the artifacts”. The apache commons-io build script shall create the jar in the directory named “target”. So enter the value “target/*.jar” in the text field titled “Files to archive”. Though this is not mandatory to build a job, I recommend you to do this as this will help the users of your continuous integration server to download the build outputs quickly.

NOTE: Since we are building the apache-commons-io project we are entering the value “target/*.jar”. If for example, your build output directory is “dist”, then you should enter here as “dist/*.jar”.

Press the “Save” button at the bottom. Our job is ready and just click link “Build Now” at the left to start building the job.

Once the build is initiated, you can relax and watch the progress in the “Build History”.

If you are restless and want to see exactly what is going on, just click the link (corresponding to the build number) in the “Build History”.

Now click the link “Console Output”.

Hudson will display you the console view where you can do all your research.

Now that the build is successful, you might want to have a look at the jar built by this job. You can find that under “Last Successful Artifacts”.

You can also have a sneak preview about the builds from your Hudson home page.

If in case some of your builds failed, Hudson will report that as well neatly along with displaying the build stability.

That’s it for now. But you can do a lot more like configuring Hudson to build this job every few minutes or just poll the repository once in a while and trigger the build whenever someone commits to the repository. Explore them under the job’s configuration page and enjoy. And did I mention that Hudson has a lot of good plugins already? Maybe I will try to cover those advanced concepts in my next post.

If you are using NetBeans as your IDE, then you have a got a lot of Hudson features integrated right into the NetBeans IDE. Check that out in my post NetBeans 6.7 – A quick glance.

Are you using Hudson? Are you planning to use Hudson? Why not leave a comment below and share your thoughts?

NetBeans 6.7 – A quick glance

James — Tue, 07 Jul 2009 15:30:58 +0000

NetBeans 5.0 – Simplified Swing development
NetBeans 5.5 – Simplified Java EE development
NetBeans 6.0 – Made the NetBeans editor and other core infrastructure on par with competitors
NetBeans 6.5 – Looked beyond Java development by supporting languages like PHP
NetBeans 7.0 6.7 – Tries to make collaborative team development seamless.

I was quick to download the “All Java” pack of NetBeans IDE for linux. Installation, as usual was pretty smooth on my Ubuntu 9.04. The installation didn’t give me much surprises and it was very much similar to version 6.5. I customized the installer to install Glassfish v2.1 and Tomcat 6.0.18 for me.

Splash Screen
The splash screen has changed a bit and the startup was quick. But I wouldn’t comment about the startup speed at this point of time since I haven’t created/opened any projects in the IDE.

Intuitive Start Page
The start page has got the much needed face lift and is very attractive. The big and clean text reminded me about Eclipse which has got a really good start page. With this new start page, installing plugins is just one click away.

The start page also offers an intuitive way to activate/de-activate IDE features. Say suppose you don’t want certain IDE features, for example, Mobile development, it’s very easy to turn it off right from your start page. Good work!

Hudson Integration
That’s my favourite feature in this release of NetBeans. Hudson is a great continuous integration server which helps you to automate your build process. And if your team uses Hudson, then this NetBeans feature might be very useful to you. As per my understanding, currently NetBeans supports only Hudson continuous integration server. If you are using other CI servers like CruiseControl, no great news for you in this release of NetBeans.

[smartads]

Open the “Services” window in the IDE and look for “Hudson Builders”. There you can add your existing hudson urls.

With the hudson support, you can now manage the hudson jobs without opening a browser. You can even copy the build artifacts to your netbeans projects.

You can also watch the remote hudson build console at the comfort of your IDE.

Issue Tracker Integration
If you are doing any serious development, it’s most likely that you will be using some issue tracker. There are many popular issue trackers available like Bugzilla, Trac, Jira etc. NetBeans 6.7 provides out of the box support for Bugzilla but Jira support is available as well through a plugin.

I registered my mozilla issue tracker account in the IDE. Once an issue tracker is registered, you can find as well as add/modify issues.

Finding issues from a bugzilla based issue tracking system is just a click away.

Reporting new issues is not a tough job either.

I didn’t try the Jira integration yet. In future, I would love to see integration with more issue trackers like Trac.

Error Reporting
Another neat feature which I like in this release is the enhancements made to the exception reporter.
In previous versions of NetBeans, the issue log file shall be uploaded to the netbeans server and you will be displayed a message in the browser regarding the status of the issue. Now that’s integrated into the IDE as well.

You can view all the issues filed by you by clicking the button “Show my issues”.

Others

Other highlighed feature of NetBeans is “Project Kenai” integration. For those who are wondering what is this all about, “Project Kenai” is a place to host your open source projects much like sourceforge, google code, launchpad etc. But I couldn’t complete my testing on this NetBeans feature and as such I couldn’t write about this at this point of time. But to be frank, I’m not very excited about this feature. A sourceforge.net integration would have made me much happier but nevertheless it’s a great effort put forward by NetBeans team.

There are many other improvements in the areas of code completion, debugging, profiling, Maven support, Groovy support etc. You can get more details about that from the netbeans wiki.

Summary
Overall, NetBeans 6.7 builds on the strong platform of 6.x series and takes team development one step further. Hudson integration is really very good and I believe Bugzilla integration is also pretty good. But there are not many new features in this release that can make a Java developer happy. Whatsoever, it’s a great effort from the NetBeans team and we must appreciate them for this solid work. So what about you? Have you tried NetBeans 6.7? How do you feel about it?

New!

Learn more about Hudson from the blog post Hudson CI Server – A step by step guide – Part I.

Ubuntu 8.10 – A Productive Java Development Environment

James — Sat, 13 Dec 2008 00:42:58 +0000

I recently started using Ubuntu 8.10 at my workplace as well. Till then, I have been using Ubuntu only at home. For me, Ubuntu@Work was very different from Ubuntu@Home. I mostly surf, blog, listen to music and play some games at home. But Ubuntu@Work was a completely different scenario.

Since I’m new to this linux stuff, it took me some time to configure things like static ip address, host names etc. But once everything was setup, things started moving quickly. I initially had doubt in my minds about the font rendering of NetBeans (or any swing app for that matter) under linux. I even wrote an post showing my frustration with NetBeans font rendering when compared to Eclipse. But with jdk.1.6.10, font rendering is smooth and NetBeans works like a champ! You can see some samples here:

But not everything is perfect at this point of time. For example, the combo boxes are not rendered properly. But apart from these minor glitches, NetBeans runs very well on Ubuntu.

I initially thought of using my already existing netbeans projects in a ntfs partition. But later, I decided not to go for it. I thought working on a native “ext3″ partition would give better performance and I can say that I’m not disappointed.

With my projects in a “ext3″ filesystem, opening projects and editing files are faster now. And with excellent subversion integration, working as a diverse team is not at all an issue. (I’m the only one using Ubuntu in my team so far. )

So far, I have been doing Java development on a Windows XP machine and I can say with absolute confidence that Ubuntu offers a much more better development environment. I can connect to other Windows machines in my network using “Terminal Server Client” which comes with the default Ubuntu installation. Yes you can argue that Windows has “Remote Desktop” by default as well. But Ubuntu supports not just “remote desktop” but also “VNC” by default. With VNC, I can connect to linux servers and other old windows machines (2000, NT).

Just in case if you want to connect to that old operating system, it’s very easy with Ubuntu on your side

And I use to depend heavily on WinSCP to share files between computers but I was stunned to see Ubuntu providing native support to ssh which is integrated into the nautilus file explorer as well. This feature alone saves me a lot of time!

What more, you get a powerful “Network Tools” which can do some simple operations like “ping” to scanning for opened ports in a remote computer.

There is an excellent partition editor as well in the form of “GParted” with which you can easily resize/create/delete/format partitions. I use this to manage partitions even in windows machines.

Remember that crappy “Disk Management” tool in Windows?. Yes there are tools like Partition Magic for Windows, but in Ubuntu, all these things are available by default and costs absolutely nothing.

Moreover, boot up and shutdown are very fast with Ubuntu 8.10 than with Windows XP. The OS itself consumes much less memory, so other applications get more resources. Especially when you have a system with minimal configuration, then Ubuntu Linux is definitely a better option than Windows.

Setting up a fresh system with Windows XP + drivers + other softwares normally take more than 2 hours but setting up a similar system with Ubuntu will take less than half an hour. And do I need to say that a default Ubuntu installation comes with softwares like Firefox, Pidgin, OpenOffice, GIMP etc. And you can find most of your favourite software in the Synaptic Package Manager. You will enjoy installing softwares like Picasa, Google Earth, Skype etc from within your operating system. No need to go to 101 sites to download 101 stuff!

And kindly note that Ubuntu Linux is not the only option you have. There are many other great Linux distros like Fedora, Linux Mint, OpenSuse etc. Since I use Ubuntu at work/home, I shared my views based on Ubuntu. I just installed Linux Mint for my wife which looks like a drop-in replacement for Windows. (Actually she couldn’t believe that it’s linux for quite some time)

With it’s excellent performance even on old hardware and with lots of bundled software tools which boosts productivity, Ubuntu certainly provides excellent environment for development. Add NetBeans/Eclipse/Intellij IDEA to this and you get a powerful java development environment that will cost you less and provide more value for your money/hardware.

Subversion and NetBeans – A quick start guide

James — Mon, 07 Apr 2008 02:24:10 +0000

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”.

[smartads]

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.

SolitaryGeek Poll

Note: There is a poll embedded within this post, please visit the site to participate in this post's poll.

Must have tools for a Java Developer

James — Wed, 19 Mar 2008 07:54:20 +0000

Apart from your favourite IDE, I feel, a Java Developer might be very productive with the following tools (in no particular order):

- Firefox (Do I need to say anything about it?)

- Apache Ant (Not needed, if you use NetBeans. NetBeans has got bundled ant)

- JEdit (Mainly for it’s wide range of plugins. I use it’s LogViewer and HexViewer plugin frequently. Also it has got excellent syntax highlighting for your properties file, java files, nsis scripts etc)

- Subversion Version Control System(Got excellent integration with NetBeans and Eclipse. You must consider it atleast for your personal development.) You can read more about installing subversion here.

- Apache Tomcat (The ubiquitous servlet container.)

- Glassfish (The best open source application server, at the moment. Thanks RedHat for making JBoss AS development sluggish. JBoss AS users are waiting for nearly 1 1/2 years for the 5.0 release.)

- Hudson (The fastest growing continuous integration server. This can be an excellent add-on to your ant/maven based build process). You can read more about hudson here.

- Java Service Wrapper (An excellent product to launch your java applications as a windows service)

- CheckStyle/PMD (Excellent code coverage tools to make your source code more maintainable)

- JASYPT (Excellent cryptography library to encrypt/decrypt your passwords, files etc.)

- Apache Commons Library (Contains almost all the utility classes you will ever need. Kindly check this project before writing your own utility classes)

- JUDE Community (An excellent free UML modelling tool. You must definitely give it a try. It’s lightweight and it’s very simple to use.)

- MySQL (The most popular open source database at the moment)

Did anybody say that I forgot to add Google as well

What else do you use? It will be of great use to the community if you can share about your experience as well.

Note: I tend not to include frameworks like Spring, JSF, Wicket etc.. Because you can see these frameworks too are highly subjective and a major reason for lots of flamewars. And that’s the reason why I didn’t mention any IDE as well. Whatever IDE or framework you use, it’s very likely that you might need the above mentioned “tools” except a few like database/application server, whose choice are mostly defined by a particular organization.

You should read this article in the perspective of “tools needed for your personal java development”. Because there are “lots” of factors involved in your work environment regarding the selection of tools.

And lastly, this is my humble suggestion only. So if you find your favourite tool missing, don’t get panic. Cheers…

Connecting to a database from a java web application

James — Wed, 12 Mar 2008 17:14:02 +0000

In these days of numerous java frameworks, we often forget or don’t care about some simple things. Though this post might not be very interesting to most of you, it might help some of those to whom this might be the information they are looking for. So bear with me.

Pre-requisites:

- Latest version of Tomcat (currently 6.0.16)

- A database (In my case, it’s mysql 5.0)

- Appropriate jdbc “driver” jar file for your database. (In my case, it’s mysql jdbc driverr)

Step 1:

- Copy the “jdbc driver” jar file to the TOMCAT_HOME/lib directory. (Usually, C:\Program Files\Apache Software Foundation\Tomcat 6.0.x\lib)

[smartads]

Step 2:

- Open the “context.xml” file of your web application. It can be found under META-INF directory in your web app.

- Your context.xml file might look something like this, initially:

Step 3:

- Update your context.xml to register your “jdbc driver”, like this:

type=”javax.sql.DataSource” username=”root” password=”mypassword”
driverClassName=”com.mysql.jdbc.Driver”
url=”jdbc:mysql://127.0.0.1:3306/CrickBossDB”
maxActive=”8″ maxIdle=”4″/>

Things to note here:

- Give appropriate resource name for your datasource. In my case, it’s “jdbc/CrickBossDB” .

- Use appropriate username and password with respect to your database.

- Provide appropriate driver name in the driverClassName attribute. In my case, it’s “com.mysql.jdbc.Driver”

- Enter your database url correctly. In my case, it’s “jdbc:mysql://127.0.0.1:3306/CrickBossDB”

(Note: Refer your database driver’s documentation to find out the jdbc url. Microsoft SQL Server, for example, expects the string “databaseName” in the jdbc url.)

Don’t worry about other settings. You need not change it at this point of time.

Step 4:

- Register the jdbc datasource in “web.xml”. (This file is located under “WEB-INF” directory.), by adding the following code:

jdbc/CrickBossDB
javax.sql.DataSource
Container

Note:

Give your datasource name in as defined in your context.xml. In my case, it’s “jdbc/CrickBossDB”

Step 5:

We are almost there. It’s now time to use all the configurations we have made.

Now lookup the jdbc datasource we have defined from your servlet, like this:

InitialContext context = new InitialContext();
DataSource dataSource = (DataSource) context.lookup(“java:/comp/env/jdbc/CrickBossDB”);

Once you get the datasource, creating a connection is a piece of cake.

Connection connection = dataSource.getConnection();

That’s it. Now it’s up to you to use this connection and execute some queries.