Spring基于XML的IOC学习总结

布满荆棘的人生 2021-10-18 07:54 334阅读 0赞

## IOC的环境配置 ##

### 导入依赖 ###

我们需要在我们的spring工程中pom.xml文件里加入IOC的相关依赖，依赖如下：

<dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.0.2.RELEASE</version>
            </dependency>
        </dependencies>

然后接下来的代码示例，项目的代码结构如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zlbmd4aW5saW51eA_size_16_color_FFFFFF_t_70]

接下来，由于我们采用的是XML形式配置IOC，所以我们还需要一个XML文件来配置我们的beans。  
在`resources`目录下，我们创建了一个名为`bean.xml`文件。  
`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">
    
        
        <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
    
        <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>
    </beans>

首先通过`beans`的标签里，导入有关ioc的相关约束。  
然后在`beans`标签内部，建立`bean`标签，来配置我们的`bean`对象。  
其中`id`为我们给bean对象起的一个唯一标识名，`class`对于我们bean对象所对应的类。  
在本文的代码示例中，`AccountServiceImpl`为业务层service接口实现类，`AccountDaoImpl`为持久层dao实现类。

到此为止，我们的有关IOC的相关配置已经完成。

## IOC的使用 ##

先看一下本文例子有关类的代码  
IAccountDao.java:

/**
     * 账户的持久层接口
     */
    public interface IAccountDao {
    
        /**
         * 模拟保存账户
         */
        void saveAccount();
    }

实现类AccountDaoImpl.java：

/**
     * 账户的持久层实现类
     */
    public class AccountDaoImpl implements IAccountDao {
    
        public  void saveAccount(){
    
            System.out.println("保存了账户");
        }
    }

IAccountService.java:

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

AccountServiceImpl.java:

/**
     * 账户的业务层实现类
     */
    public class AccountServiceImpl implements IAccountService {
    
        private IAccountDao accountDao ;
    
        public AccountServiceImpl(){
            System.out.println("对象创建了");
        }
    
        public void  saveAccount(){
            accountDao.saveAccount();
        }
    }

最后，我们定义一个client类来模拟表现层，调用service：

**
     * 模拟一个表现层，用于调用业务层
     */
    public class Client {
    
        public static void main(String[] args) {
            //1.获取核心容器对象
            ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
           // ApplicationContext ac = new FileSystemXmlApplicationContext("C:\\Users\\zhy\\Desktop\\bean.xml");
            //2.根据id获取Bean对象
            IAccountService as  = (IAccountService)ac.getBean("accountService");  //第一种获取bean的方式
            IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);  //第二种获取bean的方式，两者等价
    
            as.saveAccount();
    
        }
    }

`ApplicationContext`接口为spring提供的有关IOC的接口，还有一个名为`BeanFactory`的接口，这两个接口的区别为：

> ApplicationContext: 单例对象适用 采用此接口  
> 它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。

> BeanFactory: 多例对象使用  
> 它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。

**ApplicationContext的三个常用实现类：**

*  ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)
 *  FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）
 *  AnnotationConfigApplicationContext：它是用于读取注解创建容器的

### 创建bean的三种方式 ###

**第一种方式：使用默认构造函数创建**  
也就是我们上面的例子所用到的，例如

在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。  
采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。

**第二种方式： 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）**

我们可以模拟一个工厂类，该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数。此时，我们需要调用该类中的一个方法，才能得到我们想用到的类，例如：

public class InstanceFactory {
    
        public IAccountService getAccountService(){
            return new AccountServiceImpl();
        }
    }

我们需要通过调用InstanceFactory类中的getAccountService函数得到我们想要的对象，此时，我们就用到了第二种方式，例：

通过第一个bean标签，将InstanceFactory导入。  
然后第二个bean标签，`factory-bean`属性指定调用的类的bean标签id，factory-method对应调用的方法。

**第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)**  
与第二种方式大同小异，直接看代码示例：

因为是要调用一个类的静态方法，所以我们不需要先将该类导入为bean对象，直接在`class`标签中指定该类就可以。

### bean的作用范围调整 ###

**bean标签的scope属性：**

作用：用于指定bean的作用范围
    取值： 常用的就是单例的和多例的
            singleton：单例的（默认值）
            prototype：多例的
            request：作用于web应用的请求范围
            session：作用于web应用的会话范围
            global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

例如：

### bean对象的生命周期 ###

单例对象
             出生：当容器创建时对象出生
             活着：只要容器还在，对象一直活着
             死亡：容器销毁，对象消亡
             总结：单例对象的生命周期和容器相同
    多例对象
             出生：当我们使用对象时spring框架为我们创建
             活着：对象只要是在使用过程中就一直活着。
             死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收

bean标签的`init-method`属性可以指定bean对象初始化时，执行某个函数，`destroy-method`属性可以指定bean对象摧毁时，执行某个函数。例如：  
AccountServiceImpl.java:

public class AccountServiceImpl implements IAccountService {
    
    
    
        public AccountServiceImpl(){
            System.out.println("对象创建了");
        }
    
        public void  saveAccount(){
            System.out.println("service中的saveAccount方法执行了。。。");
        }
    
        public void  init(){
            System.out.println("对象初始化了。。。");
        }
        public void  destroy(){
            System.out.println("对象销毁了。。。");
        }
    
    }

对应的bean标签：

### spring中的依赖注入 ###

依赖注入：Dependency Injection  
IOC的作用：降低程序间的耦合（依赖关系）  
依赖关系的管理：以后都交给spring来维护  
在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明  
依赖关系的维护，就称之为依赖注入。  
依赖注入：  
能注入的数据：有三类

*  基本类型和String
 *  其他bean类型（在配置文件中或者注解配置过的bean）
 *  复杂类型/集合类型

注入的方式：有三种

*  第一种：使用构造函数提供
 *  第二种：使用set方法提供
 *  第三种：使用注解提供（xml方式中先不介绍）

**第一种，使用构造函数提供：**

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

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

例如：  
AccountServiceImpl.java:

public class AccountServiceImpl implements IAccountService {
    
        //如果是经常变化的数据，并不适用于注入的方式
        private String name;
        private Integer age;
        private Date birthday;
    
        public AccountServiceImpl(String name,Integer age,Date birthday){
            this.name = name;
            this.age = age;
            this.birthday = birthday;
        }
    
        public void  saveAccount(){
            System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
        }
    
    
    }

对应bean标签：

**第二种，set方法注入：**  
使用set方法注入时，我们需要在类中，为所有需要被注入的对象，设置set方法，例如：

public class AccountServiceImpl2 implements IAccountService {
    
        //如果是经常变化的数据，并不适用于注入的方式
        private String name;
        private Integer age;
        private Date birthday;
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        public void  saveAccount(){
            System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
        }
    
    
    }

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

**复杂类型的注入：**  
用于给List结构集合注入的标签：  
list array set  
用于个Map结构集合注入的标签:  
map props

例如：  
AccountServiceImpl3.java:

public class AccountServiceImpl3 implements IAccountService {
    
        private String[] myStrs;
        private List<String> myList;
        private Set<String> mySet;
        private Map<String,String> myMap;
        private Properties myProps;
    
        public void setMyStrs(String[] myStrs) {
            this.myStrs = myStrs;
        }
    
        public void setMyList(List<String> myList) {
            this.myList = myList;
        }
    
        public void setMySet(Set<String> mySet) {
            this.mySet = mySet;
        }
    
        public void setMyMap(Map<String, String> myMap) {
            this.myMap = myMap;
        }
    
        public void setMyProps(Properties myProps) {
            this.myProps = myProps;
        }
    
        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代码：

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zlbmd4aW5saW51eA_size_16_color_FFFFFF_t_70]: /images/20211018/f9109a04998846b1a32a895454f4cd48.png