Uses of Class org.springframework.beans.BeansException (Spring Framework) - Spring Framework 1.2.9 API 文档英文版

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

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.config	SPI interfaces and configuration-related convenience classes for bean factories.
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.support	Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
org.springframework.ejb.support	Superclasses to make implementing EJBs simpler and less error-prone, as well as guaranteeing a Spring BeanFactory is available to EJBs.
org.springframework.orm.hibernate	Package providing integration of Hibernate 2.1 with Spring concepts.
org.springframework.orm.hibernate3	Package providing integration of Hibernate3 with Spring concepts.
org.springframework.web.context	Contains the application context subinterface for web applications, and the ContextLoaderListener that bootstraps the root web application context.
org.springframework.web.context.support	Classes supporting the org.springframework.web.context package, such as WebApplicationContext implementations, and a utility class for retrieval of the root application context etc.
org.springframework.web.filter	Provides generic filter base classes allowing for bean-style configuration.
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.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.

void ProxyFactoryBean.setBeanFactory(BeanFactory beanFactory)

Methods in org.springframework.aop.framework that throw BeansException
`Object`	`ProxyFactoryBean.getObject()` Return a proxy.
`void`	`ProxyFactoryBean.setBeanFactory(BeanFactory beanFactory)`

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)

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

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.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)

Methods in org.springframework.aop.framework.autoproxy that throw BeansException
`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.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()


Object LazyInitTargetSource.getTarget()


Object CommonsPoolTargetSource.makeObject()


protected Object AbstractPrototypeBasedTargetSource.newPrototypeInstance()
          Subclasses should use 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.

Methods in org.springframework.aop.target that throw BeansException
`Object`	`ThreadLocalTargetSource.getTarget()` Implementation of abstract getTarget() method.
`Object`	`PrototypeTargetSource.getTarget()`
`Object`	`LazyInitTargetSource.getTarget()`
`Object`	`CommonsPoolTargetSource.makeObject()`
`protected Object`	`AbstractPrototypeBasedTargetSource.newPrototypeInstance()` Subclasses should use 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 isn't writable, because there's 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 PropertyAccessExceptionsException
          Combined exception, composed of individual binding propertyAccessExceptions.

class TypeMismatchException
          Exception thrown on a type mismatch when trying to set a bean property.

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 isn't writable, because there's 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`	`PropertyAccessExceptionsException` Combined exception, composed of individual binding propertyAccessExceptions.
`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 CachedIntrospectionResults CachedIntrospectionResults.forClass(Class beanClass)
          Create CachedIntrospectionResults for the given bean class.

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 BeanWrapper.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.

Object PropertyAccessor.getPropertyValue(String propertyName)
          Get the current value of the specified property.

Object BeanWrapperImpl.getPropertyValue(String propertyName)


void PropertyAccessor.setPropertyValue(PropertyValue pv)
          Set the specified value as current property value.

void BeanWrapperImpl.setPropertyValue(PropertyValue pv)


void PropertyAccessor.setPropertyValue(String propertyName, Object value)
          Set the specified value as current property value.

void BeanWrapperImpl.setPropertyValue(String propertyName, Object value)


void PropertyAccessor.setPropertyValues(Map map)
          Perform a batch update from a Map.

void BeanWrapperImpl.setPropertyValues(Map map)
          Bulk update from a Map.

void PropertyAccessor.setPropertyValues(PropertyValues pvs)
          The preferred way to perform a batch update.

void BeanWrapperImpl.setPropertyValues(PropertyValues pvs)


void PropertyAccessor.setPropertyValues(PropertyValues pvs, boolean ignoreUnknown)
          Perform a batch update with full control over behavior.

void BeanWrapperImpl.setPropertyValues(PropertyValues propertyValues, boolean ignoreUnknown)

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 CachedIntrospectionResults`	`CachedIntrospectionResults.forClass(Class beanClass)` Create CachedIntrospectionResults for the given bean class.
`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 `PropertyDescriptor`s of a given class.
`Class`	`BeanWrapperImpl.getPropertyType(String propertyName)`
`Class`	`BeanWrapper.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.
`Object`	`PropertyAccessor.getPropertyValue(String propertyName)` Get the current value of the specified property.
`Object`	`BeanWrapperImpl.getPropertyValue(String propertyName)`
`void`	`PropertyAccessor.setPropertyValue(PropertyValue pv)` Set the specified value as current property value.
`void`	`BeanWrapperImpl.setPropertyValue(PropertyValue pv)`
`void`	`PropertyAccessor.setPropertyValue(String propertyName, Object value)` Set the specified value as current property value.
`void`	`BeanWrapperImpl.setPropertyValue(String propertyName, Object value)`
`void`	`PropertyAccessor.setPropertyValues(Map map)` Perform a batch update from a Map.
`void`	`BeanWrapperImpl.setPropertyValues(Map map)` Bulk update from a Map.
`void`	`PropertyAccessor.setPropertyValues(PropertyValues pvs)` The preferred way to perform a batch update.
`void`	`BeanWrapperImpl.setPropertyValues(PropertyValues pvs)`
`void`	`PropertyAccessor.setPropertyValues(PropertyValues pvs, boolean ignoreUnknown)` Perform a batch update with full control over behavior.
`void`	`BeanWrapperImpl.setPropertyValues(PropertyValues propertyValues, boolean ignoreUnknown)`

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 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 internal error, and its definitions are invalid: for example, if an XML document containing bean definitions isn't well-formed.

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 required type.

