spring3.0详解

  一、 Spring 概述
     
            1、Spring介绍：
                          Spring 是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由RodJohnson 创建。
                        简单来说，Spring 是一个分层的 JavaSE/EEfull-stack(一站式) 轻量级开源框架
                        
            2、Spring 作用
                        Spring致力于提供一种方法管理你的业务对象。
                        Spring的主要目的是使JavaEE易用和促进好编程习惯。
                        Spring 致力于 J2EE 应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说 Spring
                    是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring 并不想取
                    代那些已有的框架，而是与它们无缝地整合。
            3． Spring 起源：
                        Spring 的出现是为了取代 EJB（Enterprise JavaBean）的臃肿、低效、脱离现实的特点。
                        传统 J2EE 应用的开发效率低，应用服务器厂商对各种技术的支持并没有真正统一，导致 J2EE
                        的应用没有真正实现 Write Once 及 Run Anywhere 的承诺。Spring 作为开源的中间件，独立
                        于各种应用服务器，甚至无须应用服务器的支持，也能提供应用服务器的功能，如声明式事
                        务、事务处理等        
            4． Spring 体系结构
                        Spring 框架是一个分层架构,,它包含一系列的功能要素并被分为大约 20 个模块。这些模块
                        分为 Core Container、Data Access/Integration、Web、AOP（Aspect Oriented Programming)、
                        Instrumentation 和测试部分,如下图所示：
                      

                      ---核心容器(Core Container)
                            1：Core 和 Beans 模块提供了 Spring 最基础的功能，提供 IoC 和依赖注入特性。这里的基础
                            概念是 BeanFactory，它提供对 Factory 模式的经典实现来消除对程序性单例模式的需要，并
                            真正地允许你从程序逻辑中分离出依赖关系和配置。
                            2：Context 模块基于 Core 和 Beans 来构建，它提供了用一种框架风格的方式来访问对象，
                            有些像 JNDI 注册表。Context 封装包继承了 beans 包的功能，还增加了国际化（I18N）,事件
                            传播，资源装载，以及透明创建上下文，例如通过 servlet 容器，以及对大量 JavaEE 特性的
                            支持，如 EJB、JMX。核心接口是 ApplicationContext。
                            3：Expression Language，表达式语言模块，提供了在运行期间查询和操作对象图的强大能力。
                            支持访问和修改属性值，方法调用，支持访问及修改数组、容器和索引器，命名变量，支持
                            算数和逻辑运算，支持从 Spring 容器获取 Bean，它也支持列表投影、选择和一般的列表聚
                            合等
                      ---数据访问/集成部分(Data Access/Integration) 
                            1：JDBC 模块，提供对 JDBC 的抽象，它可消除冗长的 JDBC 编码和解析数据库厂商特有的错
                            误代码。
                            2：ORM 模块，提供了常用的"对象/关系"映射 API 的集成层。 其中包括 JPA、JDO、Hibernate 
                            和 iBatis 。利用 ORM 封装包，可以混合使用所有 Spring 提供的特性进行"对象/关系"映射，
                            如简单声明性 事务管理 。
                            3：OXM 模块，提供一个支持 Object 和 XML 进行映射的抽象层，其中包括 JAXB、Castor、
                            XMLBeans、JiBX 和 XStream。
                            4：JMS 模块，提供一套"消息生产者、消费者"模板用于更加简单的使用 JMS，JMS 用于在两
                            个应用程序之间，或分布式系统中发送消息，进行异步通信。
                            5：Transaction 模块，支持程序通过简单声明性 事务管理，只要是 Spring 管理对象都能得到
                            Spring 管理事务的好处，即使是 POJO，也可以为他们提供事务。
                     --- Web
                            1：Web-Socket 模块， WebSocket protocol 是 HTML5 一种新的协议。它实现了浏览器与服
                            务器全双工通信，spring 支持 webSocket 通信。
                            2：Web 模块，提供了基础的 web 功能。例如多文件上传、集成 IoC 容器、远程过程访问、
                            以及 Web Service 支持，并提供一个 RestTemplate 类来提供方便的 Restful services 访问
                            3：Web-Servlet 模块，提供了 Web 应用的 Model-View-Controller（MVC）实现。Spring MVC
                            框架提供了基于注解的请求资源注入、更简单的数据绑定、数据验证等及一套非常易用的
                            JSP 标签，完全无缝与 Spring 其他技术协作。
                            4：Web-Portlet 模块，提供了在 Portlet 环境下的 MVC 实现
                     ---AOP
                            1：AOP 模块，提供了符合 AOP 联盟规范的面向方面的编程实现，让你可以定义如方法拦截
                            器和切入点，从逻辑上讲，可以减弱代码的功能耦合，清晰的被分离开。而且，利用源码级
                            的元数据功能，还可以将各种行为信息合并到你的代码中 。
                            2：Aspects 模块，提供了对 AspectJ 的集成。
                            3：Instrumentation 模块， 提供一些类级的工具支持和 ClassLoader 级的实现，可以在一些
                            特定的应用服务器中使用
                     ---Test
                            1：Test 模块，提供对使用 JUnit 和 TestNG 来测试 Spring 组件的支持，它提供一致的
                            ApplicationContexts 并缓存这些上下文，它还能提供一些 mock 对象，使得你可以独立的测
                            试代码
                            
                5． Spring 优点：
                             方便解耦，简化开发
                            Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理
                             AOP 编程的支持
                            Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
                             声明式事务的支持
                            只需要通过配置就可以完成对事务的管理，而无需手动编程
                             方便程序的测试
                            Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序
                             方便集成各种优秀框架
                            Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、
                            MyBatis、Quartz 等）的直接支持
                             降低 JavaEE API 的使用难度
                            Spring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等），都提供了封
                            装，使这些 API 应用难度大大降低
                        
                        二、 IOC 与 DI
                            1、Spring 的 jar 包下载
                                Spring 的官网：spring.io
                                我们课程中讲解使用的是 spring4.2.4
                                在 spring3.0.2 版本后，不在提供依赖 jar 包
                             
                                docs 存在 API 和规范文档
                                libs 开发 jar 包
                                schema 开发过程中需要的 xml 的 schema 约束
                            2、spring 开发环境搭建
                                在 spring 开发中，我们要根据不同的情况来导入不同的 jar 包，当前我们要讲解的是关于 ioc
                                与 di
                                对于 ioc 与 di 讲解我们只需要使用 spring 的核心功能。
                                1. beans 相关
                                2. core 相关
                                3. context 相关
                                4. spel 相关
                              

                                我们使用 spring 框架也会使用到配置文件，我们需要在 src 下创建一个关于 spring 的配置文
                                件，一般情况名称叫 applicationContext.xml
                                问题：applicationContext.xml 约束？
                              

                                它的路径:
                                spring-framework-4.2.4.RELEASE-dist\spring-framework-4.2.4.RELEASE\docs\spring-framework-r
                                eference\html
                              

                            3、IOC 快速入门
                                Ioc 它是什么，解决什么问题，它的原理是如何实现。
                                IOC inversion of Controller 控制反转。
                                在程序中所说的 IOC 其实简单说，就是原来由我们自己实例化的对象交给 spring 容器来实始
                                化。这时对象的实始化的权利就会反转。
                                程序运行时报错
                             

                                原因:当前环境需要一个 commons-loggin 的 jar 包
                                总结 spring 使用步骤:
                                1. 在 applicationContext.xml 文件中配置 bean
                                   如：<bean id="userService"  class="com.lhs.ioc.UserServiceImpl"> </bean>
                                2. 创建一个 ApplicationContext 对象
                                   ApplicationContext它是BeanFactory的一个子接口，我们在使用时使用的是AppliCationContext的
                                   实现类ClassPathXmlApplicationContext
                                

                                   可以通过 getBean(配置文件中 id 名称)来获取指定的对象。
                                   
                        4． DI
                                DI:dependency injection 依赖注入
                                在 spring 框架负责创建 Bean 对象时，动态将依赖对象注入到 Bean 组件。
                                

                                 简单说，这时 UserServiceImpl 中的 info 属性值就是 ITCAST
                                面试题:IOC 和 DI 区别?
                                IOC 控制反转，是指对象实例化权利由 spring 容器来管理
                                DI 依赖注入 在 spring 创建对象的过程中，对象所依赖的属性通过配置注入对象中。
                                
                    三、 Bean 获取与实例化
                         1． ApplicationContext 与 BeanFactory 关系
                          

                             ApplicationContext 它是扩展 BeanFactory 接口。
                             BeanFactory 它采取延迟加载的方案，只有真正在 getBean 时才会实例化 Bean
                             在开发中我们一般使用的是 ApplicationContext,真正使用的是其实现类,
                             FileSystemXmlAppliCationContext 根据文件路径获取
                             ClassPathXmlApplicationContext 根据类路径获取
                             AppliCationContext它会在配置文件加载时，就会初始化Bean,并且ApplicationContext
                             它 提 供 不 同 的 应 用 层 的 Context 实现。例如在 web 开 发 中 可 以 使 用
                             WebApplicationContext.
                         2、Bean 的实例化方式
                             1、无参数构造
                                    对于这种方式，注意 Bean 类中必须提供无参数构造。
                                    <bean name="bean1"  class="com.lhs.bean.Bean1"> </bean>
                                
                             2、静态工厂方法
                                    需要创建一个工厂类，在工厂类中提供一个 static 返回 bean 对象的方法就可以
                                  

                                  
                             3、实例工厂方法
                                    需要创建一个工厂类，在工厂类中提供一个非 static 的创建 bean 对象的方法，在配置文件
                                    中需要将工厂配置，还需要配置 bean
                                  

                                    <bean name="bean3Factory"  class="com.lhs.bean.Bean3Factory"> </bean>
                                    <bean name="bean3" factory-bean="bean3Factory"  factory-method="createBean3"> </bean>
                            
                        3． Bean 的作用域
                                  
                                    在 bean 声明时它有一个 scope 属性，它是用于描述 bean 的作用域。
                                    可取值有:
                                    singleton:单例 代表在 spring ioc 容器中只有一个 Bean 实例 (默认的 scope)
                                    prototype 多例 每一次从 spring 容器中获取时，都会返回一个新的实例
                                    request 用在 web 开发中，将 bean 对象 request.setAttribute()存储到 request 域中
                                    session 用在 web 开发中，将 bean 对象 session.setAttribute()存储到 session 域中
                                    在开如常用的值是 singleton 与 prototype
                                    
                        4． Bean 的生命周期
                                  
                                    1. instantiate bean 对象实例化
                                    2. populate properties 封装属性
                                    3. 如果 Bean 实现 BeanNameAware 执行 setBeanName
                                    4. 如果 Bean 实现 BeanFactoryAwar 或 ApplicationContextAwar 设置工厂 setBeanFactory 或上
                                    下文对象 setApplicationContext
                                    5. 如果存在类实现 BeanPostProcess(后处理 Bean),执行 postProcessBeforeInitialization
                                    6. 如果 Bean 实现 InitializingBean 执行 afterPropertiesSet
                                    7. 调用自定义的 init-method 方法
                                    8. 如果存在类实现 BeanPostProcessor(处理 Bean),执行 postProcessAfterInitialization
                                    9. 执行业务处理
                                    10. 如果 Bean 实现 DisposableBean 执行 destroy
                                    11. 调用自定义的 destroy-method
                                    对于 bean 的生命周期方法:
                                    第三步与第四步是让 Bean 了解 spring 容器。
                                    第五步与第八步 可以针对指定的 Bean 进行功能增强，这时一般会使用动态代理.
                                    第六步与第十步:通过实现指定的接口来完成 init 与 destroy 操作
                                    但是在开发中一般不使用第 6 步与第 10 步，原因是我们可以使用第 7 步与第 11 步来完成。
                                    第 7 步与第 11 步的初始化与销毁操作它无耦合，推荐使用的。但是必须在配置文件中指定
                                    初始化与销毁的方法
                                    
                                    <bean id="beanLifeCycle" class="com.lhs.bean.BeanLifeCycle"
                                        init-method="myInit"   destory-method="myDestory">
                                        <property name="name"  value="itcast"> </property>
                                    </bean>
                                    总结:
                                        对于 bean 的生命周期，我们需要关注的主要有两个方法:
                                        1. 增强 bean 的功能可以使用后处理 Bean, BeanPostProcessor
                                        2. 如果需要初始化或销毁操作我们可以使用 init-method destroy-method
                                        注意:destroy-method 只对 scope=singleTon 有效果。
                    四、 Bean 属性注入
                                   在 spring 中 bean 的属性注入有两种
                                   1、构造器注入
                                      <bean id="car" class="com.lhs.di.Car">
                                             <construtor-arg index="0" type="java.lang.String"  value="弹窗"> </construtor-arg>
                                             <construtor-arg index="1" type="double"  value="1000000"> </construtor-arg>
                                      </bean>
                                      
                                   2、Setter方法注入
                                       <!-- 使用setter方法对car的属性进行注入 -->
                                       <bean id="car1"  class="com.lhs.di.Car">
                                             <property name="name"  value="宝马" />
                                             <property name="price"  value="500000" />
                                        </bean>
                                      关于 ref属性作用
                                        <bean id="person" class="com.lhs.do.Person">
                                             <property name="name"  value="张三" />
                                             <property name="car"  ref="car1" />
                                        </bean>
                                      使用 ref 来引入另一个 bean 对象，完成 bean 之间注入
                                      
                                   3、集合属性的注入
                                        在 spring 中对于集合属性，可以使用专门的标签来完成注入例如:list set map properties
                                        等集合元素来完成集合属性注入
                                      
                                        3.1． List 属性注入
                                          
                                            如果属性是数组类型也可以使用 list 完成注入
                                        3.2． Set 属性注入
                                          
                                        3.3． Map 属性注入
                                        
                                        3.4． Properties 属性注入
                                            Java.util.Properties 是 java.utilsMap 的实现类，它的 key 与 value 都是 String 类型.