configuration d'une appli via fichier xml

Cram TeXeD

16/02/2004 à 14:52

On Mon, 16 Feb 2004 10:53:07 +0100, < Vinz > dit :

/.../

merci de m'apporter vos lumières, histoire de m'éviter de me lancer dans
quelque chose qui s'avèrera inexploitable ;-)

Personnelement j'utilise dom4j et je pense que c'est adapter à ton
cas.

Tu as 2 solutions avec dom4j.
La 1 ère est une lecture classique de fichier XML
------------
import java.io.File;
import java.net.MalformedURLException;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
* @author Marclan
*
*/
public class Temp {

public static void main(String[] args) {
SAXReader reader = new SAXReader();
try {
Document doc = reader.read(new File("./in.xml"));
Element site = doc.getRootElement();
String url = site.attributeValue("URL");
System.out.println("url "+url);
Iterator stepsIt = site.elementIterator("etape");
while ( stepsIt.hasNext()){
Element el = (Element)stepsIt.next();
byStep(el);
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (DocumentException e) {
e.printStackTrace();
}
}

public static void byStep(Element step){
int numStep = Integer.parseInt(step.attributeValue("numero"));
String page = step.elementText("page");
System.out.println(" num "+numStep+" page "+page);
Iterator parmsIt = step.elementIterator("parametre");
while ( parmsIt.hasNext()) {
byParm((Element)parmsIt.next());
}
String okReturn = step.elementText("retourOK");
System.out.println("OK "+okReturn);
}

public static void byParm(Element parm){
String name = parm.elementText("nom");
String value = parm.elementText("valeur");
System.out.println(" "+name+ " = "+value);
}

}
---------------------------

La seconde étape moins connue est la mise en place d'action
- copi- coli -
http://www.dom4j.org/cookbook.html

Introducing dom4j's declarative rule processing
This section will demonstrate the usage of dom4j's rule API by
example. Consider we have the follwing XML document, but that we want
to transform into another XML document, that carring less information.

<?xml version="1.0" encoding="UTF-8" ?>
<Songs>
<song>
<mp3 kbs="128" size="6128">
<id3>
<title>Simon</title>
<artist>Lifehouse</artist>
<album>No Name Face</album>
<year>2000</year>
<genre>Alternative Rock</genre>
<track>6</track>
</id3>
</mp3>
</song>
<song>
<mp3 kbs="128" size="6359">
<id3>
<title>Hands Clean</title>
<artist>Alanis Morrisette</artist>
<album>Under Rug Swept</album>
<year>2002</year>
<genre>Alternative Rock</genre>
<track>3</track>
</id3>
</mp3>
</song>
<song>
<mp3 kbs="256" size="6460">
<id3>
<title>Alive</title>
<artist>Payable On Deatch</artist>
<album>Satellit</album>
<year>2002</year>
<genre>Metal</genre>
<track/>
</id3>
</mp3>
<mp3 kbs="256" size="4203">
<id3>
<title>Crawling In The Dark</title>
<artist>Hoobastank</artist>
<album>Hoobastank (Selftitled)</album>
<year>2002</year>
<genre>Alternative Rock</genre>
<track/>
</id3>
</mp3>
</song>
</Songs>

All common method to transform a Document into another is XSLT. It's
quite powerfull but it is not Java and use another paradigm as OO.
Such a StyleSheet may look like this.

<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:fo="http://www.w3.org/1999/XSL/Format"

<xsl:output method="xml" indent="yes"/>

<xsl:template match="/">
<Song-Titles>
<xsl:apply-templates/>
</Song-Tiltes>
</xsl:template>

<xsl:template match="/Songs/song/mp3">
<Song>
<xsl:apply-template/>
</Song>
</xsl:template>

<xsl:template match="/Songs/song/mp3/title">
<xsl:text> <xsl:value-of select="."/> </xsl:text>
</xsl:template>

</xsl:stylesheet>

This stylesheets filters all song tiltles and creates a xml wrapper
for it. After applying a stylesheet processor on the source and the
stylesheet you will get the following xml document.

<?xml version="1.0" encoding="UTF-8" ?>
<Song-Titles>
<song>Simon</song>
<song>Hands Clean</song>
<song>Alive</song>
<song>Crawling in the Dark</song>
</Song-Titles>

Okay. Know it's time to present a possible solution using dom4j's rule
API. As you will see this API is very compact. So the Classes you have
to write are neighter complex nor extremly hard to understand. We want
to get the same result as your former stylesheet.

import java.io.File;

import org.dom4j.DocumentHelper;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;

import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;

import org.dom4j.rule.Action;
import org.dom4j.rule.Pattern;
import org.dom4j.rule.Stylesheet;
import org.dom4j.rule.Rule;

public class SongFilter {

private Document resultDoc;
private Element songElement;
private Element currentSongElement;
private Stylesheet style;

public SongFilter() {
this.songElement = DocumentHelper.createElement( "song" );
}

public Document filtering(org.dom4j.Document doc) throws Exception
{
Element resultRoot = DocumentHelper.createElement(
"Song-Titles" );
this.resultDoc = DocumentHelper.createDocument( resultRoot );

Rule songElementRule = new Rule();
songElementRule.setPattern( DocumentHelper.createPattern(
"/Songs/song/mp3/id3" ) );
songElementRule.setAction( new SongElementBuilder() );

Rule titleTextNodeFilter = new Rule();
titleTextNodeFilter.setPattern( DocumentHelper.createPattern(
"/Songs/song/mp3/id3/title" ) );
titleTextNodeFilter.setAction( new NodeTextFilter() );

this.style = new Stylesheet();
this.style.addRule( songElementRule );
this.style.addRule( titleTextNodeFilter );

style.run( doc );

return this.resultDoc;
}

private class SongElementBuilder implements Action {
public void run(Node node) throws Exception {
currentSongElement = songElement.createCopy();
resultDoc.getRootElement().add ( currentSongElement );

style.applyTemplates(node);
}
}

private class NodeTextFilter implements Action {
public void run(Node node) throws Exception {
if ( currentSongElement != null )
{
currentSongElement.setText( node.getText() );
}
}
}

}

Define the root element or another container element for the filtered
out information.

Create as many instances of org.dom4j.rule.Rule as needed.

Install for each rule a instance of org.dom4j.rule.Pattern and
org.dom4j.rule.Action . A org.dom4j.rule.Pattern consists of a XPath
Expression, which is used for Node matching.

A org.dom4j.rule.Action defines the process if a matching occured.

Create a instance of org.dom4j.rule.Stylesheet

Start the processing

If you are familar with Java Threads you may encounter similarities
bewetween java.lang.Runnable and org.dom4j.rule.Action from the
perspectiv of usage. Both acting as a kind of plugin or listener. And
yes this Observer Pattern has a wide usage in the OO and especially in
Java. We implemented them here as private inner classes. You may
decide to decleare them as outter classes as well. If you do that, it
gains more complex because you need the proper instance of
org.dom4j.rule.StyleSheet shared.

Moreover it's possible to create a anonymous inner class for
org.dom4j.rule.Action interface. Some wondering if the seen a
anonymous inner class applied on a interface frist. Don't worry about
that. A Java compiler generates a innner class thats implements the
interface an you are able to use that. Most Swing programmers sould be
familar with that features.

8:0) Cram TeXeD
- en espérant que ca t'aide -
--
"On ne peut pas ne pas communiquer"
axiome n°1 de Paul Watzlawick
<http://texed75.free.fr>

On Mon, 16 Feb 2004 10:53:07 +0100, < Vinz > dit :

/.../

merci de m'apporter vos lumières, histoire de m'éviter de me lancer dans
quelque chose qui s'avèrera inexploitable ;-)

Personnelement j'utilise dom4j et je pense que c'est adapter à ton
cas.

Tu as 2 solutions avec dom4j.
La 1 ère est une lecture classique de fichier XML
------------
import java.io.File;
import java.net.MalformedURLException;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
* @author Marclan
*
*/
public class Temp {

public static void main(String[] args) {
SAXReader reader = new SAXReader();
try {
Document doc = reader.read(new File("./in.xml"));
Element site = doc.getRootElement();
String url = site.attributeValue("URL");
System.out.println("url "+url);
Iterator stepsIt = site.elementIterator("etape");
while ( stepsIt.hasNext()){
Element el = (Element)stepsIt.next();
byStep(el);
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (DocumentException e) {
e.printStackTrace();
}
}

public static void byStep(Element step){
int numStep = Integer.parseInt(step.attributeValue("numero"));
String page = step.elementText("page");
System.out.println(" num "+numStep+" page "+page);
Iterator parmsIt = step.elementIterator("parametre");
while ( parmsIt.hasNext()) {
byParm((Element)parmsIt.next());
}
String okReturn = step.elementText("retourOK");
System.out.println("OK "+okReturn);
}

public static void byParm(Element parm){
String name = parm.elementText("nom");
String value = parm.elementText("valeur");
System.out.println(" "+name+ " = "+value);
}

}
---------------------------

La seconde étape moins connue est la mise en place d'action
- copi- coli -
http://www.dom4j.org/cookbook.html

Introducing dom4j's declarative rule processing
This section will demonstrate the usage of dom4j's rule API by
example. Consider we have the follwing XML document, but that we want
to transform into another XML document, that carring less information.

<?xml version="1.0" encoding="UTF-8" ?>
<Songs>
<song>
<mp3 kbs="128" size="6128">
<id3>
<title>Simon</title>
<artist>Lifehouse</artist>
<album>No Name Face</album>
<year>2000</year>
<genre>Alternative Rock</genre>
<track>6</track>
</id3>
</mp3>
</song>
<song>
<mp3 kbs="128" size="6359">
<id3>
<title>Hands Clean</title>
<artist>Alanis Morrisette</artist>
<album>Under Rug Swept</album>
<year>2002</year>
<genre>Alternative Rock</genre>
<track>3</track>
</id3>
</mp3>
</song>
<song>
<mp3 kbs="256" size="6460">
<id3>
<title>Alive</title>
<artist>Payable On Deatch</artist>
<album>Satellit</album>
<year>2002</year>
<genre>Metal</genre>
<track/>
</id3>
</mp3>
<mp3 kbs="256" size="4203">
<id3>
<title>Crawling In The Dark</title>
<artist>Hoobastank</artist>
<album>Hoobastank (Selftitled)</album>
<year>2002</year>
<genre>Alternative Rock</genre>
<track/>
</id3>
</mp3>
</song>
</Songs>

All common method to transform a Document into another is XSLT. It's
quite powerfull but it is not Java and use another paradigm as OO.
Such a StyleSheet may look like this.

<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:fo="http://www.w3.org/1999/XSL/Format"

<xsl:output method="xml" indent="yes"/>

<xsl:template match="/">
<Song-Titles>
<xsl:apply-templates/>
</Song-Tiltes>
</xsl:template>

<xsl:template match="/Songs/song/mp3">
<Song>
<xsl:apply-template/>
</Song>
</xsl:template>

<xsl:template match="/Songs/song/mp3/title">
<xsl:text> <xsl:value-of select="."/> </xsl:text>
</xsl:template>

</xsl:stylesheet>

This stylesheets filters all song tiltles and creates a xml wrapper
for it. After applying a stylesheet processor on the source and the
stylesheet you will get the following xml document.

<?xml version="1.0" encoding="UTF-8" ?>
<Song-Titles>
<song>Simon</song>
<song>Hands Clean</song>
<song>Alive</song>
<song>Crawling in the Dark</song>
</Song-Titles>

Okay. Know it's time to present a possible solution using dom4j's rule
API. As you will see this API is very compact. So the Classes you have
to write are neighter complex nor extremly hard to understand. We want
to get the same result as your former stylesheet.

import java.io.File;

import org.dom4j.DocumentHelper;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;

import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;

import org.dom4j.rule.Action;
import org.dom4j.rule.Pattern;
import org.dom4j.rule.Stylesheet;
import org.dom4j.rule.Rule;

public class SongFilter {

private Document resultDoc;
private Element songElement;
private Element currentSongElement;
private Stylesheet style;

public SongFilter() {
this.songElement = DocumentHelper.createElement( "song" );
}

public Document filtering(org.dom4j.Document doc) throws Exception
{
Element resultRoot = DocumentHelper.createElement(
"Song-Titles" );
this.resultDoc = DocumentHelper.createDocument( resultRoot );

Rule songElementRule = new Rule();
songElementRule.setPattern( DocumentHelper.createPattern(
"/Songs/song/mp3/id3" ) );
songElementRule.setAction( new SongElementBuilder() );

Rule titleTextNodeFilter = new Rule();
titleTextNodeFilter.setPattern( DocumentHelper.createPattern(
"/Songs/song/mp3/id3/title" ) );
titleTextNodeFilter.setAction( new NodeTextFilter() );

this.style = new Stylesheet();
this.style.addRule( songElementRule );
this.style.addRule( titleTextNodeFilter );

style.run( doc );

return this.resultDoc;
}

private class SongElementBuilder implements Action {
public void run(Node node) throws Exception {
currentSongElement = songElement.createCopy();
resultDoc.getRootElement().add ( currentSongElement );

style.applyTemplates(node);
}
}

private class NodeTextFilter implements Action {
public void run(Node node) throws Exception {
if ( currentSongElement != null )
{
currentSongElement.setText( node.getText() );
}
}
}

}

Define the root element or another container element for the filtered
out information.

Create as many instances of org.dom4j.rule.Rule as needed.

Install for each rule a instance of org.dom4j.rule.Pattern and
org.dom4j.rule.Action . A org.dom4j.rule.Pattern consists of a XPath
Expression, which is used for Node matching.

A org.dom4j.rule.Action defines the process if a matching occured.

Create a instance of org.dom4j.rule.Stylesheet

Start the processing

If you are familar with Java Threads you may encounter similarities
bewetween java.lang.Runnable and org.dom4j.rule.Action from the
perspectiv of usage. Both acting as a kind of plugin or listener. And
yes this Observer Pattern has a wide usage in the OO and especially in
Java. We implemented them here as private inner classes. You may
decide to decleare them as outter classes as well. If you do that, it
gains more complex because you need the proper instance of
org.dom4j.rule.StyleSheet shared.

Moreover it's possible to create a anonymous inner class for
org.dom4j.rule.Action interface. Some wondering if the seen a
anonymous inner class applied on a interface frist. Don't worry about
that. A Java compiler generates a innner class thats implements the
interface an you are able to use that. Most Swing programmers sould be
familar with that features.

8:0) Cram TeXeD
- en espérant que ca t'aide -
--
"On ne peut pas ne pas communiquer"
axiome n°1 de Paul Watzlawick
<http://texed75.free.fr>

Vous avez filtré cet utilisateur ! Consultez son message

On Mon, 16 Feb 2004 10:53:07 +0100, < Vinz > dit :

/.../

merci de m'apporter vos lumières, histoire de m'éviter de me lancer dans
quelque chose qui s'avèrera inexploitable ;-)

Personnelement j'utilise dom4j et je pense que c'est adapter à ton
cas.

Tu as 2 solutions avec dom4j.
La 1 ère est une lecture classique de fichier XML
------------
import java.io.File;
import java.net.MalformedURLException;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
* @author Marclan
*
*/
public class Temp {

public static void main(String[] args) {
SAXReader reader = new SAXReader();
try {
Document doc = reader.read(new File("./in.xml"));
Element site = doc.getRootElement();
String url = site.attributeValue("URL");
System.out.println("url "+url);
Iterator stepsIt = site.elementIterator("etape");
while ( stepsIt.hasNext()){
Element el = (Element)stepsIt.next();
byStep(el);
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (DocumentException e) {
e.printStackTrace();
}
}

public static void byStep(Element step){
int numStep = Integer.parseInt(step.attributeValue("numero"));
String page = step.elementText("page");
System.out.println(" num "+numStep+" page "+page);
Iterator parmsIt = step.elementIterator("parametre");
while ( parmsIt.hasNext()) {
byParm((Element)parmsIt.next());
}
String okReturn = step.elementText("retourOK");
System.out.println("OK "+okReturn);
}

public static void byParm(Element parm){
String name = parm.elementText("nom");
String value = parm.elementText("valeur");
System.out.println(" "+name+ " = "+value);
}

}
---------------------------

La seconde étape moins connue est la mise en place d'action
- copi- coli -
http://www.dom4j.org/cookbook.html

Introducing dom4j's declarative rule processing
This section will demonstrate the usage of dom4j's rule API by
example. Consider we have the follwing XML document, but that we want
to transform into another XML document, that carring less information.

<?xml version="1.0" encoding="UTF-8" ?>
<Songs>
<song>
<mp3 kbs="128" size="6128">
<id3>
<title>Simon</title>
<artist>Lifehouse</artist>
<album>No Name Face</album>
<year>2000</year>
<genre>Alternative Rock</genre>
<track>6</track>
</id3>
</mp3>
</song>
<song>
<mp3 kbs="128" size="6359">
<id3>
<title>Hands Clean</title>
<artist>Alanis Morrisette</artist>
<album>Under Rug Swept</album>
<year>2002</year>
<genre>Alternative Rock</genre>
<track>3</track>
</id3>
</mp3>
</song>
<song>
<mp3 kbs="256" size="6460">
<id3>
<title>Alive</title>
<artist>Payable On Deatch</artist>
<album>Satellit</album>
<year>2002</year>
<genre>Metal</genre>
<track/>
</id3>
</mp3>
<mp3 kbs="256" size="4203">
<id3>
<title>Crawling In The Dark</title>
<artist>Hoobastank</artist>
<album>Hoobastank (Selftitled)</album>
<year>2002</year>
<genre>Alternative Rock</genre>
<track/>
</id3>
</mp3>
</song>
</Songs>

All common method to transform a Document into another is XSLT. It's
quite powerfull but it is not Java and use another paradigm as OO.
Such a StyleSheet may look like this.

<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:fo="http://www.w3.org/1999/XSL/Format"

<xsl:output method="xml" indent="yes"/>

<xsl:template match="/">
<Song-Titles>
<xsl:apply-templates/>
</Song-Tiltes>
</xsl:template>

<xsl:template match="/Songs/song/mp3">
<Song>
<xsl:apply-template/>
</Song>
</xsl:template>

<xsl:template match="/Songs/song/mp3/title">
<xsl:text> <xsl:value-of select="."/> </xsl:text>
</xsl:template>

</xsl:stylesheet>

This stylesheets filters all song tiltles and creates a xml wrapper
for it. After applying a stylesheet processor on the source and the
stylesheet you will get the following xml document.

<?xml version="1.0" encoding="UTF-8" ?>
<Song-Titles>
<song>Simon</song>
<song>Hands Clean</song>
<song>Alive</song>
<song>Crawling in the Dark</song>
</Song-Titles>

Okay. Know it's time to present a possible solution using dom4j's rule
API. As you will see this API is very compact. So the Classes you have
to write are neighter complex nor extremly hard to understand. We want
to get the same result as your former stylesheet.

import java.io.File;

import org.dom4j.DocumentHelper;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;

import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.io.OutputFormat;

import org.dom4j.rule.Action;
import org.dom4j.rule.Pattern;
import org.dom4j.rule.Stylesheet;
import org.dom4j.rule.Rule;

public class SongFilter {

private Document resultDoc;
private Element songElement;
private Element currentSongElement;
private Stylesheet style;

public SongFilter() {
this.songElement = DocumentHelper.createElement( "song" );
}

public Document filtering(org.dom4j.Document doc) throws Exception
{
Element resultRoot = DocumentHelper.createElement(
"Song-Titles" );
this.resultDoc = DocumentHelper.createDocument( resultRoot );

Rule songElementRule = new Rule();
songElementRule.setPattern( DocumentHelper.createPattern(
"/Songs/song/mp3/id3" ) );
songElementRule.setAction( new SongElementBuilder() );

Rule titleTextNodeFilter = new Rule();
titleTextNodeFilter.setPattern( DocumentHelper.createPattern(
"/Songs/song/mp3/id3/title" ) );
titleTextNodeFilter.setAction( new NodeTextFilter() );

this.style = new Stylesheet();
this.style.addRule( songElementRule );
this.style.addRule( titleTextNodeFilter );

style.run( doc );

return this.resultDoc;
}

private class SongElementBuilder implements Action {
public void run(Node node) throws Exception {
currentSongElement = songElement.createCopy();
resultDoc.getRootElement().add ( currentSongElement );

style.applyTemplates(node);
}
}

private class NodeTextFilter implements Action {
public void run(Node node) throws Exception {
if ( currentSongElement != null )
{
currentSongElement.setText( node.getText() );
}
}
}

}

Define the root element or another container element for the filtered
out information.

Create as many instances of org.dom4j.rule.Rule as needed.

Install for each rule a instance of org.dom4j.rule.Pattern and
org.dom4j.rule.Action . A org.dom4j.rule.Pattern consists of a XPath
Expression, which is used for Node matching.

A org.dom4j.rule.Action defines the process if a matching occured.

Create a instance of org.dom4j.rule.Stylesheet

Start the processing

If you are familar with Java Threads you may encounter similarities
bewetween java.lang.Runnable and org.dom4j.rule.Action from the
perspectiv of usage. Both acting as a kind of plugin or listener. And
yes this Observer Pattern has a wide usage in the OO and especially in
Java. We implemented them here as private inner classes. You may
decide to decleare them as outter classes as well. If you do that, it
gains more complex because you need the proper instance of
org.dom4j.rule.StyleSheet shared.

Moreover it's possible to create a anonymous inner class for
org.dom4j.rule.Action interface. Some wondering if the seen a
anonymous inner class applied on a interface frist. Don't worry about
that. A Java compiler generates a innner class thats implements the
interface an you are able to use that. Most Swing programmers sould be
familar with that features.

8:0) Cram TeXeD
- en espérant que ca t'aide -
--
"On ne peut pas ne pas communiquer"
axiome n°1 de Paul Watzlawick
<http://texed75.free.fr>

Thomas Cornet

16/02/2004 à 16:07

Perso, j'utiliserai Digester
(http://jakarta.apache.org/commons/digester/index.html), une API java dont
le but principal est de transformer un fichier XML en une hiérarchie de
classes.

Thomas

Bonjour,

Je suis en train de développer ma première application en java : le but est
d'aller interroger différents serveur web, en leur passant des paramètres,
et d'analyser ce qu'ils me retourne. Chaque serveur web étant différent et
susceptible d'être modifié, je pensais utiliser un fichier xml pour stocker
la configuration de chacun. Le fichier pourrait ressembler à cela, sachant,
qu'il y a plusieurs sites, avec plusieurs étapes par site, etc.

<site URL="www.monserveur.com">
<etape numero="1">
<page>premierePage.cgi</page>

<parametre>
<nom>email</nom>
<valeur></valeur>
</parametre>
<parametre>
<nom>prenom</nom>
<valeur>vincent</valeur>
</parametre>

<retourOK>chaine renvoyee par le site, validant la prise en compte de
la demande</retourOK>
</etape>
</site>

J'utilise des classes trouvées sur Internet pour me connecter aux sites et
parser l'html renvoyé. Ma question concerne l'interfaçage de Java avec ce
fichier de configuration : j'ai vu qu'il existait pas mal d'API pour parser
l'xml, mais je ne sais pas laquelle est la plus adaptée pour mon besoin. En
fait, chaque site correspondra à un thread, pour que je puisse interroger
les serveurs en parallèle. Je ne sais pas non plus si ces API me permettront
d'initialiser mes objets facilement, sans mélanger les étapes.

merci de m'apporter vos lumières, histoire de m'éviter de me lancer dans
quelque chose qui s'avèrera inexploitable ;-)

Vinz

16/02/2004 à 16:24

à voir la description, ça a l'air pas mal du tout !!! merci, je vais essayer
ça !!

"Thomas Cornet" a écrit dans le message de
news:cs9njakrhrd$

Perso, j'utiliserai Digester
(http://jakarta.apache.org/commons/digester/index.html), une API java dont
le but principal est de transformer un fichier XML en une hiérarchie de
classes.

Thomas

Bonjour,

Je suis en train de développer ma première application en java : le but
est

d'aller interroger différents serveur web, en leur passant des
paramètres,

et d'analyser ce qu'ils me retourne. Chaque serveur web étant différent
et

susceptible d'être modifié, je pensais utiliser un fichier xml pour
stocker

la configuration de chacun. Le fichier pourrait ressembler à cela,
sachant,

qu'il y a plusieurs sites, avec plusieurs étapes par site, etc.

<site URL="www.monserveur.com">
<etape numero="1">
<page>premierePage.cgi</page>

<parametre>
<nom>email</nom>
<valeur></valeur>
</parametre>
<parametre>
<nom>prenom</nom>
<valeur>vincent</valeur>
</parametre>

<retourOK>chaine renvoyee par le site, validant la prise en
compte de

la demande</retourOK>
</etape>
</site>

J'utilise des classes trouvées sur Internet pour me connecter aux sites
et

parser l'html renvoyé. Ma question concerne l'interfaçage de Java avec
ce

fichier de configuration : j'ai vu qu'il existait pas mal d'API pour
parser

l'xml, mais je ne sais pas laquelle est la plus adaptée pour mon besoin.
En

fait, chaque site correspondra à un thread, pour que je puisse
interroger

les serveurs en parallèle. Je ne sais pas non plus si ces API me
permettront

d'initialiser mes objets facilement, sans mélanger les étapes.

merci de m'apporter vos lumières, histoire de m'éviter de me lancer dans
quelque chose qui s'avèrera inexploitable ;-)

configuration d'une appli via fichier xml

3 réponses

Veuillez sélectionner un problème