class FactoryBeanNotInitializedException
          Exception thrown if a FactoryBean is not fully initialized, 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.

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`	`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 internal error, and its definitions are invalid: for example, if an XML document containing bean definitions isn't well-formed.
`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 required type.
`class`	`FactoryBeanNotInitializedException` Exception thrown if a FactoryBean is not fully initialized, 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 includePrototypes, boolean includeFactoryBeans)
          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 includePrototypes, boolean includeFactoryBeans)
          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 includePrototypes, boolean includeFactoryBeans)
          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.

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 includePrototypes, boolean includeFactoryBeans)
          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.

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 includePrototypes, boolean includeFactoryBeans)` 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 includePrototypes, boolean includeFactoryBeans)` 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 includePrototypes, boolean includeFactoryBeans)` 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.
`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 includePrototypes, boolean includeFactoryBeans)` 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.

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.

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

protected BeanFactory SingletonBeanFactoryLocator.createDefinition(String resourceName, String factoryKey)
          Actually creates definition in the form of a BeanFactory, given a resource name which supports standard Spring Resource prefixes ('classpath:', 'classpath*:', etc.)

protected void SingletonBeanFactoryLocator.destroyDefinition(BeanFactory groupDef, String resourceName)
          Destroy definition in separate method so subclass may work with other definition types.

static BeanFactoryBootstrap BeanFactoryBootstrap.getInstance()
          Deprecated. Return the singleton instance of the bootstrap factory

protected void SingletonBeanFactoryLocator.initializeDefinition(BeanFactory groupDef)
          Instantiate singletons and do any other normal initialization of the factory.

BeanFactoryReference SingletonBeanFactoryLocator.useBeanFactory(String factoryKey)


BeanFactoryReference BeanFactoryLocator.useBeanFactory(String factoryKey)
          Use the BeanFactory (or derived class such as ApplicationContext) specified by the factoryKey parameter.

Methods in org.springframework.beans.factory.access that throw BeansException
`protected BeanFactory`	`SingletonBeanFactoryLocator.createDefinition(String resourceName, String factoryKey)` Actually creates definition in the form of a BeanFactory, given a resource name which supports standard Spring Resource prefixes ('classpath:', 'classpath*:', etc.)
`protected void`	`SingletonBeanFactoryLocator.destroyDefinition(BeanFactory groupDef, String resourceName)` Destroy definition in separate method so subclass may work with other definition types.
`static BeanFactoryBootstrap`	`BeanFactoryBootstrap.getInstance()` Deprecated. Return the singleton instance of the bootstrap factory
`protected void`	`SingletonBeanFactoryLocator.initializeDefinition(BeanFactory groupDef)` Instantiate singletons and do any other normal initialization of the factory.
`BeanFactoryReference`	`SingletonBeanFactoryLocator.useBeanFactory(String factoryKey)`
`BeanFactoryReference`	`BeanFactoryLocator.useBeanFactory(String factoryKey)` Use the BeanFactory (or derived class such as ApplicationContext) specified by the factoryKey parameter.

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 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)
          Create a new bean instance of the given class with the specified autowire strategy.

void AutowireCapableBeanFactory.autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
          Autowire the bean properties of the given bean instance by name or type.

Object PropertyPathFactoryBean.getObject()


Object BeanReferenceFactoryBean.getObject()


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).

void PropertyResourceConfigurer.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 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).

Object InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(Class beanClass, String beanName)
          Apply this BeanPostProcessor before the target bean gets instantiated.

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 abstract void PropertyResourceConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)
          Apply the given Properties to the bean factory.

protected void PropertyPlaceholderConfigurer.processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)


protected void PropertyOverrideConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)


void ConfigurableBeanFactory.registerAlias(String beanName, String alias)
          Given a bean name, create an alias.

void ConfigurableBeanFactory.registerSingleton(String beanName, Object singletonObject)
          Register the given existing object as singleton in the bean factory, under the given bean name.

