Uses of Class
org.springframework.beans.BeansException

Packages that use BeansException

Package	Description
org.springframework.aop.framework	Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
org.springframework.aop.framework.adapter	SPI package allowing Spring AOP framework to handle arbitrary advice types.
org.springframework.aop.framework.autoproxy	Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
org.springframework.aop.target
org.springframework.beans	This package contains interfaces and classes for manipulating Java beans.
org.springframework.beans.factory	The core package implementing Spring's lightweight Inversion of Control (IoC) container.
org.springframework.beans.factory.annotation	Support package for annotation-driven bean configuration.
org.springframework.beans.factory.config	SPI interfaces and configuration-related convenience classes for bean factories.
org.springframework.beans.factory.parsing	Support infrastructure for bean definition parsing.
org.springframework.beans.factory.support	Classes supporting the org.springframework.beans.factory package.
org.springframework.beans.factory.xml	Contains an abstract XML-based BeanFactory implementation, including a standard "spring-beans" XSD.
org.springframework.beans.support	Classes supporting the org.springframework.beans package, such as utility classes for sorting and holding lists of beans.
org.springframework.context	This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
org.springframework.context.expression	Expression parsing support within a Spring application context.
org.springframework.context.support	Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
org.springframework.context.weaving	Load-time weaving support for a Spring application context, building on Spring's LoadTimeWeaver abstraction.
org.springframework.dao.support	Support classes for DAO implementations, providing miscellaneous utility methods.
org.springframework.jms.annotation	Annotations and support classes for declarative JMS listener endpoints.
org.springframework.jndi.support	Support classes for JNDI usage, including a JNDI-based BeanFactory implementation.
org.springframework.messaging.core	Defines interfaces and implementation classes for messaging templates.
org.springframework.orm.hibernate5	Package providing integration of Hibernate 5.x with Spring concepts.
org.springframework.orm.jpa	Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.validation.beanvalidation	Support classes for integrating a JSR-303 Bean Validation provider (such as Hibernate Validator) into a Spring ApplicationContext and in particular with Spring's data binding and validation APIs.
org.springframework.web.context.support	Classes supporting the org.springframework.web.context package, such as WebApplicationContext implementations and various utility classes.
org.springframework.web.filter	Provides generic filter base classes allowing for bean-style configuration.
org.springframework.web.method.annotation	Support classes for annotation-based handler method processing.
org.springframework.web.reactive.handler	Provides HandlerMapping implementations including abstract base classes.
org.springframework.web.reactive.resource	Support classes for serving static resources.
org.springframework.web.reactive.result.view.freemarker	Support classes for the integration of FreeMarker as Spring web view technology.
org.springframework.web.reactive.result.view.script	Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
org.springframework.web.servlet	Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
org.springframework.web.servlet.handler	Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.resource	Support classes for serving static resources.
org.springframework.web.servlet.view	Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.view.freemarker	Support classes for the integration of FreeMarker as Spring web view technology.
org.springframework.web.servlet.view.groovy	Support classes for the integration of Groovy Templates as Spring web view technology.
org.springframework.web.servlet.view.script	Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
org.springframework.web.servlet.view.xslt	Support classes for XSLT, providing a View implementation for XSLT stylesheets.
org.springframework.web.socket.client.standard	Client-side classes for use with standard Java WebSocket endpoints.

Uses of BeansException in org.springframework.aop.framework

Methods in org.springframework.aop.framework that throw BeansException

Modifier and Type	Method	Description
Object	ProxyFactoryBean.getObject()	Return a proxy.

Uses of BeansException in org.springframework.aop.framework.adapter

Methods in org.springframework.aop.framework.adapter that throw BeansException

Modifier and Type	Method	Description
Object	AdvisorAdapterRegistrationManager.postProcessAfterInitialization(Object bean, String beanName)
Object	AdvisorAdapterRegistrationManager.postProcessBeforeInitialization(Object bean, String beanName)

Uses of BeansException in org.springframework.aop.framework.autoproxy

Methods in org.springframework.aop.framework.autoproxy that throw BeansException

