| 
 | ||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| 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.factorypackage. | 
| org.springframework.beans.factory.xml | Contains an abstract XML-based BeanFactoryimplementation,
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 LoadTimeWeaverabstraction. | 
| 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.jpapackage. | 
| 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.contextpackage,
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 | LazyInitTargetSource.getTarget() | 
|  Object | ThreadLocalTargetSource.getTarget()Implementation of abstract getTarget() method. | 
|  Object | PrototypeTargetSource.getTarget()Obtain a new prototype instance for every call. | 
|  Object | CommonsPoolTargetSource.makeObject() | 
| protected  Object | AbstractPrototypeBasedTargetSource.newPrototypeInstance()Subclasses should call this method to create a new prototype instance. | 
|  void | AbstractPrototypeBasedTargetSource.setBeanFactory(BeanFactory beanFactory) | 
|  void | AbstractBeanFactoryBasedTargetSource.setBeanFactory(BeanFactory beanFactory)Set the owning BeanFactory. | 
|  void | AbstractPoolingTargetSource.setBeanFactory(BeanFactory beanFactory) | 
| Uses of BeansException in org.springframework.beans | 
|---|
| Subclasses of BeansException in org.springframework.beans | |
|---|---|
|  class | BeanInstantiationExceptionException thrown when instantiation of a bean failed. | 
|  class | FatalBeanExceptionThrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g. bad class or field. | 
|  class | InvalidPropertyExceptionException thrown when referring to an invalid bean property. | 
|  class | MethodInvocationExceptionThrown when a bean property getter or setter method throws an exception, analogous to an InvocationTargetException. | 
|  class | NotReadablePropertyExceptionException thrown on an attempt to get the value of a property that isn't readable, because there's no getter method. | 
|  class | NotWritablePropertyExceptionException thrown on an attempt to set the value of a property that is not writable (typically because there is no setter method). | 
|  class | NullValueInNestedPathExceptionException thrown when navigation of a valid nested property path encounters a NullPointerException. | 
|  class | PropertyAccessExceptionSuperclass for exceptions related to a property access, such as type mismatch or invocation target exception. | 
|  class | PropertyBatchUpdateExceptionCombined exception, composed of individual PropertyAccessException instances. | 
|  class | TypeMismatchExceptionException 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 PropertyDescriptorfor 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 PropertyDescriptorsfor 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):
 Returnsnullif not found rather than throwing an exception. | 
| static PropertyDescriptor[] | BeanUtils.getPropertyDescriptors(Class clazz)Retrieve the JavaBeans PropertyDescriptors of a given class. | 
|  Class | DirectFieldAccessor.getPropertyType(String propertyName) | 
|  Class | BeanWrapperImpl.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. | 
|  Object | DirectFieldAccessor.getPropertyValue(String propertyName) | 
|  Object | BeanWrapperImpl.getPropertyValue(String propertyName) | 
| abstract  Object | AbstractPropertyAccessor.getPropertyValue(String propertyName)Actually get the value of a property. | 
|  Object | PropertyAccessor.getPropertyValue(String propertyName)Get the current value of the specified property. | 
|  boolean | DirectFieldAccessor.isReadableProperty(String propertyName) | 
|  boolean | DirectFieldAccessor.isWritableProperty(String propertyName) | 
|  void | BeanWrapperImpl.setPropertyValue(PropertyValue pv) | 
|  void | AbstractPropertyAccessor.setPropertyValue(PropertyValue pv) | 
|  void | PropertyAccessor.setPropertyValue(PropertyValue pv)Set the specified value as current property value. | 
|  void | DirectFieldAccessor.setPropertyValue(String propertyName,
                 Object newValue) | 
|  void | BeanWrapperImpl.setPropertyValue(String propertyName,
                 Object value) | 
| abstract  void | AbstractPropertyAccessor.setPropertyValue(String propertyName,
                 Object value)Actually set a property value. | 
|  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 | BeanCreationExceptionException thrown when a BeanFactory encounters an error when attempting to create a bean from a bean definition. | 
|  class | BeanCreationNotAllowedExceptionException 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 | BeanCurrentlyInCreationExceptionException thrown in case of a reference to a bean that's currently in creation. | 
|  class | BeanDefinitionStoreExceptionException thrown when a BeanFactory encounters an invalid bean definition: e.g. in case of incomplete or contradictory bean metadata. | 
|  class | BeanInitializationExceptionException that a bean implementation is suggested to throw if its own factory-aware initialization code fails. | 
|  class | BeanIsAbstractExceptionException thrown when a bean instance has been requested for a bean which has been defined as abstract | 
|  class | BeanIsNotAFactoryExceptionException thrown when a bean is not a factory, but a user tries to get at the factory for the given bean name. | 
|  class | BeanNotOfRequiredTypeExceptionThrown when a bean doesn't match the expected type. | 
|  class | CannotLoadBeanClassExceptionException thrown when the BeanFactory cannot load the specified class of a given bean. | 
|  class | FactoryBeanNotInitializedExceptionException 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 | NoSuchBeanDefinitionExceptionException thrown when a BeanFactory is asked for a bean instance name for which it cannot find a definition. | 
|  class | UnsatisfiedDependencyExceptionException 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 getObjectTypein 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 getObjectTypein 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 | BootstrapExceptionException 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 | BeanFactoryLocator.useBeanFactory(String factoryKey)Use the BeanFactory(or derived
 interface such asApplicationContext)
 specified by thefactoryKeyparameter. | 
