org.hibernate.engine.spi.TypedValue#org.hibernate.type.CompositeType源码实例Demo

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
	List<TypedValue> list = new ArrayList<>();
	Type type = criteriaQuery.getTypeUsingProjection(criteria, propertyName);
	if (type.isComponentType()) {
		CompositeType actype = (CompositeType) type;
		Type[] types = actype.getSubtypes();
		for (int j = 0; j < values.length; j++) {
			for (int i = 0; i < types.length; i++) {
				Object subval = values[j] == null ? null : actype.getPropertyValues(values[j], EntityMode.POJO)[i];
				list.add(new TypedValue(types[i], subval, EntityMode.POJO));
			}
		}
	} else {
		for (int j = 0; j < values.length; j++) {
			list.add(new TypedValue(type, values[j], EntityMode.POJO));
		}
	}
	return list.toArray(new TypedValue[list.size()]);
}
 

@Override
public void postInstantiate(String entityName, Class persistentClass, Set<Class> interfaces, Method getIdentifierMethod,
        Method setIdentifierMethod, CompositeType componentIdType) throws HibernateException {
    this.entityName = entityName;
    this.persistentClass = persistentClass;
    this.interfaces = toArray(interfaces);
    this.getIdentifierMethod = getIdentifierMethod;
    this.setIdentifierMethod = setIdentifierMethod;
    this.componentIdType = componentIdType;
    ProxyDefinitions.ProxyClassDetailsHolder detailsHolder = proxyClassDefinitions.getProxyForClass(persistentClass);
    if (detailsHolder == null) {
        throw new HibernateException("Could not lookup a pre-generated proxy class definition for entity '" + entityName
                + "'. Falling back to enforced eager mode for this entity!");
    }
    this.overridesEquals = detailsHolder.isOverridesEquals();
    this.constructor = detailsHolder.getConstructor();

}
 

private void addAssociationsToTheSetForOneProperty(String name, Type type, String prefix, SessionFactoryImplementor factory) {

		if ( type.isCollectionType() ) {
			CollectionType collType = (CollectionType) type;
			Type assocType = collType.getElementType( factory );
			addAssociationsToTheSetForOneProperty(name, assocType, prefix, factory);
		}
		//ToOne association
		else if ( type.isEntityType() || type.isAnyType() ) {
			associations.add( prefix + name );
		}
		else if ( type.isComponentType() ) {
			CompositeType componentType = (CompositeType) type;
			addAssociationsToTheSetForAllProperties(
					componentType.getPropertyNames(),
					componentType.getSubtypes(),
					(prefix.equals( "" ) ? name : prefix + name) + ".",
					factory);
		}
	}
 

protected void addComponentTypedValues(
		String path, 
		Object component, 
		CompositeType type,
		List<TypedValue> list,
		Criteria criteria, 
		CriteriaQuery criteriaQuery) {
	if ( component != null ) {
		final String[] propertyNames = type.getPropertyNames();
		final Type[] subtypes = type.getSubtypes();
		final Object[] values = type.getPropertyValues( component, getEntityMode( criteria, criteriaQuery ) );
		for ( int i=0; i<propertyNames.length; i++ ) {
			final Object value = values[i];
			final Type subtype = subtypes[i];
			final String subpath = StringHelper.qualify( path, propertyNames[i] );
			if ( isPropertyIncluded( value, subpath, subtype ) ) {
				if ( subtype.isComponentType() ) {
					addComponentTypedValues( subpath, value, (CompositeType) subtype, list, criteria, criteriaQuery );
				}
				else {
					addPropertyTypedValue( value, subtype, list );
				}
			}
		}
	}
}
 