Modifier and Type	Method	Description
protected abstract Object[]	AbstractAutoProxyCreator.getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource customTargetSource)	Return whether the given bean is to be proxied, what additional advices (e.g.

Uses of BeansException in org.springframework.aop.target

Methods in org.springframework.aop.target that throw BeansException

Modifier and Type	Method	Description
Object	LazyInitTargetSource.getTarget()
Object	PrototypeTargetSource.getTarget()	Obtain a new prototype instance for every call.
Object	ThreadLocalTargetSource.getTarget()	Implementation of abstract getTarget() method.
protected Object	AbstractPrototypeBasedTargetSource.newPrototypeInstance()	Subclasses should call this method to create a new prototype instance.
final void	AbstractPoolingTargetSource.setBeanFactory(BeanFactory beanFactory)
void	AbstractPrototypeBasedTargetSource.setBeanFactory(BeanFactory beanFactory)

Uses of BeansException in org.springframework.beans

Subclasses of BeansException in org.springframework.beans

Modifier and Type	Class	Description
class	BeanInstantiationException	Exception thrown when instantiation of a bean failed.
class	ConversionNotSupportedException	Exception thrown when no suitable editor or converter can be found for a bean property.
class	FatalBeanException	Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g.
class	InvalidPropertyException	Exception thrown when referring to an invalid bean property.
class	MethodInvocationException	Thrown when a bean property getter or setter method throws an exception, analogous to an InvocationTargetException.
class	NotReadablePropertyException	Exception thrown on an attempt to get the value of a property that isn't readable, because there's no getter method.
class	NotWritablePropertyException	Exception thrown on an attempt to set the value of a property that is not writable (typically because there is no setter method).
class	NullValueInNestedPathException	Exception thrown when navigation of a valid nested property path encounters a NullPointerException.
class	PropertyAccessException	Superclass for exceptions related to a property access, such as type mismatch or invocation target exception.
class	PropertyBatchUpdateException	Combined exception, composed of individual PropertyAccessException instances.
class	TypeMismatchException	Exception thrown on a type mismatch when trying to set a bean property.

Methods in org.springframework.beans that throw BeansException

Modifier and Type	Method	Description
static void	BeanUtils.copyProperties(Object source, Object target)	Copy the property values of the given source bean into the target bean.
static void	BeanUtils.copyProperties(Object source, Object target, Class<?> editable)	Copy the property values of the given source bean into the given target bean, only setting properties defined in the given "editable" class (or interface).
static void	BeanUtils.copyProperties(Object source, Object target, String... ignoreProperties)	Copy the property values of the given source bean into the given target bean, ignoring the given "ignoreProperties".
static PropertyDescriptor	BeanUtils.findPropertyForMethod(Method method)	Find a JavaBeans PropertyDescriptor for the given method, with the method either being the read method or the write method for that bean property.
static PropertyDescriptor	BeanUtils.findPropertyForMethod(Method method, Class<?> clazz)	Find a JavaBeans PropertyDescriptor for the given method, with the method either being the read method or the write method for that bean property.
static PropertyDescriptor	BeanUtils.getPropertyDescriptor(Class<?> clazz, String propertyName)	Retrieve the JavaBeans PropertyDescriptors for the given property.
static PropertyDescriptor[]	BeanUtils.getPropertyDescriptors(Class<?> clazz)	Retrieve the JavaBeans PropertyDescriptors of a given class.
protected AbstractNestablePropertyAccessor.PropertyHandler	AbstractNestablePropertyAccessor.getPropertyHandler(String propertyName)	Return the AbstractNestablePropertyAccessor.PropertyHandler for the specified propertyName, navigating if necessary.
Class<?>	AbstractNestablePropertyAccessor.getPropertyType(String propertyName)
Class<?>	PropertyAccessor.getPropertyType(String propertyName)	Determine the property type for the specified property, either checking the property descriptor or checking the value in case of an indexed or mapped element.
TypeDescriptor	AbstractNestablePropertyAccessor.getPropertyTypeDescriptor(String propertyName)
TypeDescriptor	PropertyAccessor.getPropertyTypeDescriptor(String propertyName)	Return a type descriptor for the specified property: preferably from the read method, falling back to the write method.
Object	AbstractNestablePropertyAccessor.getPropertyValue(String propertyName)
protected Object	AbstractNestablePropertyAccessor.getPropertyValue(AbstractNestablePropertyAccessor.PropertyTokenHolder tokens)
abstract Object	AbstractPropertyAccessor.getPropertyValue(String propertyName)	Actually get the value of a property.
Object	PropertyAccessor.getPropertyValue(String propertyName)	Get the current value of the specified property.
void	AbstractNestablePropertyAccessor.setPropertyValue(String propertyName, Object value)
protected void	AbstractNestablePropertyAccessor.setPropertyValue(AbstractNestablePropertyAccessor.PropertyTokenHolder tokens, PropertyValue pv)
void	AbstractNestablePropertyAccessor.setPropertyValue(PropertyValue pv)
abstract void	AbstractPropertyAccessor.setPropertyValue(String propertyName, Object value)	Actually set a property value.
void	AbstractPropertyAccessor.setPropertyValue(PropertyValue pv)
void	PropertyAccessor.setPropertyValue(String propertyName, Object value)	Set the specified value as current property value.
void	PropertyAccessor.setPropertyValue(PropertyValue pv)	Set the specified value as current property value.
void	AbstractPropertyAccessor.setPropertyValues(Map<?,?> map)
void	AbstractPropertyAccessor.setPropertyValues(PropertyValues pvs)
void	AbstractPropertyAccessor.setPropertyValues(PropertyValues pvs, boolean ignoreUnknown)
void	AbstractPropertyAccessor.setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
void	PropertyAccessor.setPropertyValues(Map<?,?> map)	Perform a batch update from a Map.
void	PropertyAccessor.setPropertyValues(PropertyValues pvs)	The preferred way to perform a batch update.
void	PropertyAccessor.setPropertyValues(PropertyValues pvs, boolean ignoreUnknown)	Perform a batch update with more control over behavior.
void	PropertyAccessor.setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)	Perform a batch update with full control over behavior.

Uses of BeansException in org.springframework.beans.factory

Subclasses of BeansException in org.springframework.beans.factory

Modifier and Type	Class	Description
class	BeanCreationException	Exception thrown when a BeanFactory encounters an error when attempting to create a bean from a bean definition.
class	BeanCreationNotAllowedException	Exception thrown in case of a bean being requested despite bean creation currently not being allowed (for example, during the shutdown phase of a bean factory).
class	BeanCurrentlyInCreationException	Exception thrown in case of a reference to a bean that's currently in creation.
class	BeanDefinitionStoreException	Exception thrown when a BeanFactory encounters an invalid bean definition: e.g.
class	BeanExpressionException	Exception that indicates an expression evaluation attempt having failed.
class	BeanInitializationException	Exception that a bean implementation is suggested to throw if its own factory-aware initialization code fails.
class	BeanIsAbstractException	Exception thrown when a bean instance has been requested for a bean definition which has been marked as abstract.
class	BeanIsNotAFactoryException	Exception thrown when a bean is not a factory, but a user tries to get at the factory for the given bean name.
class	BeanNotOfRequiredTypeException	Thrown when a bean doesn't match the expected type.
class	CannotLoadBeanClassException	Exception thrown when the BeanFactory cannot load the specified class of a given bean.
class	FactoryBeanNotInitializedException	Exception to be thrown from a FactoryBean's getObject() method if the bean is not fully initialized yet, for example because it is involved in a circular reference.
class	NoSuchBeanDefinitionException	Exception thrown when a BeanFactory is asked for a bean instance for which it cannot find a definition.
class	NoUniqueBeanDefinitionException	Exception thrown when a BeanFactory is asked for a bean instance for which multiple matching candidates have been found when only one matching bean was expected.
class	UnsatisfiedDependencyException	Exception thrown when a bean depends on other beans or simple properties that were not specified in the bean factory definition, although dependency checking was enabled.

