Spring Framework

Reference Documentation

(Work in progress)

3.0.M3

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

Preface
1. Introduction
1.1. Dependency Injection
1.2. Modules
1.2.1. Core Container
1.2.2. Data Access/Integration
1.2.3. Web
1.2.4. AOP and Instrumentation
1.2.5. Test
1.3. Usage scenarios
2. What's new in Spring 3.0?
2.1. Java 5
2.2. Improved documentation
2.3. New module organization and build system
2.4. Overview of new features
2.4.1. Core APIs updated for Java 5
2.4.2. Spring Expression Language
2.4.3. The Inversion of Control (IoC) container
2.4.3.1. Java based bean metadata
2.4.3.2. Defining bean metadata within components
2.4.4. The Data Tier
2.4.5. The Web Tier
2.4.5.1. Comprehensive REST support
2.4.5.2. @MVC additions
2.4.6. Declarative model validation
2.4.7. Early support for Java EE 6
3. Getting started with Spring
3.1. Creating an ApplicationContext
3.2. The Data Access Object
3.3. The Business Layer
3.4. The Web UI
I. Core Technologies
4. The IoC container
4.1. Introduction
4.2. Basics - containers and beans
4.2.1. The container
4.2.1.1. Configuration metadata
4.2.2. Instantiating a container
4.2.2.1. Composing XML-based configuration metadata
4.2.3. The beans
4.2.3.1. Naming beans
4.2.3.2. Instantiating beans
4.2.4. Using the container
4.3. Dependencies
4.3.1. Injecting dependencies
4.3.1.1. Constructor Injection
4.3.1.2. Setter Injection
4.3.1.3. Some examples
4.3.2. Dependencies and configuration in detail
4.3.2.1. Straight values (primitives, Strings, etc.)
4.3.2.2. References to other beans (collaborators)
4.3.2.3. Inner beans
4.3.2.4. Collections
4.3.2.5. Nulls
4.3.2.6. Shortcuts and other convenience options for XML-based configuration metadata
4.3.2.7. Compound property names
4.3.3. Using depends-on
4.3.4. Lazily-instantiated beans
4.3.5. Autowiring collaborators
4.3.5.1. Excluding a bean from being available for autowiring
4.3.6. Checking for dependencies
4.3.7. Method Injection
4.3.7.1. Lookup method injection
4.3.7.2. Arbitrary method replacement
4.4. Bean scopes
4.4.1. The singleton scope
4.4.2. The prototype scope
4.4.3. Singleton beans with prototype-bean dependencies
4.4.4. The other scopes
4.4.4.1. Initial web configuration
4.4.4.2. The request scope
4.4.4.3. The session scope
4.4.4.4. The global session scope
4.4.4.5. Scoped beans as dependencies
4.4.5. Custom scopes
4.4.5.1. Creating your own custom scope
4.4.5.2. Using a custom scope
4.5. Customizing the nature of a bean
4.5.1. Lifecycle callbacks
4.5.1.1. Initialization callbacks
4.5.1.2. Destruction callbacks
4.5.1.3. Default initialization & destroy methods
4.5.1.4. Combining lifecycle mechanisms
4.5.1.5. Shutting down the Spring IoC container gracefully in non-web applications
4.5.2. Knowing who you are
4.5.2.1. BeanFactoryAware
4.5.2.2. BeanNameAware
4.6. Bean definition inheritance
4.7. Container extension points
4.7.1. Customizing beans using BeanPostProcessors
4.7.1.1. Example: Hello World, BeanPostProcessor-style
4.7.1.2. Example: The RequiredAnnotationBeanPostProcessor
4.7.2. Customizing configuration metadata with BeanFactoryPostProcessors
4.7.2.1. Example: the PropertyPlaceholderConfigurer
4.7.2.2. Example: the PropertyOverrideConfigurer
4.7.3. Customizing instantiation logic using FactoryBeans
4.8. The ApplicationContext
4.8.1. BeanFactory or ApplicationContext?
4.8.2. Internationalization using MessageSources
4.8.3. Events
4.8.4. Convenient access to low-level resources
4.8.5. Convenient ApplicationContext instantiation for web applications
4.9. Glue code and the evil singleton
4.10. Deploying a Spring ApplicationContext as a J2EE RAR file
4.11. Annotation-based configuration
4.11.1. @Required
4.11.2. @Autowired
4.11.3. Fine-tuning annotation-based autowiring with qualifiers
4.11.4. CustomAutowireConfigurer
4.11.5. @Resource
4.11.6. @PostConstruct and @PreDestroy
4.12. Classpath scanning, managed components and writing configurations using Java
4.12.1. @Component and further stereotype annotations
4.12.2. Auto-detecting components
4.12.3. Using filters to customize scanning
4.12.4. Using the @Configuration annotation
4.12.5. Using the @Bean annotation
4.12.5.1. Declaring a bean
4.12.5.2. Injecting dependencies
4.12.5.3. Receiving lifecycle callbacks
4.12.5.4. Specifying bean scope
4.12.5.5. Customizing bean naming
4.12.6. Defining bean metadata within components
4.12.7. Naming autodetected components
4.12.8. Providing a scope for autodetected components
4.12.9. Providing qualifier metadata with annotations
4.13. Registering a LoadTimeWeaver
5. Resources
5.1. Introduction
5.2. The Resource interface
5.3. Built-in Resource implementations
5.3.1. UrlResource
5.3.2. ClassPathResource
5.3.3. FileSystemResource
5.3.4. ServletContextResource
5.3.5. InputStreamResource
5.3.6. ByteArrayResource
5.4. The ResourceLoader
5.5. The ResourceLoaderAware interface
5.6. Resources as dependencies
5.7. Application contexts and Resource paths
5.7.1. Constructing application contexts
5.7.1.1. Constructing ClassPathXmlApplicationContext instances - shortcuts
5.7.2. Wildcards in application context constructor resource paths
5.7.2.1. Ant-style Patterns
5.7.2.2. The classpath*: prefix
5.7.2.3. Other notes relating to wildcards
5.7.3. FileSystemResource caveats
6. Validation, Data-binding, the BeanWrapper, and PropertyEditors
6.1. Introduction
6.2. Validation using Spring's Validator interface
6.3. Resolving codes to error messages
6.4. Bean manipulation and the BeanWrapper
6.4.1. Setting and getting basic and nested properties
6.4.2. Built-in PropertyEditor implementations
6.4.2.1. Registering additional custom PropertyEditors
7. Spring Expression Language (SpEL)
7.1. Introduction
7.2. Feature Overview
7.3. Expression Evaluation using Spring's Expression Interface
7.3.1. The EvaluationContext interface
7.3.1.1. Type Conversion
7.4. Expression support for defining bean definitions
7.4.1. XML based configuration
7.4.2. Annotation-based configuration
7.5. Language Reference
7.5.1. Literal expressions
7.5.2. Properties, Arrays, Lists, Maps, Indexers
7.5.3. Methods
7.5.4. Operators
7.5.4.1. Relational operators
7.5.4.2. Logical operators
7.5.4.3. Mathematical operators
7.5.5. Assignment
7.5.6. Types
7.5.7. Constructors
7.5.8. Variables
7.5.8.1. The #this variable
7.5.9. Functions
7.5.10. Ternary Operator (If-Then-Else)
7.5.11. Collection Selection
7.5.12. Collection Projection
7.5.13. Expression templating
7.6. Classes used in the examples
8. Aspect Oriented Programming with Spring
8.1. Introduction
8.1.1. AOP concepts
8.1.2. Spring AOP capabilities and goals
8.1.3. AOP Proxies
8.2. @AspectJ support
8.2.1. Enabling @AspectJ Support
8.2.2. Declaring an aspect
8.2.3. Declaring a pointcut
8.2.3.1. Supported Pointcut Designators
8.2.3.2. Combining pointcut expressions
8.2.3.3. Sharing common pointcut definitions
8.2.3.4. Examples
8.2.4. Declaring advice
8.2.4.1. Before advice
8.2.4.2. After returning advice
8.2.4.3. After throwing advice
8.2.4.4. After (finally) advice
8.2.4.5. Around advice
8.2.4.6. Advice parameters
8.2.4.7. Advice ordering
8.2.5. Introductions
8.2.6. Aspect instantiation models
8.2.7. Example
8.3. Schema-based AOP support
8.3.1. Declaring an aspect
8.3.2. Declaring a pointcut
8.3.3. Declaring advice
8.3.3.1. Before advice
8.3.3.2. After returning advice
8.3.3.3. After throwing advice
8.3.3.4. After (finally) advice
8.3.3.5. Around advice
8.3.3.6. Advice parameters
8.3.3.7. Advice ordering
8.3.4. Introductions
8.3.5. Aspect instantiation models
8.3.6. Advisors
8.3.7. Example
8.4. Choosing which AOP declaration style to use
8.4.1. Spring AOP or full AspectJ?
8.4.2. @AspectJ or XML for Spring AOP?
8.5. Mixing aspect types
8.6. Proxying mechanisms
8.6.1. Understanding AOP proxies
8.7. Programmatic creation of @AspectJ Proxies
8.8. Using AspectJ with Spring applications
8.8.1. Using AspectJ to dependency inject domain objects with Spring
8.8.1.1. Unit testing @Configurable objects
8.8.1.2. Working with multiple application contexts
8.8.2. Other Spring aspects for AspectJ
8.8.3. Configuring AspectJ aspects using Spring IoC
8.8.4. Load-time weaving with AspectJ in the Spring Framework
8.8.4.1. A first example
8.8.4.2. Aspects
8.8.4.3. 'META-INF/aop.xml'
8.8.4.4. Required libraries (JARS)
8.8.4.5. Spring configuration
8.8.4.6. Environment-specific configuration
8.9. Further Resources
9. Spring AOP APIs
9.1. Introduction
9.2. Pointcut API in Spring
9.2.1. Concepts
9.2.2. Operations on pointcuts
9.2.3. AspectJ expression pointcuts
9.2.4. Convenience pointcut implementations
9.2.4.1. Static pointcuts
9.2.4.2. Dynamic pointcuts
9.2.5. Pointcut superclasses
9.2.6. Custom pointcuts
9.3. Advice API in Spring
9.3.1. Advice lifecycles
9.3.2. Advice types in Spring
9.3.2.1. Interception around advice
9.3.2.2. Before advice
9.3.2.3. Throws advice
9.3.2.4. After Returning advice
9.3.2.5. Introduction advice
9.4. Advisor API in Spring
9.5. Using the ProxyFactoryBean to create AOP proxies
9.5.1. Basics
9.5.2. JavaBean properties
9.5.3. JDK- and CGLIB-based proxies
9.5.4. Proxying interfaces
9.5.5. Proxying classes
9.5.6. Using 'global' advisors
9.6. Concise proxy definitions
9.7. Creating AOP proxies programmatically with the ProxyFactory
9.8. Manipulating advised objects
9.9. Using the "autoproxy" facility
9.9.1. Autoproxy bean definitions
9.9.1.1. BeanNameAutoProxyCreator
9.9.1.2. DefaultAdvisorAutoProxyCreator
9.9.1.3. AbstractAdvisorAutoProxyCreator
9.9.2. Using metadata-driven auto-proxying
9.10. Using TargetSources
9.10.1. Hot swappable target sources
9.10.2. Pooling target sources
9.10.3. Prototype target sources
9.10.4. ThreadLocal target sources
9.11. Defining new Advice types
9.12. Further resources
10. Testing
10.1. Introduction
10.2. Unit testing
10.2.1. Mock objects
10.2.1.1. JNDI
10.2.1.2. Servlet API
10.2.1.3. Portlet API
10.2.2. Unit testing support classes
10.2.2.1. General utilities
10.2.2.2. Spring MVC
10.3. Integration testing
10.3.1. Overview
10.3.2. Goals
10.3.2.1. Context management and caching
10.3.2.2. Dependency Injection of test fixtures
10.3.2.3. Transaction management
10.3.2.4. Integration testing support classes
10.3.3. JDBC testing support
10.3.4. Annotations
10.3.5. Spring TestContext Framework
10.3.5.1. Key abstractions
10.3.5.2. Context management and caching
10.3.5.3. Dependency Injection of test fixtures
10.3.5.4. Transaction management
10.3.5.5. TestContext support classes
10.3.6. PetClinic example
10.4. Further Resources
II. Data Access
11. Transaction management
11.1. Introduction
11.2. Motivations
11.3. Key abstractions
11.4. Resource synchronization with transactions
11.4.1. High-level approach
11.4.2. Low-level approach
11.4.3. TransactionAwareDataSourceProxy
11.5. Declarative transaction management
11.5.1. Understanding the Spring Framework's declarative transaction implementation
11.5.2. A first example
11.5.3. Rolling back
11.5.4. Configuring different transactional semantics for different beans
11.5.5. <tx:advice/> settings
11.5.6. Using @Transactional
11.5.6.1. @Transactional settings
11.5.7. Transaction propagation
11.5.7.1. Required
11.5.7.2. RequiresNew
11.5.7.3. Nested
11.5.8. Advising transactional operations
11.5.9. Using @Transactional with AspectJ
11.6. Programmatic transaction management
11.6.1. Using the TransactionTemplate
11.6.1.1. Specifying transaction settings
11.6.2. Using the PlatformTransactionManager
11.7. Choosing between programmatic and declarative transaction management
11.8. Application server-specific integration
11.8.1. IBM WebSphere
11.8.2. BEA WebLogic
11.8.3. Oracle OC4J
11.9. Solutions to common problems
11.9.1. Use of the wrong transaction manager for a specific DataSource
11.10. Further Resources
12. DAO support
12.1. Introduction
12.2. Consistent exception hierarchy
12.3. Consistent abstract classes for DAO support
13. Data access using JDBC
13.1. Introduction
13.1.1. Choosing a style
13.1.2. The package hierarchy
13.2. Using the JDBC Core classes to control basic JDBC processing and error handling
13.2.1. JdbcTemplate
13.2.1.1. Examples
13.2.1.2. JdbcTemplate idioms (best practices)
13.2.2. NamedParameterJdbcTemplate
13.2.3. SimpleJdbcTemplate
13.2.4. DataSource
13.2.5. SQLExceptionTranslator
13.2.6. Executing statements
13.2.7. Running Queries
13.2.8. Updating the database
13.2.9. Retrieving auto-generated keys
13.3. Controlling database connections
13.3.1. DataSourceUtils
13.3.2. SmartDataSource
13.3.3. AbstractDataSource
13.3.4. SingleConnectionDataSource
13.3.5. DriverManagerDataSource
13.3.6. TransactionAwareDataSourceProxy
13.3.7. DataSourceTransactionManager
13.3.8. NativeJdbcExtractor
13.4. JDBC batch operations
13.4.1. Batch operations with the JdbcTemplate
13.4.2. Batch operations with the SimpleJdbcTemplate
13.5. Simplifying JDBC operations with the SimpleJdbc classes
13.5.1. Inserting data using SimpleJdbcInsert
13.5.2. Retrieving auto-generated keys using SimpleJdbcInsert
13.5.3. Specifying the columns to use for a SimpleJdbcInsert
13.5.4. Using SqlParameterSource to provide parameter values
13.5.5. Calling a stored procedure using SimpleJdbcCall
13.5.6. Declaring parameters to use for a SimpleJdbcCall
13.5.7. How to define SqlParameters
13.5.8. Calling a stored function using SimpleJdbcCall
13.5.9. Returning ResultSet/REF Cursor from a SimpleJdbcCall
13.6. Modeling JDBC operations as Java objects
13.6.1. SqlQuery
13.6.2. MappingSqlQuery
13.6.3. SqlUpdate
13.6.4. StoredProcedure
13.6.5. SqlFunction
13.7. Common issues with parameter and data value handling
13.7.1. Providing SQL type information for parameters
13.7.2. Handling BLOB and CLOB objects
13.7.3. Passing in lists of values for IN clause
13.7.4. Handling complex types for stored procedure calls
14. Object Relational Mapping (ORM) data access
14.1. Introduction
14.2. Hibernate
14.2.1. Resource management
14.2.2. SessionFactory setup in a Spring container
14.2.3. The HibernateTemplate
14.2.4. Implementing Spring-based DAOs without callbacks
14.2.5. Implementing DAOs based on plain Hibernate 3 API
14.2.6. Programmatic transaction demarcation
14.2.7. Declarative transaction demarcation
14.2.8. Transaction management strategies
14.2.9. Container resources versus local resources
14.2.10. Spurious application server warnings when using Hibernate
14.3. JDO
14.3.1. PersistenceManagerFactory setup
14.3.2. JdoTemplate and JdoDaoSupport
14.3.3. Implementing DAOs based on the plain JDO API
14.3.4. Transaction management
14.3.5. JdoDialect
14.4. Oracle TopLink
14.4.1. SessionFactory abstraction
14.4.2. TopLinkTemplate and TopLinkDaoSupport
14.4.3. Implementing DAOs based on plain TopLink API
14.4.4. Transaction management
14.5. iBATIS SQL Maps
14.5.1. Setting up the SqlMapClient
14.5.2. Using SqlMapClientTemplate and SqlMapClientDaoSupport
14.5.3. Implementing DAOs based on plain iBATIS API
14.6. JPA
14.6.1. JPA setup in a Spring environment
14.6.1.1. LocalEntityManagerFactoryBean
14.6.1.2. Obtaining an EntityManagerFactory from JNDI
14.6.1.3. LocalContainerEntityManagerFactoryBean
14.6.1.4. Dealing with multiple persistence units
14.6.2. JpaTemplate and JpaDaoSupport
14.6.3. Implementing DAOs based on plain JPA
14.6.4. Exception Translation
14.7. Transaction Management
14.8. JpaDialect
15. Marshalling XML using O/X Mappers
15.1. Introduction
15.2. Marshaller and Unmarshaller
15.2.1. Marshaller
15.2.2. Unmarshaller
15.2.3. XmlMappingException
15.3. Using Marshaller and Unmarshaller
15.4. XML Schema-based Configuration
15.5. JAXB
15.5.1. Jaxb2Marshaller
15.5.1.1. XML Schema-based Configuration
15.6. Castor
15.6.1. CastorMarshaller
15.6.2. Mapping
15.7. XMLBeans
15.7.1. XmlBeansMarshaller
15.7.1.1. XML Schema-based Configuration
15.8. JiBX
15.8.1. JibxMarshaller
15.8.1.1. XML Schema-based Configuration
15.9. XStream
15.9.1. XStreamMarshaller
III. The Web
16. Web MVC framework
16.1. Introduction
16.1.1. Pluggability of other MVC implementations
16.1.2. Features of Spring Web MVC
16.2. The DispatcherServlet
16.3. Controllers
16.3.1. AbstractController and WebContentGenerator
16.3.2. Other simple controllers
16.3.3. The MultiActionController
16.3.4. Command controllers
16.4. Handler mappings
16.4.1. BeanNameUrlHandlerMapping
16.4.2. SimpleUrlHandlerMapping
16.4.3. Intercepting requests - the HandlerInterceptor interface
16.5. Views and resolving them
16.5.1. Resolving views - the ViewResolver interface
16.5.2. Chaining ViewResolvers
16.5.3. Redirecting to views
16.5.3.1. RedirectView
16.5.3.2. The redirect: prefix
16.5.3.3. The forward: prefix
16.6. Using locales
16.6.1. AcceptHeaderLocaleResolver
16.6.2. CookieLocaleResolver
16.6.3. SessionLocaleResolver
16.6.4. LocaleChangeInterceptor
16.7. Using themes
16.7.1. Introduction
16.7.2. Defining themes
16.7.3. Theme resolvers
16.8. Spring's multipart (fileupload) support
16.8.1. Introduction
16.8.2. Using the MultipartResolver
16.8.3. Handling a file upload in a form
16.9. Handling exceptions
16.10. Convention over configuration
16.10.1. The Controller - ControllerClassNameHandlerMapping
16.10.2. The Model - ModelMap (ModelAndView)
16.10.3. The View - RequestToViewNameTranslator
16.11. Annotation-based controller configuration
16.11.1. Setting up the dispatcher for annotation support
16.11.2. Defining a controller with @Controller
16.11.3. Mapping requests with @RequestMapping
16.11.3.1. Advanced @RequestMapping options
16.11.4. Supported handler method arguments and return types
16.11.5. Binding request parameters to method parameters with @RequestParam
16.11.6. Providing a link to data from the model with @ModelAttribute
16.11.7. Specifying attributes to store in a Session with @SessionAttributes
16.11.8. Mapping cookie values with the @CookieValue annotation
16.11.9. Mapping request header attributes with the @RequestHeader annotation
16.11.10. Customizing WebDataBinder initialization
16.11.10.1. Customizing data binding with @InitBinder
16.11.10.2. Configuring a custom WebBindingInitializer
16.12. Further Resources
17. View technologies
17.1. Introduction
17.2. JSP & JSTL
17.2.1. View resolvers
17.2.2. 'Plain-old' JSPs versus JSTL
17.2.3. Additional tags facilitating development
17.2.4. Using Spring's form tag library
17.2.4.1. Configuration
17.2.4.2. The form tag
17.2.4.3. The input tag
17.2.4.4. The checkbox tag
17.2.4.5. The checkboxes tag
17.2.4.6. The radiobutton tag
17.2.4.7. The radiobuttons tag
17.2.4.8. The password tag
17.2.4.9. The select tag
17.2.4.10. The option tag
17.2.4.11. The options tag
17.2.4.12. The textarea tag
17.2.4.13. The hidden tag
17.2.4.14. The errors tag
17.3. Tiles
17.3.1. Dependencies
17.3.2. How to integrate Tiles
17.3.2.1. UrlBasedViewResolver
17.3.2.2. ResourceBundleViewResolver
17.3.2.3. SimpleSpringPreparerFactory and SpringBeanPreparerFactory
17.4. Velocity & FreeMarker
17.4.1. Dependencies
17.4.2. Context configuration
17.4.3. Creating templates
17.4.4. Advanced configuration
17.4.4.1. velocity.properties
17.4.4.2. FreeMarker
17.4.5. Bind support and form handling
17.4.5.1. The bind macros
17.4.5.2. Simple binding
17.4.5.3. Form input generation macros
17.4.5.4. HTML escaping and XHTML compliance
17.5. XSLT
17.5.1. My First Words
17.5.1.1. Bean definitions
17.5.1.2. Standard MVC controller code
17.5.1.3. Convert the model data to XML
17.5.1.4. Defining the view properties
17.5.1.5. Document transformation
17.5.2. Summary
17.6. Document views (PDF/Excel)
17.6.1. Introduction
17.6.2. Configuration and setup
17.6.2.1. Document view definitions
17.6.2.2. Controller code
17.6.2.3. Subclassing for Excel views
17.6.2.4. Subclassing for PDF views
17.7. JasperReports
17.7.1. Dependencies
17.7.2. Configuration
17.7.2.1. Configuring the ViewResolver
17.7.2.2. Configuring the Views
17.7.2.3. About Report Files
17.7.2.4. Using JasperReportsMultiFormatView
17.7.3. Populating the ModelAndView
17.7.4. Working with Sub-Reports
17.7.4.1. Configuring Sub-Report Files
17.7.4.2. Configuring Sub-Report Data Sources
17.7.5. Configuring Exporter Parameters
18. REST support
18.1. Introduction
18.2. Creating RESTful services
18.2.1. URI Templates
18.2.1.1. Mapping RESTful URLs with the @PathVariable annotation
18.2.1.2. Mapping the request body with the @RequestBody annotation
18.2.2. Returning multiple representations
18.2.3. Views
18.2.3.1. Feed Views
18.2.3.2. XML Marshalling View
18.2.4. HTTP Method Conversion
18.2.4.1. Supporting Spring form tags
18.2.5. ETag support
18.2.6. Exception Handling
18.3. Accessing RESTful services on the Client
18.3.1. RestTemplate
18.3.2. HTTP Message Conversion
18.3.2.1. StringHttpMessageConverter
18.3.2.2. FormHttpMessageConverter
18.3.2.3. ByteArrayMessageConverter
18.3.2.4. MarshallingHttpMessageConverter
18.3.2.5. SourceHttpMessageConverter
19. Integrating with other web frameworks
19.1. Introduction
19.2. Common configuration
19.3. JavaServer Faces 1.1 and 1.2
19.3.1. DelegatingVariableResolver (JSF 1.1/1.2)
19.3.2. SpringBeanVariableResolver (JSF 1.1/1.2)
19.3.3. SpringBeanFacesELResolver (JSF 1.2+)
19.3.4. FacesContextUtils
19.4. Apache Struts 1.x and 2.x
19.4.1. ContextLoaderPlugin
19.4.1.1. DelegatingRequestProcessor
19.4.1.2. DelegatingActionProxy
19.4.2. ActionSupport Classes
19.5. WebWork 2.x
19.6. Tapestry 3.x and 4.x
19.6.1. Injecting Spring-managed beans
19.6.1.1. Dependency Injecting Spring Beans into Tapestry pages
19.6.1.2. Component definition files
19.6.1.3. Adding abstract accessors
19.6.1.4. Dependency Injecting Spring Beans into Tapestry pages - Tapestry 4.x style
19.7. Further Resources
20. Portlet MVC Framework
20.1. Introduction
20.1.1. Controllers - The C in MVC
20.1.2. Views - The V in MVC
20.1.3. Web-scoped beans
20.2. The DispatcherPortlet
20.3. The ViewRendererServlet
20.4. Controllers
20.4.1. AbstractController and PortletContentGenerator
20.4.2. Other simple controllers
20.4.3. Command Controllers
20.4.4. PortletWrappingController
20.5. Handler mappings
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.8. Handling exceptions
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
20.9.8.1. Customizing data binding with @InitBinder
20.9.8.2. Configuring a custom WebBindingInitializer
20.10. Portlet application deployment
IV. Integration
21. Remoting and web services using Spring
21.1. Introduction
21.2. Exposing services using RMI
21.2.1. Exporting the service using the RmiServiceExporter
21.2.2. Linking in the service at the client
21.3. Using Hessian or Burlap to remotely call services via HTTP
21.3.1. Wiring up the DispatcherServlet for Hessian and co.
21.3.2. Exposing your beans by using the HessianServiceExporter
21.3.3. Linking in the service on the client
21.3.4. Using Burlap
21.3.5. Applying HTTP basic authentication to a service exposed through Hessian or Burlap
21.4. Exposing services using HTTP invokers
21.4.1. Exposing the service object
21.4.2. Linking in the service at the client
21.5. Web services
21.5.1. Exposing servlet-based web services using JAX-RPC
21.5.2. Accessing web services using JAX-RPC
21.5.3. Registering JAX-RPC Bean Mappings
21.5.4. Registering your own JAX-RPC Handler
21.5.5. Exposing servlet-based web services using JAX-WS
21.5.6. Exporting standalone web services using JAX-WS
21.5.7. Exporting web services using the JAX-WS RI's Spring support
21.5.8. Accessing web services using JAX-WS
21.5.9. Exposing web services using XFire
21.6. JMS
21.6.1. Server-side configuration
21.6.2. Client-side configuration
21.7. Auto-detection is not implemented for remote interfaces
21.8. Considerations when choosing a technology
22. Enterprise Java Beans (EJB) integration
22.1. Introduction
22.2. Accessing EJBs
22.2.1. Concepts
22.2.2. Accessing local SLSBs
22.2.3. Accessing remote SLSBs
22.2.4. Accessing EJB 2.x SLSBs versus EJB 3 SLSBs
22.3. Using Spring's EJB implementation support classes
22.3.1. EJB 2.x base classes
22.3.2. EJB 3 injection interceptor
23. JMS (Java Message Service)
23.1. Introduction
23.2. Using Spring JMS
23.2.1. JmsTemplate
23.2.2. Connections
23.2.3. Destination Management
23.2.4. Message Listener Containers
23.2.4.1. SimpleMessageListenerContainer
23.2.4.2. DefaultMessageListenerContainer
23.2.4.3. ServerSessionMessageListenerContainer
23.2.5. Transaction management
23.3. Sending a Message
23.3.1. Using Message Converters
23.3.2. SessionCallback and ProducerCallback
23.4. Receiving a message
23.4.1. Synchronous Reception
23.4.2. Asynchronous Reception - Message-Driven POJOs
23.4.3. The SessionAwareMessageListener interface
23.4.4. The MessageListenerAdapter
23.4.5. Processing messages within transactions
23.5. Support for JCA Message Endpoints
23.6. JMS Namespace Support
24. JMX
24.1. Introduction
24.2. Exporting your beans to JMX
24.2.1. Creating an MBeanServer
24.2.2. Reusing an existing MBeanServer
24.2.3. Lazy-initialized MBeans
24.2.4. Automatic registration of MBeans
24.2.5. Controlling the registration behavior
24.3. Controlling the management interface of your beans
24.3.1. The MBeanInfoAssembler Interface
24.3.2. Using source-Level metadata
24.3.3. Using JDK 5.0 Annotations
24.3.4. Source-Level Metadata Types
24.3.5. The AutodetectCapableMBeanInfoAssembler interface
24.3.6. Defining management interfaces using Java interfaces
24.3.7. Using MethodNameBasedMBeanInfoAssembler
24.4. Controlling the ObjectNames for your beans
24.4.1. Reading ObjectNames from Properties
24.4.2. Using the MetadataNamingStrategy
24.4.3. The <context:mbean-export/> element
24.5. JSR-160 Connectors
24.5.1. Server-side Connectors
24.5.2. Client-side Connectors
24.5.3. JMX over Burlap/Hessian/SOAP
24.6. Accessing MBeans via Proxies
24.7. Notifications
24.7.1. Registering Listeners for Notifications
24.7.2. Publishing Notifications
24.8. Further Resources
25. JCA CCI
25.1. Introduction
25.2. Configuring CCI
25.2.1. Connector configuration
25.2.2. ConnectionFactory configuration in Spring
25.2.3. Configuring CCI connections
25.2.4. Using a single CCI connection
25.3. Using Spring's CCI access support
25.3.1. Record conversion
25.3.2. The CciTemplate
25.3.3. DAO support
25.3.4. Automatic output record generation
25.3.5. Summary
25.3.6. Using a CCI Connection and Interaction directly
25.3.7. Example for CciTemplate usage
25.4. Modeling CCI access as operation objects
25.4.1. MappingRecordOperation
25.4.2. MappingCommAreaOperation
25.4.3. Automatic output record generation
25.4.4. Summary
25.4.5. Example for MappingRecordOperation usage
25.4.6. Example for MappingCommAreaOperation usage
25.5. Transactions
26. Email
26.1. Introduction
26.2. Usage
26.2.1. Basic MailSender and SimpleMailMessage usage
26.2.2. Using the JavaMailSender and the MimeMessagePreparator
26.3. Using the JavaMail MimeMessageHelper
26.3.1. Sending attachments and inline resources
26.3.1.1. Attachments
26.3.1.2. Inline resources
26.3.2. Creating email content using a templating library
26.3.2.1. A Velocity-based example
27. Scheduling and Thread Pooling
27.1. Introduction
27.2. Using the OpenSymphony Quartz Scheduler
27.2.1. Using the JobDetailBean
27.2.2. Using the MethodInvokingJobDetailFactoryBean
27.2.3. Wiring up jobs using triggers and the SchedulerFactoryBean
27.3. Using JDK Timer support
27.3.1. Creating custom timers
27.3.2. Using the MethodInvokingTimerTaskFactoryBean
27.3.3. Wrapping up: setting up the tasks using the TimerFactoryBean
27.4. The Spring TaskExecutor abstraction
27.4.1. TaskExecutor types
27.4.2. Using a TaskExecutor
28. Dynamic language support
28.1. Introduction
28.2. A first example
28.3. Defining beans that are backed by dynamic languages
28.3.1. Common concepts
28.3.1.1. The <lang:language/> element
28.3.1.2. Refreshable beans
28.3.1.3. Inline dynamic language source files
28.3.1.4. Understanding Constructor Injection in the context of dynamic-language-backed beans
28.3.2. JRuby beans
28.3.3. Groovy beans
28.3.3.1. Customising Groovy objects via a callback
28.3.4. BeanShell beans
28.4. Scenarios
28.4.1. Scripted Spring MVC Controllers
28.4.2. Scripted Validators
28.5. Bits and bobs
28.5.1. AOP - advising scripted beans
28.5.2. Scoping
28.6. Further Resources
29. Annotations and Source Level Metadata Support
29.1. Introduction
29.2. Spring's metadata support
29.3. Annotations
29.3.1. @Required
29.3.2. Other @Annotations in Spring
29.4. Integration with Jakarta Commons Attributes
29.5. Metadata and Spring AOP autoproxying
29.5.1. Fundamentals
29.5.2. Declarative transaction management
A. XML Schema-based configuration
A.1. Introduction
A.2. XML Schema-based configuration
A.2.1. Referencing the schemas
A.2.2. The util schema
A.2.2.1. <util:constant/>
A.2.2.2. <util:property-path/>
A.2.2.3. <util:properties/>
A.2.2.4. <util:list/>
A.2.2.5. <util:map/>
A.2.2.6. <util:set/>
A.2.3. The jee schema
A.2.3.1. <jee:jndi-lookup/> (simple)
A.2.3.2. <jee:jndi-lookup/> (with single JNDI environment setting)
A.2.3.3. <jee:jndi-lookup/> (with multiple JNDI environment settings)
A.2.3.4. <jee:jndi-lookup/> (complex)
A.2.3.5. <jee:local-slsb/> (simple)
A.2.3.6. <jee:local-slsb/> (complex)
A.2.3.7. <jee:remote-slsb/>
A.2.4. The lang schema
A.2.5. The jms schema
A.2.6. The tx (transaction) schema
A.2.7. The aop schema
A.2.8. The context schema
A.2.8.1. <property-placeholder/>
A.2.8.2. <annotation-config/>
A.2.8.3. <component-scan/>
A.2.8.4. <load-time-weaver/>
A.2.8.5. <spring-configured/>
A.2.8.6. <mbean-export/>
A.2.9. The tool schema
A.2.10. The beans schema
A.3. Setting up your IDE
A.3.1. Setting up Eclipse
A.3.2. Setting up IntelliJ IDEA
A.3.3. Integration issues
A.3.3.1. XML parsing errors in the Resin v.3 application server
B. Extensible XML authoring
B.1. Introduction
B.2. Authoring the schema
B.3. Coding a NamespaceHandler
B.4. Coding a BeanDefinitionParser
B.5. Registering the handler and the schema
B.5.1. 'META-INF/spring.handlers'
B.5.2. 'META-INF/spring.schemas'
B.6. Using a custom extension in your Spring XML configuration
B.7. Meatier examples
B.7.1. Nesting custom tags within custom tags
B.7.2. Custom attributes on 'normal' elements
B.8. Further Resources
C. spring-beans-2.0.dtd
D. spring.tld
D.1. Introduction
D.2. The bind tag
D.3. The escapeBody tag
D.4. The hasBindErrors tag
D.5. The htmlEscape tag
D.6. The message tag
D.7. The nestedPath tag
D.8. The theme tag
D.9. The transform tag
E. spring-form.tld
E.1. Introduction
E.2. The checkbox tag
E.3. The checkboxes tag
E.4. The errors tag
E.5. The form tag
E.6. The hidden tag
E.7. The input tag
E.8. The label tag
E.9. The option tag
E.10. The options tag
E.11. The password tag
E.12. The radiobutton tag
E.13. The radiobuttons tag
E.14. The select tag
E.15. The textarea tag