Write a JSF 2 custom EL resolver

Tuesday, 07 June 2011 10:14

The following example describe the creation and the configuration of a custom variable resolver or ELResolver using JSF .� The custom resolver we will implement will not implement VariableResolver or PropertyResolver but ELResolver to give you the fexibility to reuse the same implementation for different purpose.

In this example we want to retrieve a collection of JSF configuration parameters using EL directly in our JSF page. The keyword used to access the collection will be jsfConfigurations.

Let's define first feature description associated with our variable to resolve :

Let's implement ELresover interface. ELResolver enables customization of variable, property and method call resolution behavior for EL expression evaluation.

Implementation of a custom ELResolver

As properties of our EL resolver we will define the feature description for the feature descriptor. If we have multiple FeatureDescriptor we will probably not define those properties as constants.

public class ConfigurationELResolver extends ELResolver {
    private static final Logger logger = Logger.getLogger(ConfigurationELResolver.class.getName());
    
    private final String NAME = "jsfConfigurations";
    private final String DISPLAYNAME = "Jsf configurations";
    private final String DESCRIPTION = "JSF2 configurations parameters";
    private final boolean EXPERT = false;
    private final boolean HIDDEN = false;
    private final boolean PREFERRED = true;
    private final Class<?> TYPE = List.class;
    private final boolean RESOLVABLE_DESIGN_TIME = Boolean.FALSE;
    .....

Return the correponding value

In the implementation of the getValue() we will return the Configuration items if the property requested correponds to the NAME constants ( jsfConfigurations )

 
    @Override
    public Object getValue(ELContext context, Object base, Object property) {
        logger.info("get Value property : "+ property);
        if (NAME.equals(property) && getConfigurationItems() != null){
            logger.info("found configuration request "+ base);
            context.setPropertyResolved(true);
            List<ConfigurationItem> values = getConfigurationItems();
            Collections.sort(values);
            return values;
        }
        return null;
    }

Return the corresponding value type

For a given base and property this method attempts to identify the most general acceptable type for the corresponding property. jsfConfigurations is suppose to return a list of object.

    @Override
    public Class<?> getType(ELContext context, Object base, Object property) {
        if (base != null) return null;
        if (property == null) {
            String message = MessageUtils.getExceptionMessageString
                (MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "property");
            throw new PropertyNotFoundException(message);
        }
        if (NAME.equals(property) && getConfigurationItems() != null) {
            context.setPropertyResolved(true);
            return TYPE;
        }
        return null;
    }

Allowing base to be null for the first part of the expression is the key enabling concept that permits the JSF 1.1 concepts of VariableResolver and PropertyResolver to be combined into the ELResolver . When the base argument is null, an ELResolver functions much like a VariableResolver. Otherwise, it functions as a PropertyResolver.

Implement setValue() method

Attempts to set the value of the given property� object on the given base� object. jsfConfigurations is a read only variable. We return a PropertyNotWritableException if someone try to edit our variable.

    @Override
    public void setValue(ELContext context, Object base, Object property,
            Object value) {
        if (base != null) return;
        if (property == null) {
            String message = MessageUtils.getExceptionMessageString
                (MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "property");
            throw new PropertyNotFoundException(message);
        }
        if (NAME.equals(property)) {
            throw new PropertyNotWritableException((String) property);
        }
    }

Read only

Our variable is read only

@Override
    public boolean isReadOnly(ELContext context, Object base, Object property) {
        if (NAME.equals(property)) {
            return true;
        }
        return true;
    }

Feature description

The following method return an iterator returning information about the set of variables or properties that can be resolved.

    @Override
    public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext context,
            Object base) {
        if (base != null) return null;
        ArrayList<FeatureDescriptor> list = new ArrayList<FeatureDescriptor>(14);
        list.add(Util.getFeatureDescriptor(
                    NAME, 
                    DISPLAYNAME,
                    DESCRIPTION,
                    EXPERT, 
                    HIDDEN, 
                    PREFERRED, 
                    TYPE, 
                    RESOLVABLE_DESIGN_TIME)
        );
        return list.iterator();
    }

Common property type

Returns the most general type that this resolver accepts

    @Override
    public Class<?> getCommonPropertyType(ELContext context, Object base) {
        if (base != null) return null;
        return String.class;
    }

Return the collection

The last method return the collection needed by the getValue() method. In this example we are using the static attribute defined in our ApplicationBB backing bean.

    private List<ConfigurationItem> getConfigurationItems(){
        return ApplicationBB.getConfigurationItems();
    }

Configure our EL Resolver in the webapp

Finally declaring the custom resolver in the faces-config is needed in order to put them to the responsibility chain.

The el-resolver element is used to specify the fully qualified class name of a javax.el.ELResolver implementation class that will replace the JSF implementation�s default expression language resolver implementation. The expression language resolver is called each time an expression
must be resolved. The el-resolver element provides the ability to override the default JSF expression language resolving by plugging in a custom ELResolver.

<?xml version="1.0" encoding="UTF-8"?>
<faces-config 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_2_0.xsd"
    version="2.0">
    <application>
        <el-resolver>
            com.ubiteck.jsf.util.ConfigurationELResolver
        </el-resolver>
    </application>
</faces-config>

If you are facing a listener start error check if you have correctly defined the class in your EL-resolver. If your logging configuration is not properly defined you we not be able to see the ClassNotFoundException

Display the el expression in a datatable

As a conclusion you are now able to access your newly defined variable and iterate to display it in a data table

            <h3><a href="https://java-tutorial.ch/java-server-faces" title="JSF">JSF <img src="https://www.java-tutorial.ch//administrator/components/com_acesef/assets/images/icon-10-external.png"/></a> Configuration</h3>
            <h:dataTable id="jsfConfigurationTable" value="#{jsfConfigurations}" var="config">
                <h:column>
                    <f:facet name="header"><h:outputText style="font-weight: bold;" value="name"/></f:facet>
                    #{config.name}
                </h:column>
                <h:column>
                    <f:facet name="header"><h:outputText style="font-weight: bold;" value="description"/></f:facet>
                    #{config.value}
                </h:column>
                <h:column>
                    <f:facet name="header"><h:outputText style="font-weight: bold;" value="defaultValue"/></f:facet>
                    #{config.defaultValue}
                </h:column>
            </h:dataTable>

The result shoud look like

JSF Configuration

Conclusion

As you have seen, the unified EL provides more features like a pluggable, extensible resolver machinery, and a way to set data and invoke methods from the page.

If you have any remark or questions feel free to put a comment.If you enjoyed this tutorial and want to promote it don't hesitate to click on