spring_装配Bean

Spring容器:

Spring有两种不同的容器，一个是org.springframework.beans.factory.BeanFactory接口实现,另一个是应用上下文org.springframework.context.ApplicationContext接口实现.

BeanFactory是简单的容器，提供了基础的依赖注入，ApplicationContext是建立在BeanFactory基础之上的，它是Beanfactory的子类，功能比BeanFactory更加强大。

ApplicationContext提供了更多功能：

• 提供了文本信息解析工具，包括对国际化的支持
  
• 提供了载入文件资源的通用方法，如载入图片
• 可以向注册为监听器的Bean发送事件

ApplicationContext经常用到的三种实现：ClassPathXmlApplicationContext, FileSystemXmlApplicationContext, XmlWebApplicationContext

使用BeanFactory示例：

        BeanFactory factory = new XmlBeanFactory(new ClassPathResource(
                "beans.xml"));
        UserSave usersave = (UserSave) factory.getBean("usersave");

使用ApplicationContext示例：

1         ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserSave usersave = (UserSave) context.getBean("usersave");

Bean的作用域：

作用域	描述
singleton	在每个Spring IoC容器中一个bean定义对应一个对象实例。
prototype	一个bean定义对应多个对象实例。
request	在一次HTTP请求中，一个bean定义对应一个实例；即每次HTTP请求将会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。
session	在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
global session	在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。

示例：在beans.xml中

    <bean id="usersave" class="com.yuan.test.UserSave" scope="singleton">
        <property name="user">
            <ref bean="user" />
        </property>
    </bean>

第1行中scope属性定义bean的作用域，将其定义为singleton即为单例。下面代码输出为true

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        
        UserSave usersave = (UserSave) context.getBean("usersave");
        UserSave usersave2 = (UserSave) context.getBean("usersave");
        
        System.out.println(usersave == usersave2);

同样可以测试其他的属性值。

依赖注入的方法：

1. 接口注入
2. 构造注入
3. 设值注入

接口注入是要自定义的Bean实现规定的接口，Spring会自动进行注入，一般用的很少，下面是构造注入和设值注入的示例：

设值注入：

在Bean中为属性设置setter方法。

public class UserSave {
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public void saveUser() {
        System.out.println("user saved!");
    }
}

然后在配置文件中设置对应<property>元素并指定初值,如下第4~6行中引用外部bean作为初值

    <bean id="user" class="com.yuan.test.User"></bean>

    <bean id="usersave" class="com.yuan.test.UserSave" scope="singleton">
        <property name="user">
            <ref bean="user" />
        </property>
    </bean>

构造注入：

为bean提供构造函数。

public class UserSave {
    private User user;

    public UserSave(User user) {
        this.user = user;
    }
}

修改配置文件，在<constructor-arg>中设置初值

    <bean id="usersave" class="com.yuan.test.UserSave" scope="singleton">
        <constructor-arg>
            <ref bean="user" />
        </constructor-arg>
    </bean>

构造注入在有些情况下会遇到些问题，如果有多个参数，我们可以依据类型依次设置配置文件中的参数值，也可以调换顺序，不过要让Spring知道

public class Student {
    private String arg1;
    private URL arg2;

    public Student(String arg1, URL arg2) {
        this.arg1 = arg1;
        this.arg2 = arg2;
    }

}

 如下是按照顺序，http://www.baidu.com赋给第一个参数arg1, http://www.google.com赋给第二参数。

<bean id="student" class="com.yuan.test.Student">
        <constructor-arg>
            <value>http://www.baidu.com</value>
        </constructor-arg>
        <constructor-arg>
            <value>http://www.google.com</value>
        </constructor-arg>
    </bean>

也可以是随便编写参数的位置，不过要在属性中指定对应的参数位置，如下：

<bean id="student" class="com.yuan.test.Student">
        <constructor-arg index="1">
            <value>http://www.baidu.com</value>
        </constructor-arg>
        <constructor-arg index="0">
            <value>http://www.google.com</value>
        </constructor-arg>
    </bean>

在<constructor-arg>元素中加了index属性，设置对应构造函数中的参数位置。这里http://www.baidu.com赋给arg2, http://www.google.com赋给arg1

<bean id="student" class="com.yuan.test.Student">
        <constructor-arg type="java.net.URL">
            <value>http://www.baidu.com</value>
        </constructor-arg>
        <constructor-arg type="java.lang.String">
            <value>http://www.google.com</value>
        </constructor-arg>
    </bean>

如上，也可以通过type属性设置对应构造函数中的参数类型，不过如果构造函数中有相同的类型参数，这种方法不可取。

 

自动装配：

关于自动装配，个人觉得不够细粒度，如果为了系统稳定最好还是手工编写好。可以参考文章：了解Spring自动装配

 

Spring中特殊的Bean:

参考文章：Spring笔记 (2) 特殊Bean

分散配置：

在项目开发中，有时候要从一些配置文件中(properties)读取一些配置信息,如数据库的连接信息。在Spring程序中可以从不同的properties中读取有用的信息。这里要用到org.springframeword.beans.factory.config.PropertyPlaceholderConfigurer类，它是BeanFactoryPostProcessor的实现类.

下面例子：

项目结构：

connet.properties:

driver=mysql
username=yuan
password=test

test.properties:

age=12
height=13
weight=14

Connect.java装载着两个properties的信息：

public class Connect {
    private String driver;
    private String username;
    private String password;
    int age;
    int height;
    int weight;
        //省略getter,setter    
}

beans.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" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="propertyConfigurer"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>connect.properties</value>
                <value>test.properties</value>
            </list>
        </property>
    </bean>
    
    <bean id="connect" class="com.sunflower.yuan.Connect">
        <property name="driver">
            <value>${driver}</value>
        </property>
        
        <property name="username">
            <value>${username}</value>
        </property>
        
        <property name="password">
            <value>${password}</value>
        </property>
        
        <property name="age">
            <value>${age}</value>
        </property>
        
        <property name="height">
            <value>${height}</value>
        </property>
        
        
        <property name="weight">
            <value>${weight}</value>
        </property>
    </bean>

</beans>

 第6~14行中，<properties name="locations">标签里面指定要读取的properties文件的位置。16~41行中用EL表达式将预先加载的properties属性注入到Bean中

 测试类Test.java:

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "beans.xml");

        Connect source = (Connect) context.getBean("connect");

        String username = source.getUsername();
        String password = source.getPassword();
        int age = source.getAge();
        int weight = source.getWeight();
        int height = source.getHeight();

        System.out.println("username is:" + username + " password is:"
                + password);
        System.out.println("age is:" + age + " weight is:" + weight
                + " height is:" + height);
    }
}

运行结果：