Formation JEE,JAVA,SPRING: December 2014

Monday, December 29, 2014

JSF:Un exemple d'image dynamique en primefaces

Dans cet exemple , on va montrer comment travailler avec une image dynamique en utilisant le composant graphicImage du primefaces.

voici la classe du managedBean:

InputStream is = new FileInputStream("c://jsf.png"); Cette ligne va convertir le fichier de l'image en InputStream.

Voici le code de la page qui va afficher l'image .

Voici ce qu'on va obtenir aprés exécution:

Friday, December 26, 2014

SpringSecurity

Dans cet article, on va montrer comment utiliser spring security dans une application web.

Le plus important est de configurer le fichier XML du spring security suivant:

security:intercept-url indique les pages qui peut y accéeder les utilisateurs ayant le role ROLE_USER.
security:form-login login-page indique la page de login.
authentication-failure-url indique la page qu'on va se rediriger ,en cas ou il y a échec d'authentification.
security:logout logout-success-url indique la page qu'on va se rediriger ,en cas ou on a fait déconnexion.

Le fichier Web.xml modifié sera comme suit : Le code de la page d'accueil pour cet exemple est le suivant:

Wednesday, December 24, 2014

JSF:Exemple d'affichage dans un tableau en JSF

Tout d'abord on doit créer la classe Person suivante:

Puis on developpe le ManagedBean.Notons bien que à partir de JSF2.0,les ManagedBean peut etre décalaré en utilisant @ManagedBean comme suit:

Ceci la page Consultation.jsp qui contient le code d'affichage du tableau en jsf

Monday, December 22, 2014

JSF:Exemple pour les débutants,contient un formulaireet navigation entre les pages selon un critère

Tout d'abord,on doit créer la classe etudiant suivante:

La page index.jsp

La page failure.jsp

et la page succes.jsp

Le fichier faces-config.xml final doit etre comme suit:

Wednesday, December 17, 2014

JSF:un simple exemple d'authentification

On va présenter un exemple de JSF.

Tout d'abord on doit créer la classe BeanUser

public class BeanUser {
String username;
String pwd;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}

public String login(){
if(username.equals("test") && pwd.equals("test"))
return "yes";
else

return "no";

}

}

Cette classe doit etre déclaré dans le fichier faces-config.xml pour etre applelé de la page index.xhtml

<managed-bean>

<managed-bean-name>beanUser</managed-bean-name>

<managed-bean-class>training.jsf.BeanUser</managed-bean-class>

<managed-bean-scope>session</managed-bean-scope>

</managed-bean>

Voici la page index.jsp:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>

<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core"%>

<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

</head>

<body>

<f:view>

<h:form>

<h:messages style="color:red"/>

<h:panelGrid columns="2" bgcolor="cyan">

<h:outputText value="Username" />

<h:inputText value="#{beanUser.username }" required="true" requiredMessage="Username is required" />

<h:outputText value="Password" />

<h:inputSecret value="#{beanUser.pwd}" required="true" requiredMessage="Password is required"/>

<h:commandButton action="#{beanUser.login }" value="Ok" />

</h:panelGrid>

</h:form>

</f:view>

</body>

</html>

Maintenant , on va ajouter la page accueil.jsp suivante:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>

<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core"%>

<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

<f:view>

Bienvenue <h:outputText value="#{beanUser.username}" />

</f:view>

</body>

</html>

et dans le fichier faces-config.xml ,on doit ajouter les regles de navigation comme suit:

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

<faces-config version="2.0" xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xi="http://www.w3.org/2001/XInclude"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd">

<managed-bean>

<managed-bean-name>beanUser</managed-bean-name>

<managed-bean-class>training.jsf.BeanUser</managed-bean-class>

<managed-bean-scope>session</managed-bean-scope>

</managed-bean>

<navigation-rule>

<display-name>index</display-name>

<from-view-id>/index.jsp</from-view-id>

<navigation-case>

<from-outcome>yes</from-outcome>

<to-view-id>/accueil.jsp</to-view-id>

</navigation-case>

</navigation-rule>

</faces-config>

Le vidéo suivant peut vous aider à mieux compendre ceci.

Tuesday, December 16, 2014

SpringMVC

Dans le cas de SpringMVC le conteneur va servir à créer:

-Le contexte de l’application Web
-Les objets traitant les requêtes (Controller)
-Les objets créant les pages HTML (View)
-Les objets données des formulaires (Command)
-Les liens avec les couches métiers et BD
-Et pleins d’autres
-Le mapping des URL vers les contrôleurs
-Le mapping des vues , etc.

Voici le shéma qui montre intervention de spring MVC dans la couche présenation de l'application

