Irian

JSF 2.2 - New namespaces

2013-05-16T13:22:32Z

JSFlive published a new post in the series on JSF 2.2 about new namespaces in JSF 2.2. The post JSF 2.2: New namespaces shows the new namespaces for config files and taglibs.

CONFESS_2013

2013-04-24T09:34:34Z

From April 3 - 5, the sixth annual CONference For Enterprise Software Solutions was held at the Congress Centre in Vienna.

Organized by IRIAN and the EJUG Austria, over 200 attendees from all over the world gathered to watch sessions, do workshops and exchange their knowledge.

This year, the three main topics of the conference were:

Enterprise Software Developent
Mobile Computing
Big Data

Some of the talks featured speakers like Jon Brisbin, Heinz Kabutz, Juergen Hoeller and Axel Fontaine.

We also held a raffle, where attendees had the chance to win 3 Raspberry Pis, which was very well-received.

We can happily say that the conference was a huge success and that we are looking forward to next years'.

Thanks to everyone who participated and helped to make it as interesting as possible.

the CONFESS_2013 team

https://2013.con-fess.com/

JSF 2.2 - File upload with inputFile component

2013-04-24T06:09:47Z

JSFlive published a new post in the series on JSF 2.2 about a feature anticipated for a long time: the JSF file upload component h:inputFile. The post JSF 2.2: File upload with h:inputFileshows how the file upload works with JSF 2.2 - even with Ajax.

JSF 2.2 - Empty composite component attributes

2013-04-24T06:09:32Z

JSFlive published a new post in the series on JSF 2.2 features about empty composite component attributes. The post JSF 2.2: Empty composite component attributes shows that JSF 2.2 solves an annoying problem that can occur with composite component attributes that evaluate to null.

JSF 2.2 - Composite components in taglibs

2013-04-24T06:09:08Z

JSFlive published a new post in the series on JSF 2.2 features about composite components in custom tag libraries. The post JSF 2.2: Composite components in taglibs shows how JSF 2.2 makes adding composite components to custom tag libs more flexible. It is now possible to add tags for specific composite components. Even if they come from different resource libraries.

JSF 2.2 - Configurable resource directory

2013-04-24T06:10:51Z

JSFlive published a new post in the series on JSF 2.2 features about the configuration of the resource directory. The post JSF 2.2: Configurable resource directory shows how the directory used for JSF resource lookup in the web application can be changed.

JSF 2.2 - CollectionDataModel

2013-04-24T06:11:02Z

JSFlive published a new post in the series on JSF 2.2 features about the CollectionDataModel. The post JSF 2.2: CollectionDataModel shows this long awaited feature that allows the usage of java.util.Collection with JSF data tables.

JSF 2.2 - View actions

2013-03-30T17:44:33Z

JSFlive started a new series on JSF 2.2 features. The first post in this series presents view actions, a feature missing since JSF 2.0 to execute actions on initial GET requests (and postbacks).

JSF@Work 1.2

2013-02-28T13:36:18Z

IRIAN released version 1.2 of the JavaServer Faces (JSF) online documentation "JSF@Work". This version features new content about CDI, MyFaces CODI, PrimeFaces 3.5 and lots of other enhancements and improvements. The tutorial contains a complete list of changes.

JSF@Work is available (currently only in german language) at: http://jsfatwork.irian.at.

TomEE and Maven

2012-11-27T10:08:29Z

Following article, shows how to use Apache TomEE in conjunction with Apache Maven.

Apache TomEE is a lightweight JEE Web Profile enterprise server wich allows you to use CDI JSF EJB etc... within a simple WAR file.

The blog walks you through a small hello world project which touches all three layers of a typical enterprise application.

On to the article

Weblets 1.2 and Weblets 1.3

2012-11-26T12:51:44Z

Weblets is an opensource resource loading library for web applications under the Apache 2.0 license.

Following Article describes the features of the new Weblets 1.2 release and the upcoming Weblets 1.3 release.

Marrying JSF and Scala part 4, Apache MyFaces Ext-Scripting

2012-11-11T17:34:08Z

In parts 1 2 and 3 we have had a look at various implementation aspects, on how to enable Scala and Apache MyFaces.
Part 4 introduces a framework which allows a zero restart configuration for JSF artifacts programmed in Scala...

Apache MyFaces Ext-Scripting and Apache TomEE

2012-11-11T17:33:30Z

Following article shows how to enable Apache MyFaces Ext-Scripting under Apache TomEE.

Apache MyFaces Ext-Scripting is a MyFaces extension framework which allows dynamic Scripting under Java, Groovy, Scala and soon JRuby. While Apache TomEE is a full JEE web profile running under Apache Tomcat.

JSF@Work 1.1

2012-09-18T13:05:50Z

IRIAN released version 1.1 of the JavaServer Faces (JSF) online documentation "JSF@Work". This version features new content about JSF 2.1, system events, ajax and composite components and lots of other enhancements and improvements. Additionally, all examples were updated to JSF 2.1 and Servlet 3.0 and will now be started with Jetty 8. The tutorial contains a complete list of changes.

JSF@Work is available (currently only in german language) at: http://jsfatwork.irian.at.

