Uses of Class
org.springframework.beans.BeansException

Packages that use BeansException

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	This package contains implementations of the org.springframework.aop.TargetSource interface.
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.access	Helper infrastructure to locate and access bean factories.
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.generic	Support package for generic BeanFactory access, leveraging Java 5 generics in the accessor API.
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" DTD.
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.access	Helper infrastructure to locate and access shared application contexts.
org.springframework.context.annotation	Annotation support for context configuration, including classpath scanning for autowire candidates.
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.annotation	Annotation support for DAOs.
org.springframework.dao.support	Support classes for DAO implementations, providing miscellaneous utility methods.
org.springframework.ejb.support	Base classes to make implementing EJB 2.x beans simpler and less error-prone, as well as guaranteeing a Spring BeanFactory is available to such EJBs.
org.springframework.jca.context	Integration package that allows for deploying a Spring application context as a JCA 1.5 compliant RAR file.
org.springframework.jndi.support	Support classes for JNDI usage, including a JNDI-based BeanFactory implementation.
org.springframework.orm.hibernate3	Package providing integration of Hibernate3 with Spring concepts.
org.springframework.orm.jpa.support	Classes supporting the org.springframework.orm.jpa package.
org.springframework.scripting.groovy	Package providing integration of Groovy into Spring's scripting infrastructure.
org.springframework.web.context	Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
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.portlet	Provides JSR-168 portlets that integrate with the application context infrastructure, and the core interfaces and classes for the Portlet variant of Spring's web MVC framework.
org.springframework.web.portlet.context	Support for Spring's application context concept in a portlet environment, including ApplicationContext implementations and various utility classes.
org.springframework.web.portlet.handler	Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
org.springframework.web.portlet.mvc.annotation	Support package for annotation-based Portlet MVC controllers.
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.handler.metadata	This package enables automatic web controller targeting.
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.tiles	Support classes for the integration of Tiles (included in Struts) as Spring web view technology.
org.springframework.web.servlet.view.velocity	Support classes for the integration of Velocity as Spring web view technology.
org.springframework.web.servlet.view.xslt	Support classes for XSLT, providing a View implementation for XSLT stylesheets.
org.springframework.web.struts	Support classes for integrating a Struts web tier with a Spring middle tier which is typically hosted in a Spring root WebApplicationContext.

Uses of BeansException in org.springframework.aop.framework

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

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

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

Constructor[]	AbstractAutoProxyCreator.determineCandidateConstructors(Class beanClass, String beanName)
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.
Object	AbstractAutoProxyCreator.getEarlyBeanReference(Object bean, String beanName)
Object	AbstractAutoProxyCreator.postProcessAfterInitialization(Object bean, String beanName) Create a proxy with the configured interceptors if the bean is identified as one to proxy by the subclass.
Object	AbstractAutoProxyCreator.postProcessBeforeInstantiation(Class beanClass, String beanName)

Uses of BeansException in org.springframework.aop.target

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

Object	ThreadLocalTargetSource.getTarget() Implementation of abstract getTarget() method.
Object	PrototypeTargetSource.getTarget() Obtain a new prototype instance for every call.
Object	LazyInitTargetSource.getTarget()
Object	CommonsPoolTargetSource.makeObject()
protected Object	AbstractPrototypeBasedTargetSource.newPrototypeInstance() Subclasses should call this method to create a new prototype instance.
void	AbstractPrototypeBasedTargetSource.setBeanFactory(BeanFactory beanFactory)
void	AbstractPoolingTargetSource.setBeanFactory(BeanFactory beanFactory)
void	AbstractBeanFactoryBasedTargetSource.setBeanFactory(BeanFactory beanFactory) Set the owning BeanFactory.

Uses of BeansException in org.springframework.beans

Subclasses of BeansException in org.springframework.beans