En effet spring mvc fonctionne par certains aspects de façon similaire à Struts : une servlet frontale va prendre l’ensemble des requêtes et les dispatcher à ses contrôleurs, ces contrôleurs sont des singletons issus d’une fabrique Spring.

Le Controller

•La org.srinframework.web.servlet.DisatcherServlet est le point d’entrée générique qui délègue les requêtes à des Controller.

•Un org.springframework.web.servlet.mvc.Controller prend en charge une requête, et utilise la couche métier pour y répondre.

•Un Controller fabrique un modèle sous la forme d’une java.util.Map contenant les éléments de la réponse.

•Un Controller choisit une org.springframework.web.servlet.View qui sera paramétrée par la Map pour donner la page qui sera affichée.

web.xml

Le fichier web.xml va contenir :

Une servlet pour dispatcher les requêtes aux contrôleurs.
Un mapping de servlet

•On aboutit à ce fichier:

<!DOCTYPE web-app

PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"

"http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>

<display-name> Created Web Application</display-name>

on déclare la servlet frontale

<servlet-name>spring-mvc-webapp</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

Toutes les requêtes se terminant par .html seront servis par la servlet frontal

<servlet-mapping>

<servlet-name>spring-mvc-webapp</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

</web-app>

Dans un contexte Web avec Spring MVC, il faut comprendre qu'il y a en générale 2 contexte différents.

Le premier est créée par le ContextLoaderListener, et par défaut il va chercher un applicationContext.xml.Ce contexte est général à l'application et est chargé lors du démarrage de celle-ci.
Ensuite, tu as un contexte propre à la servlet, créé par la DispatcherServlet.
Si dans ton mapping celle-ci porte le nom maservlet, alors elle cherchera un fichier maservlet-servlet.xml

Il faut editer le fichier de configuration de spring:

/WEB-INF/ maservlet-servlet.xml

Dans ce fichier on doit déclarer ceci:

Voici la structure du projet springmvc:

Dans le fichier xml de configuration,on doit ajouter la déaclaration du controller HelloWorldController comme suit:

Voici la classe HelloWorldController qui implemente le controller

Nous allons ajouter une autre page pour afficher le résultat au lieux de PrintWriter pour cela nous devons créer ModelAndView et lui passer le nom de model et sa valeur

ModelAndView(String viewName, String modelName, Object modelObject)

Dans la page finale hello.jsp , on recupere la valuer envoye dans la variable txt.

Sunday, December 14, 2014

Tutorial JaXB 2

JAXB (Java Architecture for XML Binding)

JAXB est une spécification qui permet de faire correspondre un document XML à un ensemble de classes et inversement via des marshaling/unmarshaling.

JAXB permet de manipuler un document XML sans avoir à connaître XML ou la façon dont un document XML est traitée comme le cas avec SAX, DOM.

La manipulation du document XML se fait en utilisant des objets précédemment générés à partir d'une DTD pour JAXB 1.0 et d'un XSD pour JAXB 2.0.

Les fonctionnalités de JAXB 2.0 par rapport à JAXB 1.0

1.JAXB 2.0 support uniquement des schémas XML (les DTD ne sont plus supportées)

2.mise en oeuvre des annotations

3.assure la correspondance entre un schéma XML et le bean correspondant.

4.l'utilisation de fonctionnalités proposées par Java 5 notamment les generics et les énumérations.

5.le nombre d'entités générées est moins important : JAXB 2.0 génère une classe pour chaque complexType du schéma alors que JAXB 1.0 génère une interface et une classe qui implémente cette interface.

Les Apport de JAXB 2.0

•En plus de son utilité principale, JAXB 2.0 propose d'atteindre plusieurs objectifs :

•Être facile à utiliser pour consulter et modifier un document XML sans connaissance ni de XML ni de techniques de traitement de documents XML

•S'assurer que la création d'un document XML à partir d'objets et retransformer ce document en objets donne le même ensemble d'objets.

•Pouvoir valider un document XML ou les objets qui encapsulent un document sans avoir à écrire le document correspondant

Nous allons montrer un exemple comment travailler avec JAXB2

-La commande xjc

L'implémentation de référence fournit l'outil xjc pour générer les classes à partir d'un schéma XML.

xXjc Shema.xsd

L'outil xjc possède plusieurs options dont voici les principales

