文章/答案/技术大牛

发布

社区首页 >专栏 >【旧】G002Spring学习笔记-IOC之XML方式实现

【旧】G002Spring学习笔记-IOC之XML方式实现

訾博ZiBo

发布于 2025-01-06 07:08:24

7800

代码可运行

文章被收录于专栏：全栈开发工程师全栈开发工程师

运行总次数：0

代码可运行

一、IOC概述和作用

1、概念

将创建对象的权利交给框架，包括依赖注入和以来查找；

2、作用

降低计算机程序的耦合（依赖程度）；

3、说明

我们在自己写的时候很麻烦，所以交给spring完成；

二、spring中的IOC

1、spring基于xml的IOC环境搭建

代码：

IAccountDao接口：

package com.zibo.dao;

public interface IAccountDao {
    void saveAccount();
}

IAccountDaoImpl接口实现类：

package com.zibo.dao.impl;

import com.zibo.dao.IAccountDao;

public class IAccountDaoImpl implements IAccountDao {
    @Override
    public void saveAccount() {
        System.out.println("保存了账户");
    }
}

IAccountService接口：

package com.zibo.services;

/**
 * 业务层接口
 */
public interface IAccountService {
    /**
     * 模拟保存账户
     */
    void saveAccount();
}

IAccountServiceImpl接口实现类：

package com.zibo.services.impl;

import com.zibo.dao.IAccountDao;
import com.zibo.dao.impl.IAccountDaoImpl;
import com.zibo.services.IAccountService;

/**
 * 账户的业务层实现类
 */
public class IAccountServiceImpl implements IAccountService {
    private IAccountDao iAccountDao = new IAccountDaoImpl();
    @Override
    public void saveAccount() {
        iAccountDao.saveAccount();
    }
}

Client类：

package com.zibo.ui;

import com.zibo.dao.IAccountDao;
import com.zibo.services.IAccountService;
import com.zibo.services.impl.IAccountServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 模拟表现层，调用业务层
 */
public class Client {
    public static void main(String[] args) {
       /*
         * 获取spring的IOC的核心容器，并根据id获取对象
         * ApplicationContext的三个常用实现类：
         * 1、ClassPathXmlApplicationContext（xml方式最常用）：仅能加载类路径下的配置文件；
         * 2、FileSystemXmlApplicationContext：可以加载磁盘任意路径下的配置文件（必须有访问权限）；
         * 3、AnnotationConfigApplicationContext：用于读取注解创建容器；
         */
        //1、获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2、根据id获取bean对象
        IAccountService service = ac.getBean("accountService",IAccountService.class);
        IAccountDao dao = ac.getBean("accountDao",IAccountDao.class);
        System.out.println(service);
        System.out.println(dao);
    }
}

配置文件：

bean.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来管理-->
    <bean id="accountService" class="com.zibo.services.impl.IAccountServiceImpl"/>

    <bean id="accountDao" class="com.zibo.dao.impl.IAccountDaoImpl"/>
</beans>

pom.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>day01_eesy_03spring</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>

</project>

文件位置图：

运行结果：

2、核心容器的两个接口引发的问题

ApplicationContext：（单例对象适用，常用此接口）

它在构建容器时，创建对象采用的策略是立即加载的方式，也就是说，一读完配置文件就马上创建对象；

BeanFactory：（多例对象适用）

在构建核心容器时，创建对象采用的策略上延迟加载的方式，也就是说什么时候根据id获取对象，什么时候创建对象；

三、spring对bean的管理细节

1、创建bean的三种方式：

第一种方法：

bean.xml文件：

<!--    1、创建bean的三种方式：-->
<!--    第一种方式：使用默认构造函数进行创建：在spring的配置文件中使用bean标签，
        有且仅有id属性和class属性时，此时采用的就是使用默认构造函数进行创建对象，
        如果类中没有默认构造函数，则无法创建-->
        <bean id="accountService" class="com.zibo.services.impl.IAccountServiceImpl"/>

第二种方法：

模拟工厂类InstanceFactory：

package com.zibo.factory;

import com.zibo.services.IAccountService;
import com.zibo.services.impl.IAccountServiceImpl;

/**
 * 用于模拟一个工厂类（该类可能存在于jar包中，我们无法通过修改代码的方式来提供默认构造方法）
 */
public class InstanceFactory {
    public IAccountService getAccountService(){
        return new IAccountServiceImpl();
    }
}

bean.xml文件：

<!--    第二种方式：使用普通工厂中的方法创建对象（使用某个类中的方法获取对象并存入容器）-->
    <bean id="instanceFactory" class="com.zibo.factory.InstanceFactory"/>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"/>

第三种方式：

模拟工厂类StaticFactory：

package com.zibo.factory;

import com.zibo.services.IAccountService;
import com.zibo.services.impl.IAccountServiceImpl;

/**
 * 用于模拟一个工厂类（该类可能存在于jar包中，我们无法通过修改代码的方式来提供默认构造方法）
 */
public class StaticFactory {
    public static IAccountService getAccountService(){
        return new IAccountServiceImpl();
    }
}

bean.xml文件：

<!--第三种方式：使用普通工厂中的静态方法创建对象（使用某个类中的静态方法获取对象并存入容器）-->
        <bean id="accountService" class="com.zibo.factory.StaticFactory" factory-method="getAccountService"/>

2、bean对象的作用范围：

使用bean标签的scope属性：

作用：

用于指定bean的作用范围；

取值：

singleton（常用）：单例的（默认）；

prototype（常用）：多例的；

