第二章 装配Bean

装配：创建对象之间写作关系的行为

2.1声明Bean

　　2.1.1创建spring配置

　　创建spring配置，创建一个springbean.xml的文件：

<?xml version="1.0" encoding="UTF-8"?>
<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-2.0.xsd">
    
    
</beans>

　　<beans>内部可以放置spring的所有配置信息，包括<bean>的声明

　　2.1.2声明一个简单的bean

　　首先：创建的maven的工程（maven的配置以及eclipse配置maven捣鼓了半天）；

　　

　　下面是每个文件的代码：

　　pom.xml文件，就不介绍pom.xml文件了（自己也不是很熟），只要在<dependency>标签里配置上依赖的jar包，若是本地maven仓库里有jar包，就不会下载，若是没有，就会自动去下载（前提是装了maven），而且会自动把包导入到Maven Dependencies（就是上图中倒数第二个箭头的文件）包类库中：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.siaction.chapter01</groupId>
  <artifactId>chapter01</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <dependencies>
      <!-- log4j的依赖 -->
      <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.14</version>
    </dependency>
    <!-- junit的依赖 -->
      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
      </dependency>
      <!-- spring beans的依赖 -->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-beans</artifactId>
          <version>4.2.9.RELEASE</version>
      </dependency>
      <!-- spring context（应用上下文的依赖） -->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>4.2.9.RELEASE</version>
      </dependency>
      
  </dependencies>
</project>

 　　springbean.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<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-2.0.xsd">
    
    <!-- 名字为duke的bean -->
    <bean id="duke" class="com.springinaction.springidol.Juggler"></bean>
    
</beans>

　　log4j.properties的文件，这个文件通用的，哪里都能找到：

# Global logging configuration\uff0c\u5efa\u8bae\u5f00\u53d1\u73af\u5883\u4e2d\u8981\u7528debug
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

　　Performer接口

package com.springinaction.springidol;

/**
 * 表演者的接口
 */
public interface Performer {
    
    /**
     * 表演的方法
     * @throws Exception
     */
    void perform() throws Exception;
    
    
}

　　Juggler实现类：

package com.springinaction.springidol;

/**
 * Performer的一个实现类：Juggler
 *
 */
public class Juggler implements Performer {
    
    //Juggler有一个豆袋子，初始值是3
    private int beanBags = 3;
    
    public Juggler(){}
    
    public Juggler(int beanBags){
        this.beanBags = beanBags;
    }
    
    //表演抛豆袋子
    public void perform() throws Exception {
        
        System.out.println("JUGGLING "+beanBags+" BENABAGS");
    
    }

}

　　TestCase测试用例：

package com.springinaction.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.springinaction.springidol.Performer;


public class TestCase {
    
    //这个ClassPathXmlApplicationContext是springframe-context中
    //org.springframework.context.support包下的类
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring/springbean.xml");//注意路径
    
    @Test
    public void testPerformer() throws Exception {
        
        Performer duke = (Performer) ac.getBean("duke");
        duke.perform();
        
    }
    
}

　　结果，注意这里的bean是单例的bean，上面语句debug有说明（singleton bean 'duke'）：

　　

 　　2.1.3构造器注入bean

　　  此时，将springbean.xml文件中的duke bean的标签中加点内容，注意这个要有对应的构造函数，就是上述中的有参数的构造函数：

<!-- 名字为duke的bean -->
    <bean id="duke" class="com.springinaction.springidol.Juggler">
        <!-- 通过构造器为beanBags赋值 -->
        <constructor-arg value="15"/>
    </bean>

　　下面分别是通过构造器注入对象引用和工厂方法（factory-method）获得bean（其他的代码就不展示了，最下面有源码）：

<!-- 声明一个sonnet29的bean -->
    <bean id="sonnet29" class="com.springinaction.springidol.Sonnet29"></bean>
    
    <!--声明一个PoeticJuggler的bean,并且通过构造器注入，对应的引用,ref位引用依赖的bean  -->
    <bean id="poeticDuke" class="com.springinaction.springidol.PoeticJuggler">
        <constructor-arg value="15"/>
        <constructor-arg ref="sonnet29"/>
    </bean>
    
    <!-- Stage是个到单例类， 构造函数私有化
        factory-method='方法名'
        创建bean的时候，就调用这个方法
    -->
    <bean id="theStage" class="com.springinaction.springidol.Stage" factory-method="getInstance"></bean>

　　2.1.4 Bean的作用域

　　spring所有的bean默认都是单例的。<bean>有scope属性设置成prototype就变成多例的了；

<!-- scope='prototype'就变成多例 -->
    <bean id="ticket" class="com.springinaction.springidol.Ticket" scope="prototype"></bean>

　　测试：

//测试多例bean
    @Test
    public void testTicket() throws Exception {
        
        Ticket ticket1 = (Ticket) ac.getBean("ticket");
        Ticket ticket2 = (Ticket) ac.getBean("ticket");
        
        System.out.println(ticket1==ticket2);//结果是false
        
    }

　　scope的取值：

　　2.1.5 初始化和销毁bean

　　init-method和destory-method方法，为bean定义初始化和销毁操作（bean的属性）；

　　init-method属性指定了在初始化Bean时要调用的方法。

　　destory-method属性指定了Bean从容器移除之前要调用的方法。

　　若是很多bean有相同的名字的初始化和销毁方法，可以为<beans>标签中加上default-init-method='方法名' ,default-destroy-method='方法名';

2.2注入Bean属性

　　2.2.1 通过setter注入简单值

　　<bean><property name="" value="" ></property></bean>;name的值是bean的属性，value的值是将要赋的值；

<!-- com.springinaction.springidol.Instrumentalist
        这个类有一个song的属性，现在赋值为“认真的雪”；
        注意：这个类一定要有setter方法，
        没有setter方法抛出NotWritablePropertyException
     -->
    <bean id="kenny" 
        class="com.springinaction.springidol.Instrumentalist">
        <property name="song" value="认真的雪"></property>
    </bean>

　　2.2.2 引用其他Bean

　　<property>属性ref="" 就是引用另一个bean

<!-- 乐器：saxophone -->
    <bean id="saxophone" class="com.springinaction.springidol.Saxophone"></bean>
    <!-- ref='saxophone'，直接引用上边的bean -->
    <bean id="kenny" 
        class="com.springinaction.springidol.Instrumentalist">
        <property name="song" value="认真的雪"></property>
        <property name="instrument" ref="saxophone"></property>
    </bean> 
    

　　上述方式，多个bean都引用saxophone，那他们就共用了一个bean，不共用的方法，注入内部bean：

 <!-- 注入内部bean，就避免了多个音乐家共用一个saxophone而产生的卫生问题 -->
    <bean id="kenny" 
        class="com.springinaction.springidol.Instrumentalist">
        <property name="song" value="认真的雪"></property>
        <property name="instrument">
            <bean class="com.springinaction.springidol.Saxophone"></bean>
        </property>
    </bean> 

　　2.2.3 使用Spring的命名空间p装配属性

　　首先要在<beans>中引入p装配的命名空间：xmlns:p="http://www.springframework.org/schema/p"

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    
    <!-- p装配,可以和最开始的那个空容器对比多了xmlns:p="http://www.springframework.org/schema/p" -->
    <bean id="kenny1" 
        class="com.springinaction.springidol.Instrumentalist"
        p:song="认真的雨"
        p:instrument-ref="saxophone"/>
    
</beans>

　　2.2.4 装配集合

　　list装配，<ref>引用Spring上下文中的其他bean的引用，数组也可以同样装配，：

<!-- 乐器：guitar 吉他 -->
    <bean id="guitar" class="com.springinaction.springidol.Guitar"></bean>
    <!-- 乐器：cymbal  钹 -->
    <bean id="cymbal" class="com.springinaction.springidol.Cymbal"></bean>
    <!-- 乐器：harmonica 口琴 -->
    <bean id="harmonica" class="com.springinaction.springidol.Harmonica"></bean>
    <!-- 一个乐队 -->
    <bean id="hank"
        class="com.springinaction.springidol.OneManBand">
        <property name="instruments">
            <list>
                <ref bean="guitar"/>
                <ref bean="cymbal"/>
                <ref bean="harmonica"/>
            </list>
        </property>
    </bean>

　　set装配，下面4个<ref>，有一个是重复的，set里面只装一个：

<bean id="hank1"
        class="com.springinaction.springidol.OneManBand">
        <property name="instruments">
            <set>
                <ref bean="guitar"/>
                <ref bean="cymbal"/>
                <ref bean="harmonica"/>
                <ref bean="harmonica"/>
            </set>
        </property>
    </bean>

　　map装配<map><entry key="" value-ref=""></map>：

<bean id="hank2"
        class="com.springinaction.springidol.OneManBand">
        <property name="instruments">
            <map>
                <entry key="GUITAR" value-ref="guitar"/>
                <entry key="CYMBAL" value-ref="cymbal"/>
                <entry key="HARMONICA" value-ref="harmonica"/>
            </map>
        </property>
    </bean>

　　properties集合装配，注意和map的区别：

<bean id="hank3"
        class="com.springinaction.springidol.OneManBand">
        <property name="instruments">
            <props>
                <prop key="GUITAR">GUITAR GUITAR GUITAR</prop>
                <prop key="CYMBAL">CYMBAL CYMBAL CYMBAL</prop>
                <prop key="HARMONICA">HARMONICA HARMONICA HARMONICA</prop>
            </props>
        </property>
    </bean>

　　2.2.4 装配空值

　　只需<property name="属性名"><null></property>,这样就是ok了

2.3使用表达式装配Bean

　　这个感觉暂时用不上，就先不看了，以后回来再看；

源码地址