Primefaces esempio introduttivo

Vai all'indice

L'esempio descritto illustra l'installazione di una web application con Primefaces5 e Maven.
L'obiettivo è l'installazione e l'esecuzione dell'esempio DataTable - Header and Footer presente nello Showcase di Primefaces.
Diversamente dagli esempi descritti precedentemente, è necessario avere installato su Eclipse un application server, io utilizzo Apache Tomcat 7.
Come prima cosa apro Eclipse già integrato con il plugin m2e, seleziono New > Maven Project, inserisco il flag "Create a simple project (skip archetype selection)" procedo nella schermata successiva dove inserisco le informazioni di progetto:
groupId: it
artifactId: jsf2
version: 0.0.1-SNAPSHOT
packaging: war (identifico che sto creando una webapp).

A questo punto il progetto è stato creato. Clicco col tasto destro sul progetto e dalla voce "properties" seleziono la scheda "Project facets" che modifico come da figura.

A seguito di questa impostazione è possibile ricevere la segnalazione: "Dynamic Web Module 3.0 requires Java 1.6 or newer", pertanto è necessario selezionare Java 1.7:
Nella scheda Java Compiler selezionare 1.7 su "Compiler compliance level".
Nella scheda Java Build Path - Libraries, cliccare Add, inserire e selezionare la libreria Java 1.7.
A questo punto, apro il file pom.xml ed inserisco le dipendenze:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>it</groupId>
  <artifactId>jsf2</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>JSF Prova</name>
<build>
 <plugins>
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-compiler-plugin</artifactId>
     <version>3.1</version>
     <configuration>
        <source>1.7</source>
        <target>1.7</target>
     </configuration>
   </plugin>
 </plugins>
</build>

<repositories>
  <repository>
     <id>prime-repo</id>
     <name>PrimeFaces Maven Repository</name>
     <url>http://repository.primefaces.org</url>
     <layout>default</layout>
  </repository>
</repositories>

<dependencies>
  <dependency>
     <groupId>com.sun.faces</groupId>
     <artifactId>jsf-api</artifactId>
     <version>2.2.4</version>
  </dependency>
  <dependency>
     <groupId>com.sun.faces</groupId>
     <artifactId>jsf-impl</artifactId>
     <version>2.2.4</version>
  </dependency>
  <dependency>
     <groupId>javax.servlet</groupId>
     <artifactId>javax.servlet-api</artifactId>
     <version>3.0.1</version>
  </dependency>
  <dependency>
     <groupId>javax.servlet</groupId>
     <artifactId>jstl</artifactId>
     <version>1.2</version>
  </dependency>
  <dependency>
     <groupId>org.primefaces</groupId>
     <artifactId>primefaces</artifactId>
     <version>5.0</version>
  </dependency>
     <dependency>
     <groupId>org.primefaces.themes</groupId>
     <artifactId>bootstrap</artifactId>
     <version>1.0.9</version>
  </dependency>
  <dependency>
     <groupId>commons-fileupload</groupId>
     <artifactId>commons-fileupload</artifactId>
     <version>1.3</version>
  </dependency>
</dependencies>
</project>

Nella cartella src/main/webapp/WEB-INF inserisco il web.xml, file che dà le direttive della web application.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <display-name>jsf2</display-name>

  <context-param>
     <param-name>javax.faces.DEFAULT_SUFFIX</param-name>
     <param-value>.xhtml</param-value>
  </context-param>
  <context-param>
     <param-name>javax.faces.PROJECT_STAGE</param-name>
     <param-value>Development</param-value>
  </context-param>
  <context-param>
     <param-name>primefaces.THEME</param-name>
     <param-value>bootstrap</param-value>
  </context-param>

  <welcome-file-list>
     <welcome-file>index.jsf</welcome-file>
  </welcome-file-list>

  <servlet>
     <servlet-name>Faces Servlet</servlet-name>
     <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
     <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
     <servlet-name>Faces Servlet</servlet-name>
     <url-pattern>*.jsf</url-pattern>
  </servlet-mapping>

  <session-config>
     <session-timeout>30</session-timeout>
  </session-config>
</web-app>

Il faces-config.xml contiene la configurazione per il JSF e va inserito nella cartella webapp/WEB-INF.

 <?xml version="1.0" encoding="UTF-8"?>

