org.hibernate.resource.beans.spi.BeanInstanceProducer Java Examples

@Override
@SuppressWarnings("unchecked")
public <B> ContainedBean<B> getBean(
		String name, Class<B> beanType, LifecycleOptions lifecycleOptions, BeanInstanceProducer fallbackProducer) {

	SpringContainedBean<?> bean;
	if (lifecycleOptions.canUseCachedReferences()) {
		bean = this.beanCache.get(name);
		if (bean == null) {
			bean = createBean(name, beanType, lifecycleOptions, fallbackProducer);
			this.beanCache.put(name, bean);
		}
	}
	else {
		bean = createBean(name, beanType, lifecycleOptions, fallbackProducer);
	}
	return (SpringContainedBean<B>) bean;
}
 

@Override
protected <B> ContainedBeanImplementor<B> createBean(
		String name,
		Class<B> beanType,
		BeanLifecycleStrategy lifecycleStrategy,
		BeanInstanceProducer fallbackProducer) {
	if ( usableBeanManager == null ) {
		return new NamedBeanImpl<>(
				name,
				beanType,
				lifecycleStrategy,
				fallbackProducer
		);
	}
	else {
		return lifecycleStrategy.createBean( name, beanType, fallbackProducer, this );
	}
}
 

@SuppressWarnings("unchecked")
private <B> ContainedBeanImplementor<B> createBean(
		String beanName,
		Class<B> beanType,
		LifecycleOptions lifecycleOptions,
		BeanInstanceProducer fallbackProducer) {
	final ContainedBeanImplementor bean = createBean(
			beanName,
			beanType,
			lifecycleOptions.useJpaCompliantCreation()
					? JpaCompliantLifecycleStrategy.INSTANCE
					: ContainerManagedLifecycleStrategy.INSTANCE,
			fallbackProducer
	);
	registeredBeans.add( bean );
	return bean;
}
 

@SuppressWarnings("unchecked")
private <B> ContainedBeanImplementor<B> getCacheableBean(
		String beanName,
		Class<B> beanType,
		LifecycleOptions lifecycleOptions,
		BeanInstanceProducer fallbackProducer) {
	final String beanCacheKey = Helper.INSTANCE.determineBeanCacheKey( beanName, beanType );

	final ContainedBeanImplementor existing = beanCache.get( beanCacheKey );
	if ( existing != null ) {
		return existing;
	}

	final ContainedBeanImplementor bean = createBean( beanName, beanType, lifecycleOptions, fallbackProducer );
	beanCache.put( beanCacheKey, bean );
	return bean;
}
 

@SuppressWarnings("unchecked")
private <B> ContainedBean<B> getCacheableBean(
		Class<B> beanType,
		LifecycleOptions lifecycleOptions,
		BeanInstanceProducer fallbackProducer) {
	final String beanCacheKey = Helper.INSTANCE.determineBeanCacheKey( beanType );

	final ContainedBeanImplementor existing = beanCache.get( beanCacheKey );
	if ( existing != null ) {
		return existing;
	}

	final ContainedBeanImplementor bean = createBean( beanType, lifecycleOptions, fallbackProducer );
	beanCache.put( beanCacheKey, bean );
	return bean;
}
 

private SpringContainedBean<?> createBean(
		String name, Class<?> beanType, LifecycleOptions lifecycleOptions, BeanInstanceProducer fallbackProducer) {

	try {
		if (lifecycleOptions.useJpaCompliantCreation()) {
			Object bean = this.beanFactory.autowire(beanType, AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false);
			this.beanFactory.autowireBeanProperties(bean, AutowireCapableBeanFactory.AUTOWIRE_NO, false);
			this.beanFactory.applyBeanPropertyValues(bean, name);
			bean = this.beanFactory.initializeBean(bean, name);
			return new SpringContainedBean<>(bean, beanInstance -> this.beanFactory.destroyBean(name, beanInstance));
		}
		else {
			return new SpringContainedBean<>(this.beanFactory.getBean(name, beanType));
		}
	}
	catch (BeansException ex) {
		if (logger.isDebugEnabled()) {
			logger.debug("Falling back to Hibernate's default producer after bean creation failure for " +
					beanType + ": " + ex);
		}
		return new SpringContainedBean<>(fallbackProducer.produceBeanInstance(name, beanType));
	}
}
 

