Analyseur xml générique et programmation refléxive

Soyez le premier à donner votre avis sur cette source.

Vue 8 839 fois - Téléchargée 525 fois

Description

Le problème était le suivant.
Pour une application, j'ai eu besoin d'un analyseur xml capable de lire trois types de fichiers contenant :

- un noyau d'informations similaires
- des informations spécifiques à chaque fichier

Début de réponse :

Faire trois classes dont deux dérivent de celle qui définit le noyau commun d'information, afin de bénéficier d'un groupe de fonctionnalités initiales

Deux solutions :

- créer trois classes et les trois analyseurs correspondants
- créer trois classes et un seul analyseur capable d'analyser les trois types de flux.

La première solution est simple mais implique des redondances de code inutiles.
La seconde solution supprime ces redondances.
Mais comment permettre à un seul analyseur de lire trois types de flux et d'associer les informations lues avec leur classes respectives avec un minimum de code, le tout en restant ouvert à de futures extensions (une quatrième classe de fichier par exemple) ?

La réponse :

- programmation générique : permet de supprimer les redondances de code.
- programmation reflexive : permet de synthétiser l'analyse et d'integrer de nouvelles classes à analyser plus facilement.

Le résultat est un analyseur xml générique bénéficiant des capacités de la programmation reflexive.

L'exemple ici utilise trois classes :

Person : une personne (nom, prenom, date de naissance)
Employee : une personne avec un emploi (fonction, salaire)
Client : une personne avec un compte client (nom du compte et date de création)

Il y a juste un problème, mais dont j'ignore la source. Eclipse ne semble pas comprendre les transtypages sur les types génériques et il rajoute des warnings sur chacune de ces opérations.
D'où les directives SuppressWarnings.
Si quelqu'un sait où est le problème, je le remercie d'avance.

Source / Exemple :


package MultiParser;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.NoSuchElementException;
import java.util.Vector;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.XMLReaderFactory;

