Spring框架学习之IOC

用此笔记来记录Spring框架学习中的知识，学习视频链接：

尚硅谷Spring框架视频教程（spring5源码级讲解）_哔哩哔哩_bilibili

目录

IOC底层原理

IOC接口(BeanFactory)

Bean管理

IOC操作Bean管理(基于xml)

1.基于xml方式创建对象

2.基于xml方式注入属性

第一种注入方式：使用set方式注入

第二种注入方式：通过有参构造器注入

xml注入其他类型属性

注入属性-外部bean

注入属性-内部bean

注入属性-级联赋值： 向多个类中设置其属性值

xml注入集合属性

3.FactoryBean

4.bean的作用域

5.bean的生命周期(一共七步操作)

6.xml自动装配(实际用的少，基本用注解来装配)

7.引入外部属性文件，以配置数据库信息为例

IOC操作Bean管理(基于注解)

1.Spring针对Bean管理中创建对象提供注解

基于注解方式实现对象创建

 开启组件扫描细节配置(设置哪些进行扫描，哪些不进行扫描)

2.基于注解方式实现属性注入

3.完全注解开发（实际开发使用SpringBoot）

---

IOC底层原理

1. 什么是IOC

① 控制反转，把对象的创建和对象之间的调用过程，交给Spring进行管理

② 使用IOC目的：为了降低耦合度

③ 做入门案例就是IOC实现

     2. IOC底层原理

xml解析、工厂模式、反射

IOC底层主要就是通过工厂模式来降低类与类之间的耦合度。

IOC接口(BeanFactory)

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

2. Spring提供IOC容器实现的两种方式（两个接口）：

        ①：BeanFactory：IOC容器基本实现，是Spring内部使用的接口，一般开发人员不使用

                * 在加载配置文件时不会去创建对象，在获取对象（使用对象）时才会去创建对象。

        ②：ApplicationContext：BeanFactory接口的子接口。提供更多更强大的功能，一般由开发人员使用

                * 在加载配置文件时就创建对象

     3. Application接口实现类

        ①：FileSystemXmlApplicationContext：输入在盘中的路径

        ②：ClassPathXmlApplicationContext：在src下的路径

Bean管理

1. 什么是Bean管理（Bean管理指的是两个操作）

        ①：Spring创建对象

        ②：Spring注入属性

     2. Bean管理操作有两种方式

        ①：基于xml文件方式实现

        ②：基于注解方式实现

IOC操作Bean管理(基于xml)

1.基于xml方式创建对象

<bean id="user" class="Test.User"></bean>

<1> 在spring配置文件中使用bean标签，标签里面添加对应属性，就可以实现对象的创建

<2> bean标签中有很多属性，常用属性如下：

id属性：唯一标识

class属性：类全路径（包类路径）

<3> 创建对象的时候默认也是执行无参数构造方法完成对象创建

2.基于xml方式注入属性

依赖注入，就是注入属性

第一种注入方式：使用set方式注入

①：创建类，定义属性和对应的set方法

public class Book {
    private String bName;
    private String bAuthor;
    public String getbName() {
        return bName;
    }
    public void setbName(String bName) {
        this.bName = bName;
    }
    public String getbAuthor() {
        return bAuthor;
    }
    public void setbAuthor(String bAuthor) {
        this.bAuthor = bAuthor;
    }
}

②：在spring先配置对象的创建，再配置属性的注入

<!--set方法注入属性-->
<bean id="book" class="Test2.Book">
       <!--使用property完成属性注入
           name：类里面属性名称
           value：向属性注入的值
       -->
        <property name="bName" value="深度理解Java虚拟机"></property>
        <property name="bAuthor" value="张三"></property>
</bean>

补充：优化set方法注入(p名称注入，作为了解即可，不常用)

①：使用p名称空间注入，可以简化基于xml的配置

第一步：先添加一个p名称空间在配置文件中

xmlns:p="http://www.springframework.org/schema/p"

第二步：进行属性注入，在bean标签里面进行操作

<bean id="book" class="Test2.Book" p:bName="深度理解Java虚拟机" p:bAuthor="张三"></bean>

第二种注入方式：通过有参构造器注入

①：创建类，定义属性，创建属性对应的有参构造

