2_IOC 容器

最新推荐文章于 2024-03-28 08:32:52 发布
最新推荐文章于 2024-03-28 08:32:52 发布
阅读量118 收藏 1
点赞数
分类专栏： # Spring 文章标签： spring
By_Code27
本文链接：https://blog.csdn.net/XJ0927/article/details/109863902
版权

是什么

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

使用 IOC 目的

为了耦合度降低

为什么出现 IOC

原始方法：直接 new 对象的方式，代码耦合度太高

在这里插入图片描述

改进：使用工厂创建对象，但调用者和工厂的代码耦合度又太高

在这里插入图片描述

IOC 底层原理

IOC 的出现就是解决代码耦合太高的问题

前置知识：xml 解析、工厂模式、反射

使用 xml 解析文件，使用工厂模式创建对象，具体是使用反射获取 Class 类，然后创建对象，这样一旦代码进行变动，只需要改动 xml 文件即可

在这里插入图片描述

IOC（BeanFactory 接口）

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

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

BeanFactory

IOC 容器基本实现，是 Spring 内部的使用接口，[ 不提供开发人员进行使用 ]

特点：加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象 [ 懒加载的方式 ]

ApplicationContext

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

特点：加载配置文件时候就会把在配置文件对象进行创建 [ 特别是项目刚启动时 ]

ApplicationContext 接口有实现类

在这里插入图片描述

两者实现类的区别

FileSystemXmlApplicationContext 获取配置文件时，需要提供盘符的全路径

ClassPathXmlApplicationContext 获取配置文件时，只需提供 src 下的路径即可

IOC 操作 Bean 管理（基于 xml 方式）

基于 xml 方式创建对象

在这里插入图片描述

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

在 bean 标签有很多属性，介绍常用的属性

id 属性：唯一标识
class 属性：类全路径（包类路径）

创建对象时候，默认是执行 [ 无参数构造方法 ] 完成对象创建

基于 xml 方式注入属性

DI： 依赖注入，就是注入属性

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

（1）创建类，定义属性和对应的 set 方法

/**
 * 演示使用set方法进行注入属性
 */
public class Book {
    //创建属性
    private String bname;
    private String bauthor;
    private String address;
    //创建属性对应的set方法
    public void setBname(String bname) {
        this.bname = bname;
    }
    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public void testDemo() {
        System.out.println(bname+"::"+bauthor+"::"+address);
    }
}

（2）在 spring 配置文件配置对象创建，配置属性注入

<!--2 set 方法注入属性--> <bean id="book" class="com.atguigu.spring5.Book">
     <!--使用 property 完成属性注入
        name：类里面属性名称
        value：向属性注入的值
     -->
     <property name="bname" value="易筋经"></property>
     <property name="bauthor" value="达摩老祖"></property>
</bean>

（3）测试

@Test
    public void testBook1() {
        //1 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        //2 获取配置创建的对象
        Book book = context.getBean("book", Book.class);

        System.out.println(book);
        book.testDemo();
    }

结果

在这里插入图片描述

第二种注入方式：使用有参数构造进行注入

如果不指定有参构造方式和 set 方式注入，默认使用无参方式注入

（1）创建类，定义属性，创建属性对应有参数构造方法

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

    public void ordersTest() {
        System.out.println(oname+"::"+address);
    }
}

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

<!-- 有参数构造注入属性--> 
<bean id="orders" class="com.atguigu.spring5.Orders">
     <constructor-arg name="oname" value="电脑"></constructor-arg>
     <constructor-arg name="address" value="China"></constructor-arg>
</bean>

（3）测试

	@Test
    public void testOrders() {
        //1 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        //2 获取配置创建的对象
        Orders orders = context.getBean("orders", Orders.class);

        System.out.println(orders);
        orders.ordersTest();
    }

结果

在这里插入图片描述

p 名称空间注入（了解）

使用 p 名称空间注入，可以简化基于 xml 配置方式，实质简化的是通过 set 方式 注入属性的

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

在这里插入图片描述

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

<!-- set 方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功" p:bauthor="无名氏"></bean>

xml 注入其他类型属性

字面量

（1）null 值 ：加入标签
<property name="address">
 	<null/>
</property>

属性值就为 null

（2）属性值包含特殊符号

先要将 属性注入为：<<南京>>

第一种方式：把<>进行转义 &lt ; &gt ;

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

第二种方式：把带特殊符号内容写到 CDATA

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

注入属性-外部 bean

所谓外部 bean 就是在外面使用 bean 标签创建对象后通过 ref 注入属性中

（1）创建两个类 service 类和 dao 类

/************* dao ****************/
public interface UserDao {
    public void update();
}

/************* imp ****************/
public class UserDaoImpl implements UserDao {

    @Override
    public void update() {
        System.out.println("dao update...........");
    }
}

（2）在 service 调用 dao 里面的方法

public class UserService {

