Design patterns Java EE 6 with JSF / EJB / JPA

Add JSF 2 to the web project

Right click on the web project / properties and click on framework. Add Java Server Faces:

Check that you are using JSF 2:

Modify the JSF page to use Primeface's datatable

Add this new namespace for primefaces components:

xmlns:p=xmlns:p="http://primefaces.org/ui"

Then, by prefixing them with "p:" we will be able to use Primefaces components.

• Replace all <h:dataTable> and </h:dataTable> by <p:dataTable> and </p:dataTable>
• same for <h:column> and </h:column>, replace h: by p:

Deploy the project (right click on the blue triangle project / deploy). Run it. You should see:

This table looks better, but if you are curious you will see that you may activate many options by adding attributes or event handlers just look at the demos here: http://www.primefaces.org/showcase-labs/ui/home.jsf

• For exemple, add in the <p:dataTable ...> tag some attributes  paginator="true" and rows="10", save, reload the page, wow, the table has pagination icons now... etc.

Add a link in a column of the table, to call a method in the JSF bean

Modify CustomerList.xhtml so when we click on a customer Id, we call a method in the JSF bean that will get the current line customer's value and forward to another JSF page with a filled form that displays the customer's details:

<p:dataTable value="#{customerMBean.customers}" var="item" 
             emptyMessage="No customer found with given criteria" 
             widgetVar="customerTable"
             paginator="true"
             rows="10">

 <f:facet name="header">  
    <p:outputPanel>  
        <h:outputText value="Search all fields:" />  
        <p:inputText id="globalFilter" onkeyup="customerTable.filter()" style="width:150px" />  
    </p:outputPanel>  
</f:facet>  

<p:column headerText="CustomerId"
          sortBy="#{item.customerId}"
          filterBy="#{item.customerId}"
          filterMatchMode="contains">
    <h:commandLink action="#{customerMBean.showDetails(item)}" value="#{item.customerId}"/>  
</p:column>
...

The added line says that when we click on the Id, we call the method  showDetails(Customer c) of the JSF managedBean (do not forget: the JSF been is in the HTTP session) :

/**
     * Action handler - called when we click on the id in a line of the datatable
     * @param customer : a Customer object that holds the current line values
     * @return
     */
    public String showDetails(Customer customer) {
        this.customer = customer; // store it in a model
        return "CustomerDetails"; // change JSF page, that will use the model
    }

This method does 2 things

1. it store the Customer corresponding to the line clicked into a model named "customer" (this attribute is in the HTTP session, so it will be accessible even if we change from one page to another...),
2. it forwards to the CustomerDetails.xhtml JSF page, as we will see, this one will get the values stores in the model in step 1 for pre-filling ther form it contains.

Save and run the project. You will see an hyperlink on the id in the datatable but that links to nothing as the CustomerDetails.xhtml page does not exists yet.

Add a JSF page for displaying a customer's details

1. Add a new JSF page to the web project, name it CustomerDetails.xhtml,
2. Drag and drop in the body of this page "jsf form from entity" from the palette tool...

Tell the entity you want to display in the form, indicate the name of the property in the JSF backing bean :

customerMBean.details  corresponds to the getDetails() method. Rememer the concept of "property"...

Ok, time to try the project...

Run the project, see that a customer's details are displayed in teh JSF page with the form

Here is what you should get with the client of id=1:

Ok, so we have displayed the details for the Customer with id=1. The DiscountCode for this client is not correct, and we still have to add some buttons for updating or cancelling the update of this client. Just remove the lines corresponding to that widget for now...

Add buttons for updating the form content and go back to the table view

Just add these two lines in CustomerDetails.xhtml before the </h:form>:

<h:commandButton id="back" value="Back" action="#{customerMBean.list()}"/>
 <h:commandButton id="update" value="Update" action="#{customerMBean.update()}"/>

Here is what they do:

• First button when clicked calls the list() method inCustomerMBean.java,
• Second one calls the update() method...

Let's have a look at update() :

public String update() {
        System.out.println("###UPDATE###");
        customer = customerManager.update(customer);
        return "CustomerList";
}