private void findKeyManyToOneTargetIndices(
		ArrayList<Integer> keyManyToOneTargetIndices,
		OuterJoinableAssociation joinWithCompositeId,
		CompositeType componentType) {
	for ( Type subType : componentType.getSubtypes() ) {
		if ( subType.isEntityType() ) {
			Integer index = locateKeyManyToOneTargetIndex( joinWithCompositeId, (EntityType) subType );
			if ( index != null ) {
				keyManyToOneTargetIndices.add( index );
			}
		}
		else if ( subType.isComponentType() ) {
			findKeyManyToOneTargetIndices(
					keyManyToOneTargetIndices,
					joinWithCompositeId,
					(CompositeType) subType
			);
		}
	}
}
 

@Override
public ExpandingCompositeQuerySpace makeCompositeIdentifierQuerySpace() {
	final String compositeQuerySpaceUid = getUid() + "-id";
	final ExpandingCompositeQuerySpace rhs = getExpandingQuerySpaces().makeCompositeQuerySpace(
			compositeQuerySpaceUid,
			new CompositePropertyMapping(
					(CompositeType) getEntityPersister().getIdentifierType(),
					(PropertyMapping) getEntityPersister(),
					getEntityPersister().getIdentifierPropertyName()
			),
			canJoinsBeRequired()
	);
	final JoinDefinedByMetadata join = JoinHelper.INSTANCE.createCompositeJoin(
			this,
			EntityPersister.ENTITY_ID,
			rhs,
			canJoinsBeRequired(),
			(CompositeType) persister.getIdentifierType()
	);
	internalGetJoins().add( join );

	return rhs;
}
 

public ExpandingCompositeQuerySpace makeCompositeQuerySpace(
		ExpandingQuerySpace lhsQuerySpace,
		AttributeDefinition attributeDefinition,
		String querySpaceUid,
		boolean shouldIncludeJoin) {
	final boolean required = lhsQuerySpace.canJoinsBeRequired() && !attributeDefinition.isNullable();
	return makeCompositeQuerySpace(
			lhsQuerySpace,
			new CompositePropertyMapping(
					(CompositeType) attributeDefinition.getType(),
					lhsQuerySpace.getPropertyMapping(),
					attributeDefinition.getName()
			),
			attributeDefinition.getName(),
			(CompositeType) attributeDefinition.getType(),
			querySpaceUid,
			required,
			shouldIncludeJoin
	);
}
 

/**
 * Builds just the first level of identifier description.  This will be either a simple id descriptor (String,
 * Long, etc) or some form of composite id (either encapsulated or not).
 *
 * @return the descriptor for the identifier
 */
private EntityIdentifierDescription buildIdentifierDescription() {
	final EntityIdentifierDefinition identifierDefinition = getEntityPersister().getEntityKeyDefinition();

	if ( identifierDefinition.isEncapsulated() ) {
		final EncapsulatedEntityIdentifierDefinition encapsulatedIdentifierDefinition = (EncapsulatedEntityIdentifierDefinition) identifierDefinition;
		final Type idAttributeType = encapsulatedIdentifierDefinition.getAttributeDefinition().getType();
		if ( ! CompositeType.class.isInstance( idAttributeType ) ) {
			return new SimpleEntityIdentifierDescriptionImpl();
		}
	}

	// if we get here, we know we have a composite identifier...
	final ExpandingCompositeQuerySpace querySpace = expandingEntityQuerySpace().makeCompositeIdentifierQuerySpace();
	return identifierDefinition.isEncapsulated()
			? buildEncapsulatedCompositeIdentifierDescription( querySpace )
			: buildNonEncapsulatedCompositeIdentifierDescription( querySpace );
}
 

private void prepareEntityIdentifierDefinition() {
	if ( entityIdentifierDefinition != null ) {
		return;
	}
	final Type idType = getIdentifierType();

	if ( !idType.isComponentType() ) {
		entityIdentifierDefinition =
				EntityIdentifierDefinitionHelper.buildSimpleEncapsulatedIdentifierDefinition( this );
		return;
	}

	final CompositeType cidType = (CompositeType) idType;
	if ( !cidType.isEmbedded() ) {
		entityIdentifierDefinition =
				EntityIdentifierDefinitionHelper.buildEncapsulatedCompositeIdentifierDefinition( this );
		return;
	}

	entityIdentifierDefinition =
			EntityIdentifierDefinitionHelper.buildNonEncapsulatedCompositeIdentifierDefinition( this );
}
 

