Newsgroup: it.comp.java
Titolo: Java e XML

Leggendo alcuni post su questo newsgroup ho visto che molti di voi 
utilizzano XML per salvare le costanti di una applicazione Java.
Vorrei sapere come fate a leggere queste costanti dal file XML e, in 
particolare, quali classi e quali metodi entrano in gioco per la lettura 
di queste costanti.
Ho cercato su google ed ho visto molti tutorial, ma ho notato che molti 
di questi leggono il file xml come un semplice file di testo cercando i 
valori inseriti dentro i tag...
Ma se il procedimento č questo non č piů semplice usare la classe 
java.util.Propreties evitando il file XML sostituendolo con un semplice 
file di testo tipo "key=valore"?
In un primo momento pensavo che avendo un file xml di questo tipo:
<?xml version="1.0"?>
<tag>Prova</tag>
Esistesse una classe in java tale che si posse fare il seguente 
procedimento:
ClassePerLaLetturaDiXML xml = new ClassePerLaLetturaDiXML();
xml.leggiFile(fileXML);
xml.getValue("tag"); // Mi restituisce "Prova"
Esiste qualche cosa di simile o no?
Grazie!
-- 
Marco "Duff" Palermo
http://www.marcoduff.com/

 Ma se il procedimento è questo non è più semplice usare la classe


POSTA pure che l'argomento mi interessa molto!
Graaaaaaazie
"¤ Ivan ¤" <flaggell...@VEtiscali.it> wrote in message
news:OIlvb.135604$e6.48...@twister2.libero.it...


 Graaaaaaazie

-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 Grazie!
Prego :-)
G.M.

 Se ti interessa ti posto qualcosina via mail...
Visto che interessa a tutti postalo nel NG!
Se poi è troppo grosso usa marcoduff (at) 
libero.it


Probabilmente le indentazioni vanno a quel paese...
L'esempio č semplice con XML ad un solo livello ma da ciň si capisce
tutto...
Poi su 
xerces.apache.org
 ci sono delle api con cui poter gestire anche file
piů complessi per problemi di copyright aziendali non posso postare di + ma
le cose dovrebbero essere chiare almeno nel approccio al problema...
Ciao Ivan
PS il beanProperty a cui faccio riferimento č facilmente ricostuibile....
package it.pippo.pluto;
import java.io.File;
import java.io.FileWriter;
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.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import org.apache.xerces.dom.DocumentImpl;
import org.apache.xml.serialize.XMLSerializer;
import org.apache.xml.serialize.OutputFormat;
/**
 * DOCUMENT ME!
 *
 * @author $author$
 * @version $Revision$
 */
