Christmas present from Sun

Just as the year was ended I got a great Christmas present from Sun Microsystems.

1) A cool NetBeans 10 year anniversary T-shirt for participating in the community acceptance test programme for NetBeans 6.5 (NetCAT)



2) A pass on my exam to become Sun Certified Specialist for NetBeans IDE

The exam was special to me as it was my first ever certification exam. My score was 82%, with the least score in questions about building Java SE applications. I guess it shows that I've never build Java SE applications on NetBeans. Otherwise I think the exam was great. Studying for the exam revealed a lot of useful features that I had never used before, but now wondering how I could ever live without. I can highly recommend doing the exam!

Thanks Sun!

Project-based formatting in NetBeans 6.5

Being part of the NetBeans Community Acceptance Testing (NetCAT) Programme has definate advantages. For one, you get to try out all the new features planned and influence how they will work before being released to the general public (that is not quite true....anyone can download the daily development builds).



One of the features in the upcoming NetBeans 6.5 that I'm particularly happy about is Formatting by project. In NetBeans it has always been one configuration for all projects. This is slowly changing. During NetCAT for 6.1 the "Shared Library" feature was implemented to detach library management from NetBeans and thereby making projects more portable. So, this time the brilliant guys on the NetBeans development team implemented a feature making it possible to do project-based formatting. This is a great feature when you work on many different projects with different formatting requirements. Way to go! My hope is that for the next version of NetBeans they will also have made template management project-based.

Using Facelets with NetBeans 6.1 (without nbfaceletssupport)

--
Update 27. May 2008: You can download the Facelets NetBeans plug-in for 6.1 from: http://project-template.googlecode.com/files/nbfaceletssupport-6.1.zip
--

I'm a fan of Facelets when it comes to templating for JSF applications. Prior to version 6.1 of NetBeans I was using the nbfaceletssupport plug-in. Sure, it had its quirks, but overall it was a good plug-in. After installing NetBeans 6.1 and really got into using all the new cool features (shared libraries being the most significant) I realised that the nbfaceletssupport plug-in for NetBeans 6.0 didn't work and a fix had not yet been released at the nbfaceletssupport project site (note: Po-Ting Wu of Sun Microsystems has provided instructions on how to re-compile the plug-in for NetBeans 6.1). This also happened when I switched from NetBeans 5.5.1 to 6.0, so I anticipate that this will also happen in the future. So, I thought to myself, why not use the powerful XML support already built-in NetBeans to give me what I need. What I really needed the plug-in for is code completion. So, here goes. First I decided to drop JSP pages (.jsp) for JSP documents (.jspx). The difference being that .jspx is pure XML and .jsp is HTML.

Facelets file as a JSP page (.xhtml):

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:ui="http://java.sun.com/jsf/facelets" xmlns:h="http://java.sun.com/jsf/html">
    <head>
        <title>JSP facelets file</title>
    </head>
    <body>

        <ui:composition template="/resources/templates/page.xhtml">
            <ui:define name="pageTitle">This is a page title</ui:define>
            <ui:define name="pageContent">This is the page content</ui:define>
        </ui:composition>

    </body>
</html>

Facelets file as a JSP document (.jspx):

<jsp:root version="2.0" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:jsp="http://java.sun.com/JSP/Page" xmlns:ui="http://java.sun.com/jsf/facelets" xmlns:h="http://java.sun.com/jsf/html" xmlns:f="http://java.sun.com/jsf/core" xmlns:fn="http://java.sun.com/jsp/jstl/functions" xmlns:t="http://myfaces.apache.org/tomahawk" xmlns:c="http://java.sun.com/jstl/core" xmlns:jsfExt="http://java.sun.com/jsf/extensions/dynafaces">
    <ui:composition template="templates/page.xhtml">
        <ui:define name="pageTitle">This is a page title</ui:define>
        <ui:define name="pageContent">This is the page content</ui:define>
    </ui:composition>
</jsp:root>

When creating facelets file as JSP document in NetBeans you will automatically get code completion (without any third-party plug-ins).



For this to work, ensure that the following configuration is set it web.xml:

<context-param>
    <param-name>javax.faces.DEFAULT_SUFFIX</param-name>
    <param-value>.jspx</param-value>
</context-param>

and that the faclets tag library descriptor (TLD) is accessible in the classpath (eg. /WEB-INF/tlds).




