Développez en JSF2 sur JBoss 7 AS avec Eclipse - Partie 3

Intégrez JBoss à Eclipse

Pour pouvoir utiliser le serveur dans Eclipse il faut intégrer JBoss à Eclipse
File > New > Other

Sélectionnez Server > Server > Next

Dans JBoss Community > sélectionnez JBoss AS 7.1 > Next

Donnez quelques options à JBoss Runtime

Commencez par sélectionner le JRE à utiliser

Sélectionnez le dossier d'installation de JBoss (le dossier résultant de la décompression du fichier .zip téléchargé sur le site de JBoss), en cliquant sur Browse

Note :
Sélectionnez le dossier racine de décompression

Un clic sur Next

Vérifiez les informations et modifiez si besoin > un clic sur Finish

Note :
Remarquez que malgré que j'aie choisi JDK 1.7, la fenêtre affiche 1.4

Créez un projet JSF

Commencez par créer un projet Web dynamique
File > New Dynamic Web Project

Note :
La perspective Web Development est conçu spécialement pour les applications Web, pour l'ouvrir :

Window → Open Perspective → Web Development 

Donnez un nom à votre projet
Un clic sur Modify pour ajouter le support de JSF 2

Un clic sur Custom

 Sélectionnez JavaServer Faces v2.0 Project dans la liste

 JavaServer Faces (2.0) est cochée maintenant > Un clic sur OK

 Un clic sur Finish pour créer le projet

 Maintenant que le projet JSF2 est créé, nous allons ajouter du contenu
Dans Project Explorer > Un clic dorit sur WebContent > New > HTML File

 Donnez un nom au fichier avec l'extension .xhtml > Next

 Sélectionnez Facelets XHTML Page comme modèle > Finish

 Un Editeur Visuel est ouvert. Entrez votre texte, modifier des propriétés,etc.
Entrez Hello World!!! (par example)

 Modifiez le mapping du servelt

