Summary of three ways to parse XML files using Digester

<?xml version="1.0" encoding="UTF-8" ?>
<Orders>
    <Order user="Zhang San" date="2008-11-14" price="12279">
    
        <goods >
            <name>IBMnotebook</name>
            <price>8999</price>
            <count>1</count>
            <total_price>8999</total_price>
        </goods>
        
        <goods >
            <name>Yageol Season</name>
            <price>1300</price>
            <count>2</count>
            <total_price>2600</total_price>
        </goods>
    
    </Order>
</Orders>

// Order categorypackage ;

import ;
/**
  *: Order category
  * @author ypykip
  *
  */
public class Order {
    private String user;    //The corresponding user attribute in the <Order> tag    private String date;    //The corresponding date attribute in the <Order> tag    private String price;   //The price attribute corresponding to the <Order> tag    //All <good> tags corresponding to <Order> tags    private ArrayList&lt;Goods&gt; goodsList = new ArrayList&lt;Goods&gt;();
    //Omit getter and setter...
    // Add items to order    public void add(Goods goods){
        ().add(goods);
    }
    // Rewrite the toString() method to facilitate observation of results    @Override
    public String toString() {
        return "Order [user=" + user + ", date=" + date + ", price=" + price
                + ", goodsList=" + () + "]";
    }

}
// Product categorypackage ;

package ;

/**
  *:Product category
  * @author ypykip
  *
  */
public class Goods {
    private String id;
    private String name;
    private String price;
    private String count;
    private String total_price;

    //Omit getter and setter...
    @Override
    public String toString() {
        return "Goods [, name=" + name + ", price=" + price
                + ", count=" + count + ", total_price=" + total_price +"]";
    }
}

// Analytical classimport ;
import ;
import ;
import ;

import ;
import ;

import ;
import ;

/**
  * title: parsed through digester
  * @author grk
  * Focus: Understand the concept of stack
  * When using the addObjectCreate() method, create an object to stack
  * All operations below (except in one case, indicating that the method called) are for the top element of the stack unless called
  * addSetNext() method, remove the top element of the stack and execute the specified method of the top element of the secondary stack
  *
  * addCallMethod(pattern, methodName): call the specified method of the top element of the stack
  * addCallMethod(pattern, methodName, paramCount): Call the specified method of the top element of the stack, which can specify the method
  * Number of parameters addCallMethod(pattern, methodName, paramCount, paramTypes): The top element of the call stack
  * Specify the method, which can specify the number of parameters and type of the method
  *
  * addCallParam(pattern, paramIndex): The default setting specifies the paramIndex parameter as the label content
  * addCallParam(pattern, paramIndex, fromStack): Set the specified paramIndex parameter to the top element of the stack
  * addCallParam(pattern, paramIndex, stackIndex): Set the specified paramIndex parameter to?
  * addCallParam(pattern, paramIndex, attributeName): Set the specified paramIndex parameter as the label attribute
  * value of attributeName addObjectParam(pattern, paramIndex, paramObj): Set the specified paramIndex
  * ParamObj
  *
  * addSetNext(pattern, methodName): Call the methodName method of the element on the top of the stack, generally a method with a parameter.
  * Use the top element of the stack as an argument, such as the add method of list
  *
  */
public class ParseOrder {
    public static void main(String[] args) {
        parseByJavaBean();
    }

