com.feilong.lib.digester3.Digester Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of feilong Show documentation
feilong is a suite of core and expanded libraries that include utility classes, http, excel,cvs, io classes, and much much more.
There is a newer version: 4.0.8
Show newest version
package com.feilong.lib.digester3;

/*
 * 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 java.lang.String.format;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EmptyStackException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.validation.Schema;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;

/**
 * 
 * A Digester processes an XML input stream by matching a series of element nesting patterns to execute
 * Rules that have been added prior to the start of parsing.
 * 
 * 
 * See the Digester Developer Guide for more information.
 * 
 * 
 * IMPLEMENTATION NOTE - A single Digester instance may only be used within the context of a single
 * thread at a time, and a call to parse() must be completed before another can be initiated even from the
 * same thread.
 * 
 * 
 * A Digester instance should not be used for parsing more than one input document. The problem is that the Digester
 * class has quite a few member variables whose values "evolve" as SAX events are received during a parse. When reusing
 * the Digester instance, all these members must be reset back to their initial states before the second parse begins.
 * The "clear()" method makes a stab at resetting these, but it is actually rather a difficult problem. If you are
 * determined to reuse Digester instances, then at the least you should call the clear() method before each parse, and
 * must call it if the Digester parse terminates due to an exception during a parse.
 * 
 * 
 * LEGACY IMPLEMENTATION NOTE - When using the legacy XML schema support (instead of using the
 * {@link Schema} class), a bug in Xerces 2.0.2 prevents the support of XML schema. You need Xerces 2.1/2.3 and up to
 * make this class work with the legacy XML schema support.
 * 
 * 
 * This package was inspired by the XmlMapper class that was part of Tomcat 3.0 and 3.1, but is organized
 * somewhat differently.
 * 
 */
public class Digester extends DefaultHandler{

    /** The Constant log. */
    private static final Logger LOGGER = LoggerFactory.getLogger(Digester.class);

    // --------------------------------------------------------- Constructors

    /**
     * Construct a new Digester, allowing an XMLReader to be passed in. This allows Digester to be used in environments
     * which are unfriendly to JAXP1.1 (such as WebLogic 6.0). Note that if you use this option you have to configure
     * namespace and validation support yourself, as these properties only affect the SAXParser and emtpy constructor.
     *
     * @param reader
     *            The XMLReader used to parse XML streams
     */
    public Digester(XMLReader reader){
        super();
        this.reader = reader;
    }

    // --------------------------------------------------- Instance Variables

    /**
     * The body text of the current element.
     */
    private StringBuilder                        bodyText              = new StringBuilder();

    /**
     * The stack of body text string buffers for surrounding elements.
     */
    private final Stack           bodyTexts             = new Stack<>();

    /**
     * Stack whose elements are List objects, each containing a list of Rule objects as returned from Rules.getMatch().
     * As each xml element in the input is entered, the matching rules are pushed onto this stack. After the end tag is
     * reached, the matches are popped again. The depth of is stack is therefore exactly the same as the current
     * "nesting" level of the input xml.
     *
     * @since 1.6
     */
    private final Stack>              matches               = new Stack<>();

    /**
     * The class loader to use for instantiating application objects. If not specified, the context class loader, or the
     * class loader used to load Digester itself, is used, based on the value of the useContextClassLoader
     * variable.
     */
    private ClassLoader                          classLoader           = null;

    /**
     * Has this Digester been configured yet.
     */
    private boolean                              configured            = false;

    /**
     * The EntityResolver used by the SAX parser. By default it use this class
     */
    private EntityResolver                       entityResolver;

    /**
     * The URLs of entityValidator that have been registered, keyed by the public identifier that corresponds.
     */
    private final HashMap           entityValidator       = new HashMap<>();

    /**
     * The application-supplied error handler that is notified when parsing warnings, errors, or fatal errors occur.
     */
    private final ErrorHandler                   errorHandler          = null;

    /**
     * The SAXParserFactory that is created the first time we need it.
     */
    private SAXParserFactory                     factory               = null;

    /**
     * The Locator associated with our parser.
     */
    private Locator                              locator               = null;

    /**
     * The current match pattern for nested element processing.
     */
    private String                               match                 = "";

    /**
     * Do we want a "namespace aware" parser.
     */
    private boolean                              namespaceAware        = false;

    /**
     * The executor service to run asynchronous parse method.
     * 
     * @since 3.1
     */
    private ExecutorService                      executorService;

    /**
     * Registered namespaces we are currently processing. The key is the namespace prefix that was declared in the
     * document. The value is an Stack of the namespace URIs this prefix has been mapped to -- the top Stack element is
     * the most current one. (This architecture is required because documents can declare nested uses of the same prefix
     * for different Namespace URIs).
     */
    private final HashMap> namespaces            = new HashMap<>();

    /**
     * Do we want a "XInclude aware" parser.
     */
    private boolean                              xincludeAware         = false;

    /**
     * The parameters stack being utilized by CallMethodRule and CallParamRule rules.
     *
     * @since 2.0
     */
    private final Stack                params                = new Stack<>();

    /**
     * The SAXParser we will use to parse the input stream.
     */
    private SAXParser                            parser                = null;

    /**
     * The public identifier of the DTD we are currently parsing under (if any).
     */
    private String                               publicId              = null;

    /**
     * The XMLReader used to parse digester rules.
     */
    private XMLReader                            reader                = null;

    /**
     * The "root" element of the stack (in other words, the last object that was popped.
     */
    private Object                               root                  = null;

    /**
     * The Rules implementation containing our collection of Rule instances and associated
     * matching policy. If not established before the first rule is added, a default implementation will be provided.
     */
    private Rules                                rules                 = null;

    /**
     * The XML schema to use for validating an XML instance.
     *
     * @since 2.0
     */
    private Schema                               schema                = null;

    /**
     * The object stack being constructed.
     */
    private final Stack