private void initCollectionPropertyMap(String aliasName, Type type, String[] columnAliases, String[] columnNames) {

		collectionPropertyColumnAliases.put( aliasName, columnAliases );
		collectionPropertyColumnNames.put( aliasName, columnNames );

		if ( type.isComponentType() ) {
			CompositeType ct = (CompositeType) type;
			String[] propertyNames = ct.getPropertyNames();
			for ( int i = 0; i < propertyNames.length; i++ ) {
				String name = propertyNames[i];
				collectionPropertyColumnAliases.put( aliasName + "." + name, columnAliases[i] );
				collectionPropertyColumnNames.put( aliasName + "." + name, columnNames[i] );
			}
		}

	}
 

public CompositionBasedCompositionAttribute(
		AbstractCompositionAttribute source,
		SessionFactoryImplementor sessionFactory,
		int entityBasedAttributeNumber,
		String attributeName,
		CompositeType attributeType,
		int columnStartPosition,
		BaselineAttributeInformation baselineInfo) {
	super(
			source,
			sessionFactory,
			entityBasedAttributeNumber,
			attributeName,
			attributeType,
			columnStartPosition,
			baselineInfo
	);
}
 

/**
 * check sub elements-nullability. Returns property path that break
 * nullability or null if none
 *
 * @param propertyType type to check
 * @param value value to check
 *
 * @return property path
 * @throws HibernateException error while getting subcomponent values
 */
private String checkSubElementsNullability(Type propertyType, Object value) throws HibernateException {
	if ( propertyType.isComponentType() ) {
		return checkComponentNullability( value, (CompositeType) propertyType );
	}

	if ( propertyType.isCollectionType() ) {
		// persistent collections may have components
		final CollectionType collectionType = (CollectionType) propertyType;
		final Type collectionElementType = collectionType.getElementType( session.getFactory() );

		if ( collectionElementType.isComponentType() ) {
			// check for all components values in the collection
			final CompositeType componentType = (CompositeType) collectionElementType;
			final Iterator itr = CascadingActions.getLoadedElementsIterator( session, collectionType, value );
			while ( itr.hasNext() ) {
				final Object compositeElement = itr.next();
				if ( compositeElement != null ) {
					return checkComponentNullability( compositeElement, componentType );
				}
			}
		}
	}

	return null;
}
 

@Override
public void postInstantiate(
		final String entityName,
		final Class persistentClass,
		final Set<Class> interfaces,
		final Method getIdentifierMethod,
		final Method setIdentifierMethod,
		CompositeType componentIdType) throws HibernateException {
	this.entityName = entityName;
	this.persistentClass = persistentClass;
	this.interfaces = toArray( interfaces );
	this.getIdentifierMethod = getIdentifierMethod;
	this.setIdentifierMethod = setIdentifierMethod;
	this.componentIdType = componentIdType;
	this.overridesEquals = ReflectHelper.overridesEquals( persistentClass );

	this.proxyClass = buildJavassistProxyFactory().createClass();
}
 

/**
 * @deprecated use {@link #SerializableProxy(String, Class, Class[], Serializable, Boolean, String, boolean, Method, Method, CompositeType)} instead.
 */
@Deprecated
public SerializableProxy(
		String entityName,
		Class persistentClass,
		Class[] interfaces,
		Serializable id,
		Boolean readOnly,
		Method getIdentifierMethod,
		Method setIdentifierMethod,
		CompositeType componentIdType) {
	this(
			entityName, persistentClass, interfaces, id, readOnly, null, false,
			getIdentifierMethod, setIdentifierMethod, componentIdType
	);
}
 

