Java MappingException类代码示例

import org.hibernate.MappingException; //导入依赖的package包/类
@Override
public boolean reassociateIfUninitializedProxy(Object value) throws MappingException {
	if ( value instanceof ElementWrapper ) {
		value = ( (ElementWrapper) value ).getElement();
	}

	if ( !Hibernate.isInitialized( value ) ) {
		final HibernateProxy proxy = (HibernateProxy) value;
		final LazyInitializer li = proxy.getHibernateLazyInitializer();
		reassociateProxy( li, proxy );
		return true;
	}
	else {
		return false;
	}
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
private Type guessType(Class clazz) throws HibernateException {
	String typename = clazz.getName();
	Type type = session.getFactory().getTypeResolver().heuristicType(typename);
	boolean serializable = type!=null && type instanceof SerializableType;
	if (type==null || serializable) {
		try {
			session.getFactory().getEntityPersister( clazz.getName() );
		}
		catch (MappingException me) {
			if (serializable) {
				return type;
			}
			else {
				throw new HibernateException("Could not determine a type for class: " + typename);
			}
		}
		return ( (Session) session ).getTypeHelper().entity( clazz );
	}
	else {
		return type;
	}
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
private static void parseIdentifierGeneratorRegistration(Element element, Mappings mappings) {
	String strategy = element.attributeValue( "name" );
	if ( StringHelper.isEmpty( strategy ) ) {
		throw new MappingException( "'name' attribute expected for identifier-generator elements" );
	}
	String generatorClassName = element.attributeValue( "class" );
	if ( StringHelper.isEmpty( generatorClassName ) ) {
		throw new MappingException( "'class' attribute expected for identifier-generator [[email protected]=" + strategy + "]" );
	}

	try {
		Class generatorClass = ReflectHelper.classForName( generatorClassName );
		mappings.getIdentifierGeneratorFactory().register( strategy, generatorClass );
	}
	catch ( ClassNotFoundException e ) {
		throw new MappingException( "Unable to locate identifier-generator class [name=" + strategy + ", class=" + generatorClassName + "]" );
	}

}
 

import org.hibernate.MappingException; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void setParameterValues(Properties parameters) {
	ParameterType reader = (ParameterType) parameters.get( PARAMETER_TYPE );
	if ( reader != null ) {
		setJavaTypeDescriptor( new SerializableTypeDescriptor<T>( reader.getReturnedClass() ) );
	} else {
		String className = parameters.getProperty( CLASS_NAME );
		if ( className == null ) {
			throw new MappingException( "No class name defined for type: " + SerializableToBlobType.class.getName() );
		}
		try {
			setJavaTypeDescriptor( new SerializableTypeDescriptor<T>( ReflectHelper.classForName( className ) ) );
		} catch ( ClassNotFoundException e ) {
			throw new MappingException( "Unable to load class from " + CLASS_NAME + " parameter", e );
		}
	}
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
public static void bindOneToMany(Element node, OneToMany oneToMany, Mappings mappings)
		throws MappingException {

	oneToMany.setReferencedEntityName( getEntityName( node, mappings ) );

	String embed = node.attributeValue( "embed-xml" );
	// sometimes embed is set to the default value when not specified in the mapping,
	// so can't seem to determine if an attribute was explicitly set;
	// log a warning if embed has a value different from the default.
	if ( !StringHelper.isEmpty( embed ) &&  !"true".equals( embed ) ) {
		LOG.embedXmlAttributesNoLongerSupported();
	}
	oneToMany.setEmbedded( embed == null || "true".equals( embed ) );

	String notFound = node.attributeValue( "not-found" );
	oneToMany.setIgnoreNotFound( "ignore".equals( notFound ) );

}
 

import org.hibernate.MappingException; //导入依赖的package包/类
NamedProcedureCallDefinition(NamedStoredProcedureQuery annotation) {
	this.registeredName = annotation.name();
	this.procedureName = annotation.procedureName();
	this.resultClasses = annotation.resultClasses();
	this.resultSetMappings = annotation.resultSetMappings();
	this.parameterDefinitions = new ParameterDefinitions( annotation.parameters() );
	this.hints = new QueryHintDefinition( annotation.hints() ).getHintsMap();

	final boolean specifiesResultClasses = resultClasses != null && resultClasses.length > 0;
	final boolean specifiesResultSetMappings = resultSetMappings != null && resultSetMappings.length > 0;

	if ( specifiesResultClasses && specifiesResultSetMappings ) {
		throw new MappingException(
				String.format(
						"NamedStoredProcedureQuery [%s] specified both resultClasses and resultSetMappings",
						registeredName
				)
		);
	}
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
public void addSubclass(Subclass subclass) throws MappingException {
	// inheritance cycle detection (paranoid check)
	PersistentClass superclass = getSuperclass();
	while (superclass!=null) {
		if( subclass.getEntityName().equals( superclass.getEntityName() ) ) {
			throw new MappingException(
				"Circular inheritance mapping detected: " +
				subclass.getEntityName() +
				" will have it self as superclass when extending " +
				getEntityName()
			);
		}
		superclass = superclass.getSuperclass();
	}
	subclasses.add(subclass);
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
protected void checkColumnDuplication(Set distinctColumns, Iterator columns) 
throws MappingException {
	while ( columns.hasNext() ) {
		Selectable columnOrFormula = (Selectable) columns.next();
		if ( !columnOrFormula.isFormula() ) {
			Column col = (Column) columnOrFormula;
			if ( !distinctColumns.add( col.getName() ) ) {
				throw new MappingException( 
						"Repeated column in mapping for entity: " +
						getEntityName() +
						" column: " +
						col.getName() + 
						" (should be mapped with insert=\"false\" update=\"false\")"
					);
			}
		}
	}
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
private static void parseFetchProfile(Element element, Mappings mappings, String containingEntityName) {
	String profileName = element.attributeValue( "name" );
	FetchProfile profile = mappings.findOrCreateFetchProfile( profileName, MetadataSource.HBM );
	Iterator itr = element.elementIterator( "fetch" );
	while ( itr.hasNext() ) {
		final Element fetchElement = ( Element ) itr.next();
		final String association = fetchElement.attributeValue( "association" );
		final String style = fetchElement.attributeValue( "style" );
		String entityName = fetchElement.attributeValue( "entity" );
		if ( entityName == null ) {
			entityName = containingEntityName;
		}
		if ( entityName == null ) {
			throw new MappingException( "could not determine entity for fetch-profile fetch [" + profileName + "]:[" + association + "]" );
		}
		profile.addFetch( entityName, association, style );
	}
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
private IdType determineIdType() {
	List<AnnotationInstance> idAnnotations = findIdAnnotations( JPADotNames.ID );
	List<AnnotationInstance> embeddedIdAnnotations = findIdAnnotations( JPADotNames.EMBEDDED_ID );

	if ( !idAnnotations.isEmpty() && !embeddedIdAnnotations.isEmpty() ) {
		throw new MappingException(
				"@EmbeddedId and @Id cannot be used together. Check the configuration for " + getName() + "."
		);
	}

	if ( !embeddedIdAnnotations.isEmpty() ) {
		if ( embeddedIdAnnotations.size() == 1 ) {
			return IdType.EMBEDDED;
		}
		else {
			throw new AnnotationException( "Multiple @EmbeddedId annotations are not allowed" );
		}
	}

	if ( !idAnnotations.isEmpty() ) {
		return idAnnotations.size() == 1 ? IdType.SIMPLE : IdType.COMPOSED;
	}
	return IdType.NONE;
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
public OneToManyJoinWalker(
		QueryableCollection oneToManyPersister,
		int batchSize,
		String subquery,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	super( factory, loadQueryInfluencers );

	this.oneToManyPersister = oneToManyPersister;

	final OuterJoinLoadable elementPersister = (OuterJoinLoadable) oneToManyPersister.getElementPersister();
	final String alias = generateRootAlias( oneToManyPersister.getRole() );

	walkEntityTree(elementPersister, alias);

	List allAssociations = new ArrayList();
	allAssociations.addAll(associations);
	allAssociations.add( OuterJoinableAssociation.createRoot( oneToManyPersister.getCollectionType(), alias, getFactory() ) );
	initPersisters(allAssociations, LockMode.NONE);
	initStatementString(elementPersister, alias, batchSize, subquery);
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
protected void initIdentifierPropertyPaths(
		final String path,
		final EntityType etype,
		final String[] columns,
		final String[] columnReaders,
		final String[] columnReaderTemplates,
		final Mapping factory) throws MappingException {

	Type idtype = etype.getIdentifierOrUniqueKeyType( factory );
	String idPropName = etype.getIdentifierOrUniqueKeyPropertyName(factory);
	boolean hasNonIdentifierPropertyNamedId = hasNonIdentifierPropertyNamedId( etype, factory );

	if ( etype.isReferenceToPrimaryKey() ) {
		if ( !hasNonIdentifierPropertyNamedId ) {
			String idpath1 = extendPath(path, EntityPersister.ENTITY_ID);
			addPropertyPath(idpath1, idtype, columns, columnReaders, columnReaderTemplates, null);
			initPropertyPaths(idpath1, idtype, columns, columnReaders, columnReaderTemplates, null, factory);
		}
	}

	if (idPropName!=null) {
		String idpath2 = extendPath(path, idPropName);
		addPropertyPath(idpath2, idtype, columns, columnReaders, columnReaderTemplates, null);
		initPropertyPaths(idpath2, idtype, columns, columnReaders, columnReaderTemplates, null, factory);
	}
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
/**
 * Does the mapping, and Hibernate default semantics, specify that
 * this association should be fetched by outer joining
 */
protected boolean isJoinedFetchEnabledInMapping(FetchMode config, AssociationType type) 
throws MappingException {
	if ( !type.isEntityType() && !type.isCollectionType() ) {
		return false;
	}
	else {
		if (config==FetchMode.JOIN) return true;
		if (config==FetchMode.SELECT) return false;
		if ( type.isEntityType() ) {
			//TODO: look at the owning property and check that it 
			//      isn't lazy (by instrumentation)
			EntityType entityType =(EntityType) type;
			EntityPersister persister = getFactory().getEntityPersister( entityType.getAssociatedEntityName() );
			return !persister.hasProxy();
		}
		else {
			return false;
		}
	}
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
public AccessType getDefaultAccess() throws MappingException {
	AccessType accessType = defaultAccess;

	AccessType hibernateAccessType = AccessType.DEFAULT;
	AccessType jpaAccessType = AccessType.DEFAULT;

	org.hibernate.annotations.AccessType accessTypeAnnotation = property.getAnnotation( org.hibernate.annotations.AccessType.class );
	if ( accessTypeAnnotation != null ) {
		hibernateAccessType = AccessType.getAccessStrategy( accessTypeAnnotation.value() );
	}

	Access access = property.getAnnotation( Access.class );
	if ( access != null ) {
		jpaAccessType = AccessType.getAccessStrategy( access.value() );
	}

	if ( hibernateAccessType != AccessType.DEFAULT
			&& jpaAccessType != AccessType.DEFAULT
			&& hibernateAccessType != jpaAccessType ) {

		StringBuilder builder = new StringBuilder();
		builder.append( property.toString() );
		builder.append(
				" defines @AccessType and @Access with contradicting values. Use of @Access only is recommended."
		);
		throw new MappingException( builder.toString() );
	}

	if ( hibernateAccessType != AccessType.DEFAULT ) {
		accessType = hibernateAccessType;
	}
	else if ( jpaAccessType != AccessType.DEFAULT ) {
		accessType = jpaAccessType;
	}
	return accessType;
}
 

import org.hibernate.MappingException; //导入依赖的package包/类
private void initDiscriminatorPropertyPath(Mapping mapping) throws MappingException {
	propertyMapping.initPropertyPaths( ENTITY_CLASS,
			getDiscriminatorType(),
			new String[]{getDiscriminatorColumnName()},
			new String[]{getDiscriminatorColumnReaders()},
			new String[]{getDiscriminatorColumnReaderTemplate()},
			new String[]{getDiscriminatorFormulaTemplate()},
			getFactory() );
}