Spring4学习笔记二：Bean配置与注入相关

一：Bean的配置形式

    基于XML配置：在src目录下创建 applicationContext.xml  文件，在其中进行配置。

    基于注解配置：在创建bean类时，通过注解来注入内容。（这个不好，因为注解也在代码中，而且过于分散）

二：Bean的寻找方式

    通过反射来创建bean：通过bean定义时的全类名，用反射机制来寻找bean元数据，创建对象。【因此：Bean类必须至少有一个无参构造函数】

    id：容器中该bean对象的唯一标识，可以在容器中其他对象中根据id来调用该对象(例如：Factory对象创建时调用数据库连接池对象等)，也可以在代码中用ApplicationContext对象.getBean(id)来获取某个bean对象。如果不指定对象，则默认使用类名作为id。

三：Bean对象的赋值——依赖注入的方式

    属性注入：在配置bean时，通过<property>标签配置，标签中name指定属性名，value指定属性值，原理是：调用Bean类中的setter方法进行属性赋值。一个标签赋值一个属性。

<bean id="bean_id" class="www.ygj0930.bean.Bean">
        <property name="attr1" value="value1"></property>
        <property name="attr2" value="value2"></property>
        <property name="attr3" value="value3"></property>
        ......
</bean>

    构造注入：在配置bean时，通过<constructor-arg>标签为构造函数配置参数值，标签中 value指定参数值，index指定是对应哪个参数，type说明该参数类型。一个标签赋值一个参数。

<bean id="bean_id" class="www.ygj0930.bean.Bean">
        <constructor-arg value="val0" index="0" type="java.lang.XX"></constructor-arg>
        <constructor-arg value="val1" index="1" type="java.lang.XX"></constructor-arg>
        <constructor-arg value="val2" index="2" type="java.lang.XX"></constructor-arg>
        ........
    </bean>

     

    属性值、参数值细节：
    1）如果属性值、参数值中包含特殊符号，则需要把属性值、参数值用C-Data括起来，即   <![CDATA[值]]>   形式来配置，都在特殊符号在xml中会被解释，从而报错。

    2）属性、参数是基本数据类型、封装数据类型：可以使用  value="字面量"  来注入。

    3）属性、参数是其他bean类型：

         3.1）引用外部bean：如果该属性、参数变量值是容器中已有bean，则使用  ref="引用的bean_id"  来注入。

         3.2）内部bean：如果属性、参数变量是当前bean中内部创建的一个新的bean，则使用<property>标签来配置，在标签之间在内嵌一个<bean>标签，并且以构造注入的方式来创建内部bean。

<bean id="外部bean">
        <property name="内部bean的属性名">
            <bean class="内部bean的全类名"> //内部bean，没有id，不能被外部其他bean引用
               <constructor-arg value="参数值" index="下标" type="参数类型"></constructor-arg>
               ......
            </bean>
        </property>
        <property name="引用外部bean的属性名" ref="其他bean的ID"></property>

        ......
</bean>

     构造注入的内部bean参数值创建方法同上，标签换成constructor-arg。

    4）注入null值

    null值的注入有专有的形式，必须按下面格式来写：

<constructor-arg><null/></constructor-arg>

四：级联属性配置

    如果一个bean2中引用了另一个bean1作为成员变量，那么我们可以在配置bean2时，通过bean2的成员变量来为引用的bean1赋值或者修改bean1的变量值。

    例如：人 的类中有  车，在配置bean时，可以为 person bean引用一个car对象，然后进一步对car对象的属性进行赋值。

    【注意：各个类的必须定义各属性的getter和setter方法，否则无法成功注入】

<bean id="person" class="www.ygj0930.bean.Person">
        <property name="name" value="ygj"></property>
        <property name="age" value="23"></property>
        <property name="car" ref="car"></property>
        <property name="car.maxSpeed" value="260"></property> 
</bean>

五：集合属性赋值

    一个Bean类在定义时，包含了集合类型的成员变量的话(list、set等)，在配置时，要使用相应的标签逐个赋值：可以用ref引用已有的，也可以用bean标签创建内部bean。

    例如：一个人有很多辆车。

<bean id="person" class="www.ygj0930.bean.Person">
        <property name="name" value="ygj"></property>
        <property name="age" value="23"></property>
        <property name="cars"> //集合属性
            <list> //对应属性类型来使用标签，还有 set等
                <ref bean="car"/> //使用ref标签，指定bean来逐个元素进行赋值
                <ref bean="car2"/>
                <bean class="全类名"> //创建内部bean来对元素赋值
                　　<constructor-arg></constructor-arg>
                   。。。。。。
                </bean>
            </list>
        </property> 
    </bean> 

     map类型的属性配置：用map标签，里面元素用entry标签，并且通过entry标签的 key、value或者value-ref来赋值。