Methods in org.springframework.beans.factory that throw BeansException

Modifier and Type	Method	Description
static <T> T	BeanFactoryUtils.beanOfType(ListableBeanFactory lbf, Class<T> type)	Return a single bean of the given type or subtypes, not looking in ancestor factories.
static <T> T	BeanFactoryUtils.beanOfType(ListableBeanFactory lbf, Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)	Return a single bean of the given type or subtypes, not looking in ancestor factories.
static <T> T	BeanFactoryUtils.beanOfTypeIncludingAncestors(ListableBeanFactory lbf, Class<T> type)	Return a single bean of the given type or subtypes, also picking up beans defined in ancestor bean factories if the current bean factory is a HierarchicalBeanFactory.
static <T> T	BeanFactoryUtils.beanOfTypeIncludingAncestors(ListableBeanFactory lbf, Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)	Return a single bean of the given type or subtypes, also picking up beans defined in ancestor bean factories if the current bean factory is a HierarchicalBeanFactory.
static <T> Map<String,T>	BeanFactoryUtils.beansOfTypeIncludingAncestors(ListableBeanFactory lbf, Class<T> type)	Return all beans of the given type or subtypes, also picking up beans defined in ancestor bean factories if the current bean factory is a HierarchicalBeanFactory.
static <T> Map<String,T>	BeanFactoryUtils.beansOfTypeIncludingAncestors(ListableBeanFactory lbf, Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)	Return all beans of the given type or subtypes, also picking up beans defined in ancestor bean factories if the current bean factory is a HierarchicalBeanFactory.
<T> T	BeanFactory.getBean(Class<T> requiredType)	Return the bean instance that uniquely matches the given object type, if any.
<T> T	BeanFactory.getBean(Class<T> requiredType, Object... args)	Return an instance, which may be shared or independent, of the specified bean.
Object	BeanFactory.getBean(String name)	Return an instance, which may be shared or independent, of the specified bean.
<T> T	BeanFactory.getBean(String name, Class<T> requiredType)	Return an instance, which may be shared or independent, of the specified bean.
Object	BeanFactory.getBean(String name, Object... args)	Return an instance, which may be shared or independent, of the specified bean.
<T> Map<String,T>	ListableBeanFactory.getBeansOfType(Class<T> type)	Return the bean instances that match the given object type (including subclasses), judging from either bean definitions or the value of getObjectType in the case of FactoryBeans.
<T> Map<String,T>	ListableBeanFactory.getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)	Return the bean instances that match the given object type (including subclasses), judging from either bean definitions or the value of getObjectType in the case of FactoryBeans.
Map<String,Object>	ListableBeanFactory.getBeansWithAnnotation(Class<? extends Annotation> annotationType)	Find all beans which are annotated with the supplied Annotation type, returning a Map of bean names with corresponding bean instances.
T	ObjectProvider.getIfAvailable()	Return an instance (possibly shared or independent) of the object managed by this factory.
default T	ObjectProvider.getIfAvailable(Supplier<T> defaultSupplier)	Return an instance (possibly shared or independent) of the object managed by this factory.
T	ObjectProvider.getIfUnique()	Return an instance (possibly shared or independent) of the object managed by this factory.
default T	ObjectProvider.getIfUnique(Supplier<T> defaultSupplier)	Return an instance (possibly shared or independent) of the object managed by this factory.
T	ObjectFactory.getObject()	Return an instance (possibly shared or independent) of the object managed by this factory.
T	ObjectProvider.getObject(Object... args)	Return an instance (possibly shared or independent) of the object managed by this factory.
default void	ObjectProvider.ifAvailable(Consumer<T> dependencyConsumer)	Consume an instance (possibly shared or independent) of the object managed by this factory, if available.
default void	ObjectProvider.ifUnique(Consumer<T> dependencyConsumer)	Consume an instance (possibly shared or independent) of the object managed by this factory, if unique.
void	BeanFactoryAware.setBeanFactory(BeanFactory beanFactory)	Callback that supplies the owning factory to a bean instance.

Constructors in org.springframework.beans.factory with parameters of type BeansException

Modifier	Constructor	Description
	UnsatisfiedDependencyException(String resourceDescription, String beanName, String propertyName, BeansException ex)	Create a new UnsatisfiedDependencyException.
	UnsatisfiedDependencyException(String resourceDescription, String beanName, InjectionPoint injectionPoint, BeansException ex)	Create a new UnsatisfiedDependencyException.

Uses of BeansException in org.springframework.beans.factory.annotation

Methods in org.springframework.beans.factory.annotation that throw BeansException