References:

• nbfaceletssupport Project Site


• Po-Ting Wu's Weblog: Build and Install Facelets Support Modules on NetBeans 6.1

Shared libraries finally made it to NetBeans

Today I installed NetBeans 6.1 beta. I've always been a great fan of NetBeans and participated in the Community Acceptance Testing programme (NetCAT) for version 4.0 and 6.0.

I haven't had time to go through all the changes yet, but one thing caught my attention immediately, the "Shared Library" functionality. It has always amazed me that this feature was not implemented way sooner. I have never used the built-in library manager for third-party libraries as the information about the libraries were not included with the projects, i.e. when I create a third-party library in the Library manager for say Apache Commons Configuration and use that in my project, it will break the built for not only other developers by also my continuous integration server. The alternative is to simply add the third-party library directly to the project as jars. The downside about that is that you can't attach the source and JavaDocs, so the inline code completion becomes almost useless. A third alternative is to manage dependencies completely outside of the IDE using Ant and Maven build scripts. I use to do this when using Eclipse, however then you have to update the dependencies in both the IDE and the build script = twice the work.

Back to NetBeans 6.1. When creating a project you now get the offer to enable "sharable libraries". When enabling this feature you are asked to specify the location where the libraries should be saved. By default it will suggest ..\libraries, which is a bit strange considering that it is outside the project folder. I guess it depends on the configuration management practices used on the project. Personally I always check in third-party libraries (as long as there are no licensing issues preventing it). In that way I alaways know that I can build the software anywhere on any machine (that includes my CI box).



After having enabled sharable libraries, NetBeans will automatically copy library to the specified folder when you add dependencies to your project. Furthermore, if you find out that you'd rather have your sharable libraries in a different location, you can simply change the location click "Save" and it will re-create the sharable libraries. Very neat!

I can imagine that they will continue working on the feature at NetBeans and this feature will become even better before the next release.

Yippiee my new phone arrived

For a long time my old phone has been way past retirement. It was a Qtec 2020 (I believe). I've always loved smartphones and hated the glorified music players (e.g. Sony Ericsson). I don't see the point in the fancy music player phones, but that is probably because I'm perfectly happy with my iPod and have no plans of replacing it for something less cool.

Anyways, the Qtec acted up a long time ago. I used it as my organiser, phone and GPS for the car. When it suddenly started losing all its memory and at the same time I misplaced my stylus, I thought that it was high time to get a new phone. So this time I decided not to get a smartphone (mostly because the complete lack of market for smartphones in Denmark - this makes it very expensive!). Instead I got myself a Nokia 6120 with all the latest services provided on the 3G network (Skype, MSN, MobileTV, etc).

So far I'm loving the phone! It is fully compatible with Java MIDP 2.0 - so I'll have to get cracking with Java ME to make some applications soon. Can anybody recommend a good starting point for Java ME programming? My background in Java is purely enterprise and web. NetBeans got some cool mobile development aids that I'll be trying out - but I'd really like to know the basics before I start all the dragging and dropping. In anycase I think this is a good place to start: NetBeans 6.0 Mobility Documentation. It's got a pretty good tutorial for creating a mobile Dilbert browser.

Creating a custom JSF message component

The other day I was tasked with creating feedback messages for a JSF-based application as JavaScript alert dialogues. JSF already got a tag for displaying messages attached to components (<h:message /> and <h:messages />), however they are limited to render the text using a given cascading style sheet class for each level of severity.

This entry will show how to build a custom JSF message tag for rendering the messages as a JavaScript alert.

There are many excellent tutorials and blog entries out there describing JSF component development much better than I am capable of. So, I'll just focus on what is needed to create this specific component. My instructions are based on NetBeans 6.0, but they don't including anything that is not possible to do in other IDEs, so you should be able to translate the instructions into your own IDE.

We will keep the tag simple with one attribute, for, which will specify for which component the messages should be displayed. The signature of the tag will therefore be: <jc:alertMessage for="myForm" />.

1. Fire up NetBeans

