Spring学习01

一、概述
1.什么是 Spring
Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作 Expert One-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。它是 为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使 用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring 使用基本的 JavaBean 来完成以前只可能由 EJB 完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、 可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。Spring 的核心是控制反转 （IoC）和面向切面（AOP）。简单来说，Spring 是一个分层的 JavaSE/EEfull-stack(一站式) 轻量级 开源框架。
EE 开发分成三层结构:

• WEB 层:Spring MVC.
• 业务层:Bean 管理:(IOC)
• 持久层:Spring 的 JDBC 模板.ORM 模板用于整合其他的持久层框架
  2.为什么学习 Spring
  方便解耦，简化开发
  Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理
  AOP编程的支持
  Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能 声明式事务的支持 只需要通过配置就可以完成对事务的管理，而无需手动编程
  方便程序的测试
  Spring对Junit4 支持，可以通过注解方便的测试 Spring 程序 方便集成各种优秀框架
  Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、 MyBatis、Quartz 等）的直接支持
  降低JavaEE API的使用难度
  Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装， 使这些API应用难度大大降低 。
  3.Spring 的入门案例:(IOC)
  
  IOC：Inversion of Control 控制反转. 指的是对象的创建权反转(交给)给Spring. 作用是实现了程序的解耦合。

步骤1：导包

步骤二：引入相关配置文件

log4j.properties 
applicationContext.xml 
引入约束: spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configur ation.html 
 
<beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     
xsi:schemaLocation="         
http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd"> 
 
</beans> 

或者

步骤三：编写相关的类:

public interface UserDao {    
public void sayHello();
 } 
 
public class UserDaoImpl implements UserDao { 
 
 @Override  
 public void sayHello() {   
 System.out.println("Hello Spring..."); 
  } 
 
} 

步骤四：完成配置

 <!-- Spring 的入门案例================ -->  
 <bean id="userDao" class="cn.spring.demo1.UserDaoImpl"></bean> 

步骤五：代码测试

public void fun1(){
		
		//1 创建容器对象
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2 向容器"要"user对象
		User u = (User) ac.getBean("user");
		//3 打印user对象
		System.out.println(u);
		
		
	}

4.IOC和DI:
IOC :控制反转,将对象的创建权交给了 Spring.
DI :Dependency Injection 依赖注入.需要有IOC的环境,Spring创建这个类的过程中,Spring将类的依 赖的属性设置进去.

5.Spring中的工厂
ApplicationContext:
每次容器启动时就会创建容器中配置的所有对象.并提供更多功能
ApplicatioContext 接口有两个实现类:
ClassPathXmlApplicationContext :加载类路径下Spring 的配置文件. FileSystemXmlApplicationContext :加载本地磁盘下Spring 的配置文件.

BeanFactory接口：
spring原始接口.针对原始接口的实现类功能较为单一
BeanFactory接口实现类的容器.特点是每次在获得对象时才会创建对象

BeanFactory 和 ApplicationContext 的区别:
BeanFactory :是在 getBean 的时候才会生成类的实例.
ApplicationContext :在加载 applicationContext.xml(容器启动)时候就会创建.

结论:web开发中,使用applicationContext. 在资源匮乏的环境可以使用BeanFactory.

二、Spring配置详解
1.bean元素
id :Bean 起个名字. 在约束中采用 ID 的约束:唯一. 必须以字母开始，可以使用字母、数字、连字符、 下划线、句话、冒号 id:不能出现特殊字符.

<bean id=”bookAction”> 

name:Bean 起个名字. 没有采用 ID 的约束. name:出现特殊字符.如果没有 id 的话 , name 可 以当做 id 使用.
整合 struts1 的时候: <bean name=”/loginAction” >

2.scope属性：Bean 的作用范围.
singleton(默认值):单例对象.被标识为单例的对象在spring容器中只会存在一个实例
prototype:多例原型.被标识为多例的对象,每次再获得才会创建.每次创建都是新的对象.整合struts2时,ActionBean必须配置为多例的.
request :WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中
session :WEB项目中,Spring 创建一个Bean的对象,将对象存入到session域中
globalSession :WEB 项目中,应用在Porlet环境.如果没有 Porlet环境那么 globalSession相当session

3.Bean的生命周期的配置
通过配置<bean>标签上的 init-method 作为 Bean 的初始化的时候执行的方法，配置 destroy-method 作为 Bean 的销毁的时候执行的方法。
销毁方法想要执行，需要是单例创建的 Bean 而且在工厂关闭的时候，Bean 才会被销毁.
4.Spring生成Bean的时候三种方式
无参数的构造方法的方式：

<!-- 方式一：无参数的构造方法的实例化 --> 
<bean id="bean1" class="cn.spring.demo3.Bean1"></bean> 