public class Orders {
    //属性
    private String oname;
    private String address;
    //有参数构造
    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

②：在spring配置文件中进行配置

<!--有参构造注入属性-->
<bean id="orders" class="Test3.Orders">
<!--通过名称进行注入-->
        <constructor-arg name="oname" value="abc"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
<!--通过下标进行注入，0代表第一个参数，1代表第二个参数-->
<!--    <constructor-arg index="0" value="111"></constructor-arg>-->
<!--    <constructor-arg index="1" value="123"></constructor-arg>-->
</bean>

xml注入其他类型属性

①：null值

<!--设置"address"属性为null值-->
<property name="address">
    <null/>
</property>

②：属性值包含特殊符号

 如果属性值存在例如"<>"符号的特殊符号，代码会报错

解决方法：

1 把<>进行转义(&lt;和&gt;)

<property name="address" value="&lt;&lt;北京&gt;&gt;"></property>

 2 把带特殊符号内容写到CDATA

<property name="address">
            <value>
                    <![CDATA[<<北京>>]]>
            </value>
</property>

注入属性-外部bean

①：创建两个类 service类和 dao类

②：在service层中调用dao里面的方法

public class UserDao {
    public void update(){
        System.out.println("dao update.............");
    }
}

public class UserService {
    //创建UserDao类型属性，生成set方法
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add.............");
        userDao.update();
    }
}

③：在spring配置文件中进行配置

<!--service和dao的对象创建-->
<bean id="userService" class="Test4.service.UserService">
<!--注入userDao对象-
    name值：类里面属性名称
    ref值：创建userDao对象bean标签中的id值
-->
<property name="userDao" ref="userDao"></property>    
</bean>
<bean id="userDao" class="Test4.dao.UserDao"></bean>

注入属性-内部bean

以部门和员工来进行示例

①：一对多关系：部门和员工

一个部门有多个员工，一个员工属于一个部门（部门为一，员工为多）

②：在实体类之间表示一对多关系，员工使用对象类型属性来表示所属部门

//部门类
public class Dept {
    private String dName;

    public void setdName(String dName) {
        this.dName = dName;
    }
}

//员工类
public class Emp {
    private String eName;
    private String gender;
    private Dept dept;