void ServiceLocatorFactoryBean.setBeanFactory(BeanFactory beanFactory)

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)` Create a new bean instance of the given class with the specified autowire strategy.
`void`	`AutowireCapableBeanFactory.autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)` Autowire the bean properties of the given bean instance by name or type.
`Object`	`PropertyPathFactoryBean.getObject()`
`Object`	`BeanReferenceFactoryBean.getObject()`
`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).
`void`	`PropertyResourceConfigurer.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`	`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).
`Object`	`InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(Class beanClass, String beanName)` Apply this BeanPostProcessor before the target bean gets instantiated.
`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 abstract void`	`PropertyResourceConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)` Apply the given Properties to the bean factory.
`protected void`	`PropertyPlaceholderConfigurer.processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)`
`protected void`	`PropertyOverrideConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)`
`void`	`ConfigurableBeanFactory.registerAlias(String beanName, String alias)` Given a bean name, create an alias.
`void`	`ConfigurableBeanFactory.registerSingleton(String beanName, Object singletonObject)` Register the given existing object as singleton in the bean factory, under the given bean name.
`void`	`ServiceLocatorFactoryBean.setBeanFactory(BeanFactory beanFactory)`

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

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

class BeanDefinitionValidationException
Exception thrown when the validation of a bean definition failed.

Subclasses of BeansException in org.springframework.beans.factory.support
`class`	`BeanDefinitionValidationException` Exception thrown when the validation of a bean definition failed.

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

Object AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)


Object AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)


protected Object AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInstantiation(Class beanClass, String beanName)
          Apply InstantiationAwareBeanPostProcessors to the specified bean definition (by class and name), invoking their postProcessBeforeInstantiation methods.

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)


protected void AbstractAutowireCapableBeanFactory.autowireByName(String beanName, RootBeanDefinition mergedBeanDefinition, BeanWrapper bw, MutablePropertyValues pvs)
          Fill in any missing property values with references to other beans in this factory if autowire is set to "byName".

protected void AbstractAutowireCapableBeanFactory.autowireByType(String beanName, RootBeanDefinition mergedBeanDefinition, BeanWrapper bw, MutablePropertyValues pvs)
          Abstract method defining "autowire by type" (bean properties by type) behavior.

protected BeanWrapper AbstractAutowireCapableBeanFactory.autowireConstructor(String beanName, RootBeanDefinition mergedBeanDefinition)
          "autowire constructor" (with constructor arguments by type) behavior.

protected void AbstractBeanFactory.checkMergedBeanDefinition(RootBeanDefinition mergedBeanDefinition, String beanName, Class requiredType, Object[] args)
          Check the given merged bean definition, potentially throwing validation exceptions.

protected abstract Map AbstractAutowireCapableBeanFactory.findMatchingBeans(Class requiredType)
          Find bean instances that match the required type.

Object StaticListableBeanFactory.getBean(String name)


Object AbstractBeanFactory.getBean(String name)


Object StaticListableBeanFactory.getBean(String name, Class requiredType)


Object AbstractBeanFactory.getBean(String name, Class requiredType)


Object AbstractBeanFactory.getBean(String name, Class requiredType, Object[] args)
          Return an instance, which may be shared or independent, of the specified bean.

Object AbstractBeanFactory.getBean(String name, Object[] args)
          Return an instance, which may be shared or independent, of the specified bean.

protected abstract BeanDefinition AbstractBeanFactory.getBeanDefinition(String beanName)
          Return the bean definition for the given bean name.

Map StaticListableBeanFactory.getBeansOfType(Class type)


Map DefaultListableBeanFactory.getBeansOfType(Class type)


Map StaticListableBeanFactory.getBeansOfType(Class type, boolean includePrototypes, boolean includeFactoryBeans)


Map DefaultListableBeanFactory.getBeansOfType(Class type, boolean includePrototypes, boolean includeFactoryBeans)


RootBeanDefinition AbstractBeanFactory.getMergedBeanDefinition(String name)
          Return a RootBeanDefinition for the given bean name, merging a child bean definition with its parent if necessary.

protected RootBeanDefinition AbstractBeanFactory.getMergedBeanDefinition(String name, boolean includingAncestors)
          Return a RootBeanDefinition, even by traversing parent if the parameter is a child definition.

protected Object AbstractBeanFactory.getObjectForSharedInstance(String name, Object beanInstance)
          Get the object for the given shared bean, either the bean instance itself or its created object in case of a FactoryBean.

protected BeanWrapper AbstractAutowireCapableBeanFactory.instantiateBean(String beanName, RootBeanDefinition mergedBeanDefinition)
          Instantiate the given bean using its default constructor.

protected BeanWrapper AbstractAutowireCapableBeanFactory.instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mergedBeanDefinition, Object[] explicitArgs)
          Instantiate the bean using a named factory method.

int PropertiesBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource)
          Load bean definitions from the specified properties file.

int PropertiesBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource, String prefix)
          Load bean definitions from the specified properties file.

int PropertiesBeanDefinitionReader.loadBeanDefinitions(Resource resource)
          Load bean definitions from the specified properties file, using all property keys (i.e. not filtering by prefix).

int AbstractBeanDefinitionReader.loadBeanDefinitions(Resource[] resources)


int PropertiesBeanDefinitionReader.loadBeanDefinitions(Resource resource, String prefix)
          Load bean definitions from the specified properties file.

int AbstractBeanDefinitionReader.loadBeanDefinitions(String[] locations)


protected void AbstractAutowireCapableBeanFactory.populateBean(String beanName, RootBeanDefinition mergedBeanDefinition, BeanWrapper bw)
          Populate the bean instance in the given BeanWrapper with the property values from the bean definition.

void DefaultListableBeanFactory.preInstantiateSingletons()


void BeanDefinitionRegistry.registerAlias(String beanName, String alias)
          Given a bean name, create an alias.

void BeanDefinitionRegistry.registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
          Register a new bean definition with this registry.

protected void PropertiesBeanDefinitionReader.registerBeanDefinition(String beanName, Map map, String prefix, String resourceDescription)
          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)
          Register bean definitions contained in a Map, using all property keys (i.e. not filtering by prefix).

int PropertiesBeanDefinitionReader.registerBeanDefinitions(Map map, String prefix)
          Register bean definitions contained in a Map.

int PropertiesBeanDefinitionReader.registerBeanDefinitions(Map map, String prefix, String resourceDescription)
          Register bean definitions contained in a Map.

Object BeanDefinitionValueResolver.resolveValueIfNecessary(String argName, Object value)
          Given a PropertyValue, return a value, resolving any references to other beans in the factory if necessary.

Methods in org.springframework.beans.factory.support that throw BeansException
`Object`	`AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)`
`Object`	`AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)`
`protected Object`	`AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInstantiation(Class beanClass, String beanName)` Apply InstantiationAwareBeanPostProcessors to the specified bean definition (by class and name), invoking their `postProcessBeforeInstantiation` methods.
`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)`
`protected void`	`AbstractAutowireCapableBeanFactory.autowireByName(String beanName, RootBeanDefinition mergedBeanDefinition, BeanWrapper bw, MutablePropertyValues pvs)` Fill in any missing property values with references to other beans in this factory if autowire is set to "byName".
`protected void`	`AbstractAutowireCapableBeanFactory.autowireByType(String beanName, RootBeanDefinition mergedBeanDefinition, BeanWrapper bw, MutablePropertyValues pvs)` Abstract method defining "autowire by type" (bean properties by type) behavior.
`protected BeanWrapper`	`AbstractAutowireCapableBeanFactory.autowireConstructor(String beanName, RootBeanDefinition mergedBeanDefinition)` "autowire constructor" (with constructor arguments by type) behavior.
`protected void`	`AbstractBeanFactory.checkMergedBeanDefinition(RootBeanDefinition mergedBeanDefinition, String beanName, Class requiredType, Object[] args)` Check the given merged bean definition, potentially throwing validation exceptions.
`protected abstract Map`	`AbstractAutowireCapableBeanFactory.findMatchingBeans(Class requiredType)` Find bean instances that match the required type.
`Object`	`StaticListableBeanFactory.getBean(String name)`
`Object`	`AbstractBeanFactory.getBean(String name)`
`Object`	`StaticListableBeanFactory.getBean(String name, Class requiredType)`
`Object`	`AbstractBeanFactory.getBean(String name, Class requiredType)`
`Object`	`AbstractBeanFactory.getBean(String name, Class requiredType, Object[] args)` Return an instance, which may be shared or independent, of the specified bean.
`Object`	`AbstractBeanFactory.getBean(String name, Object[] args)` Return an instance, which may be shared or independent, of the specified bean.
`protected abstract BeanDefinition`	`AbstractBeanFactory.getBeanDefinition(String beanName)` Return the bean definition for the given bean name.
`Map`	`StaticListableBeanFactory.getBeansOfType(Class type)`
`Map`	`DefaultListableBeanFactory.getBeansOfType(Class type)`
`Map`	`StaticListableBeanFactory.getBeansOfType(Class type, boolean includePrototypes, boolean includeFactoryBeans)`
`Map`	`DefaultListableBeanFactory.getBeansOfType(Class type, boolean includePrototypes, boolean includeFactoryBeans)`
`RootBeanDefinition`	`AbstractBeanFactory.getMergedBeanDefinition(String name)` Return a RootBeanDefinition for the given bean name, merging a child bean definition with its parent if necessary.
`protected RootBeanDefinition`	`AbstractBeanFactory.getMergedBeanDefinition(String name, boolean includingAncestors)` Return a RootBeanDefinition, even by traversing parent if the parameter is a child definition.
`protected Object`	`AbstractBeanFactory.getObjectForSharedInstance(String name, Object beanInstance)` Get the object for the given shared bean, either the bean instance itself or its created object in case of a FactoryBean.
`protected BeanWrapper`	`AbstractAutowireCapableBeanFactory.instantiateBean(String beanName, RootBeanDefinition mergedBeanDefinition)` Instantiate the given bean using its default constructor.
`protected BeanWrapper`	`AbstractAutowireCapableBeanFactory.instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mergedBeanDefinition, Object[] explicitArgs)` Instantiate the bean using a named factory method.
`int`	`PropertiesBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource)` Load bean definitions from the specified properties file.
`int`	`PropertiesBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource, String prefix)` Load bean definitions from the specified properties file.
`int`	`PropertiesBeanDefinitionReader.loadBeanDefinitions(Resource resource)` Load bean definitions from the specified properties file, using all property keys (i.e. not filtering by prefix).
`int`	`AbstractBeanDefinitionReader.loadBeanDefinitions(Resource[] resources)`
`int`	`PropertiesBeanDefinitionReader.loadBeanDefinitions(Resource resource, String prefix)` Load bean definitions from the specified properties file.
`int`	`AbstractBeanDefinitionReader.loadBeanDefinitions(String[] locations)`
`protected void`	`AbstractAutowireCapableBeanFactory.populateBean(String beanName, RootBeanDefinition mergedBeanDefinition, BeanWrapper bw)` Populate the bean instance in the given BeanWrapper with the property values from the bean definition.
`void`	`DefaultListableBeanFactory.preInstantiateSingletons()`
`void`	`BeanDefinitionRegistry.registerAlias(String beanName, String alias)` Given a bean name, create an alias.
`void`	`BeanDefinitionRegistry.registerBeanDefinition(String beanName, BeanDefinition beanDefinition)` Register a new bean definition with this registry.
`protected void`	`PropertiesBeanDefinitionReader.registerBeanDefinition(String beanName, Map map, String prefix, String resourceDescription)` 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)` Register bean definitions contained in a Map, using all property keys (i.e. not filtering by prefix).
`int`	`PropertiesBeanDefinitionReader.registerBeanDefinitions(Map map, String prefix)` Register bean definitions contained in a Map.
`int`	`PropertiesBeanDefinitionReader.registerBeanDefinitions(Map map, String prefix, String resourceDescription)` Register bean definitions contained in a Map.
`Object`	`BeanDefinitionValueResolver.resolveValueIfNecessary(String argName, Object value)` Given a PropertyValue, return a value, resolving any references to other beans in the factory if necessary.

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

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

