开涛spring3(2.3) - IoC的配置使用

2.3.1  XML配置的结构

一般配置文件结构如下：

    <beans>
        <import resource=”resource1.xml”/>
        <bean id=”bean1”class=””></bean>
        <bean id=”bean2”class=””></bean>
    <bean name=”bean2”class=””></bean>
        <alias alias="bean3" name="bean2"/>
        <import resource=”resource2.xml”/>
    </beans>  

1、<bean>标签主要用来进行Bean定义；

2、alias用于定义Bean别名的；

3、 import用于导入其他配置文件的Bean定义，这是为了加载多个配置文件，当然也可以把这些配置文件构造为一个数组（new String[] {“config1.xml”, config2.xml}）传给ApplicationContext实现进行加载多个配置文件，那一个更适合由用户决定；这两种方式都是通过调用 Bean Definition Reader 读取Bean定义，内部实现没有任何区别。<import>标签可以放在<beans>下的任何位置，没有顺序关系。

2.3.2  Bean的配置

Spring IoC容器目的就是管理Bean，这些Bean将根据配置文件中的Bean定义进行创建，而Bean定义在容器内部由BeanDefinition对象表示，该定义主要包含以下信息：

●全限定类名（FQN）：用于定义Bean的实现类;

●Bean行为定义：这些定义了Bean在容器中的行为；包括作用域（单例、原型创建）、是否惰性初始化及生命周期等；

●Bean创建方式定义：说明是通过构造器还是工厂方法创建Bean；

●Bean之间关系定义：即对其他bean的引用，也就是依赖关系定义，这些引用bean也可以称之为同事bean 或依赖bean，也就是依赖注入。

Bean 定义只有“全限定类名”在当使用构造器或静态工厂方法进行实例化bean时是必须的，其他都是可选的定义。难道Spring只能通过配置方式来创建 Bean吗？回答当然不是，某些SingletonBeanRegistry接口实现类实现也允许将那些非BeanFactory创建的、已有的用户对象 注册到容器中，这些对象必须是共享的，比如使用DefaultListableBeanFactory 的registerSingleton() 方法。不过建议采用元数据定义。

2.3.3    Bean的命名

每个Bean可以有一个或多个id（或称之为标识符或名字），在这里我们把第一个id称为“标识符”，其余id叫做“别名”；这些id在IoC容器中必须唯一。如何为Bean指定id呢，有以下几种方式；

一、  不指定id，只配置必须的全限定类名，由IoC容器为其生成一个标识，客户端必须通过接口“T getBean(Class<T> requiredType)”获取Bean；

<bean class=” cn.javass.spring.chapter2.helloworld.HelloImpl”/>

测试代码片段如下：

@Test
public void test1() {
BeanFactory beanFactory =
   new ClassPathXmlApplicationContext("chapter2/namingbean1.xml");
    //根据类型获取bean
    HelloApi helloApi = beanFactory.getBean(HelloApi.class);
    helloApi.sayHello();
} 

二、指定id，必须在Ioc容器中唯一；

<bean id=” bean” class=” cn.javass.spring.chapter2.helloworld.HelloImpl”/>

@Test
public void test2() {
BeanFactory beanFactory =
new ClassPathXmlApplicationContext("chapter2/namingbean2.xml");
//根据id获取bean
    HelloApi bean = beanFactory.getBean("bean", HelloApi.class);
    bean.sayHello();
} 

三、指定name，这样name就是“标识符”，必须在Ioc容器中唯一；

<bean name=” bean” class=” cn.javass.spring.chapter2.helloworld.HelloImpl”/>

测试代码片段如下：

    @Test
    public void test3() {
        BeanFactory beanFactory =
    new ClassPathXmlApplicationContext("chapter2/namingbean3.xml");
        //根据name获取bean
    HelloApi bean = beanFactory.getBean("bean", HelloApi.class);
    bean.sayHello();
    }  

四、指定id和name，id就是标识符，而name就是别名，必须在Ioc容器中唯一；

<bean id=”bean1”name=”alias1”
class=” cn.javass.spring.chapter2.helloworld.HelloImpl”/>
<!-- 如果id和name一样，IoC容器能检测到，并消除冲突 -->
<bean id="bean3" name="bean3" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>

测试代码片段如下：

@Test
public void test4() {
BeanFactory beanFactory =
new ClassPathXmlApplicationContext("chapter2/namingbean4.xml");
    //根据id获取bean
    HelloApi bean1 = beanFactory.getBean("bean1", HelloApi.class);
    bean1.sayHello();
    //根据别名获取bean
    HelloApi bean2 = beanFactory.getBean("alias1", HelloApi.class);
    bean2.sayHello();
    //根据id获取bean
    HelloApi bean3 = beanFactory.getBean("bean3", HelloApi.class);
    bean3.sayHello();
    String[] bean3Alias = beanFactory.getAliases("bean3");
    //因此别名不能和id一样，如果一样则由IoC容器负责消除冲突
    Assert.assertEquals(0, bean3Alias.length);
} 