@Override
public void postInstantiate(
		String entityName,
		Class persistentClass,
		Set<Class> interfaces,
		Method getIdentifierMethod,
		Method setIdentifierMethod,
		CompositeType componentIdType) throws HibernateException {
	this.entityName = entityName;
	this.persistentClass = persistentClass;
	this.interfaces = toArray( interfaces );
	this.getIdentifierMethod = getIdentifierMethod;
	this.setIdentifierMethod = setIdentifierMethod;
	this.componentIdType = componentIdType;
	this.overridesEquals = ReflectHelper.overridesEquals( persistentClass );

	this.proxyClass = byteBuddyProxyHelper.buildProxy( persistentClass, this.interfaces );
}
 

/**
 * @deprecated use {@link #SerializableProxy(String, Class, Class[], Serializable, Boolean, String, boolean, Method, Method, CompositeType)} instead.
 */
@Deprecated
public SerializableProxy(
		String entityName,
		Class persistentClass,
		Class[] interfaces,
		Serializable id,
		Boolean readOnly,
		Method getIdentifierMethod,
		Method setIdentifierMethod,
		CompositeType componentIdType) {
	this(
			entityName, persistentClass, interfaces, id, readOnly, null, false,
			getIdentifierMethod, setIdentifierMethod, componentIdType
	);
}
 

@Override
Object processComponent(Object component, CompositeType componentType) throws HibernateException {
	if ( component != null ) {
		Object[] values = componentType.getPropertyValues( component, getSession() );
		Type[] types = componentType.getSubtypes();
		boolean substituteComponent = false;
		for ( int i = 0; i < types.length; i++ ) {
			Object result = processValue( values[i], types[i] );
			if ( result != null ) {
				values[i] = result;
				substituteComponent = true;
			}
		}
		if ( substituteComponent ) {
			componentType.setPropertyValues( component, values, EntityMode.POJO );
		}
	}

	return null;
}
 

private void evictCachedCollections(Type[] types, Serializable id, EventSource source)
		throws HibernateException {
	for ( Type type : types ) {
		if ( type.isCollectionType() ) {
			CollectionPersister collectionPersister = source.getFactory().getMetamodel().collectionPersister( ( (CollectionType) type ).getRole() );
			if ( collectionPersister.hasCache() ) {
				final CollectionDataAccess cache = collectionPersister.getCacheAccessStrategy();
				final Object ck = cache.generateCacheKey(
					id,
					collectionPersister,
					source.getFactory(),
					source.getTenantIdentifier()
				);
				final SoftLock lock = cache.lockItem( source, ck, null );
				cache.remove( source, ck );
				source.getActionQueue().registerProcess( (success, session) -> cache.unlockItem( session, ck, lock ) );
			}
		}
		else if ( type.isComponentType() ) {
			CompositeType actype = (CompositeType) type;
			evictCachedCollections( actype.getSubtypes(), id, source );
		}
	}
}
 

/**
 * Visit a property value. Dispatch to the
 * correct handler for the property type.
 * @param value
 * @param type
 * @throws HibernateException
 */
final Object processValue(Object value, Type type) throws HibernateException {

	if ( type.isCollectionType() ) {
		//even process null collections
		return processCollection( value, (CollectionType) type );
	}
	else if ( type.isEntityType() ) {
		return processEntity( value, (EntityType) type );
	}
	else if ( type.isComponentType() ) {
		return processComponent( value, (CompositeType) type );
	}
	else {
		return null;
	}
}
 