    public void seteName(String eName) {
        this.eName = eName;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

在spring配置文件中配置内部bean：当然也可以使用外部bean来进行配置

<!--内部bean-->
       <bean id="emp" class="Test4.bean.Emp">
              <!--设置普通属性-->
              <property name="eName" value="张三"></property>
              <property name="gender" value="男"></property>
              <!--设置对象类型属性-->
              <property name="dept">
                     <bean id="dept" class="Test4.bean.Dept">
                            <property name="dName" value="保安部"></property>
                     </bean>
              </property>
       </bean>

注入属性-级联赋值： 向多个类中设置其属性值

写法一：配置级联赋值

    <bean id="emp" class="Test4.bean.Emp">
    <!--设置普通属性-->
    <property name="eName" value="张三"></property>
    <property name="gender" value="男"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="Test4.bean.Dept">
        <property name="dName" value="财务部"></property>
    </bean>

写法二：使用这种写法时，要注意想要级联的对象的属性必须有其get方法

    <bean id="emp" class="Test4.bean.Emp">
    <!--设置普通属性-->
    <property name="eName" value="张三"></property>
    <property name="gender" value="男"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
    <property name="dept.dName" value="人才部"></property>
    </bean>
    <bean id="dept" class="Test4.bean.Dept"></bean>

xml注入集合属性

1. 注入数组类型属性

2. 注入List集合类型

3. 注入Map集合类型属性

实现步骤

①：创建类，定义数组、list、map、set类型的属性，生成对应的set方法

public class Stu {
    //数组类型属性
    private String[] courses;
    //List集合类型属性
    private List<String> list;
    //Map集合类型属性
    private Map<String,String> map;
    //Set集合类型属性
    private Set<String> set;
    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }
}

②：在spring配置文件进行配置

<!--集合类型的注入-->
       <bean id="stu" class="Test5.collectionType.Stu">
       <!--数组类型的属性注入-->
           <property name="courses">
               <array>
                   <value>Java课程</value>
                   <value>数据库课程</value>
               </array>
           </property>
       <!--List集合类型属性注入-->
           <property name="list">
               <list>
                   <value>语文</value>
                   <value>数学</value>
               </list>
           </property>
       <!--Map类型属性注入-->
           <property name="map">
               <map>
                   <entry key="Java" value="java"></entry>
                   <entry key="PHP" value="php"></entry>
               </map>
           </property>
       <!--Set集合注入-->
           <property name="set">
               <set>
                   <value>MySql</value>
                   <value>Redis</value>
               </set>
           </property>
       </bean>

如果想要在集合中添加对象类型的值，而不是基本数据类型，则可根据以下方法添加

<!--创建多个course对象-->
    <bean id="course1" class="Test5.collectionType.Course">
        <property name="cName" value="Spring5框架"></property>
    </bean>
    <bean id="course2" class="Test5.collectionType.Course">
        <property name="cName" value="MyBatis框架"></property>
    </bean>

<!--注入list集合类型，值的对象-->
           <property name="cList">
               <list>
                   <ref bean="course1"></ref>
                   <ref bean="course2"></ref>
               </list>
           </property>

当然我们也可以将集合注入部分提取出来

①：在Spring配置文件头部中引入名称空间 util，主要添加 xmlns:util 和 xsi:schemaLocation 中的http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

②：使用util标签完成list集合注入提取

<!--提取list集合类型属性注入-->
       <util:list id="bookList">
           <value>Java基础</value>
           <value>数据库原理</value>
       </util:list> 
       <!--使用提取的list集合-->
       <bean id="book" class="Test5.collectionType.Book">
           <property name="list" ref="bookList"></property>
       </bean>

3.FactoryBean

1. Spring有两种类型bean，一种普通bean，另外一种工厂bean (FactoryBean)

2. 普通bean：在spring配置文件中，定义的类型就是返回的类型

3. 工厂bean：在配置文件中定义的bean类型可以和返回类型不相同

实现步骤

第一步 创建类，让这个类作为工厂bean，实现接口FactoryBean

第二步 实现接口里面的方法，在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean<Course> {
    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setcName("abc");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

<bean id="myBean" class="Test5.facbean.MyBean"></bean>

 @Test
    public void test3(){
        ApplicationContext context = new FileSystemXmlApplicationContext("G:\\SpringStudy\\RMTest1\\bean6.xml");
        Course myBean = context.getBean("myBean", Course.class);
        System.out.println(myBean);
    }

这样我们就实现了在配置文件中没有配置Course类对象，但可以通过其得到Course对象，常用于复杂的bean创建

4.bean的作用域

1. 在Spring中可以设置创建bean实例是单实例还是多实例

2. 在Spring中，默认情况下bean是一个单实例对象

使用之前的book对象来进行测试

@Test
    public void test2(){
        ApplicationContext context = new FileSystemXmlApplicationContext("G:\\SpringStudy\\RMTest1\\bean5.xml");
        Book book = context.getBean("book", Book.class);
        Book book1 = context.getBean("book",Book.class);
        System.out.println(book);
        System.out.println(book1);
    }

从结果可以看出book和book1对象为同一个，因此默认为单实例对象

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

①：在spring配置文件bean标签中的scope属性用于设置单实例还是多实例

②：scope属性值：常用的是singleton和prototype，还有request，session值不常用

第一个值(默认值)：singleton 表示单实例对象

第二个值：prototype 表示多实例对象

<bean id="book" class="Test5.collectionType.Book" scope="prototype">
           <property name="list" ref="bookList"></property>
</bean>

修改后，book和book1对象地址值不同，表示当前为多实例对象

③：singleton和prototype的区别：

<1> singleton表示单实例，prototype表示多实例

<2> 设置为singleton时，加载spring配置文件时就会创建单实例对象

设置为prototype时，则是在调用getbean方法时创建多实例对象

5.bean的生命周期(一共七步操作)

1. 生命周期：从对象创建到对象销毁的过程

2. bean的生命周期(基于无参构造)

①：通过构造器创建bean实例（无参数构造）

②：为bean的属性设置值和对其他bean引用（调用set方法）

③：调用bean初始化的方法（需要进行配置初始化的方法）

④：bean可以使用（对象获取到了）

⑤：当容器关闭时，调用bean销毁的方法（需要进行配置销毁的方法）

3. 演示bean的生命周期

public class Orders {
    private String oname;
    //无参构造
    public Orders() {
        System.out.println("第一步，执行无参构造创建bean实例");
    }

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步，调用set方法设置属性的值");
    }
    //创建执行初始化的方法
    public void initMethod(){
        System.out.println("第三步，执行初始化的方法");
    }
    //创建销毁时执行的方法
    public void destroyMethod(){
        System.out.println("第五步，执行销毁的方法");
    }
}

