binder.java

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

//$Id: Binder.java,v 1.26.2.45 2003/11/27 16:48:00 oneovthafew Exp $
package net.sf.hibernate.cfg;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Properties;

import net.sf.hibernate.Hibernate;
import net.sf.hibernate.MappingException;
import net.sf.hibernate.mapping.IdentifierBag;
import net.sf.hibernate.cache.CacheConcurrencyStrategy;
import net.sf.hibernate.cache.CacheFactory;
import net.sf.hibernate.engine.Cascades;
import net.sf.hibernate.engine.Versioning;
import net.sf.hibernate.id.PersistentIdentifierGenerator;
import net.sf.hibernate.loader.OuterJoinLoader;
import net.sf.hibernate.mapping.Any;
import net.sf.hibernate.mapping.Array;
import net.sf.hibernate.mapping.MetaAttribute;
import net.sf.hibernate.mapping.Value;
import net.sf.hibernate.mapping.ToOne;
import net.sf.hibernate.mapping.Bag;
import net.sf.hibernate.mapping.Collection;
import net.sf.hibernate.mapping.Column;
import net.sf.hibernate.mapping.Component;
import net.sf.hibernate.mapping.Fetchable;
import net.sf.hibernate.mapping.Formula;
import net.sf.hibernate.mapping.IdentifierCollection;
import net.sf.hibernate.mapping.IndexedCollection;
import net.sf.hibernate.mapping.List;
import net.sf.hibernate.mapping.ManyToOne;
import net.sf.hibernate.mapping.Map;
import net.sf.hibernate.mapping.NamedSQLQuery;
import net.sf.hibernate.mapping.OneToMany;
import net.sf.hibernate.mapping.OneToOne;
import net.sf.hibernate.mapping.PersistentClass;
import net.sf.hibernate.mapping.PrimitiveArray;
import net.sf.hibernate.mapping.Property;
import net.sf.hibernate.mapping.RootClass;
import net.sf.hibernate.mapping.Set;
import net.sf.hibernate.mapping.Subclass;
import net.sf.hibernate.mapping.Table;
import net.sf.hibernate.mapping.SimpleValue;
import net.sf.hibernate.persister.EntityPersister;
import net.sf.hibernate.persister.NormalizedEntityPersister;
import net.sf.hibernate.property.Getter;
import net.sf.hibernate.property.Setter;
import net.sf.hibernate.type.ComponentType;
import net.sf.hibernate.type.DynamicComponentType;
import net.sf.hibernate.type.EntityType;
import net.sf.hibernate.type.ForeignKeyDirection;
import net.sf.hibernate.type.PrimitiveType;
import net.sf.hibernate.type.Type;
import net.sf.hibernate.type.TypeFactory;
import net.sf.hibernate.util.ReflectHelper;
import net.sf.hibernate.util.StringHelper;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;

final class Binder {

	private Binder() {}

	private static final Log log = LogFactory.getLog(Binder.class);

	public static void bindClass(Element node, PersistentClass model, Mappings mapping)
	throws MappingException {

		String className = node.attributeValue("name");
		//CLASS
		try {
			model.setMappedClass( ReflectHelper.classForName(className) );
		}
		catch ( ClassNotFoundException cnfe ) {
			throw new MappingException( "persistent class [" + className + "] not found", cnfe );
		}
		//PROXY INTERFACE
		Attribute proxyNode = node.attribute("proxy");
		Attribute lazyNode = node.attribute("lazy");
		boolean lazyTrue = lazyNode!=null && "true".equals( lazyNode.getValue() );
		if ( proxyNode!=null && ( lazyNode==null || lazyTrue ) ) {
			try {
				model.setProxyInterface( ReflectHelper.classForName( proxyNode.getValue() ) );
			}
			catch (ClassNotFoundException cnfe) {
				throw new MappingException(cnfe);
			}
		}
		if ( proxyNode==null && lazyTrue ) {
			model.setProxyInterface( model.getMappedClass() );
		}
		//DISCRIMINATOR
		Attribute discriminatorNode = node.attribute("discriminator-value");
		model.setDiscriminatorValue( (discriminatorNode==null) ?
			model.getName() :
			discriminatorNode.getValue()
		);
		//DYNAMIC UPDATE
		Attribute dynamicNode = node.attribute("dynamic-update");
		model.setDynamicUpdate( (dynamicNode==null) ?
			false :
			"true".equals( dynamicNode.getValue() )
		);
		//DYNAMIC UPDATE
		Attribute insertNode = node.attribute("dynamic-insert");
		model.setDynamicInsert( (insertNode==null) ?
			false :
			"true".equals( insertNode.getValue() )
		);
		//IMPORT
		if ( mapping.isAutoImport() ) {
			mapping.addImport( className, StringHelper.unqualify(className) );
		}
		//BATCH SIZE
		Attribute batchNode = node.attribute("batch-size");
		if (batchNode!=null) model.setBatchSize( Integer.parseInt( batchNode.getValue() ) );
		//SELECT BEFORE UPDATE
		Attribute sbuNode = node.attribute("select-before-update");
		if (sbuNode!=null) model.setSelectBeforeUpdate( "true".equals( sbuNode.getValue() ) );
		//OPTIMISTIC LOCK MODE
		Attribute olNode = node.attribute("optimistic-lock");
		model.setOptimisticLockMode( getOptimisticLockMode(olNode) );
		
		model.setMetaAttributes( getMetas(node) );
	}