private SpringContainedBean<?> createBean(
		Class<?> beanType, LifecycleOptions lifecycleOptions, BeanInstanceProducer fallbackProducer) {

	try {
		if (lifecycleOptions.useJpaCompliantCreation()) {
			return new SpringContainedBean<>(
					this.beanFactory.createBean(beanType, AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false),
					this.beanFactory::destroyBean);
		}
		else {
			return new SpringContainedBean<>(this.beanFactory.getBean(beanType));
		}
	}
	catch (BeansException ex) {
		if (logger.isDebugEnabled()) {
			logger.debug("Falling back to Hibernate's default producer after bean creation failure for " +
					beanType + ": " + ex);
		}
		return new SpringContainedBean<>(fallbackProducer.produceBeanInstance(beanType));
	}
}
 

@Override
@SuppressWarnings("unchecked")
public <B> ContainedBean<B> getBean(
		String name, Class<B> beanType, LifecycleOptions lifecycleOptions, BeanInstanceProducer fallbackProducer) {

	SpringContainedBean<?> bean;
	if (lifecycleOptions.canUseCachedReferences()) {
		bean = this.beanCache.get(name);
		if (bean == null) {
			bean = createBean(name, beanType, lifecycleOptions, fallbackProducer);
			this.beanCache.put(name, bean);
		}
	}
	else {
		bean = createBean(name, beanType, lifecycleOptions, fallbackProducer);
	}
	return (SpringContainedBean<B>) bean;
}
 

@Override
@SuppressWarnings("unchecked")
public <B> ContainedBean<B> getBean(
		Class<B> beanType, LifecycleOptions lifecycleOptions, BeanInstanceProducer fallbackProducer) {

	SpringContainedBean<?> bean;
	if (lifecycleOptions.canUseCachedReferences()) {
		bean = this.beanCache.get(beanType);
		if (bean == null) {
			bean = createBean(beanType, lifecycleOptions, fallbackProducer);
			this.beanCache.put(beanType, bean);
		}
	}
	else {
		bean = createBean(beanType, lifecycleOptions, fallbackProducer);
	}
	return (SpringContainedBean<B>) bean;
}
 

@Override
@SuppressWarnings("unchecked")
public <B> ContainedBean<B> getBean(
		Class<B> beanType, LifecycleOptions lifecycleOptions, BeanInstanceProducer fallbackProducer) {

	SpringContainedBean<?> bean;
	if (lifecycleOptions.canUseCachedReferences()) {
		bean = this.beanCache.get(beanType);
		if (bean == null) {
			bean = createBean(beanType, lifecycleOptions, fallbackProducer);
			this.beanCache.put(beanType, bean);
		}
	}
	else {
		bean = createBean(beanType, lifecycleOptions, fallbackProducer);
	}
	return (SpringContainedBean<B>) bean;
}
 

@Override
protected <B> ContainedBeanImplementor<B> createBean(
		String name,
		Class<B> beanType,
		BeanLifecycleStrategy lifecycleStrategy,
		BeanInstanceProducer fallbackProducer) {
	final ContainedBeanImplementor<B> bean = lifecycleStrategy.createBean(
			name,
			beanType,
			fallbackProducer,
			this
	);
	bean.initialize();
	return bean;
}
 

@Override
public <B> ContainedBeanImplementor<B> createBean(
		Class<B> beanClass,
		BeanInstanceProducer fallbackProducer,
		BeanContainer beanContainer) {
	return new BeanImpl<>( beanClass, fallbackProducer, ( (CdiBasedBeanContainer) beanContainer ).getUsableBeanManager() );
}
 

@Override
public <B> ContainedBeanImplementor<B> createBean(
		String beanName,
		Class<B> beanClass,
		BeanInstanceProducer fallbackProducer,
		BeanContainer beanContainer) {
	return new NamedBeanImpl<>( beanName, beanClass, fallbackProducer, ( (CdiBasedBeanContainer) beanContainer ).getUsableBeanManager() );
}
 