Modifier and Type	Method	Description
protected <T> Map<String,T>	AutowiredAnnotationBeanPostProcessor.findAutowireCandidates(Class<T> type)	Obtain all beans of the given type as autowire candidates.
Object	InitDestroyAnnotationBeanPostProcessor.postProcessAfterInitialization(Object bean, String beanName)
void	CustomAutowireConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
void	InitDestroyAnnotationBeanPostProcessor.postProcessBeforeDestruction(Object bean, String beanName)
Object	InitDestroyAnnotationBeanPostProcessor.postProcessBeforeInitialization(Object bean, String beanName)
static <T> T	BeanFactoryAnnotationUtils.qualifiedBeanOfType(BeanFactory beanFactory, Class<T> beanType, String qualifier)	Obtain a bean of type T from the given BeanFactory declaring a qualifier (e.g.
static <T> Map<String,T>	BeanFactoryAnnotationUtils.qualifiedBeansOfType(ListableBeanFactory beanFactory, Class<T> beanType, String qualifier)	Retrieve all beans of type T from the given BeanFactory declaring a qualifier (e.g.
static Object	ParameterResolutionDelegate.resolveDependency(Parameter parameter, int parameterIndex, Class<?> containingClass, AutowireCapableBeanFactory beanFactory)	Resolve the dependency for the supplied Parameter from the supplied AutowireCapableBeanFactory.

Uses of BeansException in org.springframework.beans.factory.config

Methods in org.springframework.beans.factory.config with parameters of type BeansException

Modifier and Type	Method	Description
protected Exception	ServiceLocatorFactoryBean.createServiceLocatorException(Constructor<Exception> exceptionConstructor, BeansException cause)	Create a service locator exception for the given cause.

Methods in org.springframework.beans.factory.config that throw BeansException

Modifier and Type	Method	Description
Object	AutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)	Apply BeanPostProcessors to the given existing bean instance, invoking their postProcessAfterInitialization methods.
Object	AutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)	Apply BeanPostProcessors to the given existing bean instance, invoking their postProcessBeforeInitialization methods.
void	AutowireCapableBeanFactory.applyBeanPropertyValues(Object existingBean, String beanName)	Apply the property values of the bean definition with the given name to the given bean instance.
Object	AutowireCapableBeanFactory.autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck)	Instantiate a new bean instance of the given class with the specified autowire strategy.
void	AutowireCapableBeanFactory.autowireBean(Object existingBean)	Populate the given bean instance through applying after-instantiation callbacks and bean property post-processing (e.g.
void	AutowireCapableBeanFactory.autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)	Autowire the bean properties of the given bean instance by name or type.
Object	AutowireCapableBeanFactory.configureBean(Object existingBean, String beanName)	Configure the given raw bean: autowiring bean properties, applying bean property values, applying factory callbacks such as setBeanName and setBeanFactory, and also applying all bean post processors (including ones which might wrap the given raw bean).
Object	AutowireCapableBeanFactory.createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck)	Fully create a new bean instance of the given class with the specified autowire strategy.
<T> T	AutowireCapableBeanFactory.createBean(Class<T> beanClass)	Fully create a new bean instance of the given class.
default Constructor<?>[]	SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors(Class<?> beanClass, String beanName)	Determine the candidate constructors to use for the given bean.
Object	BeanExpressionResolver.evaluate(String value, BeanExpressionContext beanExpressionContext)	Evaluate the given value as an expression, if applicable; return the value as-is otherwise.
default Object	SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference(Object bean, String beanName)	Obtain a reference for early access to the specified bean, typically for the purpose of resolving a circular reference.
Object	PropertyPathFactoryBean.getObject()
Object	AutowireCapableBeanFactory.initializeBean(Object existingBean, String beanName)	Initialize the given raw bean, applying factory callbacks such as setBeanName and setBeanFactory, also applying all bean post processors (including ones which might wrap the given raw bean).
default Object	BeanPostProcessor.postProcessAfterInitialization(Object bean, String beanName)	Apply this BeanPostProcessor to the given new bean instance after any bean initialization callbacks (like InitializingBean's afterPropertiesSet or a custom init-method).
default boolean	InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation(Object bean, String beanName)	Perform operations after the bean has been instantiated, via a constructor or factory method, but before Spring property population (from explicit properties or autowiring) occurs.
void	BeanFactoryPostProcessor.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)	Modify the application context's internal bean factory after its standard initialization.
void	CustomEditorConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
void	CustomScopeConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
void	DeprecatedBeanWarner.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
void	PropertyResourceConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)	Merge, convert and process properties against the given bean factory.
void	DestructionAwareBeanPostProcessor.postProcessBeforeDestruction(Object bean, String beanName)	Apply this BeanPostProcessor to the given bean instance before its destruction, e.g.
default Object	BeanPostProcessor.postProcessBeforeInitialization(Object bean, String beanName)	Apply this BeanPostProcessor to the given new bean instance before any bean initialization callbacks (like InitializingBean's afterPropertiesSet or a custom init-method).
default Object	InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(Class<?> beanClass, String beanName)	Apply this BeanPostProcessor before the target bean gets instantiated.
default PropertyValues	InstantiationAwareBeanPostProcessor.postProcessProperties(PropertyValues pvs, Object bean, String beanName)	Post-process the given property values before the factory applies them to the given bean.
default Class<?>	SmartInstantiationAwareBeanPostProcessor.predictBeanType(Class<?> beanClass, String beanName)	Predict the type of the bean to be eventually returned from this processor's InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String) callback.
void	ConfigurableListableBeanFactory.preInstantiateSingletons()	Ensure that all non-lazy-init singletons are instantiated, also considering FactoryBeans.
protected void	PropertyOverrideConfigurer.processKey(ConfigurableListableBeanFactory factory, String key, String value)	Process the given key as 'beanName.property' entry.
protected void	PropertyOverrideConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)
protected void	PropertyPlaceholderConfigurer.processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)	Deprecated. Visit each bean definition in the given bean factory and attempt to replace ${...} property placeholders with values from the given properties.
protected abstract void	PropertyResourceConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)	Apply the given Properties to the given BeanFactory.
Object	AutowireCapableBeanFactory.resolveBeanByName(String name, DependencyDescriptor descriptor)	Resolve a bean instance for the given bean name, providing a dependency descriptor for exposure to target factory methods.
Object	DependencyDescriptor.resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)	Resolve the specified bean name, as a candidate result of the matching algorithm for this dependency, to a bean instance from the given factory.
Object	AutowireCapableBeanFactory.resolveDependency(DependencyDescriptor descriptor, String requestingBeanName)	Resolve the specified dependency against the beans defined in this factory.
Object	AutowireCapableBeanFactory.resolveDependency(DependencyDescriptor descriptor, String requestingBeanName, Set<String> autowiredBeanNames, TypeConverter typeConverter)	Resolve the specified dependency against the beans defined in this factory.
<T> NamedBeanHolder<T>	AutowireCapableBeanFactory.resolveNamedBean(Class<T> requiredType)	Resolve the bean instance that uniquely matches the given object type, if any, including its bean name.
Object	DependencyDescriptor.resolveNotUnique(ResolvableType type, Map<String,Object> matchingBeans)	Resolve the specified not-unique scenario: by default, throwing a NoUniqueBeanDefinitionException.
Object	DependencyDescriptor.resolveShortcut(BeanFactory beanFactory)	Resolve a shortcut for this dependency against the given factory, for example taking some pre-resolved information into account.
void	ServiceLocatorFactoryBean.setBeanFactory(BeanFactory beanFactory)

