Pages

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>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>demo jsf</title>
</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>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<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 :
  1.        Une servlet pour dispatcher les requêtes aux contrôleurs.
  2.         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>
 <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()) ;


}

Friday, December 12, 2014

logout spring security


Dans cet exemple nous allons montrer comment effecture la  déconnexion en
utilisant spring security dans une page utilisant le framework JSF:

Dans la page ou on vuet faire la deconnexion nous ajoutons le composant outputLink avec comme value:     j_spring_security_logout




Dans le fichier de configuration de spring security nous ajoutons la balise de logout comme suit:






la  properiete  logout-success-url  indique l'url de la page qu'on  veut y aller apres avoir cliqué sur la valeur Deconnextion.

Finalement voici le fichier web.xml complet: