## Uses of Class
org.springframework.beans.BeansException

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

- - ### Uses of BeansException in org.springframework.aop.framework

    Methods in org.springframework.aop.framework that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `Object` | ProxyFactoryBean.`getObject()` Return a proxy.

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

    Methods in org.springframework.aop.framework.adapter that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `Object` | AdvisorAdapterRegistrationManager.`postProcessAfterInitialization(Object bean, String beanName)`
    `Object` | AdvisorAdapterRegistrationManager.`postProcessBeforeInitialization(Object bean, String beanName)`

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

    Methods in org.springframework.aop.framework.autoproxy that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected abstract Object[]` | AbstractAutoProxyCreator.`getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource customTargetSource)` Return whether the given bean is to be proxied, what additional advices (e.g.

  - ### Uses of BeansException in org.springframework.aop.target

    Methods in org.springframework.aop.target that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `Object` | ThreadLocalTargetSource.`getTarget()` Implementation of abstract getTarget() method.
    `Object` | LazyInitTargetSource.`getTarget()`
    `Object` | PrototypeTargetSource.`getTarget()` Obtain a new prototype instance for every call.
    `protected Object` | AbstractPrototypeBasedTargetSource.`newPrototypeInstance()` Subclasses should call this method to create a new prototype instance.
    `void` | AbstractPoolingTargetSource.`setBeanFactory(BeanFactory beanFactory)`
    `void` | AbstractPrototypeBasedTargetSource.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeansException in org.springframework.beans

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

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

  - ### Uses of BeansException in org.springframework.beans.factory

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

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

    Constructors in org.springframework.beans.factory with parameters of type BeansException
    Constructor and Description
    `UnsatisfiedDependencyException(String resourceDescription, String beanName, InjectionPoint injectionPoint, 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.annotation

    Methods in org.springframework.beans.factory.annotation that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected <T> Map<String,T>` | AutowiredAnnotationBeanPostProcessor.`findAutowireCandidates(Class<T> type)` Deprecated. since 5.3.24 since it is unused in the meantime
    `Object` | InitDestroyAnnotationBeanPostProcessor.`postProcessAfterInitialization(Object bean, String beanName)`
    `void` | CustomAutowireConfigurer.`postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)`
    `void` | InitDestroyAnnotationBeanPostProcessor.`postProcessBeforeDestruction(Object bean, String beanName)`
    `Object` | InitDestroyAnnotationBeanPostProcessor.`postProcessBeforeInitialization(Object bean, String beanName)`
    `static <T> T` | BeanFactoryAnnotationUtils.`qualifiedBeanOfType(BeanFactory beanFactory, Class<T> beanType, String qualifier)` Obtain a bean of type `T` from the given `BeanFactory` declaring a qualifier (e.g.
    `static <T> Map<String,T>` | BeanFactoryAnnotationUtils.`qualifiedBeansOfType(ListableBeanFactory beanFactory, Class<T> beanType, String qualifier)` Retrieve all bean of type `T` from the given `BeanFactory` declaring a qualifier (e.g.
    `static Object` | ParameterResolutionDelegate.`resolveDependency(Parameter parameter, int parameterIndex, Class<?> containingClass, AutowireCapableBeanFactory beanFactory)` Resolve the dependency for the supplied `Parameter` from the supplied `AutowireCapableBeanFactory`.

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

    Methods in org.springframework.beans.factory.config with parameters of type BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected Exception` | ServiceLocatorFactoryBean.`createServiceLocatorException(Constructor<Exception> exceptionConstructor, BeansException cause)` Create a service locator exception for the given cause.

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

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

    Subclasses of BeansException in org.springframework.beans.factory.parsing
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BeanDefinitionParsingException` Exception thrown when a bean definition reader encounters an error during the parsing process.

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

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

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

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

    Subclasses of BeansException in org.springframework.beans.factory.xml
    Modifier and Type | Class and Description
    --- | ---
    `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
    Constructor and Description
    `XmlBeanFactory(Resource resource)` Deprecated. Create a new XmlBeanFactory with the given resource, which must be parsable using DOM.
    `XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory)` Deprecated. 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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ApplicationContextException` Exception thrown during application context initialization.

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

  - ### Uses of BeansException in org.springframework.context.expression

    Methods in org.springframework.context.expression that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `Object` | StandardBeanExpressionResolver.`evaluate(String value, BeanExpressionContext beanExpressionContext)`

  - ### Uses of BeansException in org.springframework.context.support

    Methods in org.springframework.context.support with parameters of type BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | GenericApplicationContext.`cancelRefresh(BeansException ex)`
    `protected void` | AbstractRefreshableApplicationContext.`cancelRefresh(BeansException ex)`
    `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
    Modifier and Type | Method and Description
    --- | ---
    `<T> T` | AbstractApplicationContext.`getBean(Class<T> requiredType)`
    `<T> T` | AbstractApplicationContext.`getBean(Class<T> requiredType, Object... args)`
    `Object` | AbstractApplicationContext.`getBean(String name)`
    `<T> T` | AbstractApplicationContext.`getBean(String name, Class<T> requiredType)`
    `Object` | AbstractApplicationContext.`getBean(String name, Object... args)`
    `<T> Map<String,T>` | AbstractApplicationContext.`getBeansOfType(Class<T> type)`
    `<T> Map<String,T>` | AbstractApplicationContext.`getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)`
    `Map<String,Object>` | AbstractApplicationContext.`getBeansWithAnnotation(Class<? extends Annotation> annotationType)`
    `protected void` | ApplicationObjectSupport.`initApplicationContext()` Subclasses can override this for custom initialization behavior.
    `protected void` | ApplicationObjectSupport.`initApplicationContext(ApplicationContext context)` Subclasses can override this for custom initialization behavior.
    `protected abstract void` | AbstractRefreshableApplicationContext.`loadBeanDefinitions(DefaultListableBeanFactory beanFactory)` Load bean definitions into the given bean factory, typically through delegating to one or more bean definition readers.
    `protected void` | AbstractXmlApplicationContext.`loadBeanDefinitions(DefaultListableBeanFactory beanFactory)` Loads the bean definitions via an XmlBeanDefinitionReader.
    `protected void` | AbstractXmlApplicationContext.`loadBeanDefinitions(XmlBeanDefinitionReader reader)` Load the bean definitions with the given XmlBeanDefinitionReader.
    `protected void` | AbstractApplicationContext.`onRefresh()` Template method which can be overridden to add context-specific refresh work.
    `void` | PropertySourcesPlaceholderConfigurer.`postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)` Processing occurs by replacing ${...} placeholders in bean definitions by resolving each against this configurer's set of `PropertySources`, which includes: all environment property sources, if an `Environment` is present merged local properties, if any have been specified any property sources set by calling `PropertySourcesPlaceholderConfigurer.setPropertySources(org.springframework.core.env.PropertySources)`
    `protected void` | PropertySourcesPlaceholderConfigurer.`processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, ConfigurablePropertyResolver propertyResolver)` Visit each bean definition in the given bean factory and attempt to replace ${...} property placeholders with values from the given properties.
    `void` | AbstractApplicationContext.`refresh()`
    `protected 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.
    `protected abstract void` | AbstractApplicationContext.`refreshBeanFactory()` Subclasses must implement this method to perform the actual configuration load.
    `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
    Constructor and Description
    `ClassPathXmlApplicationContext(String... configLocations)` Create a new ClassPathXmlApplicationContext, loading the definitions from the given XML files and automatically refreshing the context.
    `ClassPathXmlApplicationContext(String configLocation)` Create a new ClassPathXmlApplicationContext, loading the definitions from the given XML file 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... configLocations)` Create a new FileSystemXmlApplicationContext, loading the definitions from the given XML files 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, 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
    Modifier and Type | Method and Description
    --- | ---
    `void` | AspectJWeavingEnabler.`postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)`
    `Object` | LoadTimeWeaverAwareProcessor.`postProcessBeforeInitialization(Object bean, String beanName)`

  - ### Uses of BeansException in org.springframework.dao.support

    Methods in org.springframework.dao.support that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `void` | PersistenceExceptionTranslationInterceptor.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeansException in org.springframework.jca.context

    Methods in org.springframework.jca.context that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | ResourceAdapterApplicationContext.`postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)`

  - ### Uses of BeansException in org.springframework.jms.annotation

    Methods in org.springframework.jms.annotation that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `Object` | JmsListenerAnnotationBeanPostProcessor.`postProcessAfterInitialization(Object bean, String beanName)`
    `Object` | JmsListenerAnnotationBeanPostProcessor.`postProcessBeforeInitialization(Object bean, String beanName)`

  - ### Uses of BeansException in org.springframework.jndi.support

    Methods in org.springframework.jndi.support that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `<T> T` | SimpleJndiBeanFactory.`getBean(Class<T> requiredType)`
    `<T> T` | SimpleJndiBeanFactory.`getBean(Class<T> requiredType, Object... args)`
    `Object` | SimpleJndiBeanFactory.`getBean(String name)`
    `<T> T` | SimpleJndiBeanFactory.`getBean(String name, Class<T> requiredType)`
    `Object` | SimpleJndiBeanFactory.`getBean(String name, Object... args)`

  - ### Uses of BeansException in org.springframework.messaging.core

    Methods in org.springframework.messaging.core that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `void` | GenericMessagingTemplate.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeansException in org.springframework.orm.hibernate5

    Methods in org.springframework.orm.hibernate5 that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `Interceptor` | HibernateTransactionManager.`getEntityInterceptor()` Return the current Hibernate entity interceptor, or `null` if none.

  - ### Uses of BeansException in org.springframework.orm.jpa

    Methods in org.springframework.orm.jpa that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `void` | EntityManagerFactoryAccessor.`setBeanFactory(BeanFactory beanFactory)` Retrieves an EntityManagerFactory by persistence unit name, if none set explicitly.
    `void` | JpaTransactionManager.`setBeanFactory(BeanFactory beanFactory)` Retrieves an EntityManagerFactory by persistence unit name, if none set explicitly.

  - ### Uses of BeansException in org.springframework.validation.beanvalidation

    Methods in org.springframework.validation.beanvalidation that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `Object` | BeanValidationPostProcessor.`postProcessAfterInitialization(Object bean, String beanName)`
    `Object` | BeanValidationPostProcessor.`postProcessBeforeInitialization(Object bean, String beanName)`

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

    Methods in org.springframework.web.context.support that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | GroovyWebApplicationContext.`loadBeanDefinitions(DefaultListableBeanFactory beanFactory)` Loads the bean definitions via an GroovyBeanDefinitionReader.
    `protected void` | XmlWebApplicationContext.`loadBeanDefinitions(DefaultListableBeanFactory beanFactory)` Loads the bean definitions via an XmlBeanDefinitionReader.
    `Object` | ServletContextAwareProcessor.`postProcessBeforeInitialization(Object bean, String beanName)`

  - ### Uses of BeansException in org.springframework.web.filter

    Methods in org.springframework.web.filter that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | GenericFilterBean.`initBeanWrapper(BeanWrapper bw)` Initialize the BeanWrapper for this GenericFilterBean, possibly with custom editors.

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

    Subclasses of BeansException in org.springframework.web.method.annotation
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MethodArgumentConversionNotSupportedException` A ConversionNotSupportedException raised while resolving a method argument.
    `class` | `MethodArgumentTypeMismatchException` A TypeMismatchException raised while resolving a controller method argument.

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

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

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

    Methods in org.springframework.web.reactive.resource that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `void` | ResourceUrlProvider.`setApplicationContext(ApplicationContext applicationContext)`

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

    Methods in org.springframework.web.reactive.result.view.freemarker that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected FreeMarkerConfig` | FreeMarkerView.`autodetectConfiguration()` Autodetect a `FreeMarkerConfig` object in the `ApplicationContext`.

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

    Methods in org.springframework.web.reactive.result.view.script that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected ScriptTemplateConfig` | ScriptTemplateView.`autodetectViewConfig()`

  - ### Uses of BeansException in org.springframework.web.servlet

    Methods in org.springframework.web.servlet that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | HttpServletBean.`initBeanWrapper(BeanWrapper bw)` Initialize the BeanWrapper for this HttpServletBean, possibly with custom editors.

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

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

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

    Methods in org.springframework.web.servlet.resource that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `void` | ResourceUrlProvider.`setApplicationContext(ApplicationContext applicationContext)`

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

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

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

    Methods in org.springframework.web.servlet.view.freemarker that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected FreeMarkerConfig` | FreeMarkerView.`autodetectConfiguration()` Autodetect a `FreeMarkerConfig` object via the ApplicationContext.
    `protected void` | FreeMarkerView.`initServletContext(ServletContext servletContext)` Invoked on startup.

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

    Methods in org.springframework.web.servlet.view.groovy that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected groovy.text.markup.MarkupTemplateEngine` | GroovyMarkupView.`autodetectMarkupTemplateEngine()` Autodetect a MarkupTemplateEngine via the ApplicationContext.

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

    Methods in org.springframework.web.servlet.view.script that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected ScriptTemplateConfig` | ScriptTemplateView.`autodetectViewConfig()`

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

    Methods in org.springframework.web.servlet.view.xslt that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | XsltView.`initApplicationContext()` Initialize this XsltView's TransformerFactory.

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

    Methods in org.springframework.web.socket.client.standard that throw BeansException
    Modifier and Type | Method and Description
    --- | ---
    `void` | AnnotatedEndpointConnectionManager.`setBeanFactory(BeanFactory beanFactory)`