This method uses the current value of the property "customer" and pass it to a method from the customer facade for updating the database. The thing you need to understand is that when the form has been submitted, a call to all the setters for the customer properties has been performed, so the current value of the "customer" model here is already the one corresponding the the data entered in the form. The model in the JSF managed bean is updated as soon as the form is submitted ! There is just a need to call the facade method to update the data in the database.

Add an interceptor binding type annotation to the project named @Logging

We will create a new annotation named @Logging that we will just add before a class definition or before a method for intercepting and method invocations. This is similar to the annotations we created for the @InMemory and @JDBC qualifiers, but there are some particularities.

Add this class in a new package called "interceptors":

package interceptors;

import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.interceptor.InterceptorBinding;

@Inherited
@InterceptorBinding
@Retention(RUNTIME)
@Target({ METHOD, TYPE })
public @interface Logging {
}

This time, we did not define a qualifier but an "InterceptorBinding", as the meta annotation @InterceptorBinding shows. Meta annotations are annotations on annotations. Notice also that the @TARGET meta annotation indicates that this new @Logging annotation we are defining could only apply on METHODS and TYPES (classes).

Add an interceptor that implements the @Logging annotation/interface

We are going now to implement (or bind) an interceptor by creating a POJO class that looks like that:

package interceptors;

import javax.interceptor.AroundInvoke;
import javax.interceptor.Interceptor;
import javax.interceptor.InvocationContext;

@Interceptor
@Logging
public class LoggingInterceptor {
    @AroundInvoke
    public Object intercept(InvocationContext context) throws Exception {
    	System.out.println("----------------------------");
        System.out.println("BEFORE: " + context.getMethod());
        
        System.out.print("Input Parameters values: ");
        // Prints the parameter values of the method
        Object[] parameters = context.getParameters();
        for(Object o: parameters) {
        	System.out.print(o + " ,");
        }
        System.out.println();
               
        
        // Call the intercepted method
        Object result = context.proceed();
        
        System.out.println("Output Parameter value: " +  result);

        
        System.out.println("AFTER: " + context.getMethod());

        return result;
    }
}

Hmmm most of the code are println, so don't panic ! What can we notice:

1. This class is annotated by @Interceptor (it is an interceptor) and @Logging (it is a Logging Interceptor); This means that classes or methods preceded by @Logging will be intercepted by this interceptor,
2. The @AroundInvoke annotation can be only used once. It annotated the "interception method". This method a single parameter, the InvocationContext.
3. This context object proposes a set of methods that are very much related to the Java reflexivity API. For example we can get a Method object using getMethod, an array of objects corresponding to the parameters using getParameters, an array of classes corresponding to the parameter types with GetParameterTypes(), etc. The example prints the input parameter names values passed to the method,
4. The context.proceed() method invokes the method that has been intercepted, passing the input parameters (notice, that there is a context.setParameters() method, so it is possible to alter them during the interception), and the return value is also intercepted,
5. The return value is printed, 
6. and returned so that clients get it.

Update the beans.xml

The interceptors may be specified on the target class using the @Interceptors annotation which suffers from stronger coupling to the target class and not able to change the ordering globally.

The recommended way to enable interceptors is by specifying them in the beans.xml file.

Add these lines to beans.xml to declare the interceptor:

<interceptors>
    <class>org.samples.LoggingInterceptor</class>
</interceptors>

Annotated the CustomerFacade for logging, run the project

We are nearly done. In order to bind the interceptor to a java bean target class, add a @Logging annotation to the ManufacturerFacade class, just before the class definition (or you may try later on to add this annotation just before some methods).

@Stateless
@LocalBean
@Logging
public class CustomerManager {
...
}

Run the project, look at the console ! See all the logs there, they show method calls, input and output parameters, etc.

Well done ! You have now a beautiful looging service that works with annotations !