<faces-config
    xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_2.xsd"
    version="2.2">

</faces-config>

A questo punto clicco col tasto destro sul progetto e seleziono "Run as" > "Maven clean" e successivamente "Maven install". Aggiorno con Maven > Update Project...

Il passo successivo consiste nel copiare i moduli proposti dallo showcase di Primefaces, io ho optato per DataTable - Header and Footer , ma gli esempi sono veramente tanti!
Il progetto consiste di 4 file:
Car.java: definizione della classe Car
CarService.java: è il servizio che definisce le proprietà dell'oggetto Car.
BasicView.java: il backing bean per la gestione dell'interfaccia utente.
index.xhtml: la pagina jsf che espone il risultato dell'elaborazione nel client.
Di seguito riporto l'alberatura del progetto.

Caricati tutti i moduli è possibile eseguire il progetto cliccando con il tasto destro sull'icona del progetto, quindi seleziono Run as.. > Run on Server. Il risultato è il seguente.

Hai apprezzato questo post? Conferma le mie competenze o scrivi una segnalazione sul mio profilo Linkedin!

Una panoramica su Primefaces

Vai all'indice

Per la parte di presentation dei miei applicativi web ho deciso di utilizzare PrimeFaces.
Si tratta di una suite open source che utilizza il framework JavaServer Faces 2.0, tecnologia che si sta imponendo nello scenario delle tecnologie web di presentazione.

La suite offre supporto sia ad ajax che al rendering parziale delle pagine web, e fornisce componenti derivati dall'integrazione nativa con Jquery: editor HTML, finestre di dialogo, meccanismi per l’auto-completamento, grafici e calendari, datatable, drag & drop, integrazione di mappe google e in più la compatibilità con altre librerie di componenti JSF.
Le componenti grafiche si basano su JQuery UI: è quindi possibile personalizzarle attraverso ThemeRoller (applicativo online per gestire e personalizzare i controlli di interfaccia), in alternativa si possono utilizzare l'insieme di temi predefiniti disponibili nel sito ufficiale.

PrimeFaces è basato su un'unica libreria leggera dove ciascuna componente è piuttosto semplice da utilizzare e personalizzare. Nel sito ufficiale è disponibile un fornito showcase dove è possibile scaricare una serie di esempi per ogni singolo componente, inoltre è a disposizione una ricca documentazione e una attiva community online, per la risoluzione di comuni problematiche.
PrimeFaces garantisce la compatibilità con le versioni più recenti di Internet Explorer, Chrome  e Firefox, ma anche il supporto per le versioni dei browser meno recenti.
Con l'aiuto di librerie Javascript come BootStrap.js, è possibile realizzare con PrimeFaces anche pagine in grafica webresponsive, ossia adattabili a dispositivi come smathphone e tablet.
La maggior parte delle nuove componenti di Prime Faces sono sviluppate con HTML 5 o possiedono la possibilità di integrazione con i tag HTML 5.
 Per sviluppare applicazioni JSF fruibili in modo ottimale su un dispositivo mobile è disponibile l’estensione Primefaces Mobile. Basata su jQuery Mobile, essa mira ad ottenere un look and feel più vicino possibile a quello di un’applicazione nativa (di default iOS, ma esistono anche temi Android-like).

Una delle necessità più comuni nello sviluppo di una applicazione è l'esposizione della tabella di dati risultato di una query sul database. Jquery e PrimeFaces forniscono lo strumento DataTable che espone i dati in forma tabellare ed interattiva: filtrabile, ordinabile, modificabile e paginata. Nel showcase di Primefaces sono presenti diversi esempi di Datatables sia AJAX che non. L'esempio descritto nel prossimo post illustra l'installazione di una web application con Primefaces5 e Maven. L'obiettivo è l'esecuzione di uno degli esempi proposti dallo showcase disponibile al link: http://www.primefaces.org/showcase/ui/data/datatable/facets.xhtml .


Hai apprezzato questo post?: conferma le mie competenze o scrivi una segnalazione sul mio profilo Linkedin!

Creare eseguibili schedulati con Quartz

Vai all'indice

