Spring入门1

                       第一张  Spring简介
Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。
目的：解决企业应用开发的复杂性。
功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 。
范围：任何Java应用 。
简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。


轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。

非侵入 ——在应用中，一般不需要引用spring.jar包里的类。

控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，某一接口的具体实现类的选择控制权从调用类中移除，转交给第三方裁决。

面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责其它的系统级关注点，例如日志或事务支持。 
   Spring即是一个容器又是一个框架。

容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。

框架——Spring提供了很多基础的与业务逻辑无关的功能，比如：事务管理、持久化框架集成等等，使用Spring框架，开发人员可以专注于业务逻辑开发，这个意义上讲它是一个框架。
                             第二章   控制反转（IOC）
IOC(控制反转:Inverse of Control)是Spring的内核，AOP,声明式事务等功能都建立在该功能之上，它涉及到代码解耦，设计模式，代码优化等问题的考虑。
它包括两个方面的内容：其一是控制；其二是反转。到底是什么东西的控制被反转了呢，来看个例子：
导演，剧本，场景，剧中人，演员，
对于软件来说：控制反转即是某一接口的具体实现类的选择控制权从调用类中移除，转交给第三方裁决。
依赖注入DI(Dependency Injection): 将调用类对接口的实现类的依赖关系由第三方注入，以移除调用类对接口实现类的依赖。

public class SaveEmployeeEditAction extends SsoaAction {
//定义接口
public EmployeeManager employeeManager;

//属性注入
public void setEmployeeManager(EmployeeManager employeeManager) {
this.employeeManager = employeeManager;
}
public String execute() throws Exception {
       //使用接口
employeeManager.updateEmployee(ee);
}
}
第三方控制实现类
<bean id="employeeManager"
class="com.soft.ssoa.services.department.EmployeeManagerImpl">
<property name="employeeManagerDao">
<ref bean="employeeManagerDao" />
</property>
</bean>

 
IOC类型
构造函数注入
在构造函数注入中，通过调用类的构造函数将接口实现类通过构造函数变量传入，如下代码所示

public class MenuBufferImpl {
    public MenuBufferImpl(){}
    public MenuBufferImpl(PrivilegeDAO privilegeDAO) {
        this.privilegeDAO = privilegeDAO;
        
    }
}
//注入
 <bean id="menuBuffer" class="com.topsoft.prv.domain.MenuBufferImpl">
        <constructor-arg>
            <ref local="privilegeDAO"/>
        </constructor-arg>
    </bean>
<bean id="privilegeDAO" class="com.topsoft.prv.domain.dao.PrivilegeDAOImpl"/>

属性注入
属性注入可以有选择地通过Setter方法完成调用类所需依赖的注入，更加灵活方便。
一般使用属性注入。
见前面例子
课后扩展：
刚才看到，spring框架通过一个配置文件实现控制反转，在容器启动时根据配置文件的描述信息，自动实例化Bean并完成依赖关系的建立，从容器中即可返回准备就绪的Bean实例，以待以后使用。Spring之所以有这样的能力，主要归功于java语言本身的类反射功能，反射机制简单的说就是我们利用编程的方式实现类的实例化，大家课下可以查询这方面的知识，加深对控制反转的了解。

ApplicationContext(应用上下文)建立在BeanFactory之上，提供了更多面向应用的功能，更易于创建实际应用，有时在web开发中为了方便也称ApplicationContext为Spring容器。


WebApplicationContext是专门为Web应用准备的，它允许从相对于Web根目录的路径中装载配置文件完成初始化工作。从WebApplicationContext中可以获得ServletContext的引用整个web应用上下文对象将作为属性放置到ServletContext中，以便Web应用环境可以访问Spring引用上下文。Spring专门提供了一个工具类WebApplicationContextUtils,通过该类的getWebApplicationContext(ServletContext sc) 方法可以从ServletCOntext中获取WebApplicationContext实例。
使用例子：




配置一个bean

<?xml version="1.0" encoding="gb2312"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
        "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<description>权限管理prv</description>

<bean id="car" class="Ioc.car"></bean>
<bean id="boss" class="Ioc.Boss"></bean>
</beans>

上段信息提供了实例化Car和Boss这两个Bean必须的信息，Ioc容器完全可以根据该信息创建者连个Bean实例。
Bean命名：

一般情况，在配置一个bean是，需要为期指定一个id属性作为Bean的名称，id在Ioc容器中必须是唯一的，此外id的命名需要满足XML对id的命名规范：必须以字母开始，逗号和空格这些非完全结束符号是非法的。如果实际使用中需要使用一些id不允许的特殊字符，可以使用bean的name属性来命名，name没有命名上的限制，几乎可以使用任何字符，如?ab，123等。

