ANALYSEUR XML GÉNÉRIQUE ET PROGRAMMATION REFLÉXIVE

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);
   	
   }
    
}

Télécharger le zip