Package | Description |
---|---|
org.springframework.aop |
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
|
org.springframework.aop.aspectj |
AspectJ integration package.
|
org.springframework.aop.aspectj.annotation |
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
|
org.springframework.aop.config |
Support package for declarative AOP configuration,
with XML schema being the primary configuration format.
|
org.springframework.aop.framework |
Package containing Spring's basic AOP infrastructure, compliant with the
AOP Alliance interfaces.
|
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.framework.autoproxy.target | |
org.springframework.aop.interceptor |
Provides miscellaneous interceptor implementations.
|
org.springframework.aop.scope |
Support for AOP-based scoping of target objects, with configurable backend.
|
org.springframework.aop.support |
Convenience classes for using Spring's AOP API.
|
org.springframework.aop.support.annotation |
Annotation support for AOP pointcuts.
|
org.springframework.aop.target | |
org.springframework.aop.target.dynamic | |
org.springframework.beans |
This package contains interfaces and classes for manipulating Java beans.
|
org.springframework.beans.annotation |
Support package for beans-style handling of Java 5 annotations.
|
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.serviceloader |
Support package for the Java 6 ServiceLoader facility.
|
org.springframework.beans.factory.support |
Classes supporting the
org.springframework.beans.factory package. |
org.springframework.beans.factory.wiring |
Mechanism to determine bean wiring metadata from a bean instance.
|
org.springframework.beans.factory.xml |
Contains an abstract XML-based
BeanFactory implementation,
including a standard "spring-beans" XSD. |
org.springframework.beans.propertyeditors |
Properties editors used to convert from String values to object
types such as java.util.Properties.
|
org.springframework.beans.support |
Classes supporting the org.springframework.beans package,
such as utility classes for sorting and holding lists of beans.
|
org.springframework.cache |
Spring's generic cache abstraction.
|
org.springframework.cache.annotation |
Annotations and supporting classes for declarative cache management.
|
org.springframework.cache.caffeine |
Support classes for the open source cache in
Caffeine library,
allowing to set up Caffeine caches within Spring's cache abstraction.
|
org.springframework.cache.concurrent |
Implementation package for
java.util.concurrent based caches. |
org.springframework.cache.ehcache |
Support classes for the open source cache
EhCache 2.x,
allowing to set up an EhCache CacheManager and Caches
as beans in a Spring context.
|
org.springframework.cache.interceptor |
AOP-based solution for declarative caching demarcation.
|
org.springframework.cache.jcache |
Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
|
org.springframework.cache.jcache.config |
Support package for declarative JSR-107 caching configuration.
|
org.springframework.cache.jcache.interceptor |
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
|
org.springframework.cache.support |
Support classes for the org.springframework.cache package.
|
org.springframework.cache.transaction |
Transaction-aware decorators for the org.springframework.cache package.
|
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.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.event |
Support classes for application events, like standard context events.
|
org.springframework.context.expression |
Expression parsing support within a Spring application context.
|
org.springframework.context.i18n |
Abstraction for determining the current Locale,
plus global holder that exposes a thread-bound Locale.
|
org.springframework.context.index |
Support package for reading and managing the components index.
|
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.core |
Provides basic classes for exception handling and version detection,
and other core helpers that are not specific to any part of the framework.
|
org.springframework.core.annotation |
Core support package for annotations, meta-annotations, and composed
annotations with attribute overrides.
|
org.springframework.core.codec | |
org.springframework.core.convert |
Type conversion system API.
|
org.springframework.core.convert.converter |
SPI to implement Converters for the type conversion system.
|
org.springframework.core.convert.support |
Default implementation of the type conversion system.
|
org.springframework.core.env |
Spring's environment abstraction consisting of bean definition
profile and hierarchical property source support.
|
org.springframework.core.io |
Generic abstraction for (file-based) resources, used throughout the framework.
|
org.springframework.core.io.buffer |
Generic abstraction for working with byte buffer implementations.
|
org.springframework.core.io.support |
Support classes for Spring's resource abstraction.
|
org.springframework.core.serializer |
Root package for Spring's serializer interfaces and implementations.
|
org.springframework.core.style |
Support for styling values as Strings, with ToStringCreator as central class.
|
org.springframework.core.task |
This package defines Spring's core TaskExecutor abstraction,
and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
|
org.springframework.core.task.support |
Support classes for Spring's TaskExecutor abstraction.
|
org.springframework.core.type |
Core support package for type introspection.
|
org.springframework.core.type.classreading |
Support classes for reading annotation and class-level metadata.
|
org.springframework.core.type.filter |
Core support package for type filtering (e.g.
|
org.springframework.dao |
Exception hierarchy enabling sophisticated error handling independent
of the data access approach in use.
|
org.springframework.dao.support |
Support classes for DAO implementations,
providing miscellaneous utility methods.
|
org.springframework.ejb.access |
This package contains classes that allow easy access to EJBs.
|
org.springframework.expression |
Core abstractions behind the Spring Expression Language.
|
org.springframework.expression.common |
Common utility classes behind the Spring Expression Language.
|
org.springframework.expression.spel |
SpEL's central implementation package.
|
org.springframework.expression.spel.ast |
SpEL's abstract syntax tree.
|
org.springframework.expression.spel.standard |
SpEL's standard parser implementation.
|
org.springframework.expression.spel.support |
SpEL's default implementations for various core abstractions.
|
org.springframework.format.datetime.joda |
Integration with Joda-Time for formatting Joda date and time types as well as standard JDK Date types.
|
org.springframework.format.datetime.standard |
Integration with the JSR-310
java.time package in JDK 8. |
org.springframework.format.support |
Support classes for the formatting package,
providing common implementations as well as adapters.
|
org.springframework.http |
Contains a basic abstraction over client/server-side HTTP.
|
org.springframework.http.client |
Contains an abstraction over client-side HTTP.
|
org.springframework.http.client.reactive |
Abstractions for reactive HTTP client support including
ClientHttpRequest and
ClientHttpResponse as well as a
ClientHttpConnector . |
org.springframework.http.client.support |
This package provides generic HTTP support classes,
to be used by higher-level classes like RestTemplate.
|
org.springframework.http.codec | |
org.springframework.http.codec.json |
JSON encoder and decoder support.
|
org.springframework.http.codec.multipart |
Multipart support.
|
org.springframework.http.codec.xml |
XML encoder and decoder support.
|
org.springframework.http.converter |
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
|
org.springframework.http.converter.json |
Provides HttpMessageConverter implementations for handling JSON.
|
org.springframework.http.converter.protobuf |
Provides an HttpMessageConverter implementation for handling
Google Protocol Buffers.
|
org.springframework.http.converter.xml |
Provides HttpMessageConverter implementations for handling XML.
|
org.springframework.http.server |
Contains an abstraction over server-side HTTP.
|
org.springframework.http.server.reactive |
Abstractions for reactive HTTP server support including a
ServerHttpRequest and
ServerHttpResponse along with an
HttpHandler for processing. |
org.springframework.instrument.classloading |
Support package for load time weaving based on class loaders,
as required by JPA providers (but not JPA-specific).
|
org.springframework.instrument.classloading.glassfish |
Support for class instrumentation on GlassFish.
|
org.springframework.instrument.classloading.jboss |
Support for class instrumentation on JBoss AS 6 and 7.
|
org.springframework.instrument.classloading.tomcat |
Support for class instrumentation on Tomcat.
|
org.springframework.instrument.classloading.weblogic |
Support for class instrumentation on BEA WebLogic 10+.
|
org.springframework.instrument.classloading.websphere |
Support for class instrumentation on IBM WebSphere Application Server 7+.
|
org.springframework.jca.cci.connection |
Provides a utility class for easy ConnectionFactory access,
a PlatformTransactionManager for local CCI transactions,
and various simple ConnectionFactory proxies/adapters.
|
org.springframework.jca.cci.core |
Provides the core JCA CCI support, based on CciTemplate
and its associated callback interfaces.
|
org.springframework.jca.cci.core.support |
Classes supporting the
org.springframework.jca.cci.core package. |
org.springframework.jca.cci.object |
The classes in this package represent EIS operations as threadsafe,
reusable objects.
|
org.springframework.jca.context |
Integration package that allows for deploying a Spring application context
as a JCA 1.7 compliant RAR file.
|
org.springframework.jca.endpoint |
This package provides a facility for generic JCA message endpoint management.
|
org.springframework.jca.support |
Provides generic support classes for JCA usage within Spring,
mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory.
|
org.springframework.jca.work |
Convenience classes for scheduling based on the JCA WorkManager facility,
as supported within ResourceAdapters.
|
org.springframework.jdbc |
The classes in this package make JDBC easier to use and
reduce the likelihood of common errors.
|
org.springframework.jdbc.core |
Provides the core JDBC framework, based on JdbcTemplate
and its associated callback interfaces and helper objects.
|
org.springframework.jdbc.core.metadata |
Context metadata abstraction for the configuration and execution
of table inserts and stored procedure calls.
|
org.springframework.jdbc.core.namedparam |
JdbcTemplate variant with named parameter support.
|
org.springframework.jdbc.core.simple |
Simplification layer for table inserts and stored procedure calls.
|
org.springframework.jdbc.core.support |
Classes supporting the
org.springframework.jdbc.core package. |
org.springframework.jdbc.datasource |
Provides a utility class for easy DataSource access,
a PlatformTransactionManager for a single DataSource,
and various simple DataSource implementations.
|
org.springframework.jdbc.datasource.embedded |
Provides extensible support for creating embedded database instances.
|
org.springframework.jdbc.datasource.init |
Provides extensible support for initializing databases through scripts.
|
org.springframework.jdbc.datasource.lookup |
Provides a strategy for looking up JDBC DataSources by name.
|
org.springframework.jdbc.object |
The classes in this package represent RDBMS queries, updates,
and stored procedures as threadsafe, reusable objects.
|
org.springframework.jdbc.support |
Support classes for the JDBC framework, used by the classes in the
jdbc.core and jdbc.object packages.
|
org.springframework.jdbc.support.lob |
Provides a strategy interface for Large OBject handling,
as well as a customizable default implementation.
|
org.springframework.jdbc.support.rowset |
Provides a convenient holder for disconnected result sets.
|
org.springframework.jdbc.support.xml |
Abstraction for handling fields of SQLXML data type.
|
org.springframework.jms |
This package contains integration classes for JMS,
allowing for Spring-style JMS access.
|
org.springframework.jms.config |
Support package for declarative messaging configuration,
with Java configuration and XML schema support.
|
org.springframework.jms.connection |
Provides a PlatformTransactionManager implementation for a single
JMS ConnectionFactory, and a SingleConnectionFactory adapter.
|
org.springframework.jms.core |
Core package of the JMS support.
|
org.springframework.jms.core.support |
Classes supporting the
org.springframework.jms.core package. |
org.springframework.jms.listener |
This package contains the base message listener container facility.
|
org.springframework.jms.listener.adapter |
Message listener adapter mechanism that delegates to target listener
methods, converting messages to appropriate message content types
(such as String or byte array) that get passed into listener methods.
|
org.springframework.jms.listener.endpoint |
This package provides JCA-based endpoint management for JMS message listeners.
|
org.springframework.jms.remoting |
Remoting classes for transparent Java-to-Java remoting via a JMS provider.
|
org.springframework.jms.support |
This package provides generic JMS support classes,
to be used by higher-level classes like JmsTemplate.
|
org.springframework.jms.support.converter |
Provides a MessageConverter abstraction to convert
between Java objects and JMS messages.
|
org.springframework.jms.support.destination |
Support classes for Spring's JMS framework.
|
org.springframework.jmx.access |
Provides support for accessing remote MBean resources.
|
org.springframework.jmx.export |
This package provides declarative creation and registration of
Spring-managed beans as JMX MBeans.
|
org.springframework.jmx.export.annotation |
Java 5 annotations for MBean exposure.
|
org.springframework.jmx.export.assembler |
Provides a strategy for MBeanInfo assembly.
|
org.springframework.jmx.export.metadata |
Provides generic JMX metadata classes and basic support for reading
JMX metadata in a provider-agnostic manner.
|
org.springframework.jmx.export.naming |
Provides a strategy for ObjectName creation.
|
org.springframework.jmx.support |
Contains support classes for connecting to local and remote
MBeanServer s
and for exposing an MBeanServer to remote clients. |
org.springframework.jndi |
The classes in this package make JNDI easier to use,
facilitating the accessing of configuration stored in JNDI,
and provide useful superclasses for JNDI access classes.
|
org.springframework.jndi.support |
Support classes for JNDI usage,
including a JNDI-based BeanFactory implementation.
|
org.springframework.mail |
Spring's generic mail infrastructure.
|
org.springframework.mail.javamail |
JavaMail support for Spring's mail infrastructure.
|
org.springframework.messaging |
Support for working with messaging APIs and protocols.
|
org.springframework.messaging.converter |
Provides support for message conversion.
|
org.springframework.messaging.core |
Defines interfaces and implementation classes for messaging templates.
|
org.springframework.messaging.handler |
Basic abstractions for working with message handler methods.
|
org.springframework.messaging.handler.annotation.support |
Support classes for working with annotated message-handling methods.
|
org.springframework.messaging.handler.invocation |
Common infrastructure for invoking message handler methods.
|
org.springframework.messaging.simp |
Generic support for Simple Messaging Protocols including protocols such as STOMP.
|
org.springframework.messaging.simp.annotation.support |
Support classes for handling messages from simple messaging protocols
(like STOMP).
|
org.springframework.messaging.simp.broker |
Provides a "simple" message broker implementation along with an abstract base
class and other supporting types such as a registry for subscriptions.
|
org.springframework.messaging.simp.config |
Configuration support for WebSocket messaging using higher level messaging protocols.
|
org.springframework.messaging.simp.stomp |
Generic support for simple messaging protocols (like STOMP).
|
org.springframework.messaging.simp.user |
Support for handling messages to "user" destinations (i.e.
|
org.springframework.messaging.support |
Provides implementations of
Message along with
a MessageBuilder and MessageHeaderAccessor for building and working with messages and
message headers, as well as various MessageChannel
implementations and channel interceptor support. |
org.springframework.messaging.tcp |
Contains abstractions and implementation classes for establishing TCP connections via
TcpOperations ,
handling messages via
TcpConnectionHandler ,
as well as sending messages via
TcpConnection . |
org.springframework.mock.http.server.reactive |
Mock implementations of reactive HTTP server contracts.
|
org.springframework.mock.jndi |
The simplest implementation of the JNDI SPI that could possibly work.
|
org.springframework.mock.web |
A comprehensive set of Servlet API 3.0 mock objects,
targeted at usage with Spring's Web MVC framework.
|
org.springframework.orm |
Root package for Spring's O/R Mapping integration classes.
|
org.springframework.orm.hibernate5 |
Package providing integration of
Hibernate 5.x
with Spring concepts.
|
org.springframework.orm.hibernate5.support |
Classes supporting the
org.springframework.orm.hibernate5 package. |
org.springframework.orm.jpa |
Package providing integration of JPA (Java Persistence API) with Spring concepts.
|
org.springframework.orm.jpa.persistenceunit |
Internal support for managing JPA persistence units.
|
org.springframework.orm.jpa.support |
Classes supporting the
org.springframework.orm.jpa package. |
org.springframework.orm.jpa.vendor |
Support classes for adapting to specific JPA vendors.
|
org.springframework.oxm.castor |
Package providing integration of Castor
within Spring's O/X Mapping support.
|
org.springframework.oxm.jaxb |
Package providing integration of JAXB
with Spring's O/X Mapping support.
|
org.springframework.oxm.jibx |
Package providing integration of JiBX
with Spring's O/X Mapping support.
|
org.springframework.oxm.mime |
Contains (un)marshallers optimized to store binary data in MIME attachments.
|
org.springframework.oxm.support |
Provides generic support classes for using Spring's O/X Mapping integration
within various scenario's.
|
org.springframework.oxm.xstream |
Package providing integration of XStream
with Spring's O/X Mapping support.
|
org.springframework.remoting.caucho |
This package provides remoting classes for Caucho's Hessian protocol:
a proxy factory for accessing Hessian services, and an exporter for
making beans available to Hessian clients.
|
org.springframework.remoting.httpinvoker |
Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
|
org.springframework.remoting.jaxws |
Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC),
as included in Java 6 and Java EE 5.
|
org.springframework.remoting.rmi |
Remoting classes for conventional RMI and transparent remoting via
RMI invokers.
|
org.springframework.remoting.support |
Generic support classes for remoting implementations.
|
org.springframework.scheduling |
General exceptions for Spring's scheduling support,
independent of any specific scheduling system.
|
org.springframework.scheduling.annotation |
Java 5 annotation for asynchronous method execution.
|
org.springframework.scheduling.commonj |
Convenience classes for scheduling based on the CommonJ WorkManager/TimerManager
facility, as supported by IBM WebSphere 6.0+ and BEA WebLogic 9.0+.
|
org.springframework.scheduling.concurrent |
Scheduling convenience classes for the
java.util.concurrent
and javax.enterprise.concurrent packages, allowing to set up a
ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring
context. |
org.springframework.scheduling.config |
Support package for declarative scheduling configuration,
with XML schema being the primary configuration format.
|
org.springframework.scheduling.quartz |
Support classes for the open source scheduler
Quartz,
allowing to set up Quartz Schedulers, JobDetails and
Triggers as beans in a Spring context.
|
org.springframework.scheduling.support |
Generic support classes for scheduling.
|
org.springframework.scripting |
Core interfaces for Spring's scripting support.
|
org.springframework.scripting.bsh |
Package providing integration of
BeanShell
(and BeanShell2)
into Spring's scripting infrastructure.
|
org.springframework.scripting.groovy |
Package providing integration of
Groovy
into Spring's scripting infrastructure.
|
org.springframework.scripting.support |
Support classes for Spring's scripting package.
|
org.springframework.test.annotation |
Support classes for annotation-driven tests.
|
org.springframework.test.context |
This package contains the Spring TestContext Framework which
provides annotation-driven unit and integration testing support that is
agnostic of the actual testing framework in use.
|
org.springframework.test.context.cache |
Support for context caching within the Spring TestContext Framework.
|
org.springframework.test.context.junit.jupiter |
Core support for integrating the Spring TestContext Framework
with the JUnit Jupiter extension model in JUnit 5.
|
org.springframework.test.context.junit4 |
Support classes for integrating the Spring TestContext Framework
with JUnit 4.12 or higher.
|
org.springframework.test.context.junit4.statements |
Custom JUnit
Statements used in the Spring TestContext Framework. |
org.springframework.test.context.support |
Support classes for the Spring TestContext Framework.
|
org.springframework.test.context.testng |
Support classes for ApplicationContext-based and transactional
tests run with TestNG and the Spring TestContext Framework.
|
org.springframework.test.context.transaction |
Transactional support classes for the Spring TestContext Framework.
|
org.springframework.test.context.web |
Web support classes for the Spring TestContext Framework.
|
org.springframework.test.util |
General utility classes for use in unit and integration tests.
|
org.springframework.test.web.client |
Contains client-side REST testing support.
|
org.springframework.test.web.client.match |
Contains built-in
RequestMatcher
implementations. |
org.springframework.test.web.client.response |
Contains built-in
ResponseCreator
implementations. |
org.springframework.test.web.reactive.server |
Support for testing Spring WebFlux server endpoints via
WebTestClient . |
org.springframework.test.web.servlet |
Contains server-side support for testing Spring MVC applications.
|
org.springframework.test.web.servlet.request |
Contains built-in
RequestBuilder
implementations. |
org.springframework.test.web.servlet.result |
Contains built-in
ResultMatcher and ResultHandler implementations. |
org.springframework.test.web.servlet.setup |
Contains built-in
MockMvcBuilder implementations. |
org.springframework.transaction |
Exception hierarchy for Spring's transaction infrastructure,
independent of any specific transaction management system.
|
org.springframework.transaction.annotation |
Spring's support for annotation-based transaction demarcation.
|
org.springframework.transaction.config |
Support package for declarative transaction configuration,
with XML schema being the primary configuration format.
|
org.springframework.transaction.interceptor |
AOP-based solution for declarative transaction demarcation.
|
org.springframework.transaction.jta |
Transaction SPI implementation for JTA.
|
org.springframework.transaction.support |
Support classes for the org.springframework.transaction package.
|
org.springframework.ui |
Generic support for UI layer concepts.
|
org.springframework.ui.context |
Contains classes defining the application context subinterface
for UI applications.
|
org.springframework.ui.context.support |
Classes supporting the org.springframework.ui.context package.
|
org.springframework.ui.freemarker |
Support classes for setting up
FreeMarker
within a Spring application context.
|
org.springframework.util |
Miscellaneous utility classes, such as String manipulation utilities,
a Log4J configurer, and a state holder for paged lists of objects.
|
org.springframework.util.comparator |
Useful generic
java.util.Comparator implementations,
such as an invertible comparator and a compound comparator. |
org.springframework.util.concurrent |
Useful generic
java.util.concurrent.Future extension. |
org.springframework.util.xml |
Miscellaneous utility classes for XML parsing and transformation,
such as error handlers that log warnings via Commons Logging.
|
org.springframework.validation |
Provides data binding and validation functionality,
for usage in business and/or UI layers.
|
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 |
Common, generic interfaces that define minimal boundary points
between Spring's web infrastructure and other framework modules.
|
org.springframework.web.accept |
This package contains classes used to determine the requested the media types in a request.
|
org.springframework.web.bind |
Provides web-specific data binding functionality.
|
org.springframework.web.bind.support |
Support classes for web data binding.
|
org.springframework.web.client |
Core package of the client-side web support.
|
org.springframework.web.context |
Contains a variant of the application context interface for web applications,
and the ContextLoaderListener that bootstraps a root web application context.
|
org.springframework.web.context.request |
Support for generic request context holding, in particular for
scoping of application objects per HTTP request or HTTP session.
|
org.springframework.web.context.request.async |
Support for asynchronous request processing.
|
org.springframework.web.context.support |
Classes supporting the
org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes. |
org.springframework.web.cors |
Support for CORS (Cross-Origin Resource Sharing),
based on a common
CorsProcessor strategy. |
org.springframework.web.cors.reactive |
Reactive support for CORS (Cross-Origin Resource Sharing),
based on a common
CorsProcessor strategy. |
org.springframework.web.filter |
Provides generic filter base classes allowing for bean-style configuration.
|
org.springframework.web.jsf |
Support classes for integrating a JSF web layer with a Spring service layer
which is hosted in a Spring root WebApplicationContext.
|
org.springframework.web.jsf.el |
ELResolvers for integrating a JSF web layer with a Spring service layer
which is hosted in a Spring root WebApplicationContext.
|
org.springframework.web.method |
Common infrastructure for handler method processing, as used by
Spring MVC's
org.springframework.web.servlet.mvc.method package. |
org.springframework.web.method.annotation |
Support classes for annotation-based handler method processing.
|
org.springframework.web.method.support |
Generic support classes for handler method processing.
|
org.springframework.web.multipart |
Multipart resolution framework for handling file uploads.
|
org.springframework.web.multipart.commons |
MultipartResolver implementation for
Apache Commons FileUpload.
|
org.springframework.web.multipart.support |
Support classes for the multipart resolution framework.
|
org.springframework.web.reactive |
Top-level package for the
spring-webflux module that contains
DispatcherHandler , the main entry
point for WebFlux server endpoint processing including key contracts used to
map requests to handlers, invoke them, and process the result. |
org.springframework.web.reactive.config |
Spring WebFlux configuration infrastructure.
|
org.springframework.web.reactive.function |
Provides a foundation for both the reactive client and server subpackages.
|
org.springframework.web.reactive.function.client |
Provides a reactive
WebClient
that builds on top of the
org.springframework.http.client.reactive reactive HTTP adapter layer. |
org.springframework.web.reactive.function.server |
Provides the types that make up Spring's functional web framework.
|
org.springframework.web.reactive.function.server.support |
Classes supporting the
org.springframework.web.reactive.function.server package. |
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 |
Support for various programming model styles including the invocation of
different types of handlers, e.g.
|
org.springframework.web.reactive.result.condition |
RequestCondition
and implementations for matching requests based on different criteria. |
org.springframework.web.reactive.result.method |
Infrastructure for handler method processing.
|
org.springframework.web.reactive.result.method.annotation |
Infrastructure for annotation-based handler method processing.
|
org.springframework.web.reactive.result.view |
Support for result handling through view resolution.
|
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.reactive.socket |
Abstractions and support classes for reactive WebSocket interactions.
|
org.springframework.web.reactive.socket.adapter |
Classes adapting Spring's Reactive WebSocket API to and from WebSocket runtimes.
|
org.springframework.web.reactive.socket.server |
Server support for WebSocket interactions.
|
org.springframework.web.reactive.socket.server.upgrade |
Holds implementations of
RequestUpgradeStrategy . |
org.springframework.web.server |
Core interfaces and classes for Spring's generic, reactive web support.
|
org.springframework.web.server.adapter |
Implementations to adapt to the underlying
org.springframework.http.client.reactive reactive HTTP adapter
and HttpHandler . |
org.springframework.web.server.handler |
Provides common WebHandler implementations and a
WebHandlerDecorator . |
org.springframework.web.server.i18n |
Locale related support classes.
|
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.config |
Defines the XML configuration namespace for Spring MVC.
|
org.springframework.web.servlet.config.annotation |
Annotation-based setup for Spring MVC.
|
org.springframework.web.servlet.handler |
Provides standard HandlerMapping implementations,
including abstract base classes for custom implementations.
|
org.springframework.web.servlet.i18n |
Locale support classes for Spring's web MVC framework.
|
org.springframework.web.servlet.mvc |
Standard controller implementations for the Servlet MVC framework that comes with
Spring.
|
org.springframework.web.servlet.mvc.annotation |
Support package for annotation-based Servlet MVC controllers.
|
org.springframework.web.servlet.mvc.condition |
Common MVC logic for matching incoming requests based on conditions.
|
org.springframework.web.servlet.mvc.method |
Servlet-based infrastructure for handler method processing,
building on the
org.springframework.web.method package. |
org.springframework.web.servlet.mvc.method.annotation |
MVC infrastructure for annotation-based handler method processing, building on the
org.springframework.web.method.annotation package. |
org.springframework.web.servlet.mvc.support |
Support package for MVC controllers.
|
org.springframework.web.servlet.resource |
Support classes for serving static resources.
|
org.springframework.web.servlet.support |
Support classes for Spring's web MVC framework.
|
org.springframework.web.servlet.tags |
This package contains Spring's JSP standard tag library for JSP 2.0+.
|
org.springframework.web.servlet.tags.form |
Spring's form tag library for JSP views in Spring's Web MVC framework.
|
org.springframework.web.servlet.theme |
Theme support classes for Spring's web MVC framework.
|
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.json |
Support classes for providing a View implementation based on JSON serialization.
|
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.tiles3 |
Support classes for the integration of
Tiles 3
(the standalone version of Tiles) as Spring web view technology.
|
org.springframework.web.servlet.view.xml |
Support classes for providing a View implementation based on XML Marshalling.
|
org.springframework.web.servlet.view.xslt |
Support classes for XSLT,
providing a View implementation for XSLT stylesheets.
|
org.springframework.web.socket |
Common abstractions and Spring configuration support for WebSocket applications.
|
org.springframework.web.socket.adapter |
Classes adapting Spring's WebSocket API to and from WebSocket providers.
|
org.springframework.web.socket.adapter.jetty |
Adapter classes for the Jetty WebSocket API.
|
org.springframework.web.socket.adapter.standard |
Adapter classes for the standard Java WebSocket API.
|
org.springframework.web.socket.client |
Client-side abstractions for WebSocket applications.
|
org.springframework.web.socket.client.jetty |
Client-side support for the Jetty WebSocket API.
|
org.springframework.web.socket.client.standard |
Client-side classes for use with standard Java WebSocket endpoints.
|
org.springframework.web.socket.config.annotation |
Support for annotation-based WebSocket setup in configuration classes.
|
org.springframework.web.socket.handler |
Convenient
WebSocketHandler
implementations and decorators. |
org.springframework.web.socket.messaging |
WebSocket integration for Spring's messaging module.
|
org.springframework.web.socket.server |
Server-side abstractions for WebSocket interactions.
|
org.springframework.web.socket.server.jetty |
Server-side support for the Jetty 9+ WebSocket API.
|
org.springframework.web.socket.server.standard |
Server-side classes for use with standard JSR-356 WebSocket endpoints.
|
org.springframework.web.socket.server.support |
Server-side support classes including container-specific strategies
for upgrading a request.
|
org.springframework.web.socket.sockjs |
Top-level SockJS types.
|
org.springframework.web.socket.sockjs.client |
SockJS client implementation of
WebSocketClient . |
org.springframework.web.socket.sockjs.frame |
Support classes for creating SockJS frames including the encoding and decoding
of SockJS message frames.
|
org.springframework.web.socket.sockjs.support |
Support classes for SockJS including an
AbstractSockJsService
implementation. |
org.springframework.web.socket.sockjs.transport |
Server-side support for SockJS transports including
TransportHandler implementations
for processing incoming requests, their
session
counterparts for sending messages over the various transports, and
DefaultSockJsService . |
org.springframework.web.socket.sockjs.transport.handler |
TransportHandler
implementation classes as well as a concrete
SockJsService . |
org.springframework.web.socket.sockjs.transport.session |
SockJS specific implementations of
WebSocketSession . |
org.springframework.web.util |
Miscellaneous web utility classes, such as HTML escaping,
Log4j initialization, and cookie handling.
|
org.springframework.web.util.pattern |
Dedicated support for matching HTTP request paths.
|
Modifier and Type | Method and Description |
---|---|
Object |
TargetSource.getTarget()
Return a target instance.
|
Class<?> |
TargetSource.getTargetClass()
Return the type of targets returned by this
TargetSource . |
Class<?> |
TargetClassAware.getTargetClass()
Return the target class behind the implementing object
(typically a proxy configuration or an actual proxy).
|
Object |
ProxyMethodInvocation.getUserAttribute(String key)
Return the value of the specified user attribute.
|
Modifier and Type | Method and Description |
---|---|
void |
AfterReturningAdvice.afterReturning(Object returnValue,
Method method,
Object[] args,
Object target)
Callback after a given method successfully returned.
|
void |
AfterReturningAdvice.afterReturning(Object returnValue,
Method method,
Object[] args,
Object target)
Callback after a given method successfully returned.
|
void |
MethodBeforeAdvice.before(Method method,
Object[] args,
Object target)
Callback before a given method is invoked.
|
boolean |
MethodMatcher.matches(Method method,
Class<?> targetClass)
Perform static checking whether the given method matches.
|
boolean |
IntroductionAwareMethodMatcher.matches(Method method,
Class<?> targetClass,
boolean hasIntroductions)
Perform static checking whether the given method matches.
|
boolean |
MethodMatcher.matches(Method method,
Class<?> targetClass,
Object... args)
Check whether there a runtime (dynamic) match for this method,
which must have matched statically.
|
void |
ProxyMethodInvocation.setUserAttribute(String key,
Object value)
Add the specified user attribute with the given value to this invocation.
|
Modifier and Type | Method and Description |
---|---|
ClassLoader |
AspectInstanceFactory.getAspectClassLoader()
Expose the aspect class loader that this factory uses.
|
ClassLoader |
SimpleAspectInstanceFactory.getAspectClassLoader() |
ClassLoader |
SingletonAspectInstanceFactory.getAspectClassLoader() |
ClassLoader |
AbstractAspectJAdvice.getAspectClassLoader()
Return the ClassLoader for aspect instances.
|
static AspectJPrecedenceInformation |
AspectJAopUtils.getAspectJPrecedenceInformationFor(Advisor anAdvisor)
Return the AspectJPrecedenceInformation provided by this advisor or its advice.
|
protected String |
AspectJExpressionPointcut.getCurrentProxiedBeanName() |
protected Type |
AbstractAspectJAdvice.getDiscoveredReturningGenericType() |
String |
AspectJExpressionPointcutAdvisor.getExpression() |
protected org.aspectj.weaver.tools.JoinPointMatch |
AbstractAspectJAdvice.getJoinPointMatch()
Get the current join point match at the join point we are being dispatched on.
|
protected org.aspectj.weaver.tools.JoinPointMatch |
AbstractAspectJAdvice.getJoinPointMatch(ProxyMethodInvocation pmi) |
String |
AspectJExpressionPointcutAdvisor.getLocation() |
String[] |
AspectJAdviceParameterNameDiscoverer.getParameterNames(Constructor<?> ctor)
An advice method can never be a constructor in Spring.
|
String[] |
AspectJAdviceParameterNameDiscoverer.getParameterNames(Method method)
Deduce the parameter names for an advice method.
|
Object |
MethodInvocationProceedingJoinPoint.getTarget()
Returns the Spring AOP target.
|
Modifier and Type | Method and Description |
---|---|
void |
AspectJAfterReturningAdvice.afterReturning(Object returnValue,
Method method,
Object[] args,
Object target) |
void |
AspectJAfterReturningAdvice.afterReturning(Object returnValue,
Method method,
Object[] args,
Object target) |
protected Object[] |
AbstractAspectJAdvice.argBinding(org.aspectj.lang.JoinPoint jp,
org.aspectj.weaver.tools.JoinPointMatch jpMatch,
Object returnValue,
Throwable ex)
Take the arguments at the method execution join point and output a set of arguments
to the advice method
|
protected Object[] |
AbstractAspectJAdvice.argBinding(org.aspectj.lang.JoinPoint jp,
org.aspectj.weaver.tools.JoinPointMatch jpMatch,
Object returnValue,
Throwable ex)
Take the arguments at the method execution join point and output a set of arguments
to the advice method
|
protected Object[] |
AbstractAspectJAdvice.argBinding(org.aspectj.lang.JoinPoint jp,
org.aspectj.weaver.tools.JoinPointMatch jpMatch,
Object returnValue,
Throwable ex)
Take the arguments at the method execution join point and output a set of arguments
to the advice method
|
void |
AspectJMethodBeforeAdvice.before(Method method,
Object[] args,
Object target) |
protected Object |
AbstractAspectJAdvice.invokeAdviceMethod(org.aspectj.lang.JoinPoint jp,
org.aspectj.weaver.tools.JoinPointMatch jpMatch,
Object returnValue,
Throwable t) |
protected Object |
AbstractAspectJAdvice.invokeAdviceMethod(org.aspectj.lang.JoinPoint jp,
org.aspectj.weaver.tools.JoinPointMatch jpMatch,
Object returnValue,
Throwable t) |
protected Object |
AbstractAspectJAdvice.invokeAdviceMethod(org.aspectj.lang.JoinPoint jp,
org.aspectj.weaver.tools.JoinPointMatch jpMatch,
Object returnValue,
Throwable t) |
protected Object |
AbstractAspectJAdvice.invokeAdviceMethod(org.aspectj.weaver.tools.JoinPointMatch jpMatch,
Object returnValue,
Throwable ex)
Invoke the advice method.
|
protected Object |
AbstractAspectJAdvice.invokeAdviceMethod(org.aspectj.weaver.tools.JoinPointMatch jpMatch,
Object returnValue,
Throwable ex)
Invoke the advice method.
|
protected Object |
AbstractAspectJAdvice.invokeAdviceMethod(org.aspectj.weaver.tools.JoinPointMatch jpMatch,
Object returnValue,
Throwable ex)
Invoke the advice method.
|
boolean |
AspectJExpressionPointcut.matches(Method method,
Class<?> targetClass) |
boolean |
AspectJExpressionPointcut.matches(Method method,
Class<?> targetClass,
boolean hasIntroductions) |
boolean |
AspectJExpressionPointcut.matches(Method method,
Class<?> targetClass,
Object... args) |
void |
AspectJExpressionPointcutAdvisor.setExpression(String expression) |
void |
AspectJExpressionPointcutAdvisor.setLocation(String location) |
void |
AspectJAdviceParameterNameDiscoverer.setReturningName(String returningName)
If
afterReturning advice binds the return value, the
returning variable name must be specified. |
void |
AspectJAdviceParameterNameDiscoverer.setThrowingName(String throwingName)
If
afterThrowing advice binds the thrown value, the
throwing variable name must be specified. |
Constructor and Description |
---|
AspectJAdviceParameterNameDiscoverer(String pointcutExpression)
Create a new discoverer that attempts to discover parameter names
from the given pointcut expression.
|
Modifier and Type | Method and Description |
---|---|
protected static AbstractAspectJAdvisorFactory.AspectJAnnotation<?> |
AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(Method method)
Find and return the first AspectJ annotation on the given method
(there should only be one anyway...).
|
Advice |
AspectJAdvisorFactory.getAdvice(Method candidateAdviceMethod,
AspectJExpressionPointcut expressionPointcut,
MetadataAwareAspectInstanceFactory aspectInstanceFactory,
int declarationOrder,
String aspectName)
Build a Spring AOP Advice for the given AspectJ advice method.
|
Advice |
ReflectiveAspectJAdvisorFactory.getAdvice(Method candidateAdviceMethod,
AspectJExpressionPointcut expressionPointcut,
MetadataAwareAspectInstanceFactory aspectInstanceFactory,
int declarationOrder,
String aspectName) |
Advisor |
AspectJAdvisorFactory.getAdvisor(Method candidateAdviceMethod,
MetadataAwareAspectInstanceFactory aspectInstanceFactory,
int declarationOrder,
String aspectName)
Build a Spring AOP Advisor for the given AspectJ advice method.
|
Advisor |
ReflectiveAspectJAdvisorFactory.getAdvisor(Method candidateAdviceMethod,
MetadataAwareAspectInstanceFactory aspectInstanceFactory,
int declarationOrderInAspect,
String aspectName) |
ClassLoader |
LazySingletonAspectInstanceFactoryDecorator.getAspectClassLoader() |
ClassLoader |
BeanFactoryAspectInstanceFactory.getAspectClassLoader() |
Object |
MetadataAwareAspectInstanceFactory.getAspectCreationMutex()
Return the best possible creation mutex for this factory.
|
Object |
LazySingletonAspectInstanceFactoryDecorator.getAspectCreationMutex() |
Object |
BeanFactoryAspectInstanceFactory.getAspectCreationMutex() |
Constructor and Description |
---|
BeanFactoryAspectInstanceFactory(BeanFactory beanFactory,
String name,
Class<?> type)
Create a BeanFactoryAspectInstanceFactory, providing a type that AspectJ should
introspect to create AJType metadata.
|
ReflectiveAspectJAdvisorFactory(BeanFactory beanFactory)
Create a new
ReflectiveAspectJAdvisorFactory , propagating the given
BeanFactory to the created AspectJExpressionPointcut instances,
for bean pointcut handling as well as consistent ClassLoader resolution. |
Modifier and Type | Method and Description |
---|---|
static BeanDefinition |
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
Object source) |
static BeanDefinition |
AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
Object source) |
static BeanDefinition |
AopConfigUtils.registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
Object source) |
Constructor and Description |
---|
AdvisorComponentDefinition(String advisorBeanName,
BeanDefinition advisorDefinition,
BeanDefinition pointcutDefinition) |
AspectComponentDefinition(String aspectName,
BeanDefinition[] beanDefinitions,
BeanReference[] beanReferences,
Object source) |
AspectComponentDefinition(String aspectName,
BeanDefinition[] beanDefinitions,
BeanReference[] beanReferences,
Object source) |
AspectComponentDefinition(String aspectName,
BeanDefinition[] beanDefinitions,
BeanReference[] beanReferences,
Object source) |
Modifier and Type | Field and Description |
---|---|
protected Advisor |
AbstractAdvisingBeanPostProcessor.advisor |
protected Object |
ReflectiveMethodInvocation.target |
Modifier and Type | Method and Description |
---|---|
Object |
ProxyFactoryBean.getObject()
Return a proxy.
|
Class<?> |
AbstractSingletonProxyFactoryBean.getObjectType() |
protected ClassLoader |
ProxyProcessorSupport.getProxyClassLoader()
Return the configured proxy ClassLoader for this processor.
|
static Object |
AopProxyUtils.getSingletonTarget(Object candidate)
Obtain the singleton target object behind the given proxy, if any.
|
Class<?> |
AdvisedSupport.getTargetClass() |
Object |
ReflectiveMethodInvocation.getThis() |
Object |
ReflectiveMethodInvocation.getUserAttribute(String key) |
protected Object |
ReflectiveMethodInvocation.invokeJoinpoint()
Invoke the joinpoint using reflection.
|
Object |
ReflectiveMethodInvocation.proceed() |
Modifier and Type | Method and Description |
---|---|
boolean |
AdvisedSupport.adviceIncluded(Advice advice)
Is the given advice included in any advisor within this proxy configuration?
|
int |
AdvisedSupport.countAdvicesOfType(Class<?> adviceClass)
Count advices of the given class.
|
List<Object> |
DefaultAdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(Advised config,
Method method,
Class<?> targetClass) |
List<Object> |
AdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(Advised config,
Method method,
Class<?> targetClass)
Determine a list of
MethodInterceptor objects
for the given advisor chain configuration. |
List<Object> |
AdvisedSupport.getInterceptorsAndDynamicInterceptionAdvice(Method method,
Class<?> targetClass)
Determine a list of
MethodInterceptor objects
for the given method, based on this configuration. |
Object |
ProxyFactory.getProxy(ClassLoader classLoader)
Create a new proxy according to the settings in this factory.
|
Object |
AopProxy.getProxy(ClassLoader classLoader)
Create a new proxy object.
|
void |
ProxyProcessorSupport.setProxyClassLoader(ClassLoader classLoader)
Set the ClassLoader to generate the proxy class in.
|
void |
ProxyFactoryBean.setProxyClassLoader(ClassLoader classLoader)
Set the ClassLoader to generate the proxy class in.
|
void |
AdvisedSupport.setTargetClass(Class<?> targetClass)
Set a target class to be proxied, indicating that the proxy
should be castable to the given class.
|
void |
AdvisedSupport.setTargetSource(TargetSource targetSource) |
void |
ReflectiveMethodInvocation.setUserAttribute(String key,
Object value) |
Constructor and Description |
---|
ReflectiveMethodInvocation(Object proxy,
Object target,
Method method,
Object[] arguments,
Class<?> targetClass,
List<Object> interceptorsAndDynamicMethodMatchers)
Construct a new ReflectiveMethodInvocation with the given arguments.
|
ReflectiveMethodInvocation(Object proxy,
Object target,
Method method,
Object[] arguments,
Class<?> targetClass,
List<Object> interceptorsAndDynamicMethodMatchers)
Construct a new ReflectiveMethodInvocation with the given arguments.
|
ReflectiveMethodInvocation(Object proxy,
Object target,
Method method,
Object[] arguments,
Class<?> targetClass,
List<Object> interceptorsAndDynamicMethodMatchers)
Construct a new ReflectiveMethodInvocation with the given arguments.
|
Modifier and Type | Field and Description |
---|---|
protected static Object[] |
AbstractAutoProxyCreator.DO_NOT_PROXY
Convenience constant for subclasses: Return value for "do not proxy".
|
Modifier and Type | Method and Description |
---|---|
Constructor<?>[] |
AbstractAutoProxyCreator.determineCandidateConstructors(Class<?> beanClass,
String beanName) |
static Class<?> |
AutoProxyUtils.determineTargetClass(ConfigurableListableBeanFactory beanFactory,
String beanName)
Determine the original target class for the specified bean, if possible,
otherwise falling back to a regular
getType lookup. |
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.
|
protected Object[] |
BeanNameAutoProxyCreator.getAdvicesAndAdvisorsForBean(Class<?> beanClass,
String beanName,
TargetSource targetSource)
Identify as bean to proxy if the bean name is in the configured list of names.
|
protected Object[] |
AbstractAdvisorAutoProxyCreator.getAdvicesAndAdvisorsForBean(Class<?> beanClass,
String beanName,
TargetSource targetSource) |
String |
DefaultAdvisorAutoProxyCreator.getAdvisorBeanNamePrefix()
Return the prefix for bean names that will cause them to be included
for auto-proxying by this object.
|
protected BeanFactory |
AbstractAutoProxyCreator.getBeanFactory()
Return the owning
BeanFactory . |
static String |
ProxyCreationContext.getCurrentProxiedBeanName()
Return the name of the currently proxied bean instance.
|
protected TargetSource |
AbstractAutoProxyCreator.getCustomTargetSource(Class<?> beanClass,
String beanName)
Create a target source for bean instances.
|
TargetSource |
TargetSourceCreator.getTargetSource(Class<?> beanClass,
String beanName)
Create a special TargetSource for the given bean, if any.
|
Class<?> |
AbstractAutoProxyCreator.predictBeanType(Class<?> beanClass,
String beanName) |
Modifier and Type | Method and Description |
---|---|
protected Advisor[] |
AbstractAutoProxyCreator.buildAdvisors(String beanName,
Object[] specificInterceptors)
Determine the advisors for the given bean, including the specific interceptors
as well as the common interceptor, all adapted to the Advisor interface.
|
protected Advisor[] |
AbstractAutoProxyCreator.buildAdvisors(String beanName,
Object[] specificInterceptors)
Determine the advisors for the given bean, including the specific interceptors
as well as the common interceptor, all adapted to the Advisor interface.
|
protected Object |
AbstractAutoProxyCreator.createProxy(Class<?> beanClass,
String beanName,
Object[] specificInterceptors,
TargetSource targetSource)
Create an AOP proxy for the given bean.
|
protected Object |
AbstractAutoProxyCreator.createProxy(Class<?> beanClass,
String beanName,
Object[] specificInterceptors,
TargetSource targetSource)
Create an AOP proxy for the given bean.
|
static Class<?> |
AutoProxyUtils.determineTargetClass(ConfigurableListableBeanFactory beanFactory,
String beanName)
Determine the original target class for the specified bean, if possible,
otherwise falling back to a regular
getType lookup. |
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.
|
protected Object[] |
BeanNameAutoProxyCreator.getAdvicesAndAdvisorsForBean(Class<?> beanClass,
String beanName,
TargetSource targetSource)
Identify as bean to proxy if the bean name is in the configured list of names.
|
protected Object[] |
AbstractAdvisorAutoProxyCreator.getAdvicesAndAdvisorsForBean(Class<?> beanClass,
String beanName,
TargetSource targetSource) |
protected Object |
AbstractAutoProxyCreator.getCacheKey(Class<?> beanClass,
String beanName)
Build a cache key for the given bean class and bean name.
|
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.
|
void |
DefaultAdvisorAutoProxyCreator.setAdvisorBeanNamePrefix(String advisorBeanNamePrefix)
Set the prefix for bean names that will cause them to be included for
auto-proxying by this object.
|
protected boolean |
AbstractAutoProxyCreator.shouldProxyTargetClass(Class<?> beanClass,
String beanName)
Determine whether the given bean should be proxied with its target class rather than its interfaces.
|
static boolean |
AutoProxyUtils.shouldProxyTargetClass(ConfigurableListableBeanFactory beanFactory,
String beanName)
Determine whether the given bean should be proxied with its target
class rather than its interfaces.
|
Modifier and Type | Method and Description |
---|---|
protected abstract AbstractBeanFactoryBasedTargetSource |
AbstractBeanFactoryBasedTargetSourceCreator.createBeanFactoryBasedTargetSource(Class<?> beanClass,
String beanName)
Subclasses must implement this method to return a new AbstractPrototypeBasedTargetSource
if they wish to create a custom TargetSource for this bean, or
null if they are
not interested it in, in which case no special target source will be created. |
protected AbstractBeanFactoryBasedTargetSource |
QuickTargetSourceCreator.createBeanFactoryBasedTargetSource(Class<?> beanClass,
String beanName) |
protected AbstractBeanFactoryBasedTargetSource |
LazyInitTargetSourceCreator.createBeanFactoryBasedTargetSource(Class<?> beanClass,
String beanName) |
TargetSource |
AbstractBeanFactoryBasedTargetSourceCreator.getTargetSource(Class<?> beanClass,
String beanName) |
Modifier and Type | Field and Description |
---|---|
protected Log |
AbstractTraceInterceptor.defaultLogger
The default
Log instance used to write trace messages. |
Modifier and Type | Method and Description |
---|---|
protected AsyncTaskExecutor |
AsyncExecutionAspectSupport.determineAsyncExecutor(Method method)
Determine the specific executor to use when executing the given method.
|
protected Object |
AsyncExecutionAspectSupport.doSubmit(Callable<Object> task,
AsyncTaskExecutor executor,
Class<?> returnType)
Delegate for actually executing the given task with the chosen executor.
|
protected Executor |
AsyncExecutionAspectSupport.findQualifiedExecutor(BeanFactory beanFactory,
String qualifier)
Retrieve a target executor for the given qualifier.
|
protected Executor |
AsyncExecutionAspectSupport.getDefaultExecutor(BeanFactory beanFactory)
Retrieve or build a default executor for this advice instance.
|
protected Executor |
AsyncExecutionInterceptor.getDefaultExecutor(BeanFactory beanFactory)
This implementation searches for a unique
TaskExecutor
bean in the context, or for an Executor bean named "taskExecutor" otherwise. |
protected abstract String |
AsyncExecutionAspectSupport.getExecutorQualifier(Method method)
Return the qualifier or bean name of the executor to be used when executing the
given async method, typically specified in the form of an annotation attribute.
|
protected String |
AsyncExecutionInterceptor.getExecutorQualifier(Method method)
This implementation is a no-op for compatibility in Spring 3.1.2.
|
Object |
AbstractTraceInterceptor.invoke(MethodInvocation invocation)
Determines whether or not logging is enabled for the particular
MethodInvocation . |
Object |
AsyncExecutionInterceptor.invoke(MethodInvocation invocation)
Intercept the given method invocation, submit the actual calling of the method to
the correct task executor and return immediately to the caller.
|
protected abstract Object |
AbstractTraceInterceptor.invokeUnderTrace(MethodInvocation invocation,
Log logger)
Subclasses must override this method to perform any tracing around the
supplied
MethodInvocation . |
Modifier and Type | Method and Description |
---|---|
protected Executor |
AsyncExecutionAspectSupport.findQualifiedExecutor(BeanFactory beanFactory,
String qualifier)
Retrieve a target executor for the given qualifier.
|
protected Executor |
AsyncExecutionAspectSupport.getDefaultExecutor(BeanFactory beanFactory)
Retrieve or build a default executor for this advice instance.
|
protected Executor |
AsyncExecutionInterceptor.getDefaultExecutor(BeanFactory beanFactory)
This implementation searches for a unique
TaskExecutor
bean in the context, or for an Executor bean named "taskExecutor" otherwise. |
protected String |
CustomizableTraceInterceptor.replacePlaceholders(String message,
MethodInvocation methodInvocation,
Object returnValue,
Throwable throwable,
long invocationTime)
Replace the placeholders in the given message with the supplied values,
or values derived from those supplied.
|
protected String |
CustomizableTraceInterceptor.replacePlaceholders(String message,
MethodInvocation methodInvocation,
Object returnValue,
Throwable throwable,
long invocationTime)
Replace the placeholders in the given message with the supplied values,
or values derived from those supplied.
|
void |
AbstractMonitoringInterceptor.setPrefix(String prefix)
Set the text that will get appended to the trace data.
|
void |
AbstractMonitoringInterceptor.setSuffix(String suffix)
Set the text that will get prepended to the trace data.
|
protected void |
AbstractTraceInterceptor.writeToLog(Log logger,
String message,
Throwable ex)
Write the supplied trace message and
Throwable to the
supplied Log instance. |
Constructor and Description |
---|
AsyncExecutionAspectSupport(Executor defaultExecutor)
Create a new instance with a default
AsyncUncaughtExceptionHandler . |
AsyncExecutionAspectSupport(Executor defaultExecutor,
AsyncUncaughtExceptionHandler exceptionHandler)
Create a new
AsyncExecutionAspectSupport with the given exception handler. |
AsyncExecutionInterceptor(Executor defaultExecutor)
Create a new instance with a default
AsyncUncaughtExceptionHandler . |
AsyncExecutionInterceptor(Executor defaultExecutor,
AsyncUncaughtExceptionHandler exceptionHandler)
Create a new
AsyncExecutionInterceptor . |
Modifier and Type | Method and Description |
---|---|
static boolean |
ScopedProxyUtils.isScopedTarget(String beanName)
Specify if the
beanName is the name of a bean that references the target
bean within a scoped proxy. |
Modifier and Type | Method and Description |
---|---|
String |
AbstractBeanFactoryPointcutAdvisor.getAdviceBeanName()
Return the name of the advice bean that this advisor refers to, if any.
|
String |
ExpressionPointcut.getExpression()
Return the String expression for this pointcut.
|
String |
AbstractExpressionPointcut.getExpression()
Return this pointcut's expression.
|
String |
AbstractExpressionPointcut.getLocation()
Return location information about the pointcut expression
if available.
|
Object |
DelegatingIntroductionInterceptor.invoke(MethodInvocation mi)
Subclasses may need to override this if they want to perform custom
behaviour in around advice.
|
Object |
DelegatePerTargetObjectIntroductionInterceptor.invoke(MethodInvocation mi)
Subclasses may need to override this if they want to perform custom
behaviour in around advice.
|
static Object |
AopUtils.invokeJoinpointUsingReflection(Object target,
Method method,
Object[] args)
Invoke the given target via reflection, as part of an AOP method invocation.
|
Modifier and Type | Method and Description |
---|---|
static Method |
AopUtils.getMostSpecificMethod(Method method,
Class<?> targetClass)
Given a method, which may come from an interface, and a target class used
in the current AOP invocation, find the corresponding target method if there
is one.
|
static Object |
AopUtils.invokeJoinpointUsingReflection(Object target,
Method method,
Object[] args)
Invoke the given target via reflection, as part of an AOP method invocation.
|
static boolean |
AopUtils.isAopProxy(Object object)
Check whether the given object is a JDK dynamic proxy or a CGLIB proxy.
|
static boolean |
AopUtils.isCglibProxy(Object object)
Check whether the given object is a CGLIB proxy.
|
static boolean |
AopUtils.isEqualsMethod(Method method)
Determine whether the given method is an "equals" method.
|
static boolean |
AopUtils.isFinalizeMethod(Method method)
Determine whether the given method is a "finalize" method.
|
static boolean |
AopUtils.isHashCodeMethod(Method method)
Determine whether the given method is a "hashCode" method.
|
static boolean |
AopUtils.isJdkDynamicProxy(Object object)
Check whether the given object is a JDK dynamic proxy.
|
static boolean |
AopUtils.isToStringMethod(Method method)
Determine whether the given method is a "toString" method.
|
boolean |
AbstractRegexpMethodPointcut.matches(Method method,
Class<?> targetClass)
Try to match the regular expression against the fully qualified name
of the target class as well as against the method's declaring class,
plus the name of the method.
|
boolean |
ControlFlowPointcut.matches(Method method,
Class<?> targetClass)
Subclasses can override this if it's possible to filter out
some candidate classes.
|
boolean |
NameMatchMethodPointcut.matches(Method method,
Class<?> targetClass) |
boolean |
DynamicMethodMatcher.matches(Method method,
Class<?> targetClass)
Can override to add preconditions for dynamic matching.
|
boolean |
ControlFlowPointcut.matches(Method method,
Class<?> targetClass,
Object... args) |
boolean |
StaticMethodMatcher.matches(Method method,
Class<?> targetClass,
Object... args) |
static boolean |
MethodMatchers.matches(MethodMatcher mm,
Method method,
Class<?> targetClass,
boolean hasIntroductions)
Apply the given MethodMatcher to the given Method, supporting an
IntroductionAwareMethodMatcher
(if applicable). |
protected void |
AbstractExpressionPointcut.onSetExpression(String expression)
Called when a new pointcut expression is set.
|
static Method |
AopUtils.selectInvocableMethod(Method method,
Class<?> targetType)
Select an invocable method on the target type: either the given method itself
if actually exposed on the target type, or otherwise a corresponding method
on one of the target type's interfaces or on the target type itself.
|
void |
AbstractBeanFactoryPointcutAdvisor.setAdviceBeanName(String adviceBeanName)
Specify the name of the advice bean that this advisor should refer to.
|
void |
AbstractExpressionPointcut.setExpression(String expression) |
void |
AbstractExpressionPointcut.setLocation(String location)
Set the location for debugging.
|
void |
DefaultPointcutAdvisor.setPointcut(Pointcut pointcut)
Specify the pointcut targeting the advice.
|
void |
DefaultBeanFactoryPointcutAdvisor.setPointcut(Pointcut pointcut)
Specify the pointcut targeting the advice.
|
Constructor and Description |
---|
ControlFlowPointcut(Class<?> clazz,
String methodName)
Construct a new pointcut that matches all calls below the given method
in the given class.
|
DefaultIntroductionAdvisor(Advice advice,
IntroductionInfo introductionInfo)
Create a DefaultIntroductionAdvisor for the given advice.
|
Modifier and Type | Method and Description |
---|---|
boolean |
AnnotationMethodMatcher.matches(Method method,
Class<?> targetClass) |
Constructor and Description |
---|
AnnotationMatchingPointcut(Class<? extends Annotation> classAnnotationType,
Class<? extends Annotation> methodAnnotationType)
Create a new AnnotationMatchingPointcut for the given annotation types.
|
AnnotationMatchingPointcut(Class<? extends Annotation> classAnnotationType,
Class<? extends Annotation> methodAnnotationType)
Create a new AnnotationMatchingPointcut for the given annotation types.
|
AnnotationMatchingPointcut(Class<? extends Annotation> classAnnotationType,
Class<? extends Annotation> methodAnnotationType,
boolean checkInherited)
Create a new AnnotationMatchingPointcut for the given annotation types.
|
AnnotationMatchingPointcut(Class<? extends Annotation> classAnnotationType,
Class<? extends Annotation> methodAnnotationType,
boolean checkInherited)
Create a new AnnotationMatchingPointcut for the given annotation types.
|
Modifier and Type | Method and Description |
---|---|
Object |
LazyInitTargetSource.getTarget() |
Object |
EmptyTargetSource.getTarget()
Always returns
null . |
abstract Object |
AbstractPoolingTargetSource.getTarget()
Acquire an object from the pool.
|
Class<?> |
EmptyTargetSource.getTargetClass()
Always returns the specified target Class, or
null if none. |
Class<?> |
AbstractLazyCreationTargetSource.getTargetClass()
This default implementation returns
null if the
target is null (it is hasn't yet been initialized),
or the target class if the target has already been initialized. |
Modifier and Type | Method and Description |
---|---|
static EmptyTargetSource |
EmptyTargetSource.forClass(Class<?> targetClass)
Return an EmptyTargetSource for the given target Class.
|
static EmptyTargetSource |
EmptyTargetSource.forClass(Class<?> targetClass,
boolean isStatic)
Return an EmptyTargetSource for the given target Class.
|
Modifier and Type | Field and Description |
---|---|
protected Object |
AbstractRefreshableTargetSource.targetObject |
Modifier and Type | Method and Description |
---|---|
Object |
AbstractRefreshableTargetSource.getTarget() |
Modifier and Type | Field and Description |
---|---|
String[] |
AbstractNestablePropertyAccessor.PropertyTokenHolder.keys |
Modifier and Type | Method and Description |
---|---|
static String[] |
PropertyAccessorUtils.canonicalPropertyNames(String[] propertyNames)
Determine the canonical names for the given property paths.
|
Object |
BeanWrapperImpl.convertForProperty(Object value,
String propertyName)
Convert the given value for the specified property to the latter's type.
|
protected Object |
AbstractNestablePropertyAccessor.convertForProperty(String propertyName,
Object oldValue,
Object newValue,
TypeDescriptor td) |
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType) |
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType,
Field field)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType,
Field field) |
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType,
MethodParameter methodParam)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType,
MethodParameter methodParam) |
PropertyEditor |
PropertyEditorRegistry.findCustomEditor(Class<?> requiredType,
String propertyPath)
Find a custom property editor for the given type and property.
|
PropertyEditor |
PropertyEditorRegistrySupport.findCustomEditor(Class<?> requiredType,
String propertyPath) |
static Method |
BeanUtils.findDeclaredMethod(Class<?> clazz,
String methodName,
Class<?>... paramTypes)
Find a method with the given method name and the given parameter types,
declared on the given class or one of its superclasses.
|
static Method |
BeanUtils.findDeclaredMethodWithMinimalParameters(Class<?> clazz,
String methodName)
Find a method with the given method name and minimal parameters (best case: none),
declared on the given class or one of its superclasses.
|
static PropertyEditor |
BeanUtils.findEditorByConvention(Class<?> targetType)
Find a JavaBeans PropertyEditor following the 'Editor' suffix convention
(e.g.
|
static Method |
BeanUtils.findMethod(Class<?> clazz,
String methodName,
Class<?>... paramTypes)
Find a method with the given method name and the given parameter types,
declared on the given class or one of its superclasses.
|
static Method |
BeanUtils.findMethodWithMinimalParameters(Class<?> clazz,
String methodName)
Find a method with the given method name and minimal parameters (best case: none),
declared on the given class or one of its superclasses.
|
static Method |
BeanUtils.findMethodWithMinimalParameters(Method[] methods,
String methodName)
Find a method with the given method name and minimal parameters (best case: none)
in the given list of methods.
|
static <T> Constructor<T> |
BeanUtils.findPrimaryConstructor(Class<T> clazz)
Return the primary constructor of the provided class.
|
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. |
Object |
MutablePropertyValues.get(String propertyName)
Get the raw property value, if any.
|
Object |
BeanMetadataAttributeAccessor.getAttribute(String name) |
BeanInfo |
ExtendedBeanInfoFactory.getBeanInfo(Class<?> beanClass)
Return an
ExtendedBeanInfo for the given bean class, if applicable. |
BeanInfo |
BeanInfoFactory.getBeanInfo(Class<?> beanClass)
Return the bean info for the given class, if supported.
|
Class<?> |
AbstractNestablePropertyAccessor.PropertyHandler.getCollectionType(int nestingLevel) |
Method |
BeanInstantiationException.getConstructingMethod()
Return the delegate for bean construction purposes, if known.
|
Constructor<?> |
BeanInstantiationException.getConstructor()
Return the offending constructor, if known.
|
ConversionService |
ConfigurablePropertyAccessor.getConversionService()
Return the associated ConversionService, if any.
|
ConversionService |
PropertyEditorRegistrySupport.getConversionService()
Return the associated ConversionService, if any.
|
Object |
PropertyValue.getConvertedValue()
Return the converted value of this property value,
after processed type conversion.
|
PropertyEditor |
PropertyEditorRegistrySupport.getDefaultEditor(Class<?> requiredType)
Retrieve the default editor for the given property type, if any.
|
protected org.springframework.beans.BeanWrapperImpl.BeanPropertyHandler |
BeanWrapperImpl.getLocalPropertyHandler(String propertyName) |
protected org.springframework.beans.DirectFieldAccessor.FieldPropertyHandler |
DirectFieldAccessor.getLocalPropertyHandler(String propertyName) |
protected abstract AbstractNestablePropertyAccessor.PropertyHandler |
AbstractNestablePropertyAccessor.getLocalPropertyHandler(String propertyName)
Return a
AbstractNestablePropertyAccessor.PropertyHandler for the specified local propertyName . |
Class<?> |
AbstractNestablePropertyAccessor.PropertyHandler.getMapKeyType(int nestingLevel) |
Class<?> |
AbstractNestablePropertyAccessor.PropertyHandler.getMapValueType(int nestingLevel) |
BeanMetadataAttribute |
BeanMetadataAttributeAccessor.getMetadataAttribute(String name)
Look up the given BeanMetadataAttribute in this accessor's set of attributes.
|
String[] |
NotWritablePropertyException.getPossibleMatches()
Return suggestions for actual bean property names that closely match
the invalid property name, if any.
|
PropertyAccessException |
PropertyBatchUpdateException.getPropertyAccessException(String propertyName)
Return the exception for this field, or
null if there isn't any. |
PropertyChangeEvent |
PropertyAccessException.getPropertyChangeEvent()
Return the PropertyChangeEvent that resulted in the problem.
|
static PropertyDescriptor |
BeanUtils.getPropertyDescriptor(Class<?> clazz,
String propertyName)
Retrieve the JavaBeans
PropertyDescriptors for the given property. |
protected AbstractNestablePropertyAccessor.PropertyHandler |
AbstractNestablePropertyAccessor.getPropertyHandler(String propertyName)
Return the
AbstractNestablePropertyAccessor.PropertyHandler for the specified propertyName , navigating
if necessary. |
String |
PropertyAccessException.getPropertyName()
Return the name of the affected property, if available.
|
String |
TypeMismatchException.getPropertyName()
Return the name of the affected property, if available.
|
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.
|
protected Class<?> |
PropertyEditorRegistrySupport.getPropertyType(String propertyPath)
Determine the property type for the given property path.
|
Class<?> |
AbstractPropertyAccessor.getPropertyType(String propertyPath) |
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.
|
PropertyValue |
PropertyValues.getPropertyValue(String propertyName)
Return the property value with the given name, if any.
|
abstract Object |
AbstractPropertyAccessor.getPropertyValue(String propertyName)
Actually get the value of a property.
|
Object |
AbstractNestablePropertyAccessor.getPropertyValue(String propertyName) |
PropertyValue |
MutablePropertyValues.getPropertyValue(String propertyName) |
Class<?> |
TypeMismatchException.getRequiredType()
Return the required target type, if any.
|
AccessControlContext |
BeanWrapperImpl.getSecurityContext()
Return the security context used during the invocation of the wrapped instance methods.
|
Object |
BeanMetadataAttribute.getSource() |
Object |
BeanMetadataElement.getSource()
Return the configuration source
Object for this metadata element
(may be null ). |
Object |
BeanMetadataAttributeAccessor.getSource() |
Object |
PropertyValue.getValue()
Return the value of the property.
|
Object |
PropertyAccessException.getValue()
Return the affected value that was about to be set, if any.
|
Object |
TypeMismatchException.getValue()
Return the offending value (may be
null ). |
Object |
BeanMetadataAttribute.getValue()
Return the value of the attribute.
|
abstract Object |
AbstractNestablePropertyAccessor.PropertyHandler.getValue() |
protected Class<?> |
PropertyEditorRegistrySupport.guessPropertyTypeFromEditors(String propertyName)
Guess the property type of the specified property from the registered
custom editors (provided that they were registered for a specific type).
|
abstract TypeDescriptor |
AbstractNestablePropertyAccessor.PropertyHandler.nested(int level) |
Object |
BeanMetadataAttributeAccessor.removeAttribute(String name) |
static Method |
BeanUtils.resolveSignature(String signature,
Class<?> clazz)
Parse a method signature in the form
methodName[([arg_list])] ,
where arg_list is an optional, comma-separated list of fully-qualified
type names, and attempts to resolve that signature against the supplied Class . |
Modifier and Type | Method and Description |
---|---|
static void |
CachedIntrospectionResults.acceptClassLoader(ClassLoader classLoader)
Accept the given ClassLoader as cache-safe, even if its classes would
not qualify as cache-safe in this CachedIntrospectionResults class.
|
MutablePropertyValues |
MutablePropertyValues.add(String propertyName,
Object propertyValue)
Add a PropertyValue object, replacing any existing one for the
corresponding property or getting merged with it (if applicable).
|
MutablePropertyValues |
MutablePropertyValues.addPropertyValues(Map<?,?> other)
Add all property values from the given Map.
|
MutablePropertyValues |
MutablePropertyValues.addPropertyValues(PropertyValues other)
Copy all given PropertyValues into this object.
|
static String |
PropertyAccessorUtils.canonicalPropertyName(String propertyName)
Determine the canonical name for the given property path.
|
static String[] |
PropertyAccessorUtils.canonicalPropertyNames(String[] propertyNames)
Determine the canonical names for the given property paths.
|
static void |
CachedIntrospectionResults.clearClassLoader(ClassLoader classLoader)
Clear the introspection cache for the given ClassLoader, removing the
introspection results for all classes underneath that ClassLoader, and
removing the ClassLoader (and its children) from the acceptance list.
|
boolean |
PropertyBatchUpdateException.contains(Class<?> exType) |
Object |
BeanWrapperImpl.convertForProperty(Object value,
String propertyName)
Convert the given value for the specified property to the latter's type.
|
protected Object |
AbstractNestablePropertyAccessor.convertForProperty(String propertyName,
Object oldValue,
Object newValue,
TypeDescriptor td) |
protected Object |
AbstractNestablePropertyAccessor.convertForProperty(String propertyName,
Object oldValue,
Object newValue,
TypeDescriptor td) |
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType) |
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType) |
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType,
Field field)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType,
Field field)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType,
Field field)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType,
Field field) |
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType,
Field field) |
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType,
Field field) |
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType,
MethodParameter methodParam)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType,
MethodParameter methodParam)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverter.convertIfNecessary(Object value,
Class<T> requiredType,
MethodParameter methodParam)
Convert the value to the required type (if necessary from a String).
|
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType,
MethodParameter methodParam) |
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType,
MethodParameter methodParam) |
<T> T |
TypeConverterSupport.convertIfNecessary(Object value,
Class<T> requiredType,
MethodParameter methodParam) |
protected void |
PropertyEditorRegistrySupport.copyCustomEditorsTo(PropertyEditorRegistry target,
String nestedProperty)
Copy the custom editors registered in this instance to the given target registry.
|
PropertyEditor |
PropertyEditorRegistry.findCustomEditor(Class<?> requiredType,
String propertyPath)
Find a custom property editor for the given type and property.
|
PropertyEditor |
PropertyEditorRegistry.findCustomEditor(Class<?> requiredType,
String propertyPath)
Find a custom property editor for the given type and property.
|
PropertyEditor |
PropertyEditorRegistrySupport.findCustomEditor(Class<?> requiredType,
String propertyPath) |
PropertyEditor |
PropertyEditorRegistrySupport.findCustomEditor(Class<?> requiredType,
String propertyPath) |
static PropertyEditor |
BeanUtils.findEditorByConvention(Class<?> targetType)
Find a JavaBeans PropertyEditor following the 'Editor' suffix convention
(e.g.
|
static Class<?> |
BeanUtils.findPropertyType(String propertyName,
Class<?>... beanClasses)
Determine the bean property type for the given property from the
given classes/interfaces, if possible.
|
boolean |
PropertyEditorRegistrySupport.hasCustomEditorForElement(Class<?> elementType,
String propertyPath)
Determine whether this registry contains a custom editor
for the specified array/collection element.
|
boolean |
PropertyEditorRegistrySupport.hasCustomEditorForElement(Class<?> elementType,
String propertyPath)
Determine whether this registry contains a custom editor
for the specified array/collection element.
|
static boolean |
PropertyAccessorUtils.isNestedOrIndexedProperty(String propertyPath)
Check whether the given property path indicates an indexed or nested property.
|
Object |
Mergeable.merge(Object parent)
Merge the current value set with that of the supplied object.
|
void |
PropertyEditorRegistry.registerCustomEditor(Class<?> requiredType,
String propertyPath,
PropertyEditor propertyEditor)
Register the given custom property editor for the given type and
property, or for all properties of the given type.
|
void |
PropertyEditorRegistry.registerCustomEditor(Class<?> requiredType,
String propertyPath,
PropertyEditor propertyEditor)
Register the given custom property editor for the given type and
property, or for all properties of the given type.
|
void |
PropertyEditorRegistrySupport.registerCustomEditor(Class<?> requiredType,
String propertyPath,
PropertyEditor propertyEditor) |
void |
PropertyEditorRegistrySupport.registerCustomEditor(Class<?> requiredType,
String propertyPath,
PropertyEditor propertyEditor) |
void |
BeanMetadataAttributeAccessor.setAttribute(String name,
Object value) |
void |
ConfigurablePropertyAccessor.setConversionService(ConversionService conversionService)
Specify a Spring 3.0 ConversionService to use for converting
property values, as an alternative to JavaBeans PropertyEditors.
|
void |
PropertyEditorRegistrySupport.setConversionService(ConversionService conversionService)
Specify a Spring 3.0 ConversionService to use for converting
property values, as an alternative to JavaBeans PropertyEditors.
|
void |
PropertyValue.setConvertedValue(Object value)
Set the converted value of this property value,
after processed type conversion.
|
void |
PropertyAccessor.setPropertyValue(String propertyName,
Object value)
Set the specified value as current property value.
|
abstract void |
AbstractPropertyAccessor.setPropertyValue(String propertyName,
Object value)
Actually set a property value.
|
void |
AbstractNestablePropertyAccessor.setPropertyValue(String propertyName,
Object value) |
void |
BeanWrapperImpl.setSecurityContext(AccessControlContext acc)
Set the security context used during the invocation of the wrapped instance methods.
|
void |
BeanMetadataAttribute.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
BeanMetadataAttributeAccessor.setSource(Object source)
Set the configuration source
Object for this metadata element. |
abstract void |
AbstractNestablePropertyAccessor.PropertyHandler.setValue(Object value) |
void |
BeanWrapperImpl.setWrappedInstance(Object object,
String nestedPath,
Object rootObject) |
void |
BeanWrapperImpl.setWrappedInstance(Object object,
String nestedPath,
Object rootObject) |
void |
AbstractNestablePropertyAccessor.setWrappedInstance(Object object,
String nestedPath,
Object rootObject)
Switch the target object, replacing the cached introspection results only
if the class of the new object is different to that of the replaced object.
|
void |
AbstractNestablePropertyAccessor.setWrappedInstance(Object object,
String nestedPath,
Object rootObject)
Switch the target object, replacing the cached introspection results only
if the class of the new object is different to that of the replaced object.
|
Constructor and Description |
---|
BeanInstantiationException(Class<?> beanClass,
String msg,
Throwable cause)
Create a new BeanInstantiationException.
|
BeanInstantiationException(Constructor<?> constructor,
String msg,
Throwable cause)
Create a new BeanInstantiationException.
|
BeanInstantiationException(Method constructingMethod,
String msg,
Throwable cause)
Create a new BeanInstantiationException.
|
BeanMetadataAttribute(String name,
Object value)
Create a new AttributeValue instance.
|
BeansException(String msg,
Throwable cause)
Create a new BeansException with the specified message
and root cause.
|
BeansException(String msg,
Throwable cause)
Create a new BeansException with the specified message
and root cause.
|
ConversionNotSupportedException(Object value,
Class<?> requiredType,
Throwable cause)
Create a new ConversionNotSupportedException.
|
ConversionNotSupportedException(Object value,
Class<?> requiredType,
Throwable cause)
Create a new ConversionNotSupportedException.
|
ConversionNotSupportedException(Object value,
Class<?> requiredType,
Throwable cause)
Create a new ConversionNotSupportedException.
|
ConversionNotSupportedException(PropertyChangeEvent propertyChangeEvent,
Class<?> requiredType,
Throwable cause)
Create a new ConversionNotSupportedException.
|
ConversionNotSupportedException(PropertyChangeEvent propertyChangeEvent,
Class<?> requiredType,
Throwable cause)
Create a new ConversionNotSupportedException.
|
FatalBeanException(String msg,
Throwable cause)
Create a new FatalBeanException with the specified message
and root cause.
|
InvalidPropertyException(Class<?> beanClass,
String propertyName,
String msg,
Throwable cause)
Create a new InvalidPropertyException.
|
MutablePropertyValues(List<PropertyValue> propertyValueList)
Construct a new MutablePropertyValues object using the given List of
PropertyValue objects as-is.
|
MutablePropertyValues(Map<?,?> original)
Construct a new MutablePropertyValues object from a Map.
|
MutablePropertyValues(PropertyValues original)
Deep copy constructor.
|
PropertyAccessException(PropertyChangeEvent propertyChangeEvent,
String msg,
Throwable cause)
Create a new PropertyAccessException.
|
PropertyAccessException(String msg,
Throwable cause)
Create a new PropertyAccessException without PropertyChangeEvent.
|
PropertyValue(PropertyValue original,
Object newValue)
Constructor that exposes a new value for an original value holder.
|
PropertyValue(String name,
Object value)
Create a new PropertyValue instance.
|
TypeMismatchException(Object value,
Class<?> requiredType)
Create a new
TypeMismatchException without a PropertyChangeEvent . |
TypeMismatchException(Object value,
Class<?> requiredType)
Create a new
TypeMismatchException without a PropertyChangeEvent . |
TypeMismatchException(Object value,
Class<?> requiredType,
Throwable cause)
Create a new
TypeMismatchException without a PropertyChangeEvent . |
TypeMismatchException(Object value,
Class<?> requiredType,
Throwable cause)
Create a new
TypeMismatchException without a PropertyChangeEvent . |
TypeMismatchException(Object value,
Class<?> requiredType,
Throwable cause)
Create a new
TypeMismatchException without a PropertyChangeEvent . |
TypeMismatchException(PropertyChangeEvent propertyChangeEvent,
Class<?> requiredType,
Throwable cause)
Create a new
TypeMismatchException . |
TypeMismatchException(PropertyChangeEvent propertyChangeEvent,
Class<?> requiredType,
Throwable cause)
Create a new
TypeMismatchException . |
Modifier and Type | Method and Description |
---|---|
static void |
AnnotationBeanUtils.copyPropertiesToBean(Annotation ann,
Object bean,
StringValueResolver valueResolver,
String... excludedProperties)
Copy the properties of the supplied
Annotation to the supplied target bean. |
Modifier and Type | Field and Description |
---|---|
protected Field |
InjectionPoint.field |
protected MethodParameter |
InjectionPoint.methodParameter |
Modifier and Type | Method and Description |
---|---|
<A extends Annotation> |
ListableBeanFactory.findAnnotationOnBean(String beanName,
Class<A> annotationType)
Find an
Annotation of annotationType on the specified bean,
traversing its interfaces and super classes if no annotation can be found on
the given class itself. |
<A extends Annotation> |
InjectionPoint.getAnnotation(Class<A> annotationType)
Retrieve a field/parameter annotation of the given type, if any.
|
String |
CannotLoadBeanClassException.getBeanClassName()
Return the name of the class we were trying to load.
|
String |
BeanCreationException.getBeanName()
Return the name of the bean requested, if any.
|
String |
BeanDefinitionStoreException.getBeanName()
Return the name of the bean, if available.
|
String |
NoSuchBeanDefinitionException.getBeanName()
Return the name of the missing bean, if it was a lookup by name that failed.
|
Collection<String> |
NoUniqueBeanDefinitionException.getBeanNamesFound()
Return the names of all beans found when only one matching bean was expected.
|
Class<?> |
NoSuchBeanDefinitionException.getBeanType()
Return the required type of the missing bean, if it was a lookup by type
that failed.
|
Field |
InjectionPoint.getField()
Return the wrapped Field, if any.
|
T |
ObjectProvider.getIfAvailable()
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.
|
InjectionPoint |
UnsatisfiedDependencyException.getInjectionPoint()
Return the injection point (field or method/constructor parameter), if known.
|
MethodParameter |
InjectionPoint.getMethodParameter()
Return the wrapped MethodParameter, if any.
|
T |
FactoryBean.getObject()
Return an instance (possibly shared or independent) of the object
managed by this factory.
|
Class<?> |
FactoryBean.getObjectType()
Return the type of object that this FactoryBean creates,
or
null if not known in advance. |
BeanFactory |
HierarchicalBeanFactory.getParentBeanFactory()
Return the parent bean factory, or
null if there is none. |
Throwable[] |
BeanCreationException.getRelatedCauses()
Return the related causes, if any.
|
ResolvableType |
NoSuchBeanDefinitionException.getResolvableType()
Return the required
ResolvableType of the missing bean, if it was a lookup
by type that failed. |
String |
CannotLoadBeanClassException.getResourceDescription()
Return the description of the resource that the bean
definition came from.
|
String |
BeanCreationException.getResourceDescription()
Return the description of the resource that the bean
definition came from, if any.
|
String |
BeanDefinitionStoreException.getResourceDescription()
Return the description of the resource that the bean definition came from, if available.
|
Class<?> |
BeanFactory.getType(String name)
Determine the type of the bean with the given name.
|
Modifier and Type | Method and Description |
---|---|
boolean |
BeanCreationException.contains(Class<?> exClass) |
<T> T |
BeanFactory.getBean(String name,
Class<T> requiredType)
Return an instance, which may be shared or independent, of the specified bean.
|
String[] |
ListableBeanFactory.getBeanNamesForType(Class<?> type)
Return the names of beans matching the given type (including subclasses),
judging from either bean definitions or the value of
getObjectType
in the case of FactoryBeans. |
String[] |
ListableBeanFactory.getBeanNamesForType(Class<?> type,
boolean includeNonSingletons,
boolean allowEagerInit)
Return the names of beans matching the given 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)
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. |
static boolean |
BeanFactoryUtils.isFactoryDereference(String name)
Return whether the given name is a factory dereference
(beginning with the factory dereference prefix).
|
static boolean |
BeanFactoryUtils.isGeneratedBeanName(String name)
Return whether the given name is a bean name which has been generated
by the default naming strategy (containing a "#..." part).
|
boolean |
BeanFactory.isTypeMatch(String name,
Class<?> typeToMatch)
Check whether the bean with the given name matches the specified type.
|
Constructor and Description |
---|
BeanCreationException(String resourceDescription,
String beanName,
String msg)
Create a new BeanCreationException.
|
BeanCreationException(String resourceDescription,
String beanName,
String msg)
Create a new BeanCreationException.
|
BeanCreationException(String resourceDescription,
String beanName,
String msg,
Throwable cause)
Create a new BeanCreationException.
|
BeanDefinitionStoreException(String resourceDescription,
String msg)
Create a new BeanDefinitionStoreException.
|
BeanDefinitionStoreException(String resourceDescription,
String beanName,
String msg)
Create a new BeanDefinitionStoreException.
|
BeanDefinitionStoreException(String resourceDescription,
String beanName,
String msg,
Throwable cause)
Create a new BeanDefinitionStoreException.
|
BeanDefinitionStoreException(String resourceDescription,
String beanName,
String msg,
Throwable cause)
Create a new BeanDefinitionStoreException.
|
BeanDefinitionStoreException(String resourceDescription,
String msg,
Throwable cause)
Create a new BeanDefinitionStoreException.
|
BeanDefinitionStoreException(String resourceDescription,
String msg,
Throwable cause)
Create a new BeanDefinitionStoreException.
|
BeanDefinitionStoreException(String msg,
Throwable cause)
Create a new BeanDefinitionStoreException.
|
CannotLoadBeanClassException(String resourceDescription,
String beanName,
String beanClassName,
ClassNotFoundException cause)
Create a new CannotLoadBeanClassException.
|
CannotLoadBeanClassException(String resourceDescription,
String beanName,
String beanClassName,
ClassNotFoundException cause)
Create a new CannotLoadBeanClassException.
|
CannotLoadBeanClassException(String resourceDescription,
String beanName,
String beanClassName,
LinkageError cause)
Create a new CannotLoadBeanClassException.
|
CannotLoadBeanClassException(String resourceDescription,
String beanName,
String beanClassName,
LinkageError cause)
Create a new CannotLoadBeanClassException.
|
UnsatisfiedDependencyException(String resourceDescription,
String beanName,
InjectionPoint injectionPoint,
BeansException ex)
Create a new UnsatisfiedDependencyException.
|
UnsatisfiedDependencyException(String resourceDescription,
String beanName,
InjectionPoint injectionPoint,
BeansException ex)
Create a new UnsatisfiedDependencyException.
|
UnsatisfiedDependencyException(String resourceDescription,
String beanName,
InjectionPoint injectionPoint,
BeansException ex)
Create a new UnsatisfiedDependencyException.
|
UnsatisfiedDependencyException(String resourceDescription,
String beanName,
InjectionPoint injectionPoint,
String msg)
Create a new UnsatisfiedDependencyException.
|
UnsatisfiedDependencyException(String resourceDescription,
String beanName,
InjectionPoint injectionPoint,
String msg)
Create a new UnsatisfiedDependencyException.
|
UnsatisfiedDependencyException(String resourceDescription,
String beanName,
InjectionPoint injectionPoint,
String msg)
Create a new UnsatisfiedDependencyException.
|
UnsatisfiedDependencyException(String resourceDescription,
String beanName,
String propertyName,
BeansException ex)
Create a new UnsatisfiedDependencyException.
|
UnsatisfiedDependencyException(String resourceDescription,
String beanName,
String propertyName,
BeansException ex)
Create a new UnsatisfiedDependencyException.
|
UnsatisfiedDependencyException(String resourceDescription,
String beanName,
String propertyName,
String msg)
Create a new UnsatisfiedDependencyException.
|
UnsatisfiedDependencyException(String resourceDescription,
String beanName,
String propertyName,
String msg)
Create a new UnsatisfiedDependencyException.
|
Modifier and Type | Field and Description |
---|---|
protected PropertyDescriptor |
InjectionMetadata.InjectedElement.pd |
protected Boolean |
InjectionMetadata.InjectedElement.skip |
Modifier and Type | Method and Description |
---|---|
Constructor<?>[] |
AutowiredAnnotationBeanPostProcessor.determineCandidateConstructors(Class<?> beanClass,
String beanName) |
protected Object |
QualifierAnnotationAutowireCandidateResolver.findValue(Annotation[] annotationsToSearch)
Determine a suggested value from any of the given candidate annotations.
|
protected Annotation |
QualifierAnnotationAutowireCandidateResolver.getFactoryMethodAnnotation(RootBeanDefinition bd,
Class<? extends Annotation> type) |
MethodMetadata |
AnnotatedBeanDefinition.getFactoryMethodMetadata()
Obtain metadata for this bean definition's factory method, if any.
|
MethodMetadata |
AnnotatedGenericBeanDefinition.getFactoryMethodMetadata() |
protected Annotation |
QualifierAnnotationAutowireCandidateResolver.getQualifiedElementAnnotation(RootBeanDefinition bd,
Class<? extends Annotation> type) |
protected Object |
InjectionMetadata.InjectedElement.getResourceToInject(Object target,
String requestingBeanName)
Either this or
InjectionMetadata.InjectedElement.inject(java.lang.Object, java.lang.String, org.springframework.beans.PropertyValues) needs to be overridden. |
Object |
QualifierAnnotationAutowireCandidateResolver.getSuggestedValue(DependencyDescriptor descriptor)
Determine whether the given dependency declares a value annotation.
|
BeanWiringInfo |
AnnotationBeanWiringInfoResolver.resolveWiringInfo(Object beanInstance) |
Modifier and Type | Method and Description |
---|---|
protected boolean |
InjectionMetadata.InjectedElement.checkPropertySkipping(PropertyValues pvs)
Check whether this injector's property needs to be skipped due to
an explicit property value having been specified.
|
void |
InjectionMetadata.clear(PropertyValues pvs)
Clear property skipping for the contained elements.
|
protected void |
InjectionMetadata.InjectedElement.clearPropertySkipping(PropertyValues pvs)
Clear property skipping for this element.
|
protected Object |
InjectionMetadata.InjectedElement.getResourceToInject(Object target,
String requestingBeanName)
Either this or
InjectionMetadata.InjectedElement.inject(java.lang.Object, java.lang.String, org.springframework.beans.PropertyValues) needs to be overridden. |
void |
InjectionMetadata.inject(Object target,
String beanName,
PropertyValues pvs) |
void |
InjectionMetadata.inject(Object target,
String beanName,
PropertyValues pvs) |
protected void |
InjectionMetadata.InjectedElement.inject(Object target,
String requestingBeanName,
PropertyValues pvs)
Either this or
InjectionMetadata.InjectedElement.getResourceToInject(java.lang.Object, java.lang.String) needs to be overridden. |
protected void |
InjectionMetadata.InjectedElement.inject(Object target,
String requestingBeanName,
PropertyValues pvs)
Either this or
InjectionMetadata.InjectedElement.getResourceToInject(java.lang.Object, java.lang.String) needs to be overridden. |
static boolean |
BeanFactoryAnnotationUtils.isQualifierMatch(Predicate<String> qualifier,
String beanName,
BeanFactory beanFactory)
Check whether the named bean declares a qualifier of the given name.
|
static boolean |
InjectionMetadata.needsRefresh(InjectionMetadata metadata,
Class<?> clazz) |
void |
CustomAutowireConfigurer.setBeanClassLoader(ClassLoader beanClassLoader) |
protected boolean |
RequiredAnnotationBeanPostProcessor.shouldSkip(ConfigurableListableBeanFactory beanFactory,
String beanName)
Check whether the given bean definition is not subject to the annotation-based
required property check as performed by this post-processor.
|
Constructor and Description |
---|
InjectedElement(Member member,
PropertyDescriptor pd) |
Modifier and Type | Field and Description |
---|---|
protected String |
PlaceholderConfigurerSupport.nullValue |
protected String |
PlaceholderConfigurerSupport.valueSeparator
Defaults to ":"
|
Modifier and Type | Method and Description |
---|---|
Constructor<?>[] |
InstantiationAwareBeanPostProcessorAdapter.determineCandidateConstructors(Class<?> beanClass,
String beanName) |
default Constructor<?>[] |
SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors(Class<?> beanClass,
String beanName)
Determine the candidate constructors to use for the given bean.
|
Object |
BeanExpressionResolver.evaluate(String value,
BeanExpressionContext evalContext)
Evaluate the given value as an expression, if applicable;
return the value as-is otherwise.
|
String[] |
BeanDefinitionHolder.getAliases()
Return the alias names for the bean, as specified directly for the bean definition.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getArgumentValue(int index,
Class<?> requiredType)
Look for an argument value that either corresponds to the given index
in the constructor argument list or generically matches by type.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getArgumentValue(int index,
Class<?> requiredType,
String requiredName)
Look for an argument value that either corresponds to the given index
in the constructor argument list or generically matches by type.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getArgumentValue(int index,
Class<?> requiredType,
String requiredName,
Set<ConstructorArgumentValues.ValueHolder> usedValueHolders)
Look for an argument value that either corresponds to the given index
in the constructor argument list or generically matches by type.
|
ClassLoader |
ConfigurableBeanFactory.getBeanClassLoader()
Return this factory's class loader for loading bean classes
(only
null if even the system ClassLoader isn't accessible). |
String |
BeanDefinition.getBeanClassName()
Return the current bean class name of this bean definition.
|
BeanExpressionResolver |
ConfigurableBeanFactory.getBeanExpressionResolver()
Return the resolution strategy for expressions in bean definition values.
|
protected BeanFactory |
AbstractFactoryBean.getBeanFactory()
Return the BeanFactory that this bean runs in.
|
String |
Scope.getConversationId()
Return the conversation ID for the current underlying scope, if any.
|
ConversionService |
ConfigurableBeanFactory.getConversionService()
Return the associated ConversionService, if any.
|
Object |
ConstructorArgumentValues.ValueHolder.getConvertedValue()
Return the converted value of the constructor argument,
after processed type conversion.
|
String |
DependencyDescriptor.getDependencyName()
Determine the name of the wrapped parameter/field.
|
String[] |
BeanDefinition.getDependsOn()
Return the bean names that this bean depends on.
|
String |
BeanDefinition.getDescription()
Return a human-readable description of this bean definition.
|
protected Class<?>[] |
AbstractFactoryBean.getEarlySingletonInterfaces()
Return an array of interfaces that a singleton object exposed by this
FactoryBean is supposed to implement, for use with an 'early singleton
proxy' that will be exposed in case of a circular reference.
|
String |
BeanDefinition.getFactoryBeanName()
Return the factory bean name, if any.
|
String |
BeanDefinition.getFactoryMethodName()
Return a factory method, if any.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getGenericArgumentValue(Class<?> requiredType)
Look for a generic argument value that matches the given type.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getGenericArgumentValue(Class<?> requiredType,
String requiredName)
Look for a generic argument value that matches the given type.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getGenericArgumentValue(Class<?> requiredType,
String requiredName,
Set<ConstructorArgumentValues.ValueHolder> usedValueHolders)
Look for the next generic argument value that matches the given type,
ignoring argument values that have already been used in the current
resolution process.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getIndexedArgumentValue(int index,
Class<?> requiredType)
Get argument value for the given index in the constructor argument list.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getIndexedArgumentValue(int index,
Class<?> requiredType,
String requiredName)
Get argument value for the given index in the constructor argument list.
|
String |
ConstructorArgumentValues.ValueHolder.getName()
Return the name of the constructor argument.
|
Object |
FieldRetrievingFactoryBean.getObject() |
Properties |
PropertiesFactoryBean.getObject() |
Object |
MethodInvokingFactoryBean.getObject()
Returns the same value each time if the singleton property is set
to "true", otherwise returns the value returned from invoking the
specified method on the fly.
|
Object |
ServiceLocatorFactoryBean.getObject() |
Object |
PropertyPathFactoryBean.getObject() |
Properties |
YamlPropertiesFactoryBean.getObject() |
Map<String,Object> |
YamlMapFactoryBean.getObject() |
Object |
BeanExpressionContext.getObject(String key) |
abstract Class<?> |
AbstractFactoryBean.getObjectType()
This abstract method declaration mirrors the method in the FactoryBean
interface, for a consistent offering of abstract template methods.
|
BeanDefinition |
BeanDefinition.getOriginatingBeanDefinition()
Return the originating BeanDefinition, or
null if none. |
String |
BeanDefinition.getParentName()
Return the name of the parent definition of this bean definition, if any.
|
Scope |
ConfigurableBeanFactory.getRegisteredScope(String scopeName)
Return the Scope implementation for the given scope name, if any.
|
String |
BeanDefinition.getResourceDescription()
Return a description of the resource that this bean definition
came from (for the purpose of showing context in case of errors).
|
String |
BeanDefinition.getScope()
Return the name of the current target scope for this bean,
or
null if not known yet. |
Scope |
BeanExpressionContext.getScope() |
Object |
SingletonBeanRegistry.getSingleton(String beanName)
Return the (raw) singleton object registered under the given name.
|
Object |
BeanDefinitionHolder.getSource()
Expose the bean definition's source object.
|
Object |
TypedStringValue.getSource() |
Object |
RuntimeBeanReference.getSource() |
Object |
ConstructorArgumentValues.ValueHolder.getSource() |
Object |
RuntimeBeanNameReference.getSource() |
String |
TypedStringValue.getSpecifiedTypeName()
Return the type name as actually specified for this particular value, if any.
|
Class<?> |
FieldRetrievingFactoryBean.getTargetClass()
Return the target class on which the field is defined.
|
String |
FieldRetrievingFactoryBean.getTargetField()
Return the name of the field to be retrieved.
|
Object |
FieldRetrievingFactoryBean.getTargetObject()
Return the target object on which the field is defined.
|
String |
TypedStringValue.getTargetTypeName()
Return the type to convert to.
|
ClassLoader |
ConfigurableBeanFactory.getTempClassLoader()
Return the temporary ClassLoader to use for type matching purposes,
if any.
|
String |
ConstructorArgumentValues.ValueHolder.getType()
Return the type of the constructor argument.
|
String |
TypedStringValue.getValue()
Return the String value.
|
Object |
ConstructorArgumentValues.ValueHolder.getValue()
Return the value for the constructor argument.
|
protected Object |
MethodInvokingBean.invokeWithTargetException()
Perform the invocation and convert InvocationTargetException
into the underlying target exception.
|
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 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.
|
Object |
InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInstantiation(Class<?> beanClass,
String beanName) |
default PropertyValues |
InstantiationAwareBeanPostProcessor.postProcessPropertyValues(PropertyValues pvs,
PropertyDescriptor[] pds,
Object bean,
String beanName)
Post-process the given property values before the factory applies them
to the given bean.
|
Class<?> |
InstantiationAwareBeanPostProcessorAdapter.predictBeanType(Class<?> beanClass,
String beanName) |
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. |
Object |
Scope.remove(String name)
Remove the object with the given
name from the underlying scope. |
Object |
Scope.resolveContextualObject(String key)
Resolve the contextual object for the given key, if any.
|
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.
|
String |
ConfigurableBeanFactory.resolveEmbeddedValue(String value)
Resolve the given embedded value, e.g.
|
Object |
DependencyDescriptor.resolveNotUnique(Class<?> type,
Map<String,Object> matchingBeans)
Resolve the specified not-unique scenario: by default,
throwing a
NoUniqueBeanDefinitionException . |
protected String |
PropertyPlaceholderConfigurer.resolvePlaceholder(String placeholder,
Properties props)
Resolve the given placeholder using the given properties.
|
protected String |
PropertyPlaceholderConfigurer.resolvePlaceholder(String placeholder,
Properties props,
int systemPropertiesMode)
Resolve the given placeholder using the given properties, performing
a system properties check according to the given mode.
|
protected String |
PreferencesPlaceholderConfigurer.resolvePlaceholder(String path,
String key,
Preferences preferences)
Resolve the given path and key against the given Preferences.
|
Object |
DependencyDescriptor.resolveShortcut(BeanFactory beanFactory)
Resolve a shortcut for this dependency against the given factory, for example
taking some pre-resolved information into account.
|
protected String |
BeanDefinitionVisitor.resolveStringValue(String strVal)
Resolve the given String value, for example parsing placeholders.
|
String |
EmbeddedValueResolver.resolveStringValue(String strVal) |
protected String |
PropertyPlaceholderConfigurer.resolveSystemProperty(String key)
Resolve the given key as JVM system property, and optionally also as
system environment variable if no matching system property has been found.
|
Class<?> |
TypedStringValue.resolveTargetType(ClassLoader classLoader)
Determine the type to convert to, resolving it from a specified class name
if necessary.
|
protected Object |
BeanDefinitionVisitor.resolveValue(Object value) |
Modifier and Type | Method and Description |
---|---|
void |
ConstructorArgumentValues.addArgumentValues(ConstructorArgumentValues other)
Copy all given argument values into this object, using separate holder
instances to keep the values independent from the original object.
|
void |
ConstructorArgumentValues.addIndexedArgumentValue(int index,
Object value)
Add an argument value for the given index in the constructor argument list.
|
void |
ConstructorArgumentValues.addIndexedArgumentValue(int index,
Object value,
String type)
Add an argument value for the given index in the constructor argument list.
|
protected void |
AbstractFactoryBean.destroyInstance(T instance)
Callback for destroying a singleton instance.
|
Object |
BeanExpressionResolver.evaluate(String value,
BeanExpressionContext evalContext)
Evaluate the given value as an expression, if applicable;
return the value as-is otherwise.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getArgumentValue(int index,
Class<?> requiredType,
String requiredName,
Set<ConstructorArgumentValues.ValueHolder> usedValueHolders)
Look for an argument value that either corresponds to the given index
in the constructor argument list or generically matches by type.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getArgumentValue(int index,
Class<?> requiredType,
String requiredName,
Set<ConstructorArgumentValues.ValueHolder> usedValueHolders)
Look for an argument value that either corresponds to the given index
in the constructor argument list or generically matches by type.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getArgumentValue(int index,
Class<?> requiredType,
String requiredName,
Set<ConstructorArgumentValues.ValueHolder> usedValueHolders)
Look for an argument value that either corresponds to the given index
in the constructor argument list or generically matches by type.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getGenericArgumentValue(Class<?> requiredType,
String requiredName,
Set<ConstructorArgumentValues.ValueHolder> usedValueHolders)
Look for the next generic argument value that matches the given type,
ignoring argument values that have already been used in the current
resolution process.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getGenericArgumentValue(Class<?> requiredType,
String requiredName,
Set<ConstructorArgumentValues.ValueHolder> usedValueHolders)
Look for the next generic argument value that matches the given type,
ignoring argument values that have already been used in the current
resolution process.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getGenericArgumentValue(Class<?> requiredType,
String requiredName,
Set<ConstructorArgumentValues.ValueHolder> usedValueHolders)
Look for the next generic argument value that matches the given type,
ignoring argument values that have already been used in the current
resolution process.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getIndexedArgumentValue(int index,
Class<?> requiredType)
Get argument value for the given index in the constructor argument list.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getIndexedArgumentValue(int index,
Class<?> requiredType,
String requiredName)
Get argument value for the given index in the constructor argument list.
|
ConstructorArgumentValues.ValueHolder |
ConstructorArgumentValues.getIndexedArgumentValue(int index,
Class<?> requiredType,
String requiredName)
Get argument value for the given index in the constructor argument list.
|
void |
DependencyDescriptor.initParameterNameDiscovery(ParameterNameDiscoverer parameterNameDiscoverer)
Initialize parameter name discovery for the underlying method parameter, if any.
|
boolean |
BeanDefinitionHolder.matchesName(String candidateName)
Determine whether the given candidate name matches the bean name
or the aliases stored in this bean definition.
|
void |
ConfigurableListableBeanFactory.registerResolvableDependency(Class<?> dependencyType,
Object autowiredValue)
Register a special dependency type with corresponding autowired value.
|
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.
|
Object |
AutowireCapableBeanFactory.resolveDependency(DependencyDescriptor descriptor,
String requestingBeanName,
Set<String> autowiredBeanNames,
TypeConverter typeConverter)
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.
|
protected String |
PreferencesPlaceholderConfigurer.resolvePlaceholder(String path,
String key,
Preferences preferences)
Resolve the given path and key against the given Preferences.
|
Class<?> |
TypedStringValue.resolveTargetType(ClassLoader classLoader)
Determine the type to convert to, resolving it from a specified class name
if necessary.
|
protected Object |
BeanDefinitionVisitor.resolveValue(Object value) |
void |
CustomScopeConfigurer.setBeanClassLoader(ClassLoader beanClassLoader) |
void |
ConfigurableBeanFactory.setBeanClassLoader(ClassLoader beanClassLoader)
Set the class loader to use for loading bean classes.
|
void |
BeanDefinition.setBeanClassName(String beanClassName)
Specify the bean class name of this bean definition.
|
void |
ConfigurableBeanFactory.setBeanExpressionResolver(BeanExpressionResolver resolver)
Specify the resolution strategy for expressions in bean definition values.
|
void |
AbstractFactoryBean.setBeanFactory(BeanFactory beanFactory) |
void |
ConfigurableBeanFactory.setConversionService(ConversionService conversionService)
Specify a Spring 3.0 ConversionService to use for converting
property values, as an alternative to JavaBeans PropertyEditors.
|
void |
ConstructorArgumentValues.ValueHolder.setConvertedValue(Object value)
Set the converted value of the constructor argument,
after processed type conversion.
|
void |
BeanDefinition.setDependsOn(String... dependsOn)
Set the names of the beans that this bean depends on being initialized.
|
void |
BeanDefinition.setFactoryBeanName(String factoryBeanName)
Specify the factory bean to use, if any.
|
void |
BeanDefinition.setFactoryMethodName(String factoryMethodName)
Specify a factory method, if any.
|
void |
ConstructorArgumentValues.ValueHolder.setName(String name)
Set the name of the constructor argument.
|
void |
BeanDefinition.setParentName(String parentName)
Set the name of the parent definition of this bean definition, if any.
|
void |
BeanDefinition.setScope(String scope)
Override the target scope of this bean, specifying a new scope name.
|
void |
TypedStringValue.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
RuntimeBeanReference.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
ConstructorArgumentValues.ValueHolder.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
RuntimeBeanNameReference.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
TypedStringValue.setSpecifiedTypeName(String specifiedTypeName)
Set the type name as actually specified for this particular value, if any.
|
void |
FieldRetrievingFactoryBean.setTargetClass(Class<?> targetClass)
Set the target class on which the field is defined.
|
void |
FieldRetrievingFactoryBean.setTargetField(String targetField)
Set the name of the field to be retrieved.
|
void |
ListFactoryBean.setTargetListClass(Class<? extends List> targetListClass)
Set the class to use for the target List.
|
void |
MapFactoryBean.setTargetMapClass(Class<? extends Map> targetMapClass)
Set the class to use for the target Map.
|
void |
FieldRetrievingFactoryBean.setTargetObject(Object targetObject)
Set the target object on which the field is defined.
|
void |
SetFactoryBean.setTargetSetClass(Class<? extends Set> targetSetClass)
Set the class to use for the target Set.
|
void |
TypedStringValue.setTargetTypeName(String targetTypeName)
Specify the type to convert to.
|
void |
ConfigurableBeanFactory.setTempClassLoader(ClassLoader tempClassLoader)
Specify a temporary ClassLoader to use for type matching purposes.
|
void |
ConstructorArgumentValues.ValueHolder.setType(String type)
Set the type of the constructor argument.
|
void |
ConstructorArgumentValues.ValueHolder.setValue(Object value)
Set the value for the constructor argument.
|
void |
TypedStringValue.setValue(String value)
Set the String value.
|
void |
PlaceholderConfigurerSupport.setValueSeparator(String valueSeparator)
Specify the separating character between the placeholder variable
and the associated default value, or
null if no such
special character should be processed as a value separator. |
Constructor and Description |
---|
BeanDefinitionHolder(BeanDefinition beanDefinition,
String beanName,
String[] aliases)
Create a new BeanDefinitionHolder.
|
BeanExpressionContext(ConfigurableBeanFactory beanFactory,
Scope scope) |
TypedStringValue(String value)
Create a new
TypedStringValue for the given String value. |
TypedStringValue(String value,
Class<?> targetType)
Create a new
TypedStringValue for the given String value
and target type. |
TypedStringValue(String value,
String targetTypeName)
Create a new
TypedStringValue for the given String value
and target type. |
ValueHolder(Object value)
Create a new ValueHolder for the given value.
|
ValueHolder(Object value,
String type)
Create a new ValueHolder for the given value and type.
|
ValueHolder(Object value,
String type)
Create a new ValueHolder for the given value and type.
|
ValueHolder(Object value,
String type,
String name)
Create a new ValueHolder for the given value, type and name.
|
ValueHolder(Object value,
String type,
String name)
Create a new ValueHolder for the given value, type and name.
|
ValueHolder(Object value,
String type,
String name)
Create a new ValueHolder for the given value, type and name.
|
Modifier and Type | Method and Description |
---|---|
Object |
ReaderContext.extractSource(Object sourceCandidate)
Call the source extractor for the given source object.
|
Object |
NullSourceExtractor.extractSource(Object sourceCandidate,
Resource definitionResource)
This implementation simply returns
null for any input. |
Object |
SourceExtractor.extractSource(Object sourceCandidate,
Resource definingResource)
Extract the source metadata from the candidate object supplied
by the configuration parser.
|
Resource[] |
ImportDefinition.getActualResources() |
ParseState |
Problem.getParseState()
Get the
ParseState at the time of the error (may be null ). |
Throwable |
Problem.getRootCause()
Get the underlying exception that caused the error (may be
null ). |
Object |
AliasDefinition.getSource() |
Object |
ImportDefinition.getSource() |
Object |
CompositeComponentDefinition.getSource() |
Object |
Location.getSource()
Get the actual location within the associated
resource
(may be null ). |
ParseState.Entry |
ParseState.peek()
Return the
ParseState.Entry currently at the top of the LinkedList or
null if the LinkedList is empty. |
Modifier and Type | Method and Description |
---|---|
void |
ReaderContext.error(String message,
Object source)
Raise a regular error.
|
void |
ReaderContext.error(String message,
Object source,
ParseState parseState)
Raise a regular error.
|
void |
ReaderContext.error(String message,
Object source,
ParseState parseState)
Raise a regular error.
|
void |
ReaderContext.error(String message,
Object source,
ParseState parseState,
Throwable cause)
Raise a regular error.
|
void |
ReaderContext.error(String message,
Object source,
ParseState parseState,
Throwable cause)
Raise a regular error.
|
void |
ReaderContext.error(String message,
Object source,
ParseState parseState,
Throwable cause)
Raise a regular error.
|
void |
ReaderContext.error(String message,
Object source,
Throwable cause)
Raise a regular error.
|
void |
ReaderContext.error(String message,
Object source,
Throwable cause)
Raise a regular error.
|
Object |
NullSourceExtractor.extractSource(Object sourceCandidate,
Resource definitionResource)
This implementation simply returns
null for any input. |
Object |
SourceExtractor.extractSource(Object sourceCandidate,
Resource definingResource)
Extract the source metadata from the candidate object supplied
by the configuration parser.
|
Object |
PassThroughSourceExtractor.extractSource(Object sourceCandidate,
Resource definingResource)
Simply returns the supplied
sourceCandidate as-is. |
void |
ReaderContext.fatal(String message,
Object source)
Raise a fatal error.
|
void |
ReaderContext.fatal(String message,
Object source,
ParseState parseState)
Raise a fatal error.
|
void |
ReaderContext.fatal(String message,
Object source,
ParseState parseState)
Raise a fatal error.
|
void |
ReaderContext.fatal(String message,
Object source,
ParseState parseState,
Throwable cause)
Raise a fatal error.
|
void |
ReaderContext.fatal(String message,
Object source,
ParseState parseState,
Throwable cause)
Raise a fatal error.
|
void |
ReaderContext.fatal(String message,
Object source,
ParseState parseState,
Throwable cause)
Raise a fatal error.
|
void |
ReaderContext.fatal(String message,
Object source,
Throwable cause)
Raise a fatal error.
|
void |
ReaderContext.fatal(String message,
Object source,
Throwable cause)
Raise a fatal error.
|
void |
ReaderContext.fireAliasRegistered(String beanName,
String alias,
Object source)
Fire an alias-registered event.
|
void |
ReaderContext.fireImportProcessed(String importedResource,
Object source)
Fire an import-processed event.
|
void |
ReaderContext.fireImportProcessed(String importedResource,
Resource[] actualResources,
Object source)
Fire an import-processed event.
|
void |
FailFastProblemReporter.setLogger(Log logger)
Set the
logger that is to be used to report warnings. |
void |
ReaderContext.warning(String message,
Object source)
Raise a non-critical warning.
|
void |
ReaderContext.warning(String message,
Object source,
ParseState parseState)
Raise a non-critical warning.
|
void |
ReaderContext.warning(String message,
Object source,
ParseState parseState)
Raise a non-critical warning.
|
void |
ReaderContext.warning(String message,
Object source,
ParseState parseState,
Throwable cause)
Raise a non-critical warning.
|
void |
ReaderContext.warning(String message,
Object source,
ParseState parseState,
Throwable cause)
Raise a non-critical warning.
|
void |
ReaderContext.warning(String message,
Object source,
ParseState parseState,
Throwable cause)
Raise a non-critical warning.
|
void |
ReaderContext.warning(String message,
Object source,
Throwable cause)
Raise a non-critical warning.
|
void |
ReaderContext.warning(String message,
Object source,
Throwable cause)
Raise a non-critical warning.
|
Constructor and Description |
---|
AliasDefinition(String beanName,
String alias,
Object source)
Create a new AliasDefinition.
|
BeanComponentDefinition(BeanDefinition beanDefinition,
String beanName,
String[] aliases)
Create a new BeanComponentDefinition for the given bean.
|
CompositeComponentDefinition(String name,
Object source)
Create a new CompositeComponentDefinition.
|
ImportDefinition(String importedResource,
Object source)
Create a new ImportDefinition.
|
ImportDefinition(String importedResource,
Resource[] actualResources,
Object source)
Create a new ImportDefinition.
|
ImportDefinition(String importedResource,
Resource[] actualResources,
Object source)
Create a new ImportDefinition.
|
Location(Resource resource,
Object source)
Create a new instance of the
Location class. |
Problem(String message,
Location location,
ParseState parseState,
Throwable rootCause)
Create a new instance of the
Problem class. |
Problem(String message,
Location location,
ParseState parseState,
Throwable rootCause)
Create a new instance of the
Problem class. |
Modifier and Type | Method and Description |
---|---|
Class<?> |
ServiceFactoryBean.getObjectType() |
Class<?> |
AbstractServiceLoaderBasedFactoryBean.getServiceType()
Return the desired service type.
|
Modifier and Type | Method and Description |
---|---|
void |
AbstractServiceLoaderBasedFactoryBean.setBeanClassLoader(ClassLoader beanClassLoader) |
void |
AbstractServiceLoaderBasedFactoryBean.setServiceType(Class<?> serviceType)
Specify the desired service type (typically the service's public API).
|
Modifier and Type | Method and Description |
---|---|
protected Object |
AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass,
String beanName)
Apply InstantiationAwareBeanPostProcessors to the specified bean definition
(by class and name), invoking their
postProcessBeforeInstantiation methods. |
protected String |
DefaultListableBeanFactory.determineAutowireCandidate(Map<String,Object> candidates,
DependencyDescriptor descriptor)
Determine the autowire candidate in the given set of beans.
|
protected Constructor<?>[] |
AbstractAutowireCapableBeanFactory.determineConstructorsFromBeanPostProcessors(Class<?> beanClass,
String beanName)
Determine candidate constructors to use for the given bean, checking all registered
SmartInstantiationAwareBeanPostProcessors . |
protected String |
DefaultListableBeanFactory.determineHighestPriorityCandidate(Map<String,Object> candidates,
Class<?> requiredType)
Determine the candidate with the highest priority in the given set of beans.
|
protected String |
DefaultListableBeanFactory.determinePrimaryCandidate(Map<String,Object> candidates,
Class<?> requiredType)
Determine the primary candidate in the given set of beans.
|
protected Class<?> |
AbstractAutowireCapableBeanFactory.determineTargetType(String beanName,
RootBeanDefinition mbd,
Class<?>... typesToMatch)
Determine the target type for the given bean definition.
|
Object |
DefaultListableBeanFactory.doResolveDependency(DependencyDescriptor descriptor,
String beanName,
Set<String> autowiredBeanNames,
TypeConverter typeConverter) |
protected Object |
AbstractBeanFactory.evaluateBeanDefinitionString(String value,
BeanDefinition beanDefinition)
Evaluate the given String as contained in a bean definition,
potentially resolving it as an expression.
|
<A extends Annotation> |
DefaultListableBeanFactory.findAnnotationOnBean(String beanName,
Class<A> annotationType) |
<A extends Annotation> |
StaticListableBeanFactory.findAnnotationOnBean(String beanName,
Class<A> annotationType) |
ClassLoader |
AbstractBeanDefinitionReader.getBeanClassLoader() |
ClassLoader |
BeanDefinitionReader.getBeanClassLoader()
Return the class loader to use for bean classes.
|
ClassLoader |
AbstractBeanFactory.getBeanClassLoader() |
String |
AbstractBeanDefinition.getBeanClassName()
Return the current bean class name of this bean definition.
|
BeanExpressionResolver |
AbstractBeanFactory.getBeanExpressionResolver() |
protected BeanFactory |
GenericTypeAwareAutowireCandidateResolver.getBeanFactory() |
String |
LookupOverride.getBeanName()
Return the name of the bean that should be returned by this method.
|
protected Object |
FactoryBeanRegistrySupport.getCachedObjectForFactoryBean(String beanName)
Obtain an object to expose from the given FactoryBean, if available
in cached form.
|
ConversionService |
AbstractBeanFactory.getConversionService() |
static Method |
SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod()
Return the factory method currently being invoked or
null if none. |
protected TypeConverter |
AbstractBeanFactory.getCustomTypeConverter()
Return the custom TypeConverter to use, if any.
|
BeanDefinitionHolder |
RootBeanDefinition.getDecoratedDefinition()
Return the target definition that is being decorated by this bean definition, if any.
|
String |
PropertiesBeanDefinitionReader.getDefaultParentBean()
Return the default parent bean for this bean factory.
|
Comparator<Object> |
DefaultListableBeanFactory.getDependencyComparator()
Return the dependency comparator for this BeanFactory (may be
null . |
String[] |
AbstractBeanDefinition.getDependsOn()
Return the bean names that this bean depends on.
|
String |
AbstractBeanDefinition.getDescription()
Return a human-readable description of this bean definition.
|
String |
BeanDefinitionDefaults.getDestroyMethodName()
Return the name of the default destroy method.
|
String |
AbstractBeanDefinition.getDestroyMethodName()
Return the name of the destroy method.
|
String |
ManagedSet.getElementTypeName()
Return the default element type name (class name) to be used for this set.
|
String |
ManagedList.getElementTypeName()
Return the default element type name (class name) to be used for this list.
|
String |
AbstractBeanDefinition.getFactoryBeanName()
Return the factory bean name, if any.
|
String |
AbstractBeanDefinition.getFactoryMethodName()
Return a factory method, if any.
|
String |
BeanDefinitionDefaults.getInitMethodName()
Return the name of the default initializer method.
|
String |
AbstractBeanDefinition.getInitMethodName()
Return the name of the initializer method.
|
Supplier<?> |
AbstractBeanDefinition.getInstanceSupplier()
Return a callback for creating an instance of the bean, if any.
|
String |
ManagedMap.getKeyTypeName()
Return the default key type name (class name) to be used for this map.
|
default Object |
AutowireCandidateResolver.getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor,
String beanName)
Build a proxy for lazy resolution of the actual dependency target,
if demanded by the injection point.
|
Object |
SimpleAutowireCandidateResolver.getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor,
String beanName) |
BeanDefinition |
AbstractBeanDefinition.getOriginatingBeanDefinition()
Return the originating BeanDefinition, or
null if none. |
MethodOverride |
MethodOverrides.getOverride(Method method)
Return the override for the given method, if any.
|
protected ParameterNameDiscoverer |
AbstractAutowireCapableBeanFactory.getParameterNameDiscoverer()
Return the ParameterNameDiscoverer to use for resolving method parameter
names if needed.
|
BeanFactory |
AbstractBeanFactory.getParentBeanFactory() |
String |
GenericBeanDefinition.getParentName() |
String |
ChildBeanDefinition.getParentName() |
protected Integer |
DefaultListableBeanFactory.getPriority(Object beanInstance)
Return the priority assigned for the given bean instance by
the
javax.annotation.Priority annotation. |
AnnotatedElement |
RootBeanDefinition.getQualifiedElement()
Return the
AnnotatedElement defining qualifiers, if any. |
AutowireCandidateQualifier |
AbstractBeanDefinition.getQualifier(String typeName)
Return the qualifier mapped to the provided type name.
|
Scope |
AbstractBeanFactory.getRegisteredScope(String scopeName) |
protected RootBeanDefinition |
GenericTypeAwareAutowireCandidateResolver.getResolvedDecoratedDefinition(RootBeanDefinition rbd) |
Method |
RootBeanDefinition.getResolvedFactoryMethod()
Return the resolved factory method as a Java Method object, if available.
|
Resource |
AbstractBeanDefinition.getResource()
Return the resource that this bean definition came from.
|
String |
AbstractBeanDefinition.getResourceDescription()
Return a description of the resource that this bean definition
came from (for the purpose of showing context in case of errors).
|
ResourceLoader |
AbstractBeanDefinitionReader.getResourceLoader() |
ResourceLoader |
BeanDefinitionReader.getResourceLoader()
Return the resource loader to use for resource locations.
|
protected ResolvableType |
GenericTypeAwareAutowireCandidateResolver.getReturnTypeForFactoryMethod(RootBeanDefinition rbd,
DependencyDescriptor descriptor) |
String |
AbstractBeanDefinition.getScope()
Return the name of the target scope for the bean.
|
String |
DefaultListableBeanFactory.getSerializationId()
Return an id for serialization purposes, if specified, allowing this BeanFactory
to be deserialized from this id back into the BeanFactory object, if needed.
|
Object |
DefaultSingletonBeanRegistry.getSingleton(String beanName) |
protected Object |
DefaultSingletonBeanRegistry.getSingleton(String beanName,
boolean allowEarlyReference)
Return the (raw) singleton object registered under the given name.
|
Object |
ManagedSet.getSource() |
Object |
ManagedList.getSource() |
Object |
MethodOverride.getSource() |
Object |
ManagedMap.getSource() |
Object |
ManagedProperties.getSource() |
default Object |
AutowireCandidateResolver.getSuggestedValue(DependencyDescriptor descriptor)
Determine whether a default value is suggested for the given dependency.
|
Object |
SimpleAutowireCandidateResolver.getSuggestedValue(DependencyDescriptor descriptor) |
Class<?> |
RootBeanDefinition.getTargetType()
Return the target type of this bean definition, if known
(either specified in advance or resolved on first instantiation).
|
ClassLoader |
AbstractBeanFactory.getTempClassLoader() |
Class<?> |
AbstractBeanFactory.getType(String name) |
protected Class<?> |
FactoryBeanRegistrySupport.getTypeForFactoryBean(FactoryBean<?> factoryBean)
Determine the type for the given FactoryBean.
|
protected Class<?> |
AbstractAutowireCapableBeanFactory.getTypeForFactoryBean(String beanName,
RootBeanDefinition mbd)
This implementation attempts to query the FactoryBean's generic parameter metadata
if present to determine the object type.
|
protected Class<?> |
AbstractBeanFactory.getTypeForFactoryBean(String beanName,
RootBeanDefinition mbd)
Determine the bean type for the given FactoryBean definition, as far as possible.
|
protected Class<?> |
AbstractAutowireCapableBeanFactory.getTypeForFactoryMethod(String beanName,
RootBeanDefinition mbd,
Class<?>... typesToMatch)
Determine the target type for the given bean definition which is based on
a factory method.
|
String |
ManagedMap.getValueTypeName()
Return the default value type name (class name) to be used for this map.
|
protected Class<?> |
AbstractAutowireCapableBeanFactory.predictBeanType(String beanName,
RootBeanDefinition mbd,
Class<?>... typesToMatch) |
protected Class<?> |
AbstractBeanFactory.predictBeanType(String beanName,
RootBeanDefinition mbd,
Class<?>... typesToMatch)
Predict the eventual bean type (of the processed bean instance) for the
specified bean.
|
Class<?> |
AbstractBeanDefinition.resolveBeanClass(ClassLoader classLoader)
Determine the class of the wrapped bean, resolving it from a
specified class name if necessary.
|
protected Class<?> |
AbstractBeanFactory.resolveBeanClass(RootBeanDefinition mbd,
String beanName,
Class<?>... typesToMatch)
Resolve the bean class for the specified bean definition,
resolving a bean class name into a Class reference (if necessary)
and storing the resolved Class in the bean definition for further use.
|
protected Object |
AbstractAutowireCapableBeanFactory.resolveBeforeInstantiation(String beanName,
RootBeanDefinition mbd)
Apply before-instantiation post-processors, resolving whether there is a
before-instantiation shortcut for the specified bean.
|
Object |
AbstractAutowireCapableBeanFactory.resolveDependency(DependencyDescriptor descriptor,
String requestingBeanName) |
Object |
DefaultListableBeanFactory.resolveDependency(DependencyDescriptor descriptor,
String requestingBeanName,
Set<String> autowiredBeanNames,
TypeConverter typeConverter) |
String |
AbstractBeanFactory.resolveEmbeddedValue(String value) |
Modifier and Type | Method and Description |
---|---|
BeanDefinitionBuilder |
BeanDefinitionBuilder.addConstructorArgValue(Object value)
Add an indexed constructor arg value.
|
void |
MethodOverrides.addOverrides(MethodOverrides other)
Copy all given method overrides into this object.
|
BeanDefinitionBuilder |
BeanDefinitionBuilder.addPropertyValue(String name,
Object value)
Add the supplied property value under the given property name.
|
protected BeanWrapper |
AbstractAutowireCapableBeanFactory.autowireConstructor(String beanName,
RootBeanDefinition mbd,
Constructor<?>[] ctors,
Object[] explicitArgs)
"autowire constructor" (with constructor arguments by type) behavior.
|
protected BeanWrapper |
AbstractAutowireCapableBeanFactory.autowireConstructor(String beanName,
RootBeanDefinition mbd,
Constructor<?>[] ctors,
Object[] explicitArgs)
"autowire constructor" (with constructor arguments by type) behavior.
|
protected void |
AbstractBeanFactory.checkMergedBeanDefinition(RootBeanDefinition mbd,
String beanName,
Object[] args)
Check the given merged bean definition,
potentially throwing validation exceptions.
|
protected Object |
AbstractAutowireCapableBeanFactory.createBean(String beanName,
RootBeanDefinition mbd,
Object[] args)
Central method of this class: creates a bean instance,
populates the bean instance, applies post-processors, etc.
|
protected abstract Object |
AbstractBeanFactory.createBean(String beanName,
RootBeanDefinition mbd,
Object[] args)
Create a bean instance for the given merged bean definition (and arguments).
|
static AbstractBeanDefinition |
BeanDefinitionReaderUtils.createBeanDefinition(String parentName,
String className,
ClassLoader classLoader)
Create a new GenericBeanDefinition for the given parent name and class name,
eagerly loading the bean class if a ClassLoader has been specified.
|
static AbstractBeanDefinition |
BeanDefinitionReaderUtils.createBeanDefinition(String parentName,
String className,
ClassLoader classLoader)
Create a new GenericBeanDefinition for the given parent name and class name,
eagerly loading the bean class if a ClassLoader has been specified.
|
static AbstractBeanDefinition |
BeanDefinitionReaderUtils.createBeanDefinition(String parentName,
String className,
ClassLoader classLoader)
Create a new GenericBeanDefinition for the given parent name and class name,
eagerly loading the bean class if a ClassLoader has been specified.
|
protected BeanWrapper |
AbstractAutowireCapableBeanFactory.createBeanInstance(String beanName,
RootBeanDefinition mbd,
Object[] args)
Create a new instance for the specified bean, using an appropriate instantiation strategy:
factory method, constructor autowiring, or simple instantiation.
|
protected void |
DefaultSingletonBeanRegistry.destroyBean(String beanName,
DisposableBean bean)
Destroy the given bean.
|
protected Constructor<?>[] |
AbstractAutowireCapableBeanFactory.determineConstructorsFromBeanPostProcessors(Class<?> beanClass,
String beanName)
Determine candidate constructors to use for the given bean, checking all registered
SmartInstantiationAwareBeanPostProcessors . |
protected Object |
AbstractAutowireCapableBeanFactory.doCreateBean(String beanName,
RootBeanDefinition mbd,
Object[] args)
Actually create the specified bean.
|
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 <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) |
Object |
DefaultListableBeanFactory.doResolveDependency(DependencyDescriptor descriptor,
String beanName,
Set<String> autowiredBeanNames,
TypeConverter typeConverter) |
Object |
DefaultListableBeanFactory.doResolveDependency(DependencyDescriptor descriptor,
String beanName,
Set<String> autowiredBeanNames,
TypeConverter typeConverter) |
protected Object |
AbstractBeanFactory.evaluateBeanDefinitionString(String value,
BeanDefinition beanDefinition)
Evaluate the given String as contained in a bean definition,
potentially resolving it as an expression.
|
protected Object |
AbstractBeanFactory.evaluateBeanDefinitionString(String value,
BeanDefinition beanDefinition)
Evaluate the given String as contained in a bean definition,
potentially resolving it as an expression.
|
protected Map<String,Object> |
DefaultListableBeanFactory.findAutowireCandidates(String beanName,
Class<?> requiredType,
DependencyDescriptor descriptor)
Find bean instances that match the required type.
|
<T> T |
DefaultListableBeanFactory.getBean(Class<T> requiredType,
Object... args) |
<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.
|
<T> T |
AbstractBeanFactory.getBean(String name,
Class<T> requiredType,
Object... args)
Return an instance, which may be shared or independent, of the specified bean.
|
String[] |
DefaultListableBeanFactory.getBeanNamesForType(Class<?> type) |
String[] |
StaticListableBeanFactory.getBeanNamesForType(Class<?> type) |
String[] |
DefaultListableBeanFactory.getBeanNamesForType(Class<?> type,
boolean includeNonSingletons,
boolean allowEagerInit) |
String[] |
StaticListableBeanFactory.getBeanNamesForType(Class<?> type,
boolean includeNonSingletons,
boolean allowEagerInit) |
String[] |
StaticListableBeanFactory.getBeanNamesForType(ResolvableType type) |
<T> Map<String,T> |
DefaultListableBeanFactory.getBeansOfType(Class<T> type) |
<T> Map<String,T> |
StaticListableBeanFactory.getBeansOfType(Class<T> type) |
<T> Map<String,T> |
DefaultListableBeanFactory.getBeansOfType(Class<T> type,
boolean includeNonSingletons,
boolean allowEagerInit) |
<T> Map<String,T> |
StaticListableBeanFactory.getBeansOfType(Class<T> type,
boolean includeNonSingletons,
boolean allowEagerInit) |
default Object |
AutowireCandidateResolver.getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor,
String beanName)
Build a proxy for lazy resolution of the actual dependency target,
if demanded by the injection point.
|
Object |
SimpleAutowireCandidateResolver.getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor,
String beanName) |
protected RootBeanDefinition |
AbstractBeanFactory.getMergedBeanDefinition(String beanName,
BeanDefinition bd,
BeanDefinition containingBd)
Return a RootBeanDefinition for the given bean, by merging with the
parent if the given bean's definition is a child bean definition.
|
protected Object |
AbstractAutowireCapableBeanFactory.getObjectForBeanInstance(Object beanInstance,
String name,
String beanName,
RootBeanDefinition mbd)
Overridden in order to implicitly register the currently created bean as
dependent on further beans getting programmatically retrieved during a
Supplier callback. |
protected Object |
AbstractBeanFactory.getObjectForBeanInstance(Object beanInstance,
String name,
String beanName,
RootBeanDefinition mbd)
Get the object for the given bean instance, either the bean
instance itself or its created object in case of a FactoryBean.
|
protected Object |
AbstractAutowireCapableBeanFactory.initializeBean(String beanName,
Object bean,
RootBeanDefinition mbd)
Initialize the given bean instance, applying factory callbacks
as well as init methods and bean post processors.
|
Object |
InstantiationStrategy.instantiate(RootBeanDefinition bd,
String beanName,
BeanFactory owner)
Return an instance of the bean with the given name in this factory.
|
Object |
SimpleInstantiationStrategy.instantiate(RootBeanDefinition bd,
String beanName,
BeanFactory owner) |
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,
Constructor<?> ctor,
Object... args)
Return an instance of the bean with the given name in this factory,
creating it via the given constructor.
|
Object |
SimpleInstantiationStrategy.instantiate(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Constructor<?> ctor,
Object... args) |
Object |
SimpleInstantiationStrategy.instantiate(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Constructor<?> ctor,
Object... args) |
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.
|
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.
|
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.
|
Object |
SimpleInstantiationStrategy.instantiate(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Object factoryBean,
Method factoryMethod,
Object... args) |
Object |
SimpleInstantiationStrategy.instantiate(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Object factoryBean,
Method factoryMethod,
Object... args) |
Object |
SimpleInstantiationStrategy.instantiate(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Object factoryBean,
Method factoryMethod,
Object... args) |
protected BeanWrapper |
AbstractAutowireCapableBeanFactory.instantiateUsingFactoryMethod(String beanName,
RootBeanDefinition mbd,
Object[] explicitArgs)
Instantiate the bean using a named factory method.
|
protected Object |
SimpleInstantiationStrategy.instantiateWithMethodInjection(RootBeanDefinition bd,
String beanName,
BeanFactory owner)
Subclasses can override this method, which is implemented to throw
UnsupportedOperationException, if they can instantiate an object with
the Method Injection specified in the given RootBeanDefinition.
|
protected Object |
CglibSubclassingInstantiationStrategy.instantiateWithMethodInjection(RootBeanDefinition bd,
String beanName,
BeanFactory owner) |
protected Object |
SimpleInstantiationStrategy.instantiateWithMethodInjection(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Constructor<?> ctor,
Object... args)
Subclasses can override this method, which is implemented to throw
UnsupportedOperationException, if they can instantiate an object with
the Method Injection specified in the given RootBeanDefinition.
|
protected Object |
SimpleInstantiationStrategy.instantiateWithMethodInjection(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Constructor<?> ctor,
Object... args)
Subclasses can override this method, which is implemented to throw
UnsupportedOperationException, if they can instantiate an object with
the Method Injection specified in the given RootBeanDefinition.
|
protected Object |
SimpleInstantiationStrategy.instantiateWithMethodInjection(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Constructor<?> ctor,
Object... args)
Subclasses can override this method, which is implemented to throw
UnsupportedOperationException, if they can instantiate an object with
the Method Injection specified in the given RootBeanDefinition.
|
protected Object |
CglibSubclassingInstantiationStrategy.instantiateWithMethodInjection(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Constructor<?> ctor,
Object... args) |
protected Object |
CglibSubclassingInstantiationStrategy.instantiateWithMethodInjection(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Constructor<?> ctor,
Object... args) |
protected Object |
CglibSubclassingInstantiationStrategy.instantiateWithMethodInjection(RootBeanDefinition bd,
String beanName,
BeanFactory owner,
Constructor<?> ctor,
Object... args) |
protected void |
AbstractAutowireCapableBeanFactory.invokeInitMethods(String beanName,
Object bean,
RootBeanDefinition mbd)
Give a bean a chance to react now all its properties are set,
and a chance to know about its owning bean factory (this object).
|
boolean |
AbstractBeanFactory.isTypeMatch(String name,
Class<?> typeToMatch) |
boolean |
StaticListableBeanFactory.isTypeMatch(String name,
Class<?> typeToMatch) |
int |
PropertiesBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource,
String prefix)
Load bean definitions from the specified properties file.
|
int |
PropertiesBeanDefinitionReader.loadBeanDefinitions(Resource resource,
String prefix)
Load bean definitions from the specified properties file.
|
int |
AbstractBeanDefinitionReader.loadBeanDefinitions(String location,
Set<Resource> actualResources)
Load bean definitions from the specified resource location.
|
protected boolean |
DefaultListableBeanFactory.matchesBeanName(String beanName,
String candidateName)
Determine whether the given candidate name matches the bean name or the aliases
stored in this bean definition.
|
Set<E> |
ManagedSet.merge(Object parent) |
List<E> |
ManagedList.merge(Object parent) |
Object |
ManagedMap.merge(Object parent) |
Object |
ManagedProperties.merge(Object parent) |
protected void |
AbstractAutowireCapableBeanFactory.populateBean(String beanName,
RootBeanDefinition mbd,
BeanWrapper bw)
Populate the bean instance in the given BeanWrapper with the property values
from the bean definition.
|
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.
|
int |
PropertiesBeanDefinitionReader.registerBeanDefinitions(ResourceBundle rb,
String prefix)
Register bean definitions contained in a ResourceBundle.
|
void |
DefaultListableBeanFactory.registerResolvableDependency(Class<?> dependencyType,
Object autowiredValue) |
Class<?> |
AbstractBeanDefinition.resolveBeanClass(ClassLoader classLoader)
Determine the class of the wrapped bean, resolving it from a
specified class name if necessary.
|
Object |
AbstractAutowireCapableBeanFactory.resolveDependency(DependencyDescriptor descriptor,
String requestingBeanName) |
Object |
DefaultListableBeanFactory.resolveDependency(DependencyDescriptor descriptor,
String requestingBeanName,
Set<String> autowiredBeanNames,
TypeConverter typeConverter) |
Object |
DefaultListableBeanFactory.resolveDependency(DependencyDescriptor descriptor,
String requestingBeanName,
Set<String> autowiredBeanNames,
TypeConverter typeConverter) |
Object |
DefaultListableBeanFactory.resolveDependency(DependencyDescriptor descriptor,
String requestingBeanName,
Set<String> autowiredBeanNames,
TypeConverter typeConverter) |
String |
AbstractBeanFactory.resolveEmbeddedValue(String value) |
static BeanDefinitionBuilder |
BeanDefinitionBuilder.rootBeanDefinition(Class<?> beanClass,
String factoryMethodName)
Create a new
BeanDefinitionBuilder used to construct a RootBeanDefinition . |
static BeanDefinitionBuilder |
BeanDefinitionBuilder.rootBeanDefinition(String beanClassName,
String factoryMethodName)
Create a new
BeanDefinitionBuilder used to construct a RootBeanDefinition . |
void |
AbstractBeanDefinition.setBeanClass(Class<?> beanClass)
Specify the class for this bean.
|
void |
AbstractBeanDefinitionReader.setBeanClassLoader(ClassLoader beanClassLoader)
Set the ClassLoader to use for bean classes.
|
void |
AbstractBeanFactory.setBeanClassLoader(ClassLoader beanClassLoader) |
void |
AbstractBeanDefinition.setBeanClassName(String beanClassName)
Specify the bean class name of this bean definition.
|
void |
AbstractBeanFactory.setBeanExpressionResolver(BeanExpressionResolver resolver) |
void |
AbstractBeanDefinitionReader.setBeanNameGenerator(BeanNameGenerator beanNameGenerator)
Set the BeanNameGenerator to use for anonymous beans
(without explicit bean name specified).
|
void |
AbstractBeanFactory.setConversionService(ConversionService conversionService) |
void |
RootBeanDefinition.setDecoratedDefinition(BeanDefinitionHolder decoratedDefinition)
Register a target definition that is being decorated by this bean definition.
|
void |
PropertiesBeanDefinitionReader.setDefaultParentBean(String defaultParentBean)
Set the default parent bean for this bean factory.
|
void |
DefaultListableBeanFactory.setDependencyComparator(Comparator<Object> dependencyComparator)
Set a
Comparator for dependency Lists and arrays. |
void |
AbstractBeanDefinition.setDependsOn(String... dependsOn)
Set the names of the beans that this bean depends on being initialized.
|
void |
AbstractBeanDefinition.setDescription(String description)
Set a human-readable description of this bean definition.
|
void |
BeanDefinitionDefaults.setDestroyMethodName(String destroyMethodName)
Set the name of the default destroy method.
|
void |
AbstractBeanDefinition.setDestroyMethodName(String destroyMethodName)
Set the name of the destroy method.
|
BeanDefinitionBuilder |
BeanDefinitionBuilder.setDestroyMethodName(String methodName)
Set the destroy method for this definition.
|
void |
ManagedSet.setElementTypeName(String elementTypeName)
Set the default element type name (class name) to be used for this set.
|
void |
AbstractBeanDefinition.setFactoryBeanName(String factoryBeanName)
Specify the factory bean to use, if any.
|
void |
AbstractBeanDefinition.setFactoryMethodName(String factoryMethodName)
Specify a factory method, if any.
|
void |
BeanDefinitionDefaults.setInitMethodName(String initMethodName)
Set the name of the default initializer method.
|
void |
AbstractBeanDefinition.setInitMethodName(String initMethodName)
Set the name of the initializer method.
|
BeanDefinitionBuilder |
BeanDefinitionBuilder.setInitMethodName(String methodName)
Set the init method for this definition.
|
void |
AbstractBeanDefinition.setInstanceSupplier(Supplier<?> instanceSupplier)
Specify a callback for creating an instance of the bean,
as an alternative to a declaratively specified factory method.
|
void |
ManagedMap.setKeyTypeName(String keyTypeName)
Set the default key type name (class name) to be used for this map.
|
void |
AbstractAutowireCapableBeanFactory.setParameterNameDiscoverer(ParameterNameDiscoverer parameterNameDiscoverer)
Set the ParameterNameDiscoverer to use for resolving method parameter
names if needed (e.g.
|
void |
AbstractBeanFactory.setParentBeanFactory(BeanFactory parentBeanFactory) |
void |
GenericBeanDefinition.setParentName(String parentName) |
void |
RootBeanDefinition.setParentName(String parentName) |
void |
ChildBeanDefinition.setParentName(String parentName) |
void |
PropertiesBeanDefinitionReader.setPropertiesPersister(PropertiesPersister propertiesPersister)
Set the PropertiesPersister to use for parsing properties files.
|
void |
RootBeanDefinition.setQualifiedElement(AnnotatedElement qualifiedElement)
Specify the
AnnotatedElement defining qualifiers,
to be used instead of the target class or factory method. |
void |
AbstractBeanDefinition.setResource(Resource resource)
Set the resource that this bean definition came from
(for the purpose of showing context in case of errors).
|
void |
AbstractBeanDefinition.setResourceDescription(String resourceDescription)
Set a description of the resource that this bean definition
came from (for the purpose of showing context in case of errors).
|
void |
AbstractBeanDefinitionReader.setResourceLoader(ResourceLoader resourceLoader)
Set the ResourceLoader to use for resource locations.
|
void |
AbstractBeanDefinition.setScope(String scope)
Set the name of the target scope for the bean.
|
BeanDefinitionBuilder |
BeanDefinitionBuilder.setScope(String scope)
Set the scope of this definition.
|
void |
DefaultListableBeanFactory.setSerializationId(String serializationId)
Specify an id for serialization purposes, allowing this BeanFactory to be
deserialized from this id back into the BeanFactory object, if needed.
|
void |
ManagedSet.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
ManagedList.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
MethodOverride.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
ManagedMap.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
ManagedProperties.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
RootBeanDefinition.setTargetType(Class<?> targetType)
Specify the target type of this bean definition, if known in advance.
|
void |
AbstractBeanFactory.setTempClassLoader(ClassLoader tempClassLoader) |
void |
ManagedMap.setValueTypeName(String valueTypeName)
Set the default value type name (class name) to be used for this map.
|
Constructor and Description |
---|
AbstractAutowireCapableBeanFactory(BeanFactory parentBeanFactory)
Create a new AbstractAutowireCapableBeanFactory with the given parent.
|
AbstractBeanDefinition(ConstructorArgumentValues cargs,
MutablePropertyValues pvs)
Create a new AbstractBeanDefinition with the given
constructor argument values and property values.
|
AbstractBeanDefinition(ConstructorArgumentValues cargs,
MutablePropertyValues pvs)
Create a new AbstractBeanDefinition with the given
constructor argument values and property values.
|
AbstractBeanFactory(BeanFactory parentBeanFactory)
Create a new AbstractBeanFactory with the given parent.
|
DefaultListableBeanFactory(BeanFactory parentBeanFactory)
Create a new DefaultListableBeanFactory with the given parent.
|
LookupOverride(Method method,
String beanName)
Construct a new LookupOverride.
|
LookupOverride(String methodName,
String beanName)
Construct a new LookupOverride.
|
RootBeanDefinition(Class<?> beanClass)
Create a new RootBeanDefinition for a singleton.
|
RootBeanDefinition(Class<?> beanClass,
ConstructorArgumentValues cargs,
MutablePropertyValues pvs)
Create a new RootBeanDefinition for a singleton,
providing constructor arguments and property values.
|
RootBeanDefinition(Class<?> beanClass,
ConstructorArgumentValues cargs,
MutablePropertyValues pvs)
Create a new RootBeanDefinition for a singleton,
providing constructor arguments and property values.
|
RootBeanDefinition(Class<?> beanClass,
ConstructorArgumentValues cargs,
MutablePropertyValues pvs)
Create a new RootBeanDefinition for a singleton,
providing constructor arguments and property values.
|
RootBeanDefinition(Class<?> beanClass,
int autowireMode,
boolean dependencyCheck)
Create a new RootBeanDefinition for a singleton,
using the given autowire mode.
|
RootBeanDefinition(Class<T> beanClass,
String scope,
Supplier<T> instanceSupplier)
Create a new RootBeanDefinition for a scoped bean, constructing each instance
through calling the given supplier (possibly a lambda or method reference).
|
RootBeanDefinition(Class<T> beanClass,
String scope,
Supplier<T> instanceSupplier)
Create a new RootBeanDefinition for a scoped bean, constructing each instance
through calling the given supplier (possibly a lambda or method reference).
|
RootBeanDefinition(Class<T> beanClass,
Supplier<T> instanceSupplier)
Create a new RootBeanDefinition for a singleton bean, constructing each instance
through calling the given supplier (possibly a lambda or method reference).
|
RootBeanDefinition(Class<T> beanClass,
Supplier<T> instanceSupplier)
Create a new RootBeanDefinition for a singleton bean, constructing each instance
through calling the given supplier (possibly a lambda or method reference).
|
SimpleSecurityContextProvider(AccessControlContext acc)
Construct a new
SimpleSecurityContextProvider instance. |
Modifier and Type | Method and Description |
---|---|
protected BeanWiringInfoResolver |
BeanConfigurerSupport.createDefaultBeanWiringInfoResolver()
Create the default BeanWiringInfoResolver to be used if none was
specified explicitly.
|
String |
BeanWiringInfo.getBeanName()
Return the specific bean name that this BeanWiringInfo points to, if any.
|
BeanWiringInfo |
BeanWiringInfoResolver.resolveWiringInfo(Object beanInstance)
Resolve the BeanWiringInfo for the given bean instance.
|
Modifier and Type | Method and Description |
---|---|
BeanDefinitionHolder |
NamespaceHandlerSupport.decorate(Node node,
BeanDefinitionHolder definition,
ParserContext parserContext)
Decorates the supplied
Node by delegating to the BeanDefinitionDecorator that
is registered to handle that Node . |
BeanDefinitionHolder |
NamespaceHandler.decorate(Node source,
BeanDefinitionHolder definition,
ParserContext parserContext)
Parse the specified
Node and decorate the supplied
BeanDefinitionHolder , returning the decorated definition. |
protected Object |
DefaultBeanDefinitionDocumentReader.extractSource(Element ele)
Invoke the
SourceExtractor
to pull the source metadata from the supplied Element . |
protected Object |
BeanDefinitionParserDelegate.extractSource(Element ele)
Invoke the
SourceExtractor
to pull the source metadata from the supplied Element . |
Object |
ParserContext.extractSource(Object sourceCandidate) |
String |
DocumentDefaultsDefinition.getAutowire()
Return the default autowire setting for the document that's currently parsed.
|
String[] |
BeanDefinitionParserDelegate.getAutowireCandidatePatterns()
Return any patterns provided in the 'default-autowire-candidates'
attribute of the top-level
<beans/> element. |
String |
DocumentDefaultsDefinition.getAutowireCandidates()
Return the default autowire-candidate pattern for the document that's currently parsed.
|
protected Class<?> |
AbstractSingleBeanDefinitionParser.getBeanClass(Element element)
Determine the bean class corresponding to the supplied
Element . |
ClassLoader |
XmlReaderContext.getBeanClassLoader()
Return the bean class loader to use, if any.
|
protected String |
AbstractSingleBeanDefinitionParser.getBeanClassName(Element element)
Determine the bean class name corresponding to the supplied
Element . |
BeanDefinition |
ParserContext.getContainingBeanDefinition() |
CompositeComponentDefinition |
ParserContext.getContainingComponent() |
String |
DocumentDefaultsDefinition.getDestroyMethod()
Return the default destroy-method setting for the document that's currently parsed.
|
String |
DocumentDefaultsDefinition.getInitMethod()
Return the default init-method setting for the document that's currently parsed.
|
String |
DocumentDefaultsDefinition.getLazyInit()
Return the default lazy-init flag for the document that's currently parsed.
|
String |
DocumentDefaultsDefinition.getMerge()
Return the default merge setting for the document that's currently parsed.
|
String |
BeanDefinitionParserDelegate.getNamespaceURI(Node node)
Get the namespace URI for the supplied node.
|
protected String |
AbstractSingleBeanDefinitionParser.getParentName(Element element)
Determine the name for the parent of the currently parsed bean,
in case of the current bean being defined as a child bean.
|
ResourceLoader |
XmlReaderContext.getResourceLoader()
Return the resource loader to use, if any.
|
Object |
DocumentDefaultsDefinition.getSource() |
BeanDefinition |
NamespaceHandlerSupport.parse(Element element,
ParserContext parserContext)
Parses the supplied
Element by delegating to the BeanDefinitionParser that is
registered for that Element . |
BeanDefinition |
AbstractBeanDefinitionParser.parse(Element element,
ParserContext parserContext) |
BeanDefinition |
NamespaceHandler.parse(Element element,
ParserContext parserContext)
Parse the specified
Element and register any resulting
BeanDefinitions with the
BeanDefinitionRegistry
that is embedded in the supplied ParserContext . |
BeanDefinition |
SimplePropertyNamespaceHandler.parse(Element element,
ParserContext parserContext) |
BeanDefinition |
BeanDefinitionParser.parse(Element element,
ParserContext parserContext)
Parse the specified
Element and register the resulting
BeanDefinition(s) with the
BeanDefinitionRegistry
embedded in the supplied ParserContext . |
BeanDefinition |
SimpleConstructorNamespaceHandler.parse(Element element,
ParserContext parserContext) |
BeanDefinitionHolder |
BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele)
Parses the supplied
<bean> element. |
BeanDefinitionHolder |
BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele,
BeanDefinition containingBean)
Parses the supplied
<bean> element. |
AbstractBeanDefinition |
BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele,
String beanName,
BeanDefinition containingBean)
Parse the bean definition itself, without regard to name or aliases.
|
BeanDefinition |
BeanDefinitionParserDelegate.parseCustomElement(Element ele)
Parse a custom element (outside of the default namespace).
|
BeanDefinition |
BeanDefinitionParserDelegate.parseCustomElement(Element ele,
BeanDefinition containingBd)
Parse a custom element (outside of the default namespace).
|
Object |
BeanDefinitionParserDelegate.parseIdRefElement(Element ele)
Return a typed String value Object for the given 'idref' element.
|
protected abstract AbstractBeanDefinition |
AbstractBeanDefinitionParser.parseInternal(Element element,
ParserContext parserContext)
Central template method to actually parse the supplied
Element
into one or more BeanDefinitions . |
protected Object |
BeanDefinitionParserDelegate.parseKeyElement(Element keyEle,
BeanDefinition bd,
String defaultKeyTypeName)
Parse a key sub-element of a map element.
|
Object |
BeanDefinitionParserDelegate.parsePropertySubElement(Element ele,
BeanDefinition bd)
Parse a value, ref or collection sub-element of a property or
constructor-arg element.
|
Object |
BeanDefinitionParserDelegate.parsePropertySubElement(Element ele,
BeanDefinition bd,
String defaultValueType)
Parse a value, ref or collection sub-element of a property or
constructor-arg element.
|
Object |
BeanDefinitionParserDelegate.parsePropertyValue(Element ele,
BeanDefinition bd,
String propertyName)
Get the value of a property element.
|
NamespaceHandler |
NamespaceHandlerResolver.resolve(String namespaceUri)
Resolve the namespace URI and return the located
NamespaceHandler
implementation. |
NamespaceHandler |
DefaultNamespaceHandlerResolver.resolve(String namespaceUri)
Locate the
NamespaceHandler for the supplied namespace URI
from the configured mappings. |
InputSource |
ResourceEntityResolver.resolveEntity(String publicId,
String systemId) |
InputSource |
PluggableSchemaResolver.resolveEntity(String publicId,
String systemId) |
InputSource |
DelegatingEntityResolver.resolveEntity(String publicId,
String systemId) |
InputSource |
BeansDtdResolver.resolveEntity(String publicId,
String systemId) |
Modifier and Type | Method and Description |
---|---|
protected TypedStringValue |
BeanDefinitionParserDelegate.buildTypedStringValue(String value,
String targetTypeName)
Build a typed String value Object for the given raw value.
|
protected AbstractBeanDefinition |
BeanDefinitionParserDelegate.createBeanDefinition(String className,
String parentName)
Create a bean definition for the given class name and parent name.
|
protected AbstractBeanDefinition |
BeanDefinitionParserDelegate.createBeanDefinition(String className,
String parentName)
Create a bean definition for the given class name and parent name.
|
protected BeanDefinitionParserDelegate |
DefaultBeanDefinitionDocumentReader.createDelegate(XmlReaderContext readerContext,
Element root,
BeanDefinitionParserDelegate parentDelegate) |
protected DocumentBuilder |
DefaultDocumentLoader.createDocumentBuilder(DocumentBuilderFactory factory,
EntityResolver entityResolver,
ErrorHandler errorHandler)
Create a JAXP DocumentBuilder that this bean definition reader
will use for parsing XML documents.
|
protected DocumentBuilder |
DefaultDocumentLoader.createDocumentBuilder(DocumentBuilderFactory factory,
EntityResolver entityResolver,
ErrorHandler errorHandler)
Create a JAXP DocumentBuilder that this bean definition reader
will use for parsing XML documents.
|
BeanDefinitionHolder |
BeanDefinitionParserDelegate.decorateBeanDefinitionIfRequired(Element ele,
BeanDefinitionHolder originalDef,
BeanDefinition containingBd)
Decorate the given bean definition through a namespace handler, if applicable.
|
BeanDefinitionHolder |
BeanDefinitionParserDelegate.decorateIfRequired(Node node,
BeanDefinitionHolder originalDef,
BeanDefinition containingBd)
Decorate the given bean definition through a namespace handler,
if applicable.
|
void |
BeanDefinitionParserDelegate.initDefaults(Element root,
BeanDefinitionParserDelegate parent)
Initialize the default lazy-init, autowire, dependency check settings,
init-method, destroy-method and merge settings.
|
boolean |
BeanDefinitionParserDelegate.isDefaultNamespace(String namespaceUri)
Determine whether the given URI indicates the default namespace.
|
int |
XmlBeanDefinitionReader.loadBeanDefinitions(InputSource inputSource,
String resourceDescription)
Load bean definitions from the specified XML file.
|
Object |
BeanDefinitionParserDelegate.parseArrayElement(Element arrayEle,
BeanDefinition bd)
Parse an array element.
|
AbstractBeanDefinition |
BeanDefinitionParserDelegate.parseBeanDefinitionAttributes(Element ele,
String beanName,
BeanDefinition containingBean,
AbstractBeanDefinition bd)
Apply the attributes of the given bean element to the given bean * definition.
|
BeanDefinitionHolder |
BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele,
BeanDefinition containingBean)
Parses the supplied
<bean> element. |
AbstractBeanDefinition |
BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele,
String beanName,
BeanDefinition containingBean)
Parse the bean definition itself, without regard to name or aliases.
|
protected void |
BeanDefinitionParserDelegate.parseCollectionElements(NodeList elementNodes,
Collection<Object> target,
BeanDefinition bd,
String defaultElementType) |
BeanDefinition |
BeanDefinitionParserDelegate.parseCustomElement(Element ele,
BeanDefinition containingBd)
Parse a custom element (outside of the default namespace).
|
protected Object |
BeanDefinitionParserDelegate.parseKeyElement(Element keyEle,
BeanDefinition bd,
String defaultKeyTypeName)
Parse a key sub-element of a map element.
|
List<Object> |
BeanDefinitionParserDelegate.parseListElement(Element collectionEle,
BeanDefinition bd)
Parse a list element.
|
Map<Object,Object> |
BeanDefinitionParserDelegate.parseMapElement(Element mapEle,
BeanDefinition bd)
Parse a map element.
|
Object |
BeanDefinitionParserDelegate.parsePropertySubElement(Element ele,
BeanDefinition bd)
Parse a value, ref or collection sub-element of a property or
constructor-arg element.
|
Object |
BeanDefinitionParserDelegate.parsePropertySubElement(Element ele,
BeanDefinition bd,
String defaultValueType)
Parse a value, ref or collection sub-element of a property or
constructor-arg element.
|
Object |
BeanDefinitionParserDelegate.parsePropertySubElement(Element ele,
BeanDefinition bd,
String defaultValueType)
Parse a value, ref or collection sub-element of a property or
constructor-arg element.
|
Object |
BeanDefinitionParserDelegate.parsePropertyValue(Element ele,
BeanDefinition bd,
String propertyName)
Get the value of a property element.
|
Set<Object> |
BeanDefinitionParserDelegate.parseSetElement(Element collectionEle,
BeanDefinition bd)
Parse a set element.
|
Object |
BeanDefinitionParserDelegate.parseValueElement(Element ele,
String defaultTypeName)
Return a typed String value Object for the given value element.
|
protected void |
BeanDefinitionParserDelegate.populateDefaults(DocumentDefaultsDefinition defaults,
DocumentDefaultsDefinition parentDefaults,
Element root)
Populate the given DocumentDefaultsDefinition instance with the default lazy-init,
autowire, dependency check settings, init-method, destroy-method and merge settings.
|
InputSource |
ResourceEntityResolver.resolveEntity(String publicId,
String systemId) |
InputSource |
ResourceEntityResolver.resolveEntity(String publicId,
String systemId) |
InputSource |
PluggableSchemaResolver.resolveEntity(String publicId,
String systemId) |
InputSource |
PluggableSchemaResolver.resolveEntity(String publicId,
String systemId) |
InputSource |
DelegatingEntityResolver.resolveEntity(String publicId,
String systemId) |
InputSource |
DelegatingEntityResolver.resolveEntity(String publicId,
String systemId) |
InputSource |
BeansDtdResolver.resolveEntity(String publicId,
String systemId) |
InputSource |
BeansDtdResolver.resolveEntity(String publicId,
String systemId) |
void |
DocumentDefaultsDefinition.setAutowire(String autowire)
Set the default autowire setting for the document that's currently parsed.
|
void |
DocumentDefaultsDefinition.setAutowireCandidates(String autowireCandidates)
Set the default autowire-candidate pattern for the document that's currently parsed.
|
void |
DocumentDefaultsDefinition.setDestroyMethod(String destroyMethod)
Set the default destroy-method setting for the document that's currently parsed.
|
void |
XmlBeanDefinitionReader.setDocumentLoader(DocumentLoader documentLoader)
Specify the
DocumentLoader to use. |
void |
XmlBeanDefinitionReader.setEntityResolver(EntityResolver entityResolver)
Set a SAX entity resolver to be used for parsing.
|
void |
XmlBeanDefinitionReader.setEventListener(ReaderEventListener eventListener)
Specify which
ReaderEventListener to use. |
void |
DocumentDefaultsDefinition.setInitMethod(String initMethod)
Set the default init-method setting for the document that's currently parsed.
|
void |
DocumentDefaultsDefinition.setLazyInit(String lazyInit)
Set the default lazy-init flag for the document that's currently parsed.
|
void |
DocumentDefaultsDefinition.setMerge(String merge)
Set the default merge setting for the document that's currently parsed.
|
void |
XmlBeanDefinitionReader.setNamespaceHandlerResolver(NamespaceHandlerResolver namespaceHandlerResolver)
Specify the
NamespaceHandlerResolver to use. |
void |
XmlBeanDefinitionReader.setProblemReporter(ProblemReporter problemReporter)
Specify which
ProblemReporter to use. |
void |
DocumentDefaultsDefinition.setSource(Object source)
Set the configuration source
Object for this metadata element. |
void |
XmlBeanDefinitionReader.setSourceExtractor(SourceExtractor sourceExtractor)
Specify the
SourceExtractor to use. |
Constructor and Description |
---|
DefaultNamespaceHandlerResolver(ClassLoader classLoader)
Create a new
DefaultNamespaceHandlerResolver using the
default mapping file location. |
DefaultNamespaceHandlerResolver(ClassLoader classLoader,
String handlerMappingsLocation)
Create a new
DefaultNamespaceHandlerResolver using the
supplied mapping file location. |
DelegatingEntityResolver(ClassLoader classLoader)
Create a new DelegatingEntityResolver that delegates to
a default
BeansDtdResolver and a default PluggableSchemaResolver . |
ParserContext(XmlReaderContext readerContext,
BeanDefinitionParserDelegate delegate,
BeanDefinition containingBeanDefinition) |
PluggableSchemaResolver(ClassLoader classLoader)
Loads the schema URL -> schema file location mappings using the default
mapping file pattern "META-INF/spring.schemas".
|
PluggableSchemaResolver(ClassLoader classLoader,
String schemaMappingsLocation)
Loads the schema URL -> schema file location mappings using the given
mapping file pattern.
|
Modifier and Type | Method and Description |
---|---|
String |
CustomCollectionEditor.getAsText()
This implementation returns
null to indicate that
there is no appropriate text representation. |
String |
InputStreamEditor.getAsText()
This implementation returns
null to indicate that
there is no appropriate text representation. |
String |
CustomMapEditor.getAsText()
This implementation returns
null to indicate that
there is no appropriate text representation. |
String |
ReaderEditor.getAsText()
This implementation returns
null to indicate that
there is no appropriate text representation. |
Modifier and Type | Method and Description |
---|---|
void |
PropertiesEditor.setAsText(String text)
Convert
String into Properties , considering it as
properties content. |
void |
CharacterEditor.setAsText(String text) |
void |
CustomBooleanEditor.setAsText(String text) |
void |
PatternEditor.setAsText(String text) |
void |
StringTrimmerEditor.setAsText(String text) |
void |
CustomDateEditor.setAsText(String text)
Parse the Date from the given text, using the specified DateFormat.
|
void |
ByteArrayPropertyEditor.setAsText(String text) |
void |
CharArrayPropertyEditor.setAsText(String text) |
void |
CustomCollectionEditor.setValue(Object value)
Convert the given value to a Collection of the target type.
|
void |
CustomNumberEditor.setValue(Object value)
Coerce a Number value into the required target class, if necessary.
|
void |
CustomMapEditor.setValue(Object value)
Convert the given value to a Map of the target type.
|
Constructor and Description |
---|
ClassArrayEditor(ClassLoader classLoader)
Create a default
ClassArrayEditor , using the given
ClassLoader . |
ClassEditor(ClassLoader classLoader)
Create a default ClassEditor, using the given ClassLoader.
|
CustomBooleanEditor(String trueString,
String falseString,
boolean allowEmpty)
Create a new CustomBooleanEditor instance,
with configurable String values for true and false.
|
CustomBooleanEditor(String trueString,
String falseString,
boolean allowEmpty)
Create a new CustomBooleanEditor instance,
with configurable String values for true and false.
|
CustomNumberEditor(Class<? extends Number> numberClass,
NumberFormat numberFormat,
boolean allowEmpty)
Create a new CustomNumberEditor instance, using the given NumberFormat
for parsing and rendering.
|
StringArrayPropertyEditor(String separator,
String charsToDelete,
boolean emptyArrayAsNull)
Create a new StringArrayPropertyEditor with the given separator.
|
StringArrayPropertyEditor(String separator,
String charsToDelete,
boolean emptyArrayAsNull,
boolean trimValues)
Create a new StringArrayPropertyEditor with the given separator.
|
URIEditor(ClassLoader classLoader)
Create a new URIEditor, using the given ClassLoader to resolve
"classpath:" locations into physical resource URLs.
|
URIEditor(ClassLoader classLoader,
boolean encode)
Create a new URIEditor, using the given ClassLoader to resolve
"classpath:" locations into physical resource URLs.
|
Modifier and Type | Method and Description |
---|---|
protected Method |
ArgumentConvertingMethodInvoker.doFindMatchingMethod(Object[] arguments)
Actually find a method with matching parameter type, i.e.
|
Date |
PagedListHolder.getRefreshDate()
Return the last time the list has been fetched from the source provider.
|
SortDefinition |
PagedListHolder.getSort()
Return the sort definition for this holder.
|
TypeConverter |
ArgumentConvertingMethodInvoker.getTypeConverter()
Return the TypeConverter used for argument type conversion.
|
Modifier and Type | Method and Description |
---|---|
void |
PagedListHolder.setSort(SortDefinition sort)
Set the sort definition for this holder.
|
void |
ArgumentConvertingMethodInvoker.setTypeConverter(TypeConverter typeConverter)
Set a TypeConverter to use for argument type conversion.
|
Modifier and Type | Method and Description |
---|---|
Object |
Cache.ValueWrapper.get()
Return the actual value in the cache.
|
Cache.ValueWrapper |
Cache.get(Object key)
Return the value to which this cache maps the specified key.
|
<T> T |
Cache.get(Object key,
Callable<T> valueLoader)
Return the value to which this cache maps the specified key, obtaining
that value from
valueLoader if necessary. |
<T> T |
Cache.get(Object key,
Class<T> type)
Return the value to which this cache maps the specified key,
generically specifying a type that return value will be cast to.
|
Cache |
CacheManager.getCache(String name)
Get the cache associated with the given name.
|
Object |
Cache.ValueRetrievalException.getKey() |
Cache.ValueWrapper |
Cache.putIfAbsent(Object key,
Object value)
Atomically associate the specified value with the specified key in this cache
if it is not set already.
|
Modifier and Type | Method and Description |
---|---|
<T> T |
Cache.get(Object key,
Class<T> type)
Return the value to which this cache maps the specified key,
generically specifying a type that return value will be cast to.
|
void |
Cache.put(Object key,
Object value)
Associate the specified value with the specified key in this cache.
|
Cache.ValueWrapper |
Cache.putIfAbsent(Object key,
Object value)
Atomically associate the specified value with the specified key in this cache
if it is not set already.
|
Constructor and Description |
---|
ValueRetrievalException(Object key,
Callable<?> loader,
Throwable ex) |
Modifier and Type | Field and Description |
---|---|
protected CacheManager |
AbstractCachingConfiguration.cacheManager |
protected CacheResolver |
AbstractCachingConfiguration.cacheResolver |
protected AnnotationAttributes |
AbstractCachingConfiguration.enableCaching |
protected CacheErrorHandler |
AbstractCachingConfiguration.errorHandler |
protected KeyGenerator |
AbstractCachingConfiguration.keyGenerator |
Modifier and Type | Method and Description |
---|---|
CacheManager |
CachingConfigurerSupport.cacheManager() |
CacheManager |
CachingConfigurer.cacheManager()
Return the cache manager bean to use for annotation-driven cache
management.
|
CacheResolver |
CachingConfigurerSupport.cacheResolver() |
CacheResolver |
CachingConfigurer.cacheResolver()
Return the
CacheResolver bean to use to resolve regular caches for
annotation-driven cache management. |
protected Collection<CacheOperation> |
AnnotationCacheOperationSource.determineCacheOperations(AnnotationCacheOperationSource.CacheOperationProvider provider)
Determine the cache operation(s) for the given
AnnotationCacheOperationSource.CacheOperationProvider . |
CacheErrorHandler |
CachingConfigurerSupport.errorHandler() |
CacheErrorHandler |
CachingConfigurer.errorHandler()
Return the
CacheErrorHandler to use to handle cache-related errors. |
protected Collection<CacheOperation> |
AnnotationCacheOperationSource.findCacheOperations(Class<?> clazz) |
protected Collection<CacheOperation> |
AnnotationCacheOperationSource.findCacheOperations(Method method) |
Collection<CacheOperation> |
AnnotationCacheOperationSource.CacheOperationProvider.getCacheOperations(CacheAnnotationParser parser)
Return the
CacheOperation instance(s) provided by the specified parser. |
KeyGenerator |
CachingConfigurerSupport.keyGenerator() |
KeyGenerator |
CachingConfigurer.keyGenerator()
Return the key generator bean to use for annotation-driven cache management.
|
Collection<CacheOperation> |
CacheAnnotationParser.parseCacheAnnotations(Class<?> type)
Parse the cache definition for the given class,
based on an annotation type understood by this parser.
|
Collection<CacheOperation> |
SpringCacheAnnotationParser.parseCacheAnnotations(Class<?> type) |
Collection<CacheOperation> |
CacheAnnotationParser.parseCacheAnnotations(Method method)
Parse the cache definition for the given method,
based on an annotation type understood by this parser.
|
Collection<CacheOperation> |
SpringCacheAnnotationParser.parseCacheAnnotations(Method method) |
Modifier and Type | Method and Description |
---|---|
Cache.ValueWrapper |
CaffeineCache.get(Object key) |
<T> T |
CaffeineCache.get(Object key,
Callable<T> valueLoader) |
Cache |
CaffeineCacheManager.getCache(String name) |
protected Object |
CaffeineCache.lookup(Object key) |
Cache.ValueWrapper |
CaffeineCache.putIfAbsent(Object key,
Object value) |
Modifier and Type | Method and Description |
---|---|
void |
CaffeineCache.put(Object key,
Object value) |
Cache.ValueWrapper |
CaffeineCache.putIfAbsent(Object key,
Object value) |
void |
CaffeineCacheManager.setCacheNames(Collection<String> cacheNames)
Specify the set of cache names for this CacheManager's 'static' mode.
|
Modifier and Type | Method and Description |
---|---|
<T> T |
ConcurrentMapCache.get(Object key,
Callable<T> valueLoader) |
Cache |
ConcurrentMapCacheManager.getCache(String name) |
ConcurrentMapCache |
ConcurrentMapCacheFactoryBean.getObject() |
protected Object |
ConcurrentMapCache.lookup(Object key) |
Cache.ValueWrapper |
ConcurrentMapCache.putIfAbsent(Object key,
Object value) |
Modifier and Type | Method and Description |
---|---|
protected Object |
ConcurrentMapCache.fromStoreValue(Object storeValue) |
void |
ConcurrentMapCache.put(Object key,
Object value) |
Cache.ValueWrapper |
ConcurrentMapCache.putIfAbsent(Object key,
Object value) |
void |
ConcurrentMapCacheManager.setCacheNames(Collection<String> cacheNames)
Specify the set of cache names for this CacheManager's 'static' mode.
|
protected Object |
ConcurrentMapCache.toStoreValue(Object userValue) |
Constructor and Description |
---|
ConcurrentMapCache(String name,
ConcurrentMap<Object,Object> store,
boolean allowNullValues,
SerializationDelegate serialization)
Create a new ConcurrentMapCache with the specified name and the
given internal
ConcurrentMap to use. |
Modifier and Type | Method and Description |
---|---|
Cache.ValueWrapper |
EhCacheCache.get(Object key) |
<T> T |
EhCacheCache.get(Object key,
Callable<T> valueLoader) |
<T> T |
EhCacheCache.get(Object key,
Class<T> type) |
CacheManager |
EhCacheCacheManager.getCacheManager()
Return the backing EhCache
CacheManager . |
CacheManager |
EhCacheManagerFactoryBean.getObject() |
Ehcache |
EhCacheFactoryBean.getObject() |
Cache.ValueWrapper |
EhCacheCache.putIfAbsent(Object key,
Object value) |
Modifier and Type | Method and Description |
---|---|
<T> T |
EhCacheCache.get(Object key,
Class<T> type) |
void |
EhCacheCache.put(Object key,
Object value) |
Cache.ValueWrapper |
EhCacheCache.putIfAbsent(Object key,
Object value) |
void |
EhCacheCacheManager.setCacheManager(CacheManager cacheManager)
Set the backing EhCache
CacheManager . |
Modifier and Type | Method and Description |
---|---|
protected Cache.ValueWrapper |
AbstractCacheInvoker.doGet(Cache cache,
Object key)
Execute
Cache.get(Object) on the specified Cache and
invoke the error handler if an exception occurs. |
protected Object |
CacheAspectSupport.execute(CacheOperationInvoker invoker,
Object target,
Method method,
Object[] args) |
protected abstract Collection<CacheOperation> |
AbstractFallbackCacheOperationSource.findCacheOperations(Class<?> clazz)
Subclasses need to implement this to return the caching attribute for the
given class, if any.
|
protected abstract Collection<CacheOperation> |
AbstractFallbackCacheOperationSource.findCacheOperations(Method method)
Subclasses need to implement this to return the caching attribute for the
given method, if any.
|
protected Object |
CacheAspectSupport.CacheOperationContext.generateKey(Object result)
Compute the key for the given caching operation.
|
protected abstract Collection<String> |
AbstractCacheResolver.getCacheNames(CacheOperationInvocationContext<?> context)
Provide the name of the cache(s) to resolve against the current cache manager.
|
Collection<CacheOperation> |
CompositeCacheOperationSource.getCacheOperations(Method method,
Class<?> targetClass) |
Collection<CacheOperation> |
NameMatchCacheOperationSource.getCacheOperations(Method method,
Class<?> targetClass) |
Collection<CacheOperation> |
AbstractFallbackCacheOperationSource.getCacheOperations(Method method,
Class<?> targetClass)
Determine the caching attribute for this method invocation.
|
Collection<CacheOperation> |
CacheOperationSource.getCacheOperations(Method method,
Class<?> targetClass)
Return the collection of cache operations for this method,
or
null if the method contains no cacheable annotations. |
CacheOperationSource |
CacheAspectSupport.getCacheOperationSource()
Return the CacheOperationSource for this cache aspect.
|
CacheResolver |
CacheAspectSupport.
|