day03-Spring管理Bean-IOC-01

时间:2023-01-16 22:10:33

1.Spring配置/管理bean介绍

  • Bean管理包括两方面:
    • 创建bean对象
    • 给bean注入属性
  • Bean的配置方式:
    • 基于xml文件配置方式
    • 基于注解配置方式

2.基于XML配置bean

2.1通过类型来获取bean

通过id来获取bean在Spring基本介绍中已经使用过,这里不再赘叙

2.1.1应用案例

  • 案例说明:

    1. 通过spring的ioc容器,获取一个bean对象
    2. 说明:获取bean的方式:按类型
  • 完成步骤:

    1. 创建一个Java对象Monster.java
    2. 在beans.xml中配置

Monster.java:

package com.li.bean;

/**
 * @author 李
 * @version 1.0
 * Javabean / Entity
 */
public class Monster {
    private Integer monsterId;
    private String name;
    private String skill;

    //无参构造器一定要有,spring底层反射创建对象时需要使用
    public Monster() {
    }

    public Monster(Integer monsterId, String name, String skill) {
        this.monsterId = monsterId;
        this.name = name;
        this.skill = skill;
    }

    public Integer getMonsterId() {
        return monsterId;
    }

    public void setMonsterId(Integer monsterId) {
        this.monsterId = monsterId;
    }

    public String getName() {
        return name;
    }

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

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "monsterId=" + monsterId +
                ", name='" + name + '\'' +
                ", skill='" + skill + '\'' +
                '}';
    }
}

beans.xml:

<!--配置Monster,希望通过类型来获取-->
<bean class="com.li.bean.Monster" >
    <property name="monsterId" value="10086"/>
    <property name="name" value="孙悟空"/>
    <property name="skill" value="筋斗云"/>
</bean>

SpringBeanTest:

package com.li.test;

import com.li.bean.Monster;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //通过Bean的类型来获取对象
    @Test
    public void getBeanByType() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        //直接传入class对象/类型
        Monster bean = ioc.getBean(Monster.class);
        System.out.println(bean);
    }
}
day03-Spring管理Bean-IOC-01

2.1.2细节说明

  1. 按照类型来获取bean,要求ioc容器中的同一个类的bean只能有一个,否则会抛出异常NoUniqueBeanDefinitionException

    day03-Spring管理Bean-IOC-01
  2. 用类型来获取bean的应用场景:XxxAction/Servlet/Controller或者XxxService,在一个线程中只需要一个对象实例的情况(单例情况)

  3. 在容器配置文件(比如beans.xml)中给属性值,底层是通过setter方法完成的,这也是为什么需要在java对象中提供setter方法,否则会报错

2.2通过构造器配置bean

2.2.1应用实例

  • 案例说明:

    使用spring的ioc容器,可以通过构造器来来配置bean对象

  • 完整步骤:

    1. 配置bean.xml

在beans.xml配置:

前提是Monster类中有对应的构造器

   <!--配置Monster对象,并指定构造器-->
    <!--
        1. constructor-arg 标签可以指定使用构造器的参数
        2. index 表示构造器的第几个参数,从0开始计算
        3. 除了通过index,还可以通过 name/ type 的方式来指定参数
        4. 类构造器可以有多个,但是不能有参数完全相同的类型和顺序的构造器,
           这就决定了 通过构造器参数type 可以唯一确定一个构造器)
    -->
    <bean >
        <constructor-arg value="200" index="0"/>
        <constructor-arg value="白骨精" index="1"/>
        <constructor-arg value="吸血" index="2"/>
    </bean>
    <!--通过 name 的方式来指定参数-->
    <bean >
        <constructor-arg value="200" name="monsterId"/>
        <constructor-arg value="白骨精" name="name"/>
        <constructor-arg value="吸血" name="skill"/>
    </bean>
    <!--通过 type 的方式来指定参数-->
    <bean >
        <constructor-arg value="200" type="java.lang.Integer"/>
        <constructor-arg value="白骨精" type="java.lang.String"/>
        <constructor-arg value="吸血" type="java.lang.String"/>
    </bean>

SpringBeanTest:

package com.li.test;

import com.li.bean.Monster;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

import java.io.File;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //通过构造器来设置属性
    @Test
    public void setBeanConstructor() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        Monster monster03 = ioc.getBean("monster03", Monster.class);
        System.out.println("monster03=" + monster03);
    }
}
day03-Spring管理Bean-IOC-01

2.2.2细节说明

  1. 通过index属性来区分是第几个参数
  2. 通过type属性来区分是什么类型(按照顺序)

2.3通过p名称空间配置bean

2.3.1应用实例

  • 案例说明:

    在spring的ioc容器,可以通过p名称空间来配置bean对象

  • 完成步骤:

    1. 在beans.xml配置,增加命名空间配置,如下,点击Create namespace declaration,成功后在配置文件头会自动添加xmlns
    day03-Spring管理Bean-IOC-01day03-Spring管理Bean-IOC-01

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

    <!--通过p名称空间来配置bean
        将光标放在p,输入alt+enter,就会自动添加 xmlns
     -->
    <bean 
          p:monsterId="500"
          p:name="红孩儿"
          p:skill="风火轮"
    />