class	BeanInstantiationException Exception thrown when instantiation of a bean failed.
class	FatalBeanException Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g. bad class or field.
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

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.getPropertyDescriptor(Class clazz, String propertyName) Retrieve the JavaBeans PropertyDescriptors for the given property.
PropertyDescriptor	BeanWrapperImpl.getPropertyDescriptor(String propertyName)
PropertyDescriptor	BeanWrapper.getPropertyDescriptor(String propertyName) Obtain the property descriptor for a specific property of the wrapped object.
protected PropertyDescriptor	BeanWrapperImpl.getPropertyDescriptorInternal(String propertyName) Internal version of BeanWrapperImpl.getPropertyDescriptor(java.lang.String): Returns null if not found rather than throwing an exception.
static PropertyDescriptor[]	BeanUtils.getPropertyDescriptors(Class clazz) Retrieve the JavaBeans PropertyDescriptors of a given class.
Class	BeanWrapperImpl.getPropertyType(String propertyName)
Class	DirectFieldAccessor.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.
abstract Object	AbstractPropertyAccessor.getPropertyValue(String propertyName) Actually get the value of a property.
Object	BeanWrapperImpl.getPropertyValue(String propertyName)
Object	DirectFieldAccessor.getPropertyValue(String propertyName)
Object	PropertyAccessor.getPropertyValue(String propertyName) Get the current value of the specified property.
boolean	DirectFieldAccessor.isReadableProperty(String propertyName)
boolean	DirectFieldAccessor.isWritableProperty(String propertyName)
void	AbstractPropertyAccessor.setPropertyValue(PropertyValue pv)
void	BeanWrapperImpl.setPropertyValue(PropertyValue pv)
void	PropertyAccessor.setPropertyValue(PropertyValue pv) Set the specified value as current property value.
abstract void	AbstractPropertyAccessor.setPropertyValue(String propertyName, Object value) Actually set a property value.
void	BeanWrapperImpl.setPropertyValue(String propertyName, Object value)
void	DirectFieldAccessor.setPropertyValue(String propertyName, Object newValue)
void	PropertyAccessor.setPropertyValue(String propertyName, Object value) Set the specified value as current property value.
void	AbstractPropertyAccessor.setPropertyValues(Map map)
void	PropertyAccessor.setPropertyValues(Map map) Perform a batch update from a Map.
void	AbstractPropertyAccessor.setPropertyValues(PropertyValues pvs)
void	PropertyAccessor.setPropertyValues(PropertyValues pvs) The preferred way to perform a batch update.
void	AbstractPropertyAccessor.setPropertyValues(PropertyValues pvs, boolean ignoreUnknown)
void	PropertyAccessor.setPropertyValues(PropertyValues pvs, boolean ignoreUnknown) Perform a batch update with more control over behavior.
void	AbstractPropertyAccessor.setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
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

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. in case of incomplete or contradictory bean metadata.
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 which has been defined 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 name for which it cannot find a definition.
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