@Override
public boolean needsRecreate(CollectionPersister persister) {
	// Workaround for situations like HHH-7072.  If the collection element is a component that consists entirely
	// of nullable properties, we currently have to forcefully recreate the entire collection.  See the use
	// of hasNotNullableColumns in the AbstractCollectionPersister constructor for more info.  In order to delete
	// row-by-row, that would require SQL like "WHERE ( COL = ? OR ( COL is null AND ? is null ) )", rather than
	// the current "WHERE COL = ?" (fails for null for most DBs).  Note that
	// the param would have to be bound twice.  Until we eventually add "parameter bind points" concepts to the
	// AST in ORM 5+, handling this type of condition is either extremely difficult or impossible.  Forcing
	// recreation isn't ideal, but not really any other option in ORM 4.
	// Selecting a type used in where part of update statement
	// (must match condidion in org.hibernate.persister.collection.BasicCollectionPersister.doUpdateRows).
	// See HHH-9474
	Type whereType;
	if ( persister.hasIndex() ) {
		whereType = persister.getIndexType();
	}
	else {
		whereType = persister.getElementType();
	}
	if ( whereType instanceof CompositeType ) {
		CompositeType componentIndexType = (CompositeType) whereType;
		return !componentIndexType.hasNotNullProperty();
	}
	return false;
}
 

protected String quoteIdentifier(Object... value) {
	if ( value.length == 1 ) {
		return quoteIdentifier( value[0], identifierType );
	}
	else {
		if ( identifierType instanceof CompositeType ) {
			CompositeType compositeType = (CompositeType) identifierType;
			List<String> quotedIdentifiers = new ArrayList<>();

			for ( int i = 0; i < value.length; i++ ) {
				quotedIdentifiers.add(quoteIdentifier( value[i], compositeType.getSubtypes()[i] ));
			}
			return String.join( ",", quotedIdentifiers );
		}
		else {
			throw new IllegalArgumentException("Composite identifier does not implement CompositeType");
		}
	}
}
 

public ComponentJoin(
		FromClause fromClause,
		FromElement origin,
		String alias,
		String componentPath,
		CompositeType componentType) {
	super( fromClause, origin, alias );
	this.componentPath = componentPath;
	this.componentType = componentType;
	this.componentProperty = StringHelper.unqualify( componentPath );
	fromClause.addJoinByPathMap( componentPath, this );
	initializeComponentJoin( new ComponentFromElementType( this ) );

	this.columns = origin.getPropertyMapping( "" ).toColumns( getTableAlias(), componentProperty );
	StringBuilder buf = new StringBuilder();
	for ( int j = 0; j < columns.length; j++ ) {
		final String column = columns[j];
		if ( j > 0 ) {
			buf.append( ", " );
		}
		buf.append( column );
	}
	this.columnsFragment = buf.toString();
}
 

private void evictCachedCollections(Type[] types, Serializable id, EventSource source)
		throws HibernateException {
	final ActionQueue actionQueue = source.getActionQueue();
	final SessionFactoryImplementor factory = source.getFactory();
	final MetamodelImplementor metamodel = factory.getMetamodel();
	for ( Type type : types ) {
		if ( type.isCollectionType() ) {
			CollectionPersister collectionPersister = metamodel.collectionPersister( ( (CollectionType) type ).getRole() );
			if ( collectionPersister.hasCache() ) {
				final CollectionDataAccess cache = collectionPersister.getCacheAccessStrategy();
				final Object ck = cache.generateCacheKey(
					id,
					collectionPersister,
					factory,
					source.getTenantIdentifier()
				);
				final SoftLock lock = cache.lockItem( source, ck, null );
				cache.remove( source, ck );
				actionQueue.registerProcess( (success, session) -> cache.unlockItem( session, ck, lock ) );
			}
		}
		else if ( type.isComponentType() ) {
			CompositeType actype = (CompositeType) type;
			evictCachedCollections( actype.getSubtypes(), id, source );
		}
	}
}
 

public CascadeStyle getCascadeStyle() throws MappingException {
	Type type = value.getType();
	if ( type.isComponentType() ) {
		return getCompositeCascadeStyle( (CompositeType) type, cascade );
	}
	else if ( type.isCollectionType() ) {
		return getCollectionCascadeStyle( ( (Collection) value ).getElement().getType(), cascade );
	}
	else {
		return getCascadeStyle( cascade );			
	}
}
 

