Remote Debugging Java Applications

After my previous article about Remote Debugging .NET Applications using Visual Studio 2010, I was curious to see how Remote Debugging works for Java Applications. This blog post covers Remote Debugging Java Applications using NetBeans 7.0.

The basic concepts of Remote Debugging are the same for .NET and Java but the process of setting up the host and remote computers varies between Visual Studio and NetBeans. Similar to the .NET application used in the previous post, the screen shots correspond to a simple Java application which would popup a MessageDialog on a button click. Get the code here.

Before configuring the host and remote computers, it is vital to understand the Java Platform Debugger Architecture (JPDA). JPDA provides the infrastructure you need to build end-user debugger applications for the Java Platform. It includes the following APIs broken into three layers -

• Java Debug Interface (JDI), a high-level Java programming language interface including support for remote debugging
• Java Debug Wire Protocol (JDWP), which defines the format of information and requests transferred between the process being debugged and the debugger front end
• JVM Tools Interface (JVM TI), which is a low-level native interface that defines the services a JVM provides for tools such debuggers and profilers

Configuring the Remote Computer

Run the Java application using the -Xdebug and -Xrunjdwp options from the command line.

java -Xdebug -Xrunjdwp:transport=dt_socket,address=6000,server=y -jar RemoteDebugging.jar

Here's a description of the options of the java command -

Option	Description
-Xdebug	Enables debugging support in the VM
-Xrunjdwp	Loads in-process debugging libraries and specifies the kind of connection to be made

The -Xrunjdwp option has several sub options. Here are the descriptions of the ones that are used above -

Option	Description
transport	Name of the transport to user in connecting to debugger application
address	Transport address for the connection If server=n, attempt to attach to debugger application at this address If server=y, listen for a connection at this address
server	If y, listen for a debugger application to attach If n, attach to the debugger application at the specified address

By default the application starts in suspended mode. In suspended mode the application waits for a debugger to attach itself to the server at the specified port before the application starts.

Configuring the Host Computer

The host computer is the system running NetBeans 7.0. Open the code of the application in NetBeans and select "Attach Debugger". Specify the Connector as SocketAttach, the Host as the hostname of the remote system and the Transport and Port as specified above.

Specify the breakpoints in the code and they would hit appropriately. There are two major bottlenecks in Remote Debugging -

• The code from which the executable was built should be available at the time of debugging
• Applications cannot be configured for Remote Debugging at runtime. The -Xdebug option must be specified at the instantiation of the application, making debugging live production code difficult

Before I conclude, here's an article from OTN (Oracle Technology Network) on the Java Platform Debugger Architecture. Visit it if you would like a deeper insight into Java Debugging. The schematic of the JPDA is from a weblog, check it out here.

Introducing Hibernate In Java Using NetBeans

In one of my recent posts, I introduced the theoretical topic of Object-Relational Mapping (ORM) - http://gautam-m.blogspot.com/2010/11/object-relation-mapping.html. In this post I am going to take a step forward and introduce Hibernate - an open source Java persistence framework from JBoss.

This post covers four basic principles of Hibernate -

• Configuring a Java project for Hibernate
• Inserting data using Object Persistence
• Retrieving data using Hibernate Query Language (HQL)
• Changing the database configuration to connect to another DBMS

Though the post and screen-shots emphasize on NetBeans, the concept is the same for all IDEs. Hibernate configuration files can definitely be written without an IDE but make sure all the required class libraries are properly referenced.

Requirements to run the example in the article - NetBeans, MySQL, JavaDB, Java and Hibernate. Java can be downloaded here, installing the All NetBeans package will cover JavaDB and Hibernate. and MySQL can be downloaded here.

Configuring a Java project for Hibernate

The crux of Hibernate is the creation and usage of configuration files. There are three types of configuration files which are to be setup for Hibernate -