/**

  • Xml multiobject file parser for Person, Employee, Client class
  • <br><br>Can parse three file structures:
  • <ol>
  • <li>Person file, which contains a list of Person
  • <li>Employee file, which contains a list of Employee
  • <li>Client file, a list of Client
  • </ol>
  • @author AlexN
*
  • /
public class XmlMultiParser extends DefaultHandler { public enum ParsingMethod { PERSON, EMPLOYEE, CLIENT }; private enum NameFormat { LOWERCASE, FIRSTCAPITAL } private ParsingMethod method; // parsing method to use : person, employee or client private String filename; // name of file to use private FileInputStream stream; // stream associated to filename private Vector<? extends Person> results; // results container private String value; // characters container private Action action; // reference to action for each tag /**
  • default Constructor
  • @param filename
  • @param method
  • /
public XmlMultiParser(String filename, ParsingMethod method) { setSource(filename, method); } /**
  • Change source filename and parsing method of parser
  • @param filename
  • @param method
  • /
public void setSource(String filename, ParsingMethod method) { try{ this.filename = filename; this.method = method; stream = new FileInputStream(new File(filename)); } catch(FileNotFoundException e){ System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " file not found : " + filename); } } /**
  • Check for a valid stream
  • @return
  • /
public Boolean fileExists() { return stream != null; } /**
  • get current parsing method
  • @return
  • /
public ParsingMethod getMethod() { return method; } /**
  • get name of parsing method using format for String response
  • @param method
  • @param format
  • @return
  • /
public static String getMethodName(ParsingMethod method, NameFormat format) { String name = method == ParsingMethod.PERSON ? "Person" : method == ParsingMethod.EMPLOYEE ? "Employee" : "Client"; return format == NameFormat.LOWERCASE ? name.toLowerCase() : name; } /**
  • get name of current parsing method using format for String response
  • @param format
  • @return
  • /
public String getMethodName(NameFormat format) { return getMethodName(method, format); } /**
  • add a new response object to results list
  • @return
  • /
@SuppressWarnings("unchecked") private void addResult() { switch (method) { case PERSON: ((Vector<Person>)results).add(new Person()); break; case EMPLOYEE: ((Vector<Employee>)results).add(new Employee()); break; case CLIENT: ((Vector<Person>)results).add(new Client()); break; } } /**
  • parse the current stream using current method
  • @return
  • /
public Vector<? extends Person> parse () { switch (method) { case PERSON : results = new Vector<Person>(); break; case EMPLOYEE : results = new Vector<Employee>(); break; case CLIENT : results = new Vector<Client>(); break; } if (stream != null) try { XMLReader xr = XMLReaderFactory.createXMLReader(); xr.setContentHandler(this); xr.setErrorHandler(this); xr.parse(new InputSource(stream)); } catch (SAXException se) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " SAXException in file '" + filename + "' : " + se.getLocalizedMessage()); } catch (IOException ie) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " IOException in file '" + filename + "' : " + ie.getLocalizedMessage()); } if (results.size() == 0) addResult(); return results; } // Event Handlers /**
  • Called event when a start tag has been parsed
  • clear character container
  • add a new object to results list when parsed tag is appropriate
  • /
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { value = ""; // reset characters receiver if ((method == ParsingMethod.PERSON && qName.equalsIgnoreCase("person")) || (method == ParsingMethod.EMPLOYEE && qName.equalsIgnoreCase("employee")) || (method == ParsingMethod.CLIENT && qName.equalsIgnoreCase("client"))) addResult(); } /**
  • Called event when enclosed tag characters has been parsed
  • Fill characters container
  • /
public void characters(char[] ch, int start, int length) throws SAXException { value = new String(ch,start,length); } /**
  • Called event when a end tag has been parsed
  • Fill appropriate result property
  • /
@SuppressWarnings("unchecked") public void endElement(String uri, String localName, String qName) { // try to find object action associated to tag name // if not find try to find qName in allowed tag for object try { if ((action = (Action) Action.ACTIONS.get(qName)) == null) { Boolean FoundAllowedTag = false; Vector<String> allowedTags = Action.TAGS.get(method); for (String tag : allowedTags) if (tag.equalsIgnoreCase(qName)) { FoundAllowedTag = true; break; } if (!FoundAllowedTag) System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " unknown tagname : " + qName + " (ignoring this tag)"); return; } // find method to apply for last results element related to action Method methodClass = action.getType().getDeclaredMethod(action.getName(), action.getClasses()); // parse argument of setter Object argument = parseArgument(value, action, qName); // apply action with argument to last results element if (methodClass != null && argument != null) methodClass.invoke(results.lastElement(), new Object[] {argument} ); } catch (SecurityException e) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " security exception for " + qName + " tag"); } catch (NoSuchMethodException e) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " invalid tag " + qName + " " + results.lastElement().getClass()); } catch (NoSuchElementException e) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " invalid element " + qName); } catch (IllegalArgumentException e) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " invalid agument '"+value+"' for " + qName + " tag"); } catch (IllegalAccessException e) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " illegal access for " + qName + " tag"); } catch (InvocationTargetException e) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " invocation target exception for " + qName + " tag"); } } /**
  • parse argument of setter
  • @param value
  • @param action
  • @param qName
  • @return
  • /
private Object parseArgument (String value, Action action, String qName) { Object argument = null; if (action.getClasses().length > 0) // String argument, nothing to do if (action.getClasses()[0] == String.class) argument = value; // Boolean argument else if (action.getClasses()[0] == Boolean.class) { if ((argument = parseBoolean()) != BOOLEAN.ERROR) argument = ((BOOLEAN) argument).toBoolean(); else { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " invalid boolean agument '"+value+"' for " + qName + " tag"); } // Integer argument } else if (action.getClasses()[0] == Integer.class) try { argument = Integer.parseInt(value); } catch (NumberFormatException nfe) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " invalid integer agument '"+value+"' for " + qName + " tag"); } // Float argument else if (action.getClasses()[0] == Float.class) try { argument = Float.parseFloat(value); } catch (NumberFormatException nfe) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " invalid float agument '"+value+"' for " + qName + " tag"); } // Date argument else if (action.getClasses()[0] == Date.class) try { String[] arguments = value.split("/"); if (arguments.length != 3) throw new NumberFormatException(); GregorianCalendar gc = new GregorianCalendar (Integer.parseInt(arguments[2]), Integer.parseInt(arguments[1]), Integer.parseInt(arguments[0])); argument = new Date(gc.getTimeInMillis()); } catch (NumberFormatException nfe) { System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " invalid date agument '"+value+"' for " + qName + " tag"); } // URL argument else if (action.getClasses()[0] == URL.class) try { argument = new URL(value); } catch(MalformedURLException e){ System.err.println(getMethodName(NameFormat.FIRSTCAPITAL) + " invalid url agument '"+value+"' for " + qName + " tag"); } return argument; } // non numeric lexem parsing methods private enum BOOLEAN { FALSE, TRUE, ERROR; Boolean toBoolean() { return this == FALSE ? false : this == TRUE ? true : false; } } private BOOLEAN parseBoolean() { boolean isFalse = value.equalsIgnoreCase("false") || value.equals("0"); return (value.equalsIgnoreCase("true") || value.equals("1") || isFalse) ? isFalse ? BOOLEAN.FALSE : BOOLEAN.TRUE : BOOLEAN.ERROR; } /**
  • Program entry point
  • @param args
  • /
@SuppressWarnings("unchecked") public static void main(String[]args) { XmlMultiParser parser = new XmlMultiParser("persons.xml", ParsingMethod.PERSON); Vector<Person> persons = (Vector<Person>) parser.parse(); for (Person person : persons) person.print(true); parser.setSource("employees.xml", ParsingMethod.EMPLOYEE); Vector<Employee> employees = (Vector<Employee>) parser.parse(); for (Employee employee : employees) employee.print(true); parser.setSource("clients.xml", ParsingMethod.CLIENT); Vector<Client> clients = (Vector<Client>) parser.parse(); for (Client client : clients) client.print(true); } }

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
2
Date d'inscription
jeudi 16 janvier 2003
Statut
Membre
Dernière intervention
22 octobre 2007

Juste une remarque, je penses qu'une class List ou ArrayList serai plus judicieuse de Vector qui est tres groumad en memoire...
Messages postés
694
Date d'inscription
lundi 5 décembre 2005
Statut
Membre
Dernière intervention
8 janvier 2014
13
Merci je vais voir ça.
Messages postés
342
Date d'inscription
vendredi 1 septembre 2006
Statut
Membre
Dernière intervention
6 novembre 2012

Salut, pour éviter les Warnings, tu peux, pour une énumération de Personne, faire (je n'ai pas lu ton code) :
Enumeration enum1 = new Enumeration()

(JDK >= 1.5)
Messages postés
3
Date d'inscription
mardi 1 février 2005
Statut
Membre
Dernière intervention
21 juin 2007

Pas mal ..

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.