Uses of BeansException in org.springframework.beans.factory.parsing

Subclasses of BeansException in org.springframework.beans.factory.parsing

Modifier and Type	Class	Description
class	BeanDefinitionParsingException	Exception thrown when a bean definition reader encounters an error during the parsing process.

Uses of BeansException in org.springframework.beans.factory.support

Subclasses of BeansException in org.springframework.beans.factory.support

Modifier and Type	Class	Description
class	BeanDefinitionOverrideException	Subclass of BeanDefinitionStoreException indicating an invalid override attempt: typically registering a new definition for the same bean name while DefaultListableBeanFactory.isAllowBeanDefinitionOverriding() is false.
class	BeanDefinitionValidationException	Exception thrown when the validation of a bean definition failed.
class	ScopeNotActiveException	A subclass of BeanCreationException which indicates that the target scope is not active, e.g.

Methods in org.springframework.beans.factory.support that throw BeansException

Modifier and Type	Method	Description
Object	AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
Object	AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
void	AbstractAutowireCapableBeanFactory.applyBeanPropertyValues(Object existingBean, String beanName)
Object	AbstractAutowireCapableBeanFactory.autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck)
void	AbstractAutowireCapableBeanFactory.autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
Object	AbstractAutowireCapableBeanFactory.configureBean(Object existingBean, String beanName)
Object	AbstractAutowireCapableBeanFactory.createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck)
<T> T	AbstractAutowireCapableBeanFactory.createBean(Class<T> beanClass)
protected Constructor<?>[]	AbstractAutowireCapableBeanFactory.determineConstructorsFromBeanPostProcessors(Class<?> beanClass, String beanName)	Determine candidate constructors to use for the given bean, checking all registered SmartInstantiationAwareBeanPostProcessors.
protected <T> T	AbstractBeanFactory.doGetBean(String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly)	Return an instance, which may be shared or independent, of the specified bean.
Object	DefaultListableBeanFactory.doResolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter)
Object	AbstractBeanFactory.getBean(String name)
<T> T	AbstractBeanFactory.getBean(String name, Class<T> requiredType)
<T> T	AbstractBeanFactory.getBean(String name, Class<T> requiredType, Object... args)	Return an instance, which may be shared or independent, of the specified bean.
Object	AbstractBeanFactory.getBean(String name, Object... args)
<T> T	DefaultListableBeanFactory.getBean(Class<T> requiredType)
<T> T	DefaultListableBeanFactory.getBean(Class<T> requiredType, Object... args)
<T> T	StaticListableBeanFactory.getBean(Class<T> requiredType)
<T> T	StaticListableBeanFactory.getBean(Class<T> requiredType, Object... args)
Object	StaticListableBeanFactory.getBean(String name)
<T> T	StaticListableBeanFactory.getBean(String name, Class<T> requiredType)
Object	StaticListableBeanFactory.getBean(String name, Object... args)
protected abstract BeanDefinition	AbstractBeanFactory.getBeanDefinition(String beanName)	Return the bean definition for the given bean name.
<T> ObjectProvider<T>	StaticListableBeanFactory.getBeanProvider(Class<T> requiredType)
<T> Map<String,T>	DefaultListableBeanFactory.getBeansOfType(Class<T> type)
<T> Map<String,T>	DefaultListableBeanFactory.getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
<T> Map<String,T>	StaticListableBeanFactory.getBeansOfType(Class<T> type)
<T> Map<String,T>	StaticListableBeanFactory.getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
Map<String,Object>	StaticListableBeanFactory.getBeansWithAnnotation(Class<? extends Annotation> annotationType)
protected FactoryBean<?>	FactoryBeanRegistrySupport.getFactoryBean(String beanName, Object beanInstance)	Get a FactoryBean for the given bean if possible.
BeanDefinition	AbstractBeanFactory.getMergedBeanDefinition(String name)	Return a 'merged' BeanDefinition for the given bean name, merging a child bean definition with its parent if necessary.
protected RootBeanDefinition	AbstractBeanFactory.getMergedLocalBeanDefinition(String beanName)	Return a merged RootBeanDefinition, traversing the parent bean definition if the specified bean corresponds to a child bean definition.
Object	InstantiationStrategy.instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner)	Return an instance of the bean with the given name in this factory.
Object	InstantiationStrategy.instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner, Object factoryBean, Method factoryMethod, Object... args)	Return an instance of the bean with the given name in this factory, creating it via the given factory method.
Object	InstantiationStrategy.instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner, Constructor<?> ctor, Object... args)	Return an instance of the bean with the given name in this factory, creating it via the given constructor.
void	BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)	Modify the application context's internal bean definition registry after its standard initialization.
protected Object	FactoryBeanRegistrySupport.postProcessObjectFromFactoryBean(Object object, String beanName)	Post-process the given object that has been obtained from the FactoryBean.
void	DefaultListableBeanFactory.preInstantiateSingletons()
protected void	PropertiesBeanDefinitionReader.registerBeanDefinition(String beanName, Map<?,?> map, String prefix, String resourceDescription)	Deprecated. Get all property values, given a prefix (which will be stripped) and add the bean they define to the factory with the given name.
int	PropertiesBeanDefinitionReader.registerBeanDefinitions(Map<?,?> map)	Deprecated. Register bean definitions contained in a Map, using all property keys (i.e.
int	PropertiesBeanDefinitionReader.registerBeanDefinitions(Map<?,?> map, String prefix)	Deprecated. Register bean definitions contained in a Map.
int	PropertiesBeanDefinitionReader.registerBeanDefinitions(Map<?,?> map, String prefix, String resourceDescription)	Deprecated. Register bean definitions contained in a Map.
Object	AbstractAutowireCapableBeanFactory.resolveDependency(DependencyDescriptor descriptor, String requestingBeanName)
Object	DefaultListableBeanFactory.resolveDependency(DependencyDescriptor descriptor, String requestingBeanName, Set<String> autowiredBeanNames, TypeConverter typeConverter)
<T> NamedBeanHolder<T>	DefaultListableBeanFactory.resolveNamedBean(Class<T> requiredType)

Uses of BeansException in org.springframework.beans.factory.xml

Subclasses of BeansException in org.springframework.beans.factory.xml

Modifier and Type	Class	Description
class	XmlBeanDefinitionStoreException	XML-specific BeanDefinitionStoreException subclass that wraps a SAXException, typically a SAXParseException which contains information about the error location.

Uses of BeansException in org.springframework.beans.support

Methods in org.springframework.beans.support that throw BeansException

Modifier and Type	Method	Description
static void	PropertyComparator.sort(Object[] source, SortDefinition sortDefinition)	Sort the given source according to the given sort definition.
static void	PropertyComparator.sort(List<?> source, SortDefinition sortDefinition)	Sort the given List according to the given sort definition.

Uses of BeansException in org.springframework.context

Subclasses of BeansException in org.springframework.context

Modifier and Type	Class	Description
class	ApplicationContextException	Exception thrown during application context initialization.

Methods in org.springframework.context that throw BeansException

Modifier and Type	Method	Description
void	ConfigurableApplicationContext.refresh()	Load or refresh the persistent representation of the configuration, which might be from Java-based configuration, an XML file, a properties file, a relational database schema, or some other format.
void	ApplicationContextAware.setApplicationContext(ApplicationContext applicationContext)	Set the ApplicationContext that this object runs in.

Uses of BeansException in org.springframework.context.expression

Methods in org.springframework.context.expression that throw BeansException

Modifier and Type	Method	Description
Object	StandardBeanExpressionResolver.evaluate(String value, BeanExpressionContext beanExpressionContext)

Uses of BeansException in org.springframework.context.support

Methods in org.springframework.context.support with parameters of type BeansException

Modifier and Type	Method	Description
protected void	AbstractApplicationContext.cancelRefresh(BeansException ex)	Cancel this context's refresh attempt, resetting the active flag after an exception got thrown.
protected void	AbstractRefreshableApplicationContext.cancelRefresh(BeansException ex)
protected void	GenericApplicationContext.cancelRefresh(BeansException ex)

Methods in org.springframework.context.support that throw BeansException

Modifier and Type	Method	Description
<T> T	AbstractApplicationContext.getBean(Class<T> requiredType)
<T> T	AbstractApplicationContext.getBean(Class<T> requiredType, Object... args)
Object	AbstractApplicationContext.getBean(String name)
<T> T	AbstractApplicationContext.getBean(String name, Class<T> requiredType)
Object	AbstractApplicationContext.getBean(String name, Object... args)
<T> Map<String,T>	AbstractApplicationContext.getBeansOfType(Class<T> type)
<T> Map<String,T>	AbstractApplicationContext.getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
Map<String,Object>	AbstractApplicationContext.getBeansWithAnnotation(Class<? extends Annotation> annotationType)
protected void	ApplicationObjectSupport.initApplicationContext()	Subclasses can override this for custom initialization behavior.
protected void	ApplicationObjectSupport.initApplicationContext(ApplicationContext context)	Subclasses can override this for custom initialization behavior.
protected abstract void	AbstractRefreshableApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory)	Load bean definitions into the given bean factory, typically through delegating to one or more bean definition readers.
protected void	AbstractXmlApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory)	Loads the bean definitions via an XmlBeanDefinitionReader.
protected void	AbstractXmlApplicationContext.loadBeanDefinitions(XmlBeanDefinitionReader reader)	Load the bean definitions with the given XmlBeanDefinitionReader.
protected void	AbstractApplicationContext.onRefresh()	Template method which can be overridden to add context-specific refresh work.
void	PropertySourcesPlaceholderConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)	Processing occurs by replacing ${...} placeholders in bean definitions by resolving each against this configurer's set of PropertySources, which includes: all environment property sources, if an Environment is present merged local properties, if any have been specified any property sources set by calling PropertySourcesPlaceholderConfigurer.setPropertySources(org.springframework.core.env.PropertySources)
protected void	PropertySourcesPlaceholderConfigurer.processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, ConfigurablePropertyResolver propertyResolver)	Visit each bean definition in the given bean factory and attempt to replace ${...} property placeholders with values from the given properties.
void	AbstractApplicationContext.refresh()
protected abstract void	AbstractApplicationContext.refreshBeanFactory()	Subclasses must implement this method to perform the actual configuration load.
protected final void	AbstractRefreshableApplicationContext.refreshBeanFactory()	This implementation performs an actual refresh of this context's underlying bean factory, shutting down the previous bean factory (if any) and initializing a fresh bean factory for the next phase of the context's lifecycle.
void	StaticApplicationContext.registerPrototype(String name, Class<?> clazz)	Register a prototype bean with the underlying bean factory.
void	StaticApplicationContext.registerPrototype(String name, Class<?> clazz, MutablePropertyValues pvs)	Register a prototype bean with the underlying bean factory.
void	StaticApplicationContext.registerSingleton(String name, Class<?> clazz)	Register a singleton bean with the underlying bean factory.
void	StaticApplicationContext.registerSingleton(String name, Class<?> clazz, MutablePropertyValues pvs)	Register a singleton bean with the underlying bean factory.
final void	ApplicationObjectSupport.setApplicationContext(ApplicationContext context)

Constructors in org.springframework.context.support that throw BeansException

Modifier	Constructor	Description
	ClassPathXmlApplicationContext(String configLocation)	Create a new ClassPathXmlApplicationContext, loading the definitions from the given XML file and automatically refreshing the context.
	ClassPathXmlApplicationContext(String... configLocations)	Create a new ClassPathXmlApplicationContext, loading the definitions from the given XML files and automatically refreshing the context.
	ClassPathXmlApplicationContext(String[] configLocations, boolean refresh)	Create a new ClassPathXmlApplicationContext, loading the definitions from the given XML files.
	ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)	Create a new ClassPathXmlApplicationContext with the given parent, loading the definitions from the given XML files.
	ClassPathXmlApplicationContext(String[] paths, Class<?> clazz)	Create a new ClassPathXmlApplicationContext, loading the definitions from the given XML files and automatically refreshing the context.
	ClassPathXmlApplicationContext(String[] paths, Class<?> clazz, ApplicationContext parent)	Create a new ClassPathXmlApplicationContext with the given parent, loading the definitions from the given XML files and automatically refreshing the context.
	ClassPathXmlApplicationContext(String[] configLocations, ApplicationContext parent)	Create a new ClassPathXmlApplicationContext with the given parent, loading the definitions from the given XML files and automatically refreshing the context.
	ClassPathXmlApplicationContext(String path, Class<?> clazz)	Create a new ClassPathXmlApplicationContext, loading the definitions from the given XML file and automatically refreshing the context.
	FileSystemXmlApplicationContext(String configLocation)	Create a new FileSystemXmlApplicationContext, loading the definitions from the given XML file and automatically refreshing the context.
	FileSystemXmlApplicationContext(String... configLocations)	Create a new FileSystemXmlApplicationContext, loading the definitions from the given XML files and automatically refreshing the context.
	FileSystemXmlApplicationContext(String[] configLocations, boolean refresh)	Create a new FileSystemXmlApplicationContext, loading the definitions from the given XML files.
	FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)	Create a new FileSystemXmlApplicationContext with the given parent, loading the definitions from the given XML files.
	FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent)	Create a new FileSystemXmlApplicationContext with the given parent, loading the definitions from the given XML files and automatically refreshing the context.
	StaticApplicationContext()	Create a new StaticApplicationContext.
	StaticApplicationContext(ApplicationContext parent)	Create a new StaticApplicationContext with the given parent.

