Richfaces ModalPanel in Internet Explorer

2009-04-06T09:34:00.000+05:30

RichFaces provides ready-to-use Ajax components to enable building Ajax-based JSF applications. One of the interesting component that you will end up commonly end up relying on would be the rich:modalPanel. Modal Panel, as the name implies, lets you display a modal dialog window (desktop borrowed paradigm) on screen that will render the parent widow locked out for edit.

You may refer to the Richfaces developer documentation for more details of the usage of this component. Although Richfaces library does a good job in handling the browser incompatibility concerns, there are times when it fails to find a good solution. Modal Panel is such a special case; as per the Practical Richfaces book, in order to avoid a bug in Internet Explorer, the root node of the modal panel is moved to the top of a DOM tree.

However, you should have a separate form inside the modal panel if you want to perform submits from this panel. So the modal panel itself should not be placed inside any other form if it has its own form.

If you have multiple Modal Panels in your application, you may use the “zindex” property for relative positioning of the windows (default value is 100)

JAXB, Annotated beans and Unmarshallar Listener

2009-04-04T14:56:00.003+05:30

JAXB is a cool revelation from the Java Technology Platform that offers enough goodies off the shelf for processing simple to complex xml structures. Auto-code generation for creation of marshalling and un-marshalling stubs that happens under the hood has been one of the much hyped about feature of JAXB used by a fairly large percentage of the Java community. And then, there are people like me who like to have a much better control of what is going on behind the scenes. JAXB won’t disappoint you if you are that kind of a breed who wants to write every piece of code and don’t want any junk coming from code generation tools.

In this post, we will look at how JAXB can be used in conjunction with Java 5 Annotations to avoid code generation for un-marshalling operations. We will also explore how JAXB listeners can be used for processing complex xml structures when building your custom Java structures in one pass along with the un-marshalling operation.

Preparing Annotated Beans
JAXB provides you various alternatives to un-marshal xml using Annotations. In this post, we will use setters and getters of the annotated beans. First, let us prepare the bean for the root node:
Let us say, the xml to be unmarchalled looks like this:

<MyXmlRoot name="My Root">
     ...
</MyXmlRoot>

The root tag of the xml as in the example above is <>
The annotated bean will look like this:

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;

@XmlAccessorType(XmlAccessType.PUBLIC_MEMBER)
@XmlRootElement(name = "MyXmlRoot")
public class MyXmlRoot {
   
    private String name;
   
    public String getName() {
        return name;
    }
   
    @XmlAttribute(name = "name")
    public void setName(String name) {
        this.name = name;
      <add your custom code here>   
    }
}

I have included the imports to make your life easy. The first annotation @XmlAccessorType(XmlAccessType.PUBLIC_MEMBER) instructs JAXB to invoke setters of the annotated beans when encountering any of the attributes. Please refer JAXB documentation for the other types of accessors supported. By using the setters, you get a chance to plug-in your custom handler code.

Second annotation @XmlRootElement(name = "MyXmlRoot") tells JAXB to use this bean un-marshalling the root Xml tag (MyXmlRoot)

Introducing a Listener
To create a custom listener, extend your class from Unmarshaller.Listener and override the afterUnmarshall method as shown below:

public class UnmarshallerListener extends Unmarshaller.Listener {
    @Override
    public void afterUnmarshal(Object target, Object parent) {
    super.afterUnmarshal(target, parent);
    <add your custom code here>
}

This method gives you an opportunity to inject additional processing code after the target node has been un-marshalled.

Careful with JAXB Context
Once you are all set with the annotated beans, listeners and custom java structures, it is time for improvisation. Performance is an important aspect that you may want to keep an eye on. On time-slicing the different operations, I found that the time elapsed in creating a JAXB Context has the maximum performance overhead. A smart fix would be to create a single context instance and re-use the same for each of the un-marshaller operations. Follow this approach when you have several XMLs to be un-marshaled over a period of time.

public class MyUnmarshaller {
    private static MyUnmarshaller instance;
    private JAXBContext context;
    private MyXmlRoot root;
   
    private MyUnmarshaller() {
        try {
            if(context == null)
                context = JAXBContext.newInstance(MyXmlRoot.class);
        } catch (JAXBException e) {
            throw new RuntimeException(e);
        }
    }
   
    public static MyUnmarshaller getInstance() {
        if(instance == null) {
            instance = new MyUnmarshaller();
        }
        UnmarshallarContext.createNewInstance();
        return instance;
    }
}

Code snippet above shows several best practices. There is only one instance of the xml un-marshallar. When the instance is created, it also creates a single instance of the JAXB Context. This way although the first un-marshaller operation is costly, from the second operation onwards, the same JAXB context can be re-used resulting in better performance.
You will also observe creation of an UnmarshallarContext. This context may be used to share the context sensitive information across the complete stages of processing xml document.
Final Step
We are all set to run the Unmarshallar. Here is a simplified code snippet that takes in the InputStream of the xml and performing the Unmarshallar operation.

public void unmarshal(InputStream stream) {       
try {
        Unmarshaller unmarshaller = context.createUnmarshaller();
        UnmarshallerListener listener = new UnmarshallerListener();
        unmarshaller.setListener(listener);
        root = (MyXmlRoot) unmarshaller.unmarshal(new InputSource(stream));
    } catch (JAXBException e) {
        throw new RuntimeException(e);
    }       
}

Please feel free to use the code in your applications and let us know if you liked it. Any inputs or techniques to improve the code are most welcome.
Email us at smtechbytes@gmail.com if you need the full source code.

Technology Bytes

Richfaces ModalPanel in Internet Explorer

JAXB, Annotated beans and Unmarshallar Listener