IOC底层原理

什么是IOC

控制反转，把创建对象和对象之间的调用过程，交给Spring进行管理
使用IOC的目的，为了耦合度降低
IOC的底层原理
xml解析、工厂模式、反射
示意图

IOC接口

IOC思想基于IOC 容器完成，IOC容器底层就是对象工厂
Spring提供IOC 容器实现两种方式：（两个接口）
1. BeanFactory：IOC 容器基于实现，是Spring 内部的使用接口，不提供开发人员进行使用。（加载配置文件时，不创建对象，在使用的时候创建）
2. ApplicationContext : BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用（在加载配置文件时，同步创建对象）
ApplicationContext 接口有实现类

截屏2021-08-27 上午8.55.03.png

IOC接口（BeanFactory）

截屏2021-08-27 上午8.57.47.png

IOC操作Bean管理

什么是Bean管理

管理Bean指的是两个操作

1、Spring创建对象

2、Spring注入属性

Bean管理操作的两种实现方式

1、基于xml 配置文件方式实现

创建对象

在Spring 配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
在bean标签属性
1. id : 唯一一个标识，通过标识获取对象，不能使用特殊符号
2. class : 类的全路径
3. name : 也是一个唯一标识
创建对象时，默认也是执行无参构造方法完成对象创建。 ```xml <?xml version=”1.0” encoding=”UTF-8”?>

<bean id="user" class="com.wujing.spring5.base.User">
</bean>

<a name="RqPH2"></a>
#### 注入属性
DI： 依赖注入，就是注入属性

1. 第一种方式：使用set方法进行注入

 a、创建对象<br /> b、在Spring 配置文件中，配置对象<br /> c、使用set 方法注入属性

2. 第二种方式：构造方法
```xml
 <!-- 注入 属性 set注入-->
    <bean id="user" class="com.wujing.spring5.base.User" name="user2">
        <property name="name" value="用户" ></property>
    </bean>

    <!-- 注入属性  构造方法 注入-->
    <bean id="book" class="com.wujing.spring5.base.Book" >
       <constructor-arg name="name" value="你好" ></constructor-arg>
    </bean>
        <!--
        1、添加p命名空间的 到配置文件中
        xmlns:p="http://www.springframework.org/schema/p"
        2、属性注入，在bean 标签里进行操作
    -->
    <bean id="user3" class="com.wujing.spring5.base.User"  p:name="张三你好" ></bean>

FactoryBean

1、Spring 有两种类型bean
一种：普通bean
在配置文件中定义bean类型就是返回类型
二种：工厂bean（FactoryBean）
在配置文件定义bean类型可以和返回值类型不一样
创建工厂bean步骤
1、创建类，让这个类作为工厂bean，实现接口FactoryBean
2、实现接口里面的方法，在实现的方法中定义返回的bean类型

2、基于注解方式实现

bean作用域

说明

1、在Spring里，设置创建bean实例是单实例还是多实例
2、在Spring里，默认情况下，bean是单例对象

如何设置单实例还是多实例

1、在Spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例
2、scope 属性值
第一个值：默认值，singleton 单实例
第二个值：prototype 多实例
3、两个值的区别
设置scope 值为：singleton 时，加载Spring 配置文件时就会创建单实例对象
设置scope值为；prototype时，不是在加载Spring 配置文件时创建对象，是在调用getBean方法时创建多实例对象

bean的生命周期

1、生命周期

从对象创建到对象销毁的过程

2、bean 生命周期

第一步、通过构造器创建bean实例（无参构造方法）
第二步、为bean的属性设置值和其他bean引用（调用set方法）
第三部、调用bean的初始化的方法（需要进行配置）
第四步、bean可以使用了（对象获取到了）
第五步、当容器关闭时，调用bean的销毁方法（需要配置销毁方法）

3、生命周期代码

package com.wujing.spring5.bean;

/**
 * @ClassName: Orders
 * @Description: 测试生命周期
 * @Author liujiexin
 * @Date 2021/9/1 8:55 上午
 */
public class Orders {
    private String oname;

    public Orders() {
        System.out.println("第一步 执行无参构造器方法创建 bean实例");
    }

    public String getOname() {
        return oname;
    }

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性值");
    }

    /** 
     * @Description: 初始化的方法
     * @Param:  
     * @return: void
     * @Author: liujiexin
     * @Date: 2021/9/1 9:02 上午
     */
    public void initMethod(){
        System.out.println("第三步 执行初始化的方法");
    }

    /**
     * @Description: 初始化的方法
     * @Param:
     * @return: void
     * @Author: liujiexin
     * @Date: 2021/9/1 9:02 上午
     */
    public void destroyMethod(){
        System.out.println("第五步 执行销毁方法");
    }


}

