Java Code Examples for org.hibernate.mapping.PersistentClass#getSubclassIterator()

@SuppressWarnings("unchecked")
private boolean determineCanReadFromCache(PersistentClass persistentClass, EntityDataAccess cacheAccessStrategy) {
	if ( cacheAccessStrategy == null ) {
		return false;
	}

	if ( persistentClass.isCached() ) {
		return true;
	}

	final Iterator<Subclass> subclassIterator = persistentClass.getSubclassIterator();
	while ( subclassIterator.hasNext() ) {
		final Subclass subclass = subclassIterator.next();
		if ( subclass.isCached() ) {
			return true;
		}
	}
	return false;
}
 

public SingleTableEntityPersister(PersistentClass persistentClass,
		EntityRegionAccessStrategy cacheAccessStrategy,
		SessionFactoryImplementor factory,
		Mapping mapping) throws HibernateException {
	super(persistentClass, cacheAccessStrategy, factory, mapping);
	this.hasSubselectLoadableCollections = persistentClass.hasSubselectLoadableCollections();
	java.util.Iterator i = persistentClass.getSubclassIterator();
	while(!this.hasSubselectLoadableCollections && i.hasNext()) {
		this.hasSubselectLoadableCollections = ((org.hibernate.mapping.PersistentClass) i.next()).hasSubselectLoadableCollections();
	}
}
 

@Override
protected ProxyFactory buildProxyFactory(PersistentClass persistentClass, Getter idGetter, Setter idSetter) {
	// determine the id getter and setter methods from the proxy interface (if any)
	// determine all interfaces needed by the resulting proxy
	
	/*
	 * We need to preserve the order of the interfaces they were put into the set, since javassist will choose the
	 * first one's class-loader to construct the proxy class with. This is also the reason why HibernateProxy.class
	 * should be the last one in the order (on JBossAS7 its class-loader will be org.hibernate module's class-
	 * loader, which will not see the classes inside deployed apps.  See HHH-3078
	 */
	Set<Class> proxyInterfaces = new java.util.LinkedHashSet<Class>();

	Class mappedClass = persistentClass.getMappedClass();
	Class proxyInterface = persistentClass.getProxyInterface();

	if ( proxyInterface != null && !mappedClass.equals( proxyInterface ) ) {
		if ( !proxyInterface.isInterface() ) {
			throw new MappingException(
					"proxy must be either an interface, or the class itself: " + getEntityName()
			);
		}
		proxyInterfaces.add( proxyInterface );
	}

	if ( mappedClass.isInterface() ) {
		proxyInterfaces.add( mappedClass );
	}

	Iterator<Subclass> subclasses = persistentClass.getSubclassIterator();
	while ( subclasses.hasNext() ) {
		final Subclass subclass = subclasses.next();
		final Class subclassProxy = subclass.getProxyInterface();
		final Class subclassClass = subclass.getMappedClass();
		if ( subclassProxy != null && !subclassClass.equals( subclassProxy ) ) {
			if ( !subclassProxy.isInterface() ) {
				throw new MappingException(
						"proxy must be either an interface, or the class itself: " + subclass.getEntityName()
				);
			}
			proxyInterfaces.add( subclassProxy );
		}
	}

	proxyInterfaces.add( HibernateProxy.class );

	Iterator properties = persistentClass.getPropertyIterator();
	Class clazz = persistentClass.getMappedClass();
	while ( properties.hasNext() ) {
		Property property = (Property) properties.next();
		Method method = property.getGetter( clazz ).getMethod();
		if ( method != null && Modifier.isFinal( method.getModifiers() ) ) {
			LOG.gettersOfLazyClassesCannotBeFinal( persistentClass.getEntityName(), property.getName() );
		}
		method = property.getSetter( clazz ).getMethod();
		if ( method != null && Modifier.isFinal( method.getModifiers() ) ) {
			LOG.settersOfLazyClassesCannotBeFinal( persistentClass.getEntityName(), property.getName() );
		}
	}

	Method idGetterMethod = idGetter == null ? null : idGetter.getMethod();
	Method idSetterMethod = idSetter == null ? null : idSetter.getMethod();

	Method proxyGetIdentifierMethod = idGetterMethod == null || proxyInterface == null ?
			null :
			ReflectHelper.getMethod( proxyInterface, idGetterMethod );
	Method proxySetIdentifierMethod = idSetterMethod == null || proxyInterface == null ?
			null :
			ReflectHelper.getMethod( proxyInterface, idSetterMethod );

	ProxyFactory pf = buildProxyFactoryInternal( persistentClass, idGetter, idSetter );
	try {
		pf.postInstantiate(
				getEntityName(),
				mappedClass,
				proxyInterfaces,
				proxyGetIdentifierMethod,
				proxySetIdentifierMethod,
				persistentClass.hasEmbeddedIdentifier() ?
						(CompositeType) persistentClass.getIdentifier().getType() :
						null
		);
	}
	catch (HibernateException he) {
		LOG.unableToCreateProxyFactory( getEntityName(), he );
		pf = null;
	}
	return pf;
}
 