|  BeanFactoryReference | SingletonBeanFactoryLocator.useBeanFactory(String factoryKey) | 
| 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 | AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(PropertyValues pvs,
                          PropertyDescriptor[] pds,
                          Object bean,
                          String beanName) | 
|  PropertyValues | RequiredAnnotationBeanPostProcessor.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 BeanPostProcessorsto the given existing bean
 instance, invoking theirpostProcessAfterInitializationmethods. | 
|  Object | AutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(Object existingBean,
                                            String beanName)Apply BeanPostProcessorsto the given existing bean
 instance, invoking theirpostProcessBeforeInitializationmethods. | 
|  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 setBeanNameandsetBeanFactory, 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 setBeanNameandsetBeanFactory,
 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 afterPropertiesSetor 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 | 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 | PropertyResourceConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) | 
|  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 afterPropertiesSetor 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  void | PropertyPlaceholderConfigurer.processProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
                  Properties props) | 
| protected  void | PropertyOverrideConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory,
                  Properties props) | 
| protected abstract  void | PropertyResourceConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory,
                  Properties props)Apply the given Properties to the given BeanFactory. | 
|  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 | ||
|---|---|---|
| 
 | GenericBeanFactoryAccessor.getBean(String name) | |
| 
 | GenericBeanFactoryAccessor.getBean(String name,
        Class<T> requiredType) | |
| 
 | GenericBeanFactoryAccessor.getBeansOfType(Class<T> type) | |
| 
 | 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 | BeanDefinitionParsingExceptionException 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 | BeanDefinitionValidationExceptionException 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 postProcessBeforeInstantiationmethods. | 
|  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 postProcessMergedBeanDefinitionmethods. | 
|  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 | StaticListableBeanFactory.getBeansOfType(Class type) | 
|  Map | DefaultListableBeanFactory.getBeansOfType(Class type) | 
|  Map | StaticListableBeanFactory.getBeansOfType(Class type,
               boolean includeNonSingletons,
               boolean includeFactoryBeans) | 
|  Map | DefaultListableBeanFactory.getBeansOfType(Class type,
               boolean includeNonSingletons,
               boolean allowEagerInit) | 
| 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 | XmlBeanDefinitionStoreExceptionXML-specific BeanDefinitionStoreException subclass that wraps a SAXException, typically aSAXParseExceptionwhich 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 | ApplicationContextExceptionException 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 activeflag
 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 | |
|---|---|
|  org.hibernate.Interceptor | HibernateAccessor.getEntityInterceptor()Return the current Hibernate entity interceptor, or nullif none. | 
|  org.hibernate.Interceptor | HibernateTransactionManager.getEntityInterceptor()Return the current Hibernate entity interceptor, or nullif 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 | PortletModeHandlerMapping.initApplicationContext()Calls the registerHandlersmethod in addition
 to the superclass's initialization. | 
| protected  void | AbstractHandlerMapping.initApplicationContext()Initializes the interceptors. | 
|  void | PortletModeParameterHandlerMapping.initApplicationContext()Calls the registerHandlersmethod in addition
 to the superclass's initialization. | 
|  void | ParameterHandlerMapping.initApplicationContext()Calls the registerHandlersmethod in addition
 to the superclass's initialization. | 
|  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 | PortletModeHandlerMapping.registerHandlers(Map portletModeMap)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 | ParameterHandlerMapping.registerHandlers(Map parameterMap)Register all handlers specified in the Portlet mode map for the corresponding modes. | 
| protected  void | AbstractMapBasedHandlerMapping.registerHandlers(Map handlerMap)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 registerHandlersmethod 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 XmlWebApplicationContextor acustom 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 | DispatcherServlet.onRefresh(ApplicationContext context)This implementation calls DispatcherServlet.initStrategies(org.springframework.context.ApplicationContext). | 
| protected  void | FrameworkServlet.onRefresh(ApplicationContext context)Template method which can be overridden to add servlet-specific refresh work. | 
|  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. | 
| protected  void | AbstractHandlerMapping.initApplicationContext()Initializes the interceptors. | 
|  void | SimpleUrlHandlerMapping.initApplicationContext()Calls the SimpleUrlHandlerMapping.registerHandlers(java.util.Map)method in addition to the
 superclass's initialization. | 
|  Object | SimpleServletPostProcessor.postProcessAfterInitialization(Object bean,
                               String beanName) | 
|  void | SimpleServletPostProcessor.postProcessBeforeDestruction(Object bean,
                             String beanName) | 
|  Object | SimpleServletPostProcessor.postProcessBeforeInitialization(Object bean,
                                String beanName) | 
| protected  void | AbstractUrlHandlerMapping.registerHandler(String[] urlPaths,
                String beanName)Register the specified handler for the given URL paths. | 
| protected  void | AbstractUrlHandlerMapping.registerHandler(String urlPath,
                Object handler)Register the specified handler for the given URL path. | 
| protected  void | SimpleUrlHandlerMapping.registerHandlers(Map 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 detectAndCreateHandlersmethod 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 BeanFactoryfrom theResourceBundle,
 for the givenlocale. | 
| 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 FreeMarkerConfigobject 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 Actionfor the given mapping. | 
| protected  Action | DelegatingActionProxy.getDelegateAction(ActionMapping mapping)Return the delegate Actionfor the givenmapping. | 
| 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. | 
| 
 | ||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||