五、指定多个name，多个name用“，”、“；”、“ ”分割，第一个被用作标识符，其他的（alias1、alias2、alias3）是别名，所有标识符也必须在Ioc容器中唯一；

<bean name=” bean1;alias11,alias12;alias13 alias14”
      class=” cn.javass.spring.chapter2.helloworld.HelloImpl”/>
<!-- 当指定id时，name指定的标识符全部为别名 -->
<bean id="bean2" name="alias21;alias22"
class="cn.javass.spring.chapter2.helloworld.HelloImpl"/> 

@Test
public void test5() {
BeanFactory beanFactory =
new ClassPathXmlApplicationContext("chapter2/namingbean5.xml");
    //1根据id获取bean
    HelloApi bean1 = beanFactory.getBean("bean1", HelloApi.class);
    bean1.sayHello();
    //2根据别名获取bean
    HelloApi alias11 = beanFactory.getBean("alias11", HelloApi.class);
    alias11.sayHello();
    //3验证确实是四个别名
    String[] bean1Alias = beanFactory.getAliases("bean1");
    System.out.println("=======namingbean5.xml bean1 别名========");
    for(String alias : bean1Alias) {
        System.out.println(alias);
    }
    Assert.assertEquals(4, bean1Alias.length);
    //根据id获取bean
    HelloApi bean2 = beanFactory.getBean("bean2", HelloApi.class);
    bean2.sayHello();
    //2根据别名获取bean
    HelloApi alias21 = beanFactory.getBean("alias21", HelloApi.class);
    alias21.sayHello();
    //验证确实是两个别名
    String[] bean2Alias = beanFactory.getAliases("bean2");
    System.out.println("=======namingbean5.xml bean2 别名========");
    for(String alias : bean2Alias) {
        System.out.println(alias);
    }
    Assert.assertEquals(2, bean2Alias.length);
} 

六、使用<alias>标签指定别名，别名也必须在IoC容器中唯一

<bean name="bean" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
<alias alias="alias1" name="bean"/>
<alias alias="alias2" name="bean"/> 

测试代码片段如下：

@Test
public void test6() {
BeanFactory beanFactory =
new ClassPathXmlApplicationContext("chapter2/namingbean6.xml");
    //根据id获取bean
    HelloApi bean = beanFactory.getBean("bean", HelloApi.class);
   bean.sayHello();
    //根据别名获取bean
    HelloApi alias1 = beanFactory.getBean("alias1", HelloApi.class);
    alias1.sayHello();
    HelloApi alias2 = beanFactory.getBean("alias2", HelloApi.class);
    alias2.sayHello();
    String[] beanAlias = beanFactory.getAliases("bean");
    System.out.println("=======namingbean6.xml bean 别名========");
    for(String alias : beanAlias) {
        System.out.println(alias);
   }
   System.out.println("=======namingbean6.xml bean 别名========");
    Assert.assertEquals(2, beanAlias.length);
 } 

从 定义来看，name或id如果指定它们中的一个时都作为“标识符”，那为什么还要有id和name同时存在呢？这是因为当使用基于XML的配置元数据时， 在XML中id是一个真正的XML id属性，因此当其他的定义来引用这个id时就体现出id的好处了，可以利用XML解析器来验证引用的这个id是否存在，从而更早的发现是否引用了一个不 存在的bean，而使用name，则可能要在真正使用bean时才能发现引用一个不存在的bean。

●Bean命名约定：Bean的命名遵循XML命名规范，但最好符合Java命名规范，由“字母、数字、下划线组成“，而且应该养成一个良好的命名习惯， 比如采用“驼峰式”，即第一个单词首字母开始，从第二个单词开始首字母大写开始，这样可以增加可读性。

2.3.4  实例化Bean

Spring IoC容器如何实例化Bean呢？传统应用程序可以通过new和反射方式进行实例化Bean。而Spring IoC容器则需要根据Bean定义里的配置元数据使用反射机制来创建Bean。在Spring IoC容器中根据Bean定义创建Bean主要有以下几种方式：

一、使用构造器实例化Bean：这是最简单的方式，Spring IoC容器即能使用默认空构造器也能使用有参数构造器两种方式创建Bean，如以下方式指定要创建的Bean类型：

1.使用空构造器进行定义，使用此种方式，class属性指定的类必须有空构造器

    <bean name="bean1" class="cn.javass.spring.chapter2.HelloImpl2"/>  

2.使用有参数构造器进行定义，使用此中方式，可以使用< constructor-arg >标签指定构造器参数值，其中index表示位置，value表示常量值，也可以指定引用，指定引用使用ref来引用另一个Bean定义，后边会详细介绍：