    //创建UserDao类型属性，生成set方法 [ 在 bean 中使用 set 注入]
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

（3）在 spring 配置文件中进行配置

<!--1 service和dao对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
    <!--注入userDao对象
            name属性：类里面属性名称
            ref属性：创建userDao对象bean标签id值
        -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>

（4）测试

@Test
public void testBean1() {
    //1 加载spring配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");

    //2 获取配置创建的对象
    UserService userService = context.getBean("userService", UserService.class);

    userService.add();
}

结果

在这里插入图片描述

注入属性-内部 bean

所谓内部 bean 就是在 bean 标签内部 在使用一层 bean 标签创建对象

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

​ 部门是一，员工是多

（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

//部门类
public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

//员工类
public class Emp {
    private String ename;
    private String gender;
    //员工属于某一个部门，使用对象形式表示
    private Dept dept;

    //生成dept的get方法
    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }

    public void add() {
        System.out.println(ename+"::"+gender+"::"+dept);
    }
}

（3）在 spring 配置文件中进行配置

<!--内部bean-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--设置对象类型属性-->
    <property name="dept">
        <bean id="dept" class="com.atguigu.spring5.bean.Dept">
            <property name="dname" value="安保部"></property>
        </bean>
    </property>
</bean>

注入属性-级联赋值

（1）第一种写法

通过外部 bean 注入对象，然后通过 ref 引入该对象

<!--级联赋值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
 	<!--设置两个普通属性-->
 	<property name="ename" value="lucy"></property>
 	<property name="gender" value="女"></property>
	 <!--级联赋值-->
 	<property name="dept" ref="dept"></property>
</bean>

<bean id="dept" class="com.atguigu.spring5.bean.Dept">
 	<property name="dname" value="财务部"></property>
</bean>
（2）第二种写法

通过 外部 Bean 创建对象后，引入时，使用 get 方法获取属性之后，再通过 set 注入属性

注意：需要在 bean 创建对象所属的类中加入该属性的 get 方法

<!--级联赋值-->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!--级联赋值-->
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="技术部"></property>
    </bean>
    <bean id="dept" class="com.atguigu.spring5.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>

xml 注入集合属性

  • 1、注入数组类型属性
  • 2、注入 List 集合类型属性
  • 3、注入 Map 集合类型属性
  • 4、注入 Set 集合类型属性

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

public class Stu {
    //1 数组类型属性
    private String[] courses;
    //2 list集合类型属性
    private List<String> list;
    //3 map集合类型属性
    private Map<String,String> maps;
    //4 set集合类型属性
    private Set<String> sets;

    //学生所学多门课程
    private List<Course> courseList;
    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void test() {
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
        System.out.println(courseList);
    }
}

（2）在 spring 配置文件进行配置

<!--1 集合类型属性注入-->
<bean id="stu" class="com.atguigu.spring5.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="maps">
        <map>
            <entry key="JAVA" value="java"></entry>
            <entry key="PHP" value="php"></entry>
        </map>
    </property>
    <!--set类型属性注入-->
    <property name="sets">
        <set>
            <value>MySQL</value>
            <value>Redis</value>
        </set>
    </property>
</bean>

上面集合元素 都是储存的基本数据类型

在集合里面设置对象类型值

增加对象

//课程类
public class Course {
    private String cname; //课程名称
    public void setCname(String cname) {
        this.cname = cname;
    }

    @Override
    public String toString() {
        return "Course{" +
                "cname='" + cname + '\'' +
                '}';
    }
}

在 spring 配置文件进行配置

<!--创建多个course对象-->
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
    <property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
    <property name="cname" value="MyBatis框架"></property>
</bean>

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

把集合注入部分提取出来

（1）在 spring 配置文件中引入名称空间 util

在这里插入图片描述

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

<!--1 提取list集合类型属性注入-->
<util:list id="bookList">
    <value>易筋经</value>
    <value>九阴真经</value>
    <value>九阳神功</value>
</util:list>

<!--2 提取list集合类型属性注入使用-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
    <property name="list" ref="bookList"></property>