L'obiettivo di questo post è creare un'applicazione batch eseguibile schedulata. Per fare questo ho inserito la libreria Quartz nell'esempio descritto nel post precedente, per cui lanciando il processo il risultato dell'elaborazione sarà lo stesso, ma ripetuto ad un intervallo di tempo prestabilito.
Quartz è una libreria open source che permette di schedulare, ovvero pianificare, i processi da una qualsiasi applicazione java. Per fare questo Quartz utilizza la stessa sintassi utilizzata dal crontab di Linux.

Per prima cosa creo un nuovo Java project (File>New>Java project) con Eclipse e definisco un pacchetto prova. Clicco sull'icona di progetto col tasto destro e seleziono Properties dal menù. Mi posiziono sulla scheda Libraries dalla voce Java Build Path ed importo le librerie nel classpath come riportato nella figura.

A questo punto definisco una nuova classe HelloJob.java ed inserisco il codice creato nel post precedente (il test sulle classi String, StringBuilder e StringBuffer).

package prova;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class HelloJob implements Job
{
private static StringBuilder oString = new StringBuilder(""); 
public void execute(JobExecutionContext context)
throws JobExecutionException {

   long start=System.currentTimeMillis();
   testString();
   long end=System.currentTimeMillis();
   oString.append("Tempo di esecuzione testString() "+(end-start)+" millis.\n");
   
   start=System.currentTimeMillis();
   testStringBuffer();
   end=System.currentTimeMillis();
   oString.append("Tempo di esecuzione testStringBuffer() "+(end-start)+" millis.\n");
   
   start=System.currentTimeMillis();
   testStringBuilder();
   end=System.currentTimeMillis();
   oString.append("Tempo di esecuzione testStringBuilder() "+(end-start)+" millis.\n");
  
   File file = new File("output.txt");
    try {
    FileWriter fw = new FileWriter(file);
    fw.write(oString.toString());
    fw.flush();
    fw.close();
    } catch (IOException e) {                        
    System.out.println(e);         
    }  
    }  

 private static void testString() {
   String x = "";
   for(int i=0;i<15000;i++){
     //operazione di append
     x+=i;
   }
 }

 private static void testStringBuffer() {
   StringBuffer x = new StringBuffer("");
   for(int i=0;i<15000;i++){
     //operazione di append
     x.append(i);
   }
 }

 private static void testStringBuilder() {
   StringBuilder x = new StringBuilder("");
   for(int i=0;i<15000;i++){
     //operazione di append
     x.append(i);
   }
 }  

}

Definisco la classe Prova.java come entry point. All'interno del metodo main inserisco il codice per l'esecuzione del CronTrigger di Quartz, che tramite un'espressione tipica di Unix ci consente di specificare le date e gli orari in cui eseguire il job.

package prova;

import org.quartz.CronScheduleBuilder;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.core.*;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class Prova  implements Job{

    public static void main( String[] args ) throws Exception
    {
   
    JobDetail job = JobBuilder.newJob(HelloJob.class)
.withIdentity("dummyJobName", "group1").build();

    Trigger trigger = TriggerBuilder
.newTrigger()
.withIdentity("dummyTriggerName", "group1")
.withSchedule(
CronScheduleBuilder.cronSchedule("0/5 * * * * ?"))
.build();

    //schedulo
    Scheduler scheduler = new StdSchedulerFactory().getScheduler();
    scheduler.start();
    scheduler.scheduleJob(job, trigger);

    }

@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
// TODO Auto-generated method stub

}
}

In sostanza il codice costruisce un job partendo dalla classe HelloJob e la manda in esecuzione ogni 5 secondi. La riga che determina la pianificazione è:
CronScheduleBuilder.cronSchedule("0/5 * * * * ?"))

Per comprenderla vi consiglio di cercare su Google documentazione sul Crontab di Linux.
Terminata la stesura del codice ho salvato il progetto come Jar eseguibile e creato il file .exe utilizzando Launch4j come descritto nel post precedente.
Lanciando l'eseguibile, il processo ogni 5 secondi accoda nel file output.txt un nuovo report sui tempi di esecuzione delle tre classi String, StringBuffer e StringBuilder.

Nota per chi testasse questo esempio; Una volta lanciata l'esecuzione vi consiglio di terminare il processo javaw tramite  la scheda Processo del pannello di Gestione Attività, in caso contrario il processo continuerà a ciclare fino allo spegnimento del pc.

Hai apprezzato questo post? Conferma le mie competenze o scrivi una segnalazione sul mio profilo Linkedin!