To go further, we recommend reading a good course/tutorial on java reflexivity API, like this one by Michel Buffa (in french: http://deptinfo.unice.fr/twiki/pub/M...minfo-0910.pdf) and look at the official section of the JavaEE6 tutorial by Oracle: http://docs.oracle.com/javaee/6/tuto...doc/gkeed.html

An excellent quick overview of CDI goodies is proposed in this blog entry (in french): http://blog.xebia.fr/2012/02/01/java...bien-se-tenir/

Régler l'affichage des DiscountCodes dans le détail d'un client

Dans la base de données la table des DISCOUNT_CODE contient juste 4 valeurs correspondants aux quatre types de réductions possibles. Nous allons utiliser un Converter, qui permet de transformer un objet de type entities.DiscountCode en String, et vice versa.

On va commencer par rajouter au projet EJB un session bean stateless dans lequel on ajoutera une méthode List<DiscountCode> getAllDiscountCodes(). Inspirez-vous du gestionnaire de client et de la méthode qui renvoie tous les clients. Plutôt que copier/coller le code ci-dessous, essayez de refaire les étapes que nous avions faites lors de l'écriture du gestionnaire de clients (avec insert code/call enterprise bean, insert code/user Entity Manager etc...)

Vous devriez avoir un code comme ceci :

package session;

import entities.DiscountCode;
import java.util.List;
import javax.ejb.Stateless;
import javax.ejb.LocalBean;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

@Stateless
@LocalBean
public class DiscountCodeManager {

    @PersistenceContext(unitName = "TP1CustomerApplication-ejbPU")
    private EntityManager em;

    public List<DiscountCode> getDiscountCodes() {
        Query query = em.createNamedQuery("DiscountCode.findAll");
        return query.getResultList();
    }

    public void persist(Object object) {
        em.persist(object);
    }
}

Donc, maintenant on a un EJB qui renvoie toutes les valeurs possibles de DiscountCode.

On va ajouter dans le managed bean du projet web un objet de type javax.faces.convert.Converter, qui nous servira à transformer un objet de type entities.DiscountCode en String, et vice versa. On utilisera une représentation en string de la forme "L : 7.00%", comme dans la colonne du tableau de détail des clients. Pour celà, commencez par indiquer au bean qu'il va appeler un EJB : DiscountCodeManager, celui que nous venons d'écrire. Ensuite, pour utiliser ce converter dans la page JSF .xhtml, on a besoin de définir une méthode get. Voici le code à ajouter dans le managed bean CustomerMBean:

@EJB
private DiscountCodeManager discountCodeManager;
    
public Converter getDiscountCodeConverter() {
    return discountCodeConverter;
}

private Converter discountCodeConverter = new Converter() {

    @Override
    public Object getAsObject(FacesContext context, UIComponent component, String value) {
        return new ConverterException("On verra la conversion String->Objet plus tard...");
    }
    @Override
    public String getAsString(FacesContext context, UIComponent component, Object value) {
        DiscountCode dc = (DiscountCode) value;
        return dc.getDiscountCode()+" : "+dc.getRate()+"%"; 
    }
};

Finalement, on peut définir une méthode utilitaire qui servira à remplir le menu déroulant de la page JSF CustomerDetails.xhtml. Procédez comme dans le début du TP (insert code/call enterprise bean), puis insérez dans le bean la méthode suivante :

/**
 * renvoie un tableau de SelectItem pour affichage dans le menu déroulant
 * de la page des détails d'un client
 * @return
 */
public List<SelectItem> getAllDiscountCodes() {
    List<SelectItem> options = new ArrayList<SelectItem>();
    List<DiscountCode> ldc = discountCodeManager.getDiscountCodes();
    for(DiscountCode dc : ldc) {
        options.add(new SelectItem(dc,discountCodeConverter.getAsString(null, null, dc)));
    }
    return options;
}

Si vous regardez ce code, il se contente de récupérer la liste des DiscountCodes et de la transformer en liste de SelectItems qui est une classe JSF utilisée par le composant <f:selecteditems ... /> qui indique le contenu du menu <h:selectOneMenu.../> situé dans la page CustomerDetail.xhtml. Chaque SelectItem prends en paramètre lors de la construction un objet (l'objet de type DiscountCode) et une string qui le décrit (formatée par le Converter, qui sera visible par l'utilisateur).

On va pouvoir maintenant modifier la partie "menu" de la page CustomerDetails.xhtml afin que la méthode que nous venons d'écrire soit appelée. Voici le code qu'il faut modifier dans CustomerDetails.xhtml :

<h:selectOneMenu id="discountCode" value="#{customerMBean.details.discountCode}" 
                title="DiscountCode" required="true" requiredMessage="The DiscountCode field is required."
                converter="#{customerMBean.discountCodeConverter}"> 
	<f:selectItems value="#{customerMBean.allDiscountCodes}"/>
</h:selectOneMenu>

Remarquons plusieurs choses :

1. Le contenu du menu est invoqué par value="#{customerMBean.allDiscountCodes}" du tag f:selectItems, cette expression (il s'agit du langage EL de JSF) correspond à un appel à getDiscountCodes() sur le bean de nom customerMBean, c'est la méthode que l'on vient d'écrire.
2. L'attribut qui correspond à la propriété du "modèle associé" au menu, c'est à dire la propriété dont la valeur sera affichée dans le menu comme choix par défaut (appel au getter), mais c'est aussi la propriété qui sera modifiée (par un appel à son setter) lorsque la valeur sera modifiée par un nouveau choix dans le menu. Comme les menus renvoient un e String lorsqu'on leur demande la valeur choisie, c'est le Converter qui se charge de transformer un Objet en string et vice-versa. Ici:
   
   1. le modèle associé au menu est spécifié par l'attribut value="#{customerMBean.details.discountCode}" du tag h:selectOneMenu (appel de la méthode getDiscountCode() de l'objet renvoyé par la méthode getDetails() du customerMBean
   2. l'instance de Converter à utiliser est définie par l'attribut converter="#{customerMBean.discountCodeConverter}"du tag h:selectOneMenu (appel de la méthode getDiscountCodeConverter() de du customerMBean.

On peut utiliser le Converter dans la page JSF CustomerList.xhtml également :

<p:column headerText="DiscountCode"
          sortBy="#{item.discountCode.discountCode}"
          filterBy="#{item.discountCode.rate}%"
          filterMatchMode="contains">
    <h:outputText value="#{item.discountCode}" converter="#{customerMBean.discountCodeConverter}"/>
</p:column>

Voilà, sauvegardez, testez, ça doit fonctionner 

 Il existe en effet une relation entre les clients et les codes de remise. Regardez attentivement la classe entité Customer.java, vous verrez que le code de remise est un attribut discountCode de type DiscountCode. Or le menu déroulant dans la page de détails, lorsqu'on modifie le code de remise, nous renvoie une String. C'est le travail du Converter de transformer cette string en objet de type DiscountCode !

Observez la requête nommée DiscountCode.findByDiscountCode définie dans un attribut de la classe bean entité DiscountCode. Cette requète possède un paramètre noté :discountCode. Quand on donne la valeur d'un code de réduction à ce paramètre, on peut récupérer l'objet de type DiscountCode correspondant. On propose d'utiliser une nouvelle méthode     public DiscountCode getDiscountCodeByDiscountCode(char code) dans le bean session session.DiscountCodeManager. Voici cette méthode:

public DiscountCode getDiscountCodeByDiscountCode(char code) {
        Query query = em.createNamedQuery("DiscountCode.findByDiscountCode");
        query.setParameter("discountCode", code);
        return (DiscountCode) query.getSingleResult();
 }

 Observez: on associe le caractère code au paramètre de requête "discountCode", et on récupère un unique résultat de type DiscountCode: query.getSingleResult().

Voici finalement ce qu'on vous propose comme transformation String->DiscountCode par le Converter:

private Converter discountCodeConverter = new Converter() {

        @Override
        public Object getAsObject(FacesContext context, UIComponent component, String value) {
            char code = value.charAt(0);
            DiscountCode dc = discountCodeManager.getDiscountCodeByDiscountCode(code);
            return dc;
       }
        @Override
        public String getAsString(FacesContext context, UIComponent component, Object value) {
            DiscountCode dc = (DiscountCode) value;
            return dc.getDiscountCode()+" : "+dc.getRate()+"%"; 
        }
    };

Exécutez, testez, amusez-vous à modifier les valeurs des clients, vérifiez dans le gestionnaire de base de données de netbeans que les modifications ont été prises en compte...