<bean id="person" class="www.ygj0930.bean.Person">
        <property name="name" value="ygj"></property>
        <property name="age" value="23"></property>
        <property name="cars">
            <map> //使用map标签
                <entry key="1" value-ref="car"></entry> //用entry标签来为元素赋值
            </map>
        </property> 
    </bean> 

      Properties类型属性配置：常用于DAO层框架相关bean类配置等。使用props标签包住，里面用prop标签逐个赋值。

<bean id="properties" class="www.ygj0930.bean.TestProperties">
        <property name="properties">
            <props>
                <prop key="name">ygj</prop>  //key是属性名，标签之间是属性值
                <prop key="password">123</prop>
                <prop key="email">11111@111.com</prop>
            </props>
        </property>
    </bean>

六：把集合属性单独配置，供多个bean引用

1：增加命名空间

如下图：Source是xml代码编辑界面，点击  Namespaces  选项卡，切换到命名空间配置界面。

勾选  util  命名空间。

2:配置集合内容，指定id。例如：配置map

<util:map id="cars">
        <entry key="1" value-ref="car"></entry>
</util:map>

3:在需要引用集合属性值的bean中，通过id来引用集合

    <bean id="person" class="www.ygj0930.bean.Person">
        <property name="name" value="ygj"></property>
        <property name="age" value="23"></property>
        <property name="cars" ref="cars"> //引用上面配置的map
        </property> 
    </bean> 

七：使用 p 命名空间，简化bean配置

1:引入 p 命名空间

2:使用 p:属性名="值"  的形式配置bean属性值。

 <bean id="person" class="www.ygj0930.bean.Person" p:name="ygj" p:age="23" p:cars-ref="cars"></bean> 

八：Bean的自动装配(不推荐使用)——autowire属性

    byName：按名自动装配，用于引用其他bean时可以根据bean在容器中的id 与 当前配置bean的属性名  进行匹配，同名则引用。

    byType：按类型自动装配，用于根据类型匹配来引用其他bean。缺点：如果某类型的bean不只一个，就会报错。

    为什么不推荐使用自动装配：

    1:不灵活：如果采用了自动装配配置某个bean，则这个bean的所有 引用  属性都自动装配。

    2:不清晰：相比于自动装配，逐个配置的话文档看起来更加清晰，知道引用了哪个bean，也方便修改。

九：Bean之间的关系——继承 与 依赖

    继承：一个bean可以继承自容器中的另一个bean，并且可以覆盖掉继承来的属性。

<bean id="car1" class="www.ygj0930.bean.Car">
        <constructor-arg value="Audi" index="0" type="java.lang.String"></constructor-arg>
        <constructor-arg value="ShangHai" type="java.lang.String"></constructor-arg>
        <constructor-arg value="1" type="int"></constructor-arg>
    </bean>
    <bean id="car2" class="www.ygj0930.bean.Car" parent="car1" p:brand="Benz">  //继承car1，覆写个别属性

    依赖：一个bean可以依赖于某个bean，在被依赖的bean创建之后才创建自己，否则报错。

  <bean id="person" class="www.ygj0930.bean.Person" p:name="ygj" p:age="23" p:cars-ref="cars" depends-on="car"></bean>  //依赖car

    这样的话，需要在car被创建后，才创建person。

十：Bean的作用域

    我们可以通过 scope 属性配置bean的作用域。

    Spring支持如下5种作用域：

• singleton：单例模式，在整个Spring IOC容器中，使用singleton定义的Bean将只有一个实例

• prototype：原型模式，每次通过容器的getBean方法获取prototype定义的Bean时，都将产生一个新的Bean实例

• request：对于每次HTTP请求，使用request定义的Bean都将产生一个新实例，即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时，该作用域才有效

• session：对于每次HTTP Session，使用session定义的Bean豆浆产生一个新实例。同样只有在Web应用中使用Spring时，该作用域才有效

• globalsession：每个全局的HTTP Session，使用session定义的Bean都将产生一个新实例。典型情况下，仅在使用portlet context的时候有效。同样只有在Web应用中使用Spring时，该作用域才有效