Id和name都可以指定多个名字，名字中间使用逗号、分号、或者空格进行分割，
<bean name=“?car1,car2,#car3” calss=“Ioc.car”/>
这里为bean定义了三个名字?car1,car2,#car3,他们是一样的，可以通过任何一个取得bean实例。
配置文件中不能出现相同的id,但可以出现相同的name，根据name取得bean时，以最后出现的name为准。

推荐使用id .
属性注入配置
使用属性注入时,bean配置方式如下：

引用

<bean id="car" class="Ioc.car"></bean>
<bean id="boss" class="Ioc.Boss">
  <property name="name">
    <idref bean="car"/>
  </property>
  <property name="car">
   <value>hongqi,200,2000</value>
  </property>
</bean>

两种方式设置属性的值，1,通过字面值value；2，通过idref引用别的bean.
上例中name的值是car.
构造函数注入装配
构造函数注入通过<constructor-arg>标记完成。

1，按类型匹配入参 
<bean id="car" class="Ioc.Car">
<constructor-arg type=“java.lang.String”>
   <value><![CDATA[hongi&asldf]]></value>
</constructor-arg>
<constructor-arg type=“java.lang.String” value="hehe"/>
<constructor-arg type=“java.lang.int” value="3"/>
<constructor-arg>
   <set>
     <value>${barand}</value>
     <value>${color}</value>
     <value>${maxSpeed}</value>
   </set>
</constructor-arg>
</bean>
2，按索引匹配入参
<bean id="car" class="Ioc.Car">
<constructor-arg index="0">
   <value><![CDATA[hongi&asldf]]></value>
</constructor-arg>
<constructor-arg index="1" value="hehe"/>
<constructor-arg index="2" value="3"/>
<constructor-arg>
   <set>
     <value>${barand}</value>
     <value>${color}</value>
     <value>${maxSpeed}</value>
   </set>
</constructor-arg>
</bean>

注入参数详解
1，字面值
  即可用字符串表示的值，这些值<value>元素标签进行注入 ，比如
<property name="car">
   <value>hongqi</value>
  </property>
对于一些特殊符号可以使用<![CDATA[]]>的特殊处理标签，比如：
<property name="car">
   <value> <![CDATA[轿车&@@car]]></value>
  </property>
当然也可以使用转义序列处理特殊符号，xml中共有五个特殊符号，它们的转义序列如下：
＜    &lt;
>     &gt;
&     &amp;
“      &quot;
‘      &apos;
2, 引用其它bean
idref
idref元素用来将容器内其它bean的id传给<constructor-arg/>或<property/>元素，同时提供错误难功能。
<property name="name">
    <idref bean="car"/>
  </property>

ref
形式一：<ref bean=“someBean”>这是最常见的形式是通过使用ref标记指定bean属性的目标bean，通过该标签可以引用同一容器或父容器内的任何bean（无论是否在同一XML文件中）。XML‘bean’元素的值即可以是指定的bean的id值也可以是其name值。

形式二：<ref local=“someBean”>使用ref的local属性指定目标bean，它可以利用XML解析器来难所引用的bean是否存在同一文件中。local属性值必须是目标bean的id属性值。

形式三：<bean parent="someBean">通过使用ref的parent属性来引用当前窗口的父容器中的bean。parent属性值即可以是目标bean的id值，也可以是name属性值。
3、内部 bean:
所谓内部bean(inner bean)是指在一个bean的<property/>或

<constructor-arg/>中使用<bean/>元素定义的bean.<bean id="outer" class="..."> <property name="target">  <bean class="com.mycoompany.Person">   <property name="name" value="Fiona Apple"/>   <property name="age" value="25"/>  </bean> </property></bean>

内部bean不能被其它bean引用，只能在声明处为外部bean提供实例注入。
内部bean即使提供了id,name,scope属性也会被忽略.
4、集合合并：
从Spring2.0开始，Spring IoC容器将支持集合的合并。父子集合元素合并后的值就是子集合中的最终结果，而且子集合中的元素值将覆盖父集合中的对应的值。

<beans><bean id="parent" abstract="true" class="example.ComplexObject"> <property name="adminEmails">  <props>   <prop key="administrator">[e-mail]</prop>   <prop key="support">[e-mail]</prop>  </props> </property></bean><bean id="child" parent="parent"> <property name="adminEmails">  <props merge="trur">   <prop key="sales">[e-mail]</prop>   <prop key="support">[e-mail]</prop>  </props> </property></bean></beans>
合并后内容：
administrator=[e-mail] sales=[e-mail] support=[e-mail] 

