public static final » Facelets

Weld Tutorial – Part 1

Daniel — Fri, 23 Oct 2009 08:03:52 +0000

Following my recently published article about integrating Weld with Tomcat6 here’s Part 1 of my Weld tutorial.

In this first part I want to create a really really really simple example application – the so called “Hello Weld” example. For the Non-German readers: “Hello Weld” is a litte pun. “World” is “Welt” in German which is pretty close to Weld. Enough jokes for now, let’s go to work.First we create the simplest bean known to mankind:

package de.publicstaticfinal.web.jsf;
import java.io.Serializable;

import javax.enterprise.context.SessionScoped;
import javax.inject.Named;

@Named("helloWeld")
@SessionScoped
public class HelloWeld implements Serializable {
private String message = "Hello Weld";

 public String getMessage() {
   return message;
 }
}

9: @Named(“helloWeld”) tells Weld that this bean is accessible under the name “helloWeld”. You don’t have to specify a value the default would be the camel-cased de-capitalized name of the Class.
10: @SessionScoped tells Weld that this bean resides in session scope. Be aware: When you use JSF 2.0 the are two @SessionScoped annotation. If using Wled always use the annotation in the javax.enterprise package.

Now consider the following Facelets page which just outputs the “message” field from the bean referenced by the name “helloWeld”:



Test

And with little surprise you get this output:

What happened? When helloWeld.jsf is requested Weld does a lookup of “#{helloWeld}” and since we declared the bean it can be found by Weld. Weld creates an instance of the bean and puts it into session scope. If you debug the application and create a breakpoint you can see that it is indeed always the same instance within a session.

There’s nothing that special about it since the scoped annotations are also included in JSF 2.0. Part 2 of my tutorial will show you the real fun with dependency injection.

JSF 2: What’s new?

Daniel — Wed, 05 Aug 2009 07:34:17 +0000

Ever wanted to have a complete overview of the (cool) new features of JSF 2? Well, you might be pleased by the blog entry of Andy Schwartz which gives a really terrific introduction to JSF 2. But be warned: You need a lot of time to work through the post!

What’s New in JSF 2?

Unified EL: Method calls using parameters

Daniel — Tue, 02 Jun 2009 13:07:47 +0000

What Seam (and its Extended EL) could do a long time ago standard EL can do now, too: calling methods with parameters. Assuming you have the following bean:

public class MyBean {
 public String sayHello(final String name){
  return "Hello "  + name;
 }
}

If you put somewhere in your JSF page the output ist not a TargetInvocationException or a MethodNotFoundException but indeed a “Hello Daniel”. But with one precondition: you have to use Facelets and not JSP (which should already do). Why is described by Ryan Lubke.

If you’re using Tomcat 6 be aware that it brings its own el-api.jar so you have to replace it in the lib folder.

UPDATE: As admitted in the comments I hadn’t tested the stuff I wrote above. The steps described here aren’t enough, so I’m writing it again so that it works.

Download the two SNAPSHOT jars (el-api and el-ri) from the location posted in Ryan’s blog entry
Put el-api-2.1.2-SNAPSHOT.jar into /lib and remove the existing el-api.jar (please make an backup)
Put el-impl-2.1.2-SNAPSHOT.jar into the WEB-INF/lib folder of your webapp (or let Maven do this for you )
An now the most important part: Tell JSF to use the ExpressionFactory of the RI by adding the following lines to the web.xml:
```
 com.sun.faces.expressionFactory
 com.sun.el.ExpressionFactoryImpl
```

I missed number 4 so JSF always uses org.apache.el.ExpressionFactoryImpl as the default ExpressionFactory. But if you follow these 4 steps everything should work. At least it works for me (Mojarra 2.0.1 and Tomcat 6.0.20).