Uses of BeansException in org.springframework.context.weaving

Methods in org.springframework.context.weaving that throw BeansException

Modifier and Type	Method	Description
void	AspectJWeavingEnabler.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
Object	LoadTimeWeaverAwareProcessor.postProcessBeforeInitialization(Object bean, String beanName)

Uses of BeansException in org.springframework.dao.support

Methods in org.springframework.dao.support that throw BeansException

Modifier and Type	Method	Description
void	PersistenceExceptionTranslationInterceptor.setBeanFactory(BeanFactory beanFactory)

Uses of BeansException in org.springframework.jms.annotation

Methods in org.springframework.jms.annotation that throw BeansException

Modifier and Type	Method	Description
Object	JmsListenerAnnotationBeanPostProcessor.postProcessAfterInitialization(Object bean, String beanName)
Object	JmsListenerAnnotationBeanPostProcessor.postProcessBeforeInitialization(Object bean, String beanName)

Uses of BeansException in org.springframework.jndi.support

Methods in org.springframework.jndi.support that throw BeansException

Modifier and Type	Method	Description
<T> T	SimpleJndiBeanFactory.getBean(Class<T> requiredType)
<T> T	SimpleJndiBeanFactory.getBean(Class<T> requiredType, Object... args)
Object	SimpleJndiBeanFactory.getBean(String name)
<T> T	SimpleJndiBeanFactory.getBean(String name, Class<T> requiredType)
Object	SimpleJndiBeanFactory.getBean(String name, Object... args)

Uses of BeansException in org.springframework.messaging.core

Methods in org.springframework.messaging.core that throw BeansException

Modifier and Type	Method	Description
void	GenericMessagingTemplate.setBeanFactory(BeanFactory beanFactory)

Uses of BeansException in org.springframework.orm.hibernate5

Methods in org.springframework.orm.hibernate5 that throw BeansException

Modifier and Type	Method	Description
Interceptor	HibernateTransactionManager.getEntityInterceptor()	Return the current Hibernate entity interceptor, or null if none.

Uses of BeansException in org.springframework.orm.jpa

Methods in org.springframework.orm.jpa that throw BeansException

Modifier and Type	Method	Description
void	EntityManagerFactoryAccessor.setBeanFactory(BeanFactory beanFactory)	Retrieves an EntityManagerFactory by persistence unit name, if none set explicitly.
void	JpaTransactionManager.setBeanFactory(BeanFactory beanFactory)	Retrieves an EntityManagerFactory by persistence unit name, if none set explicitly.

Uses of BeansException in org.springframework.validation.beanvalidation

Methods in org.springframework.validation.beanvalidation that throw BeansException

Modifier and Type	Method	Description
Object	BeanValidationPostProcessor.postProcessAfterInitialization(Object bean, String beanName)
Object	BeanValidationPostProcessor.postProcessBeforeInitialization(Object bean, String beanName)

Uses of BeansException in org.springframework.web.context.support

Methods in org.springframework.web.context.support that throw BeansException

Modifier and Type	Method	Description
protected void	GroovyWebApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory)	Loads the bean definitions via an GroovyBeanDefinitionReader.
protected void	XmlWebApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory)	Loads the bean definitions via an XmlBeanDefinitionReader.
Object	ServletContextAwareProcessor.postProcessBeforeInitialization(Object bean, String beanName)

Uses of BeansException in org.springframework.web.filter

Methods in org.springframework.web.filter that throw BeansException

Modifier and Type	Method	Description
protected void	GenericFilterBean.initBeanWrapper(BeanWrapper bw)	Initialize the BeanWrapper for this GenericFilterBean, possibly with custom editors.

Uses of BeansException in org.springframework.web.method.annotation

Subclasses of BeansException in org.springframework.web.method.annotation

Modifier and Type	Class	Description
class	MethodArgumentConversionNotSupportedException	A ConversionNotSupportedException raised while resolving a method argument.
class	MethodArgumentTypeMismatchException	A TypeMismatchException raised while resolving a controller method argument.

Uses of BeansException in org.springframework.web.reactive.handler

Methods in org.springframework.web.reactive.handler that throw BeansException

