The Spring Framework

## 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 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` `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 `PropertyDescriptor`s 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, 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` `InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInstantiation(Class beanClass, String beanName)`
`Object` `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(Class beanClass, String beanName)` Apply this BeanPostProcessor before the target bean gets instantiated.
`PropertyValues` `InstantiationAwareBeanPostProcessorAdapter.postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)`
`PropertyValues` `InstantiationAwareBeanPostProcessor.postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)` Post-process the given property values before the factory applies them to the given bean.
`Class` `SmartInstantiationAwareBeanPostProcessor.predictBeanType(Class beanClass, String beanName)` Predict the type of the bean to be eventually returned from this processor's `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class, java.lang.String)` callback.
`void` `ConfigurableListableBeanFactory.preInstantiateSingletons()` Ensure that all non-lazy-init singletons are instantiated, also considering `FactoryBeans`.
`protected void` `PropertyOverrideConfigurer.processKey(ConfigurableListableBeanFactory factory, String key, String value)` Process the given key as 'beanName.property' entry.
`protected abstract void` `PropertyResourceConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)` Apply the given Properties to the given BeanFactory.
`protected void` `PropertyPlaceholderConfigurer.processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)`
`protected void` `PropertyOverrideConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)`
`Object` `AutowireCapableBeanFactory.resolveDependency(DependencyDescriptor descriptor, String beanName)` Resolve the specified dependency against the beans defined in this factory.
`Object` `AutowireCapableBeanFactory.resolveDependency(DependencyDescriptor descriptor, String beanName, Set autowiredBeanNames, TypeConverter typeConverter)` Resolve the specified dependency against the beans defined in this factory.
`void` `ServiceLocatorFactoryBean.setBeanFactory(BeanFactory beanFactory)`

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

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

`

`<T> T`

`

`GenericBeanFactoryAccessor.getBean(String name)`

`

`<T> T`

`

`GenericBeanFactoryAccessor.getBean(String name, Class<T> requiredType)`

`

`<T> Map<String,T>`

`

`GenericBeanFactoryAccessor.getBeansOfType(Class<T> type)`

`

`<T> Map<String,T>`

`

`GenericBeanFactoryAccessor.getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)`

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

Subclasses of BeansException in org.springframework.beans.factory.parsing
`class` `BeanDefinitionParsingException` Exception thrown when a bean definition reader encounters an error during the parsing process.

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

