技术教程 编程教程 day03-Spring管理Bean-IOC-01 正文

day03-Spring管理Bean-IOC-01

2023-02-15,,,,

Spring管理Bean-IOC

1.Spring配置/管理bean介绍

Bean管理包括两方面：

创建bean对象
给bean注入属性
Bean的配置方式：
基于xml文件配置方式
基于注解配置方式

2.基于XML配置bean

2.1通过类型来获取bean

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

2.1.1应用案例

案例说明：

    通过spring的ioc容器，获取一个bean对象
    说明：获取bean的方式：按类型

完成步骤：

    创建一个Java对象Monster.java
    在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);

    }

}

2.1.2细节说明

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

    用类型来获取bean的应用场景：XxxAction/Servlet/Controller或者XxxService，在一个线程中只需要一个对象实例的情况（单例情况）

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

2.2通过构造器配置bean

2.2.1应用实例

案例说明：

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

完整步骤：

    配置bean.xml

在beans.xml配置：

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

   <!--配置Monster对象，并指定构造器-->

    <!--

        1. constructor-arg 标签可以指定使用构造器的参数

        2. index 表示构造器的第几个参数，从0开始计算

        3. 除了通过index，还可以通过 name/ type 的方式来指定参数

        4. 类构造器可以有多个，但是不能有参数完全相同的类型和顺序的构造器，

           这就决定了 通过构造器参数type 可以唯一确定一个构造器)

    -->

    <bean id="monster03" class="com.li.bean.Monster">

        <constructor-arg value="200" index="0"/>

        <constructor-arg value="白骨精" index="1"/>

        <constructor-arg value="吸血" index="2"/>

    </bean>

    <!--通过 name 的方式来指定参数-->

    <bean id="monster04" class="com.li.bean.Monster">

        <constructor-arg value="200" name="monsterId"/>

        <constructor-arg value="白骨精" name="name"/>

        <constructor-arg value="吸血" name="skill"/>

    </bean>

    <!--通过 type 的方式来指定参数-->

    <bean id="monster05" class="com.li.bean.Monster">

        <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);

    }

}

2.2.2细节说明

    通过index属性来区分是第几个参数
    通过type属性来区分是什么类型（按照顺序）

2.3通过p名称空间配置bean

2.3.1应用实例

案例说明：

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

完成步骤：

    在beans.xml配置，增加命名空间配置，如下，点击Create namespace declaration，成功后在配置文件头会自动添加xmlns

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 id="monster06" class="com.li.bean.Monster"

          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);

    }

}

2.3.2细节说明

注意要引入p名称空间

2.4引用/注入其他bean对象

2.4.1应用实例

案例说明：

在spring的ioc容器中，可以通过 ref （reference）来实现bean对象的相互应用

完成步骤：

    创建MemberDAOImpl.java，MemberServiceImpl.java
    配置beans.xml

beans.xml：

<!--配置MemberDAOImpl对象-->

<bean class="com.li.dao.MemberDAOImpl" id="memberDAO"/>

<!--配置MemberServiceImpl对象

     1.ref="memberDAO" 表示

        MemberServiceImpl 对象的属性memberDAO 引用的对象是id=memberDAO的对象

     2.这就体现了spring容器的依赖注入

     3.注意在spring容器中，是作为一个整体来执行的，也就是说如果你引用到了一个bean对象，对你配置的顺序没有要求

        （在底层，对spring配置文件进行扫描，将关联的关系自动梳理，并放到beanDefinitionMap中，

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

     4.但是建议按照顺序配置，易于阅读

  -->

<bean class="com.li.service.MemberServiceImpl" id="memberService">

    <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();

    }

}

2.4.2细节说明

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

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

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

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

2.5引入/注入内部bean对象

2.5.1应用实例

案例说明：

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

完成步骤：

    创建MemberDAOImpl.java，MemberServiceImpl.java
    配置beans.xml

创建MemberDAOImpl.java，MemberServiceImpl.java（见2.4）

beans.xml：

<!--配置MemberService对象（使用内部bean）-->

<bean class="com.li.service.MemberServiceImpl" id="memberService2">

    <!--自己配置一个内部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();

    }

}

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

2.6.1应用实例

案例说明

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

完成步骤：

    创建Monster.java
    创建Master.java
    配置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" id="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());

        }

    }

}

2.6.2细节说明

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

    Properties集合的特点：

    （1）Properties是Hashtable的子类，也是key-value形式

    （2）key是String类型，value也是String类型

day03-Spring管理Bean-IOC-01的相关教程结束。

《day03-Spring管理Bean-IOC-01.doc》

下载本文的Word格式文档，以方便收藏与打印。

Copyright 2023. 昆居客 - IT编程,互联网信息技术文档大全!