spring入门五

最新推荐文章于 2024-09-24 11:42:16 发布

qq_35383788

最新推荐文章于 2024-09-24 11:42:16 发布

阅读量67

点赞数

本文链接：https://blog.csdn.net/qq_35383788/article/details/110394784

版权

Spring DI 构造函数注入依赖注入集合注入 bean配置

关键词由CSDN通过智能技术生成

spring的依赖注入:
          依赖注入:
              Dependency Injection
          IOC的作用:
              降低程序间的耦合(依赖关系)
              依赖关系的管理：
              以后都交由spring来维护
          在当前类需要用到其他类的对象，有spring为我们提供，我们只需在配置文件中说明
              依赖关系的维护：
                   就称之为依赖注入。
              依赖注入:
                  能注入的数据有三类：
                      基本类型和String
                      其他Bean类型（在配置文件中或者注解配置过的bean）
                      复杂类型/集合类型
                  注入的方式有三种：
                       第一种：使用构造函数提供
                       第二种：使用set方法提供
                       第三种：使用注解提供

构造函数的注入:
        使用的标签:constructor-arg
        标签出现的位置:Bean标签的内部
        标签中的属性
             type:用于指定要注入的数据类型，该数据类型也是构造函数中某个或某些参数的类型
             index:用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置从0开始
             name:用于指定给构造函数中指定的参数赋值（常用）
             ==========以上三个用于指定给构造函数中哪个参数赋值============================
             value:用于提供基本类型和String类型的数据
             ref:用于指定其他的Bean类型数据。他指的就是在spring的IOC核心容器中出现过得bean对象

             优势：
                 在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
             弊端:
                 改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供

<bean id="accountService" class="com.springpractise.demo.service.AccountServiceImpl" scope="prototype">
    <constructor-arg name="name" value="test"></constructor-arg>
    <constructor-arg name="age" value="18"></constructor-arg>
    <constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>

<!--配置一个日期对象-->
<bean id="now" class="java.util.Date"></bean>

<!--set方法注入   更常用的方式
    涉及的标签:property
    出现的位置:bean标签的内部
    标签的属性
         name:用于指定注入时所调用的set方法名称
         value:用于提供基本类型和String类型的数据
         ref:用于指定其他bean类型数据。它指的是在spring的IOC核心容器中出现过的bean对象
    优势:
        创建对象时没有明确的限制，可以直接使用默认构造函数
    弊端:
        如果有某个成员必须有值，则获取对象时有可能set方法没有执行
    -->
<bean id="accountService3" class="com.springpractise.demo.service.AccountServiceImpl" scope="prototype">
    <property name="age" value="12"></property>
    <property name="name" value="泰斯特"></property>
    <property name="birthday" ref="now"></property>
</bean>

<!--复杂类型的注入/集合类型的注入
    用于给List结构集合注入的标签:
       list array set
    用于给Map结构集合注入的标签:
       map props
    结构相同，标签可以互换-->
<bean id="mapList" class="com.springpractise.demo.service.MapList">
    <property name="strings">
        <array>
            <value>AAAA</value>
            <value>BBBB</value>
            <value>CCCC</value>
            <value>DDDD</value>
        </array>
    </property>

    <property name="list">
        <list>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
            <value>DDD</value>
        </list>
    </property>

    <property name="set">
        <set>
            <value>AA</value>
            <value>BB</value>
            <value>CC</value>
            <value>DD</value>
        </set>
    </property>

    <property name="map">
        <map>
            <entry key="one" value="1"></entry>
            <entry key="two" value="2"></entry>
            <entry key="three">
                <value>3</value>
            </entry>
        </map>
    </property>

    <property name="properties">
        <props>
            <prop key="test">1</prop>
            <prop key="test1">2</prop>
        </props>
    </property>
</bean>

完整代码:

package com.springpractise.demo.service;

import java.util.*;

public class MapList {

    private String[] strings;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties properties;

    public void setStrings(String[] strings) {
        this.strings = strings;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void saveAccount(){
        System.out.println(Arrays.toString(strings));
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
        System.out.println(properties);
    }
}

.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--把对象的创建交给spring管理-->

    <!--spring对bean的管理细节
        1.创建Bean的三种方式
        2.bean对象的作用范围
        3.bean对象的生命周期
        -->
    <!--创建Bean的三种方式-->
    <!--第一种方式:使用默认构造函数创建
        在spring的配置文件中使用bean标签，配以ID和class属性后，且没有其他属性和标签时。
        采用的就是默认的默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建-->
    <!--<bean id="accountService" class="com.springpractise.demo.service.AccountServiceImpl"></bean>-->

    <!--第二种方法，使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）-->
    <bean id="instanceFactory" class="com.springpractise.demo.test.FactoryInstanceFactory"></bean>
    <bean id="accountService1" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
    <bean id="accountDao" class="com.springpractise.demo.Dao.AccountDaoImpl"></bean>

