0
0

Spring——IOC底层原理

一、IOC底层原理

1.什么是IOC

    通过**控制反转**（Inversion of Control，缩写为**IOC**），对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

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

    2）使用IOC目的：降低耦合度

    3）入门案例即为IOC的实现（入门案例：【网址】）

2.IOC底层原理

（1）XML解析 + 工厂设计模式 + 反射（令耦合度尽可能的降低到最小）

通过画图来讲解IOC底层原理:

二、IOC接口（BeanFanctory）

  1. IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
  2. Spring提供IOC容器实现的两种方式（两个接口，两个接口均可加载XML文件并且获取配置创建的对象）：

** （1）BeanFactory**：IOC容器基本实现方式，是Spring内部使用的接口，不提供开发人员使用。

** 特点：**加载配置文件时不会创建对象，而是在获取对象或者使用对象时才去创建对象。

** （2）ApplicationContext**：BeanFactory接口的子接口，提供更多更强大的功能，一般面向开发人员使用。

** 特点：**加载配置文件时，直接创建对象。

ApplicationContext中有两个主要的实现类：

  1. FileSystemXmlApplicationContext：括号中时配置文件的全路径。

  2. ClassPathXmlApplicationContext：括号中直接配置文件名。

三、IOC操作Bean管理（基于XML）

Bean管理（两个操作）：

    （1）Spring创建对象

    （2）Spring属性注入

1.创建对象

            ![](https://img-blog.csdnimg.cn/ec2b127cf8424ebfaaa8256ec4159ae4.png)

            a. 在Spring配置文件中，使用bean标签，标签里面添加对应的属性，就可以实现对象创建。

            b. 在bean标签中有很多属性，常见的有：

            * id 属性：设置类的唯一标识（并不是直接指对象名称）；

            * Class属性 ：类全路径（包类路径）；

            c. 创建对象的时候，默认执行无参构造器方法（若使用有参构造器，且未构成无参构造器，此时无参构造器被覆盖，所以常规获取对象方式报错）

2.注入属性

（1）DI：依赖注入

是AOC的一种具体实现，必须在创建对象的基础之上完成。

  • 第一种注入方式：set方法注入

i.

/**
 * 演示使用set方法进行属性注入
 */
public class Book {
    //创建属性
    private String bname;
    private String bauthor;

    //创建属性对应的set方式注入

    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
    
    public void TestBook(){
        System.out.println(bname + " :: "+bauthor);
    }
}

ii.在Spring配置文件中配置对象创建，配置属性注入

<bean id="Book" class="com.xx.Spring.Book">
    <!--使用property完成属性注入
        name:类里面的属性名称
        value：向属性注入的值
    -->
    <property name="bname" value="数据结构"></property>
    <property name="bauthor" value="xxx"></property>
</bean>

iii. 测试代码 

public void TestBook(){
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    Book book = context.getBean("Book", Book.class);
    book.TestBook();
}

输出结果：

  • 第二种注入方式：使用有参构造器注入
package com.xx.Spring.testDome;

/**
 * 演示使用有参构造来进行属性注入
 */
public class Orders {
    private String oname;
    private String address;

    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
    public void Test(){
        System.out.println(oname + ":" + address);
    }
}

<bean id="Oders" class="com.xx.Spring.testDome.Orders">
    <constructor-arg name="oname" value="abc"></constructor-arg>
    <constructor-arg name="address" value="123"></constructor-arg>
</bean>

@Test
public void TestOrder(){
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    Orders oders = context.getBean("Oders", Orders.class);
    oders.Test();
}

（2）p名称空间注入（了解）

    a. 使用p名称空间注入，可以简化基于xml配置方式

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

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

<bean id="Book" class="com.xx.Spring.Book" p:bname="高频电子线路" p:bauthor="周珩">
    
</bean>

测试：

@Test
public void TestBook() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    Book book = context.getBean("Book", Book.class);
    book.TestBook();
}

结果：

（3）注入其他类型属性

1.字面量

（1）null

<bean id="Book" class="com.xx.Spring.Book">
    <!--设置一个空值-->
    <property name="bname" value="数据结构"></property>
    <property name="bauthor">
        <null/>
    </property>
</bean>

（2）特殊符号

<bean id="Book" class="com.xx.Spring.Book">
    <!--属性值包含特殊符号
        1.把<>进行转义 &lt;&gt;
        <property name="bauthor" value="&lt;&gt;<<南京>>"></property>
        2.把带特殊符号的内容写道CDATA
    -->
    <property name="bauthor" >
        <value><![CDATA[<<南京>>]]></value>
    </property>
</bean>

（4）注入外部bean

a.创建Service类和Dao类

b.在Service类中调用Dao类中的方法

c.在Spring配置文件中进行配置