Subclasses of BeansException in org.springframework.beans.factory.support
`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)`
`protected void` `AbstractAutowireCapableBeanFactory.applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class beanType, String beanName)` Apply MergedBeanDefinitionPostProcessors to the specified bean definition, invoking their `postProcessMergedBeanDefinition` methods.
`Object` `AbstractAutowireCapableBeanFactory.autowire(Class beanClass, int autowireMode, boolean dependencyCheck)`
`void` `AbstractAutowireCapableBeanFactory.autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)`
`Object` `AbstractAutowireCapableBeanFactory.configureBean(Object existingBean, String beanName)`
`Object` `AbstractAutowireCapableBeanFactory.createBean(Class beanClass)`
`Object` `AbstractAutowireCapableBeanFactory.createBean(Class beanClass, int autowireMode, boolean dependencyCheck)`
`protected Constructor[]` `AbstractAutowireCapableBeanFactory.determineConstructorsFromBeanPostProcessors(Class beanClass, String beanName)` Determine candidate constructors to use for the given bean, checking all registered `SmartInstantiationAwareBeanPostProcessors`.
`protected Object` `AbstractBeanFactory.doGetBean(String name, Class requiredType, Object[] args, boolean typeCheckOnly)` Return an instance, which may be shared or independent, of the specified bean.
`Object` `AbstractBeanFactory.getBean(String name)`
`Object` `StaticListableBeanFactory.getBean(String name)`
`Object` `AbstractBeanFactory.getBean(String name, Class requiredType)`
`Object` `StaticListableBeanFactory.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)`
`Object` `StaticListableBeanFactory.getBean(String name, Object[] args)`
`protected abstract BeanDefinition` `AbstractBeanFactory.getBeanDefinition(String beanName)` Return the bean definition for the given bean name.
`Map` `DefaultListableBeanFactory.getBeansOfType(Class type)`
`Map` `StaticListableBeanFactory.getBeansOfType(Class type)`
`Map` `DefaultListableBeanFactory.getBeansOfType(Class type, boolean includeNonSingletons, boolean allowEagerInit)`
`Map` `StaticListableBeanFactory.getBeansOfType(Class type, boolean includeNonSingletons, boolean includeFactoryBeans)`
`protected FactoryBean` `FactoryBeanRegistrySupport.getFactoryBean(String beanName, Object beanInstance)` Get a FactoryBean for the given bean if possible.
`BeanDefinition` `AbstractBeanFactory.getMergedBeanDefinition(String name)` Return a 'merged' BeanDefinition for the given bean name, merging a child bean definition with its parent if necessary.
`protected RootBeanDefinition` `AbstractBeanFactory.getMergedLocalBeanDefinition(String beanName)` Return a merged RootBeanDefinition, traversing the parent bean definition if the specified bean corresponds to a child bean definition.
`Object` `InstantiationStrategy.instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner)` Return an instance of the bean with the given name in this factory.
`Object` `InstantiationStrategy.instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner, Constructor ctor, Object[] args)` Return an instance of the bean with the given name in this factory, creating it via the given constructor.
`Object` `InstantiationStrategy.instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner, Object factoryBean, Method factoryMethod, Object[] args)` Return an instance of the bean with the given name in this factory, creating it via the given factory method.
`protected Object` `FactoryBeanRegistrySupport.postProcessObjectFromFactoryBean(Object object, String beanName)` Post-process the given object that has been obtained from the FactoryBean.
`void` `DefaultListableBeanFactory.preInstantiateSingletons()`
`protected void` `PropertiesBeanDefinitionReader.registerBeanDefinition(String beanName, Map map, String prefix, String resourceDescription)` 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` `AbstractAutowireCapableBeanFactory.resolveDependency(DependencyDescriptor descriptor, String beanName)`
`Object` `DefaultListableBeanFactory.resolveDependency(DependencyDescriptor descriptor, String beanName, Set autowiredBeanNames, TypeConverter typeConverter)`

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

Subclasses of BeansException in org.springframework.beans.factory.xml
`class` `XmlBeanDefinitionStoreException` XML-specific BeanDefinitionStoreException subclass that wraps a `SAXException`, typically a `SAXParseException` which contains information about the error location.

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.

Uses of BeansException in org.springframework.context

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.

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

Methods in org.springframework.context.annotation that throw BeansException
`protected Object` `CommonAnnotationBeanPostProcessor.autowireResource(BeanFactory factory, CommonAnnotationBeanPostProcessor.LookupElement element, String requestingBeanName)` Obtain a resource object for the given name and type through autowiring based on the given factory.
`protected Object` `CommonAnnotationBeanPostProcessor.getResource(CommonAnnotationBeanPostProcessor.LookupElement element, String requestingBeanName)` Obtain the resource object for the given name and type.
`boolean` `CommonAnnotationBeanPostProcessor.postProcessAfterInstantiation(Object bean, String beanName)`
`Object` `CommonAnnotationBeanPostProcessor.postProcessBeforeInstantiation(Class beanClass, String beanName)`
`PropertyValues` `CommonAnnotationBeanPostProcessor.postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)`
`void` `CommonAnnotationBeanPostProcessor.setBeanFactory(BeanFactory beanFactory)`

Uses of BeansException in org.springframework.context.support

Methods in org.springframework.context.support with parameters of type BeansException
`protected void` `AbstractApplicationContext.cancelRefresh(BeansException ex)` Cancel this context's refresh attempt, resetting the `active` flag after an exception got thrown.

Methods in org.springframework.context.support that throw BeansException
`Object` `AbstractApplicationContext.getBean(String name)`
`Object` `AbstractApplicationContext.getBean(String name, Class requiredType)`
`Object` `AbstractApplicationContext.getBean(String name, Object[] args)`
`Map` `AbstractApplicationContext.getBeansOfType(Class type)`
`Map` `AbstractApplicationContext.getBeansOfType(Class type, boolean includePrototypes, boolean allowEagerInit)`
`protected void` `ApplicationObjectSupport.initApplicationContext()` Subclasses can override this for custom initialization behavior.
`protected void` `ApplicationObjectSupport.initApplicationContext(ApplicationContext context)` Subclasses can override this for custom initialization behavior.
`protected abstract void` `AbstractRefreshableApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory)` Load bean definitions into the given bean factory, typically through delegating to one or more bean definition readers.
`protected void` `AbstractXmlApplicationContext.loadBeanDefinitions(XmlBeanDefinitionReader reader)` Load the bean definitions with the given XmlBeanDefinitionReader.
`protected void` `AbstractApplicationContext.onRefresh()` Template method which can be overridden to add context-specific refresh work.
`void` `AbstractApplicationContext.refresh()`
`protected abstract void` `AbstractApplicationContext.refreshBeanFactory()` Subclasses must implement this method to perform the actual configuration load.
`protected void` `AbstractRefreshableApplicationContext.refreshBeanFactory()` This implementation performs an actual refresh of this context's underlying bean factory, shutting down the previous bean factory (if any) and initializing a fresh bean factory for the next phase of the context's lifecycle.
`void` `StaticApplicationContext.registerPrototype(String name, Class clazz)` Register a prototype bean with the underlying bean factory.
`void` `StaticApplicationContext.registerPrototype(String name, Class clazz, MutablePropertyValues pvs)` Register a prototype bean with the underlying bean factory.
`void` `StaticApplicationContext.registerSingleton(String name, Class clazz)` Register a singleton bean with the underlying bean factory.
`void` `StaticApplicationContext.registerSingleton(String name, Class clazz, MutablePropertyValues pvs)` Register a singleton bean with the underlying bean factory.
`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.
`ClassPathXmlApplicationContext(String[] paths, Class clazz)` Create a new ClassPathXmlApplicationContext, loading the definitions from the given XML files and automatically refreshing the context.
`ClassPathXmlApplicationContext(String[] paths, Class clazz, ApplicationContext parent)` Create a new ClassPathXmlApplicationContext with the given parent, loading the definitions from the given XML files and automatically refreshing the context.
`ClassPathXmlApplicationContext(String path, Class clazz)` Create a new ClassPathXmlApplicationContext, loading the definitions from the given XML file and automatically refreshing the context.
`FileSystemXmlApplicationContext(String configLocation)` Create a new FileSystemXmlApplicationContext, loading the definitions from the given XML file and automatically refreshing the context.
`FileSystemXmlApplicationContext(String[] configLocations)` Create a new FileSystemXmlApplicationContext, loading the definitions from the given XML files and automatically refreshing the context.
`FileSystemXmlApplicationContext(String[] configLocations, 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.context.weaving

Methods in org.springframework.context.weaving that throw BeansException
`void` `AspectJWeavingEnabler.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)`
`Object` `LoadTimeWeaverAwareProcessor.postProcessBeforeInitialization(Object bean, String beanName)`

Uses of BeansException in org.springframework.dao.annotation

Methods in org.springframework.dao.annotation that throw BeansException
`Object` `PersistenceExceptionTranslationPostProcessor.postProcessAfterInitialization(Object bean, String beanName)`
`Object` `PersistenceExceptionTranslationPostProcessor.postProcessBeforeInitialization(Object bean, String beanName)`
`void` `PersistenceExceptionTranslationPostProcessor.setBeanFactory(BeanFactory beanFactory)`

Uses of BeansException in org.springframework.dao.support

Methods in org.springframework.dao.support that throw BeansException
`void` `PersistenceExceptionTranslationInterceptor.setBeanFactory(BeanFactory beanFactory)`

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.

Uses of BeansException in org.springframework.jca.context

Methods in org.springframework.jca.context that throw BeansException
`protected void` `ResourceAdapterApplicationContext.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)`

Uses of BeansException in org.springframework.jndi.support

Methods in org.springframework.jndi.support that throw BeansException
`Object` `SimpleJndiBeanFactory.getBean(String name)`
`Object` `SimpleJndiBeanFactory.getBean(String name, Class requiredType)`
`Object` `SimpleJndiBeanFactory.getBean(String name, Object[] args)`

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.

Uses of BeansException in org.springframework.orm.jpa.support

Methods in org.springframework.orm.jpa.support that throw BeansException
`Object` `PersistenceAnnotationBeanPostProcessor.postProcessAfterInitialization(Object bean, String beanName)`
`boolean` `PersistenceAnnotationBeanPostProcessor.postProcessAfterInstantiation(Object bean, String beanName)`
`void` `PersistenceAnnotationBeanPostProcessor.postProcessBeforeDestruction(Object bean, String beanName)`
`Object` `PersistenceAnnotationBeanPostProcessor.postProcessBeforeInitialization(Object bean, String beanName)`
`Object` `PersistenceAnnotationBeanPostProcessor.postProcessBeforeInstantiation(Class beanClass, String beanName)`
`PropertyValues` `PersistenceAnnotationBeanPostProcessor.postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)`

Uses of BeansException in org.springframework.scripting.groovy

Methods in org.springframework.scripting.groovy that throw BeansException
`void` `GroovyScriptFactory.setBeanFactory(BeanFactory beanFactory)`

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.

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

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

Methods in org.springframework.web.portlet that throw BeansException
`protected Object` `DispatcherPortlet.createDefaultStrategy(ApplicationContext context, Class clazz)` Create a default strategy.
`protected ApplicationContext` `FrameworkPortlet.createPortletApplicationContext(ApplicationContext parent)` Instantiate the Portlet ApplicationContext for this portlet, either a default XmlPortletApplicationContext or a custom context class if set.
`protected List` `DispatcherPortlet.getDefaultStrategies(ApplicationContext context, Class strategyInterface)` Create a List of default strategy objects for the given strategy interface.
`protected Object` `DispatcherPortlet.getDefaultStrategy(ApplicationContext context, Class strategyInterface)` Return the default strategy object for the given strategy interface.
`protected void` `GenericPortletBean.initBeanWrapper(BeanWrapper bw)` Initialize the BeanWrapper for this GenericPortletBean, possibly with custom editors.
`protected void` `FrameworkPortlet.initFrameworkPortlet()` This method will be invoked after any bean properties have been set and the ApplicationContext has been loaded.
`protected ApplicationContext` `FrameworkPortlet.initPortletApplicationContext()` Initialize and publish the Portlet ApplicationContext for this portlet.
`protected void` `FrameworkPortlet.initPortletBean()` Overridden method of GenericPortletBean, invoked after any bean properties have been set.
`protected void` `FrameworkPortlet.onRefresh(ApplicationContext context)` Template method which can be overridden to add portlet-specific refresh work.
`void` `FrameworkPortlet.refresh()` Refresh this portlet's application context, as well as the dependent state of the portlet.

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

Methods in org.springframework.web.portlet.context that throw BeansException
`protected void` `XmlPortletApplicationContext.loadBeanDefinitions(XmlBeanDefinitionReader reader)` Load the bean definitions with the given XmlBeanDefinitionReader.
`Object` `PortletContextAwareProcessor.postProcessBeforeInitialization(Object bean, String beanName)`

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

Methods in org.springframework.web.portlet.handler that throw BeansException
`void` `PortletModeParameterHandlerMapping.initApplicationContext()` Calls the `registerHandlers` method in addition to the superclass's initialization.
`void` `PortletModeHandlerMapping.initApplicationContext()` Calls the `registerHandlers` method in addition to the superclass's initialization.
`void` `ParameterHandlerMapping.initApplicationContext()` Calls the `registerHandlers` method in addition to the superclass's initialization.
`protected void` `AbstractHandlerMapping.initApplicationContext()` Initializes the interceptors.
`Object` `SimplePortletPostProcessor.postProcessAfterInitialization(Object bean, String beanName)`
`void` `SimplePortletPostProcessor.postProcessBeforeDestruction(Object bean, String beanName)`
`Object` `SimplePortletPostProcessor.postProcessBeforeInitialization(Object bean, String beanName)`
`protected void` `AbstractMapBasedHandlerMapping.registerHandler(Object lookupKey, Object handler)` Register the given handler instance for the given parameter value.
`protected void` `AbstractMapBasedHandlerMapping.registerHandler(Object lookupKey, Object handler, AbstractMapBasedHandlerMapping.PortletRequestMappingPredicate predicate)` Register the given handler instance for the given parameter value.
`protected void` `PortletModeParameterHandlerMapping.registerHandler(javax.portlet.PortletMode mode, Map parameterMap)` Register all handlers specified in the given parameter map.
`protected void` `PortletModeParameterHandlerMapping.registerHandler(javax.portlet.PortletMode mode, String parameter, Object handler)` Register the given handler instance for the given PortletMode and parameter value, under an appropriate lookup key.
`protected void` `AbstractMapBasedHandlerMapping.registerHandlers(Map handlerMap)` Register all handlers specified in the Portlet mode map for the corresponding modes.
`protected void` `PortletModeParameterHandlerMapping.registerHandlers(Map portletModeParameterMap)` Register all handlers specified in the Portlet mode map for the corresponding modes.
`protected void` `PortletModeHandlerMapping.registerHandlers(Map portletModeMap)` Register all handlers specified in the Portlet mode map for the corresponding modes.
`protected void` `ParameterHandlerMapping.registerHandlers(Map parameterMap)` Register all handlers specified in the Portlet mode map for the corresponding modes.

Uses of BeansException in org.springframework.web.portlet.mvc.annotation

Methods in org.springframework.web.portlet.mvc.annotation that throw BeansException
`protected void` `DefaultAnnotationHandlerMapping.detectHandlers()` Register all handlers specified in the Portlet mode map for the corresponding modes.
`void` `DefaultAnnotationHandlerMapping.initApplicationContext()` Calls the `registerHandlers` method in addition to the superclass's initialization.

Uses of BeansException in org.springframework.web.servlet

Methods in org.springframework.web.servlet that throw BeansException
`protected Object` `DispatcherServlet.createDefaultStrategy(ApplicationContext context, Class clazz)` Create a default strategy.
`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(ApplicationContext context, Class strategyInterface)` Create a List of default strategy objects for the given strategy interface.
`protected Object` `DispatcherServlet.getDefaultStrategy(ApplicationContext context, 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` `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.
`protected void` `FrameworkServlet.onRefresh(ApplicationContext context)` Template method which can be overridden to add servlet-specific refresh work.
`protected void` `DispatcherServlet.onRefresh(ApplicationContext context)` This implementation calls `DispatcherServlet.initStrategies(org.springframework.context.ApplicationContext)`.
`void` `FrameworkServlet.refresh()` Refresh this servlet's application context, as well as the dependent state of the servlet.

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

Methods in org.springframework.web.servlet.handler that throw BeansException
`protected void` `AbstractDetectingUrlHandlerMapping.detectHandlers()` Register all handlers found in the current ApplicationContext.
`void` `SimpleUrlHandlerMapping.initApplicationContext()` Calls the `SimpleUrlHandlerMapping.registerHandlers(java.util.Map)` method in addition to the superclass's initialization.
`protected void` `AbstractHandlerMapping.initApplicationContext()` Initializes the interceptors.
`Object` `SimpleServletPostProcessor.postProcessAfterInitialization(Object bean, String beanName)`
`void` `SimpleServletPostProcessor.postProcessBeforeDestruction(Object bean, String beanName)`
`Object` `SimpleServletPostProcessor.postProcessBeforeInitialization(Object bean, String beanName)`
`protected void` `AbstractUrlHandlerMapping.registerHandler(String[] urlPaths, String beanName)` Register the specified handler for the given URL paths.
`protected void` `AbstractUrlHandlerMapping.registerHandler(String urlPath, Object handler)` Register the specified handler for the given URL path.
`protected void` `SimpleUrlHandlerMapping.registerHandlers(Map urlMap)` Register all handlers specified in the URL map for the corresponding paths.

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

Methods in org.springframework.web.servlet.handler.metadata that throw BeansException
`protected void` `AbstractPathMapHandlerMapping.detectAndCreateHandlers(ConfigurableListableBeanFactory beanFactory)` Deprecated. 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.
`void` `AbstractPathMapHandlerMapping.initApplicationContext()` Deprecated. Calls the `detectAndCreateHandlers` method in addition to the superclass's initialization.
`protected void` `AbstractPathMapHandlerMapping.registerHandler(PathMap[] pathMaps, Object handler)` Deprecated. Register the given handler for the URL paths indicated by the given PathMaps.

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 View factories on context shutdown.
`protected void` `XmlViewResolver.initApplicationContext()` Pre-initialize the factory from the XML file.
`protected void` `ResourceBundleViewResolver.initApplicationContext()`
`protected BeanFactory` `XmlViewResolver.initFactory()` Initialize the view bean factory from the XML file.
`protected BeanFactory` `ResourceBundleViewResolver.initFactory(Locale locale)` Initialize the View `BeanFactory` from the `ResourceBundle`, for the given `locale`.
`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 FreeMarkerConfig` `FreeMarkerView.autodetectConfiguration()` Autodetect a `FreeMarkerConfig` 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 VelocityEngine` `VelocityView.autodetectVelocityEngine()` Autodetect a VelocityEngine via the ApplicationContext.
`protected void` `VelocityView.initApplicationContext()` Invoked on startup.

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

Methods in org.springframework.web.servlet.view.xslt that throw BeansException
`protected void` `XsltView.initApplicationContext()` Initialize this XsltView's TransformerFactory.

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` `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 Action` `DelegatingTilesRequestProcessor.getDelegateAction(ActionMapping mapping)` Return the delegate Action for the given mapping.
`protected WebApplicationContext` `ContextLoaderPlugIn.initWebApplicationContext()` Initialize and publish the WebApplicationContext for the ActionServlet.

The Spring Framework

Copyright © 2002-2008 The Spring Framework.