2. Create a new Java Class Library Project (I've called mine jsf-components)

Before we continue let me briefly explain what we need:

META-INF/jsf-components.tld

Tag library descriptor declaring your tag and defining its attributes

META-INF/faces-config.xml

Declares the tag in the faces application

components/AlertMessage.java

Class representing the user interface component with properties for each attribute supported by the tag. It's recommended to sub-class one of the existing components to avoid doing all the work yourself.

components/AlertMessageRenderer.java

Class for rendering the content of the tag. This is the class where we will actual construct the HTML/Javascript code that is outputted to the browser.

components/AlertMessageTag.java

Class representing the actual tag.

Now that we know what to do - lets get on with it.

3. Create the components package in the Source Packages


3a) Right click Source Packages
3b) Select 'New'
3c) Select 'Other'
3d) Select 'Java'
3e) Select 'Java Package'
3f) Click 'Next'
3g) Enter components as the package name
3h) Click 'Finish'

4. Create the tag library descriptor
4a) Right click Source Packages
4b) Select 'New'
4c) Select 'Other'
4d) Select 'Web'
4e) Select 'Tag Library Descriptor'
4f) Click 'Next'
4g) Enter the following information:

• TLD name: jsf-components


• URI: http://jsf-components


• Prefix: jc

4h) Click 'Finish'

5. Add the javaee.jar from the GlassFish project (%GLASSFISH%/lib) to the library dependencies of the project.

6. Create the Java class for the UI component, AlertMessage subclassing the UIMessage component.

package components;

import javax.faces.component.UIMessage;

public class AlertMessage extends UIMessage {

    private static final String MSG_COMPONENT_TYPE = "components.alertmessage";
    private static final String MSG_COMPONENT_FAMILY = "javax.faces.Message";

    @Override
    public String getFamily() {
        return MSG_COMPONENT_FAMILY;
    }

    @Override
    public String getRendererType() {
        return MSG_COMPONENT_TYPE;
    }

    @Override
    public String getFor() {
        return super.getFor();
    }

    @Override
    public void setFor(String forParam) {
        super.setFor(forParam);
    }
}

7. Create the Java class for the tag, AlertMessageTag subclassing the UIComponentELTag tag.

package components;

import javax.el.ValueExpression;
import javax.faces.component.UIComponent;
import javax.faces.webapp.UIComponentELTag;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.Tag;

public class AlertMessageTag extends UIComponentELTag {

    private ValueExpression forParam;

    private static final String MSG_COMPONENT_TYPE = "components.alertmessage";

    private static final String MSG_RENDERER_TYPE = "components.alertmessage";

    @Override
    public String getComponentType() {
        return MSG_COMPONENT_TYPE;
    }

    @Override
    public String getRendererType() {
        return MSG_RENDERER_TYPE;
    }

    @Override
    protected void setProperties(UIComponent component) {
        super.setProperties(component);
        AlertMessage em = (AlertMessage) component;
        em.setValueExpression("for", forParam);
    }

    @Override
    public int doEndTag() throws JspException {
        return super.doEndTag();
    }

    @Override
    public int doStartTag() throws JspException {
        return super.doStartTag();
    }

    @Override
    public void setPageContext(PageContext ctx) {
        super.setPageContext(ctx);
    }

    @Override
    public void setParent(Tag tag) {
        super.setParent(tag);
    }

    public void setFor(ValueExpression forParam) {
        this.forParam = forParam;
    }
}

9. Create the Java class for rendering the tag, AlertMessageRenderer subclassing the JSF Renderer.

package components;

import java.io.IOException;
import java.util.Iterator;
import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.context.ResponseWriter;
import javax.faces.render.Renderer;
import org.apache.commons.lang.StringEscapeUtils;

public class AlertMessageRenderer extends Renderer {

    @Override
    public void encodeBegin(FacesContext context, UIComponent component) throws IOException {
        AlertMessage alertMessage = (AlertMessage) component;

        // Locate the component for which to display messages
        UIComponent forComponent = alertMessage.findComponent(alertMessage.getFor());

        // If the component could not be found end processing
        if (forComponent == null) {
            return;
        }

        // Iterate through messages for the component
        Iterator iter = context.getMessages(forComponent.getClientId(context));
        if (iter.hasNext()) {
            ResponseWriter writer = context.getResponseWriter();

            // Start the script tag
            writer.startElement("script", alertMessage);
            writer.writeAttribute("type", "text/javascript", null);

            // Construct one big string of all messages
            StringBuffer message = new StringBuffer();
            while (iter.hasNext()) {
                FacesMessage msg = (FacesMessage) iter.next();
                if (message.length() > 0) {
                    // Separate each message with the JavaScript escape code
                    // for newline
                    message.append("\n");
                }

                message.append(msg.getSummary());
            }

            // Escape the constructed string to be outputable as a JavaScript
            String displayMessage = StringEscapeUtils.escapeJavaScript(message.toString());

            // Output the javascript code for displaying the alert dialogue
            String jsAlert = "alert('" + displayMessage + "');";
            writer.writeText(jsAlert.toCharArray(), 0, jsAlert.length());

            // End the script tag
            writer.endElement("script");
        }
    }