    /**
      * Use javaBean for storage
      */
    public static void parseByJavaBean(){
        // 1. Initialize the Digester instance object        Digester digester = new Digester();

        // 2. Parsing the <Order> tag node        // List enters the stack, list object of the top element of the stack        ("Orders", );
        //Order instance is entered into the stack, and the Order instance object is used when the top element of the stack is entered.        ("Orders/Order", );
        //Set the properties of the <Order> tag        ("Orders/Order");

        // 3. Analyze the <goods> tag node        //Goods instance object is stacked        ("Orders/Order/goods", );
        ("Orders/Order/goods");
        //Set other tag contents under <goods>        ("Orders/Order/goods/name");
        ("Orders/Order/goods/price");
        ("Orders/Order/goods/count");
        ("Orders/Order/goods/total_price");
        //Goods object instance is out of the stack        ("Orders/Order/goods", "add");
        //Order object instance is stacked        ("Orders/Order", "add");

        // 4. Load the configuration file        String filePath = "";
        filePath = ("")+"/bin/config/";
        File file = new File(filePath);

        // 5. Analysis        try {
            ArrayList list = (ArrayList) (file);
            (());
        } catch (IOException e) {
            ();
        } catch (SAXException e) {
            ();
        }
    }
}

    /**
      * Use list and map for storage (the process is complicated and not recommended)
      */
    public static void parseByMap(){
        Digester digester = new Digester();
        // 1. Define Orders node rules and create a List collection        ("Orders", );

        // 2. Define Orders/Order node rules, create a Map collection to store attributes and content, and place this Map in the List in the previous node        ("Orders/Order", );
        ("Orders/Order", "add");

        // 3. Define the properties of the Orders/Order node        ("Orders/Order", "put", 2);//Calling the put method of the map on the top element of the stack        ("Orders/Order", 0, "name");//Set key        ("Orders/Order", 1, "name");//Set value        ("Orders/Order", "put", 2);
        ("Orders/Order", 0, "date");
        ("Orders/Order", 1, "date");
        ("Orders/Order", "put", 2);
        ("Orders/Order", 0, "price");
        ("Orders/Order", 1, "price");

        // 4. Define a List collection to store the tags under the Orders/Order nodes        ("Orders/Order", "put", 2);
        ("Orders/Order", );
        ("Orders/Order", 0, "goodsList");
        ("Orders/Order", 1, true);

        // 5. Define Orders/Order/goods node rules, store id, name, price, count, total_price attributes or tags respectively        ("Orders/Order/goods", );
        ("Orders/Order/goods", "add");
        ("Orders/Order/goods", "put", 2);
        ("Orders/Order/goods", 0, "id");
        ("Orders/Order/goods", 1, "id");

        ("Orders/Order/goods/name", "put", 2);
        ("Orders/Order/goods/name", 0, "name");
        ("Orders/Order/goods/name", 1);
        ("Orders/Order/goods/price", "put", 2);
        ("Orders/Order/goods/price", 0, "price");
        ("Orders/Order/goods/price", 1);
        ("Orders/Order/goods/count", "put", 2);
        ("Orders/Order/goods/count", 0, "count");
        ("Orders/Order/goods/count", 1);
        ("Orders/Order/goods/total_price", "put", 2);
        ("Orders/Order/goods/total_price", 0, "total_price");
        ("Orders/Order/goods/total_price", 1);

        String filePath = ("")+"/bin/config/";
        (filePath);
        File file = new File(filePath);
        (());
        try {
            ArrayList list = (ArrayList) (file);
            (());
        } catch (IOException e) {
            ();
        } catch (SAXException e) {
            ();
        }
    }

<?xml version="1.0" encoding="UTF-8"?>
<digester-rules>
    <pattern value="Orders">
        <object-create-rule classname="" />  
        <!-- Configuration<Order>Label -->
        <pattern value="Order">
            <object-create-rule classname="" />
                <set-properties-rule/>

            <!-- Configuration<goods>Label -->
            <pattern value="goods">
                <object-create-rule classname="" />
                <set-properties-rule>
                    <alias attr-name="id" prop-name="id" /><!-- idProperties correspond tojavabeanofid -->
                </set-properties-rule>
                <bean-property-setter-rule pattern="name" propertyname="name" /><!-- nameProperties correspond tojavabeanofname -->
                <bean-property-setter-rule pattern="price" propertyname="price" /><!-- priceLabel对应javabeanofprice -->
                <bean-property-setter-rule pattern="count" propertyname="count" /><!-- countLabel对应javabeanofcount -->
                <bean-property-setter-rule pattern="total_price" propertyname="total_price" /><!-- total_priceLabel对应javabeanoftotal_price -->
                <set-next-rule methodname="add" paramtype=""/>

            </pattern>
            <set-next-rule methodname="add" paramtype=""/>
        </pattern>
    </pattern>
</digester-rules>  

public static void parseByXmlConfig() throws IOException, SAXException, URISyntaxException{
        // 1. Load the rule configuration file        URL rule = ()
                .getContextClassLoader()
                .getResource("config/");

        // 2. Load the configuration file to be parsed        Reader reader = null;
        try {
            reader = new InputStreamReader(
                    new FileInputStream(
                            new File(("") + "/bin/config/")), "utf-8");
        } catch (FileNotFoundException e) {
            ();
        }

        // 3. Create Digester instance object based on the rule configuration file        InputSource in = new InputSource(new InputStreamReader(new FileInputStream(new File(()))));
        Digester digester = (in);

        // 4. Perform parsing and print the results        List list = (List) (reader);
        (());
        try {
            if(reader != null){
                ();
            }
        } catch (Exception e) {
            ();
        }
    }