Spring配置bean的细节

bean的管理

1.bean配置信息的重用

在配置bean时，我们可以通过parent属性来继承一个对象
我们使用我们的猫猫类

public class Cat {
    //这是一只什么样的猫猫
    private Integer age;
    private String name;
    private String active;
    //无参构造器
    public Cat(){

    }
    //有参构造器
    public Cat(Integer age, String name, String active) {
        this.age = age;
        this.name = name;
        this.active = active;
    }
    //get和set方法
    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getActive() {
        return active;
    }

    public void setActive(String active) {
        this.active = active;
    }
    //toString方法

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", active='" + active + '\'' +
                '}';
    }
}

然后配置一个猫猫对象

<bean id="cat4" class="com.spring.Cat">
        <property name="age" value="4"/>
        <property name="name" value="小四"/>
        <property name="active" value="喵"/>
    </bean>

重头戏来了，我们要继承这个猫猫对象的属性

<bean id="cat5" class="com.spring.Cat" parent="cat4"/>

此时，cat5已经具有了和cat4相同的属性值，让我们来输出验证一下吧！
测试代码如下

@Test
   public void testCat(){
       //创建容器
       ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
       //得到对象
       Cat cat5 = ioc.getBean("cat5", Cat.class);
       System.out.println("cat5 =" + cat5);
   }

执行代码，得到以下结果，说明继承成功了

2.depends-on属性

在默认情况下，xml配置文件中的bean是根据从上到下的顺序执行的，如果用了depends-on属性，就可以产生依赖，手动决定哪个bean先执行，哪个bean后执行
来看一个例子吧！

public class Father {
    private String name;

    public Father() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Son {
    private String name;

    public Son() {
        System.out.println("son的构造器被调用");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

这是两个对象，接下来我们来配置

<bean id="father" class="com.spring.Father">
        <property name="name" value="父亲"/>
    </bean>
    <bean id="son" class="com.spring.Son">
        <property name="name" value="儿子"/>
    </bean>

我们先配置的father，所以应该先执行father的构造器
让我们来测一下是否是这样的

 @Test
    public void depends(){
        //创建容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        //得到对象
        Father father = ioc.getBean("father", Father.class);
        Son son = ioc.getBean("son", Son.class);
    }

果然，结果如我们所料，先输出了father的构造器

让我们改一下配置顺序来看看

<bean id="son" class="com.spring.Son">
       <property name="name" value="儿子"/>
   </bean>
   <bean id="father" class="com.spring.Father">
       <property name="name" value="父亲"/>
   </bean>

这次我们先配置了son，来测一测吧！

 @Test
   public void depends(){
       //创建容器
       ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
       //得到对象
       Father father = ioc.getBean("father", Father.class);
       Son son = ioc.getBean("son", Son.class);
   }

太好了，这次先输出了son，我们是正确的！
该引出我们的主角了，保持上面的配置，添加depends-on属性

 <bean id="son" class="com.spring.Son" depends-on="father">
       <property name="name" value="儿子"/>
   </bean>
   <bean id="father" class="com.spring.Father">
       <property name="name" value="父亲"/>
   </bean>

son在father的上面，按理说应该先输出son的构造器，但是我们添加了depends-on属性，son依赖father，所以应该先输出father的构造器
太好了，结果是我们所料的！

3.通过scope="prototype"实现多例

在Spring的默认容器中，创建对象是以单例的形式，看下面这个例子

<bean id="cat6" class="com.spring.Cat">
        <property name="age" value="6"/>
        <property name="name" value="小六"/>
        <property name="active" value="喵"/>
    </bean>

我们来测试一下

@Test
    public void singleton(){
        //创建容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        //得到对象
        Cat cat6 = ioc.getBean("cat6", Cat.class);
        System.out.println("cat6 =" + cat6);
        Cat cat66 = ioc.getBean("cat6", Cat.class);
        System.out.println("cat66 =" + cat66);
        Cat cat666 = ioc.getBean("cat6", Cat.class);
        System.out.println("cat666 =" + cat666);
    }

从输出结果可以看到，它们的地址相同，说明是同一个对象
接下来我们来看多例，我们需要配置scope属性

<bean id="cat7" class="com.spring.Cat" scope="prototype">
       <property name="age" value="7"/>
       <property name="name" value="小七"/>
       <property name="active" value="喵"/>
   </bean>

配置完成后，我们做同样的测试

@Test
   public void multipleCases(){
       //创建容器
       ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
       //得到对象
       Cat cat7 = ioc.getBean("cat7", Cat.class);
       System.out.println("cat7 =" + cat7);
       Cat cat77 = ioc.getBean("cat6", Cat.class);
       System.out.println("cat77 =" + cat77);
       Cat cat777 = ioc.getBean("cat6", Cat.class);
       System.out.println("cat777 =" + cat777);
   }

激动人心的时刻到了，让我们来看看结果
果然，如我们所料，在配置后，返回了不同的对象地址，即我们完成了返回多例！