	public static void bindSubclass(Element node, Subclass model, Mappings mappings) throws MappingException {

		bindClass(node, model, mappings);

		if ( model.getClassPersisterClass()==null ) {
			model.getRootClass().setClassPersisterClass(EntityPersister.class);
		}

		model.setTable( model.getSuperclass().getTable() );

		log.info("Mapping subclass: " + model.getName() + " -> " + model.getTable().getName() );

		// properties
		propertiesFromXML(node, model, mappings);
	}

	public static void bindJoinedSubclass(Element node, Subclass model, Mappings mappings) throws MappingException {

		bindClass(node, model, mappings);

		// joined subclasses
		if ( model.getClassPersisterClass()==null ) {
			model.getRootClass().setClassPersisterClass(NormalizedEntityPersister.class);
		}

		Attribute tableNameNode = node.attribute("table");
		String tableName = (tableNameNode==null) ?
			StringHelper.unqualify( model.getMappedClass().getName() ) :
			tableNameNode.getValue();
		Attribute schemaNode = node.attribute("schema");
		String schema = schemaNode==null ? mappings.getSchemaName() : schemaNode.getValue();
		Table mytable = mappings.addTable(schema, tableName);
		model.setTable(mytable);

		log.info("Mapping joined-subclass: " + model.getName() + " -> " + model.getTable().getName() );

		Element keyNode = node.element("key");
		SimpleValue key = new SimpleValue(mytable);
		model.setKey(key);
		bindSimpleValue( keyNode, key, false, model.getName() );

		model.getKey().setType( model.getIdentifier().getType() );
		model.createPrimaryKey();
		model.getKey().createForeignKeyOfClass( model.getSuperclass().getMappedClass() );

		// properties
		propertiesFromXML(node, model, mappings);
	}