list集合有排序功能，父bean的列表内容将排在子bean列表内容的前面；merge属性必须在继承的子bean中定义。
5、Nulls
<null/>用于处理null值。Spring会把属性的空参数当作空字符串处理。
<bean class="ExampleBean"> <property name="email">  <value></value> </property></bean>
等同于
excapleBean.setEamil("");
而null值则可以使用<null/>元素来表示：
<bean class="ExampleBean"> <property name="email"><null/></property></bean>
6、简写：
针对常见的value值或bean的引用，Spring提供了简化格式用于替代<value/>和<ref/>元素。<property/>、<constructor-arg/>、<entry/>元素都支持value属性，它可以用来替代内嵌的<value/>元素。

<property name="myProperty">                             <value>hello</value>           =====            <property name="myProperty" value="helo" /></property>
<constructor-arg> <value>hello</value>           =====            <constructor-arg value="hello" /></construtctor-arg>
<entry key="myKey"> <value>hello</value>           =====            <entry key="myKey" value="hello" /></entry>
<property/>和<constructor-arg/>支持类似的简写属性ref，它可以替找整个内嵌的</ref>元素。
<property name="myProperty"> <ref bean="myBean">            =====            <property name="myProperty" ref="myBean" /></property>
<constructor-arg> <ref bean="myBean">            =====            <constructor-arg ref="myBean" /></constructor-arg>
切记：尽管存在等同于<ref bean="xxx" >元素的简写形式，但并没有<ref local="xxx">的简写形式。
map中的entry元素的简写形式为key/key-ref和value/value-ref属性。
<entry> <key>  <ref bean="myKeyBean" />            =====          <entry key-ref="myKeyBean" value-ref="myValueBean" /> </key> <ref bean="myValueBean" /></entry>
Spring 建议使用简写形式

7、延迟初始化bean--lazy-init 属性：
<bean id="lazy" class="com.foo.ExpensiveToCreateBean" lazy-init="true"> <!-- various properties here... --></bean><bean name="noo.lazy" class="com.foo.AnotherBean"> <!-- various properties here... --></bean>
如果一个bean被设置为延迟初始化，而另一个非延迟初始化的singleton bean依赖于它，那么当ApplicationContext提前实例化singleton bean时，它必须也确保所有上述singleton依赖bean也被预先初始化，当然也包括设置为延迟实例化的bean.
在容器层次中通过在<beans />元素上使用‘default-lazy-init’属性来控制延迟初始化也是可能的。<beans default-lazy-init="true"> <!-- no beans will be eagerly pre-instantiated... --></beans>
8、自动装配< autowire > 属性：
模式     说明
no      不使用自动装配，必须通过ref元素指定依赖，这是默认设置。
byName     根据属性名自动装配。Spring将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配。
byType     如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配。如果存在多个，则抛出异常。
constructor    与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中未找到与构造器参数类型一致的bean，那么将抛出异常。
autodetect    通过bean类的自省机制(introspection)来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。
Bean之间的关系
1，继承
如果多个bean存在相同的配置信息,spring允许我们定义一个父<bean>，子<bean>将自动继承父<bean>的配置信息。

<bean id="abstractCar" class="Ioc.Car" abstract="true">
  <property name="barand" value="barand"/>
  <property name="color" value="cc"/>
</bean>
<bean id="car2" parent="abstractCar">
<property name="maxSpeed">
   <value>200</value>
</property>
</bean>
2，依赖
depends-on属性可以用于当前bean初始化之前显式的强制一个或多个bean被初始化。
<bean id="beanOne" class="ExampleBean" depends-on="manager"> <property name="manager" ref="manager" /></bean><bean id="manager" class="ManagerBean" />
若需要表达对多个bean的依赖，可以在<depends-on />中将指定的多个bean名字用分隔符进行分隔，分隔符可以是逗号、空格及分号等。
<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao"> <property name="manager" ref="manager" /></bean><bean id="manager" class="ManagerBean" /><bean id="accountDao" class="x.y.jdbc.JdbcAccountDao" />
3，引用
即前面讲的idref
循环依赖问题
Spring容器能够顺利实例化以构造函数注入进行装配的bean有一个前提：Bean构造函数入参引用的对象必须已经准备就绪。由于这个机制的限制，如果两个bean都采用构造函数注入，而且都通过构造函数入参引用对方，就会发生类似于线程死锁的循环依赖问题。如下：
Public class car{
…
Public car(Boss boss){
this.boss=boss;
}
}
Public class boss{
…
Public boss(Car car){

this.car=carl;
}
}
当启动Ioc容器时，由于存在循环依赖问题，Spring容器将无法成功启动，这时我们可以混合使用函数注入和属性输入来解决该问题。即，把上面的一个函数注入改为属性注入方式。