spring-framework-reference(英文原版pdf官方参考文档) Spring F

文件名称: spring-framework-reference(英文原版pdf官方参考文档)

所属分类: Web开发

开发工具:

文件大小: 5mb

下载次数: 0

上传时间: 2017-01-20

提供者: love_******

下载 (5mb)

不能下载？报告错误

详细说明： 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 , Sebastien Deleuze 4.3.5.RELEASE Copyright © 2004-2016 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 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. 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 Not Using Commons Logging Using SLF4J Using Log4J 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 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 7.13.2. XML bean definition profiles Activating a profile Default profile 7.13.3. PropertySource abstraction 7.13.4. @PropertySource 7.13.5. 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*: portability 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. Feature Overview 10.3. Expression Evaluation using Spring’s Expression Interface 10.3.1. The EvaluationContext interface Type Conversion 10.3.2. Parser configuration 10.3.3. SpEL compilation Compiler configuration Compiler limitations 10.4. Expression support for defining bean definitions 10.4.1. XML based configuration 10.4.2. Annotation-based configuration 10.5. Language Reference 10.5.1. Literal expressions 10.5.2. Properties, Arrays, Lists, Maps, Indexers 10.5.3. Inline lists 10.5.4. Inline Maps 10.5.5. Array construction 10.5.6. Methods 10.5.7. Operators Relational operators Logical operators Mathematical operators 10.5.8. Assignment 10.5.9. Types 10.5.10. Constructors 10.5.11. Variables The #this and #root variables 10.5.12. Functions 10.5.13. Bean references 10.5.14. Ternary Operator (If-Then-Else) 10.5.15. The Elvis Operator 10.5.16. Safe Navigation operator 10.5.17. Collection Selection 10.5.18. Collection Projection 10.5.19. Expression templating 10.6. 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 TestNG support classes 15.6. Spring MVC Test Framework 15.6.1. Server-Side Tests Static Imports Setup Options 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. 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 Schema-based Configuration 21.5. JAXB 21.5.1. Jaxb2Marshaller XML Schema-based Configuration 21.6. Castor 21.6.1. CastorMarshaller 21.6.2. Mapping XML Schema-based Configuration 21.7. XMLBeans 21.7.1. XmlBeansMarshaller XML Schema-based Configuration 21.8. JiBX 21.8.1. JibxMarshaller XML Schema-based Configuration 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. 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. The View - RequestToViewNameTranslator 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. Falling Back On the "Default" Servlet To Serve Resources 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 Templates 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. Additional tags facilitating development 23.5.4. Using 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 templates 23.6.1. Dependencies 23.6.2. How to integrate script based templating 23.7. XML Marshalling View 23.8. Tiles 23.8.1. Dependencies 23.8.2. How to integrate Tiles UrlBasedViewResolver ResourceBundleViewResolver SimpleSpringPreparerFactory and SpringBeanPreparerFactory 23.9. XSLT 23.9.1. My First Words Bean definitions Standard MVC controller code Document transformation 23.10. Document views (PDF/Excel) 23.10.1. Introduction 23.10.2. Configuration and setup Document view definitions Controller code Subclassing for Excel views Subclassing for 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 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. Create and Configure a WebSocketHandler 26.2.2. Customizing the WebSocket Handshake 26.2.3. WebSocketHandler Decoration 26.2.4. Deployment Considerations 26.2.5. Configuring the WebSocket Engine 26.2.6. Configuring allowed origins 26.3. SockJS Fallback Options 26.3.1. Overview of SockJS 26.3.2. Enable SockJS 26.3.3. HTTP Streaming in IE 8, 9: Ajax/XHR vs IFrame 26.3.4. Heartbeat Messages 26.3.5. Servlet 3 Async Requests 26.3.6. CORS Headers for SockJS 26.3.7. SockJS Client 26.4. STOMP Over WebSocket Messaging Architecture 26.4.1. Overview of STOMP 26.4.2. Enable STOMP over WebSocket 26.4.3. Flow of Messages 26.4.4. Annotation Message Handling 26.4.5. Sending Messages 26.4.6. Simple Broker 26.4.7. Full-Featured Broker 26.4.8. Connections To Full-Featured Broker 26.4.9. Using Dot as Separator in @MessageMapping Destinations 26.4.10. Authentication 26.4.11. Token-based Authentication 26.4.12. User Destinations 26.4.13. Listening To ApplicationContext Events and Intercepting Messages 26.4.14. STOMP Client 26.4.15. WebSocket Scope 26.4.16. Configuration and Performance 26.4.17. Runtime Monitoring 26.4.18. Testing Annotated Controller Methods 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. the SessionAwareMessageListener interface 30.4.4. the 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. the MBeanInfoAssembler Interface 31.3.2. Using Source-Level Metadata (Java annotations) 31.3.3. Source-Level Metadata Types 31.3.4. the 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. the 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. the 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 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. Features 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 41.2.3. the jee schema (simple) (with single JNDI environment setting) (with multiple JNDI environment settings) (complex) (simple) (complex) 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 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 Part I. Overview of Spring Framework The Spring Framework is a lightweight solution and a potential one-stop-shop for building your enterprise-ready applications. However, Spring is modular, allowing you to use only those parts that you need, without having to bring in the rest. You can use the IoC container, with any web framework on top, but you can also use only the Hibernate integration code or the JDBC abstraction layer. The Spring Framework supports declarative transaction management, remote access to your logic through RMI or web services, and various options for persisting your data. It offers a full-featured MVC framework, and enables you to integrate AOP transparently into your software. Spring is designed to be non-intrusive, meaning that your domain logic code generally has no dependencies on the framework itself. In your integration layer (such as the data access layer), some dependencies on the data access technology and the Spring libraries will exist. However, it should be easy to isolate these dependencies from the rest of your code base. This document is a reference guide to Spring Framework features. If you have any requests, comments, or questions on this document, please post them on the user mailing list. Questions on the Framework itself should be asked on StackOverflow (see https://spring.io/questions). 1. Getting Started with Spring This reference guide provides detailed information about the Spring Framework. It provides comprehensive documentation for all features, as well as some background about the underlying concepts (such as "Dependency Injection") that Spring has embraced. If you are just getting started with Spring, you may want to begin using the Spring Framework by creating a Spring Boot based application. Spring Boot provides a quick (and opinionated) way to create a production-ready Spring based application. It is based on the Spring Framework, favors convention over configuration, and is designed to get you up and running as quickly as possible. You can use start.spring.io to generate a basic project or follow one of the "Getting Started" guides like the Getting Started Building a RESTful Web Service one. As well as being easier to digest, these guides are very task focused, and most of them are based on Spring Boot. They also cover other projects from the Spring portfolio that you might want to consider when solving a particular problem. 2. Introduction to the Spring Framework The Spring Framework is a Java platform that provides comprehensive infrastructure support for developing Java applications. Spring handles the infrastructure so you can focus on your application. Spring enables you to build applications from "plain old Java objects" (POJOs) and to apply enterprise services non-invasively to POJOs. This capability applies to the Java SE programming model and to full and partial Java EE. Examples of how you, as an application developer, can benefit from the Spring platform: Make a Java method execute in a database transaction without having to deal with transaction APIs. Make a local Java method a remote procedure without having to deal with remote APIs. Make a local Java method a management operation without having to deal with JMX APIs. Make a local Java method a message handler without having to deal with JMS APIs. 2.1 Dependency Injection and Inversion of Control A Java application — a loose term that runs the gamut from constrained, embedded applications to n-tier, server-side enterprise applications — typically consists of objects that collaborate to form the application proper. Thus the objects in an application have dependencies on each other. Although the Java platform provides a wealth of application development functionality, it lacks the means to organize the basic building blocks into a coherent whole, leaving that task to architects and developers. Although you can use design patterns such as Factory, Abstract Factory, Builder, Decorator, and Service Locator to compose the various classes and object instances that make up an application, these patterns are simply that: best practices given a name, with a description of what the pattern does, where to apply it, the problems it addresses, and so forth. Patterns are formalized best practices that you must implement yourself in your application. The Spring Framework Inversion of Control (IoC) component addresses this concern by providing a formalized means of composing disparate components into a fully working application ready for use. The Spring Framework codifies formalized design patterns as first-class objects that you can integrate into your own application(s). Numerous organizations and institutions use the Spring Framework in this manner to engineer robust, maintainable applications. Background "The question is, what aspect of control are [they] inverting?" Martin Fowler posed this question about Inversion of Control (IoC) on his site in 2004. Fowler suggested renaming the principle to make it more self-explanatory and came up with Dependency Injection. 2.2 Modules The Spring Framework consists of features organized into about 20 modules. These modules are grouped into Core Container, Data Access/Integration, Web, AOP (Aspect Oriented Programming), Instrumentation, Messaging, and Test, as shown in the following diagram. Figure 2.1. Overview of the Spring Framework spring overview The following sections list the available modules for each feature along with their artifact names and the topics they cover. Artifact names correlate to artifact IDs used in Dependency Management tools. 2.2.1 Core Container The Core Container consists of the spring-core, spring-beans, spring-context, spring-context-support, and spring-expression (Spring Expression Language) modules. The spring-core and spring-beans modules provide the fundamental parts of the framework, including the IoC and Dependency Injecti ...展开收缩