Logo Spring Framework Reference
Back to index
  • I. Overview of Spring Framework
    • 1. Getting Started with Spring
    • 2. Introduction to the Spring Framework
      • 2.1. Dependency Injection and Inversion of Control
      • 2.2. Framework Modules
        • 2.2.1. Core Container
        • 2.2.2. AOP and Instrumentation
        • 2.2.3. Messaging
        • 2.2.4. Data Access/Integration
        • 2.2.5. Web
        • 2.2.6. Test
      • 2.3. Usage scenarios
        • 2.3.1. Dependency Management and Naming Conventions
          • Spring Dependencies and Depending on Spring
          • Maven Dependency Management
          • Maven "Bill Of Materials" Dependency
          • Gradle Dependency Management
          • Ivy Dependency Management
          • Distribution Zip Files
        • 2.3.2. Logging
          • Using Log4j 1.2 or 2.x
          • Avoiding Commons Logging
          • Using SLF4J with Log4j or Logback
          • Using JUL (java.util.logging)
          • Commons Logging on WebSphere
  • 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.4. Java EE 6 and 7
      • 3.5. Groovy Bean Definition DSL
      • 3.6. Core Container Improvements
      • 3.7. General Web Improvements
      • 3.8. WebSocket, SockJS, and STOMP Messaging
      • 3.9. Testing Improvements
    • 4. New Features and Enhancements in Spring Framework 4.1
      • 4.1. JMS Improvements
      • 4.2. Caching Improvements
      • 4.3. Web Improvements
      • 4.4. WebSocket Messaging Improvements
      • 4.5. Testing Improvements
    • 5. New Features and Enhancements in Spring Framework 4.2
      • 5.1. Core Container Improvements
      • 5.2. Data Access Improvements
      • 5.3. JMS Improvements
      • 5.4. Web Improvements
      • 5.5. WebSocket Messaging Improvements
      • 5.6. Testing Improvements
    • 6. New Features and Enhancements in Spring Framework 4.3
      • 6.1. Core Container Improvements
      • 6.2. Data Access Improvements
      • 6.3. Caching Improvements
      • 6.4. JMS Improvements
      • 6.5. Web Improvements
      • 6.6. WebSocket Messaging Improvements
      • 6.7. Testing Improvements
      • 6.8. Support for new library and server generations
  • III. Core Technologies
    • 7. The IoC container
      • 7.1. Introduction to the Spring IoC container and beans
      • 7.2. Container overview
        • 7.2.1. Configuration metadata
        • 7.2.2. Instantiating a container
          • Composing XML-based configuration metadata
          • The Groovy Bean Definition DSL
        • 7.2.3. Using the container
      • 7.3. Bean overview
        • 7.3.1. Naming beans
          • Aliasing a bean outside the bean definition
        • 7.3.2. Instantiating beans
          • Instantiation with a constructor
          • Instantiation with a static factory method
          • Instantiation using an instance factory method
      • 7.4. Dependencies
        • 7.4.1. Dependency Injection
          • Constructor-based dependency injection
          • Setter-based dependency injection
          • Dependency resolution process
          • Examples of dependency injection
        • 7.4.2. Dependencies and configuration in detail
          • Straight values (primitives, Strings, and so on)
          • References to other beans (collaborators)
          • Inner beans
          • Collections
          • Null and empty string values
          • XML shortcut with the p-namespace
          • XML shortcut with the c-namespace
          • Compound property names
        • 7.4.3. Using depends-on
        • 7.4.4. Lazy-initialized beans
        • 7.4.5. Autowiring collaborators
          • Limitations and disadvantages of autowiring
          • Excluding a bean from autowiring
        • 7.4.6. Method injection
          • Lookup method injection
          • Arbitrary method replacement
      • 7.5. Bean scopes
        • 7.5.1. The singleton scope
        • 7.5.2. The prototype scope
        • 7.5.3. Singleton beans with prototype-bean dependencies
        • 7.5.4. Request, session, global session, application, and WebSocket scopes
          • Initial web configuration
          • Request scope
          • Session scope
          • Global session scope
          • Application scope
          • Scoped beans as dependencies
        • 7.5.5. Custom scopes
          • Creating a custom scope
          • Using a custom scope
      • 7.6. Customizing the nature of a bean
        • 7.6.1. Lifecycle callbacks
          • Initialization callbacks
          • Destruction callbacks
          • Default initialization and destroy methods
          • Combining lifecycle mechanisms
          • Startup and shutdown callbacks
          • Shutting down the Spring IoC container gracefully in non-web applications
        • 7.6.2. ApplicationContextAware and BeanNameAware
        • 7.6.3. Other Aware interfaces
      • 7.7. Bean definition inheritance
      • 7.8. Container Extension Points
        • 7.8.1. Customizing beans using a BeanPostProcessor
          • Example: Hello World, BeanPostProcessor-style
          • Example: The RequiredAnnotationBeanPostProcessor
        • 7.8.2. Customizing configuration metadata with a BeanFactoryPostProcessor
          • Example: the Class name substitution PropertyPlaceholderConfigurer
          • Example: the PropertyOverrideConfigurer
        • 7.8.3. Customizing instantiation logic with a FactoryBean
      • 7.9. Annotation-based container configuration
        • 7.9.1. @Required
        • 7.9.2. @Autowired
        • 7.9.3. Fine-tuning annotation-based autowiring with @Primary
        • 7.9.4. Fine-tuning annotation-based autowiring with qualifiers
        • 7.9.5. Using generics as autowiring qualifiers
        • 7.9.6. CustomAutowireConfigurer
        • 7.9.7. @Resource
        • 7.9.8. @PostConstruct and @PreDestroy
      • 7.10. Classpath scanning and managed components
        • 7.10.1. @Component and further stereotype annotations
        • 7.10.2. Meta-annotations
        • 7.10.3. Automatically detecting classes and registering bean definitions
        • 7.10.4. Using filters to customize scanning
        • 7.10.5. Defining bean metadata within components
        • 7.10.6. Naming autodetected components
        • 7.10.7. Providing a scope for autodetected components
        • 7.10.8. Providing qualifier metadata with annotations
      • 7.11. Using JSR 330 Standard Annotations
        • 7.11.1. Dependency Injection with @Inject and @Named
        • 7.11.2. @Named and @ManagedBean: standard equivalents to the @Component annotation
        • 7.11.3. Limitations of JSR-330 standard annotations
      • 7.12. Java-based container configuration
        • 7.12.1. Basic concepts: @Bean and @Configuration
        • 7.12.2. Instantiating the Spring container using AnnotationConfigApplicationContext
          • Simple construction
          • Building the container programmatically using register(Class<?>…)
          • Enabling component scanning with scan(String…)
          • Support for web applications with AnnotationConfigWebApplicationContext
        • 7.12.3. Using the @Bean annotation
          • Declaring a bean
          • Bean dependencies
          • Receiving lifecycle callbacks
          • Specifying bean scope
          • Customizing bean naming
          • Bean aliasing
          • Bean description
        • 7.12.4. Using the @Configuration annotation
          • Injecting inter-bean dependencies
          • Lookup method injection
          • Further information about how Java-based configuration works internally
        • 7.12.5. Composing Java-based configurations
          • Using the @Import annotation
          • Conditionally include @Configuration classes or @Bean methods
          • Combining Java and XML configuration
      • 7.13. Environment abstraction
        • 7.13.1. Bean definition profiles
          • @Profile
          • XML bean definition profiles
          • Activating a profile
          • Default profile
        • 7.13.2. PropertySource abstraction
        • 7.13.3. @PropertySource
        • 7.13.4. Placeholder resolution in statements
      • 7.14. Registering a LoadTimeWeaver
      • 7.15. Additional capabilities of the ApplicationContext
        • 7.15.1. Internationalization using MessageSource
        • 7.15.2. Standard and custom events
          • Annotation-based event listeners
          • Asynchronous Listeners
          • Ordering listeners
          • Generic events
        • 7.15.3. Convenient access to low-level resources
        • 7.15.4. Convenient ApplicationContext instantiation for web applications
        • 7.15.5. Deploying a Spring ApplicationContext as a Java EE RAR file
      • 7.16. The BeanFactory
        • 7.16.1. BeanFactory or ApplicationContext?
        • 7.16.2. Glue code and the evil singleton
    • 8. Resources
      • 8.1. Introduction
      • 8.2. The Resource interface
      • 8.3. Built-in Resource implementations
        • 8.3.1. UrlResource
        • 8.3.2. ClassPathResource
        • 8.3.3. FileSystemResource
        • 8.3.4. ServletContextResource
        • 8.3.5. InputStreamResource
        • 8.3.6. ByteArrayResource
      • 8.4. The ResourceLoader
      • 8.5. The ResourceLoaderAware interface
      • 8.6. Resources as dependencies
      • 8.7. Application contexts and Resource paths
        • 8.7.1. Constructing application contexts
          • Constructing ClassPathXmlApplicationContext instances - shortcuts
        • 8.7.2. Wildcards in application context constructor resource paths
          • Ant-style Patterns
          • The classpath*: prefix
          • Other notes relating to wildcards
        • 8.7.3. FileSystemResource caveats
    • 9. Validation, Data Binding, and Type Conversion
      • 9.1. Introduction
      • 9.2. Validation using Spring’s Validator interface
      • 9.3. Resolving codes to error messages
      • 9.4. Bean manipulation and the BeanWrapper
        • 9.4.1. Setting and getting basic and nested properties
        • 9.4.2. Built-in PropertyEditor implementations
          • Registering additional custom PropertyEditors
      • 9.5. Spring Type Conversion
        • 9.5.1. Converter SPI
        • 9.5.2. ConverterFactory
        • 9.5.3. GenericConverter
          • ConditionalGenericConverter
        • 9.5.4. ConversionService API
        • 9.5.5. Configuring a ConversionService
        • 9.5.6. Using a ConversionService programmatically
      • 9.6. Spring Field Formatting
        • 9.6.1. Formatter SPI
        • 9.6.2. Annotation-driven Formatting
          • Format Annotation API
        • 9.6.3. FormatterRegistry SPI
        • 9.6.4. FormatterRegistrar SPI
        • 9.6.5. Configuring Formatting in Spring MVC
      • 9.7. Configuring a global date & time format
      • 9.8. Spring Validation
        • 9.8.1. Overview of the JSR-303 Bean Validation API
        • 9.8.2. Configuring a Bean Validation Provider
          • Injecting a Validator
          • Configuring Custom Constraints
          • Spring-driven Method Validation
          • Additional Configuration Options
        • 9.8.3. Configuring a DataBinder
        • 9.8.4. Spring MVC 3 Validation
    • 10. Spring Expression Language (SpEL)
      • 10.1. Introduction
      • 10.2. Evaluation
        • 10.2.1. EvaluationContext
          • Type conversion
        • 10.2.2. Parser configuration
        • 10.2.3. SpEL compilation
          • Compiler configuration
          • Compiler limitations
      • 10.3. Expressions in bean definitions
        • 10.3.1. XML configuration
        • 10.3.2. Annotation config
      • 10.4. Language Reference
        • 10.4.1. Literal expressions
        • 10.4.2. Properties, Arrays, Lists, Maps, Indexers
        • 10.4.3. Inline lists
        • 10.4.4. Inline Maps
        • 10.4.5. Array construction
        • 10.4.6. Methods
        • 10.4.7. Operators
          • Relational operators
          • Logical operators
          • Mathematical operators
        • 10.4.8. Assignment
        • 10.4.9. Types
        • 10.4.10. Constructors
        • 10.4.11. Variables
          • The #this and #root variables
        • 10.4.12. Functions
        • 10.4.13. Bean references
        • 10.4.14. Ternary Operator (If-Then-Else)
        • 10.4.15. The Elvis Operator
        • 10.4.16. Safe Navigation operator
        • 10.4.17. Collection Selection
        • 10.4.18. Collection Projection
        • 10.4.19. Expression templating
      • 10.5. Classes used in the examples
    • 11. Aspect Oriented Programming with Spring
      • 11.1. Introduction
        • 11.1.1. AOP concepts
        • 11.1.2. Spring AOP capabilities and goals
        • 11.1.3. AOP Proxies
      • 11.2. @AspectJ support
        • 11.2.1. Enabling @AspectJ Support
          • Enabling @AspectJ Support with Java configuration
          • Enabling @AspectJ Support with XML configuration
        • 11.2.2. Declaring an aspect
        • 11.2.3. Declaring a pointcut
          • Supported Pointcut Designators
          • Combining pointcut expressions
          • Sharing common pointcut definitions
          • Examples
          • Writing good pointcuts
        • 11.2.4. Declaring advice
          • Before advice
          • After returning advice
          • After throwing advice
          • After (finally) advice
          • Around advice
          • Advice parameters
          • Advice ordering
        • 11.2.5. Introductions
        • 11.2.6. Aspect instantiation models
        • 11.2.7. Example
      • 11.3. Schema-based AOP support
        • 11.3.1. Declaring an aspect
        • 11.3.2. Declaring a pointcut
        • 11.3.3. Declaring advice
          • Before advice
          • After returning advice
          • After throwing advice
          • After (finally) advice
          • Around advice
          • Advice parameters
          • Advice ordering
        • 11.3.4. Introductions
        • 11.3.5. Aspect instantiation models
        • 11.3.6. Advisors
        • 11.3.7. Example
      • 11.4. Choosing which AOP declaration style to use
        • 11.4.1. Spring AOP or full AspectJ?
        • 11.4.2. @AspectJ or XML for Spring AOP?
      • 11.5. Mixing aspect types
      • 11.6. Proxying mechanisms
        • 11.6.1. Understanding AOP proxies
      • 11.7. Programmatic creation of @AspectJ Proxies
      • 11.8. Using AspectJ with Spring applications
        • 11.8.1. Using AspectJ to dependency inject domain objects with Spring
          • Unit testing @Configurable objects
          • Working with multiple application contexts
        • 11.8.2. Other Spring aspects for AspectJ
        • 11.8.3. Configuring AspectJ aspects using Spring IoC
        • 11.8.4. Load-time weaving with AspectJ in the Spring Framework
          • A first example
          • Aspects
          • 'META-INF/aop.xml'
          • Required libraries (JARS)
          • Spring configuration
          • Environment-specific configuration
      • 11.9. Further Resources
    • 12. Spring AOP APIs
      • 12.1. Introduction
      • 12.2. Pointcut API in Spring
        • 12.2.1. Concepts
        • 12.2.2. Operations on pointcuts
        • 12.2.3. AspectJ expression pointcuts
        • 12.2.4. Convenience pointcut implementations
          • Static pointcuts
          • Dynamic pointcuts
        • 12.2.5. Pointcut superclasses
        • 12.2.6. Custom pointcuts
      • 12.3. Advice API in Spring
        • 12.3.1. Advice lifecycles
        • 12.3.2. Advice types in Spring
          • Interception around advice
          • Before advice
          • Throws advice
          • After Returning advice
          • Introduction advice
      • 12.4. Advisor API in Spring
      • 12.5. Using the ProxyFactoryBean to create AOP proxies
        • 12.5.1. Basics
        • 12.5.2. JavaBean properties
        • 12.5.3. JDK- and CGLIB-based proxies
        • 12.5.4. Proxying interfaces
        • 12.5.5. Proxying classes
        • 12.5.6. Using 'global' advisors
      • 12.6. Concise proxy definitions
      • 12.7. Creating AOP proxies programmatically with the ProxyFactory
      • 12.8. Manipulating advised objects
      • 12.9. Using the "auto-proxy" facility
        • 12.9.1. Autoproxy bean definitions
          • BeanNameAutoProxyCreator
          • DefaultAdvisorAutoProxyCreator
          • AbstractAdvisorAutoProxyCreator
        • 12.9.2. Using metadata-driven auto-proxying
      • 12.10. Using TargetSources
        • 12.10.1. Hot swappable target sources
        • 12.10.2. Pooling target sources
        • 12.10.3. Prototype target sources
        • 12.10.4. ThreadLocal target sources
      • 12.11. Defining new Advice types
      • 12.12. Further resources
  • IV. Testing
    • 13. Introduction to Spring Testing
    • 14. Unit Testing
      • 14.1. Mock Objects
        • 14.1.1. Environment
        • 14.1.2. JNDI
        • 14.1.3. Servlet API
        • 14.1.4. Portlet API
      • 14.2. Unit Testing support Classes
        • 14.2.1. General testing utilities
        • 14.2.2. Spring MVC
    • 15. Integration Testing
      • 15.1. Overview
      • 15.2. Goals of Integration Testing
        • 15.2.1. Context management and caching
        • 15.2.2. Dependency Injection of test fixtures
        • 15.2.3. Transaction management
        • 15.2.4. Support classes for integration testing
      • 15.3. JDBC Testing Support
      • 15.4. Annotations
        • 15.4.1. Spring Testing Annotations
          • @BootstrapWith
          • @ContextConfiguration
          • @WebAppConfiguration
          • @ContextHierarchy
          • @ActiveProfiles
          • @TestPropertySource
          • @DirtiesContext
          • @TestExecutionListeners
          • @Commit
          • @Rollback
          • @BeforeTransaction
          • @AfterTransaction
          • @Sql
          • @SqlConfig
          • @SqlGroup
        • 15.4.2. Standard Annotation Support
        • 15.4.3. Spring JUnit 4 Testing Annotations
          • @IfProfileValue
          • @ProfileValueSourceConfiguration
          • @Timed
          • @Repeat
        • 15.4.4. Meta-Annotation Support for Testing
      • 15.5. Spring TestContext Framework
        • 15.5.1. Key abstractions
          • TestContext
          • TestContextManager
          • TestExecutionListener
          • Context Loaders
        • 15.5.2. Bootstrapping the TestContext framework
        • 15.5.3. TestExecutionListener configuration
          • Registering custom TestExecutionListeners
          • Automatic discovery of default TestExecutionListeners
          • Ordering TestExecutionListeners
          • Merging TestExecutionListeners
        • 15.5.4. Context management
          • Context configuration with XML resources
          • Context configuration with Groovy scripts
          • Context configuration with annotated classes
          • Mixing XML, Groovy scripts, and annotated classes
          • Context configuration with context initializers
          • Context configuration inheritance
          • Context configuration with environment profiles
          • Context configuration with test property sources
          • Loading a WebApplicationContext
          • Context caching
          • Context hierarchies
        • 15.5.5. Dependency injection of test fixtures
        • 15.5.6. Testing request and session scoped beans
        • 15.5.7. Transaction management
          • Test-managed transactions
          • Enabling and disabling transactions
          • Transaction rollback and commit behavior
          • Programmatic transaction management
          • Executing code outside of a transaction
          • Configuring a transaction manager
          • Demonstration of all transaction-related annotations
        • 15.5.8. Executing SQL scripts
          • Executing SQL scripts programmatically
          • Executing SQL scripts declaratively with @Sql
        • 15.5.9. TestContext Framework support classes
          • Spring JUnit 4 Runner
          • Spring JUnit 4 Rules
          • JUnit 4 support classes
          • JUnit 5 Support
          • TestNG support classes
      • 15.6. Spring MVC Test Framework
        • 15.6.1. Server-Side Tests
          • Static Imports
          • Setup Choices
          • Performing Requests
          • Defining Expectations
          • Filter Registrations
          • Differences between Out-of-Container and End-to-End Integration Tests
          • Further Server-Side Test Examples
        • 15.6.2. HtmlUnit Integration
          • Why HtmlUnit Integration?
          • MockMvc and HtmlUnit
          • MockMvc and WebDriver
          • MockMvc and Geb
        • 15.6.3. Client-Side REST Tests
          • Static Imports
          • Further Examples of Client-side REST Tests
      • 15.7. PetClinic Example
    • 16. Further Resources
  • V. Data Access
    • 17. Transaction Management
      • 17.1. Introduction to Spring Framework transaction management
      • 17.2. Advantages of the Spring Framework’s transaction support model
        • 17.2.1. Global transactions
        • 17.2.2. Local transactions
        • 17.2.3. Spring Framework’s consistent programming model
      • 17.3. Understanding the Spring Framework transaction abstraction
      • 17.4. Synchronizing resources with transactions
        • 17.4.1. High-level synchronization approach
        • 17.4.2. Low-level synchronization approach
        • 17.4.3. TransactionAwareDataSourceProxy
      • 17.5. Declarative transaction management
        • 17.5.1. Understanding the Spring Framework’s declarative transaction implementation
        • 17.5.2. Example of declarative transaction implementation
        • 17.5.3. Rolling back a declarative transaction
        • 17.5.4. Configuring different transactional semantics for different beans
        • 17.5.5. <tx:advice/> settings
        • 17.5.6. Using @Transactional
          • @Transactional settings
          • Multiple Transaction Managers with @Transactional
          • Custom shortcut annotations
        • 17.5.7. Transaction propagation
          • Required
          • RequiresNew
          • Nested
        • 17.5.8. Advising transactional operations
        • 17.5.9. Using @Transactional with AspectJ
      • 17.6. Programmatic transaction management
        • 17.6.1. Using the TransactionTemplate
          • Specifying transaction settings
        • 17.6.2. Using the PlatformTransactionManager
      • 17.7. Choosing between programmatic and declarative transaction management
      • 17.8. Transaction bound event
      • 17.9. Application server-specific integration
        • 17.9.1. IBM WebSphere
        • 17.9.2. Oracle WebLogic Server
      • 17.10. Solutions to common problems
        • 17.10.1. Use of the wrong transaction manager for a specific DataSource
      • 17.11. Further resources
    • 18. DAO support
      • 18.1. Introduction
      • 18.2. Consistent exception hierarchy
      • 18.3. Annotations used for configuring DAO or Repository classes
    • 19. Data access with JDBC
      • 19.1. Introduction to Spring Framework JDBC
        • 19.1.1. Choosing an approach for JDBC database access
        • 19.1.2. Package hierarchy
      • 19.2. Using the JDBC core classes to control basic JDBC processing and error handling
        • 19.2.1. JdbcTemplate
          • Examples of JdbcTemplate class usage
          • JdbcTemplate best practices
        • 19.2.2. NamedParameterJdbcTemplate
        • 19.2.3. SQLExceptionTranslator
        • 19.2.4. Executing statements
        • 19.2.5. Running queries
        • 19.2.6. Updating the database
        • 19.2.7. Retrieving auto-generated keys
      • 19.3. Controlling database connections
        • 19.3.1. DataSource
        • 19.3.2. DataSourceUtils
        • 19.3.3. SmartDataSource
        • 19.3.4. AbstractDataSource
        • 19.3.5. SingleConnectionDataSource
        • 19.3.6. DriverManagerDataSource
        • 19.3.7. TransactionAwareDataSourceProxy
        • 19.3.8. DataSourceTransactionManager
        • 19.3.9. NativeJdbcExtractor
      • 19.4. JDBC batch operations
        • 19.4.1. Basic batch operations with the JdbcTemplate
        • 19.4.2. Batch operations with a List of objects
        • 19.4.3. Batch operations with multiple batches
      • 19.5. Simplifying JDBC operations with the SimpleJdbc classes
        • 19.5.1. Inserting data using SimpleJdbcInsert
        • 19.5.2. Retrieving auto-generated keys using SimpleJdbcInsert
        • 19.5.3. Specifying columns for a SimpleJdbcInsert
        • 19.5.4. Using SqlParameterSource to provide parameter values
        • 19.5.5. Calling a stored procedure with SimpleJdbcCall
        • 19.5.6. Explicitly declaring parameters to use for a SimpleJdbcCall
        • 19.5.7. How to define SqlParameters
        • 19.5.8. Calling a stored function using SimpleJdbcCall
        • 19.5.9. Returning ResultSet/REF Cursor from a SimpleJdbcCall
      • 19.6. Modeling JDBC operations as Java objects
        • 19.6.1. SqlQuery
        • 19.6.2. MappingSqlQuery
        • 19.6.3. SqlUpdate
        • 19.6.4. StoredProcedure
      • 19.7. Common problems with parameter and data value handling
        • 19.7.1. Providing SQL type information for parameters
        • 19.7.2. Handling BLOB and CLOB objects
        • 19.7.3. Passing in lists of values for IN clause
        • 19.7.4. Handling complex types for stored procedure calls
      • 19.8. Embedded database support
        • 19.8.1. Why use an embedded database?
        • 19.8.2. Creating an embedded database using Spring XML
        • 19.8.3. Creating an embedded database programmatically
        • 19.8.4. Selecting the embedded database type
          • Using HSQL
          • Using H2
          • Using Derby
        • 19.8.5. Testing data access logic with an embedded database
        • 19.8.6. Generating unique names for embedded databases
        • 19.8.7. Extending the embedded database support
      • 19.9. Initializing a DataSource
        • 19.9.1. Initializing a database using Spring XML
          • Initialization of other components that depend on the database
    • 20. Object Relational Mapping (ORM) Data Access
      • 20.1. Introduction to ORM with Spring
      • 20.2. General ORM integration considerations
        • 20.2.1. Resource and transaction management
        • 20.2.2. Exception translation
      • 20.3. Hibernate
        • 20.3.1. SessionFactory setup in a Spring container
        • 20.3.2. Implementing DAOs based on plain Hibernate API
        • 20.3.3. Declarative transaction demarcation
        • 20.3.4. Programmatic transaction demarcation
        • 20.3.5. Transaction management strategies
        • 20.3.6. Comparing container-managed and locally defined resources
        • 20.3.7. Spurious application server warnings with Hibernate
      • 20.4. JDO
        • 20.4.1. PersistenceManagerFactory setup
        • 20.4.2. Implementing DAOs based on the plain JDO API
        • 20.4.3. Transaction management
        • 20.4.4. JdoDialect
      • 20.5. JPA
        • 20.5.1. Three options for JPA setup in a Spring environment
          • LocalEntityManagerFactoryBean
          • Obtaining an EntityManagerFactory from JNDI
          • LocalContainerEntityManagerFactoryBean
          • Dealing with multiple persistence units
        • 20.5.2. Implementing DAOs based on JPA: EntityManagerFactory and EntityManager
        • 20.5.3. Spring-driven JPA transactions
        • 20.5.4. JpaDialect and JpaVendorAdapter
        • 20.5.5. Setting up JPA with JTA transaction management
    • 21. Marshalling XML using O/X Mappers
      • 21.1. Introduction
        • 21.1.1. Ease of configuration
        • 21.1.2. Consistent interfaces
        • 21.1.3. Consistent exception hierarchy
      • 21.2. Marshaller and Unmarshaller
        • 21.2.1. Marshaller
        • 21.2.2. Unmarshaller
        • 21.2.3. XmlMappingException
      • 21.3. Using Marshaller and Unmarshaller
      • 21.4. XML configuration namespace
      • 21.5. JAXB
        • 21.5.1. Jaxb2Marshaller
          • XML configuration namespace
      • 21.6. Castor
        • 21.6.1. CastorMarshaller
        • 21.6.2. Mapping
          • XML configuration namespace
      • 21.7. XMLBeans
        • 21.7.1. XmlBeansMarshaller
          • XML configuration namespace
      • 21.8. JiBX
        • 21.8.1. JibxMarshaller
          • XML configuration namespace
      • 21.9. XStream
        • 21.9.1. XStreamMarshaller
  • VI. The Web
    • 22. Web MVC framework
      • 22.1. Introduction to Spring Web MVC framework
        • 22.1.1. Features of Spring Web MVC
        • 22.1.2. Pluggability of other MVC implementations
      • 22.2. The DispatcherServlet
        • 22.2.1. Special Bean Types In the WebApplicationContext
        • 22.2.2. Default DispatcherServlet Configuration
        • 22.2.3. DispatcherServlet Processing Sequence
      • 22.3. Implementing Controllers
        • 22.3.1. Defining a controller with @Controller
        • 22.3.2. Mapping Requests With @RequestMapping
          • Composed @RequestMapping Variants
          • @Controller and AOP Proxying
          • New Support Classes for @RequestMapping methods in Spring MVC 3.1
          • URI Template Patterns
          • URI Template Patterns with Regular Expressions
          • Path Patterns
          • Path Pattern Comparison
          • Path Patterns with Placeholders
          • Suffix Pattern Matching
          • Suffix Pattern Matching and RFD
          • Matrix Variables
          • Consumable Media Types
          • Producible Media Types
          • Request Parameters and Header Values
          • HTTP HEAD and HTTP OPTIONS
        • 22.3.3. Defining @RequestMapping handler methods
          • Supported method argument types
          • Supported method return 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 HttpEntity
          • Using @ModelAttribute on a method
          • Using @ModelAttribute on a method argument
          • Using @SessionAttributes to store model attributes in the HTTP session between requests
          • Using @SessionAttribute to access pre-existing global session attributes
          • Using @RequestAttribute to access request 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
          • Advising controllers with @ControllerAdvice and @RestControllerAdvice
          • Jackson Serialization View Support
          • Jackson JSONP Support
        • 22.3.4. Asynchronous Request Processing
          • Exception Handling for Async Requests
          • Intercepting Async Requests
          • HTTP Streaming
          • HTTP Streaming With Server-Sent Events
          • HTTP Streaming Directly To The OutputStream
          • Configuring Asynchronous Request Processing
        • 22.3.5. Testing Controllers
      • 22.4. Handler mappings
        • 22.4.1. Intercepting requests with a HandlerInterceptor
      • 22.5. Resolving views
        • 22.5.1. Resolving views with the ViewResolver interface
        • 22.5.2. Chaining ViewResolvers
        • 22.5.3. Redirecting to Views
          • RedirectView
          • The redirect: prefix
          • The forward: prefix
        • 22.5.4. ContentNegotiatingViewResolver
      • 22.6. Using flash attributes
      • 22.7. Building URIs
        • 22.7.1. Building URIs to Controllers and methods
        • 22.7.2. Working with "Forwarded" and "X-Forwarded-*" Headers
        • 22.7.3. Building URIs to Controllers and methods from views
      • 22.8. Using locales
        • 22.8.1. Obtaining Time Zone Information
        • 22.8.2. AcceptHeaderLocaleResolver
        • 22.8.3. CookieLocaleResolver
        • 22.8.4. SessionLocaleResolver
        • 22.8.5. LocaleChangeInterceptor
      • 22.9. Using themes
        • 22.9.1. Overview of themes
        • 22.9.2. Defining themes
        • 22.9.3. Theme resolvers
      • 22.10. Spring’s multipart (file upload) support
        • 22.10.1. Introduction
        • 22.10.2. Using a MultipartResolver with Commons FileUpload
        • 22.10.3. Using a MultipartResolver with Servlet 3.0
        • 22.10.4. Handling a file upload in a form
        • 22.10.5. Handling a file upload request from programmatic clients
      • 22.11. Handling exceptions
        • 22.11.1. HandlerExceptionResolver
        • 22.11.2. @ExceptionHandler
        • 22.11.3. Handling Standard Spring MVC Exceptions
        • 22.11.4. Annotating Business Exceptions With @ResponseStatus
        • 22.11.5. Customizing the Default Servlet Container Error Page
      • 22.12. Web Security
      • 22.13. Convention over configuration support
        • 22.13.1. The Controller ControllerClassNameHandlerMapping
        • 22.13.2. The Model ModelMap (ModelAndView)
        • 22.13.3. Default view name
      • 22.14. HTTP caching support
        • 22.14.1. Cache-Control HTTP header
        • 22.14.2. HTTP caching support for static resources
        • 22.14.3. Support for the Cache-Control, ETag and Last-Modified response headers in Controllers
        • 22.14.4. Shallow ETag support
      • 22.15. Code-based Servlet container initialization
      • 22.16. Configuring Spring MVC
        • 22.16.1. Enabling the MVC Java Config or the MVC XML Namespace
        • 22.16.2. Customizing the Provided Configuration
        • 22.16.3. Conversion and Formatting
        • 22.16.4. Validation
        • 22.16.5. Interceptors
        • 22.16.6. Content Negotiation
        • 22.16.7. View Controllers
        • 22.16.8. View Resolvers
        • 22.16.9. Serving of Resources
        • 22.16.10. Default Servlet
        • 22.16.11. Path Matching
        • 22.16.12. Message Converters
        • 22.16.13. Advanced Customizations with MVC Java Config
        • 22.16.14. Advanced Customizations with the MVC Namespace
    • 23. View Technologies
      • 23.1. Introduction
      • 23.2. Thymeleaf
      • 23.3. Groovy Markup
        • 23.3.1. Configuration
        • 23.3.2. Example
      • 23.4. Velocity & FreeMarker
        • 23.4.1. Dependencies
        • 23.4.2. Context configuration
        • 23.4.3. Creating templates
        • 23.4.4. Advanced configuration
          • velocity.properties
          • FreeMarker
        • 23.4.5. Bind support and form handling
          • The bind macros
          • Simple binding
          • Form input generation macros
          • HTML escaping and XHTML compliance
      • 23.5. JSP & JSTL
        • 23.5.1. View resolvers
        • 23.5.2. 'Plain-old' JSPs versus JSTL
        • 23.5.3. Spring’s JSP tag library
        • 23.5.4. Spring’s form tag library
          • Configuration
          • The form tag
          • The input tag
          • The checkbox tag
          • The checkboxes tag
          • The radiobutton tag
          • The radiobuttons tag
          • The password tag
          • The select tag
          • The option tag
          • The options tag
          • The textarea tag
          • The hidden tag
          • The errors tag
          • HTTP method conversion
          • HTML5 tags
      • 23.6. Script views
        • 23.6.1. Requirements
        • 23.6.2. Script templates
      • 23.7. XML Marshalling
      • 23.8. Tiles
        • 23.8.1. Dependencies
        • 23.8.2. Configuration
          • UrlBasedViewResolver
          • ResourceBundleViewResolver
          • SimpleSpringPreparerFactory and SpringBeanPreparerFactory
      • 23.9. XSLT
        • 23.9.1. Beans
        • 23.9.2. Controller
        • 23.9.3. Transformation
      • 23.10. Document views: PDF, Excel
        • 23.10.1. Introduction
        • 23.10.2. Configuration
        • 23.10.3. View definition
        • 23.10.4. Controller
        • 23.10.5. Excel views
        • 23.10.6. PDF views
      • 23.11. JasperReports
        • 23.11.1. Dependencies
        • 23.11.2. Configuration
          • Configuring the ViewResolver
          • Configuring the Views
          • About Report Files
          • Using JasperReportsMultiFormatView
        • 23.11.3. Populating the ModelAndView
        • 23.11.4. Working with sub-reports
          • Configuring sub-report files
          • Configuring sub-report data sources
        • 23.11.5. Configuring exporter parameters
      • 23.12. Feed views: RSS, Atom
      • 23.13. JSON Mapping View
      • 23.14. XML Mapping View
    • 24. Integrating with other web frameworks
      • 24.1. Introduction
      • 24.2. Common configuration
      • 24.3. JavaServer Faces 1.2
        • 24.3.1. SpringBeanFacesELResolver (JSF 1.2+)
        • 24.3.2. FacesContextUtils
      • 24.4. Apache Struts 2.x
      • 24.5. Tapestry 5.x
      • 24.6. Further Resources
    • 25. Portlet MVC Framework
      • 25.1. Introduction
        • 25.1.1. Controllers - The C in MVC
        • 25.1.2. Views - The V in MVC
        • 25.1.3. Web-scoped beans
      • 25.2. The DispatcherPortlet
      • 25.3. The ViewRendererServlet
      • 25.4. Controllers
        • 25.4.1. AbstractController and PortletContentGenerator
        • 25.4.2. Other simple controllers
        • 25.4.3. Command Controllers
        • 25.4.4. PortletWrappingController
      • 25.5. Handler mappings
        • 25.5.1. PortletModeHandlerMapping
        • 25.5.2. ParameterHandlerMapping
        • 25.5.3. PortletModeParameterHandlerMapping
        • 25.5.4. Adding HandlerInterceptors
        • 25.5.5. HandlerInterceptorAdapter
        • 25.5.6. ParameterMappingInterceptor
      • 25.6. Views and resolving them
      • 25.7. Multipart (file upload) support
        • 25.7.1. Using the PortletMultipartResolver
        • 25.7.2. Handling a file upload in a form
      • 25.8. Handling exceptions
      • 25.9. Annotation-based controller configuration
        • 25.9.1. Setting up the dispatcher for annotation support
        • 25.9.2. Defining a controller with @Controller
        • 25.9.3. Mapping requests with @RequestMapping
        • 25.9.4. Supported handler method arguments
        • 25.9.5. Binding request parameters to method parameters with @RequestParam
        • 25.9.6. Providing a link to data from the model with @ModelAttribute
        • 25.9.7. Specifying attributes to store in a Session with @SessionAttributes
        • 25.9.8. Customizing WebDataBinder initialization
          • Customizing data binding with @InitBinder
          • Configuring a custom WebBindingInitializer
      • 25.10. Portlet application deployment
    • 26. WebSocket Support
      • 26.1. Introduction
        • 26.1.1. WebSocket Fallback Options
        • 26.1.2. A Messaging Architecture
        • 26.1.3. Sub-Protocol Support in WebSocket
        • 26.1.4. Should I Use WebSocket?
      • 26.2. WebSocket API
        • 26.2.1. WebSocketHandler
        • 26.2.2. WebSocket Handshake
        • 26.2.3. WebSocketHandler Decoration
        • 26.2.4. Deployment
        • 26.2.5. Configuring the WebSocket Engine
        • 26.2.6. Configuring allowed origins
      • 26.3. SockJS Fallback
        • 26.3.1. Overview
        • 26.3.2. Enable SockJS
        • 26.3.3. IE 8, 9
        • 26.3.4. Heartbeats
        • 26.3.5. Client disconnects
        • 26.3.6. SockJS and CORS
        • 26.3.7. SockJsClient
      • 26.4. STOMP
        • 26.4.1. Overview
        • 26.4.2. Benefits
        • 26.4.3. Enable STOMP
        • 26.4.4. Flow of Messages
        • 26.4.5. Annotated Controllers
          • @MessageMapping
          • @SubscribeMapping
          • @MessageExceptionHandler
        • 26.4.6. Send Messages
        • 26.4.7. Simple Broker
        • 26.4.8. External Broker
        • 26.4.9. Connect to Broker
        • 26.4.10. Dot as Separator
        • 26.4.11. Authentication
        • 26.4.12. Token Authentication
        • 26.4.13. User Destinations
        • 26.4.14. Events and Interception
        • 26.4.15. STOMP Client
        • 26.4.16. WebSocket Scope
        • 26.4.17. Performance
        • 26.4.18. Monitoring
        • 26.4.19. Testing
    • 27. CORS Support
      • 27.1. Introduction
      • 27.2. Controller method CORS configuration
      • 27.3. Global CORS configuration
        • 27.3.1. JavaConfig
        • 27.3.2. XML namespace
      • 27.4. Advanced Customization
      • 27.5. Filter based CORS support
  • VII. Integration
    • 28. Remoting and web services using Spring
      • 28.1. Introduction
      • 28.2. Exposing services using RMI
        • 28.2.1. Exporting the service using the RmiServiceExporter
        • 28.2.2. Linking in the service at the client
      • 28.3. Using Hessian or Burlap to remotely call services via HTTP
        • 28.3.1. Wiring up the DispatcherServlet for Hessian and co.
        • 28.3.2. Exposing your beans by using the HessianServiceExporter
        • 28.3.3. Linking in the service on the client
        • 28.3.4. Using Burlap
        • 28.3.5. Applying HTTP basic authentication to a service exposed through Hessian or Burlap
      • 28.4. Exposing services using HTTP invokers
        • 28.4.1. Exposing the service object
        • 28.4.2. Linking in the service at the client
      • 28.5. Web services
        • 28.5.1. Exposing servlet-based web services using JAX-WS
        • 28.5.2. Exporting standalone web services using JAX-WS
        • 28.5.3. Exporting web services using the JAX-WS RI’s Spring support
        • 28.5.4. Accessing web services using JAX-WS
      • 28.6. JMS
        • 28.6.1. Server-side configuration
        • 28.6.2. Client-side configuration
      • 28.7. AMQP
      • 28.8. Auto-detection is not implemented for remote interfaces
      • 28.9. Considerations when choosing a technology
      • 28.10. Accessing RESTful services on the client
        • 28.10.1. RestTemplate
          • Working with the URI
          • Dealing with request and response headers
          • Jackson JSON Views support
        • 28.10.2. HTTP message conversion
          • StringHttpMessageConverter
          • FormHttpMessageConverter
          • ByteArrayHttpMessageConverter
          • MarshallingHttpMessageConverter
          • MappingJackson2HttpMessageConverter
          • MappingJackson2XmlHttpMessageConverter
          • SourceHttpMessageConverter
          • BufferedImageHttpMessageConverter
        • 28.10.3. Async RestTemplate
    • 29. Enterprise JavaBeans (EJB) integration
      • 29.1. Introduction
      • 29.2. Accessing EJBs
        • 29.2.1. Concepts
        • 29.2.2. Accessing local SLSBs
        • 29.2.3. Accessing remote SLSBs
        • 29.2.4. Accessing EJB 2.x SLSBs versus EJB 3 SLSBs
      • 29.3. Using Spring’s EJB implementation support classes
        • 29.3.1. EJB 3 injection interceptor
    • 30. JMS (Java Message Service)
      • 30.1. Introduction
      • 30.2. Using Spring JMS
        • 30.2.1. JmsTemplate
        • 30.2.2. Connections
          • Caching Messaging Resources
          • SingleConnectionFactory
          • CachingConnectionFactory
        • 30.2.3. Destination Management
        • 30.2.4. Message Listener Containers
          • SimpleMessageListenerContainer
          • DefaultMessageListenerContainer
        • 30.2.5. Transaction management
      • 30.3. Sending a Message
        • 30.3.1. Using Message Converters
        • 30.3.2. SessionCallback and ProducerCallback
      • 30.4. Receiving a message
        • 30.4.1. Synchronous reception
        • 30.4.2. Asynchronous reception: Message-Driven POJOs
        • 30.4.3. SessionAwareMessageListener interface
        • 30.4.4. MessageListenerAdapter
        • 30.4.5. Processing messages within transactions
      • 30.5. Support for JCA Message Endpoints
      • 30.6. Annotation-driven listener endpoints
        • 30.6.1. Enable listener endpoint annotations
        • 30.6.2. Programmatic endpoints registration
        • 30.6.3. Annotated endpoint method signature
        • 30.6.4. Response management
      • 30.7. JMS namespace support
    • 31. JMX
      • 31.1. Introduction
      • 31.2. Exporting your beans to JMX
        • 31.2.1. Creating an MBeanServer
        • 31.2.2. Reusing an existing MBeanServer
        • 31.2.3. Lazy-initialized MBeans
        • 31.2.4. Automatic registration of MBeans
        • 31.2.5. Controlling the registration behavior
      • 31.3. Controlling the management interface of your beans
        • 31.3.1. MBeanInfoAssembler interface
        • 31.3.2. Using source-level metadata: Java annotations
        • 31.3.3. Source-level metadata types
        • 31.3.4. AutodetectCapableMBeanInfoAssembler interface
        • 31.3.5. Defining management interfaces using Java interfaces
        • 31.3.6. Using MethodNameBasedMBeanInfoAssembler
      • 31.4. Controlling the ObjectNames for your beans
        • 31.4.1. Reading ObjectNames from Properties
        • 31.4.2. Using the MetadataNamingStrategy
        • 31.4.3. Configuring annotation based MBean export
      • 31.5. JSR-160 Connectors
        • 31.5.1. Server-side connectors
        • 31.5.2. Client-side connectors
        • 31.5.3. JMX over Burlap/Hessian/SOAP
      • 31.6. Accessing MBeans via proxies
      • 31.7. Notifications
        • 31.7.1. Registering listeners for notifications
        • 31.7.2. Publishing Notifications
      • 31.8. Further resources
    • 32. JCA CCI
      • 32.1. Introduction
      • 32.2. Configuring CCI
        • 32.2.1. Connector configuration
        • 32.2.2. ConnectionFactory configuration in Spring
        • 32.2.3. Configuring CCI connections
        • 32.2.4. Using a single CCI connection
      • 32.3. Using Spring’s CCI access support
        • 32.3.1. Record conversion
        • 32.3.2. CciTemplate
        • 32.3.3. DAO support
        • 32.3.4. Automatic output record generation
        • 32.3.5. Summary
        • 32.3.6. Using a CCI Connection and Interaction directly
        • 32.3.7. Example for CciTemplate usage
      • 32.4. Modeling CCI access as operation objects
        • 32.4.1. MappingRecordOperation
        • 32.4.2. MappingCommAreaOperation
        • 32.4.3. Automatic output record generation
        • 32.4.4. Summary
        • 32.4.5. Example for MappingRecordOperation usage
        • 32.4.6. Example for MappingCommAreaOperation usage
      • 32.5. Transactions
    • 33. Email
      • 33.1. Introduction
      • 33.2. Usage
        • 33.2.1. Basic MailSender and SimpleMailMessage usage
        • 33.2.2. Using the JavaMailSender and the MimeMessagePreparator
      • 33.3. Using the JavaMail MimeMessageHelper
        • 33.3.1. Sending attachments and inline resources
          • Attachments
          • Inline resources
        • 33.3.2. Creating email content using a templating library
          • A Velocity-based example
    • 34. Task Execution and Scheduling
      • 34.1. Introduction
      • 34.2. The Spring TaskExecutor abstraction
        • 34.2.1. TaskExecutor types
        • 34.2.2. Using a TaskExecutor
      • 34.3. The Spring TaskScheduler abstraction
        • 34.3.1. Trigger interface
        • 34.3.2. Trigger implementations
        • 34.3.3. TaskScheduler implementations
      • 34.4. Annotation Support for Scheduling and Asynchronous Execution
        • 34.4.1. Enable scheduling annotations
        • 34.4.2. The @Scheduled annotation
        • 34.4.3. The @Async annotation
        • 34.4.4. Executor qualification with @Async
        • 34.4.5. Exception management with @Async
      • 34.5. The task namespace
        • 34.5.1. The 'scheduler' element
        • 34.5.2. The 'executor' element
        • 34.5.3. The 'scheduled-tasks' element
      • 34.6. Using the Quartz Scheduler
        • 34.6.1. Using the JobDetailFactoryBean
        • 34.6.2. Using the MethodInvokingJobDetailFactoryBean
        • 34.6.3. Wiring up jobs using triggers and the SchedulerFactoryBean
    • 35. Dynamic language support
      • 35.1. Introduction
      • 35.2. A first example
      • 35.3. Defining beans that are backed by dynamic languages
        • 35.3.1. Common concepts
          • The <lang:language/> element
          • Refreshable beans
          • Inline dynamic language source files
          • Understanding Constructor Injection in the context of dynamic-language-backed beans
        • 35.3.2. JRuby beans
        • 35.3.3. Groovy beans
          • Customizing Groovy objects via a callback
        • 35.3.4. BeanShell beans
      • 35.4. Scenarios
        • 35.4.1. Scripted Spring MVC Controllers
        • 35.4.2. Scripted Validators
      • 35.5. Bits and bobs
        • 35.5.1. AOP - advising scripted beans
        • 35.5.2. Scoping
      • 35.6. Further resources
    • 36. Cache Abstraction
      • 36.1. Introduction
      • 36.2. Understanding the cache abstraction
      • 36.3. Declarative annotation-based caching
        • 36.3.1. @Cacheable annotation
          • Default Key Generation
          • Custom Key Generation Declaration
          • Default Cache Resolution
          • Custom cache resolution
          • Synchronized caching
          • Conditional caching
          • Available caching SpEL evaluation context
        • 36.3.2. @CachePut annotation
        • 36.3.3. @CacheEvict annotation
        • 36.3.4. @Caching annotation
        • 36.3.5. @CacheConfig annotation
        • 36.3.6. Enable caching annotations
        • 36.3.7. Using custom annotations
      • 36.4. JCache (JSR-107) annotations
        • 36.4.1. Feature summary
        • 36.4.2. Enabling JSR-107 support
      • 36.5. Declarative XML-based caching
      • 36.6. Configuring the cache storage
        • 36.6.1. JDK ConcurrentMap-based Cache
        • 36.6.2. Ehcache-based Cache
        • 36.6.3. Caffeine Cache
        • 36.6.4. Guava Cache
        • 36.6.5. GemFire-based Cache
        • 36.6.6. JSR-107 Cache
        • 36.6.7. Dealing with caches without a backing store
      • 36.7. Plugging-in different back-end caches
      • 36.8. How can I set the TTL/TTI/Eviction policy/XXX feature?
  • VIII. Appendices
    • 37. Migrating to Spring Framework 4.x
    • 38. Spring Annotation Programming Model
    • 39. Classic Spring Usage
      • 39.1. Classic ORM usage
        • 39.1.1. Hibernate
          • The HibernateTemplate
          • Implementing Spring-based DAOs without callbacks
      • 39.2. JMS Usage
        • 39.2.1. JmsTemplate
        • 39.2.2. Asynchronous Message Reception
        • 39.2.3. Connections
        • 39.2.4. Transaction Management
    • 40. Classic Spring AOP Usage
      • 40.1. Pointcut API in Spring
        • 40.1.1. Concepts
        • 40.1.2. Operations on pointcuts
        • 40.1.3. AspectJ expression pointcuts
        • 40.1.4. Convenience pointcut implementations
          • Static pointcuts
          • Dynamic pointcuts
        • 40.1.5. Pointcut superclasses
        • 40.1.6. Custom pointcuts
      • 40.2. Advice API in Spring
        • 40.2.1. Advice lifecycles
        • 40.2.2. Advice types in Spring
          • Interception around advice
          • Before advice
          • Throws advice
          • After Returning advice
          • Introduction advice
      • 40.3. Advisor API in Spring
      • 40.4. Using the ProxyFactoryBean to create AOP proxies
        • 40.4.1. Basics
        • 40.4.2. JavaBean properties
        • 40.4.3. JDK- and CGLIB-based proxies
        • 40.4.4. Proxying interfaces
        • 40.4.5. Proxying classes
        • 40.4.6. Using 'global' advisors
      • 40.5. Concise proxy definitions
      • 40.6. Creating AOP proxies programmatically with the ProxyFactory
      • 40.7. Manipulating advised objects
      • 40.8. Using the "autoproxy" facility
        • 40.8.1. Autoproxy bean definitions
          • BeanNameAutoProxyCreator
          • DefaultAdvisorAutoProxyCreator
          • AbstractAdvisorAutoProxyCreator
        • 40.8.2. Using metadata-driven auto-proxying
      • 40.9. Using TargetSources
        • 40.9.1. Hot swappable target sources
        • 40.9.2. Pooling target sources
        • 40.9.3. Prototype target sources
        • 40.9.4. ThreadLocal target sources
      • 40.10. Defining new Advice types
      • 40.11. Further resources
    • 41. XML Schema-based configuration
      • 41.1. Introduction
      • 41.2. XML Schema-based configuration
        • 41.2.1. Referencing the schemas
        • 41.2.2. the util schema
          • <util:constant/>
          • <util:property-path/>
          • <util:properties/>
          • <util:list/>
          • <util:map/>
          • <util:set/>
        • 41.2.3. the jee schema
          • <jee:jndi-lookup/> (simple)
          • <jee:jndi-lookup/> (with single JNDI environment setting)
          • <jee:jndi-lookup/> (with multiple JNDI environment settings)
          • <jee:jndi-lookup/> (complex)
          • <jee:local-slsb/> (simple)
          • <jee:local-slsb/> (complex)
          • <jee:remote-slsb/>
        • 41.2.4. the lang schema
        • 41.2.5. the jms schema
        • 41.2.6. the tx (transaction) schema
        • 41.2.7. the aop schema
        • 41.2.8. the context schema
          • <property-placeholder/>
          • <annotation-config/>
          • <component-scan/>
          • <load-time-weaver/>
          • <spring-configured/>
          • <mbean-export/>
        • 41.2.9. the tool schema
        • 41.2.10. the jdbc schema
        • 41.2.11. the cache schema
        • 41.2.12. the beans schema
    • 42. Extensible XML authoring
      • 42.1. Introduction
      • 42.2. Authoring the schema
      • 42.3. Coding a NamespaceHandler
      • 42.4. BeanDefinitionParser
      • 42.5. Registering the handler and the schema
        • 42.5.1. 'META-INF/spring.handlers'
        • 42.5.2. 'META-INF/spring.schemas'
      • 42.6. Using a custom extension in your Spring XML configuration
      • 42.7. Meatier examples
        • 42.7.1. Nesting custom tags within custom tags
        • 42.7.2. Custom attributes on 'normal' elements
      • 42.8. Further Resources
    • 43. spring JSP Tag Library
      • 43.1. Introduction
      • 43.2. The argument tag
      • 43.3. The bind tag
      • 43.4. The escapeBody tag
      • 43.5. The eval tag
      • 43.6. The hasBindErrors tag
      • 43.7. The htmlEscape tag
      • 43.8. The message tag
      • 43.9. The nestedPath tag
      • 43.10. The param tag
      • 43.11. The theme tag
      • 43.12. The transform tag
      • 43.13. The url tag
    • 44. spring-form JSP Tag Library
      • 44.1. Introduction
      • 44.2. The button tag
      • 44.3. The checkbox tag
      • 44.4. The checkboxes tag
      • 44.5. The errors tag
      • 44.6. The form tag
      • 44.7. The hidden tag
      • 44.8. The input tag
      • 44.9. The label tag
      • 44.10. The option tag
      • 44.11. The options tag
      • 44.12. The password tag
      • 44.13. The radiobutton tag
      • 44.14. The radiobuttons tag
      • 44.15. The select tag
      • 44.16. The textarea tag
Home API Docs Tools
Home
API Docs
Tools

Part VII. Integration

This part of the reference documentation covers the Spring Framework’s integration with a number of Java EE (and related) technologies.

  • Chapter 28, Remoting and web services using Spring
  • Chapter 29, Enterprise JavaBeans (EJB) integration
  • Chapter 30, JMS (Java Message Service)
  • Chapter 31, JMX
  • Chapter 32, JCA CCI
  • Chapter 33, Email
  • Chapter 34, Task Execution and Scheduling
  • Chapter 35, Dynamic language support
  • Chapter 36, Cache Abstraction
Name Spring Framework Reference
Version
Language
Badge
Last Updated 2021-07-05T14:07:32
扫码关注公众号

Docs4dev®

如果你在使用过程中遇到任何问题,可以在 这里 提issue。

蜀ICP备14021783号-6

Copyright © Docs4dev all right reserved, powered by Docs4dev