Spring---->projects----->Spring Framework

1.Spring Framework概述：

• • Spring Framework是spring若干子项目中的一个
  • Spring Framework的主要功能有：
    • • 依赖注入（dependency injection/IoC）,
      • AOP以及声明式的事务管理机制（Aspect-Oriented Programming including Spring's declarative【声明式的】 transaction management
      • web applications：Spring MVC web application and RESTful web service framework
      • data access：Foundational support for JDBC, JPA, JMS
      • messaging,
      • testing and more.　
  • Spring的全部功能模块（about 20 modules）：
    • • 概述，The Spring Framework总共包含大体20个模块（modules），每一个模块都是Spring框架这个project下的子project，也就是说每一个子module都有惟一的artifactId，项目管理工具（maven/gradle）能够经过引入某个module的artifactId来向开发者的project中引入单独的某个module。换句话说就是，spring framework下的20个模块都是独立的，开发者在使用spring framework的时候彻底能够根据本身项目的实际须要选择向本身的project引入spring framework的20个模块中的任意一个或几个module，而不是将全部module都引入到你的project中（e.g. so for example if you don’t want to write a web application you don’t need the spring-web modules. ）

      • Figure 2.1. Overview of the Spring Framework。The Spring Framework的20个模块能够被分红以下几类：Core Container, Data Access/Integration, Web, AOP (Aspect Oriented Programming), Instrumentation【仪器仪表】, Messaging, and Test类， as shown in the following diagram.

      • Table:Spring framework的20个modules的artifactId，有了artifactId，就可使用项目管理工具（如maven/gradle等）来进行dependencies management了。这些module是相互独立的，能够任意引入其中的一个或多个module。

        • • spring framework的这20个module都会被发布到maven中央仓库，而且Many of the common libraries that Spring depends on also are available from Maven Central，因此可使用maven来进行这些module的dependencies management。使用maven进行dependency management,只须要配置pom.xml,maven就会自动从maven 中央仓库帮你下载相应的jar包到maven本地仓库，你的项目就能够从maven本地仓库找到它的dependencies并使用它们。maven的引入省去了手动下载、添加项目依赖的jar包的过程。
          • the Maven groupId is  org.springframework.
          • Table 2.1. Spring Framework Artifacts（Spring framework的20个module的artifactId）

            GroupId	ArtifactId	Description
            org.springframework	spring-aop	Proxy-based AOP support
            org.springframework	spring-aspects	AspectJ based aspects
            org.springframework	spring-beans	Beans support, including Groovy
            org.springframework	spring-context	Application context runtime, including scheduling and remoting abstractions
            org.springframework	spring-context-support	Support classes for integrating common third-party libraries into a Spring application context
            org.springframework	spring-core	Core utilities, used by many other Spring modules
            org.springframework	spring-expression	Spring Expression Language (SpEL)
            org.springframework	spring-instrument	Instrumentation agent for JVM bootstrapping
            org.springframework	spring-instrument-tomcat	Instrumentation agent for Tomcat
            org.springframework	spring-jdbc	JDBC support package, including DataSource setup and JDBC access support
            org.springframework	spring-jms	JMS support package, including helper classes to send and receive JMS messages
            org.springframework	spring-messaging	Support for messaging architectures and protocols
            org.springframework	spring-orm	Object/Relational Mapping, including JPA and Hibernate support
            org.springframework	spring-oxm	Object/XML Mapping
            org.springframework	spring-test	Support for unit testing and integration testing Spring components
            org.springframework	spring-tx	Transaction infrastructure, including DAO support and JCA integration
            org.springframework	spring-web	Web support packages, including client and web remoting
            org.springframework	spring-webmvc	REST Web Services and model-view-controller implementation for web applications
            org.springframework	spring-webmvc-portlet	MVC implementation to be used in a Portlet environment
            org.springframework	spring-websocket	WebSocket and SockJS implementations, including STOMP support

      • the Spring Framework的20个module，每一个module的功能（详述）

      • • • Core Container（IoC Container）参考资料：

        • • • • 参考资料：
                1. 　　Spring官网：IoC Container
                2. 　　Spring官网：
              • Core Container包括20个module中的5个模块，分别是 spring-core, spring-beans, spring-context, spring-context-support, and spring-expression　这五个module
              • 其中，The spring-core ，spring-context and spring-beans modules 提供IoC功能和依赖注入功能，是the spring framework的基本功能模块，要想使用spring framework的beanfactory（其实是一个配置文件*.xml或者注解）来管理beans，就必需要引入20个module中的　The spring-core and spring-beans modules 。
                • • The org.springframework.beans and org.springframework.context packages are the basis for Spring Framework’s IoC container. 这些包中最主要的两个API是The BeanFactory interface以及 ApplicationContext  interface，这两个接口都是用来管理beans的，建议使用 the ApplicationContext接口。
                  • The BeanFactory interface provides an advanced configuration mechanism capable of managing any type of object.
                  • org.springframework.context.ApplicationContext is a sub-interface of BeanFactory. It adds easier integration with Spring’s AOP features; message resource handling (for use in internationalization), event publication; and application-layer specific contexts such as the WebApplicationContext for use in web applications.　
                  • In short, the BeanFactory provides the configuration framework and basic functionality, and the ApplicationContext adds more enterprise-specific functionality.TheApplicationContext is a complete superset of the BeanFactory,  the ApplicationContext includes all functionality of the BeanFactory，因此通常状况下咱们会使用　ApplicationContext interface，下面这个网址有使用ApplicationContext接口及其实现类管理beans的教程。固然，你也可使用beanFactory来管理你的beans,以下网址是使用BeanFactory接口管理beans的教程。(Spring官网建议使用the ApplicationContext)
              • the spring-context module
                • 依赖于the  spring-core and spring-beans 模块，
                • 功能：support for internationalization【国际化】 (using, for example, resource bundles), event propagation【传播】, resource loading, and the transparent【透明的】 creation of contexts by, for example, a Servlet container. The Context module also supports Java EE features such as EJB, JMX, and basic remoting.
                • 该模块最经常使用的API：The ApplicationContext interface is the focal point of the Context module.　
              • spring-context-support moduleprovides support for integrating common third-party libraries into a Spring application context for caching (EhCache, Guava, JCache), mailing (JavaMail), scheduling (CommonJ, Quartz) and template engines (FreeMarker, JasperReports, Velocity).
              • The spring-expression module provides是JSP2.1规范中的表达式语言的一个扩展，你可使用表达式语言来setting and getting property values, property assignment, method invocation, accessing the content of arrays, collections and indexers, logical and arithmetic operators, named variables, and retrieval of objects by name from Spring’s IoC container. It also supports list projection and selection as well as common list aggregations.

          • AOP and Instrumentation

            • • The spring-aop module提供AOP功能，
              • The separate spring-aspects module provides integration with AspectJ【AspectJ:一个使用java语言编写的面向切面的框架】.　　　　
              • The spring-instrument module provides class instrumentation support and classloader implementations to be used in certain application servers.
              • The spring-instrument-tomcat module contains Spring’s instrumentation agent for Tomcat.

          • Messaging

            • • Spring Framework 4 includes a spring-messaging module to serve as a foundation for messaging-based applications. The module also includes a set of annotations for mapping messages to methods, similar to the Spring MVC annotation based programming model.　　　　

          • Data Access/Integration

            • • The spring-jdbc module provides a JDBC-abstraction【抽象】 layer that removes the need to do tedious 【单调乏味的】JDBC coding and parsing【解析】 of database-vendor【数据库供应商】 specific error codes.

              • The spring-tx module supports programmatic and declarative transaction management for classes that implement special interfaces and for all your POJOs (Plain Old Java Objects).

                The spring-orm module provides integration layers for popular object-relational mapping APIs, including JPA, JDO, and Hibernate. Using the spring-orm module you can use all of these O/R-mapping frameworks in combination with all of the other features Spring offers, such as the simple declarative transaction management feature mentioned previously.

                The spring-oxm module provides an abstraction layer that supports Object/XML mapping implementations such as JAXB, Castor, XMLBeans, JiBX and XStream.

                The spring-jms module (Java Messaging Service) contains features for producing and consuming messages. Since Spring Framework 4.1, it provides integration with the spring-messaging module.

                　　　　

          • Web

            • • The Web layer consists of the spring-web, spring-webmvc, spring-websocket, and spring-webmvc-portlet modules.
              • The spring-web module provides basic web-oriented integration features such as多文件上传功能、初始化IoC 容器等功能（使用Servlet listeners以及面向web的application context来实现这些功能）。 It also contains an HTTP client and the web-related parts of Spring’s remoting support.

              • The spring-webmvc module (also known as the Web-Servlet module) 实现了MVC架构模式以及REST Web Services. Spring’s MVC framework provides a clean separation between domain model code and web forms and integrates with all of the other features of the Spring Framework.

              •  

                The spring-webmvc-portlet module (also known as the Web-Portlet module) provides the MVC implementation to be used in a Portlet environment and mirrors the functionality of the spring-webmvc module.

              • 　　　　

          • Test

            • • The spring-test module supports the unit testing and integration testing of Spring components with JUnit or TestNG. It provides consistent loading of SpringApplicationContexts and caching of those contexts. It also provides mock objects that you can use to test your code in isolation.　　　　

 

