Uses of Class
org.springframework.lang.Nullable

Packages that use Nullable

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	Encoder and Decoder abstractions to convert between a reactive stream of bytes and Java objects.
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	Provides implementations of Encoder and Decoder for web use.
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 MBeanServers 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.

Uses of Nullable in org.springframework.aop

Methods in org.springframework.aop with annotations of type Nullable

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.

Method parameters in org.springframework.aop with annotations of type Nullable

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.

Uses of Nullable in org.springframework.aop.aspectj

Methods in org.springframework.aop.aspectj with annotations of type Nullable

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.

Method parameters in org.springframework.aop.aspectj with annotations of type Nullable

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 parameters in org.springframework.aop.aspectj with annotations of type Nullable

Constructor and Description
AspectJAdviceParameterNameDiscoverer(String pointcutExpression) Create a new discoverer that attempts to discover parameter names from the given pointcut expression.

Uses of Nullable in org.springframework.aop.aspectj.annotation

Methods in org.springframework.aop.aspectj.annotation with annotations of type Nullable

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 parameters in org.springframework.aop.aspectj.annotation with annotations of type Nullable

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.

Uses of Nullable in org.springframework.aop.config

Methods in org.springframework.aop.config with annotations of type Nullable

Modifier and Type	Method and Description
ClassLoader	SimpleBeanFactoryAwareAspectInstanceFactory.getAspectClassLoader()
Method	MethodLocatingFactoryBean.getObject()
Object	AdvisorComponentDefinition.getSource()
Object	PointcutComponentDefinition.getSource()
static BeanDefinition	AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry)
static BeanDefinition	AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source)
static BeanDefinition	AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry)
static BeanDefinition	AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source)
static BeanDefinition	AopConfigUtils.registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry)
static BeanDefinition	AopConfigUtils.registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source)

Method parameters in org.springframework.aop.config with annotations of type Nullable

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 parameters in org.springframework.aop.config with annotations of type Nullable

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)

Uses of Nullable in org.springframework.aop.framework

Fields in org.springframework.aop.framework with annotations of type Nullable

Modifier and Type	Field and Description
protected Advisor	AbstractAdvisingBeanPostProcessor.advisor
protected Object	ReflectiveMethodInvocation.target

Methods in org.springframework.aop.framework with annotations of type Nullable

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

Method parameters in org.springframework.aop.framework with annotations of type Nullable

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 parameters in org.springframework.aop.framework with annotations of type Nullable

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.

Uses of Nullable in org.springframework.aop.framework.autoproxy

Fields in org.springframework.aop.framework.autoproxy with annotations of type Nullable

Modifier and Type	Field and Description
protected static Object[]	AbstractAutoProxyCreator.DO_NOT_PROXY Convenience constant for subclasses: Return value for "do not proxy".

Methods in org.springframework.aop.framework.autoproxy with annotations of type Nullable

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)

Method parameters in org.springframework.aop.framework.autoproxy with annotations of type Nullable

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.

Uses of Nullable in org.springframework.aop.framework.autoproxy.target

Methods in org.springframework.aop.framework.autoproxy.target with annotations of type Nullable

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)

Uses of Nullable in org.springframework.aop.interceptor

Fields in org.springframework.aop.interceptor with annotations of type Nullable

Modifier and Type	Field and Description
protected Log	AbstractTraceInterceptor.defaultLogger The default Log instance used to write trace messages.

Methods in org.springframework.aop.interceptor with annotations of type Nullable

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.

Method parameters in org.springframework.aop.interceptor with annotations of type Nullable

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 parameters in org.springframework.aop.interceptor with annotations of type Nullable

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.

Uses of Nullable in org.springframework.aop.scope

Method parameters in org.springframework.aop.scope with annotations of type Nullable

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.

Uses of Nullable in org.springframework.aop.support

Methods in org.springframework.aop.support with annotations of type Nullable

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.

Method parameters in org.springframework.aop.support with annotations of type Nullable

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 parameters in org.springframework.aop.support with annotations of type Nullable

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.

Uses of Nullable in org.springframework.aop.support.annotation

Method parameters in org.springframework.aop.support.annotation with annotations of type Nullable

Modifier and Type	Method and Description
boolean	AnnotationMethodMatcher.matches(Method method, Class<?> targetClass)

Constructor parameters in org.springframework.aop.support.annotation with annotations of type Nullable

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.

Uses of Nullable in org.springframework.aop.target

Methods in org.springframework.aop.target with annotations of type Nullable

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.

Method parameters in org.springframework.aop.target with annotations of type Nullable

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.

Uses of Nullable in org.springframework.aop.target.dynamic

Fields in org.springframework.aop.target.dynamic with annotations of type Nullable

Modifier and Type	Field and Description
protected Object	AbstractRefreshableTargetSource.targetObject

Methods in org.springframework.aop.target.dynamic with annotations of type Nullable

Modifier and Type	Method and Description
Object	AbstractRefreshableTargetSource.getTarget()

Uses of Nullable in org.springframework.beans

Fields in org.springframework.beans with annotations of type Nullable

Modifier and Type	Field and Description
String[]	AbstractNestablePropertyAccessor.PropertyTokenHolder.keys

Methods in org.springframework.beans with annotations of type Nullable

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.

