Spring—— Spring IOC

欧金鹏

2023-12-01

一、IOC简介

1.什么是IOC

IOC(Inverse of Control) 控制反转，是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。控制反转指的是将对象交给Spring来创建。

DI(依赖注入)是实现IOC的一种方法。
IOC是Spring框架的核心内容，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IOC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

2.IOC容器的底层原理

IOC的实现，依赖于以下3门技术：

dom4j解析xml文档；
工厂模式；
采用反射设计模式创建对象

DOM4J：是一个开源的，基于Java的库来解析XML文档，它具有高度的灵活性，高性能和内存效率的API。由电脑完成。

工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

采用反射设计模式创建对象：Class.newInstance() 或Constructor.newInstance()

二、IOC容器的实现方式

IOC思想是基于IOC容器完成的，IOC的底层就是对象工厂。

1.BeanFactroy

BeanFactroy：IOC容器是Spring内部的使用接口，不提供给开发人员使用

public class DemoTest {
        //传统写法
        @Test
        public void run(){
            Demo demo = new Demo();
            demo.hello();
        }
        //spring写法
        @Test
        public void run1(){
            //创建spring工厂，加载配置文件
            BeanFactory ac = new ClassPathXmlApplicationContext("applicationContext.xml");
            //获取bean对象
            Demo demo = (Demo) ac.getBean("demo");
            demo.hello();
        }
}

【注意】 BeanFactroy:加载配置文件的时候不会去创建对象，在使用对象的时候才会去创建对象

2.ApplicationContext

ApplicationContext:BeanFactory接口的子接口，提供了更多更强大的功能，一般由开发人员进行使用

public class DemoTest {
        //传统写法
        @Test
        public void run(){
            Demo demo = new Demo();
            demo.hello();
        }
        //spring写法
        @Test
        public void run1(){
            //创建spring工厂，加载配置文件
            ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
            //获取bean对象
            Demo demo = (Demo) ac.getBean("demo");
            demo.hello();
        }
}

【注意】加载配置文件的时候会把对象创建

三、IOC创建对象的方式

1.使用无参构造方法创建对象（默认）

实体类
注意点：实体类中一定要有一个无参构造方法

public class User {
        private String name;
        public User() {
                System.out.println("user无参构造方法");
}
        public void setName(String name) {
                this.name = name;
}
        public void show(){
                System.out.println("name="+ name );
        }
}

bean.xml

<bean id="user" class="com.kuang.pojo.User">
     <property name="name" value="我是一个name"/>
</bean>

测试类

@Test
public void test(){
        ApplicationContext context = new
        ClassPathXmlApplicationContext("beans.xml");
        //在执行getBean的时候, user已经创建好了 , 通过无参构造
        User user = (User) context.getBean("user");
        //调用对象的方法 .
        user.show();
}

输出

user无参构造方法
name：我是一个name
说明：结果可以发现，在调用show方法之前，User对象已经通过无参构造初始化了。

2.使用有参构造方法创建对象（3种）

实体类

public class UserT {
    private String name;
    public UserT(){
        System.out.println("UserT的无参构造");
    }
    public UserT(String name){
        this.name = name;
        System.out.println("UserT的有参构造");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println("name:"+name);
    }
}

xml

<!-- 第一种根据index参数下标设置 -->
<bean id="userT" class="com.spring.pojo.UserT">
    <!-- index指构造方法 , 下标从0开始 -->
    <constructor-arg index="0" value="name1"/>
</bean>

<!-- 第二种根据参数类型设置 -->
<bean id="userT" class="com.spring.pojo.UserT">
    <constructor-arg type="java.lang.String" value="name2"/>
</bean>

<!-- 第三种根据参数名字设置 -->
<bean id="userT" class="com.spring.pojo.UserT">
    <!-- name指参数名 -->
    <constructor-arg name="name" value="name3"/>
</bean>