静态工厂实例化的方式：

提供一个工厂类： public class Bean2Factory { 
 
 public static Bean2 getBean2(){   
 return new Bean2(); 
  }   
 } 
 
<!-- 方式二：静态工厂实例化 Bean --> 
<bean id="bean2" class="cn.spring.demo3.Bean2Factory" factory-method="getBean2"/> 

实例工厂实例化的方式：

提供 Bean3 的实例工厂: public class Bean3Factory {    
public Bean3 getBean3(){   
return new Bean3(); 
 } 
} 
 
<!-- 方式三：实例工厂实例化 Bean --> 
<bean id="bean3Factory" class="cn.spring.demo3.Bean3Factory"></bean> 
<bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean> 

Spring的分模块配置：
三、Spring的属性注入
1.set 方法的方式注入属性

<!-- 第一种：set 方法的方式 -->  
<bean id="car2" class="cn.spring.demo4.Car2"> 
  <property name="name" value=" 奇瑞 QQ"/>   
  <property name="price" value="40000"/>  
</bean>
<!-- 注入对象类型的属性 -->  
<bean id="person" class="cn.spring.demo4.Person"> 
  <property name="name" value=" 会希 "/>  
   <!-- ref 属性：引用另一个 bean 的 id 或 name -->   
   <property name="car2" ref="car2"/>  
</bean>

2.构造方法的方式注入属性:

<!-- 第二种：构造方法的方式 -->  
<bean id="car" class="cn.spring.demo4.Car"> 
  <constructor-arg name="name" value=" 保时捷 "/>  
  <constructor-arg name="price" value="1000000"/>  
</bean>

3. 名称空间p的属性注入的方式:Spring2.x 版本后提供的方式

第一步:引入 p 名称空间 
<beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:p="http://www.springframework.org/schema/p"     
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     
 xsi:schemaLocation="         
 http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans.xsd"> 
 
第二步:使用 p 名称空间.    
 * 普通属性:      p:属性名称=””    
 * 对象类型属性: p:属性名称-ref=”” 
  <!-- p 名称空间的属性注入的方式 -->  
  <bean id="car2" class="cn.itcast.spring.demo4.Car2" p:name=" 宝马 7" p:price="1200000"/> 
  <bean id="person" class="cn.itcast.spring.demo4.Person" p:name=" 思聪" p:car2-ref="car2"/> 

4.SpEL的方式的属性注入:Spring3.x 版本后提供的方式

SpEL：Spring Expression Language. 
语法:#{ SpEL } 
 
 <!-- SpEL 的注入的方式 -->  
 <bean id="car2" class="cn.itcast.spring.demo4.Car2"> 
  <property name="name" value="#{' 奔驰 '}"/>   
  <property name="price" value="#{800000}"/>  
 </bean> 
 
    <bean id="person" class="cn.itcast.spring.demo4.Person"> 
     <property name="name" value="#{'冠希'}"/>      
     <property name="car2" value="#{car2}"/>     
    </bean> 
 
 <bean id="carInfo" class="cn.itcast.spring.demo4.CarInfo"></bean>   
  引用了另一个类的属性  
  <bean id="car2" class="cn.itcast.spring.demo4.Car2"> 
<!--   <property name="name" value="#{'奔驰'}"/> -->   
<property name="name" value="#{carInfo.carName}"/>   
<property name="price" value="#{carInfo.calculatePrice()}"/> 
 </bean>

5.注入复杂类型:
数组：


list：


Map：
Properties：

<!-- Spring 的复杂类型的注入===================== -->  
<bean id="collectionBean" class="cn.itcast.spring.demo5.CollectionBean"> 
  <!-- 数组类型的属性 -->   
  <property name="arrs">    
  <array> 
    <value>会希</value>     
    <value>冠希</value>     
    <value>天一</value>    
  </array> 
  </property> 
  
  <!-- 注入 List 集合的数据 -->   
  <property name="list">    
  <list> 
    <value>芙蓉</value>     
    <value>如花</value>     
    <value>凤姐</value>    
  </list>   
  </property> 
   
  <!-- 注入 Map 集合 -->   
  <property name="map">    
  <map> 
    <entry key="aaa" value="111"/>     
    <entry key="bbb" value="222"/>     
    <entry key="ccc" value="333"/>    
  </map>   
  </property>    
  <!-- Properties 的注入 -->  
   <property name="properties">   
    <props> 
    <prop key="username">root</prop>     
    <prop key="password">123</prop>   
    </props>   
   </property>  
 </bean>

四、Spring 的分配置文件的开发
一种:创建工厂的时候加载多个配置文件:

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml"); 

二种:在一个配置文件中包含另一个配置文件：

<import resource="applicationContext2.xml"></import>