</bean>
果将如此
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring：核心技术——IoC容器
梦幻天空
04-25 846
说明：本文翻译自Spring官方文档Core Technologies — 核心技术 (spring.io)。This part of the reference documentation covers all the technologies that are absolutely integral to the Spring Framework. 参考文档的这一部分涵盖了Spring框架中不可或缺的所有技术。Foremost amongst these is the Spring Framework’
山寨spring_ ioc容器
07-27
标题中的“山寨spring_ioc容器”指的是一个非官方的、模仿Spring框架实现的IoC（Inversion of Control，控制反转）容器。这个容器可能是由个人开发者或者小团队创建的，目的是为了学习Spring的核心机制，或者在某些...
IOC容器
秃头小达人
05-22 208
IOC容器 1、IOC底层原理 什么是IOC 控制反转，把对象创建和对象之间的调用过程交给Spring进行管理 使用IOC目的：为了耦合度降低 IOC底层原理 xml解析、工厂模式、反射 画图讲解IOC底层原理 2、IOC接口（BeanFactory） IOC思想基于IOC容器完成，IOC容器底层就是对象工厂 Spring提供IOC容器实现两种方式： BeanFactory：IOC容器基本实现，是Spring内部使用的接口，不提供给开发人员使用 加载配置文件时不会创建对象，在获取
第2部分：IoC容器
Jack Zhou的专栏
04-13 2654
2.2.1  IoC容器的概念 IoC容器就是具有依赖注入功能的容器，IoC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。应用程序无需直接在代码中new相关的对象，应用程序由IoC容器进行组装。在Spring中BeanFactory是IoC容器的实际代表者。 Spring IoC容器如何知道哪些是它管理的对象呢？这就需要配置文件，Spring IoC容器通过读取配置文件中的
Spring_IOC_.rar_spring ioc
09-23
7. **Spring的其他模块**：如数据访问/集成（JDBC、ORM）、Web MVC、Test支持等，这些模块如何与IOC容器协同工作。 总之，Spring_IOC_.pdf文档应该是对Spring框架中IOC特性的深入讲解，对于理解和掌握Spring框架的...
ioc.zip_ioc_ioc基于_反射
09-24
**依赖注入（DI）**：DI是IOC的一种具体实现方式，它通过外部容器（如Spring框架）来管理和注入对象的依赖关系，而不是让对象自己去查找或创建依赖。这使得代码更加灵活，因为对象不再需要知道依赖的具体实现。 **...
03spring4_ioc2.rar
02-29
这通常在数据库操作或数据访问层的上下文中看到，暗示了我们将讨论如何使用Spring的IOC容器来管理此类DAO（Data Access Object）对象。 Spring框架的核心特性之一是IOC，它允许开发者将对象的创建和管理职责从应用...
IoC.rar_beancreateexception_ioc
09-21
2. **Bean的实例化**: IOC容器读取配置，根据信息创建Bean的实例。这个过程可能包括单例或多例的管理、依赖注入等。 3. **依赖注入**: IOC容器负责将Bean的依赖关系注入到Bean实例中。它可以是值、其他Bean、接口...
IoC容器
Claire7734的博客
10-23 355
BeanFactory和ApplicationContextBeanFactory：IoC容器。Spring框架最核心的接口，提供了高级IoC的配置机制。是Spring框架的基础设施，面向Spring本身 ApplicationContext：应用上下文，Spring容器。面向使用Spring框架的开发者，更易于创建实际应用。BeanFactoryBeanFactory是一个类的通用工厂，可以创建
Spring之IOC容器
最新发布
tq02的博客
03-28 1096
本文讲解的SpringIoc的知识点，对比传统代码，SpringIoc的优点，通过控制反转，如何获取Bean的两种方法，以及配置的xml文件
了解IOC容器
lafengbitipao的博客
01-15 2379
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 在学习Spring框架中，有时需要定义各种集合属性，传统给集合注入属性值需要一个比较繁琐，如果能够把集合本文讲解如何创建并使用<util:list></util:list>标签 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumP
什么是IOC容器
renxingzhadan的专栏
08-24 4405
https://blog.csdn.net/navyforce/article/details/108927826
IOC容器(详细讲解)
酷小亚
08-29 9110
IOC容器(详细讲解) 一、IOC底层原理 二、IOC接口 三、Bean管理
Spring二次学习——3.ioc容器的概念
微微安的博客
11-25 377
2.2.1 IoC容器的概念 IoC容器就是具有依赖注入功能的容器，IoC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。应用程序无需直接在代码中new相关的对象，应用程序由IoC容器进行组装。在Spring中BeanFactory是IoC容器的实际代表者。 Spring IoC容器如何知道哪些是它管理的对象呢？这就需要配置文件，Spring IoC容器通过读取配置文件中的...
IOC容器概述
yuanyajieh的博客
04-23 306
框架概述IOC容器（1）IOC底层原理IOC过程Bean管理Bean管理操作有两种方式（2）IOC接口（BeanFactory）（3）IOC操作Bean管理（基于xml）IOC操作bean管理（xml注入其他类型属性）IOC操作Bean管理（xml注入集合属性）IOC操作Bean管理（FactoryBean）IOC操作Bean管理（Bean作用域）IOC操作bean管理（Bean生命周期）IOC操作Bean管理（自动装配）IOC操作Bean管理（外部属性文件）（4）IOC操作Bean管理（基于注解操作）
ioc 容器
06-02
IoC （Inversion of Control，控制反转）是一种设计模式，它将程序中的控制权从代码中转移到了容器中，使得程序的可扩展性和可维护性更强。IoC 容器就是实现 IoC 模式的一个工具，它可以自动创建、装配和管理对象，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值