protected int XmlBeanDefinitionReader.doLoadBeanDefinitions(InputSource inputSource, Resource resource)
          Actually load bean definitions from the specified XML file.

int XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource)
          Load bean definitions from the specified XML file.

int XmlBeanDefinitionReader.loadBeanDefinitions(InputSource inputSource)
          Load bean definitions from the specified XML file.

int XmlBeanDefinitionReader.loadBeanDefinitions(InputSource inputSource, String resourceDescription)
          Load bean definitions from the specified XML file.

int XmlBeanDefinitionReader.loadBeanDefinitions(Resource resource)
          Load bean definitions from the specified XML file.

int XmlBeanDefinitionReader.registerBeanDefinitions(Document doc, Resource resource)
          Register the bean definitions contained in the given DOM document.

Methods in org.springframework.beans.factory.xml that throw BeansException
`protected int`	`XmlBeanDefinitionReader.doLoadBeanDefinitions(InputSource inputSource, Resource resource)` Actually load bean definitions from the specified XML file.
`int`	`XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource)` Load bean definitions from the specified XML file.
`int`	`XmlBeanDefinitionReader.loadBeanDefinitions(InputSource inputSource)` Load bean definitions from the specified XML file.
`int`	`XmlBeanDefinitionReader.loadBeanDefinitions(InputSource inputSource, String resourceDescription)` Load bean definitions from the specified XML file.
`int`	`XmlBeanDefinitionReader.loadBeanDefinitions(Resource resource)` Load bean definitions from the specified XML file.
`int`	`XmlBeanDefinitionReader.registerBeanDefinitions(Document doc, Resource resource)` Register the bean definitions contained in the given DOM document.