</beans>

SpringBeanTest:

package com.li.test;

import com.li.bean.Monster;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //通过p名称空间来设置属性
    @Test
    public void setBeanByP() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        Monster monster06 = ioc.getBean("monster06", Monster.class);
        System.out.println("monster06=" + monster06);
    }
}
day03-Spring管理Bean-IOC-01

2.3.2细节说明

注意要引入p名称空间

2.4引用/注入其他bean对象

2.4.1应用实例

  • 案例说明:

    在spring的ioc容器中,可以通过 ref (reference)来实现bean对象的相互应用

  • 完成步骤:

    1. 创建MemberDAOImpl.java,MemberServiceImpl.java
    2. 配置beans.xml

beans.xml:

<!--配置MemberDAOImpl对象-->
<bean class="com.li.dao.MemberDAOImpl" />

<!--配置MemberServiceImpl对象
     1.ref="memberDAO" 表示
        MemberServiceImpl 对象的属性memberDAO 引用的对象是id=memberDAO的对象
     2.这就体现了spring容器的依赖注入
     3.注意在spring容器中,是作为一个整体来执行的,也就是说如果你引用到了一个bean对象,对你配置的顺序没有要求
        (在底层,对spring配置文件进行扫描,将关联的关系自动梳理,并放到beanDefinitionMap中,
         也就是说,是从beanDefinitionMap中查找关联关系的。与spring配置文件的配置顺序无关)
     4.但是建议按照顺序配置,易于阅读
  -->
<bean class="com.li.service.MemberServiceImpl" >
    <property name="memberDAO" ref="memberDAO"/>
</bean>

MemberDAOImpl:

package com.li.dao;

/**
 * @author 李
 * @version 1.0
 * DAO 对象
 */
public class MemberDAOImpl {
    //构造器
    public MemberDAOImpl() {
        System.out.println("MemberDAOImpl 构造器...");
    }

    //方法
    public void add() {
        System.out.println("MemberDAOImpl add()方法被执行");
    }

}

MemberServiceImpl:

package com.li.service;

import com.li.dao.MemberDAOImpl;

/**
 * @author 李
 * @version 1.0
 * Service类
 */
public class MemberServiceImpl {
    private MemberDAOImpl memberDAO;

    public MemberDAOImpl getMemberDAO() {
        return memberDAO;
    }

    public void setMemberDAO(MemberDAOImpl memberDAO) {
        this.memberDAO = memberDAO;
    }

    public void add() {
        System.out.println("MemberServiceImpl add() 方法被调用...");
        memberDAO.add();
    }
}

SpringBeanTest:

package com.li.test;

import com.li.service.MemberServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;


/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //通过ref 来设置 bean属性
    @Test
    public void setBeanByRef() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        MemberServiceImpl memberService =
                ioc.getBean("memberService", MemberServiceImpl.class);

        memberService.add();
    }
}
day03-Spring管理Bean-IOC-01day03-Spring管理Bean-IOC-01

2.4.2细节说明

注意:在spring容器中,是作为一个整体来执行的,也就是说如果你引用到了一个bean对象,对你配置的顺序没有要求。例如这里的例子,如果我们将Memb erDAOImpl对象的配置,放到MemberServiceImpl对象的配置之后也是可以的。

因为在底层,会对spring的配置文件进行扫描,将关联的关系自动梳理,并放到beanDefinitionMap中。

也就是说,是从beanDefinitionMap中查找关联关系的。与spring配置文件的配置顺序无关。

但是建议按照顺序配置,易于阅读

2.5引入/注入内部bean对象

2.5.1应用实例

  • 案例说明:

    在spring的ioc容器中,可以直接配置内部bean对象

  • 完成步骤:

    1. 创建MemberDAOImpl.java,MemberServiceImpl.java
    2. 配置beans.xml

创建MemberDAOImpl.java,MemberServiceImpl.java(见2.4)

beans.xml:

<!--配置MemberService对象(使用内部bean)-->
<bean class="com.li.service.MemberServiceImpl" >
    <!--自己配置一个内部bean-->
    <property name="memberDAO">
        <bean class="com.li.dao.MemberDAOImpl"/>
    </property>
</bean>

SpringBeanTest:

package com.li.test;

import com.li.service.MemberServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //通过内部 bean来设置 bean属性
    @Test
    public void setBeanByProper() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        MemberServiceImpl memberService2 =
                ioc.getBean("memberService2", MemberServiceImpl.class);

        memberService2.add();
    }
}
day03-Spring管理Bean-IOC-01

2.6引用/注入集合/数组类型

2.6.1应用实例

  • 案例说明

    在spring的ioc容器中,看看如何给bean对象的集合/数组类型属性赋值

  • 完成步骤:

    1. 创建Monster.java
    2. 创建Master.java
    3. 配置beans.xml

Monster.java:见2.1

Master.java:

package com.li.bean;

import java.util.*;

/**
 * @author 李
 * @version 1.0
 * Master类
 */
public class Master {
    private String name;