Double cliquez sur web.xml > Sélectionnez Faces Servlet > dans URL-Pattern > Entrez *.jsf (à la places de /faces/*)

Sauvegardez tout

 Exécutez le projet

Un clic droit sur le projet > Run As > Run On Server 

JBoss 7.1 est sélectionné par défaut > Finish

 Le server est lancé et le navigateur interne d'Eclipse est ouvert (on peut tester sur n'importe quel navigateur internet, comme firefox, chrome,etc) avec l'url suivante :
http://localhost:8080/test-jsf/

Ajoutez à la fin de l'url le chemin vers le fichier .xhtml en utilisant l'extension .jsf comme suite :

http://localhost:8080/test-jsf/hello.jsf

et voilà

Read more...

Installer WindowBuilder dans Eclipse Indigo

Dans mes précédents articles  (installation and Hello World in Swing,  SWT Hello World), j'ai mentionné l'avenir de cet outils, comme partie d'un package Eclipse.

Vous pouvez maintenant télécharger, par exemple le package  Eclipse IDE for Java Developers, contenant Window Builder Pro

 

Installer WindowBuilder avec un autre package (update site)

Si vous voulez utiliser un autre package Eclipse, ne contenant pas WindowBuilder par défaut, vous avez la possibilité de l'installer en utilisant un "update site"


Après l'installation de votre package préféré d'Eclipse :

• Lancer Eclipse

• A l'Url suivante vous trouverez les adresses des sites d'update (update sites)

        http://www.eclipse.org/windowbuilder/download.php

• Un clic droit sur le lien Idigo link ->  Copy Link Location

• Sous le menu Help dans Eclipse ->  Install New Software

• Coller (Past) le lien copié dans le champs Work with  -> un clic sur  Add

• Donnez un nom dans Name au repository -> un clic sur  OK

• Il est possible de sélectionner tous les composants (voir note plus loin), ou de sélectionner les composants de votre choix -> Next

Note:
Dans Linux (Fedora 14), un message d'erreur est affiché si vous sélectionnez le composant eRCP Designer.

• Vérifiez les détails de l'installation -> Next

• Lisez les Licences

       Sélectionnez  I Accept the terms of the license agreement , puis un clic sur le bouton Finish pour lancer l'installation

Installation en-cours

• Relancer  Eclipse

Amusez-vous bien en utilisant WindowBuilder :)

Read more...

Analyser et traiter des documents XML en Java avec XML Parsing in Java Kit – Plug-in D'Eclipse

XML Parsing in Java Kit (English)

XML Parsing in Java Kit v2.0.0.beta_2i est un logiciel gratuit, diffusé sous la licence GPL

Téléchargez le plug-in ici

Le plug-in est compatible avec Eclipse (3.6 ou supérieure). Il est composé de trois parties :

Cheat sheets (feuilles de triche) :

Un petit tutoriel sur le parsing de document XML (analyse et traitement), avec une description du parser DOM, la validation de documents, l'utilisation de XPath, référence de caractères, les entités prédéfinies, etc. Avec un exemple interactif de l'utilisation des expressions XPath



Visual XPath
Un visualiseur d'expression XPath. Chargez un fichier .xml depuis votre disque dur (un exemple est fourni aussi). Entrez une expression XPath, puis un clic sur évaluer. Les parties concernées dans le document XML sont surlignées.

Templates ou modèles XML
Quelques modèles prêts à l'emploi, dans vos programmes Java, quand vous programmez des fonctionnalités de traitement de documents XML



Installation :

Télécharger le plug-in ici. Décompressez le fichier .zip. Ceci donne un dossier plugins.

Dans ce dossier i l ya deux fichier .jar

1. Fermez Eclipse
2. Copiez les deux fichier .jar du dossier plugins vers le dossier dropins situé sous le dossier d'installation d'Eclipse
3. Relancer Eclipse

Utilisation des cheat sheets

Le menu Help dans Eclipse -> Cheat Sheets

Un clic sur "Kaesar ALNIJRES – XML Parsing in Java"
Sélectionnez  Parsing XML in Java -> OK




Expression XPath – exemple interactif

Dans cet exemple quelques expressions sont prédéfinies permettant de visualiser leurs résultats. Sélectionnez une expression dans la liste, les parties concernées sont surlignées.

Utilisation de Visual XPath

Pour ouvrir l'outil -> un clic sur son icône dans la barre d'outils d'Eclipse



L'utilisation de cet outil est hyper simple. In suffit d'entrer une expression XPath, puis un clic sur évaluer. Si l'expression est une bonne expression XPath, les parties concernées sont surlignées. Il est possible de travailler avec n'importe quel fichier .xml sur votre disque dur. Utilisez pour cela choisir un fichier.



Utilisation de modèles Java (templates)

Dans un fichier .java -> entrez xml -> puis CTRL+Espace -> sélectionnez un modèle

Le modèle sélectionné est inséré dans le code.

Read more...

Les opérations XML en Java partie 1

Ce tutoriel utilise le parser fourni avec le JDK. L'installation d'un autre parser n'est pas nécessaire.

Comment utiliser java pour parcourir un document XML et extraire ses éléments. Comment extraire des attributs, le texte d'un élément, etc.

La structure des documents XML
Un document XML est composé principalement d'éléments et texte.


Les composants essentiels d'un document
1.Header
2.Elément racine
3.Eléments enfants

L'élément racine, peut avoir un ou plusieurs éléments (enfants). Un élément peut contenir un élément enfant ou un texte ou les deux. Un élément peut aussi avoir des attributs

XML Header
<?xml version="1,0" encoding="UTF-8"?>

Prenons comme  example un template Eclipse
L'élément racine ici est <templates> (avec s). Un élément enfant est entre <template> et </template>. Un <template> a des attributs (nom/valeur). Le texte pour un template est son contenu.


<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<templates>
    <template autoinsert="true" context="catchblock_context" deleted="false"     description="Code in new catch blocks" enabled="true"     id="org.eclipse.jdt.ui.text.codetemplates.catchblock" name="catchblock">
    // ${todo} Auto-generated catch block
    ${exception_var}.printStackTrace();</template>
</templates>

Le parser
Un parser est un programme servant à lire, vérifier et extraire les éléments d'un document XML

Les parsers de Java
DOM parser -> lit un document et forme un arbre de ses éléments
SAX parser -> lance des événements Java au passage des éléments XML

Comment ça marche ?
1-Appelez newDocumentBuilder() sur un objet DocumentBuilderFactory pour avoir
  un objet DocumentBuilder.
 
DocumentBuilderFactory     documentBuilderFactory=DocumentBuilderFactory.newInstance();
  DocumentBuilder documentBuilder=documentBuilderFactory.newDocumentBuilder();

2-Passez un objet File (On peut aussi utiliser un URL) à la méthode parse. Cette méthode retourne une réference de Document (Le document XML)

  File file=new File("fileName");
  Document document=documentBuilder.parse(file);

3-Avec la référence Document on peut parcourir les éléments XML
  -Elément racine
  -Elément enfants
  -Contenu et attributs



4-(Racine ou root)
  Element root=document.getDocumentElement();

5-Elément enfants
  //NodeList est une collection de Nodes
    NodeList children = root.getChildNodes();
    for (int i = 0; i < children.getLength(); i++)
    {
      
    Node child = children.item(i);
    //get rid of white spaces
    if(child instanceof Element)
     {
        ...
        ...
     }//~if a child is element
    }//~children

6-Et les attributs
  NamedNodeMap attributes=child.getAttributes();
          
  for(int j=0;j<attributes.getLength();j++)
    {
    Node attribute=attributes.item(j);
    if(!(attribute instanceof Node) )
        continue;
    String attributeName=attribute.getNodeName();
    String attributeValue=attribute.getNodeValue();
              
    }//~attributes

7-Beaucoup d'opérations sont disponibles sur des éléments XML
 Par exemple :
  - Obtenir le nom d'un élément : getTagName()
  - L'attribut d'un node en passant son nom : getAttributeNode(String name)
  - Supprimer un attribut en donnant son nom : removeAttribute(String name)
  Consultez Javadoc

Un petit programme
package com.java_javafx.ka;

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

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.SAXException;

/*
@author Kaesar ALNIJRES
*/

public class Test {
public void test()
{
//parse a file, get root element, children elements and their attributes

try {
    //prepare to read the xml document, by getting a DocumentBuilder
    DocumentBuilderFactory     documentBuilderFactory=DocumentBuilderFactory.newInstance();
    DocumentBuilder      documentBuilder=documentBuilderFactory.newDocumentBuilder();
    File file=new File("put_a_path_to_xml_file");
    Document document=documentBuilder.parse(file);
  
    //get the root element
    Element root=document.getDocumentElement();
  
    //get the root's name
    String string2=root.getTagName();
  
    System.out.println("root "+string2);
  
    //get a list of children
    NodeList children = root.getChildNodes();
    for (int i = 0; i < children.getLength(); i++)
    {
      
        Node child = children.item(i);
        //no white spaces
        if(child instanceof Element)
        {
            //cast a child to Element  
            Element element = (Element) child;
          
            //get the name of the child (element)         
            String childName=element.getTagName();
          
          
            System.out.println("current element "+childName);
            //get the content of the current element
            Text content = (Text) child.getFirstChild();
            String string3=content.getData().trim();
          
          
            System.out.println("content "+string3);
            //Get attributes of the current child
            NamedNodeMap attributes=child.getAttributes();
          
            for(int j=0;j<attributes.getLength();j++)
            {
                Node attribute=attributes.item(j);
                if(!(attribute instanceof Node) )
                    continue;
                String attributeName=attribute.getNodeName();
                String attributeValue=attribute.getNodeValue();
                          
                System.out.println("att "+attributeName+" = "+attributeValue);
            }//~attributes
          
        }//~if a child is element
    }//~children
  
} catch (ParserConfigurationException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} catch (SAXException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
  

}
public static void main(String[] args) {
    Test t=new Test();
    t.test();
}
}

Templates pour Eclipse (Servez-vous)


J'ai préparé quelques instructions XML, sous forme de templates pour Eclipse, vous permettant d'avoir un peu d'automatisme pour travailler avec des fichiers XML. Les templates sont encore en phase Beta (désolé).Je vais mettre les commentaire en Français prochainement.
Pour utiliser ces templates. Un clic sur le menu "Download" du site. Téléchargez le fichier .zip. Décompressez ce fichier.
Importez le fichier xml dans Eclipse. Dans un éditeur java tappez xml -> puis CTRL+ESPACE. Sélectionnez un template pour l'insérer dans le code.

Read more...