1. The .cfg.xml file - this is the main configuration file which contains information about the database like the database URL, the driver, the username and password, etc. Hibernate can optimize it's behavior depending on the DBMS being used. To facilitate this, a property called Dialect is specified. However this is an optional property as Hibernate can deduce this depending on the JDBC metadata returned by the driver
2. The .reveng.xml file - this file holds the data corresponding to the schemas and tables being utilized by Hibernate in the application
3. The .hbm.xml - these files maps POJOs (Plain Old Java Objects) to the table schemas of the database

Typically one .cfg.xml and one .reveng.xml exist for a project and one .hbm.xml exists for each table (mapped to a class). The .hbm.xml maps the object properties to the table columns. It is possible to add new properties to the class which have no effect on the backend tables.

To create these files in a NetBeans project, select New File and select the following File Types from the Hibernate category -

1. Hibernate Configuration Wizard
2. Hibernate Reverse Engineering Wizard
3. Hibernate Mapping Files and POJOs from Database

Follow the wizards to complete the configuration setup. I used MySQL and JavaDB as my DBMS to create a sample application to insert and retrieve data. You can get the MySQL and JavaDB scripts along with the NetBeans project here.

Inserting data using Object Persistence

Inserting data is a cake-walk in Hibernate. All that is there to do is to create the object and store the object data in the database tables using the save method of a SessionFactory object. The following piece of code persists the object data -

SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Session session = sessionFactory.openSession();

// Create the object
session.save(object);

Retrieving data using Hibernate Query Language (HQL)

Retrieving data is done through a query language designed for Hibernate called the Hibernate Query Language. HQL is a Object-Oriented Query Language and is very much similar to the traditional SQL we use. The beauty of HQL is that the result of the query is returned as a list of objects rather than as a ResultSet. These objects can be used directly in the code without any overheads. HQL is very wide topic, so I am going to skip the details here but there are several tutorials available for HQL on the Internet. The createQuery method of the above Session object is used along with the list method of the Query object to get the objects -

Query query = session.createQuery(queryString);
for (Object object : query.list()) {
// cast and use the object appropriately
}

Changing the database configuration to connect to another DBMS

The best feature of Hibernate according to me is it's ability to change a DBMS without any change to the application code. To change the DBMS, open the Hibernate Configuration File (typically hibernate.cfg.xml) and change the dialect, driver class, connection URL, username and password to the values corresponding to the new DBMS.

These changes can be done either through the design view or directly on the XML.

Integrating OACurl With A Java Desktop Application

In my previous post, I introduced the Google Buzz API and the technologies surrounding it. In this post, I will be emphasizing on how to integrate OACurl with a Java Desktop Application to make the authentication process simpler. Before I continue, let me categorical state that this method is good for small student projects; but for serious production applications, OACurl integration isn't a good option.

OACurl is primarily an OAuth aware wrapper around the popular cURL command line utility. If you are wondering what cURL is, it is a software project providing a library and command-line tool for transferring data using various protocols like HTTP, FTP, HTTPS, LDAP, IMAP, POP3, etc. The beauty of cURL is that it simplifies the process of data transfer using these protocols to a very large extent. OACurl is an extension to this utility which supports OAuth, the authentication/authorization protocol of the Google Buzz API. OACurl provides an easy way to experiment with the Buzz API.

Before I start with OACurl Integration, let's see how we can connect a desktop application to the Google Buzz API without OACurl. As I mentioned in the previous post, the OAuth token request and authorization process takes place through a Web Browser. So the desktop application should open the Browser and allow Google to verify the user credentials. Then Google issues an authorized token to a Callback URL as specified by the application. This has to be detected by the application and it has to regain focus. For a more detailed view on this, check out - http://code.google.com/apis/accounts/docs/OAuthForInstalledApps.html.

The biggest challenge in this process is that in devices like Gaming Consoles, Setup Boxes, etc., where a Web Browser isn't available the entire procedure goes haywire. Google is working on a solution for this, until then we have to adjust with the Web Browser technique.

OACurl is a pretty easy tool to work with. It is available as a Java Archive with multiple classes for various operations like Logging in, Fetching data from URLs, etc. To use OACurl directly from the command-line, refer http://code.google.com/apis/buzz/v1/oacurl.html.

To use OACurl within a Java Desktop Application, add a reference to the jar file from your project. Now there are two classes which do the entire thing for us - Fetch and Login. Both of them contain a main method; actually it is these classes that are being used in the URL mentioned above. But instead of using classes from the command-line, we will directly call the main method in them from our Java program.

A bit of reverse engineering makes it clear that the flags like "-buzz", "-X", "POST", etc. are being sent as command line arguments. So we can create a String array of these flags and sent it to the main method.

com.google.oacurl.Login.main (new String[] { "-buzz" });
com.google.oacurl.Fetch.main (new String[] { "-X", "POST", URL });

The main methods push the output content to the default output stream as specified by System.out. By default, this is the user screen. If we want to use this output, we can transfer this output into a temporary file and read from this file.

File temp = File.createTempFile ("output", null);
PrintStream output = new PrintStream (temp);
System.setOut (output);

Similarly, the main methods read the input from the default input stream as specified by System.in. By default, this is the keyboard. If we have to send our input, we can create a temporary file, write the content into it and make the file the default input stream.

File temp = File.createTempFile ("output", null);
// Write into the file
PrintWriter writer = new PrintWriter (temp);
System.setIn (writer);

This way we can use the Google Buzz API within our Java Desktop Application without having to worry anything about the authorization process. Developers curious to know how this works can explore the OACurl project hosted on Google Code at http://code.google.com/p/oacurl/. The complete source code of the Login and Fetch classes as well as the Callback Server and other classes is available at the link.

Before I wind up, here is a small project developed in NetBeans which reads the latest buzz and publishes buzz content.

NetBeans 6.9 - The JavaFX Composer Rocks

NetBeans 6.9 has finally been released a few days back, June 15th 2010 to be exact. It was a very special release in the NetBeans community as this was the first major revision after Oracle's acquisition of Sun Microsystems this January. Check out the release notes at http://netbeans.org/community/releases/69/relnotes.html.

Along with NetBeans, a minor revision of GlassFish, GlassFish 3.0.1 has also been released. The minor revision contains several bug fixes and the GlassFish Server Open Source Edition 3.0.1 has been integrated with NetBeans 6.9.

There are several new features which been added to NetBeans this time, like the support for Zend Framework on PHP, Ruby on Rails 3.0 Beta support, Spring Framework 3.0, JavaFX SDK 1.3, CSS Refactoring and Code Completion, support for JDK 7 and several other features. The complete feature enhancement list is available at http://wiki.netbeans.org/NewAndNoteworthy69.

But personally, I felt the best feature addition to NetBeans this time was the JavaFX Composer. For people who are new to JavaFX, it is a Java platform for creating and delivering Rich Internet Applications (RIA) that can run across a wide variety of connected devices like computers (as browser-based and desktop applications), mobile phones, TV set-top boxes, gaming consoles and Blu-ray players.

The JavaFX Composer is a visual layout tool similar to Project Matisse for Swing. Initially released as a plugin for NetBeans 6.8, it has now been completely incorporated into NetBeans 6.9. The primary features of the JavaFX Composer are -

• Visual editor for a form-like UI using components
• Dynamic design editing based on states
• Data access to Web Services, databases and local storage
• Support for JavaFX binding
• Simple animation editor
• Multi-screen-size editing

Create a new JavaFX project using the JavaFX Composer by navigating to File, New Project and choosing a JavaFX Desktop Business Application or a JavaFX Mobile Business Application under the JavaFX category depending on the requirement. Give a project name and the UI editor opens for creating the UI from the JavaFX components.

