【Spring框架】（三）控制反转IOC和bean标签

控制反转-Inversion Of Control

工厂是什么？
工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。
原来：我们在获取对象时，都是采用 new 的方式。是主动的。
现在：我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。

这种被动接收的方式获取对象的思想就是控制反转，它是 spring 框架的核心之一。

IOC简介：

控制反转（Inversion of Control，缩写为IoC） ，是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。
通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中.

明确 ioc 的作用：
削减计算机程序的耦合(解除我们代码中的依赖关系)。

使用 spring 的 IOC 解决程序耦合

Spring基于xml的ioc环境搭建

一、pom.xml文件导入依赖

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

二、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="code.service.impl.AccountServiceImpl"></bean>
    <bean id="accountDao" class="code.dao.impl.AccountDaoImpl"></bean>
</beans>

三、持久层dao、业务逻辑层Service 的代码

持久层的实现类：AccountDao

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

账户的业务层实现类 : AccountService

/**  * 账户的业务层实现类  */ 
public class AccountServiceImpl implements IAccountService {
    IAccountDao accountDao = new AccountDaoImpl();
    public void saveAccount() {
        accountDao.saveAccount();
        } 
    }

四、表现层通过Spring核心对象ApplicationContext,读取XML配置文件,创建对象

表现层UI：获取Spring的IOC核心容器，并根据id获取对象

/**  * 获取Spring的IOC核心容器，并根据id获取对象  */ 
public class Client {
    public static void main(String[] args) {
       //1.获取核心容器对象
        ApplicationContext ac =new ClassPathXmlApplicationContext("bean.xml");
        
       // 2.根据id获取bean对象
       IAccountService as=(IAccountService) ac.getBean("accountService");
        IAccountDao adao= (IAccountDao)ac.getBean("accountDao");

        System.out.println(as);
        System.out.println(adao);

        as.saveAccount();

       } 
    }
     ```
     

执行结果：

spring 中工厂的类结构图

BeanFactory 和 ApplicationContext 的区别

BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
BeanFactory 和 ApplicationContext 的区别：

• 创建对象的时间点不一样。
• ApplicationContext：它在构建核心容器时，创建对象采取的策略是采用 立即加载的方式。也就是说，只要一读取完配置文件，马上就创建配置文件中配置的对象。适用于单例对象。
• BeanFactory：延迟加载，什么使用什么时候创建对象。适用于多例对象。

示例代码：BeanFactory创建bean对象

  //--------------BeanFactory-------------------------
        Resource resource =  new ClassPathResource("bean.xml");
        BeanFactory factory = new XmlBeanFactory(resource);
        IAccountService as = (IAccountService) factory.getBean("accountService");
        System.out.println(as);

ApplicationContext 接口 的三个实现类

ClassPathXmlApplicationContext ：它是从类的根路径下加载配置文件 推荐使用这种
FileSystemXmlApplicationContext ：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext:当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

IOC 中bean标签和管理对象细节

把对象的创建交给spring来管理–>
spring对bean的管理细节-->

• 1.创建bean的三种方式–>
• 2.bean对象的作用范围–>
• 3.bean对象的生命周期–>

创建Bean的三种方式

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

    <bean id="accountService" class="code.service.impl.AccountServiceImpl"></bean>
    <bean id="accountDao" class="code.dao.impl.AccountDaoImpl"></bean>

---

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

    <bean id="instanceFactory" class="code.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>

---

第三种方式，使用工厂中的静态方法创建对象（使用某个类中的方法创建对象，并存入spring容器）

    <bean id="accountService"  class="code.factory.staticFactory" factory-method="getAccountService">
   </bean>

bean标签的属性:
属性：

• id：给对象在容器中提供一个唯一标识。用于获取对象。
• class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
• scope：指定对象的作用范围。

  • singleton :默认值，单例的.

  • prototype :多例的.

  • request : WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.

  • session : WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.

  • global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境
    那么globalSession 相当于 session.

  • init-method：指定类中的初始化方法名称。

  • destroy-method：指定类中销毁方法名称。

global session的含义又叫全局session，作用于集群环境的全局会话范围
global session-负载均衡

bean对象的作用范围

单例对象：scope=“singleton”
一个应用只有一个对象的实例。它的作用范围就是整个引用。 即使用相同的id获得的都是同一个对象引用。
生命周期：
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

多例对象：scope=“prototype”
每次访问对象时，都会重新创建对象实例。使用相同的id 多次申请会得到新的对象引用。
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java的垃圾回收器回收了。

单例模式下的初始化和销毁，且创建bean对象时为立即加载

<!--   bean对象的作用范围：单例模式 -->
    <bean id="accountService" class="code.service.impl.AccountServiceImpl"
        scope="singleton" init-method="init" destroy-method="destroy"></bean>

public class Client {
    public static void main(String[] args) {
        //1.获取核心容器对象
        ClassPathXmlApplicationContext ac =new ClassPathXmlApplicationContext("bean.xml");
        // 2.根据id获取bean对象
        IAccountService as=(IAccountService) ac.getBean("accountService");

        System.out.println(as);
        as.saveAccount();
        //手动关闭ac的容器
        ac.close();
  }
}

多例模式下的初始化和销毁，且创建bean对象时为延迟加载

<!--   bean对象的作用范围 ：多例模式 -->
    <bean id="accountService" class="code.service.impl.AccountServiceImpl"
        scope="prototype" init-method="init" destroy-method="destroy"></bean>

如下图，多例对象不会立即销毁，而是会有Java的垃圾回收机制销毁。
即使调用了 close()方法，也不会立即销毁。

spring的依赖注入

10 构造函数注入
11 set方法注入
12 注入集合数据
13 课程知识梳理