	public static void bindRootClass(Element node, RootClass model, Mappings mappings) throws MappingException {

		bindClass(node, model, mappings);

		//TABLENAME
		Attribute tableNameNode = node.attribute("table");
		String tableName = (tableNameNode==null) ?
			StringHelper.unqualify( model.getMappedClass().getName() ) :
			tableNameNode.getValue();

		Attribute schemaNode = node.attribute("schema");
		String schema = schemaNode==null ? mappings.getSchemaName() : schemaNode.getValue();
		Table table = mappings.addTable(schema, tableName);
		model.setTable(table);

		log.info("Mapping class: " + model.getName() + " -> " + model.getTable().getName() );

		//PERSISTER
		Attribute persisterNode = node.attribute("persister");
		if (persisterNode==null) {
			//persister = EntityPersister.class;
		}
		else {
			try {
				model.setClassPersisterClass( ReflectHelper.classForName( persisterNode.getValue() ) );
			}
			catch (ClassNotFoundException cnfe) {
				throw new MappingException( "Could not find persister class: " + persisterNode.getValue() );
			}
		}

		//MUTABLE
		Attribute mutableNode = node.attribute("mutable");
		model.setMutable( (mutableNode==null) || mutableNode.getValue().equals("true") );

		//WHERE
		Attribute whereNode = node.attribute("where");
		if (whereNode!=null) model.setWhere( whereNode.getValue() );

		//POLYMORPHISM
		Attribute polyNode = node.attribute("polymorphism");
		model.setExplicitPolymorphism( (polyNode!=null) && polyNode.getValue().equals("explicit") );

		Iterator subnodes = node.elementIterator();
		while ( subnodes.hasNext() ) {

			Element subnode = (Element) subnodes.next();
			String name = subnode.getName();
			String propertyName = getPropertyName(subnode);

			if ( "id".equals(name) ) {
				SimpleValue id = new SimpleValue(table);
				model.setIdentifier(id);
				if (propertyName==null) {
					bindSimpleValue(subnode, id, false, RootClass.DEFAULT_IDENTIFIER_COLUMN_NAME);
					if (id.getType()==null) throw new MappingException(
						"must specify an identifier type: " + model.getMappedClass().getName()
					);
					model.setIdentifierProperty(null);
				}
				else {
					bindSimpleValue(subnode, id, false, propertyName);
					id.setTypeByReflection( model.getMappedClass(), propertyName );
					Property prop = new Property(id);
					bindProperty(subnode, prop, mappings);
					model.setIdentifierProperty(prop);
				}
				if ( id.getType().getReturnedClass().isArray() ) throw new MappingException(
					"illegal use of an array as an identifier (arrays don't reimplement equals)"
				);
				makeIdentifier(subnode, id, mappings);
			}
			else if ( "composite-id".equals(name) ) {
				Component id = new Component(model);
				model.setIdentifier(id);
				if (propertyName==null) {
					bindComponent(subnode, id, null, model.getName() + ".id", false, mappings);
					model.setEmbeddedIdentifier( id.isEmbedded() );
					model.setIdentifierProperty(null);
				}
				else {
					Class reflectedClass = ReflectHelper.reflectedPropertyClass( model.getMappedClass(), propertyName );
					bindComponent(
						subnode,
						id,
						reflectedClass,
						StringHelper.qualify( model.getName(), propertyName ),
						false,
						mappings
					);
					Property prop = new Property(id);
					bindProperty(subnode, prop, mappings);
					model.setIdentifierProperty(prop);
				}
				makeIdentifier(subnode, id, mappings);
				
				if ( !ReflectHelper.overridesEquals( id.getComponentClass() ) ) {
					throw new MappingException(
						"composite-id class must override equals() and hashCode(): " + 
						id.getComponentClass().getName()
					);
				}
			}
			else if ( "version".equals(name) || "timestamp".equals(name) ) {
				//VERSION
				SimpleValue val = new SimpleValue(table);
				bindSimpleValue(subnode, val, false, propertyName);
				if ( val.getType()==null ) val.setType( "version".equals(name) ? Hibernate.INTEGER : Hibernate.TIMESTAMP );
				Property prop = new Property(val);
				bindProperty(subnode, prop, mappings);
				makeVersion(subnode, val);
				model.setVersion(prop);
				model.addProperty(prop);
			}
			else if ( "discriminator".equals(name) ) {
				//DISCRIMINATOR
				SimpleValue discrim = new SimpleValue(table);
				model.setDiscriminator(discrim);
				bindSimpleValue(subnode, discrim, false, RootClass.DEFAULT_DISCRIMINATOR_COLUMN_NAME);
				if ( discrim.getType()==null ) {
					discrim.setType(Hibernate.STRING);
					( (Column) discrim.getColumnIterator().next() ).setType(Hibernate.STRING);
				}
				model.setPolymorphic(true);
				if ( "true".equals( subnode.attributeValue("force") ) ) model.setForceDiscriminator(true);
			}
			else if ( "jcs-cache".equals(name) || "cache".equals(name) ) {
				String className = model.getMappedClass().getName();
				CacheConcurrencyStrategy cache = CacheFactory.createCache( 
					subnode, className, model.isMutable() 
				);
				mappings.addCache(className, cache);
				model.setCache(cache);
			}

		}

		//Primary key constraint
		model.createPrimaryKey();

		propertiesFromXML(node, model, mappings);

	}

	public static void bindColumns(Element node, SimpleValue model, boolean isNullable, boolean autoColumn, String defaultColumnName) {
		//COLUMN(S)
		Attribute columnNode = node.attribute("column");
		if ( columnNode==null) {
			Iterator iter = node.elementIterator("column");
			int count=0;
			while( iter.hasNext() ) {
				Element subnode = (Element) iter.next();
				Table table = model.getTable();
				Column col = new Column( model.getType(), count++ );
				bindColumn(subnode, col, isNullable);
				col.setName( subnode.attributeValue("name") );
				if (table!=null) table.addColumn(col); //table=null -> an association - fill it in later
				model.addColumn(col);
				//column index
				Attribute indexNode = subnode.attribute("index");
				if ( indexNode!=null && table!=null ) {
					table.getIndex( indexNode.getValue() ).addColumn(col);
				}
				Attribute uniqueNode = subnode.attribute("unique-key");
				if ( uniqueNode!=null && table!=null ) {
					table.getUniqueKey( uniqueNode.getValue() ).addColumn(col);
				}
			}
		}
		else {
			Column col = new Column( model.getType(), 0 );
			bindColumn(node, col, isNullable);
			col.setName( columnNode.getValue() );
			Table table = model.getTable();
			if (table!=null) table.addColumn(col); //table=null -> an association - fill it in later
			model.addColumn(col);
		}

		if ( autoColumn && model.getColumnSpan()==0 ) {
			Column col = new Column( model.getType(), 0 );
			bindColumn(node, col, isNullable);
			col.setName(defaultColumnName);
			model.getTable().addColumn(col);
			model.addColumn(col);
		}