blob: 4c5b644797e0d65a8919b0e21c3347a1cf405bd4 [file] [log] [blame]
package org.apache.commons.digester3.examples.xmlrules.addressbook;
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import static org.apache.commons.digester3.binder.DigesterLoader.newLoader;
import java.io.File;
import java.io.IOException;
import org.apache.commons.digester3.Digester;
import org.apache.commons.digester3.xmlrules.FromXmlRulesModule;
import org.xml.sax.SAXException;
/**
* A simple program to demonstrate the basic functionality of the
* Commons Digester module with the xmlrules extension.
* <p>
* This code will parse the provided "example.xml" file to build a tree
* of java objects, then cause those objects to print out their values
* to demonstrate that the input file has been processed correctly.
* <p>
* Unlike the "addressbook" example in the "api" section, this implementation
* has no parsing rules hard-wired into the code in this class. Instead, the
* parsing rules are loaded from an external file at runtime. This allows
* the parsing rules to be modified without compiling the code, and
* potentially makes it somewhat easier to review the parsing rules.
* <p>
* Note, however, that there is tyically quite a tight coupling between
* the parsing rules and the <i>purpose</i> of the application which means
* that it may not be all that common for parsing rules to be altered
* without the application code also being altered, so only in some cases
* will this prove of benefit. As with all software, it must be determined
* whether this feature provides a true benefit in the context of the
* application it is being applied to.
* <p>
* Usage: java Main xmlrules.xml example.xml
*/
public class Main
{
/**
* Main method : entry point for running this example program.
* <p>
* Usage: java Example example.xml
*/
public static void main( final String[] args )
throws Exception
{
if ( args.length != 2 )
{
usage();
System.exit( -1 );
}
final String rulesfileName = args[0];
final String datafileName = args[1];
// Create a Digester instance which has been initialised with
// rules loaded from the specified file.
final Digester d = newLoader( new FromXmlRulesModule()
{
@Override
protected void loadRules()
{
loadXMLRules( rulesfileName );
}
} ).newDigester();
// Prime the digester stack with an object for rules to
// operate on. Note that it is quite common for "this"
// to be the object pushed.
final AddressBook book = new AddressBook();
d.push( book );
// Process the input file.
try
{
final File srcfile = new java.io.File( datafileName );
d.parse( srcfile );
}
catch ( final IOException ioe )
{
System.out.println( "Error reading input file:" + ioe.getMessage() );
System.exit( -1 );
}
catch ( final SAXException se )
{
System.out.println( "Error parsing input file:" + se.getMessage() );
System.exit( -1 );
}
// Print out all the contents of the address book, as loaded from
// the input file.
book.print();
}
private static void usage()
{
System.out.println( "Usage: java Main xmlrules.xml example.xml" );
}
}