protected ProxyFactory buildProxyFactory(PersistentClass persistentClass, Getter idGetter, Setter idSetter) {
	// determine the id getter and setter methods from the proxy interface (if any)
       // determine all interfaces needed by the resulting proxy
	HashSet proxyInterfaces = new HashSet();
	proxyInterfaces.add( HibernateProxy.class );
	
	Class mappedClass = persistentClass.getMappedClass();
	Class proxyInterface = persistentClass.getProxyInterface();

	if ( proxyInterface!=null && !mappedClass.equals( proxyInterface ) ) {
		if ( !proxyInterface.isInterface() ) {
			throw new MappingException(
			        "proxy must be either an interface, or the class itself: " + 
			        getEntityName()
				);
		}
		proxyInterfaces.add( proxyInterface );
	}

	if ( mappedClass.isInterface() ) {
		proxyInterfaces.add( mappedClass );
	}

	Iterator iter = persistentClass.getSubclassIterator();
	while ( iter.hasNext() ) {
		Subclass subclass = ( Subclass ) iter.next();
		Class subclassProxy = subclass.getProxyInterface();
		Class subclassClass = subclass.getMappedClass();
		if ( subclassProxy!=null && !subclassClass.equals( subclassProxy ) ) {
			if ( !proxyInterface.isInterface() ) {
				throw new MappingException(
				        "proxy must be either an interface, or the class itself: " + 
				        subclass.getEntityName()
				);
			}
			proxyInterfaces.add( subclassProxy );
		}
	}

	Iterator properties = persistentClass.getPropertyIterator();
	Class clazz = persistentClass.getMappedClass();
	while ( properties.hasNext() ) {
		Property property = (Property) properties.next();
		Method method = property.getGetter(clazz).getMethod();
		if ( method != null && Modifier.isFinal( method.getModifiers() ) ) {
			log.error(
					"Getters of lazy classes cannot be final: " + persistentClass.getEntityName() + 
					"." + property.getName() 
				);
		}
		method = property.getSetter(clazz).getMethod();
           if ( method != null && Modifier.isFinal( method.getModifiers() ) ) {
			log.error(
					"Setters of lazy classes cannot be final: " + persistentClass.getEntityName() + 
					"." + property.getName() 
				);
		}
	}

	Method idGetterMethod = idGetter==null ? null : idGetter.getMethod();
	Method idSetterMethod = idSetter==null ? null : idSetter.getMethod();

	Method proxyGetIdentifierMethod = idGetterMethod==null || proxyInterface==null ? 
			null :
	        ReflectHelper.getMethod(proxyInterface, idGetterMethod);
	Method proxySetIdentifierMethod = idSetterMethod==null || proxyInterface==null  ? 
			null :
	        ReflectHelper.getMethod(proxyInterface, idSetterMethod);

	ProxyFactory pf = buildProxyFactoryInternal( persistentClass, idGetter, idSetter );
	try {
		pf.postInstantiate(
				getEntityName(),
				mappedClass,
				proxyInterfaces,
				proxyGetIdentifierMethod,
				proxySetIdentifierMethod,
				persistentClass.hasEmbeddedIdentifier() ?
		                (AbstractComponentType) persistentClass.getIdentifier().getType() :
		                null
		);
	}
	catch ( HibernateException he ) {
		log.warn( "could not create proxy factory for:" + getEntityName(), he );
		pf = null;
	}
	return pf;
}