Spring基础——Bean

Spring核心

Spring的核心机制就是IoC（控制反转）容器，被调用者的实例并不是由调用者创建（new），而是由Spring容器完成，然后注入调用者，调用者便获得了被调用者的实例，这也称为依赖注入（DI）。而ApplicationContext就是一个很强大的IoC容器，那些有setter和getter方法的类也叫做Bean，这些 bean 是由用容器提供的配置元数据创建的（容器内不是一开始就有所有bean实例的）。

Bean

容器通过内部保存的以下信息来装配一个Bean:

scope定义的Bean作用域包括以下几种：

construtor-arg：用构造参数进行实例化。
properties：先创建实例，再用set进行实例化。

下面分别以list、map、set的实例化为例来更好理解bean的装配：

bean装配示例

UserInfo.java（“基础的”bean类，也是list…里的元素）

package com.shw;

import java.util.Random;

public class UserInfo {
    private String userName;
    private String password;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public UserInfo(String userName, String password) {
        this.userName = userName;
        this.password = password;
    }

    public UserInfo() {
        // 产生一个100000以内的随机密码
        this.password = String.valueOf(new Random().nextInt(100000));
    }
}

XmlBeanAssemble.java（“高级的”bean类，里面定义了初始化和销毁方法）

package com.shw;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class XmlBeanAssemble {
    // 定义集合类型的属性
    List myList1;//里面是原型模式创建的UserInfo
    List myList2;//里面是单例模式创建的UserInfo
    Set mySet;
    Map myMap;

    // 定义初始化方法
    public void init() {
        System.out.println("XmlBeanAssemble类的初始化方法init被调用！");
    }

    // 定义销毁方法
    public void destroy() {
        System.out.println("XmlBeanAssemble类的销毁方法destroy被调用！");
    }

    // 定义方法show，在控制台输出各个属性
    public void show() {
        System.out.print("原型模式，zhangsan两次获得的密码分别为：  ");
        for (Object obj : myList1) {
            System.out.print(((UserInfo) obj).getPassword() + "   ");
        }
        System.out.println("");
        System.out.print("单例模式，zhangsan两次获得的密码分别为：  ");
        for (Object obj : myList2) {
            System.out.print(((UserInfo) obj).getPassword() + "   ");
        }
        System.out.println("");
        for (Object obj : mySet) {
            if (obj instanceof UserInfo)
                System.out.print(((UserInfo) obj).getUserName() + "正在学习框架："
                        + "   ");
            else
                System.out.print(obj + "\t");
        }
        System.out.println("");
        for (Object key : myMap.keySet()) {
            System.out.print(key.toString() + ":" + myMap.get(key) + "    ");
        }
        System.out.println("");
    }

    public List getMyList1() {
        return myList1;
    }

    public void setMyList1(List myList1) {
        this.myList1 = myList1;
    }

    public List getMyList2() {
        return myList2;
    }

    public void setMyList2(List myList2) {
        this.myList2 = myList2;
    }

    public Set getMySet() {
        return mySet;
    }

    public void setMySet(Set mySet) {
        this.mySet = mySet;
    }

    public Map getMyMap() {
        return myMap;
    }

    public void setMyMap(Map myMap) {
        this.myMap = myMap;
    }

}

xmlBeanAssemble.xml（单独的配置文件，防止applicationContext过于臃肿，用于装配UserInfo和XmlBeanAssemble）

<?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.2.xsd">

    <!-- 基于XML方式的Bean装配示例配置开始 -->
    <!-- 使用设值方式装配UserInfo实例，原型模式 -->
    <bean id="user1" class="com.shw.UserInfo" scope="prototype">
        <property name="userName" value="zhangsan" />
    </bean>
    <!-- 使用设值方式装配Users实例，单例模式 -->
    <bean id="user2" class="com.shw.UserInfo">
        <property name="userName" value="zhangsan" />
    </bean>
    <!-- 使用构造方式装配Users实例，单例模式 -->
    <bean id="user3" class="com.shw.UserInfo">
        <!-- 使用构造方式注入属性值 -->
        <constructor-arg index="0" value="lisi" />
        <constructor-arg index="1" value="123456" />
    </bean>
    <!-- 使用单实例模式装配XmlBeanAssemble实例 -->
    <bean id="xba" class="com.shw.XmlBeanAssemble" init-method="init"
        destroy-method="destroy">
        <!-- 使用Set方式注入List类型属性 -->
        <property name="myList1">
            <list>
                <!-- user1实例使用原型模式装配，每次引用将是一个新的Users实例 -->
                <ref bean="user1" />
                <ref bean="user1" />
            </list>
        </property>
        <!-- 使用Set方式注入List类型属性 -->
        <property name="myList2">
            <list>
                <!-- user2实例使用单例模式装配，每次引用将是同一个实例 -->
                <ref bean="user2" />
                <ref bean="user2" />
            </list>
        </property>
        <!-- 使用Set方式注入Set类型属性 -->
        <property name="mySet">
            <set>
                <ref bean="user3" />
                <value>Struts 2</value>
                <value>Spring 3</value>
            </set>
        </property>
        <!-- 使用Set方式注入Map类型属性 -->
        <property name="myMap">
            <map>
                <entry key="Struts 2">
                    <value>支持MVC模式</value>
                </entry>
                <entry key="Spring 3">
                    <value>充当组件间的粘合剂</value>
                </entry>
            </map>
        </property>
    </bean>
    <!-- 基于XML方式的Bean装配示例配置结束 -->

</beans>

TestXmlBeanAssemble.java（测试类）

package com.shw;

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

public class TestXmlBeanAssemble {

    public static void main(String[] args) {
        // 加载xmlBeanAssemble.xml配置，初始化Spring容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "xmlBeanAssemble.xml");
        // 从Bean工厂容器中获取名为"xba"的XmlBeanAssemble实例
        XmlBeanAssemble xba = (XmlBeanAssemble) ctx.getBean("xba");
        // 调用方法show
        xba.show();
        // 手工关闭Spring容器
        ((ClassPathXmlApplicationContext) ctx).destroy();
    }
}

结果：