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 |
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.parsing |
Support infrastructure for bean definition parsing.
|
org.springframework.beans.factory.support |
Classes supporting the
org.springframework.beans.factory package. |
org.springframework.beans.factory.xml |
Contains an abstract XML-based
BeanFactory implementation,
including a standard "spring-beans" DTD. |
org.springframework.beans.support |
Classes supporting the org.springframework.beans package,
such as utility classes for sorting and holding lists of beans.
|
org.springframework.context |
This package builds on the beans package to add support for
message sources and for the Observer design pattern, and the
ability for application objects to obtain resources using a
consistent API.
|
org.springframework.context.access |
Helper infrastructure to locate and access shared application contexts.
|
org.springframework.context.annotation |
Annotation support for the Application Context, including JSR-250 "common"
annotations, component-scanning, and Java-based metadata for creating
Spring-managed objects.
|
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.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
Hibernate 3.x
with Spring concepts.
|
org.springframework.orm.jpa |
Package providing integration of JPA (Java Persistence API) with Spring concepts.
|
org.springframework.orm.jpa.support |
Classes supporting the
org.springframework.orm.jpa package. |
org.springframework.validation.beanvalidation |
Support classes for integrating a JSR-303 Bean Validation provider
(such as Hibernate Validator 4.0) 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.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.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.
|
Modifier and Type | Method and Description |
---|---|
Object |
ProxyFactoryBean.getObject()
Return a proxy.
|
Modifier and Type | Method and Description |
---|---|
Object |
AdvisorAdapterRegistrationManager.postProcessAfterInitialization(Object bean,
String beanName) |
Object |
AdvisorAdapterRegistrationManager.postProcessBeforeInitialization(Object bean,
String beanName) |
Modifier and Type | Method and Description |
---|---|
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) |
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.
|
Object |
CommonsPoolTargetSource.makeObject() |
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) |
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.
|
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. |
PropertyDescriptor |
BeanWrapperImpl.getPropertyDescriptor(String propertyName) |
protected PropertyDescriptor |
BeanWrapperImpl.getPropertyDescriptorInternal(String propertyName)
Internal version of
BeanWrapperImpl.getPropertyDescriptor(java.lang.String) :
Returns null if not found rather than throwing an exception. |
static PropertyDescriptor[] |
BeanUtils.getPropertyDescriptors(Class<?> clazz)
Retrieve the JavaBeans
PropertyDescriptor s of a given class. |
Class<?> |
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.
|
TypeDescriptor |
DirectFieldAccessor.getPropertyTypeDescriptor(String propertyName) |
TypeDescriptor |
BeanWrapperImpl.getPropertyTypeDescriptor(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.
|
Object |
DirectFieldAccessor.getPropertyValue(String propertyName) |
abstract Object |
AbstractPropertyAccessor.getPropertyValue(String propertyName)
Actually get the value of a property.
|
Object |
BeanWrapperImpl.getPropertyValue(String propertyName) |
Object |
PropertyAccessor.getPropertyValue(String propertyName)
Get the current value of the specified property.
|
boolean |
DirectFieldAccessor.isReadableProperty(String propertyName) |
boolean |
DirectFieldAccessor.isWritableProperty(String propertyName) |
void |
AbstractPropertyAccessor.setPropertyValue(PropertyValue pv) |
void |
BeanWrapperImpl.setPropertyValue(PropertyValue pv) |
void |
PropertyAccessor.setPropertyValue(PropertyValue pv)
Set the specified value as current property value.
|
void |
DirectFieldAccessor.setPropertyValue(String propertyName,
Object newValue) |
abstract void |
AbstractPropertyAccessor.setPropertyValue(String propertyName,
Object value)
Actually set a property value.
|
void |
BeanWrapperImpl.setPropertyValue(String propertyName,
Object 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.
|
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.
|
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.
|
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 whose
Class has the supplied Annotation type. |
T |
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.
|
Constructor and Description |
---|
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.
|
Modifier and Type | Class and Description |
---|---|
class |
BootstrapException
Exception thrown if a bean factory could not be loaded by a bootstrap class.
|
Modifier and Type | Method and Description |
---|---|
static BeanFactoryLocator |
SingletonBeanFactoryLocator.getInstance()
Returns an instance which uses the default "classpath*:beanRefFactory.xml",
as the name of the definition file(s).
|
static BeanFactoryLocator |
SingletonBeanFactoryLocator.getInstance(String selector)
Returns an instance which uses the the specified selector, as the name of the
definition file(s).
|
BeanFactoryReference |
SingletonBeanFactoryLocator.useBeanFactory(String factoryKey) |
BeanFactoryReference |
BeanFactoryLocator.useBeanFactory(String factoryKey)
Use the
BeanFactory (or derived
interface such as ApplicationContext )
specified by the factoryKey parameter. |
Modifier and Type | Method and Description |
---|---|
Constructor<?>[] |
AutowiredAnnotationBeanPostProcessor.determineCandidateConstructors(Class<?> beanClass,
String beanName) |
protected <T> Map<String,T> |
AutowiredAnnotationBeanPostProcessor.findAutowireCandidates(Class<T> type)
Obtain all beans of the given type as autowire candidates.
|
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) |
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) |
Modifier and Type | Method and Description |
---|---|
protected Exception |
ServiceLocatorFactoryBean.createServiceLocatorException(Constructor exceptionConstructor,
BeansException cause)
Create a service locator exception for the given cause.
|
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.
|
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 |
BeanExpressionResolver.evaluate(String value,
BeanExpressionContext evalContext)
Evaluate the given value as an expression, if applicable;
return the value as-is otherwise.
|
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()
Deprecated.
|
Object |
AutowireCapableBeanFactory.initializeBean(Object existingBean,
String beanName)
Initialize the given raw bean, applying factory callbacks
such as
setBeanName and setBeanFactory ,
also applying all bean post processors (including ones which
might wrap the given raw bean). |
Object |
InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInitialization(Object bean,
String beanName) |
Object |
BeanPostProcessor.postProcessAfterInitialization(Object bean,
String beanName)
Apply this BeanPostProcessor to the given new bean instance after any bean
initialization callbacks (like InitializingBean's
afterPropertiesSet
or a custom init-method). |
boolean |
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.
|
boolean |
InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInstantiation(Object bean,
String beanName) |
void |
PropertyResourceConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
|
void |
CustomScopeConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) |
void |
CustomEditorConfigurer.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) |
void |
BeanFactoryPostProcessor.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
Modify the application context's internal bean factory after its standard
initialization.
|
void |
DeprecatedBeanWarner.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
afterPropertiesSet
or a custom init-method). |
Object |
InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(Class<?> beanClass,
String beanName)
Apply this BeanPostProcessor before the target bean gets instantiated.
|
Object |
InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInstantiation(Class<?> beanClass,
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.
|
PropertyValues |
InstantiationAwareBeanPostProcessorAdapter.postProcessPropertyValues(PropertyValues pvs,
PropertyDescriptor[] pds,
Object bean,
String beanName) |
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 |
PropertyOverrideConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory,
Properties props) |
protected abstract void |
PropertyResourceConfigurer.processProperties(ConfigurableListableBeanFactory beanFactory,
Properties props)
Apply the given Properties to the given BeanFactory.
|
protected void |
PropertyPlaceholderConfigurer.processProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
Properties props)
Visit each bean definition in the given bean factory and attempt to replace ${...} property
placeholders with values from the given properties.
|
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<String> autowiredBeanNames,
TypeConverter typeConverter)
Resolve the specified dependency against the beans defined in this factory.
|
void |
ServiceLocatorFactoryBean.setBeanFactory(BeanFactory beanFactory) |
Modifier and Type | Class and Description |
---|---|
class |
BeanDefinitionParsingException
Exception thrown when a bean definition reader encounters an error
during the parsing process.
|
Modifier and Type | Class and Description |
---|---|
class |
BeanDefinitionValidationException
Exception thrown when the validation of a bean definition failed.
|
Modifier and Type | Method and Description |
---|---|
Object |
AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization(Object existingBean,
String beanName) |
Object |
AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(Object existingBean,
String beanName) |
protected Object |
AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass,
String beanName)
Apply InstantiationAwareBeanPostProcessors to the specified bean definition
(by class and name), invoking their
postProcessBeforeInstantiation methods. |
void |
AbstractAutowireCapableBeanFactory.applyBeanPropertyValues(Object existingBean,
String beanName) |
protected void |
AbstractAutowireCapableBeanFactory.applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd,
Class<?> beanType,
String beanName)
Apply MergedBeanDefinitionPostProcessors to the specified bean definition,
invoking their
postProcessMergedBeanDefinition methods. |
Object |
AbstractAutowireCapableBeanFactory.autowire(Class<?> beanClass,
int autowireMode,
boolean dependencyCheck) |
void |
AbstractAutowireCapableBeanFactory.autowireBeanProperties(Object existingBean,
int autowireMode,
boolean dependencyCheck) |
Object |
AbstractAutowireCapableBeanFactory.configureBean(Object existingBean,
String beanName) |
Object |
AbstractAutowireCapableBeanFactory.createBean(Class<?> beanClass,
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.
|
protected Object |
DefaultListableBeanFactory.doResolveDependency(DependencyDescriptor descriptor,
Class<?> type,
String beanName,
Set<String> autowiredBeanNames,
TypeConverter typeConverter) |
<T> T |
StaticListableBeanFactory.getBean(Class<T> requiredType) |
<T> T |
DefaultListableBeanFactory.getBean(Class<T> requiredType) |
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> 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 includeFactoryBeans) |
<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 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.
|
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)
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.
|
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<String> autowiredBeanNames,
TypeConverter typeConverter) |
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. |
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.
|
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.
|
Modifier and Type | Class and Description |
---|---|
class |
ApplicationContextException
Exception thrown during application context initialization.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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 . |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
Object |
StandardBeanExpressionResolver.evaluate(String value,
BeanExpressionContext evalContext) |
Modifier and Type | Method and Description |
---|---|
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. |
protected void |
GenericApplicationContext.cancelRefresh(BeansException ex) |
Modifier and Type | Method and Description |
---|---|
<T> T |
AbstractApplicationContext.getBean(Class<T> requiredType) |
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)
|
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) |
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.
|
Modifier and Type | Method and Description |
---|---|
void |
AspectJWeavingEnabler.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) |
Object |
LoadTimeWeaverAwareProcessor.postProcessBeforeInitialization(Object bean,
String beanName) |
Modifier and Type | Method and Description |
---|---|
void |
PersistenceExceptionTranslationInterceptor.setBeanFactory(BeanFactory beanFactory) |
Modifier and Type | Method and Description |
---|---|
protected void |
AbstractStatefulSessionBean.loadBeanFactory()
Deprecated.
Load a Spring BeanFactory namespace.
|
Modifier and Type | Method and Description |
---|---|
protected void |
ResourceAdapterApplicationContext.postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) |
Modifier and Type | Method and Description |
---|---|
<T> T |
SimpleJndiBeanFactory.getBean(Class<T> requiredType) |
Object |
SimpleJndiBeanFactory.getBean(String name) |
<T> T |
SimpleJndiBeanFactory.getBean(String name,
Class<T> requiredType) |
Object |
SimpleJndiBeanFactory.getBean(String name,
Object... args) |
Modifier and Type | Method and Description |
---|---|
org.hibernate.Interceptor |
HibernateTransactionManager.getEntityInterceptor()
Return the current Hibernate entity interceptor, or
null if none. |
org.hibernate.Interceptor |
HibernateAccessor.getEntityInterceptor()
Return the current Hibernate entity interceptor, or
null if none. |
Modifier and Type | Method and Description |
---|---|
void |
JpaTransactionManager.setBeanFactory(BeanFactory beanFactory)
Retrieves an EntityManagerFactory by persistence unit name, if none set explicitly.
|
void |
EntityManagerFactoryAccessor.setBeanFactory(BeanFactory beanFactory)
Retrieves an EntityManagerFactory by persistence unit name, if none set explicitly.
|
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
Object |
BeanValidationPostProcessor.postProcessAfterInitialization(Object bean,
String beanName) |
Object |
BeanValidationPostProcessor.postProcessBeforeInitialization(Object bean,
String beanName) |
Modifier and Type | Method and Description |
---|---|
protected void |
XmlWebApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
Loads the bean definitions via an XmlBeanDefinitionReader.
|
Object |
ServletContextAwareProcessor.postProcessBeforeInitialization(Object bean,
String beanName) |
Modifier and Type | Method and Description |
---|---|
protected void |
GenericFilterBean.initBeanWrapper(BeanWrapper bw)
Initialize the BeanWrapper for this GenericFilterBean,
possibly with custom editors.
|
Modifier and Type | Method and Description |
---|---|
protected void |
GenericPortletBean.initBeanWrapper(BeanWrapper bw)
Initialize the BeanWrapper for this GenericPortletBean,
possibly with custom editors.
|
Modifier and Type | Method and Description |
---|---|
protected void |
XmlPortletApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
Loads the bean definitions via an XmlBeanDefinitionReader.
|
protected void |
XmlPortletApplicationContext.loadBeanDefinitions(XmlBeanDefinitionReader reader)
Load the bean definitions with the given XmlBeanDefinitionReader.
|
Object |
PortletContextAwareProcessor.postProcessBeforeInitialization(Object bean,
String beanName) |
Modifier and Type | Method and Description |
---|---|
protected void |
AbstractHandlerMapping.initApplicationContext()
Initializes the interceptors.
|
void |
PortletModeHandlerMapping.initApplicationContext()
Calls the
registerHandlers method in addition
to the superclass's initialization. |
void |
PortletModeParameterHandlerMapping.initApplicationContext()
Calls the
registerHandlers method in addition
to the superclass's initialization. |
void |
ParameterHandlerMapping.initApplicationContext()
Calls the
registerHandlers method in addition
to the superclass's initialization. |
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(K lookupKey,
Object handler)
Register the given handler instance for the given parameter value.
|
protected void |
AbstractMapBasedHandlerMapping.registerHandler(K lookupKey,
Object handler,
AbstractMapBasedHandlerMapping.PortletRequestMappingPredicate predicate)
Register the given handler instance for the given parameter value.
|
protected void |
PortletModeParameterHandlerMapping.registerHandler(javax.portlet.PortletMode mode,
String parameter,
Object handler)
Register the given handler instance for the given PortletMode and parameter value,
under an appropriate lookup key.
|
protected void |
AbstractMapBasedHandlerMapping.registerHandlers(Map<K,?> handlerMap)
Register all handlers specified in the Portlet mode map for the corresponding modes.
|
Modifier and Type | Method and Description |
---|---|
protected void |
DefaultAnnotationHandlerMapping.detectHandlers()
Register all handlers specified in the Portlet mode map for the corresponding modes.
|
void |
DefaultAnnotationHandlerMapping.initApplicationContext()
Calls the
registerHandlers method in addition
to the superclass's initialization. |
Modifier and Type | Method and Description |
---|---|
protected void |
HttpServletBean.initBeanWrapper(BeanWrapper bw)
Initialize the BeanWrapper for this HttpServletBean,
possibly with custom editors.
|
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.
|
Modifier and Type | Method and Description |
---|---|
void |
XmlViewResolver.afterPropertiesSet()
Pre-initialize the factory from the XML file.
|
void |
ResourceBundleViewResolver.afterPropertiesSet()
Eagerly initialize Locales if necessary.
|
void |
XmlViewResolver.destroy()
Close the view bean factory on context shutdown.
|
void |
ResourceBundleViewResolver.destroy()
Close the bundle View factories on context shutdown.
|
protected BeanFactory |
XmlViewResolver.initFactory()
Initialize the view bean factory from the XML file.
|
protected BeanFactory |
ResourceBundleViewResolver.initFactory(Locale locale)
|
protected View |
XmlViewResolver.loadView(String viewName,
Locale locale) |
View |
BeanNameViewResolver.resolveViewName(String viewName,
Locale locale) |
Modifier and Type | Method and Description |
---|---|
protected FreeMarkerConfig |
FreeMarkerView.autodetectConfiguration()
Autodetect a
FreeMarkerConfig object via the ApplicationContext. |
protected void |
FreeMarkerView.initServletContext(javax.servlet.ServletContext servletContext)
Invoked on startup.
|
Modifier and Type | Method and Description |
---|---|
protected void |
ComponentControllerSupport.initApplicationContext()
Deprecated.
Subclasses can override this for custom initialization behavior.
|
Modifier and Type | Method and Description |
---|---|
protected org.apache.velocity.app.VelocityEngine |
VelocityView.autodetectVelocityEngine()
Autodetect a VelocityEngine via the ApplicationContext.
|
protected void |
VelocityView.initApplicationContext()
Invoked on startup.
|
Modifier and Type | Method and Description |
---|---|
protected void |
XsltView.initApplicationContext()
Initialize this XsltView's TransformerFactory.
|
Modifier and Type | Method and Description |
---|---|
protected WebApplicationContext |
ContextLoaderPlugIn.createWebApplicationContext(WebApplicationContext parent)
Deprecated.
Instantiate the WebApplicationContext for the ActionServlet, either a default
XmlWebApplicationContext or a custom context class if set.
|
protected org.apache.struts.action.Action |
DelegatingRequestProcessor.getDelegateAction(org.apache.struts.action.ActionMapping mapping)
Deprecated.
Return the delegate
Action for the given mapping. |
protected org.apache.struts.action.Action |
DelegatingTilesRequestProcessor.getDelegateAction(org.apache.struts.action.ActionMapping mapping)
Deprecated.
Return the delegate Action for the given mapping.
|
protected org.apache.struts.action.Action |
DelegatingActionProxy.getDelegateAction(org.apache.struts.action.ActionMapping mapping)
Deprecated.
Return the delegate
Action for the given mapping . |
protected WebApplicationContext |
ContextLoaderPlugIn.initWebApplicationContext()
Deprecated.
Initialize and publish the WebApplicationContext for the ActionServlet.
|
Copyright © 2015. All rights reserved.