voici le fichier XSD qu'on va utiliser

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="personne">
<xs:complexType>
<xs:sequence>
<xs:element ref="Nom"/>
<xs:element ref="Prénom"/>
<xs:element ref="Solde"/>
<xs:element ref="Deuxbras"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="loonguer">
<xs:simpleType>
<xs:restriction base="xs:byte">
<xs:enumeration value="1"/>
<xs:enumeration value="2"/>
<xs:enumeration value="3"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name="longueur">
<xs:simpleType>
<xs:restriction base="xs:byte">
<xs:enumeration value="5"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name="doigs">
<xs:complexType>
<xs:sequence>
<xs:element ref="loonguer"/>
</xs:sequence>
<xs:attribute name="nom" use="required">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="d1"/>
<xs:enumeration value="d2"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
<xs:element name="couleur">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="blanche"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name="cinqdoigts">
<xs:complexType>
<xs:sequence>
<xs:element ref="doigs" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="bras">
<xs:complexType>
<xs:sequence>
<xs:element ref="longueur"/>
<xs:element ref="couleur"/>
<xs:element ref="cinqdoigts"/>
</xs:sequence>
<xs:attribute name="id" use="required">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="droite"/>
<xs:enumeration value="gauche"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
<xs:element name="Solde">
<xs:simpleType>
<xs:restriction base="xs:decimal">
<xs:enumeration value="97.2"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name="Prénom">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="jean"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name="Personnes">
<xs:complexType>
<xs:sequence>
<xs:element ref="Numéro"/>
<xs:element ref="personne"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="Numéro">
<xs:simpleType>
<xs:restriction base="xs:long">
<xs:enumeration value="70290956565"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name="Nom">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="suissi"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
<xs:element name="Deuxbras">
<xs:complexType>
<xs:sequence>
<xs:element ref="bras" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>

Exemple de classe pour creer un fichier xml :

public class TestMarshalling {
public static void main(String[] args) {
try {
JAXBContext context = JAXBContext.newInstance(Personnes.class);
Marshaller m = context.createMarshaller();
m.setProperty(Marshaller.JAXB_ENCODING, "windows-1252");
m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
///////////////////////
ObjectFactory fabrique = new ObjectFactory();
Personnes pers = fabrique.createPersonnes();

Personne personne = fabrique.createPersonne();
personne.setSolde(new BigDecimal(5000));
personne.setNom("jean");
personne.setPrénom("sahbi");
Deuxbras deuxbras=fabrique.createDeuxbras();
Bras bras=fabrique.createBras();
bras.setCouleur("blanche");
bras.setId("25");
bras.setLongueur(100);
Cinqdoigts cinqdoigts=fabrique.createCinqdoigts();
List<Doigs> listdoigs=new Vector();
Doigs doig1=fabrique.createDoigs();
doig1.setLoonguer(1);
doig1.setNom("pouce");

listdoigs.add(doig1);
Doigs doig2=fabrique.createDoigs();
doig2.setLoonguer(2);

doig2.setNom("index");
listdoigs.add(doig2);

Doigs doig3=fabrique.createDoigs();
doig3.setLoonguer(3);

doig3.setNom("le majeur");
listdoigs.add(doig3);
Doigs doig4=fabrique.createDoigs();
doig4.setLoonguer(4);

doig4.setNom("l'annulaire");
listdoigs.add(doig4);
Doigs doig5=fabrique.createDoigs();
doig5.setLoonguer(5);

doig5.setNom("l'auriculaire");
listdoigs.add(doig5);
cinqdoigts.getDoigs().addAll(listdoigs);
/////
bras.setCinqdoigts(cinqdoigts) ;

deuxbras.getBras().add(bras);
personne.setDeuxbras(deuxbras);

pers.setNuméro(0736512);
pers.setPersonne(personne);

m.marshal(pers, System.out);
// écriture finale du document XML dans un fichier surcouf.xml
m.marshal(pers, new File("c:\\PersonGenerated.xml")) ;

} catch (JAXBException ex) {
ex.printStackTrace();
}
}
}

Exemple de classe pour lire un fichier xml avec jaxb2:

public class TestUnMarshalling {
public static void main(String[] args) throws JAXBException {

//Création d'un contexte JAXB sur la classe Personne
JAXBContext context = JAXBContext.newInstance(Personnes.class) ;
// Création d'un unmarshaller
Unmarshaller unmarshaller = context.createUnmarshaller() ;
Personnes personne = (Personnes)unmarshaller.unmarshal(new File("c:\\PersonGenerated.xml")) ;
System.out.println("numero =" + personne.getNuméro()) ;
System.err.println("Nom = " + personne.getPersonne().getNom()) ;
System.out.println("Solde = " + personne.getPersonne().getSolde()) ;
System.err.println("lognguerur doig = " + personne.getPersonne().getDeuxbras()
.getBras().get(0)
.getCinqdoigts()
.getDoigs().get(0).getLoonguer()) ;

}

Pages