| Spring Framework Reference Documentation | ||
|---|---|---|
| Next |
Spring Framework Reference Documentation
Authors
Rod Johnson , Juergen Hoeller , Keith Donald , Colin Sampaleanu , Rob Harrop , Thomas Risberg , Alef Arendsen , Darren Davison , Dmitriy Kopylenko , Mark Pollack ,Thierry Templier , Erwin Vervaet , Portia Tung , Ben Hale , Adrian Colyer , John Lewis , Costin Leau , Mark Fisher , Sam Brannen , Ramnivas Laddad , Arjen Poutsma ,Chris Beams , Tareq Abedrabbo , Andy Clement , Dave Syer , Oliver Gierke , Rossen Stoyanchev , Phillip Webb , Rob Winch , Brian Clozel , Stephane Nicoll , SebastienDeleuze
4.1.3.RELEASE
Copyright © 2004-2014
Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically.
Table of Contents
1. Getting Started With Spring
2. Introduction to Spring Framework
2.1. Dependency Injection and Inversion of Control
2.2.2. AOP and Instrumentation
2.2.4. Data Access/Integration
2.3.1. Dependency Management and Naming Conventions
Spring Dependencies and Depending on Spring
Maven "Bill Of Materials" Dependency
II. What’s New in Spring Framework 4.x
3. New Features and Enhancements in Spring Framework 4.0
3.1. Improved Getting Started Experience
3.2. Removed Deprecated Packages and Methods
3.3. Java 8 (as well as 6 and 7)
3.5. Groovy Bean Definition DSL
3.6. Core Container Improvements
3.8. WebSocket, SockJS, and STOMP Messaging
4. New Features and Enhancements in Spring Framework 4.1
4.4. WebSocket STOMP Messaging Improvements
5.1. Introduction to the Spring IoC container and beans
5.2.2. Instantiating a container
Composing XML-based configuration metadata
Aliasing a bean outside the bean definition
Instantiation with a constructor
Instantiation with a static factory method
Instantiation using an instance factory method
Constructor-based dependency injection
Setter-based dependency injection
Examples of dependency injection
5.4.2. Dependencies and configuration in detail
Straight values (primitives, Strings, and so on)
References to other beans (collaborators)
XML shortcut with the p-namespace
XML shortcut with the c-namespace
5.4.5. Autowiring collaborators
Limitations and disadvantages of autowiring
Excluding a bean from autowiring
5.5.3. Singleton beans with prototype-bean dependencies
5.5.4. Request, session, and global session scopes
5.6. Customizing the nature of a bean
Default initialization and destroy methods
Combining lifecycle mechanisms
Startup and shutdown callbacks
Shutting down the Spring IoC container gracefully in non-web applications
5.6.2. ApplicationContextAware and BeanNameAware
5.7. Bean definition inheritance
5.8. Container Extension Points
5.8.1. Customizing beans using a BeanPostProcessor
Example: Hello World, BeanPostProcessor-style
Example: The RequiredAnnotationBeanPostProcessor
5.8.2. Customizing configuration metadata with a BeanFactoryPostProcessor
Example: the Class name substitution PropertyPlaceholderConfigurer
Example: the PropertyOverrideConfigurer
5.8.3. Customizing instantiation logic with a FactoryBean
5.9. Annotation-based container configuration
5.9.3. Fine-tuning annotation-based autowiring with qualifiers
5.9.4. Using generics as autowiring qualifiers
5.9.5. CustomAutowireConfigurer
5.9.7. @PostConstruct and @PreDestroy
5.10. Classpath scanning and managed components
5.10.1. @Component and further stereotype annotations
5.10.3. Automatically detecting classes and registering bean definitions
5.10.4. Using filters to customize scanning
5.10.5. Defining bean metadata within components
5.10.6. Naming autodetected components
5.10.7. Providing a scope for autodetected components
5.10.8. Providing qualifier metadata with annotations
5.11. Using JSR 330 Standard Annotations
5.11.1. Dependency Injection with @Inject and @Named
5.11.2. @Named: a standard equivalent to the @Component annotation
5.11.3. Limitations of the standard approach
5.12. Java-based container configuration
5.12.1. Basic concepts: @Bean and @Configuration
5.12.2. Instantiating the Spring container using AnnotationConfigApplicationContext
Building the container programmatically using register(Class<?>…)
Enabling component scanning with scan(String…)
Support for web applications with AnnotationConfigWebApplicationContext
5.12.3. Using the @Bean annotation
5.12.4. Using the @Configuration annotation
Injecting inter-bean dependencies
Further information about how Java-based configuration works internally
5.12.5. Composing Java-based configurations
Conditionally including @Configuration classes or @Beans
Combining Java and XML configuration
5.13.1. Bean definition profiles
5.13.2. XML Bean definition profiles
5.13.3. PropertySource Abstraction
5.13.5. Placeholder resolution in statements
5.14. Registering a LoadTimeWeaver
5.15. Additional Capabilities of the ApplicationContext
5.15.1. Internationalization using MessageSource
5.15.2. Standard and Custom Events
5.15.3. Convenient access to low-level resources
5.15.4. Convenient ApplicationContext instantiation for web applications
5.15.5. Deploying a Spring ApplicationContext as a Java EE RAR file
5.16.1. BeanFactory or ApplicationContext?
5.16.2. Glue code and the evil singleton
6.3. Built-in Resource implementations
6.5. The ResourceLoaderAware interface
6.6. Resources as dependencies
6.7. Application contexts and Resource paths
6.7.1. Constructing application contexts
Constructing ClassPathXmlApplicationContext instances - shortcuts
6.7.2. Wildcards in application context constructor resource paths
The Classpath*: portability classpath*: prefix
Other notes relating to wildcards
6.7.3. FileSystemResource caveats
7.2. Validation using Spring’s Validator interface
7.3. Resolving codes to error messages
7.4. Bean manipulation and the BeanWrapper
7.4.1. Setting and getting basic and nested properties
7.4.2. Built-in PropertyEditor implementations
Registering additional custom PropertyEditors
7.5.5. Configuring a ConversionService
7.5.6. Using a ConversionService programmatically
7.6.2. Annotation-driven Formatting
7.6.5. Configuring Formatting in Spring MVC
7.7. Configuring a global date & time format
7.8.1. Overview of the JSR-303 Bean Validation API
7.8.2. Configuring a Bean Validation Provider
Configuring Custom Constraints
Spring-driven Method Validation
Additional Configuration Options
7.8.3. Configuring a DataBinder
7.8.4. Spring MVC 3 Validation
Triggering @Controller Input Validation
Configuring a Validator for use by Spring MVC
Configuring a JSR-303/JSR-349 Validator for use by Spring MVC
8. Spring Expression Language (SpEL)
8.3. Expression Evaluation using Spring’s Expression Interface
8.3.1. The EvaluationContext interface
8.4. Expression support for defining bean definitions
8.4.1. XML based configuration
8.4.2. Annotation-based configuration
8.5.2. Properties, Arrays, Lists, Maps, Indexers
8.5.14. Ternary Operator (If-Then-Else)
8.5.16. Safe Navigation operator
8.6. Classes used in the examples
9. Aspect Oriented Programming with Spring
9.1.2. Spring AOP capabilities and goals
9.2.1. Enabling @AspectJ Support
Enabling @AspectJ Support with Java configuration
Enabling @AspectJ Support with XML configuration
Supported Pointcut Designators
Combining pointcut expressions
Sharing common pointcut definitions
9.2.6. Aspect instantiation models
9.3.5. Aspect instantiation models
9.4. Choosing which AOP declaration style to use
9.4.1. Spring AOP or full AspectJ?
9.4.2. @AspectJ or XML for Spring AOP?
9.6.1. Understanding AOP proxies
9.7. Programmatic creation of @AspectJ Proxies
9.8. Using AspectJ with Spring applications
9.8.1. Using AspectJ to dependency inject domain objects with Spring
Unit testing @Configurable objects
Working with multiple application contexts
9.8.2. Other Spring aspects for AspectJ
9.8.3. Configuring AspectJ aspects using Spring IoC
9.8.4. Load-time weaving with AspectJ in the Spring Framework
Environment-specific configuration
10.2.2. Operations on pointcuts
10.2.3. AspectJ expression pointcuts
10.2.4. Convenience pointcut implementations
10.3.2. Advice types in Spring
10.5. Using the ProxyFactoryBean to create AOP proxies
10.5.3. JDK- and CGLIB-based proxies
10.6. Concise proxy definitions
10.7. Creating AOP proxies programmatically with the ProxyFactory
10.8. Manipulating advised objects
10.9. Using the "auto-proxy" facility
10.9.1. Autoproxy bean definitions
DefaultAdvisorAutoProxyCreator
AbstractAdvisorAutoProxyCreator
10.9.2. Using metadata-driven auto-proxying
10.10.1. Hot swappable target sources
10.10.2. Pooling target sources
10.10.3. Prototype target sources
10.10.4. ThreadLocal target sources
10.11. Defining new Advice types
11.1. Introduction to Spring Testing
11.2.2. Unit Testing support Classes
11.3.2. Goals of Integration Testing
Context management and caching
Dependency Injection of test fixtures
Support classes for integration testing
Spring JUnit Testing Annotations
Meta-Annotation Support for Testing
11.3.5. Spring TestContext Framework
TestExecutionListener configuration
Dependency injection of test fixtures
Testing request and session scoped beans
TestContext Framework support classes
11.3.6. Spring MVC Test Framework
12.1. Introduction to Spring Framework transaction management
12.2. Advantages of the Spring Framework’s transaction support model
12.2.3. Spring Framework’s consistent programming model
12.3. Understanding the Spring Framework transaction abstraction
12.4. Synchronizing resources with transactions
12.4.1. High-level synchronization approach
12.4.2. Low-level synchronization approach
12.4.3. TransactionAwareDataSourceProxy
12.5. Declarative transaction management
12.5.1. Understanding the Spring Framework’s declarative transaction implementation
12.5.2. Example of declarative transaction implementation
12.5.3. Rolling back a declarative transaction
12.5.4. Configuring different transactional semantics for different beans
Multiple Transaction Managers with @Transactional
12.5.7. Transaction propagation
12.5.8. Advising transactional operations
12.5.9. Using @Transactional with AspectJ
12.6. Programmatic transaction management
12.6.1. Using the TransactionTemplate
Specifying transaction settings
12.6.2. Using the PlatformTransactionManager
12.7. Choosing between programmatic and declarative transaction management
12.8. Application server-specific integration
12.8.2. Oracle WebLogic Server
12.9. Solutions to common problems
12.9.1. Use of the wrong transaction manager for a specific DataSource
13.2. Consistent exception hierarchy
13.3. Annotations used for configuring DAO or Repository classes
14.1. Introduction to Spring Framework JDBC
14.1.1. Choosing an approach for JDBC database access
14.2. Using the JDBC core classes to control basic JDBC processing and error handling
Examples of JdbcTemplate class usage
14.2.2. NamedParameterJdbcTemplate
14.2.3. SQLExceptionTranslator
14.2.7. Retrieving auto-generated keys
14.3. Controlling database connections
14.3.5. SingleConnectionDataSource
14.3.6. DriverManagerDataSource
14.3.7. TransactionAwareDataSourceProxy
14.3.8. DataSourceTransactionManager
14.4.1. Basic batch operations with the JdbcTemplate
14.4.2. Batch operations with a List of objects
14.4.3. Batch operations with multiple batches
14.5. Simplifying JDBC operations with the SimpleJdbc classes
14.5.1. Inserting data using SimpleJdbcInsert
14.5.2. Retrieving auto-generated keys using SimpleJdbcInsert
14.5.3. Specifying columns for a SimpleJdbcInsert
14.5.4. Using SqlParameterSource to provide parameter values
14.5.5. Calling a stored procedure with SimpleJdbcCall
14.5.6. Explicitly declaring parameters to use for a SimpleJdbcCall
14.5.7. How to define SqlParameters
14.5.8. Calling a stored function using SimpleJdbcCall
14.5.9. Returning ResultSet/REF Cursor from a SimpleJdbcCall
14.6. Modeling JDBC operations as Java objects
14.7. Common problems with parameter and data value handling
14.7.1. Providing SQL type information for parameters
14.7.2. Handling BLOB and CLOB objects
14.7.3. Passing in lists of values for IN clause
14.7.4. Handling complex types for stored procedure calls
14.8. Embedded database support
14.8.1. Why use an embedded database?
14.8.2. Creating an embedded database instance using Spring XML
14.8.3. Creating an embedded database instance programmatically
14.8.4. Extending the embedded database support
14.8.8. Testing data access logic with an embedded database
14.9. Initializing a DataSource
14.9.1. Initializing a database instance using Spring XML
Initialization of Other Components that Depend on the Database
15. Object Relational Mapping (ORM) Data Access
15.1. Introduction to ORM with Spring
15.2. General ORM integration considerations
15.2.1. Resource and transaction management
15.3.1. SessionFactory setup in a Spring container
15.3.2. Implementing DAOs based on plain Hibernate 3 API
15.3.3. Declarative transaction demarcation
15.3.4. Programmatic transaction demarcation
15.3.5. Transaction management strategies
15.3.6. Comparing container-managed and locally defined resources
15.3.7. Spurious application server warnings with Hibernate
15.4.1. PersistenceManagerFactory setup
15.4.2. Implementing DAOs based on the plain JDO API
15.4.3. Transaction management
15.5.1. Three options for JPA setup in a Spring environment
Obtaining an EntityManagerFactory from JNDI
LocalContainerEntityManagerFactoryBean
Dealing with multiple persistence units
15.5.2. Implementing DAOs based on plain JPA
15.5.3. Transaction Management
16. Marshalling XML using O/X Mappers
16.1.3. Consistent Exception Hierarchy
16.2. Marshaller and Unmarshaller
16.3. Using Marshaller and Unmarshaller
16.4. XML Schema-based Configuration
XML Schema-based Configuration
XML Schema-based Configuration
XML Schema-based Configuration
XML Schema-based Configuration
17.1.2. Pluggability of other MVC implementations
17.2.1. Special Bean Types In the WebApplicationContext
17.2.2. Default DispatcherServlet Configuration
17.2.3. DispatcherServlet Processing Sequence
17.3. Implementing Controllers
17.3.1. Defining a controller with @Controller
17.3.2. Mapping Requests With @RequestMapping
@Controller's and AOP Proxying
New Support Classes for @RequestMapping methods in Spring MVC 3.1
URI Template Patterns with Regular Expressions
Path Patterns with Placeholders
Path Pattern Matching By Suffix
Request Parameters and Header Values
17.3.3. Defining @RequestMapping handler methods
Supported method argument types
Binding request parameters to method parameters with @RequestParam
Mapping the request body with the @RequestBody annotation
Mapping the response body with the @ResponseBody annotation
Creating REST Controllers with the @RestController annotation
Using @ModelAttribute on a method
Using @ModelAttribute on a method argument
Using @SessionAttributes to store model attributes in the HTTP session between requests
Specifying redirect and flash attributes
Working with "application/x-www-form-urlencoded" data
Mapping cookie values with the @CookieValue annotation
Mapping request header attributes with the @RequestHeader annotation
Method Parameters And Type Conversion
Customizing WebDataBinder initialization
Support for the Last-Modified Response Header To Facilitate Content Caching
Advising controllers with the @ControllerAdvice annotation
Jackson Serialization View Support
17.3.4. Asynchronous Request Processing
Exception Handling for Async Requests
Configuration for Async Request Processing
17.4.1. Intercepting requests with a HandlerInterceptor
17.5.1. Resolving views with the ViewResolver interface
17.5.2. Chaining ViewResolvers
17.5.4. ContentNegotiatingViewResolver
17.7.1. Building URIs to Controllers and methods
17.7.2. Building URIs to Controllers and methods from views
17.8.1. Obtaining Time Zone Information
17.8.2. AcceptHeaderLocaleResolver
17.8.5. LocaleChangeInterceptor
17.10. Spring’s multipart (file upload) support
17.10.2. Using a MultipartResolver with Commons FileUpload
17.10.3. Using a MultipartResolver with Servlet 3.0
17.10.4. Handling a file upload in a form
17.10.5. Handling a file upload request from programmatic clients
17.11.1. HandlerExceptionResolver
17.11.3. Handling Standard Spring MVC Exceptions
17.11.4. Annotating Business Exceptions With @ResponseStatus
17.11.5. Customizing the Default Servlet Container Error Page
17.13. Convention over configuration support
17.13.1. The Controller ControllerClassNameHandlerMapping
17.13.2. The Model ModelMap (ModelAndView)
17.13.3. The View - RequestToViewNameTranslator
17.15. Code-based Servlet container initialization
17.16.1. Enabling the MVC Java Config or the MVC XML Namespace
17.16.2. Customizing the Provided Configuration
17.16.8. Falling Back On the "Default" Servlet To Serve Resources
17.16.10. Advanced Customizations with MVC Java Config
17.16.11. Advanced Customizations with the MVC Namespace
18.2.2. Plain-old JSPs versus JSTL
18.2.3. Additional tags facilitating development
18.2.4. Using Spring’s form tag library
18.3.2. How to integrate Tiles
SimpleSpringPreparerFactory and SpringBeanPreparerFactory
18.4.4. Advanced configuration
18.4.5. Bind support and form handling
HTML escaping and XHTML compliance
18.6. Document views (PDF/Excel)
18.6.2. Configuration and setup
Using JasperReportsMultiFormatView
18.7.3. Populating the ModelAndView
18.7.4. Working with Sub-Reports
Configuring Sub-Report Data Sources
18.7.5. Configuring Exporter Parameters
19. Integrating with other web frameworks
19.3.1. SpringBeanFacesELResolver (JSF 1.2+)
20.1.1. Controllers - The C in MVC
20.4.1. AbstractController and PortletContentGenerator
20.4.2. Other simple controllers
20.4.4. PortletWrappingController
20.5.1. PortletModeHandlerMapping
20.5.2. ParameterHandlerMapping
20.5.3. PortletModeParameterHandlerMapping
20.5.4. Adding HandlerInterceptors
20.5.5. HandlerInterceptorAdapter
20.5.6. ParameterMappingInterceptor
20.6. Views and resolving them
20.7. Multipart (file upload) support
20.7.1. Using the PortletMultipartResolver
20.7.2. Handling a file upload in a form
20.9. Annotation-based controller configuration
20.9.1. Setting up the dispatcher for annotation support
20.9.2. Defining a controller with @Controller
20.9.3. Mapping requests with @RequestMapping
20.9.4. Supported handler method arguments
20.9.5. Binding request parameters to method parameters with @RequestParam
20.9.6. Providing a link to data from the model with @ModelAttribute
20.9.7. Specifying attributes to store in a Session with @SessionAttributes
20.9.8. Customizing WebDataBinder initialization
Customizing data binding with @InitBinder
Configuring a custom WebBindingInitializer
20.10. Portlet application deployment
21.1.1. WebSocket Fallback Options
21.1.2. A Messaging Architecture
21.1.3. Sub-Protocol Support in WebSocket
21.1.4. Should I Use WebSocket?
21.2.1. Create and Configure a WebSocketHandler
21.2.2. Customizing the WebSocket Handshake
21.2.3. WebSocketHandler Decoration
21.2.4. Deployment Considerations
21.2.5. Configuring the WebSocket Engine
21.3.3. HTTP Streaming in IE 8, 9: Ajax/XHR vs IFrame
21.3.5. Servlet 3 Async Requests
21.3.6. CORS Headers for SockJS
21.4. STOMP Over WebSocket Messaging Architecture
21.4.2. Enable STOMP over WebSocket
21.4.4. Annotation Message Handling
21.4.8. Connections To Full-Featured Broker
21.4.9. Using Dot as Separator in @MessageMapping Destinations
21.4.12. Listening To ApplicationContext Events and Intercepting Messages
21.4.14. Configuration and Performance
21.4.16. Testing Annotated Controller Methods
22. Remoting and web services using Spring
22.2. Exposing services using RMI
22.2.1. Exporting the service using the RmiServiceExporter
22.2.2. Linking in the service at the client
22.3. Using Hessian or Burlap to remotely call services via HTTP
22.3.1. Wiring up the DispatcherServlet for Hessian and co.
22.3.2. Exposing your beans by using the HessianServiceExporter
22.3.3. Linking in the service on the client
22.3.5. Applying HTTP basic authentication to a service exposed through Hessian or Burlap
22.4. Exposing services using HTTP invokers
22.4.1. Exposing the service object
22.4.2. Linking in the service at the client
22.5.1. Exposing servlet-based web services using JAX-WS
22.5.2. Exporting standalone web services using JAX-WS
22.5.3. Exporting web services using the JAX-WS RI’s Spring support
22.5.4. Accessing web services using JAX-WS
22.6.1. Server-side configuration
22.6.2. Client-side configuration
22.8. Auto-detection is not implemented for remote interfaces
22.9. Considerations when choosing a technology
22.10. Accessing RESTful services on the Client
Dealing with request and response headers
22.10.2. HTTP Message Conversion
MarshallingHttpMessageConverter
MappingJackson2HttpMessageConverter
MappingJackson2XmlHttpMessageConverter
BufferedImageHttpMessageConverter
23. Enterprise JavaBeans (EJB) integration
23.2.3. Accessing remote SLSBs
23.2.4. Accessing EJB 2.x SLSBs versus EJB 3 SLSBs
23.3. Using Spring’s EJB implementation support classes
23.3.1. EJB 3 injection interceptor
24. JMS (Java Message Service)
24.2.3. Destination Management
24.2.4. Message Listener Containers
SimpleMessageListenerContainer
DefaultMessageListenerContainer
24.2.5. Transaction management
24.3.1. Using Message Converters
24.3.2. SessionCallback and ProducerCallback
24.4.2. Asynchronous Reception - Message-Driven POJOs
24.4.3. the SessionAwareMessageListener interface
24.4.4. the MessageListenerAdapter
24.4.5. Processing messages within transactions
24.5. Support for JCA Message Endpoints
24.6. Annotation-driven listener endpoints
24.6.1. Enable listener endpoint annotations
24.6.2. Programmatic endpoints registration
24.6.3. Annotated endpoint method signature
25.2. Exporting your beans to JMX
25.2.1. Creating an MBeanServer
25.2.2. Reusing an existing MBeanServer
25.2.3. Lazy-initialized MBeans
25.2.4. Automatic registration of MBeans
25.2.5. Controlling the registration behavior
25.3. Controlling the management interface of your beans
25.3.1. the MBeanInfoAssembler Interface
25.3.2. Using Source-Level Metadata (Java annotations)
25.3.3. Source-Level Metadata Types
25.3.4. the AutodetectCapableMBeanInfoAssembler interface
25.3.5. Defining management interfaces using Java interfaces
25.3.6. Using MethodNameBasedMBeanInfoAssembler
25.4. Controlling the ObjectNames for your beans
25.4.1. Reading ObjectNames from Properties
25.4.2. Using the MetadataNamingStrategy
25.4.3. Configuring annotation based MBean export
25.5.1. Server-side Connectors
25.5.2. Client-side Connectors
25.5.3. JMX over Burlap/Hessian/SOAP
25.6. Accessing MBeans via Proxies
25.7.1. Registering Listeners for Notifications
25.7.2. Publishing Notifications
26.2.1. Connector configuration
26.2.2. ConnectionFactory configuration in Spring
26.2.3. Configuring CCI connections
26.2.4. Using a single CCI connection
26.3. Using Spring’s CCI access support
26.3.4. Automatic output record generation
26.3.6. Using a CCI Connection and Interaction directly
26.3.7. Example for CciTemplate usage
26.4. Modeling CCI access as operation objects
26.4.1. MappingRecordOperation
26.4.2. MappingCommAreaOperation
26.4.3. Automatic output record generation
26.4.5. Example for MappingRecordOperation usage
26.4.6. Example for MappingCommAreaOperation usage
27.2.1. Basic MailSender and SimpleMailMessage usage
27.2.2. Using the JavaMailSender and the MimeMessagePreparator
27.3. Using the JavaMail MimeMessageHelper
27.3.1. Sending attachments and inline resources
27.3.2. Creating email content using a templating library
28. Task Execution and Scheduling
28.2. The Spring TaskExecutor abstraction
28.3. The Spring TaskScheduler abstraction
28.3.2. Trigger implementations
28.3.3. TaskScheduler implementations
28.4. Annotation Support for Scheduling and Asynchronous Execution
28.4.1. Enable scheduling annotations
28.4.2. The @Scheduled Annotation
28.4.4. Executor qualification with @Async
28.4.5. Exception management with @Async
28.5.3. The scheduled-tasks element
28.6. Using the Quartz Scheduler
28.6.1. Using the JobDetailFactoryBean
28.6.2. Using the MethodInvokingJobDetailFactoryBean
28.6.3. Wiring up jobs using triggers and the SchedulerFactoryBean
29.3. Defining beans that are backed by dynamic languages
Inline dynamic language source files
Understanding Constructor Injection in the context of dynamic-language-backed beans
Customizing Groovy objects via a callback
29.4.1. Scripted Spring MVC Controllers
29.5.1. AOP - advising scripted beans
30.2. Understanding the cache abstraction
30.3. Declarative annotation-based caching
Custom Key Generation Declaration
Available caching SpEL evaluation context
30.3.3. @CacheEvict annotation
30.3.5. @CacheConfig annotation
30.3.6. Enable caching annotations
30.3.7. Using custom annotations
30.4. JCache (JSR-107) annotations
30.4.2. Enabling JSR-107 support
30.5. Declarative XML-based caching
30.6. Configuring the cache storage
30.6.1. JDK ConcurrentMap-based Cache
30.6.6. Dealing with caches without a backing store
30.7. Plugging-in different back-end caches
30.8. How can I set the TTL/TTI/Eviction policy/XXX feature?
31. Migrating to Spring Framework 4.0
Implementing Spring-based DAOs without callbacks
32.3.2. Asynchronous Message Reception
32.3.4. Transaction Management
33.1.2. Operations on pointcuts
33.1.3. AspectJ expression pointcuts
33.1.4. Convenience pointcut implementations
33.2.2. Advice types in Spring
33.4. Using the ProxyFactoryBean to create AOP proxies
33.4.3. JDK- and CGLIB-based proxies
33.5. Concise proxy definitions
33.6. Creating AOP proxies programmatically with the ProxyFactory
33.7. Manipulating advised objects
33.8. Using the "autoproxy" facility
33.8.1. Autoproxy bean definitions
DefaultAdvisorAutoProxyCreator
AbstractAdvisorAutoProxyCreator
33.8.2. Using metadata-driven auto-proxying
33.9.1. Hot swappable target sources
33.9.2. Pooling target sources
33.9.3. Prototype target sources
33.9.4. ThreadLocal target sources
33.10. Defining new Advice types
34. XML Schema-based configuration
34.2. XML Schema-based configuration
34.2.1. Referencing the schemas
<jee:jndi-lookup/> (with single JNDI environment setting)
<jee:jndi-lookup/> (with multiple JNDI environment settings)
34.2.6. the tx (transaction) schema
35.3. Coding a NamespaceHandler
35.5. Registering the handler and the schema
35.5.1. META-INF/spring.handlers
35.5.2. META-INF/spring.schemas
35.6. Using a custom extension in your Spring XML configuration
35.7.1. Nesting custom tags within custom tags
35.7.2. Custom attributes on normal elements
| Next | ||
| Part I. Spring 框架概述 |
扫一扫
3699
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