private AbstractBeanImpl(
		Class<B> beanType,
		BeanInstanceProducer fallbackProducer,
		BeanManager beanManager) {
	this.beanType = beanType;
	this.fallbackProducer = fallbackProducer;
	this.beanManager = beanManager;
}
 

private NamedBeanImpl(
		String beanName,
		Class<B> beanType,
		BeanInstanceProducer fallbackProducer,
		BeanManager beanManager) {
	super( beanType, fallbackProducer, beanManager );
	this.beanName = beanName;
}
 

@Override
protected <B> ContainedBeanImplementor<B> createBean(
		Class<B> beanType,
		BeanLifecycleStrategy lifecycleStrategy,
		BeanInstanceProducer fallbackProducer) {
	if ( usableBeanManager == null ) {
		return new BeanImpl<>( beanType, lifecycleStrategy, fallbackProducer );
	}
	else {
		return lifecycleStrategy.createBean( beanType, fallbackProducer, this );
	}
}
 

private NamedBeanImpl(
		String beanName,
		Class<B> beanType,
		BeanInstanceProducer fallbackProducer,
		BeanManager beanManager) {
	this.beanName = beanName;
	this.beanType = beanType;
	this.fallbackProducer = fallbackProducer;
	this.beanManager = beanManager;
}
 

@Override
protected <B> ContainedBeanImplementor<B> createBean(
		Class<B> beanType,
		BeanLifecycleStrategy lifecycleStrategy,
		BeanInstanceProducer fallbackProducer) {
	final ContainedBeanImplementor<B> bean = lifecycleStrategy.createBean( beanType, fallbackProducer, this );
	bean.initialize();
	return bean;
}
 

private BeanImpl(
		Class<B> beanType,
		BeanLifecycleStrategy lifecycleStrategy,
		BeanInstanceProducer fallbackProducer) {
	this.beanType = beanType;
	this.lifecycleStrategy = lifecycleStrategy;
	this.fallbackProducer = fallbackProducer;
}
 

private NamedBeanImpl(
		String name,
		Class<B> beanType,
		BeanLifecycleStrategy lifecycleStrategy, 
		BeanInstanceProducer fallbackProducer) {
	this.name = name;
	this.beanType = beanType;
	this.lifecycleStrategy = lifecycleStrategy;
	this.fallbackProducer = fallbackProducer;
}
 

@Override
public <B> ContainedBean<B> getBean(
		Class<B> beanType,
		LifecycleOptions lifecycleOptions,
		BeanInstanceProducer fallbackProducer) {
	// todo (5.3) : should this throw an exception instead?
	return CdiBeanContainerExtendedAccessImpl.this.getBean( beanType, lifecycleOptions, fallbackProducer );
}
 

@Override
public <B> ContainedBean<B> getBean(
		String beanName,
		Class<B> beanType,
		LifecycleOptions lifecycleOptions,
		BeanInstanceProducer fallbackProducer) {
	// todo (5.3) : should this throw an exception instead?
	return CdiBeanContainerExtendedAccessImpl.this.getBean( beanName, beanType, lifecycleOptions, fallbackProducer );
}
 

@Override
public <B> ContainedBeanImplementor<B> createBean(
		Class<B> beanClass,
		BeanInstanceProducer fallbackProducer,
		BeanContainer beanContainer) {
	return new BeanImpl<>(
			beanClass,
			fallbackProducer,
			( (CdiBasedBeanContainer) beanContainer ).getUsableBeanManager()
	);
}
 

@Override
public <B> ContainedBeanImplementor<B> createBean(
		String beanName,
		Class<B> beanClass,
		BeanInstanceProducer fallbackProducer,
		BeanContainer beanContainer) {
	return new NamedBeanImpl<>(
			beanName,
			beanClass,
			fallbackProducer,
			( (CdiBasedBeanContainer) beanContainer ).getUsableBeanManager()
	);
}
 

public BeanImpl(
		Class<B> beanType,
		BeanInstanceProducer fallbackProducer,
		BeanManager beanManager) {
	this.beanType = beanType;
	this.fallbackProducer = fallbackProducer;
	this.beanManager = beanManager;
}
 