<bean name="bean2" class="cn.javass.spring.chapter2.HelloImpl2">
<!-- 指定构造器参数 -->
     <constructor-arg index="0" value="Hello Spring!"/>
</bean> 

知道如何配置了，让我们做个例子的例子来实践一下吧：

（1）准备Bean class(HelloImpl2.java)，该类有一个空构造器和一个有参构造器：

package lqy.springh;

public class HelloApi {

    private String message; 

    public HelloApi() {
        this.message = "Hello World!";
     }  

    public HelloApi(String message) {
         this.message=message;
     }

    public void sayHello() {
      System.out.println(message);
    }

}

（2）在配置文件配置Bean定义，如下所示

<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context                http://www.springframework.org/schema/context/spring-context-3.0.xsd">
  <!-- id 表示你这个组件的名字，class表示组件类 -->  

<bean id="bean1" class="lqy.springh.HelloApi"></bean> 

 <bean id="bean2" class="lqy.springh.HelloApi">
 <constructor-arg index="0" value="Hello Spring constructor-arg!"/>
 </bean> 

</beans>

（2）测试代码

package lqy.springh;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class App
{
    public static void main( String[] args )
    {
           //ApplicationContext context = new ClassPathXmlApplicationContext("helloworld.xml");
           //使用构造器
BeanFactory beanFactory =  new ClassPathXmlApplicationContext("helloworld.xml");
           HelloApi bean1 = beanFactory.getBean("bean1", HelloApi.class);
           bean1.sayHello();
           HelloApi bean2 = beanFactory.getBean("bean2", HelloApi.class);
           bean2.sayHello(); 

    }
}

结果

aaarticlea/png;base64,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" alt="" />

二、 使用静态工厂方式实例化Bean，使用这种方式除了指定必须的class属性，还要指定factory-method属性来指定实例化Bean的方法，而 且使用静态工厂方法也允许指定方法参数，spring IoC容器将调用此属性指定的方法来获取Bean，配置如下所示：

（1）先来看看静态工厂类代码吧HelloApiStaticFactory：

package lqy.springh;

public class HelloApiStaticFactory {
    //工厂方法
       public static HelloApi newInstance(String message) {
              //返回需要的Bean实例
           return new HelloApi(message);
}
} 

（2）静态工厂写完了，让我们在配置文件配置Bean定义

 <!-- 使用静态工厂方法 -->
<bean id="bean3" class="lqy.springh.HelloApiStaticFactory" factory-method="newInstance">
     <constructor-arg index="0" value="Hello Spring!"/>
</bean>

（3）配置完了，写段测试代码来测试一下吧，InstantiatingBeanTest：

         BeanFactory beanFactory =  new ClassPathXmlApplicationContext("helloworld.xml");
         HelloApi bean3 = beanFactory.getBean("bean3", HelloApi.class);
         bean3.sayHello();  

aaarticlea/png;base64,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" alt="" />

三、 使用实例工厂方法实例化Bean，使用这种方式不能指定class属性，此时必须使用factory-bean属性来指定工厂Bean，factory- method属性指定实例化Bean的方法，而且使用实例工厂方法允许指定方法参数，方式和使用构造器方式一样，配置如下：

（1）实例工厂类代码（HelloApiInstanceFactory.java）如下：

package lqy.springh;

public class HelloApiInstanceFactory {
public HelloApi newInstance(String message) {
          return new HelloApi(message);
   }
} 

（2）让我们在配置文件配置Bean定义：

<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context                http://www.springframework.org/schema/context/spring-context-3.0.xsd">  

<!-- 1、定义实例工厂Bean -->
<bean id="beanInstanceFactory"
class="lqy.springh.HelloApiInstanceFactory"/>
<!-- 2、使用实例工厂Bean创建Bean -->
<bean id="bean4"  factory-bean="beanInstanceFactory"  factory-method="newInstance">
 <constructor-arg index="0" value="Hello Spring!"></constructor-arg>
</bean>

</beans>

（3）测试代码

         BeanFactory beanFactory =  new ClassPathXmlApplicationContext("helloworld.xml");
         HelloApi bean3 = beanFactory.getBean("bean4", HelloApi.class);
         bean3.sayHello();  

通过以上例子我们已经基本掌握了如何实例化Bean了，大家是否注意到？这三种方式只是配置不一样，从获取方式看完全一样，没有任何不同。这也是Spring IoC的魅力，Spring IoC帮你创建Bean，我们只管使用就可以了，是不是很简单。

2.3.5  小结

到此我们已经讲完了Spring IoC基础部分，包括IoC容器概念，如何实例化容器，Bean配置、命名及实例化，Bean获取等等。不知大家是否注意到到目前为止，我们只能通过简单 的实例化Bean，没有涉及Bean之间关系。接下来一章让我们进入配置Bean之间关系章节，也就是依赖注入。