public class Property {
 private String       filePath = "proprieta.xml";
 private PropertyBean propertyBean = new PropertyBean(  );
 private final String remoteUser = "";
 private final String remotePwd = "";
 private final String webservice = "nameService";
 private final String port = "8080";
 private final String ServerURL = "
http://192.168.1.2
";
 private final String enti = "";
 private final String articoli = "";
 private final String installDir = "";
 /**
  * Creates a new Property object.
  */
 public Property (  ) {
 }
 /**
  * Creates a new Property object.
  *
  * @param filePath DOCUMENT ME!
  */
 public Property ( String filePath ) {
  this.filePath = filePath;
 }
 /**
  * DOCUMENT ME!
  *
  * @return DOCUMENT ME!
  */
 public PropertyBean getProperty (  ) {
  DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance (  );
  try {
   DocumentBuilder builder = factory.newDocumentBuilder (  );
   Document        doc = builder.parse ( filePath );
   Element         root = doc.getDocumentElement (  );
   NodeList        children = root.getChildNodes (  );
   int             size = children.getLength (  );
   Node         child = null;
   String          nodeName = null;
   for ( int i = 0; i < size; i++ ) {
    child = children.item ( i );
    if ( child instanceof Element && child.hasChildNodes (  ) ) {
     nodeName = child.getNodeName (  );
     if ( nodeName.equals ( "username" ) ) {
      propertyBean.setUserName ( child.getFirstChild (  ).getNodeValue
(  ) );
     } else if ( nodeName.equals ( "password" ) ) {
      propertyBean.setPassword ( child.getFirstChild (  ).getNodeValue
(  ) );
     } else if ( nodeName.equals ( "remoteuser" ) ) {
      propertyBean.setRemoteUser ( child.getFirstChild (  ).getNodeValue
(  ) );
     } else if ( nodeName.equals ( "remotepassword" ) ) {
      propertyBean.setRemotePsw ( child.getFirstChild (  ).getNodeValue
(  ) );
     } else if ( nodeName.equals ( "logfile" ) ) {
      propertyBean.setLogFile ( child.getFirstChild (  ).getNodeValue
(  ) );
     } else if ( nodeName.equals ( "webservice" ) ) {
      propertyBean.setWebService ( child.getFirstChild (  ).getNodeValue
(  ) );
     } else if ( nodeName.equals ( "port" ) ) {
      propertyBean.setPort ( child.getFirstChild (  ).getNodeValue (  ) );
     } else if ( nodeName.equals ( "ServerURL" ) ) {
      propertyBean.setServerURL( child.getFirstChild (  ).getNodeValue
(  ) );
     } else if ( nodeName.equals ( "enti" ) ) {
      propertyBean.setEnti ( child.getFirstChild (  ).getNodeValue (  ) );
     } else if ( nodeName.equals ( "articoli" ) ) {
      propertyBean.setArticoli ( child.getFirstChild (  ).getNodeValue
(  ) );
     } else if ( nodeName.equals ( "installDir" ) ) {
      propertyBean.setInstallDir( child.getFirstChild (  ).getNodeValue
(  ) );
     }
    }
   }
  } catch ( ParserConfigurationException e ) {
   propertyBean = createDefaultPropertyFile (  );
   e.printStackTrace (  );
  } catch ( IOException e ) {
   propertyBean = createDefaultPropertyFile (  );
   System.out.println ( "Creazione del file di proprieta di default");
  } catch ( SAXException e ) {
   propertyBean = createDefaultPropertyFile (  );
   e.printStackTrace (  );
  } finally {
   return propertyBean;
  }
 }
 /**
  * DOCUMENT ME!
  *
  * @param propertyBean DOCUMENT ME!
  */
 public void setProperty ( PropertyBean propertyBean ) {
  Document doc = new DocumentImpl(  );
  Element  root = doc.createElement ( "property" );
  Element  username = doc.createElement ( "username" );
  Element  password = doc.createElement ( "password" );
  Element  remoteuser = doc.createElement ( "remoteuser" );
  Element  remotepsw = doc.createElement ( "remotepassword" );
  Element  logfile = doc.createElement ( "logfile" );
  Element  webservice = doc.createElement ( "webservice" );
  Element  port = doc.createElement ( "port" );
  Element  ServerURL = doc.createElement ( "ServerURL" );
  Element  enti = doc.createElement ( "enti" );
  Element  articoli = doc.createElement ( "articoli" );
  Element  installDir = doc.createElement ( "installDir" );
  username.appendChild ( doc.createTextNode ( propertyBean.getUserName
(  ) ) );
  password.appendChild ( doc.createTextNode ( propertyBean.getPassword
(  ) ) );
  remoteuser.appendChild ( doc.createTextNode ( propertyBean.getRemoteUser
(  ) ) );
  remotepsw.appendChild ( doc.createTextNode ( propertyBean.getRemotePsw
(  ) ) );
  logfile.appendChild ( doc.createTextNode ( propertyBean.getLogFile
(  ) ) );
  webservice.appendChild ( doc.createTextNode ( propertyBean.getWebService
(  ) ) );
  port.appendChild ( doc.createTextNode ( propertyBean.getPort (  ) ) );
  ServerURL.appendChild ( doc.createTextNode ( propertyBean.getServerURL
(  ) ) );
  enti.appendChild ( doc.createTextNode ( propertyBean.getEnti (  ) ) );
  articoli.appendChild ( doc.createTextNode ( propertyBean.getArticoli
(  ) ) );
  installDir.appendChild ( doc.createTextNode (
propertyBean.getInstallDir(  ) ) );
  root.appendChild ( username );
  root.appendChild ( password );
  root.appendChild ( remoteuser );
  root.appendChild ( remotepsw );
  root.appendChild ( logfile );
  root.appendChild ( webservice );
  root.appendChild ( port );
  root.appendChild ( ServerURL );
  root.appendChild ( enti );
  root.appendChild ( articoli );
  root.appendChild ( installDir );
  doc.appendChild ( root );
  OutputFormat format = new OutputFormat( doc ); //Serialize DOM
  format.setIndenting( true );
  File         file = new File( "proprieta.xml" );
  try {
   XMLSerializer serial = new XMLSerializer( new FileWriter( file ),
format );
   serial.asDOMSerializer (  );
   serial.serialize ( doc.getDocumentElement (  ) );
  } catch ( IOException e ) {
   e.printStackTrace (  );
  }
 }
 /**
  * DOCUMENT ME!
  *
  * @return DOCUMENT ME!
  */
 public PropertyBean createDefaultPropertyFile (  ) {
  propertyBean.setLogFile ( "log/cat.log" );
  propertyBean.setRemoteUser ( remoteUser );
  propertyBean.setRemotePsw ( remotePwd );
  propertyBean.setWebService ( webservice );
  propertyBean.setPort ( port );
  propertyBean.setServerURL ( ServerURL );
  propertyBean.setEnti ( enti );
  propertyBean.setArticoli ( articoli );
  propertyBean.setInstallDir( System.getProperty("user.dir") );
  setProperty ( propertyBean );
  return propertyBean;
 }
}

 package it.pippo.pluto;
[STRACUT!!!!]
Mi sono fermato a leggere qui!
Cacchio! Certo che usare la Propreties č MOLTO meglio!
Ancora non riesco a capire che cavolo ci hanno messo a fare i package 
*.xml.* in java, visto che per leggere uno stupidissimo file xml di un 
solo livello ci vuole tutto questo papello di codice!


 solo livello ci vuole tutto questo papello di codice!
Personalmente io preferisco usare la libreria JDOM.
www.jdom.org
E' una libreria scritta sopra la pur molto piů valida Xerces.
Rappresenta un'architettura a mio parere molto piů
vicina al modello ad oggetti di JAVA ed č molto piů
immediata da utilizzare.
Certo č che per ora sono rimasto a livello progettuale
molto sullo standard.
Forse quando si comincia a parlare di references XML
o altre cosine piů complicate Jdom puň presentare dei limiti.
Luca Paganelli

 SW ed inoltre IMHO danno una visione + immediata dei paramentri...
Su questo non sono d'accordo...
Un file proprietis e' il più portabile in assoluto! Semplice txt con 
esclusivamente l'utilizzo degli operatori =,#
Quello che va a favore di XML e' che e' uno Standard Ufficiale.


 Quello che va a favore di XML e' che e' uno Standard Ufficiale.
Si il mio discorso voleva parare prorpio su questo "Standard Ufficiale"...

 modo di vedere...
Allora e' sicuramente un errore di valutazione mio...
Faccio XML da *_troppo_* poco e quindi per il momento mi trovo d'avanti 
piccoli file di esempio (catalogo di libri o cd...)
In effetti, adesso che penso ad XML "in grande" devo darti pienamente 
ragione... Andare con "TagByName" e' una pazzia!