request：作用于web应用的请求范围；

session：作用于web应用的会话范围；

global-session：作用于集群应用的会话范围（全局会话范围），当不上集群时相当于session；

示例代码：

<bean id="accountService" class="com.zibo.factory.StaticFactory" factory-method="getAccountService" scope="prototype"/>

3、bean对象的生命周期：

单例对象：

被创建：随容器一起被创建；

存活：随容器存活；

销毁：随容器销毁；

总结：单例对象的生命周期与容器相同；

多例对象：

被创建：当我们使用对象时，spring框架为我们创建；

存活：对象只要在使用中就一直存活；

销毁：当对象长时间不用，且没有别的对象引用时，有Java垃圾回收器进行回收；

四、spring的依赖注入

1、概述

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

2、构造函数注入

（1）使用构造函数注入：

说明：

1、使用构造函数注入（一般不用，除非不得不用）:
               使用的标签：constructor-arg;
               标签出现的位置：bean的内部；
               标签中的属性：
                        type：用于指定注入的数据类型，该数据类型是构造函数中某参数的类型；
                        index：用于指定注入数据的索引，给对应索引位置赋值，索引从0开始；
                        name：用于指定注入数据的名字，给对应名字赋值（常用）；
                        value：用于指定基本类型和string类型的数据；
                        ref：用于指定其他bean类型的数据，指定是在spring的Ioc核心容器中出现过的bean对象；

                优势：
                        在创建bean对象时，必须注入数据，否则无法创建成功；
                弊端：
                        改变了bean对象的实例化方式，若用不到这些数据也必须提供；

代码示例：

配置：

        <bean id="accountService" class="com.zibo.services.impl.IAccountServiceImpl">
                <constructor-arg name="name" value="名字"/>
                <constructor-arg name="age" value="18"/>
                <constructor-arg name="birthday" ref="now"/>
        </bean>
        <!--配置一个日期对象-->
        <bean name="now" class="java.util.Date"/>

实现类IAccountServiceImpl：

package com.zibo.services.impl;

import com.zibo.services.IAccountService;

import java.util.Date;

/**
 * 账户的业务层实现类
 */
public class IAccountServiceImpl implements IAccountService {

    //构造函数注入演示，如果是经常发生变化的数据，不适合使用此方法
    private String name;
    private Integer age;
    private Date birthday;

    public IAccountServiceImpl(String name, Integer age, Date birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    @Override
    public void saveAccount() {
        System.out.println("service中的saveAccount方法执行了");
    }
}

（2）使用set方法注入：

说明：

                2、set方法注入（更常用的方式）：
                涉及的标签：property；
                出现的位置：bean标签内部；
                标签的属性：
                        name：用于指定所调用的set方法名称；
                        value：用于指定基本类型和string类型的数据；
                        ref：用于指定其他bean类型的数据，指定是在spring的Ioc核心容器中出现过的bean对象；
                优势：
                        创建对象没有明确的限制，可以直接使用默认构造方法；
                弊端：
                        如果某个成员必须有值，获取对象时set方法可能没有执行；

代码示例：

配置：

        <bean id="accountService2" class="com.zibo.services.impl.IAccountServiceImpl2">
                <property name="name" value="test"/>
                <property name="age" value="18"/>
                <property name="birthday" ref="now"/>
        </bean>

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

实现类IAccountServiceImpl2：

package com.zibo.services.impl;

import com.zibo.services.IAccountService;

import java.util.Date;

/**
 * 账户的业务层实现类
 */
public class IAccountServiceImpl2 implements IAccountService {
    
    private String name;
    private Integer age;
    private Date birthday;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public void saveAccount() {
        System.out.println("service中的saveAccount方法执行了");
    }
}

（3）注入集合数据：

说明：

                复杂类型的注入/集合类型的注入:
                用于给list结构集合注入的标签：
                        list array set
                用于给map结构集合注入的标签：
                        map props
                总结：结构相同，标签可以互换；

代码示例：

实现类IAccountServiceImpl3：

package com.zibo.services.impl;

import com.zibo.services.IAccountService;

import java.util.*;

/**
 * 账户的业务层实现类
 */
public class IAccountServiceImpl3 implements IAccountService {

    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;

    public String[] getMyStrs() {
        return myStrs;
    }

    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }

    public List<String> getMyList() {
        return myList;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public Set<String> getMySet() {
        return mySet;
    }

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

    public Map<String, String> getMyMap() {
        return myMap;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public Properties getMyProps() {
        return myProps;
    }

    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    @Override
    public void saveAccount() {
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);
    }
}

配置：

        <bean id="accountService3" class="com.zibo.services.impl.IAccountServiceImpl3">
                <property name="myStrs">
                        <array>
                                <value>AAA</value>
                                <value>BBB</value>
                                <value>CCC</value>
                        </array>
                </property>
                <property name="myList">
                        <list>
                                <value>AAA</value>
                                <value>BBB</value>
                                <value>CCC</value>
                        </list>
                </property>
                <property name="mySet">
                        <set>
                                <value>AAA</value>
                                <value>BBB</value>
                                <value>CCC</value>
                        </set>
                </property>
                <property name="myMap">
                        <map>
                                <entry key="k1" value="v1"/>
                                <entry key="k2" value="v2"/>
                                <entry key="k3" value="v3"/>
                        </map>
                </property>
                <property name="myProps">
                        <props>
                                <prop key="testA">AAA</prop>
                                <prop key="testB">BBB</prop>
                                <prop key="testC">CCC</prop>
                        </props>
                </property>
        </bean>