Composite component pitfalls - Root component

2012-09-07T13:53:07Z

JSFlive published a second post in the composite component pitfalls series: Composite component pitfalls: Root component discusses cases where the composite component root component can lead to unexpected behavior.

Composite component pitfalls - Empty attributes

2012-09-06T14:41:39Z

JSFlive starts a small series about JSF composite component pitfalls. While composite components really simplify the life of JSF developers in most cases they (still) have some minor quirks from time to time. The first post in this series Composite component pitfalls: Empty attributes discusses problems with composite component attributes whose value is null.

Running JSF 2 on Jetty 8

2012-08-19T21:04:38Z

JSFlive shows how to run JSF applications (MyFaces and Mojarra) on Jetty 8: http://jsflive.wordpress.com/2012/08/19/jsf-2-on-jetty-8/

"CDI für Rich Clients" in Eclipse Magazin

2012-05-17T17:56:33Z

The current issue (4.2012) of the german Eclipse Magazin (http://eclipse-magazin.de) includes the article “CDI für Richt Clients” from Jakob Korherr (Software Engineer at IRIAN).

This article explains how it was possible to integrate Apache OpenWebBeans (CDI implementation from Apache) and Apache MyFaces CODI in an existing Eclipse RCP project and how the project benefited from it.

Here is the original blog post from Jakob: http://www.jakobk.com/2012/05/cdi-fuer-rich-clients-in-eclipse-magazin/

Irian@JAX 2012

2012-04-19T10:06:50Z

Irian will be at the JAX 2012 in Mainz. Michael Kurz will do the session JSF 2 Kompositkomponenten im Einsatz on 19th April 2012.

The slides and examples are available for download.

Marrying JSF and Scala Part 3 - Custom Components in Scala

2012-02-29T09:57:30Z

Marrying JSF and Scala part 3: Custom Components in Scala

Introduction

While JSF2.0 has simplified the component building a lot thanks to the
composite components, there are still usecases when the classical component
building tasks have to be performed.

We showed in part 1 and part 2 how to build the basic JSF artifacts in Scala we now are going to dive deeper into JSF by showing how to leverage Scala to build your own jsf custom component.

In this article we combine various techniques of Scala for programming custom components.
The case we are going to investigate is a simple hello world component.

A custom component in Scala

First we have a look at the component itself:

Code a) Custom component

We have a simple component which exposes one additional attribute sayHello2. The component itself is a composite component with an xml template for rendering an performs some listener tasks.

So far so good, however we use several things here which are of interest:

Code b) Singleton

A singleton object for static replacements and struct replacements

Code c) Listeners Array

A listeners array for combining multiple listeners

Code d) trait

a trait instead of a utils class to combine common functionality of components

Code e) Type matches

matches for types to avoid instanceof cascades

Lets dissect the code parts one by one:

1) Object HelloWorld

Scala does have neither static variables nor structs, instead of that it provides singletons as language construct.
Static variables simply can be simulated by a singleton and a simple in class import:

Code b) Singleton

and then

Code f) import

Allows you to import the instance variables and methods as semi native members.

Code g) import usage

2) Annotation Arrays

Code h) annotation array Scala

is simply what would be in Java

Code i) annotation array Java

Since this code transition is not quite obvious even within the Scala documentation, it is worth to be noted in this blog.

3) Traits

The most interesting part is the traits part.
First of all, what is a trait? To sum it up, a trait is an abstract class which can be multiply inherited sort of an interface with code. Now this opens quite a few possibilities:

Common constraints can be isolated and shared among object instances without having to revert to singletons.
Traits can access "this" and can call methods provided by the class as abstract members.

We reuse traits in this case to isolate common component behavior without having to introduce yet another helper class or an abstract base class.

In fact we finally can share this referencing code among components with different base classes without having to introduce our own inheritance hierarchy.

The trait looks like following:

Code j) Trait

We use only a subset of this functionality namely getAttr and setAttr.

Code k) getAttr

Here we can see clearly the this reference to the underlying component getAttributes with

def getAttributes(): java.util.Map[String, AnyRef]

being defined only as interface, which has to be implemented by the component or one of its parents.

4) Match patterns

Now an interesting language part in Scala is the extended matches. Not only you can match in Scala for values, also matches for types and patterns are allowed.
We use the type matches to avoid instanceof if cascades:

Code l) match patterns

The cases basically replace if instanceof constructs here

A renderer in Scala

Now what if we want to write the renderer in Scala.
Scala there can support us as well, it has XML support in the language baked in.
Now lets have a look at the renderer (if not done in an xhtml template like it should be)

Code m) renderer

Now the interesting part of this renderer is following code:

Code m) render part

As we can see, we simply write the html directly constructs like id={id} and {text} allow for inline templating.

There are constraints to this approach

We cannot write out partial xml. The xml written always must be complete, hence we cannot simply write an open tag first, call a subclass and then close the tag
We do not use the startElement, endElement. The plus side is readability.
In the end a composite component and its direct xhtml rendering should always be the first choice. Xhtml simply is the target platform in most cases why not use xhtml also for the component renderer part.

References