//测试
@Test
public void TestBean1(){
    ApplicationContext context =
            new ClassPathXmlApplicationContext("Bean1.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

/*结果：
Service.add运行.....
Dao.updata运行....
*/

（5）注入内部bean和级联赋值

a.一对多关系：部门和员工（一个部门有多个员工，一个员工属于一个部门）；

b.在实体类之间标识一对多（员工表示所属部门），使用对象类型属性进行表示；

c.在Spring配置文件中进行配置

public void TestBean_(){
    ApplicationContext context =
            new ClassPathXmlApplicationContext("Bean_.xml");
    Emp emp = context.getBean("emp", Emp.class);
    emp.add();
}

/*结果：
id = 1 ename = xx dept = Dept{dname='研发部'}
*/

注：配置文件也可以使用级联赋值的方式

也可以这样写： 但注意此时的结果：

已经将bean标签中的value值覆盖！！！

（6）注入集合类型

集合类型（List、Map、Set）

1.注入数组类型属性

2.注入list集合属性

3.注入Map集合类型的属性

（1）创建类，定义数组、list、map、set集合类型属性，并生成对应的set方法

package com.xx.Spring2.collectionType;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Stu {
    //1.数组类型属性
    private String[] course;
    //2.List集合类型属性
    private List<String> list;
    //3.Map集合类型的属性
    private Map<String, String> mapS;
    //4.Set集合类型属性
    private Set<String> sets;

    public void setCourse(String[] course) {
        this.course = course;
    }

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

    public void setMapS(Map<String, String> mapS) {
        this.mapS = mapS;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void test(){
    System.out.println(Arrays.toString(course));
    System.out.println("===============");
    System.out.println(list);
    System.out.println("===============");
    System.out.println(maps);
    System.out.println("===============");
    System.out.println(sets);
    }
}

（2）在Spring配置文件中进行配置

<?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="stu" class="com.xx.Spring2.collectionType.Stu">
    <!--1.数组类型注入-->
    <property name="course" >
        <array>
            <value>英语</value>
            <value>语文</value>
            <value>数学</value>
            <value>历史</value>
        </array>
    </property>
    
    <!--list集合类型注入-->
    <property name="list" >
        <array>
            <value>张三</value>
            <value>三三</value>
        </array>
    </property>

    <!--map集合类型注入-->
    <property name="maps">
        <map>
            <entry key="1" value="数学"></entry>
            <entry key="2" value="语文"></entry>
        </map>
    </property>

    <!--set集合类型注入-->
    <property name="sets">
        <set>
            <value>mysql</value>
            <value>java</value>
        </set>
    </property>
</bean>

</beans>

//测试
package com.xx.Spring2.TestArray;

import com.xx.Spring2.collectionType.Stu;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    @org.junit.Test
    public void TestBeanArray(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beanArray.xml");

        Stu stu = context.getBean("stu", Stu.class);

        stu.test();
    }
}
/*结果：
[英语, 语文, 数学, 历史]
===============
[张三, 三三]
===============
{1=数学, 2=语文}
===============
[mysql, java]
*/

4.属性注入细节

1.若集合中储存对象类型的值

（比如每个学生可以学多门课程，创建Course类，并且在Stu类中创建list集合来储存多个course对象，再构建其对应的set方法）

package com.xx.Spring2.collectionType;

public class Course {
    private String cname;

    public void setCname(String cname) {
        this.cname = cname;
    }
}

在配置文件中配制时，首先创建多个course对象

<!--创建多个course对象-->
<bean id="course1" class="com.xx.Spring2.collectionType.Course">
    <property name="cname" value="数据结构"></property>
</bean>
<bean id="course2" class="com.xx.Spring2.collectionType.Course">
    <property name="cname" value="Spring5"></property>
</bean>

再使用外部标签注入

<!--list对象类型值注入-->
<property name="courseList">
    <list>
        <ref bean="course1"></ref>
        <ref bean="course2"></ref>
    </list>
</property>

2.不同类中，用到相同的集合类型****（目前的配置文件的说明只注入一个类中，解决方法：将list结合的配置提取，做成公共部分，让所有的类均能引入该集合）

（1）在Spring配置中先引入一个名称空间 （util）

（2）使用Util标签完成list集合注入提取

【关于IOC操作Bean管理（基于beanFactory）笔记可转：】

标签： spring java mybatis
本文转载自: https://blog.csdn.net/qq_50233116/article/details/127601447
版权归原作者 星星下雪 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Spring——IOC底层原理”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

Zabbix 配置端口监控

Python 单元测试详解：Unittest 框架的应用与最佳实践

将文件从Mac传输到 iPhone 的 6 种简单方法

Macbook Pro 的 Type-C 接口突然不工作的解决方案

Unity(2022.3.41LTS) - UI详细介绍- Button(按钮)TMP

探索高效消息处理：scala-kafka开源项目推荐

人工智能两个要素：机器学习算法+大数据

文章导航