    @Override
    public void decode(FacesContext ctx, UIComponent component) {
        if (ctx == null || component == null) {
            throw new NullPointerException();
        }
    }
}

Notice that I'm using StringEscapeUtils.escapeJavaScript(String) from the Apache Commons Lang library to ensure the correct output of the JavaScript code.

10. Update the tag library descriptor to reflect the created component:

<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd">
    <tlib-version>1.0</tlib-version>
    <short-name>jc</short-name>
    <uri>http://jsf-components</uri>
    <tag>
        <name>AlertMessage</name>
        <tag-class>components.AlertMessageTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
            <description>
                The ID of the component whose attached FacesMessage object 
                (if present) should be diplayed by this component.
            </description>
            <name>for</name>
            <required>true</required>
            <deferred-value/>
        </attribute>
    </tag>
</taglib>

11. Create the faces configuration (META-INF/faces-config.xml) for the component:

<?xml version='1.0' encoding='UTF-8'?>
<faces-config version="1.2" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd">
    <component>
        <component-type>components.alertmessage</component-type>
        <component-class>components.AlertMessage</component-class>
    </component>
    
    <render-kit>
        <renderer>
            <description>Renderer for the alert message component.</description>
            <component-family>javax.faces.Message</component-family>
            <renderer-type>components.alertmessage</renderer-type>
            <renderer-class>components.AlertMessageRenderer</renderer-class>
        </renderer>
    </render-kit>
</faces-config>

12. Build the class library

All you need to do now is to place the jsf-components.jar into your web application, declare the tag library (<%@taglib prefix="jc" uri="http://jsf-components" %>) on the pages where you want to use the tag (<jc:alertMessage for="componentId" />). Example:

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<%@taglib prefix="jc" uri="http://jsf-components" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Example of AlertMessage component</title>
    </head>
    <body>
        <f:view>
            <h:form>
                <jc:AlertMessage for="numberField" />
                <h:inputText id="numberField">
                    <f:validateLength minimum="5" maximum="10" />
                    <f:validateLongRange minimum="10000" maximum="222222" />
                </h:inputText>
                <h:commandButton value="Submit" action="reload" />
            </h:form>
        </f:view>
    </body>
</html>

UPDATE (30. July 2008): Facelets Support

You can use the component with Facelets by providing a Facelets Tag Library descriptor. In this example I name the tag library descriptor mycomponents.taglib.xml and place in the WEB-INF/ directory.

The contents of the descriptor is:

<?xml version="1.0"?>
<!DOCTYPE facelet-taglib PUBLIC "-//Sun Microsystems, Inc.//DTD Facelet Taglib 1.0//EN" "http://java.sun.com/dtd/facelet-taglib_1_0.dtd">

<facelet-taglib>
    <namespace>http://jsf-components</namespace>
    <tag>
        <tag-name>alertMessage</tag-name>
        <component>
            <component-type>components.alertmessage</component-type>
            <renderer-type>components.alertmessage</renderer-type>
        </component<
    </tag<  
</facelet-taglib<

Next you need to reference the descriptor in web.xml using the facelets.LIBRARIES context parameter:

<context-param>
    <param-name>facelets.LIBRARIES</param-name>
    <param-value>/WEB-INF/mycomponents.taglib.xml</param-value>
</context-param>

Remember that if you have more than one Facelets Tag Library Descriptor, to separate them using semicolons (;)

Custom code folding in NetBeans

When you got large source files it can sometimes be helpful to create foldings for certain sections of your code. NetBeans got a nifty functionality for this using non-intrusive XML code (similar to Visual Studio).

To create a custom code folding section simply insert the following before the content to fold:

    //<editor-fold defaultstate="collapsed" desc="My custom code folding">