Constructors in org.springframework.beans.factory.xml that throw BeansException

XmlBeanFactory(Resource resource)
Create a new XmlBeanFactory with the given resource, which must be parsable using DOM.

XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory)
Create a new XmlBeanFactory with the given input stream, which must be parsable using DOM.

Constructors in org.springframework.beans.factory.xml that throw BeansException
`XmlBeanFactory(Resource resource)` Create a new XmlBeanFactory with the given resource, which must be parsable using DOM.
`XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory)` Create a new XmlBeanFactory with the given input stream, which must be parsable using DOM.

Uses of BeansException in org.springframework.beans.support

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

static void PropertyComparator.sort(List source, SortDefinition sortDefinition)
Sort the given List according to the given sort definition.

static void PropertyComparator.sort(Object[] source, SortDefinition sortDefinition)
Sort the given source according to the given sort definition.

Methods in org.springframework.beans.support that throw BeansException
`static void`	`PropertyComparator.sort(List source, SortDefinition sortDefinition)` Sort the given List according to the given sort definition.
`static void`	`PropertyComparator.sort(Object[] source, SortDefinition sortDefinition)` Sort the given source according to the given sort definition.

Uses of BeansException in org.springframework.context

Subclasses of BeansException in org.springframework.context

class ApplicationContextException
Exception thrown during application context initialization.

Subclasses of BeansException in org.springframework.context
`class`	`ApplicationContextException` Exception thrown during application context initialization.

Methods in org.springframework.context that throw BeansException

void ConfigurableApplicationContext.refresh()
Load or refresh the persistent representation of the configuration, which might an XML file, properties file, or relational database schema.