private BeanImpl(
		Class<B> beanType,
		BeanLifecycleStrategy lifecycleStrategy, 
		BeanInstanceProducer fallbackProducer) {
	this.beanType = beanType;
	this.lifecycleStrategy = lifecycleStrategy;
	this.fallbackProducer = fallbackProducer;
}
 

private SpringContainedBean<?> createBean(
		Class<?> beanType, LifecycleOptions lifecycleOptions, BeanInstanceProducer fallbackProducer) {

	try {
		if (lifecycleOptions.useJpaCompliantCreation()) {
			return new SpringContainedBean<>(
					this.beanFactory.createBean(beanType, AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false),
					this.beanFactory::destroyBean);
		}
		else {
			return new SpringContainedBean<>(this.beanFactory.getBean(beanType));
		}
	}
	catch (BeansException ex) {
		if (logger.isDebugEnabled()) {
			logger.debug("Falling back to Hibernate's default producer after bean creation failure for " +
					beanType + ": " + ex);
		}
		try {
			return new SpringContainedBean<>(fallbackProducer.produceBeanInstance(beanType));
		}
		catch (RuntimeException ex2) {
			if (ex instanceof BeanCreationException) {
				if (logger.isDebugEnabled()) {
					logger.debug("Fallback producer failed for " + beanType + ": " + ex2);
				}
				// Rethrow original Spring exception from first attempt.
				throw ex;
			}
			else {
				// Throw fallback producer exception since original was probably NoSuchBeanDefinitionException.
				throw ex2;
			}
		}
	}
}
 

private SpringContainedBean<?> createBean(
		String name, Class<?> beanType, LifecycleOptions lifecycleOptions, BeanInstanceProducer fallbackProducer) {

	try {
		if (lifecycleOptions.useJpaCompliantCreation()) {
			Object bean = this.beanFactory.autowire(beanType, AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false);
			this.beanFactory.autowireBeanProperties(bean, AutowireCapableBeanFactory.AUTOWIRE_NO, false);
			this.beanFactory.applyBeanPropertyValues(bean, name);
			bean = this.beanFactory.initializeBean(bean, name);
			return new SpringContainedBean<>(bean, beanInstance -> this.beanFactory.destroyBean(name, beanInstance));
		}
		else {
			return new SpringContainedBean<>(this.beanFactory.getBean(name, beanType));
		}
	}
	catch (BeansException ex) {
		if (logger.isDebugEnabled()) {
			logger.debug("Falling back to Hibernate's default producer after bean creation failure for " +
					beanType + " with name '" + name + "': " + ex);
		}
		try {
			return new SpringContainedBean<>(fallbackProducer.produceBeanInstance(name, beanType));
		}
		catch (RuntimeException ex2) {
			if (ex instanceof BeanCreationException) {
				if (logger.isDebugEnabled()) {
					logger.debug("Fallback producer failed for " + beanType + " with name '" + name + "': " + ex2);
				}
				// Rethrow original Spring exception from first attempt.
				throw ex;
			}
			else {
				// Throw fallback producer exception since original was probably NoSuchBeanDefinitionException.
				throw ex2;
			}
		}
	}
}
 

@Override
public <B> ContainedBean<B> getBean(
		Class<B> beanType,
		LifecycleOptions lifecycleOptions,
		BeanInstanceProducer fallbackProducer) {
	if ( lifecycleOptions.canUseCachedReferences() ) {
		return getCacheableBean( beanType, lifecycleOptions, fallbackProducer );
	}
	else {
		return createBean( beanType, lifecycleOptions, fallbackProducer );
	}
}
 

@SuppressWarnings("unchecked")
private <B> ContainedBeanImplementor<B> createBean(
		Class<B> beanType,
		LifecycleOptions lifecycleOptions,
		BeanInstanceProducer fallbackProducer) {
	final ContainedBeanImplementor bean = createBean(
			beanType,
			lifecycleOptions.useJpaCompliantCreation()
					? JpaCompliantLifecycleStrategy.INSTANCE
					: ContainerManagedLifecycleStrategy.INSTANCE,
			fallbackProducer
	);
	registeredBeans.add( bean );
	return bean;
}