and the following after the content to fold:

    //</editor-fold>

.

So for example, if you had a JSF backing bean where you want to create a custom code folding for your properties, action listeners, and action handlers you could do as follows:

package backingbeans;

import javax.faces.model.*;
import javax.faces.event.*;

public class MyBackingBean {

    private String prop1 = "";

    public MyBackingBean() {
    }

    //<editor-fold defaultstate="collapsed" desc="Properties">
    public String getProp1() {
        return this.prop1;
    }

    public void setProp1(String prop1) {
        this.prop1 = prop1;
    }
    //</editor-fold>


    //<editor-fold defaultstate="collapsed" desc="Action listeners">
    public void myFirstListener(ActionEvent event) {
        ... do something ...
    }

    public void mySecondListener(ActionEvent event) {
        ... do something else ...
    }
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Action handlers">
    public String myFirstActionHandler() {
        ... do something ...
        return "OUTCOME1";
    }

    public String mySecondActionHandler() {
        ... do something else ...
        return "OUTCOME2";
    }
    //</editor-fold>
}

This will create three custom folders that are collapsed by default when the file is opened.

If you like this, I'd suggest setting up a coding template for inserting the XML code as it can otherwise be tricky to remember. This is done by following these steps:

1. Click Tools -> Options


2. Select "Editor" from the top options


3. Select the "Code Templates" tab


4. Select "Java" in the Language dropdown


5. Click the "New" button


6. Enter the shorthand for inserting the template, for example I use 'efold'


7. Click the "OK" button


8. The template has been created, now enter the following code into the Expanded Text textbox:
   

   
       //<editor-fold defaultstate="collapsed" desc="${cursor}">
   
       //</editor-fold>
   

   
   
9. Click the "OK" button.

You can try out the template by opening a Java source file, place the cursor where you want to insert the folding and type efold followed by the tab key. It will now have inserted the complete editor-fold and place the cursor ready for you to enter a description for the folding.

Using the "License" functionality in NetBeans 6

NetBeans 6 comes with a brand new functionality for including project-based licenses in source files. This enables you to easily use different licenses in the headers depending on the project you are working on.

Using the functionality is simple, here are the steps:

1. Add your licenses to the NetBeans templates
2. Update the project.properties to specify the desired license
   

Simple, eh?

Okay, first we add a license to the NetBeans template. For the sake of this example I'll add the GPL license:

1. Click Tools -> Templates
2. Expand the "Licenses" folder
3. Select "Default License"
4. Click the "Duplicate" button (a new template is created called license-default_1.txt)
   
5. Select license-default_1.txt
6. Click the "Rename" button
7. Name the new license license-gpl.txt (notice, the name should follow the format: license-.txt)
8. Select license-gpl.txt
9. Click "Open in Editor"
10. Enter the following text (GPL license) into the editor:
    

    
    <#if licenseFirst??>
    ${licenseFirst}
    </#if>
    ${licensePrefix}${name}.java
    ${licensePrefix}
    ${licensePrefix}Copyright (C) ${date?date?string("yyyy")} Allan Lykke Christensen
    ${licensePrefix}
    ${licensePrefix}This program is distributed in the hope that it will be useful,
    ${licensePrefix}but WITHOUT ANY WARRANTY; without even the implied warranty of
    ${licensePrefix}MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    ${licensePrefix}GNU General Public License for more details.
    ${licensePrefix}
    ${licensePrefix}You should have received a copy of the GNU General Public License
    ${licensePrefix}along with this program.  If not, see <http://www.gnu.org/licenses/>.
    <#if licenseLast??>
    ${licenseLast}
    </#if>
    

    
    


11. Replace the author name


12. Save and close the template (CTRL+S followed by CTRL+W)
    

You have successfully added the template to NetBeans for use in future projects.

To use the license in a project do the following:

1. Open the "Files" view (CTRL+2)
2. Expand the nbproject folder of your project
3. Open the project.properties file
4. Add project.license=gpl in the end of the file, or if you already have a line starting project.license replace it.
5. Save and close the file

Alright, you are ready to try out the license. Create a new Java class in your Source Packages and viola, the source file is using the newly created license.

In a future version of NetBeans I expect that it will be possible to select the license from the project properties page rather than you having to tinker around with project.properties.