void ApplicationContextAware.setApplicationContext(ApplicationContext applicationContext)
Set the ApplicationContext that this object runs in.

Methods in org.springframework.context that throw BeansException
`void`	`ConfigurableApplicationContext.refresh()` Load or refresh the persistent representation of the configuration, which might an XML file, properties file, or relational database schema.
`void`	`ApplicationContextAware.setApplicationContext(ApplicationContext applicationContext)` Set the ApplicationContext that this object runs in.

Uses of BeansException in org.springframework.context.access

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

protected ApplicationContext ContextJndiBeanFactoryLocator.createApplicationContext(String[] resources)
          Create the ApplicationContext instance, given an array of class path resource Strings which should be combined

protected BeanFactoryReference ContextJndiBeanFactoryLocator.createBeanFactory(String[] resources)
          Create the BeanFactory instance, given an array of class path resource Strings which should be combined.

protected BeanFactory ContextSingletonBeanFactoryLocator.createDefinition(String resourceName, String factoryKey)
          Overrides default method to create definition object as an ApplicationContext instead of the default BeanFactory.

protected void ContextSingletonBeanFactoryLocator.destroyDefinition(BeanFactory groupDef, String resourceName)
          Overrides default method to work with ApplicationContext

static BeanFactoryLocator ContextSingletonBeanFactoryLocator.getInstance()
          Returns an instance which uses the default "classpath*:beanRefContext.xml", as the name of the definition file(s).

static BeanFactoryLocator ContextSingletonBeanFactoryLocator.getInstance(String selector)
          Returns an instance which uses the the specified selector, as the name of the definition file(s).

protected void ContextSingletonBeanFactoryLocator.initializeDefinition(BeanFactory groupDef)
          Overrides default method to initialize definition object, which this method assumes is a ConfigurableApplicationContext.

BeanFactoryReference ContextJndiBeanFactoryLocator.useBeanFactory(String factoryKey)
          Load/use a bean factory, as specified by a factory key which is a JNDI address, of the form java:comp/env/ejb/BeanFactoryPath.

Methods in org.springframework.context.access that throw BeansException
`protected ApplicationContext`	`ContextJndiBeanFactoryLocator.createApplicationContext(String[] resources)` Create the ApplicationContext instance, given an array of class path resource Strings which should be combined
`protected BeanFactoryReference`	`ContextJndiBeanFactoryLocator.createBeanFactory(String[] resources)` Create the BeanFactory instance, given an array of class path resource Strings which should be combined.
`protected BeanFactory`	`ContextSingletonBeanFactoryLocator.createDefinition(String resourceName, String factoryKey)` Overrides default method to create definition object as an ApplicationContext instead of the default BeanFactory.
`protected void`	`ContextSingletonBeanFactoryLocator.destroyDefinition(BeanFactory groupDef, String resourceName)` Overrides default method to work with ApplicationContext
`static BeanFactoryLocator`	`ContextSingletonBeanFactoryLocator.getInstance()` Returns an instance which uses the default "classpath*:beanRefContext.xml", as the name of the definition file(s).
`static BeanFactoryLocator`	`ContextSingletonBeanFactoryLocator.getInstance(String selector)` Returns an instance which uses the the specified selector, as the name of the definition file(s).
`protected void`	`ContextSingletonBeanFactoryLocator.initializeDefinition(BeanFactory groupDef)` Overrides default method to initialize definition object, which this method assumes is a ConfigurableApplicationContext.
`BeanFactoryReference`	`ContextJndiBeanFactoryLocator.useBeanFactory(String factoryKey)` Load/use a bean factory, as specified by a factory key which is a JNDI address, of the form `java:comp/env/ejb/BeanFactoryPath`.

Uses of BeansException in org.springframework.context.support

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

Object AbstractApplicationContext.getBean(String name)


Object AbstractApplicationContext.getBean(String name, Class requiredType)


BeanDefinition GenericApplicationContext.getBeanDefinition(String beanName)


Map AbstractApplicationContext.getBeansOfType(Class type)


Map AbstractApplicationContext.getBeansOfType(Class type, boolean includePrototypes, boolean includeFactoryBeans)