 创建和销毁的方法需要在配置文件中进行配置

<bean id="orders" class="Test5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
                <property name="oname" value="手机"></property>
</bean>

@Test
    public void test4(){
//        ApplicationContext context = new FileSystemXmlApplicationContext("G:\\SpringStudy\\RMTest1\\bean6.xml");
        FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("G:\\SpringStudy\\RMTest1\\bean6.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步，获取创建bean实例的对象");
        System.out.println(orders);
        //手动让bean实例销毁
        context.close();
    }

 由于ApplicationContext接口中没有close方法，因此要用其子接口来进行销毁  

4. bean的后置处理器，加上后置处理器生命周期一共有7步

①：通过构造器创建bean实例（无参数构造）

②：为bean的属性设置值和对其他bean引用（调用set方法）

把bean的实例传递给bean后置处理器的postProcessBeforeInitialization方法

③：调用bean初始化的方法（需要进行配置初始化的方法）

把bean的实例传递给bean后置处理器的postProcessAfterInitialization方法

④：bean可以使用（对象获取到了）

⑤：当容器关闭时，调用bean销毁的方法（需要进行配置销毁的方法）

5. 演示添加后置处理器效果

①：创建类，实现接口BeanPostProcessor，创建后置处理器

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}

 ②：在配置文件中配置后置处理器（直接在配置文件中创建一个对象即可），当配置好后置处理器后，spring会将当前配置文件中的所有bean配置该后置处理器的处理

<!--配置后置处理器-->
<bean id="myBeanPost" class="Test5.bean.MyBeanPost"></bean>

 

6.xml自动装配(实际用的少，基本用注解来装配)

手动设置什么属性为什么值叫做手动装配

1. 什么是自动装配：根据指定的装配规则（属性名称或属性规则），Spring自动将匹配的属性值进行注入

2. 演示自动装配的过程：

通过bean标签中的属性autowire，配置自动装配

autowire常用属性值：

①：byName：根据属性名称进行注入，需要让注入bean的id值和类属性名称一样

<!--实现自动装配-->
        <bean id="emp" class="Test5.autowire.Emp" autowire="byName"></bean>
        <bean id="dept" class="Test5.autowire.Dept"></bean>

②：byType：根据属性类型就行注入，需要注意配置文件中只能存在一个该属性类型的对象，不然会报错

<!--实现自动装配-->
        <bean id="emp" class="Test5.autowire.Emp" autowire="byType"></bean>
        <bean id="dept" class="Test5.autowire.Dept"></bean>

7.引入外部属性文件，以配置数据库信息为例

1. 直接配置数据库信息

①：配置德鲁伊连接池

②：引入德鲁伊连接池依赖jar包

<!--直接配置连接池-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <!--数据库的驱动-->
            <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
            <!--数据库的地址-->
            <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
            <!--连接数据库的用户名-->
            <property name="username" value="root"></property>
            <!--连接数据库的密码-->
            <property name="password" value="root"></property>
        </bean>

 2. 引入外部属性文件配置数据库连接池

①：创建外部属性文件，properties格式文件(jdbc.properties)，写上数据库信息

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/user
prop.userName=root
prop.password=root

②：把外部properties属性文件引入到spring配置文件中  

<1> 引入context名称空间

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="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">

<2> 在spring配置文件中使用标签引入外部属性文件

<!--引入外部属性文件-->
        <context:property-placeholder location="jdbc.properties"></context:property-placeholder>
        <!--配置连接池-->
            <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
                <!--数据库的驱动-->
                <property name="driverClassName" value="${prop.driverClass}"></property>
                <!--数据库的地址-->
                <property name="url" value="${prop.url}"></property>
                <!--连接数据库的用户名-->
                <property name="username" value="${prop.userName}"></property>
                <!--连接数据库的密码-->
                <property name="password" value="${prop.password}"></property>
            </bean>

