public QName get(String name, Namespace namespace) {
    Map cache = getNamespaceCache(namespace);
    QName answer = null;

    if (name != null) {
        answer = (QName) cache.get(name);  // 此行为第117行
    } else {
        name = "";
    }

    if (answer == null) {
        answer = createQName(name, namespace);
        answer.setDocumentFactory(documentFactory);
        cache.put(name, answer);
    }

    return answer;
}

protected Map getNamespaceCache(Namespace namespace) {
    if (namespace == Namespace.NO_NAMESPACE) {
        return noNamespaceCache;
    }

    Map answer = null;

    if (namespace != null) {
        answer = (Map) namespaceCache.get(namespace);
    }

    if (answer == null) {
        answer = createMap();
        namespaceCache.put(namespace, answer);
    }

    return answer;
}

public class QNameCache {
    /** Cache of {@link QName}instances with no namespace */
    protected Map noNamespaceCache = Collections.synchronizedMap(new WeakHashMap());

    /**
     * Cache of {@link Map}instances indexed by namespace which contain caches
     * of {@link QName}for each name
     */
    protected Map namespaceCache = Collections.synchronizedMap(new WeakHashMap());
    // ......
}

private static class SynchronizedMap<K,V>
    implements Map<K,V>, Serializable {
    private static final long serialVersionUID = 1978198479659022715L;

    private final Map<K,V> m;     // Backing Map
    final Object      mutex;        // Object on which to synchronize
    .....
    public V get(Object key) {
        synchronized (mutex) {return m.get(key);}
    }
    ......
}

SAXReader saxReader = new SAXReader();
Document domdoc = saxReader.read(new BufferedInputStream(inputstream));

public Document read(InputStream in) throws DocumentException {
    InputSource source = new InputSource(in);
    if (this.encoding != null) {
        source.setEncoding(this.encoding);
    }

    return read(source);
}

public Document read(InputSource in) throws DocumentException {
     try {
         XMLReader reader = getXMLReader();

         reader = installXMLFilter(reader);

         EntityResolver thatEntityResolver = this.entityResolver;

         if (thatEntityResolver == null) {
             thatEntityResolver = createDefaultEntityResolver(in
                     .getSystemId());
             this.entityResolver = thatEntityResolver;
         }

         reader.setEntityResolver(thatEntityResolver);

         SAXContentHandler contentHandler = createContentHandler(reader);
         contentHandler.setEntityResolver(thatEntityResolver);
         contentHandler.setInputSource(in);

         boolean internal = isIncludeInternalDTDDeclarations();
         boolean external = isIncludeExternalDTDDeclarations();

         contentHandler.setIncludeInternalDTDDeclarations(internal);
         contentHandler.setIncludeExternalDTDDeclarations(external);
         contentHandler.setMergeAdjacentText(isMergeAdjacentText());
         contentHandler.setStripWhitespaceText(isStripWhitespaceText());
         contentHandler.setIgnoreComments(isIgnoreComments());
         reader.setContentHandler(contentHandler);

         configureReader(reader, contentHandler);

         reader.parse(in);

         return contentHandler.getDocument();
     } catch (Exception e) {
         // 省略......
     }
 }

protected SAXContentHandler createContentHandler(XMLReader reader) {
    return new SAXContentHandler(getDocumentFactory(), dispatchHandler);
}

public DocumentFactory getDocumentFactory() {
    if (factory == null) {
        factory = DocumentFactory.getInstance();
    }

    return factory;
}

public class DocumentFactory implements Serializable {
    private static SingletonStrategy singleton = null;

    protected transient QNameCache cache;

    /** Default namespace prefix -> URI mappings for XPath expressions to use */
    private Map xpathNamespaceURIs;

    private static SingletonStrategy createSingleton() {
        SingletonStrategy result = null;

        String documentFactoryClassName;
        try {
            documentFactoryClassName = System.getProperty("org.dom4j.factory",
                    "org.dom4j.DocumentFactory");
        } catch (Exception e) {
            documentFactoryClassName = "org.dom4j.DocumentFactory";
        }

        try {
            String singletonClass = System.getProperty(
                    "org.dom4j.DocumentFactory.singleton.strategy",
                    "org.dom4j.util.SimpleSingleton");
            Class clazz = Class.forName(singletonClass);
            result = (SingletonStrategy) clazz.newInstance();
        } catch (Exception e) {
            result = new SimpleSingleton();
        }

        result.setSingletonClassName(documentFactoryClassName);

        return result;
    }

    public DocumentFactory() {
        init();
    }

    /**
     * <p>
     * Access to singleton implementation of DocumentFactory which is used if no
     * DocumentFactory is specified when building using the standard builders.
     * </p>
     *
     * @return the default singleon instance
     */
    public static synchronized DocumentFactory getInstance() {
        if (singleton == null) {
            singleton = createSingleton();
        }
        return (DocumentFactory) singleton.instance();
    }
    // ......省略
}