Drag and drop components from the palette and create the user-interface as you want. Here's a small echo application which echoes what has been typed in the text-box. To be honest, this is my first application in JavaFX and I could finish it by typing only a single line of code and that too a JOptionPane.showMessageDialog and I had help from the auto-complete feature of NetBeans for this :), rest of the work was done the JavaFX composer. That actually reflects the ease of development which the composer and NetBeans are driving. On a whole, a big thumps-up for the JavaFX composer and the entire NetBeans development team for integrating this into the IDE.

Download the project here.

If you give the JavaFX Composer a try, check out the huge arsenal of features which the palette possesses like Shapes, Effects, Charts, etc. You will definitely love them.

This blog-post was shown as a featured article on NetBeans -

Configuring C, C++ In NetBeans 6.5

In Linux and Solaris NetBeans 6.5 configures itself using the gcc/g++ compiler which is available in several flavors of Linux to run C/C++ programs. However, in Windows, there isn’t any C/C++ compiler pre-installed, so we need to manually install a C/C++ compiler and configure NetBeans 6.5 with the compiler.

To achieve this, we use Cygwin - A Linux like environment for Windows. It contains several popular tools like gcc, g++, gmake, gdb, etc. Cygwin can be downloaded and installed from http://www.cygwin.com/.

Once the setup file is downloaded from the above mentioned site, it can be run as a normal .exe file. Cygwin supports three installation types -

• Online installation
• Downloading the installation files without actual installation
• Offline installation form a local directory

Mention the directory path for the installation files. Also mention the directory where the downloaded files were placed. Offline install requires the packages to be downloaded and stored as a directory.

The installer will collect information from the parse-file and list all the packages that are available for install. In online install, this will list all the packages that are available to be downloaded and installed. Select the required packages to be installed and proceed. After some time, the installation completes.

Once Cygwin is installed, NetBeans automatically recognizes it and configures its C/C++ compilers. However if it does automatically recognize Cygwin, go to Tools > Options. Under the C/C++ tab, set in the parameters by mentioning the path of the base directory (the bin directory of cygwin), C compiler (gcc), C++ compiler (g++), make command and the gdb command.

That’s all; NetBeans is now configured to run your C/C++ programs.

NetBeans 6.5 Installation

Installation of NetBeans 6.5 requires Java Development Kit 5 or Java Development Kit 6 as a pre-requisite. You can download the required JDK from http://java.sun.com/javase/downloads/.

The installation procedure of NetBeans is the same in Windows, Linux and Solaris. Since NetBeans is written in Java, it is platform-independent and the installation User-Interface is also same in any operating system. NetBeans 6.5 is available as binaries for all the three Operating Systems - Windows, Linux and Solaris. Download it from http://www.netbeans.org/.

Start the installation by either double-clicking the .exe file in Windows or running the .sh file in Linux and Solaris from the Terminal. This starts the GUI based installation of NetBeans 6.5. Initially it takes a few seconds to configure the installer. The best part of NetBeans is its flexibility. It allows the user to install whatever is required, instead of installing everything. There are few runtimes which are selected by default.

Click on the customize button to select the runtimes which you need. The customize button also gives brief information about each component which is being installed. Also the GlassFish app-server and the Apache Tomcat web-server can also be installed as a part of NetBeans. Accept the license agreement.

Specify the installation directory of NetBeans. Also specify the directory where JDK is installed, the JDK directory is generally recognized by the installer itself. If you customized the installer to install GlassFish v2, the installer will prompt for the required parameters for GlassFish v2. These include the directory path, the admin username and password and the 3 ports - HTTP, HTTPS and admin. All these parameters are initialized to their default values.

Similarly, if you customized the installer for GlassFish v3, specify its directory path. Also, if you customized the installer for Apache Tomcat, specify its directory path.

The installer finally gives a summary of all the components which are to be installed, if you are satisfied with the customized components, start the installation. The installation will take some time depending on your system configuration and the components which are being installed.

Once the installation is complete, the installer will prompt you for registration. It is recommended that users register as there are a lot of offers available for registered users. However the choice of registration is left to the users. That’s it, NetBeans 6.5 is up and ready to use.