    private List<Monster> monsterList;
    private Map<String, Monster> monsterMap;
    private Set<Monster> monsterSet;

    //数组
    private String[] monsterName;

    // Properties 是 Hashtable 的子类,也是k-v形式
    // 这里Properties 的key和value都是String类型
    private Properties pros;

    public String getName() {
        return name;
    }

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

    public List<Monster> getMonsterList() {
        return monsterList;
    }

    public void setMonsterList(List<Monster> monsterList) {
        this.monsterList = monsterList;
    }

    public Map<String, Monster> getMonsterMap() {
        return monsterMap;
    }

    public void setMonsterMap(Map<String, Monster> monsterMap) {
        this.monsterMap = monsterMap;
    }

    public Set<Monster> getMonsterSet() {
        return monsterSet;
    }

    public void setMonsterSet(Set<Monster> monsterSet) {
        this.monsterSet = monsterSet;
    }

    public String[] getMonsterName() {
        return monsterName;
    }

    public void setMonsterName(String[] monsterName) {
        this.monsterName = monsterName;
    }

    public Properties getPros() {
        return pros;
    }

    public void setPros(Properties pros) {
        this.pros = pros;
    }

    @Override
    public String toString() {
        return "Master{" +
                "name='" + name + '\'' +
                ", monsterList=" + monsterList +
                ", monsterMap=" + monsterMap +
                ", monsterSet=" + monsterSet +
                ", monsterName=" + Arrays.toString(monsterName) +
                ", pros=" + pros +
                '}';
    }
}

beans.xml:

<!--配置Master对象-->
<!--体会Spring容器配置特点-->
<bean class="com.li.bean.Master" >
    <property name="name" value="太上老君"/>

    <!--(1)给list属性赋值-->
    <property name="monsterList">
        <list>
            <!--方式1.引用的方式-->
            <ref bean="monster01"/>
            <ref bean="monster02"/>
            <!--方式2.内部bean-->
            <bean class="com.li.bean.Monster">
                <property name="name" value="黄袍怪"/>
                <property name="monsterId" value="1024"/>
                <property name="skill" value="吃人"/>
            </bean>
        </list>
    </property>

    <!--(2)给map属性赋值-->
    <property name="monsterMap">
        <map>
            <entry>
                <key>
                    <value>monster01</value>
                </key>
                <!--也可以通过内部 bean来配置,这里使用引用-->
                <ref bean="monster01"/>
            </entry>
            <entry>
                <key>
                    <value>monster02</value>
                </key>
                <!--也可以通过内部 bean来配置,这里使用引用-->
                <ref bean="monster02"/>
            </entry>
        </map>
    </property>

    <!--(3)给set属性赋值-->
    <property name="monsterSet">
        <set>
            <!--同理,依然可以使用ref或者内部 bean的方式配置-->
            <ref bean="monster05"/>
            <bean class="com.li.bean.Monster">
                <property name="name" value="金角大王"/>
                <property name="monsterId" value="888"/>
                <property name="skill" value="有钱"/>
            </bean>
        </set>
    </property>

    <!--(4)给数组属性赋值-->
    <property name="monsterName">
        <array>
            <!--这里根据数组的类型来选择对应的标签-->
            <value>小猪妖</value>
            <value>大鹏妖</value>
            <value>老狐狸</value>
            <!--同理,依然可以使用ref或者内部 bean的方式配置-->
        </array>
    </property>

    <!--(5)给Properties属性赋值,结构 k(String)-v(String)-->
    <property name="pros">
        <props>
            <prop key="username">root</prop>
            <prop key="pwd">1234</prop>
            <prop key="ip">127.0.0.1</prop>
        </props>
    </property>
</bean>

SpringBeanTest:

package com.li.test;

import com.li.bean.Master;
import com.li.bean.Monster;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

import java.util.Iterator;
import java.util.Map;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //给集合/数组属性进行配置值
    @Test
    public void setBeanByCollection() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        Master master = ioc.getBean("master", Master.class);

        System.out.println("========master的list属性=========");
        for (Monster monster : master.getMonsterList()) {
            System.out.println(monster);
        }

        System.out.println("\n========master的map属性=========");
        Iterator<Map.Entry<String, Monster>> iterator =
                master.getMonsterMap().entrySet().iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.println("\n========master的set属性=========");
        for (Monster monster : master.getMonsterSet()) {
            System.out.println(monster);
        }

        System.out.println("\n========master的数组属性=========");
        for (int i = 0; i < master.getMonsterName().length; i++) {
            System.out.println(master.getMonsterName()[i]);
        }

        System.out.println("\n========master的Properties属性=========");
        Iterator<Map.Entry<Object, Object>> iterator1
                = master.getPros().entrySet().iterator();
        while (iterator1.hasNext()) {
            System.out.println(iterator1.next());
        }
    }
}
day03-Spring管理Bean-IOC-01day03-Spring管理Bean-IOC-01

2.6.2细节说明

  1. 主要掌握List/Map/Properties三种集合的使用

  2. Properties集合的特点:

    (1)Properties是Hashtable的子类,也是key-value形式

    (2)key是String类型,value也是String类型