private static CascadeStyle getCompositeCascadeStyle(CompositeType compositeType, String cascade) {
	if ( compositeType.isAnyType() ) {
		return getCascadeStyle( cascade );
	}
	int length = compositeType.getSubtypes().length;
	for ( int i=0; i<length; i++ ) {
		if ( compositeType.getCascadeStyle(i) != CascadeStyles.NONE ) {
			return CascadeStyles.ALL;
		}
	}
	return getCascadeStyle( cascade );
}
 

private static CascadeStyle getCollectionCascadeStyle(Type elementType, String cascade) {
	if ( elementType.isComponentType() ) {
		return getCompositeCascadeStyle( (CompositeType) elementType, cascade );
	}
	else {
		return getCascadeStyle( cascade );
	}
}
 

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) {
	final EntityPersister meta = criteriaQuery.getFactory().getEntityPersister(
			criteriaQuery.getEntityName( criteria )
	);
	final String[] propertyNames = meta.getPropertyNames();
	final Type[] propertyTypes = meta.getPropertyTypes();

	final Object[] values = meta.getPropertyValues( exampleEntity );
	final List<TypedValue> list = new ArrayList<TypedValue>();
	for ( int i=0; i<propertyNames.length; i++ ) {
		final Object value = values[i];
		final Type type = propertyTypes[i];
		final String name = propertyNames[i];

		final boolean isVersionProperty = i == meta.getVersionProperty();

		if ( ! isVersionProperty && isPropertyIncluded( value, name, type ) ) {
			if ( propertyTypes[i].isComponentType() ) {
				addComponentTypedValues( name, value, (CompositeType) type, list, criteria, criteriaQuery );
			}
			else {
				addPropertyTypedValue( value, type, list );
			}
		}
	}

	return list.toArray( new TypedValue[ list.size() ] );
}
 

protected void appendComponentCondition(
		String path,
		Object component,
		CompositeType type,
		Criteria criteria,
		CriteriaQuery criteriaQuery,
		StringBuilder buf) {
	if ( component != null ) {
		final String[] propertyNames = type.getPropertyNames();
		final Object[] values = type.getPropertyValues( component, getEntityMode( criteria, criteriaQuery ) );
		final Type[] subtypes = type.getSubtypes();
		for ( int i=0; i<propertyNames.length; i++ ) {
			final String subPath = StringHelper.qualify( path, propertyNames[i] );
			final Object value = values[i];
			if ( isPropertyIncluded( value, subPath, subtypes[i] ) ) {
				final Type subtype = subtypes[i];
				if ( subtype.isComponentType() ) {
					appendComponentCondition(
							subPath,
							value,
							(CompositeType) subtype,
							criteria,
							criteriaQuery,
							buf
					);
				}
				else {
					appendPropertyCondition(
							subPath,
							value,
							criteria,
							criteriaQuery,
							buf
					);
				}
			}
		}
	}
}
 

private boolean hasAssociation(CompositeType componentType) {
	for ( Type subType : componentType.getSubtypes() ) {
		if ( subType.isEntityType() ) {
			return true;
		}
		else if ( subType.isComponentType() && hasAssociation( ( (CompositeType) subType ) ) ) {
			return true;
		}
	}
	return false;
}
 

ComponentCollectionCriteriaInfoProvider(QueryableCollection persister) {
	this.persister = persister;
	if ( !persister.getElementType().isComponentType() ) {
		throw new IllegalArgumentException( "persister for role " + persister.getRole() + " is not a collection-of-component" );
	}

	CompositeType componentType = (CompositeType) persister.getElementType();
	String[] names = componentType.getPropertyNames();
	Type[] types = componentType.getSubtypes();

	for ( int i = 0; i < names.length; i++ ) {
		subTypes.put( names[i], types[i] );
	}

}