　　其中比较常用的是singleton和prototype两种作用域。对于singleton作用域的Bean，每次请求该Bean都将获得相同的实例。容器负责跟踪Bean实例的状态，负责维护Bean实例的生命周期行为；如果一个Bean被设置成prototype作用域，程序每次请求该id的Bean，Spring都会新建一个Bean实例，然后返回给程序。在这种情况下，Spring容器仅仅使用new 关键字创建Bean实例，一旦创建成功，容器不在跟踪实例，也不会维护Bean实例的状态。

　　如果不指定Bean的作用域，Spring默认使用singleton作用域。Java在创建Java实例时，需要进行内存申请；销毁实例时，需要完成垃圾回收，这些工作都会导致系统开销的增加。因此，prototype作用域Bean的创建、销毁代价比较大。而singleton作用域的Bean实例一旦创建成功，可以重复使用。因此，除非必要，否则尽量避免将Bean被设置成prototype作用域。

十一：引用外部配置文件

    对于C3P0等第三方工具的配置，一般使用properties等文件进行各项配置，那么在配置这些bean时怎么获取到里面的具体配置项呢？

    Properties文件中各项以 name=value 形式来定义内容，如：

name=Name1
age=21

    我们在applicationContext.xml中可以把properties文件加载进容器的上下文中，然后在配置bean时就可以用 ${name} 的形式获取具体的配置值了。

    1:添加命名空间

   2:加载文件

   注意：配置文件需要与applicationContext.xml位于同一级目录，最好位于src下。

   加载格式为：<context:property-placeholder location="classpath:XX.properties>

   获取配置项内容：${配置项名}

 <context:property-placeholder location="classpath:test1.properties"/>
 <bean id="person2" class="www.ygj0930.bean.Person" p:name="${name}" p:age="${age}"></bean>

    3:加载多个配置文件的命名问题

    我们可以通过多个加载语句把多个配置文件加载进context中：

<context:property-placeholder location="classpath:XX.properties"/>
<context:property-placeholder location="classpath:XXX.properties"/>
<context:property-placeholder location="classpath:XXXX.properties"/>
。。。。。。

    如果这些文件中存在同名的配置项，例如：都有name配置项，那么我们用 ${name} 获取到的是哪个呢？——第一个导入的文件中的name配置项值。

十二：SpEL表达式

    1）语法格式：#{表达式}

    2）使用场景：

         调用其他bean中的方法和属性：#{bean.func()}、#{bean.attr}

         计算表达式的值，为bean的属性进行动态赋值:表达式包括  数学运算+-*/%^；字符串连接；比较运算符><,==,>=,<=；三目运算符：条件 ? value1 ：value2 ；逻辑运算符等。

         正则表达式的匹配：#{内容 matches '正则表达式'}

         静态内容的引用：使用  T(静态类名).变量、方法  来引用，例如：#{T(java.lang.Math).PI}

    

十三：Bean的生命周期

    一般生命周期：Bean的构造函数——bean设置属性(setter函数)——使用bean（代码中getBean，调用bean的一系列属性与方法）

    配置了初始化和销毁方法的生命周期：Bean的构造函数——bean设置属性(setter函数)——执行init方法(需要在配置bean时指定)——使用bean（代码中getBean，调用bean的一系列属性与方法）——随着IOC容器的关闭，销毁bean，调用bean的destroy方法（需要在配置bean时指定）

    配置了后置处理器的生命周期：Bean的构造函数——bean设置属性(setter函数)——后置处理器执行beforeInit方法——执行init方法(需要在配置bean时指定)——后置处理器执行afterInit方法——使用bean（代码中getBean，调用bean的一系列属性与方法）——随着IOC容器的关闭，销毁bean，调用bean的destroy方法（需要在配置bean时指定）

    后置处理器的使用：

    1）实现BeanPostProcessor接口，定义后置处理器类；

    2）重写其中的两个方法：postProcessAfterInitialization(Object bean, String name)、postProcessBeforeInitialization(Object bean, String name)

         在方法中，根据 name 识别bean的名字，执行对应与该bean的校验、过滤、修改工作。

         方法的最后，要return bean，把修改后的bean返回。

     3）配置后置处理器：在applicationContext.xml中配置一个bean，class为后置处理器类，不需要id。

     4）使用：IOC容器自动识别后置处理器，并且在容器中的每个bean初始化方法执行的先后，分别调用postProcessAfterInitialization(Object bean, String name)、postProcessBeforeInitialization(Object bean, String name)这两个方法进行bean的校验和过滤。

十四：