public static final » JSF

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.

Integrating JSF 2.0 and Weld with Tomcat6

Daniel — Thu, 22 Oct 2009 12:29:11 +0000

While Mojarra 2.0.0 is out on the street and Weld (aka Java Contexts and Dependency Injection (JSR-299)) is reaching CR1 there’s not much content on the web about it. So I tried to give a litte tutorial how they can be integrated with Tomcat6 (Glassfish v3 and JBoss provide built in support).What’s needed?

Mojarra 2.0.0 (Instructions for obtaining can be found here)
Weld 1.0.0CR1 Servlet Environment (“weld-servlet.jar” contained in Weld donwload archive)
JSR-250 API
jstl 1.2
el-impl 2.1.2-b04

Thats’s not really much (just about 5 MB of JARs) but all you need to get your application running. I’m not going into detail on how to configurate JSF but just what’s additionally required for Weld.

First you have to “tell” Weld and Tomcat that Weld is present by including the Weld Servlet listener in your application’s web.xml:


  org.jboss.weld.environment.servlet.Listener

After that create an empty file called “beans.xml” in the WEB-INF folder. Now Weld can do its magical stuff with all incoming Servlet request. Buth there’s more. This was just the setup of the Weld Servlet environment. Next you need to tell Weld what BeanManager should be used. The BeanManager is the reference to the Injection Manager itself.

The first thing to add is a resource reference in web.xml:


 Object factory for the CDI Bean Manager
 BeanManager
 javax.enterprise.inject.spi.BeanManager

And finally if not already present create META-INF/context.xml and put the Resource itself in it:

That’s all. Tomcat6 is now running with JSF 2.0 and Weld 1.0.0CR1 and ready for hours of fun. As you might have already guessed this post doesn’t contain anything about how to use Weld but just how to set it up with Tomcat6. However I’m writing a short introduction for Wled which should be online within 3 or 4 days.

UPDATE: For those using Maven here’s a simple POM containing the required repositories and dependencies:


 4.0.0
 de.publicstaticfinal
 WeldJSF2
 war
 0.0.1-SNAPSHOT
 
  
   maven2-repository.dev.java.net
   Java.net Repository for Maven
   http://download.java.net/maven/2/
   default
  
  
  
   ibiblio
   http://www.ibiblio.org/maven2/
   
   
   JBoss
   http://repository.jboss.com/maven2
  
 
 
  
   com.sun.faces
   jsf-api
   2.0.1
  
  
   com.sun.faces
   jsf-impl
   runtime
   2.0.1
  
  
   javax.enterprise
   cdi-api
   provided
   1.0-CR1
  
  
   javax.annotation
   jsr250-api
   1.0
  
  
   javax.servlet
   jstl
   1.2
   runtime
  
  
   org.jboss.weld.servlet
   weld-servlet
   1.0.0-CR1
   runtime
  
  
   org.glassfish.web
   el-impl
   2.1.2-b04
   runtime
   
    
     javax.el
     el-api

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).

JSR-303: Bean Validation

Daniel — Fri, 29 May 2009 07:14:12 +0000

In the last few days I created some JPA entities which are used in a Web Application and filled by the user. So what’s next? Input validation. I don’t like JSF’s f:validator tag since it displays only one error message which might be useful if you put the error message next to the input filed. But if you display all error messages bundled on the top of the main content the messages are non-sense for the user.

The next possible solution would be the validator attribute of a JSF component. While this is appropriate for small forms it creates a lot of overhead in big forms (assume you have 10 input fields which follow different constraints). Also it leaves a “Do Repeat Yourself” taste in the delevoper’s mouth. Okay, so what’s the one and only solution.

As always I don’t think there is any but one that comes pretty close: JSR-303 aka Bean Validation. Emerged from Hibernate Validation this JSR aims to simplify bean validation. The JSR is currently in its final proposal stage hence the final release 1.0.0 should be near.

Instead of writing you own code you annotate your beans and tell the Validator what to look for. @NotNull e.g. tells the Validator that the value must not be null. The Rest of the validation is very very very easy:

final ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
final Validator addressValidator = factory.getValidator();
final Set> violations = addressValidator.validate(beanToValidate);

And with this set of violations you can display whatever error messages you want.

You can download it from the Sourceforge page of Hibernate Validator which also contains a very good “Getting started” guide which was (co-)written by Gunnar Morling. At his blog you can find two good introductions, too (Part1 and Part2). For further information just follow the blog of Gavin King et. al.

Or if you use Maven you can download it from JBoss’ Maven repository:

Hibernate Validator
Bean Validation API