Method parameters in org.springframework.beans with annotations of type Nullable

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 parameters in org.springframework.beans with annotations of type Nullable

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.

Uses of Nullable in org.springframework.beans.annotation

Method parameters in org.springframework.beans.annotation with annotations of type Nullable

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.

Uses of Nullable in org.springframework.beans.factory

Fields in org.springframework.beans.factory with annotations of type Nullable

Modifier and Type	Field and Description
protected Field	InjectionPoint.field
protected MethodParameter	InjectionPoint.methodParameter

Methods in org.springframework.beans.factory with annotations of type Nullable

Modifier and Type	Method and Description
<A extends Annotation> A	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> A	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.

Method parameters in org.springframework.beans.factory with annotations of type Nullable

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 parameters in org.springframework.beans.factory with annotations of type Nullable

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.

Uses of Nullable in org.springframework.beans.factory.annotation

Fields in org.springframework.beans.factory.annotation with annotations of type Nullable

Modifier and Type	Field and Description
protected PropertyDescriptor	InjectionMetadata.InjectedElement.pd
protected Boolean	InjectionMetadata.InjectedElement.skip

Methods in org.springframework.beans.factory.annotation with annotations of type Nullable

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)

Method parameters in org.springframework.beans.factory.annotation with annotations of type Nullable

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 parameters in org.springframework.beans.factory.annotation with annotations of type Nullable

Constructor and Description
InjectedElement(Member member, PropertyDescriptor pd)

Uses of Nullable in org.springframework.beans.factory.config

Fields in org.springframework.beans.factory.config with annotations of type Nullable

Modifier and Type	Field and Description
protected String	PlaceholderConfigurerSupport.nullValue
protected String	PlaceholderConfigurerSupport.valueSeparator Defaults to ":"

Methods in org.springframework.beans.factory.config with annotations of type Nullable

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)

Method parameters in org.springframework.beans.factory.config with annotations of type Nullable

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 parameters in org.springframework.beans.factory.config with annotations of type Nullable

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.

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

Methods in org.springframework.beans.factory.parsing with annotations of type Nullable

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.

Method parameters in org.springframework.beans.factory.parsing with annotations of type Nullable

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 parameters in org.springframework.beans.factory.parsing with annotations of type Nullable

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.

Uses of Nullable in org.springframework.beans.factory.serviceloader

Methods in org.springframework.beans.factory.serviceloader with annotations of type Nullable

Modifier and Type	Method and Description
Class<?>	ServiceFactoryBean.getObjectType()
Class<?>	AbstractServiceLoaderBasedFactoryBean.getServiceType() Return the desired service type.

Method parameters in org.springframework.beans.factory.serviceloader with annotations of type Nullable

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

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

Methods in org.springframework.beans.factory.support with annotations of type Nullable

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> A	DefaultListableBeanFactory.findAnnotationOnBean(String beanName, Class<A> annotationType)
<A extends Annotation> A	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)

Method parameters in org.springframework.beans.factory.support with annotations of type Nullable

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 parameters in org.springframework.beans.factory.support with annotations of type Nullable

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.

Uses of Nullable in org.springframework.beans.factory.wiring

Methods in org.springframework.beans.factory.wiring with annotations of type Nullable

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.

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

Methods in org.springframework.beans.factory.xml with annotations of type Nullable

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)

Method parameters in org.springframework.beans.factory.xml with annotations of type Nullable

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 parameters in org.springframework.beans.factory.xml with annotations of type Nullable

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.

Uses of Nullable in org.springframework.beans.propertyeditors

Methods in org.springframework.beans.propertyeditors with annotations of type Nullable

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.

Method parameters in org.springframework.beans.propertyeditors with annotations of type Nullable

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 parameters in org.springframework.beans.propertyeditors with annotations of type Nullable

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.

Uses of Nullable in org.springframework.beans.support

Methods in org.springframework.beans.support with annotations of type Nullable

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.

Method parameters in org.springframework.beans.support with annotations of type Nullable

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.

Uses of Nullable in org.springframework.cache

Methods in org.springframework.cache with annotations of type Nullable

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.

Method parameters in org.springframework.cache with annotations of type Nullable

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 parameters in org.springframework.cache with annotations of type Nullable

Constructor and Description
ValueRetrievalException(Object key, Callable<?> loader, Throwable ex)

Uses of Nullable in org.springframework.cache.annotation

Fields in org.springframework.cache.annotation with annotations of type Nullable

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

Methods in org.springframework.cache.annotation with annotations of type Nullable

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)

Uses of Nullable in org.springframework.cache.caffeine

Methods in org.springframework.cache.caffeine with annotations of type Nullable

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)

Method parameters in org.springframework.cache.caffeine with annotations of type Nullable

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.

Uses of Nullable in org.springframework.cache.concurrent

Methods in org.springframework.cache.concurrent with annotations of type Nullable

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)

Method parameters in org.springframework.cache.concurrent with annotations of type Nullable

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 parameters in org.springframework.cache.concurrent with annotations of type Nullable

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.

Uses of Nullable in org.springframework.cache.ehcache

Methods in org.springframework.cache.ehcache with annotations of type Nullable

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)

Method parameters in org.springframework.cache.ehcache with annotations of type Nullable

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.

Uses of Nullable in org.springframework.cache.interceptor

Methods in org.springframework.cache.interceptor with annotations of type Nullable

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.