2.The Spring Frameork的 使用实例（个人project中引入Spring framework的若干module） 

　　2.1 Minimum requirements

• • • • JDK 6+ for Spring Framework 4.x
      • JDK 5+ for Spring Framework 3.x

       2.2spring framework的20个modules有不一样的组合方法，另外，Spring framework也能够和其余技术进行组合开发

• • • • • Figure 2.2. Typical full-fledged Spring web application

          　　

          Spring’s  declarative transaction management features make the web application fully transactional, just as it would be if you used EJB container-managed transactions. All your custom business logic can be implemented with simple POJOs and managed by Spring’s IoC container. Additional services include support for sending email and validation that is independent of the web layer, which lets you choose where to execute validation rules. Spring’s ORM support is integrated with JPA, Hibernate and JDO; for example, when using Hibernate, you can continue to use your existing mapping files and standard Hibernate  SessionFactory configuration. Form controllers seamlessly integrate the web-layer with the domain model, removing the need for  ActionForms or other classes that transform HTTP parameters to values for your domain model.

        • Figure 2.3. Spring middle-tier using a third-party web framework

          Sometimes circumstances do not allow you to completely switch to a different framework. The Spring Framework does  not force you to use everything within it; it is not an all-or-nothing solution. Existing front-ends built with Struts, Tapestry, JSF or other UI frameworks can be integrated with a Spring-based middle-tier, which allows you to use Spring transaction features. You simply need to wire up your business logic using an ApplicationContext and use a WebApplicationContext to integrate your web layer.

        • Figure 2.5. EJBs - Wrapping existing POJOs

           

          The Spring Framework also provides an access and abstraction layer for Enterprise JavaBeans, enabling you to reuse your existing POJOs and wrap them in stateless session beans for use in scalable, fail-safe web applications that might need declarative security.