Modifier and Type	Method	Description
void	SimpleUrlHandlerMapping.initApplicationContext()	Calls the SimpleUrlHandlerMapping.registerHandlers(java.util.Map<java.lang.String, java.lang.Object>) method in addition to the superclass's initialization.
protected void	AbstractUrlHandlerMapping.registerHandler(String[] urlPaths, String beanName)	Register the specified handler for the given URL paths.
protected void	AbstractUrlHandlerMapping.registerHandler(String urlPath, Object handler)	Register the specified handler for the given URL path.
protected void	SimpleUrlHandlerMapping.registerHandlers(Map<String,Object> urlMap)	Register all handlers specified in the URL map for the corresponding paths.

Uses of BeansException in org.springframework.web.reactive.resource

Methods in org.springframework.web.reactive.resource that throw BeansException

Modifier and Type	Method	Description
void	ResourceUrlProvider.setApplicationContext(ApplicationContext applicationContext)

Uses of BeansException in org.springframework.web.reactive.result.view.freemarker

Methods in org.springframework.web.reactive.result.view.freemarker that throw BeansException

Modifier and Type	Method	Description
protected FreeMarkerConfig	FreeMarkerView.autodetectConfiguration()	Autodetect a FreeMarkerConfig object in the ApplicationContext.

Uses of BeansException in org.springframework.web.reactive.result.view.script

Methods in org.springframework.web.reactive.result.view.script that throw BeansException

Modifier and Type	Method	Description
protected ScriptTemplateConfig	ScriptTemplateView.autodetectViewConfig()

Uses of BeansException in org.springframework.web.servlet

Methods in org.springframework.web.servlet that throw BeansException

Modifier and Type	Method	Description
protected void	HttpServletBean.initBeanWrapper(BeanWrapper bw)	Initialize the BeanWrapper for this HttpServletBean, possibly with custom editors.

Uses of BeansException in org.springframework.web.servlet.handler

Methods in org.springframework.web.servlet.handler that throw BeansException

Modifier and Type	Method	Description
protected void	AbstractDetectingUrlHandlerMapping.detectHandlers()	Register all handlers found in the current ApplicationContext.
protected void	AbstractHandlerMapping.initApplicationContext()	Initializes the interceptors.
void	SimpleUrlHandlerMapping.initApplicationContext()	Calls the SimpleUrlHandlerMapping.registerHandlers(java.util.Map<java.lang.String, java.lang.Object>) method in addition to the superclass's initialization.
Object	SimpleServletPostProcessor.postProcessAfterInitialization(Object bean, String beanName)
void	SimpleServletPostProcessor.postProcessBeforeDestruction(Object bean, String beanName)
Object	SimpleServletPostProcessor.postProcessBeforeInitialization(Object bean, String beanName)
protected void	AbstractUrlHandlerMapping.registerHandler(String[] urlPaths, String beanName)	Register the specified handler for the given URL paths.
protected void	AbstractUrlHandlerMapping.registerHandler(String urlPath, Object handler)	Register the specified handler for the given URL path.
protected void	SimpleUrlHandlerMapping.registerHandlers(Map<String,Object> urlMap)	Register all handlers specified in the URL map for the corresponding paths.

Uses of BeansException in org.springframework.web.servlet.resource

Methods in org.springframework.web.servlet.resource that throw BeansException

Modifier and Type	Method	Description
void	ResourceUrlProvider.setApplicationContext(ApplicationContext applicationContext)

Uses of BeansException in org.springframework.web.servlet.view

Methods in org.springframework.web.servlet.view that throw BeansException

Modifier and Type	Method	Description
void	ResourceBundleViewResolver.afterPropertiesSet()	Deprecated. Eagerly initialize Locales if necessary.
void	XmlViewResolver.afterPropertiesSet()	Deprecated. Pre-initialize the factory from the XML file.
void	ResourceBundleViewResolver.destroy()	Deprecated. Close the bundle View factories on context shutdown.
void	XmlViewResolver.destroy()	Deprecated. Close the view bean factory on context shutdown.
protected BeanFactory	ResourceBundleViewResolver.initFactory(Locale locale)	Deprecated. Initialize the View BeanFactory from the ResourceBundle, for the given locale.
protected BeanFactory	XmlViewResolver.initFactory()	Deprecated. Initialize the view bean factory from the XML file.
protected View	XmlViewResolver.loadView(String viewName, Locale locale)	Deprecated.
View	BeanNameViewResolver.resolveViewName(String viewName, Locale locale)
void	ViewResolverComposite.setApplicationContext(ApplicationContext applicationContext)

Uses of BeansException in org.springframework.web.servlet.view.freemarker

Methods in org.springframework.web.servlet.view.freemarker that throw BeansException

Modifier and Type	Method	Description
protected FreeMarkerConfig	FreeMarkerView.autodetectConfiguration()	Autodetect a FreeMarkerConfig object via the ApplicationContext.
protected void	FreeMarkerView.initServletContext(ServletContext servletContext)	Invoked on startup.

Uses of BeansException in org.springframework.web.servlet.view.groovy

Methods in org.springframework.web.servlet.view.groovy that throw BeansException

Modifier and Type	Method	Description
protected groovy.text.markup.MarkupTemplateEngine	GroovyMarkupView.autodetectMarkupTemplateEngine()	Autodetect a MarkupTemplateEngine via the ApplicationContext.

Uses of BeansException in org.springframework.web.servlet.view.script

Methods in org.springframework.web.servlet.view.script that throw BeansException

Modifier and Type	Method	Description
protected ScriptTemplateConfig	ScriptTemplateView.autodetectViewConfig()

Uses of BeansException in org.springframework.web.servlet.view.xslt

Methods in org.springframework.web.servlet.view.xslt that throw BeansException

Modifier and Type	Method	Description
protected void	XsltView.initApplicationContext()	Initialize this XsltView's TransformerFactory.

Uses of BeansException in org.springframework.web.socket.client.standard

Methods in org.springframework.web.socket.client.standard that throw BeansException

Modifier and Type	Method	Description
void	AnnotatedEndpointConnectionManager.setBeanFactory(BeanFactory beanFactory)