xmldatabinder.java

用Java实现的23个常用设计模式源代码

//$Id: XMLDatabinder.java,v 1.10.2.10 2003/11/02 04:26:44 oneovthafew Exp $
package net.sf.hibernate.xml;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import javax.xml.transform.ErrorListener;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Templates;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import net.sf.hibernate.Databinder;
import net.sf.hibernate.Hibernate;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.MappingException;
import net.sf.hibernate.cfg.Environment;
import net.sf.hibernate.collection.CollectionPersister;
import net.sf.hibernate.collection.PersistentCollection;
import net.sf.hibernate.engine.SessionFactoryImplementor;
import net.sf.hibernate.persister.ClassPersister;
import net.sf.hibernate.proxy.HibernateProxy;
import net.sf.hibernate.proxy.HibernateProxyHelper;
import net.sf.hibernate.proxy.LazyInitializer;
import net.sf.hibernate.type.AbstractComponentType;
import net.sf.hibernate.type.BagType;
import net.sf.hibernate.type.ListType;
import net.sf.hibernate.type.MapType;
import net.sf.hibernate.type.PersistentCollectionType;
import net.sf.hibernate.type.SetType;
import net.sf.hibernate.type.StringType;
import net.sf.hibernate.type.Type;
import net.sf.hibernate.util.StringHelper;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.DOMWriter;
import org.dom4j.io.DocumentSource;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

/**
 * Implementation of the API class Databinder. NOT threadsafe.
 * @see Databinder
 * @author Gavin King, Brad Clow
 */
public class XMLDatabinder implements Databinder {
	private SessionFactoryImplementor factory;
	private List objects = new ArrayList();
	private Set associatedObjects;
	private Set processedObjects;
	private Transformer transform;
	private boolean initializeLazy = false;
	
	private static final Log log = LogFactory.getLog(XMLDatabinder.class);
	
	public XMLDatabinder(SessionFactoryImplementor factory, Transformer transform) {
		this.factory = factory;
		this.transform = transform;
	}
	
	private ClassPersister getPersister(Class clazz) throws MappingException {
		return factory.getPersister(clazz);
	}
	
	public void setInitializeLazy(boolean initializeLazy) {
		this.initializeLazy = initializeLazy;
	}
	
	private Document toDocument() throws HibernateException {
		this.associatedObjects = new HashSet();
		this.processedObjects = new HashSet();
		
		Document doc = DocumentHelper.createDocument();
		Element root = doc.addElement("hibernate-generic");
		root.setAttributeValue("datetime", Hibernate.TIMESTAMP.toString( new Date(), factory) );
		Iterator iter;
		
		// keep going until we run out of bound objects and their associated objects
		while ( objects.size()>0 ) {
			iter = objects.iterator();
			while ( iter.hasNext() ) {
				Object object = iter.next();
				Element objectElem = root.addElement("object");
				object = maybeInitializeIfProxy(object, objectElem);
				if ( object!=null ) {
					addClass( objectElem, object.getClass() );
					ClassPersister persister = getPersister( object.getClass() );
					//ID
					if ( persister.hasIdentifierPropertyOrEmbeddedCompositeIdentifier() ) {
						Object id = persister.getIdentifier(object);
						Element elemElement = renderProperty(persister.getIdentifierPropertyName(), persister.getIdentifierType(), id, "composite-id", "id", null, true);
						objectElem.add(elemElement);
					}

					//PROPERTIES
					Type[] types = persister.getPropertyTypes();
					Object[] values = persister.getPropertyValues(object);
					String[] names = persister.getPropertyNames();
					//This approach wont work for components + collections
					for ( int i=0; i<types.length; i++ ) {
						objectElem.add( renderProperty( names[i], types[i], values[i], "component", "property", "collection", true ) );
					}
				}
			}
			
			processedObjects.addAll(objects);
			objects = new ArrayList(associatedObjects);
			associatedObjects = new HashSet();
		}
		return doc;
	}
	
	private void addClass(Element element, Class clazz) {
		String className = clazz.getName();
		element.setAttributeValue( "class", StringHelper.unqualify(className) );
		element.setAttributeValue( "package", StringHelper.qualifier(className) );
	}
	
	private Object maybeInitializeIfProxy(Object object, Element element) throws HibernateException {
		if ( !(object instanceof HibernateProxy) ) return object;
		
		LazyInitializer li = HibernateProxyHelper.getLazyInitializer( (HibernateProxy) object );
		
		if (li.isUninitialized() && !initializeLazy) {
			Class clazz = li.getPersistentClass();
			ClassPersister persister = getPersister(clazz);
			//ID
			if ( persister.hasIdentifierPropertyOrEmbeddedCompositeIdentifier() ) {
				Object id = li.getIdentifier();
				Element elemElement = renderProperty(persister.getIdentifierPropertyName(), persister.getIdentifierType(), id, "composite-id", "id", null, true);
				element.add(elemElement);
			}
			addClass(element, clazz);
		
			element.setAttributeValue("proxy", "uninitialized");
			return null;
		}
		else if ( li.isUninitialized() ) {
			element.setAttributeValue("proxy", "now-initialized");
		}
		else {
			element.setAttributeValue("proxy", "initialized");
		}
		
		return li.getImplementation();
	}
	
	public String toGenericXML() throws HibernateException {
		StringWriter writer = new StringWriter();
		XMLWriter outputter = new XMLWriter( writer, OutputFormat.createPrettyPrint() );
		//outputter.setNewlines(true);
		try {
			outputter.write( toDocument() );
		}
		catch (IOException ioe) {
			throw new HibernateException("could not XML to String", ioe);
		}
		return writer.toString();
	}
	
	public String toXML() throws HibernateException, TransformerException {

		Source source = new DocumentSource( toDocument() );
		StringWriter writer = new StringWriter();
		Result result = new StreamResult(writer);
		
		transform.setErrorListener( new ErrorListener() {
			public void warning(TransformerException te)
			throws TransformerException {
				
				log.warn("problem transforming to Custom XML: " + te.getMessageAndLocation(), te);
			}
			public void error(TransformerException te)
			throws TransformerException {
				
				log.error("problem transforming to Custom XML: " + te.getMessageAndLocation(), te);
			}
			public void fatalError(TransformerException te)
			throws TransformerException {
				error(te);
			}
		} );
		
		transform.transform(source, result);
		return writer.toString();
	}
	
	public org.w3c.dom.Document toDOM() throws HibernateException, TransformerException {
		Source source = new DocumentSource( toDocument() );
		DOMResult result = new DOMResult();
		transform.transform(source, result);