Spring中的IoC

1、Spring核心之IoC控制反转

1.1 IoC的概念

        Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。 IoC 是指在程序开发中，实例的创建不再由调用者管理，而是由 Spring 容器创建。Spring 容器会负责控 制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转移到了 Spring 容器中，控 制权发生了反转，这就是 Spring 的 IoC 思想。

1.2 Spring入门案例

1.2.1 创建maven项目 '

        创建完毕的目录结

1.2.2 pom.xml文件添加依赖和插件

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

    </dependencies>

1.2.3 创建一个实体类 

  package com.kkb.pojo;

    /**
     * 实体类球队
     */
    public class Team {
        private Integer id;
        private String name;
        private String location;

        public Team() {
            System.out.println("Team的默认构造方法被调用：id=" + id + ",name=" + name + ",
                    location = "+location);
        }
    }

1.3.4 创建Spring的配置文件application.xml 

1.3.5 使用Spring容器创建对象 

配置文件中创建对象

<?xml version="1.0" encoding="UTF-8"?>
    <!--spring的配置文件
    1、beans: 根标签，spring中java的对象成为bean
    2、spring-beans.xsd 是约束文件（约束XML文件中能编写哪些标签）-->
    <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,通知spring要创建哪个类的对象
        一个bean标签声明一个对象：
        id="自定义的对象名称" ,要求唯一
        class="类的完全限定名" 包名+类名，spring底层是反射机制创建对象，所以必须使用类
        名
        相当于 Team team1=new Team();创建好的对象放入一个集合Map中
        例如：springMap.put("team1",new Team());
        -->
        <bean id="team1" class="com.kkb.pojo.Team"></bean>
    </beans>

1.3.6 获取Spring容器 

Spring 提供了两种 IoC 容器，分别为 BeanFactory 和 ApplicationContext.

1.3.6.1 BeanFactory

BeanFactory 是基础类型的 IoC 容器,是一个管理 Bean 的工厂，它主要负责初始化各种 Bean，并调用 它们的生命周期方法。 BeanFactory 接口有多个实现类，最常见的是 org.Springframework.beans.factory.xml.XmlBeanFactory，它是根据 XML 配置文件中的定义装配 Bean 的。

BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource(Spring配置文件
的名称));

1.3.6.2 ApplicationContext

ApplicationContext 是 BeanFactory 的子接口，也被称为应用上下文。它不仅提供了 BeanFactory 的 所有功能，还添加了对 i18n（国际化）、资源访问、事件传播等方面的良好支持。 ApplicationContext 接口有两个常用的实现类:

1.6.2.2.1 ClassPathXmlApplicationContext——常用

该类从类路径 ClassPath 中寻找指定的 XML 配置文件，找到并装载完成 ApplicationContext 的实例化 工作

ApplicationContext applicationContext=new ClassPathXmlApplicationContext(Spring配
置文件的名称);

1.6.2.2.2 FileSystemXmlApplicationContext 

ApplicationContext applicationContext = new
FileSystemXmlApplicationContext(String configLocation);

它与 ClassPathXmlApplicationContext 的区别是：在读取 Spring 的配置文件时， FileSystemXmlApplicationContext 不再从类路径中读取配置文件，而是通过参数指定配置文件的位 置，它可以获取类路径之外的资源，如“D:\application.xml”。

1.3.7 通过上下文对象获取容器中的对象

ackage com.hgf.test;
import com.hgf.pojo.Team;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.FileSystemResource;

import java.util.Date;

public class Test1 {
    @Test
    public void test01() {
        //使用spring容器创建对象
        //1、指定spring配置文件的名称
        String springConfig = "application.xml";
        //2、创建spring容器的对象：
        //方式1:不推荐，了解
        //BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource("D:/workspaces/ideaProjects/MySpring/spring01/src/main/resources/application.xml"));
        //beanFactory.getBean("team1");//根据ID从IOC容器获取对象
        //方式2：applicationContext--常用
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(springConfig);//这里执行完毕容器中的对象都已经创建完成
        //方式3：applicationContext--了解
        //ApplicationContext applicationContext2 = new
        FileSystemXmlApplicationContext("D:/workspaces/ideaProjects/MySpring/spring01/src/main/resources/application.xml");
        //3、获取容器中的对象
                //Team team1 = (Team) applicationContext.getBean("team1");
        //4、容器其他api
        int beanDefinitionCount = applicationContext.getBeanDefinitionCount();
        System.out.println("spring容器中对象的个数：" + beanDefinitionCount);
        String[] beanDefinitionNames =
                applicationContext.getBeanDefinitionNames();
        System.out.println("spring容器中所有对象的名称：");
        for (String name : beanDefinitionNames) {
            System.out.println(name);
        }
    }
}

1.3.8 bean标签的属性

总结:

IoC（Inversion of Control）是Spring框架的核心概念之一，它代表了一种设计思想，即控制反转。在传统的程序开发中，对象的创建和管理由调用者负责，而在IoC思想下，对象的创建和管理被转移到了Spring容器中。

通过IoC，我们将程序的控制权交给了Spring容器，它负责创建和管理对象，并处理对象之间的关系。这样的设计带来了许多好处，包括解耦、灵活性和可维护性的提高。

在Spring中，我们通过配置文件（如XML配置文件）或注解来描述对象及其依赖关系。Spring容器根据这些描述信息来创建和初始化对象，同时解决对象之间的依赖关系。我们可以指定对象的作用域（如单例或原型），以及其他属性和行为。

Spring提供了两种主要的IoC容器：BeanFactory和ApplicationContext。BeanFactory是基础类型的IoC容器，负责对象的创建和生命周期管理。ApplicationContext是BeanFactory的子接口，它提供了更多的功能，如国际化、资源访问、事件传播等。

通过使用Spring容器，我们可以轻松地创建和管理对象，而不必直接依赖于具体的实现类。这提供了更大的灵活性和可测试性，同时也降低了代码之间的耦合度。

总而言之，IoC是Spring框架的核心思想，它通过将对象的创建和管理交给Spring容器来实现控制反转。这种设计思想带来了许多优势，使得我们的程序更加灵活、可维护和可扩展。