static Object	BeanFactoryUtils.beanOfType(ListableBeanFactory lbf, Class type) Return a single bean of the given type or subtypes, not looking in ancestor factories.
static Object	BeanFactoryUtils.beanOfType(ListableBeanFactory lbf, Class type, boolean includeNonSingletons, boolean allowEagerInit) Return a single bean of the given type or subtypes, not looking in ancestor factories.
static Object	BeanFactoryUtils.beanOfTypeIncludingAncestors(ListableBeanFactory lbf, Class 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 Object	BeanFactoryUtils.beanOfTypeIncludingAncestors(ListableBeanFactory lbf, Class 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 Map	BeanFactoryUtils.beansOfTypeIncludingAncestors(ListableBeanFactory lbf, Class 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 Map	BeanFactoryUtils.beansOfTypeIncludingAncestors(ListableBeanFactory lbf, Class 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.
Object	BeanFactory.getBean(String name) Return an instance, which may be shared or independent, of the specified bean.
Object	BeanFactory.getBean(String name, Class 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.
Map	ListableBeanFactory.getBeansOfType(Class 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.
Map	ListableBeanFactory.getBeansOfType(Class 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.
Object	ObjectFactory.getObject() Return an instance (possibly shared or independent) of the object managed by this factory.
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

UnsatisfiedDependencyException(String resourceDescription, String beanName, int ctorArgIndex, Class ctorArgType, BeansException ex)
Create a new UnsatisfiedDependencyException.

UnsatisfiedDependencyException(String resourceDescription, String beanName, String propertyName, BeansException ex)
Create a new UnsatisfiedDependencyException.

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

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

class

BootstrapException Exception thrown if a bean factory could not be loaded by a bootstrap class.

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

static BeanFactoryLocator	SingletonBeanFactoryLocator.getInstance() Returns an instance which uses the default "classpath*:beanRefFactory.xml", as the name of the definition file(s).
static BeanFactoryLocator	SingletonBeanFactoryLocator.getInstance(String selector) Returns an instance which uses the the specified selector, as the name of the definition file(s).
BeanFactoryReference	SingletonBeanFactoryLocator.useBeanFactory(String factoryKey)
BeanFactoryReference	BeanFactoryLocator.useBeanFactory(String factoryKey) Use the BeanFactory (or derived interface such as ApplicationContext) specified by the factoryKey parameter.

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

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

Constructor[]	AutowiredAnnotationBeanPostProcessor.determineCandidateConstructors(Class beanClass, String beanName)
protected Map	AutowiredAnnotationBeanPostProcessor.findAutowireCandidates(Class type) Obtain all beans of the given type as autowire candidates.
Object	InitDestroyAnnotationBeanPostProcessor.postProcessAfterInitialization(Object bean, String beanName)
boolean	AutowiredAnnotationBeanPostProcessor.postProcessAfterInstantiation(Object bean, String beanName)
void	CustomAutowireConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
void	InitDestroyAnnotationBeanPostProcessor.postProcessBeforeDestruction(Object bean, String beanName)
Object	InitDestroyAnnotationBeanPostProcessor.postProcessBeforeInitialization(Object bean, String beanName)
PropertyValues	RequiredAnnotationBeanPostProcessor.postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
PropertyValues	AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
void	AutowiredAnnotationBeanPostProcessor.processInjection(Object bean) 'Native' processing method for direct calls with an arbitrary target instance, resolving all of its fields and methods which are annotated with @Autowired.
void	AutowiredAnnotationBeanPostProcessor.setBeanFactory(BeanFactory beanFactory)

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

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

protected Exception

ServiceLocatorFactoryBean.createServiceLocatorException(Constructor exceptionConstructor, BeansException cause) Create a service locator exception for the given cause.

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

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. for annotation-driven injection).
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) Fully create a new bean instance of the given class.
Object	AutowireCapableBeanFactory.createBean(Class beanClass, int autowireMode, boolean dependencyCheck) Fully create a new bean instance of the given class with the specified autowire strategy.
Constructor[]	SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors(Class beanClass, String beanName) Determine the candidate constructors to use for the given bean.
Constructor[]	InstantiationAwareBeanPostProcessorAdapter.determineCandidateConstructors(Class beanClass, String beanName)
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	InstantiationAwareBeanPostProcessorAdapter.getEarlyBeanReference(Object bean, String beanName)
Object	PropertyPathFactoryBean.getObject()
Object	BeanReferenceFactoryBean.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).
Object	InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInitialization(Object bean, String beanName)
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).
boolean	InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInstantiation(Object bean, String beanName)
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	PropertyResourceConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
void	CustomScopeConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
void	CustomEditorConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
void	BeanFactoryPostProcessor.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) Modify the application context's internal bean factory after its standard initialization.
void	DestructionAwareBeanPostProcessor.postProcessBeforeDestruction(Object bean, String beanName) Apply this BeanPostProcessor to the given bean instance before its destruction.
Object	InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInitialization(Object bean, String beanName)
Object	BeanPostProcessor.postProcessBeforeInitialization(Object bean,