IOC操作Bean管理(基于注解)

什么是注解：

①：注解是代码的特殊标记，格式：@注解名称(属性名称=属性值,属性名称=属性值...)

②：使用注解，注解可以作用在类上面，方法上面，属性上面

③：使用注解的目的：简化xml配置

1.Spring针对Bean管理中创建对象提供注解

1. @Component

2. @Service

3. @Controller

4. @Repository

以上四个注解的功能是一样的，都可以用来创建对象，主要是为了后续进行功能扩展

基于注解方式实现对象创建

第一步 引入依赖

第二步 开启组件扫描，让spring知道在哪里去找注解

首先要引入context名称空间

如果要扫描多个包，多个包可以使用逗号隔开；

<!--开启组件扫描-->
    <contxt:component-scan base-package="Test6.dao,Test6.service"></contxt:component-scan>

 如果多个包在同一层目录下，则可以写其上层目录

<contxt:component-scan base-package="Test6"></contxt:component-scan>

第三步 创建类，在类上添加创建对象注解  

//注解里面的value属性值可以省略不写
//默认值为类名称首字母小写 userService
@Component(value = "userService") //类似于<bean id="userService" class=".."></bean>
public class UserService {
    public void add(){
        System.out.println("service add........");
    }
}

第四步 获取对象，和xml方式一样

@Test
    public void testService(){
        ApplicationContext context = new FileSystemXmlApplicationContext("G:\\SpringStudy\\RMTest1\\bean9.xml");
        UserService userServicec = context.getBean("userService", UserService.class);
        System.out.println(userServicec);
        userServicec.add();
    }

 开启组件扫描细节配置(设置哪些进行扫描，哪些不进行扫描)

<!--示例一
            use-default-filters="false" 表示不使用默认的filter，自己配置filter
            contxt:include-filter 设置扫描哪些内容
            type="annotation" 表示根据注解
            expression="org.springframework.stereotype.Controller" 表示扫描配置注解为Controller的类
        -->
    <contxt:component-scan base-package="Test6.dao" use-default-filters="false">
        <contxt:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </contxt:component-scan>
        <!--示例二
            contxt:exclude-filter：设置哪些内容不进行扫描
            下面配置表示Test6.dao中不扫描Controller注解
        -->
    <contxt:component-scan base-package="Test6.dao">
        <contxt:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </contxt:component-scan>

2.基于注解方式实现属性注入

1. @AutoWired：根据属性类型进行自动装配

示例

第一步 把service和dao对象创建，在service和dao类添加创建对象注解

第二步 在service注入dao对象，在service类中添加dao类型属性，在属性上面使用注解，该属性不需要添加set方法

@Component(value = "userService") //类似于<bean id="userService" class=".."></bean>
public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性的注解
    @Autowired
    private UserDao userDao;
    public void add(){
        System.out.println("service add........");
        userDao.add();
    }
}

2. @Qualifier：根据属性名称进行注入

该注解的使用要和上面@AutoWired一起使用，为了避免一个接口有多个实现类，通过该注解设置名称来注入

@Autowired
    @Qualifier(value = "userDaoImp1")
    private UserDao userDao;
    public void add(){
        System.out.println("service add........");
        userDao.add();
    }

3. @Resource：可以根据类型注入，可以根据名称注入，但该注解为javax提供的注解，不是spring提供

@Resource //根据类型进行注入
    private UserDao userDao;
    public void add(){
        System.out.println("service add........");
        userDao.add();
    }

@Resource(name = "userDaoImp1") //根据名称进行注入
    private UserDao userDao;
    public void add(){
        System.out.println("service add........");
        userDao.add();
    }

4. @Value：注入普通类型属性  

@Value(value = "abc")
private String name;

3.完全注解开发（实际开发使用SpringBoot）

1. 创建配置类，替代xml配置文件

@Configuration //作为配置类，替代xml文件
@ComponentScan(basePackages = {"Test6"})
public class SpringConfig {
}

 2. 编写测试类

@Test
    public void test1(){
        //加载配置类
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }
}

 IOC学习至此结束。