    <!--第三种方式:使用工厂中的静态方法创建对象，使用某个类中的静态方法创建对象，并存入spring容器-->
    <!--<bean id="accountService2" class="com.springpractise.demo.test.StaticFactory" factory-method="getAccountService"></bean>-->
    <!--Bean的作用范围调整
        Bean标签的scope属性:
        作用:用于指定Bean的作用范围
        取值:   常用的就是singleton和prototype
                singleton:单列的（默认值）
                prototype:多列的
                request:作用于web应用的请求范围
                session:作用于web应用的会话范围
                global-session:作用于集群环境的会话范围（全局会话范围），当不是集群时，它就是session-->

    <bean id="accountService2" class="com.springpractise.demo.test.StaticFactory" factory-method="getAccountService" scope="prototype"></bean>

    <!--Bean对象的生命周期
            单例对象
                出生：当容器创建时对象出生
                活着: 只要容器还在，对象一直活着
                死亡: 容器消亡，对象消亡
                总结: 单例对象的生命周期和容器相同
            多例对象
                出生: 当我们使用对象时spring框架为我们创建
                活着: 对象只要是在使用过程中就一直活着
                死亡: 当对象长时间不用，且没有别的对象引用时，由java垃圾回收器回收
                -->
    <!--<bean id="accountService" class="com.springpractise.demo.service.AccountServiceImpl" scope="prototype"-->
    <!--init-method="init" destroy-method="destory"></bean>-->

    <!--spring的依赖注入:
              依赖注入:
                  Dependency Injection
              IOC的作用:
                  降低程序间的耦合(依赖关系)
                  依赖关系的管理：
                  以后都交由spring来维护
              在当前类需要用到其他类的对象，有spring为我们提供，我们只需在配置文件中说明
                  依赖关系的维护：
                       就称之为依赖注入。
                  依赖注入:
                      能注入的数据有三类：
                          基本类型和String
                          其他Bean类型（在配置文件中或者注解配置过的bean）
                          复杂类型/集合类型
                      注入的方式有三种：
                           第一种：使用构造函数提供
                           第二种：使用set方法提供
                           第三种：使用注解提供-->

    <!--构造函数的注入:
            使用的标签:constructor-arg
            标签出现的位置:Bean标签的内部
            标签中的属性
                 type:用于指定要注入的数据类型，该数据类型也是构造函数中某个或某些参数的类型
                 index:用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置从0开始
                 name:用于指定给构造函数中指定的参数赋值（常用）
                 ==========以上三个用于指定给构造函数中哪个参数赋值============================
                 value:用于提供基本类型和String类型的数据
                 ref:用于指定其他的Bean类型数据。他指的就是在spring的IOC核心容器中出现过得bean对象

                 优势：
                     在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
                 弊端:
                     改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供


                 -->
    <bean id="accountService" class="com.springpractise.demo.service.AccountServiceImpl" scope="prototype">
        <constructor-arg name="name" value="test"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>

    <!--配置一个日期对象-->
    <bean id="now" class="java.util.Date"></bean>

    <!--set方法注入   更常用的方式
        涉及的标签:property
        出现的位置:bean标签的内部
        标签的属性
             name:用于指定注入时所调用的set方法名称
             value:用于提供基本类型和String类型的数据
             ref:用于指定其他bean类型数据。它指的是在spring的IOC核心容器中出现过的bean对象
        优势:
            创建对象时没有明确的限制，可以直接使用默认构造函数
        弊端:
            如果有某个成员必须有值，则获取对象时有可能set方法没有执行
        -->
    <bean id="accountService3" class="com.springpractise.demo.service.AccountServiceImpl" scope="prototype">
        <property name="age" value="12"></property>
        <property name="name" value="泰斯特"></property>
        <property name="birthday" ref="now"></property>
    </bean>

    <!--复杂类型的注入/集合类型的注入
        用于给List结构集合注入的标签:
           list array set
        用于给Map结构集合注入的标签:
           map props
        结构相同，标签可以互换-->
    <bean id="mapList" class="com.springpractise.demo.service.MapList">
        <property name="strings">
            <array>
                <value>AAAA</value>
                <value>BBBB</value>
                <value>CCCC</value>
                <value>DDDD</value>
            </array>
        </property>

        <property name="list">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
                <value>DDD</value>
            </list>
        </property>

        <property name="set">
            <set>
                <value>AA</value>
                <value>BB</value>
                <value>CC</value>
                <value>DD</value>
            </set>
        </property>

        <property name="map">
            <map>
                <entry key="one" value="1"></entry>
                <entry key="two" value="2"></entry>
                <entry key="three">
                    <value>3</value>
                </entry>
            </map>
        </property>

        <property name="properties">
            <props>
                <prop key="test">1</prop>
                <prop key="test1">2</prop>
            </props>
        </property>
    </bean>


</beans>

main方法：

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
//ApplicationContext applicationContext = new FileSystemXmlApplicationContext("F:\\vertx\\springpractise\\src\\main\\resources\\bean.xml");
//根据ID获取Bean对象
AccountService accountService = (AccountService) applicationContext.getBean("accountService3");
accountService.saveAccount();

MapList mapList = (MapList) applicationContext.getBean("mapList");
mapList.saveAccount();