protected void ApplicationObjectSupport.initApplicationContext()
          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(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.

protected void AbstractApplicationContext.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
          Modify the application context's internal bean factory after its standard initialization.

Object ApplicationContextAwareProcessor.postProcessBeforeInitialization(Object bean, String beanName)


void AbstractApplicationContext.refresh()


protected void AbstractRefreshableApplicationContext.refreshBeanFactory()


protected abstract void AbstractApplicationContext.refreshBeanFactory()
          Subclasses must implement this method to perform the actual configuration load.

void GenericApplicationContext.registerAlias(String beanName, String alias)


void GenericApplicationContext.registerBeanDefinition(String beanName, BeanDefinition beanDefinition)


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.

void ApplicationObjectSupport.setApplicationContext(ApplicationContext context)

Methods in org.springframework.context.support that throw BeansException
`Object`	`AbstractApplicationContext.getBean(String name)`
`Object`	`AbstractApplicationContext.getBean(String name, Class requiredType)`
`BeanDefinition`	`GenericApplicationContext.getBeanDefinition(String beanName)`
`Map`	`AbstractApplicationContext.getBeansOfType(Class type)`
`Map`	`AbstractApplicationContext.getBeansOfType(Class type, boolean includePrototypes, boolean includeFactoryBeans)`
`protected void`	`ApplicationObjectSupport.initApplicationContext()` 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(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.
`protected void`	`AbstractApplicationContext.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)` Modify the application context's internal bean factory after its standard initialization.
`Object`	`ApplicationContextAwareProcessor.postProcessBeforeInitialization(Object bean, String beanName)`
`void`	`AbstractApplicationContext.refresh()`
`protected void`	`AbstractRefreshableApplicationContext.refreshBeanFactory()`
`protected abstract void`	`AbstractApplicationContext.refreshBeanFactory()` Subclasses must implement this method to perform the actual configuration load.
`void`	`GenericApplicationContext.registerAlias(String beanName, String alias)`
`void`	`GenericApplicationContext.registerBeanDefinition(String beanName, BeanDefinition beanDefinition)`
`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.
`void`	`ApplicationObjectSupport.setApplicationContext(ApplicationContext context)`

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

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, 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, 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.

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, ApplicationContext parent)
          Create a new FileSystemXmlApplicationContext with the given parent, 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.

StaticApplicationContext()
          Create a new StaticApplicationContext.

StaticApplicationContext(ApplicationContext parent)
          Create a new StaticApplicationContext with the given parent.

Constructors in org.springframework.context.support that throw BeansException
`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, 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, 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.
`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, ApplicationContext parent)` Create a new FileSystemXmlApplicationContext with the given parent, 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.
`StaticApplicationContext()` Create a new StaticApplicationContext.
`StaticApplicationContext(ApplicationContext parent)` Create a new StaticApplicationContext with the given parent.

Uses of BeansException in org.springframework.ejb.support

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

protected void AbstractStatefulSessionBean.loadBeanFactory()
Load a Spring BeanFactory namespace.

(package private) void AbstractEnterpriseBean.loadBeanFactory()
Load a Spring BeanFactory namespace.

Methods in org.springframework.ejb.support that throw BeansException
`protected void`	`AbstractStatefulSessionBean.loadBeanFactory()` Load a Spring BeanFactory namespace.
`(package private) void`	`AbstractEnterpriseBean.loadBeanFactory()` Load a Spring BeanFactory namespace.

Uses of BeansException in org.springframework.orm.hibernate

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

net.sf.hibernate.Interceptor HibernateTransactionManager.getEntityInterceptor()
Return the current Hibernate entity interceptor, or null if none.

net.sf.hibernate.Interceptor HibernateAccessor.getEntityInterceptor()
Return the current Hibernate entity interceptor, or null if none.

Methods in org.springframework.orm.hibernate that throw BeansException
`net.sf.hibernate.Interceptor`	`HibernateTransactionManager.getEntityInterceptor()` Return the current Hibernate entity interceptor, or `null` if none.
`net.sf.hibernate.Interceptor`	`HibernateAccessor.getEntityInterceptor()` Return the current Hibernate entity interceptor, or `null` if none.

Uses of BeansException in org.springframework.orm.hibernate3

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

Interceptor HibernateTransactionManager.getEntityInterceptor()
Return the current Hibernate entity interceptor, or null if none.

Interceptor HibernateAccessor.getEntityInterceptor()
Return the current Hibernate entity interceptor, or null if none.

Methods in org.springframework.orm.hibernate3 that throw BeansException
`Interceptor`	`HibernateTransactionManager.getEntityInterceptor()` Return the current Hibernate entity interceptor, or `null` if none.
`Interceptor`	`HibernateAccessor.getEntityInterceptor()` Return the current Hibernate entity interceptor, or `null` if none.

Uses of BeansException in org.springframework.web.context

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

protected WebApplicationContext ContextLoader.createWebApplicationContext(ServletContext servletContext, ApplicationContext parent)
          Instantiate the root WebApplicationContext for this loader, either the default context class or a custom context class if specified.

WebApplicationContext ContextLoader.initWebApplicationContext(ServletContext servletContext)
          Initialize Spring's web application context for the given servlet context, according to the "contextClass" and "contextConfigLocation" context-params.

protected ApplicationContext ContextLoader.loadParentContext(ServletContext servletContext)
          Template method with default implementation (which may be overridden by a subclass), to load or obtain an ApplicationContext instance which will be used as the parent context of the root WebApplicationContext.

Methods in org.springframework.web.context that throw BeansException
`protected WebApplicationContext`	`ContextLoader.createWebApplicationContext(ServletContext servletContext, ApplicationContext parent)` Instantiate the root WebApplicationContext for this loader, either the default context class or a custom context class if specified.
`WebApplicationContext`	`ContextLoader.initWebApplicationContext(ServletContext servletContext)` Initialize Spring's web application context for the given servlet context, according to the "contextClass" and "contextConfigLocation" context-params.
`protected ApplicationContext`	`ContextLoader.loadParentContext(ServletContext servletContext)` Template method with default implementation (which may be overridden by a subclass), to load or obtain an ApplicationContext instance which will be used as the parent context of the root WebApplicationContext.

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

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

protected void XmlWebApplicationContext.loadBeanDefinitions(XmlBeanDefinitionReader reader)
          Load the bean definitions with the given XmlBeanDefinitionReader.

Object ServletContextAwareProcessor.postProcessBeforeInitialization(Object bean, String beanName)


void AbstractRefreshableWebApplicationContext.refresh()
          Sets a default config location if no explicit config location specified.

Methods in org.springframework.web.context.support that throw BeansException
`protected void`	`XmlWebApplicationContext.loadBeanDefinitions(XmlBeanDefinitionReader reader)` Load the bean definitions with the given XmlBeanDefinitionReader.
`Object`	`ServletContextAwareProcessor.postProcessBeforeInitialization(Object bean, String beanName)`
`void`	`AbstractRefreshableWebApplicationContext.refresh()` Sets a default config location if no explicit config location specified.

Uses of BeansException in org.springframework.web.filter

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

protected void GenericFilterBean.initBeanWrapper(BeanWrapper bw)
Initialize the BeanWrapper for this GenericFilterBean, possibly with custom editors.

Uses of BeansException in org.springframework.web.servlet

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

protected WebApplicationContext FrameworkServlet.createWebApplicationContext(WebApplicationContext parent)
          Instantiate the WebApplicationContext for this servlet, either a default XmlWebApplicationContext or a custom context class if set.

protected List DispatcherServlet.getDefaultStrategies(Class strategyInterface)
          Create a List of default strategy objects for the given strategy interface.

protected Object DispatcherServlet.getDefaultStrategy(Class strategyInterface)
          Return the default strategy object for the given strategy interface.

protected void HttpServletBean.initBeanWrapper(BeanWrapper bw)
          Initialize the BeanWrapper for this HttpServletBean, possibly with custom editors.

protected void FrameworkServlet.initFrameworkServlet()
          This method will be invoked after any bean properties have been set and the WebApplicationContext has been loaded.

protected void DispatcherServlet.initFrameworkServlet()
          Overridden method, invoked after any bean properties have been set and the WebApplicationContext and BeanFactory for this namespace is available.

protected void FrameworkServlet.initServletBean()
          Overridden method of HttpServletBean, invoked after any bean properties have been set.

protected WebApplicationContext FrameworkServlet.initWebApplicationContext()
          Initialize and publish the WebApplicationContext for this servlet.

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

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

void SimpleUrlHandlerMapping.initApplicationContext()
          Calls the registerHandlers 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 urlPath, Object handler)
          Register the specified handler for the given URL path.

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

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

void AbstractPathMapHandlerMapping.initApplicationContext()
Look for all classes with a PathMap class attribute, instantiate them in the owning ApplicationContext and register them as MVC handlers usable by the current DispatcherServlet.

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

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

void XmlViewResolver.destroy()
          Close the view bean factory on context shutdown.

void ResourceBundleViewResolver.destroy()
          Close the bundle bean factories on context shutdown.

protected void XmlViewResolver.initApplicationContext()
          Pre-initialize the factory from the XML file.

protected BeanFactory XmlViewResolver.initFactory()
          Initialize the view bean factory from the XML file.

protected View XmlViewResolver.loadView(String viewName, Locale locale)


View BeanNameViewResolver.resolveViewName(String viewName, Locale locale)

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

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

protected Configuration FreeMarkerView.autodetectConfiguration()
Autodetect a FreeMarker Configuration object via the ApplicationContext.

protected void FreeMarkerView.initApplicationContext()
Invoked on startup.

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

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

protected void ComponentControllerSupport.initApplicationContext()
Subclasses can override this for custom initialization behavior.

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

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

protected org.apache.velocity.app.VelocityEngine VelocityView.autodetectVelocityEngine()
Autodetect a VelocityEngine via the ApplicationContext.

protected void VelocityView.initApplicationContext()
Invoked on startup.

Uses of BeansException in org.springframework.web.struts

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

protected WebApplicationContext ContextLoaderPlugIn.createWebApplicationContext(WebApplicationContext parent)
          Instantiate the WebApplicationContext for the ActionServlet, either a default XmlWebApplicationContext or a custom context class if set.

protected Action DelegatingTilesRequestProcessor.getDelegateAction(ActionMapping mapping)
          Return the delegate Action for the given mapping.

protected Action DelegatingRequestProcessor.getDelegateAction(ActionMapping mapping)
          Return the delegate Action for the given mapping.

protected Action DelegatingActionProxy.getDelegateAction(ActionMapping mapping)
          Return the delegate Action for the given mapping.

protected WebApplicationContext ContextLoaderPlugIn.initWebApplicationContext()
          Initialize and publish the WebApplicationContext for the ActionServlet.