<?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="order" class="com.wujing.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="订单名称"></property>
    </bean>
</beans>

package com.wujing.spring5.test;


import com.wujing.spring5.base.Book;
import com.wujing.spring5.bean.Orders;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;



/**
 * @ClassName: OrdersTest
 * @Description:
 * @Author liujiexin
 * @Date 2021/9/1 9:27 上午
 */
public class OrdersTest {

    @Test
    public void test1(){
        // 第一步加载 配置文件
        ClassPathXmlApplicationContext classPathXmlApplicationContext =
                new ClassPathXmlApplicationContext("order.xml");

        Orders order = classPathXmlApplicationContext.getBean("order", Orders.class);
        System.out.println(order.getOname());

        classPathXmlApplicationContext.close();
    }
}

4、bean后置处理器，有7步

第一步、通过构造器创建bean实例（无参构造方法）
第二步、为bean的属性设置值和其他bean引用（调用set方法）
第三部、把bean实例传递给bean后置处理器的方法
第四部、调用bean的初始化的方法（需要进行配置）
第五步、把bean实例传递给bean后置处理的方法
第六步、bean可以使用了（对象获取到了）
第七步、当容器关闭时，调用bean的销毁方法（需要配置销毁方法）

5、后置处理器的代码

xml自动装配

1、什么是自动装配

根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

2、自动装配过程

   <!-- 实现自动装配
        bean标签属性autowire 配置自动装配
        autowire属性常用两个值，
            byName 根据属性名称注入，注入值bean的id值和属性名称一样
            byType 根据属性类型注入
        -->
    <bean id="emp" class="com.wujing.spring5.autowire.Emp" autowire="byName">
        <!--<property name="dept" ref="dept" ></property>-->
    </bean>

    <bean id="dept" class="com.wujing.spring5.autowire.Dept" >

    </bean>

基于注解管理bean

1、什么是注解

a、注解是代码特殊标记，格式： @注解名称(属性名称=属性值…)
b、使用注解，注解作用在类上面，方法上面，属性上面
c、使用注解目的：简化xml配置

2、Spring 针对Bean管理中创建对象提供注解

@Component

@Service

@Controller

@Repositroy

都可以用来创建bean实例

3、基于注解方式实现对象注入

第一步引入依赖

spring-aop.jar 包

第二步开启组件扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:pcontext="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd ">

    <!--
      开启组件扫描
      1、扫描多个包使用逗号隔开
      2、扫描包的上层目录
      -->
    <pcontext:component-scan base-package="com.wujing.spring5.annotation" >


    </pcontext:component-scan>

</beans>

第三步创建类使用注解

@Component(value = "userService")
public class UserService {

    public void add(){
        System.out.println( "userService");
    }
}

4、扫描配置的细节

    <!--  包含 类型 的对应的注解  -->
    <pcontext:component-scan base-package="com.wujing.spring5.annotation" use-default-filters="false">
        <pcontext:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>

    </pcontext:component-scan>


    <!--  不包含 类型 的对应的注解  -->
    <pcontext:component-scan base-package="com.wujing.spring5.annotation" >
        <pcontext:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
    </pcontext:component-scan>

5、基于注解方式实现属性注入

@AutoWired (org.springframework.beans.factory.annotation)

根据属性类型注入

@Qualifier(org.springframework.beans.factory.annotation)

根据属性名称进行注入和 AutoWired 一起使用, 可以用于多个实现类的区别

@Resource(javax.annotation)

可以根据类型注入也可以根据名称注入

@Value

注入普通类型属性(主要读取配置文件的信息)

6、完全注解开发

package com.wujing.spring5.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @ClassName: SpringConfig
 * @Description: 配置类
 *
 * 在类上标注 @Configuration 注解标识 配置类
 *
 * @Author liujiexin
 * @Date 2021/9/6 8:46 上午
 */

@Configuration
@ComponentScan(basePackages = "com.wujing.spring5")
public class SpringConfig {

}




package com.wujing.spring5.test;


import com.wujing.spring5.bean.Orders;
import com.wujing.spring5.config.SpringConfig;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @ClassName: SpringConfigTest
 * @Description:
 * @Author liujiexin
 * @Date 2021/9/6 8:49 上午
 */
public class SpringConfigTest {

    @Test
    public void test1(){
        // 第一步加载 配置类
        ApplicationContext classPathXmlApplicationContext =
                new AnnotationConfigApplicationContext(SpringConfig.class);

        // 注意这里要用类名 首字母小写获取对应bean对象 ，除非在类处重写bean名称
        Orders order = classPathXmlApplicationContext.getBean("orders", Orders.class);
        System.out.println(order.getOname());

    }

}

Spring IOC(Inversion of Control)容器