Spring IOC详解

最新推荐文章于 2024-08-20 17:09:23 发布
最新推荐文章于 2024-08-20 17:09:23 发布
阅读量503 收藏 6
点赞数 4
分类专栏： JavaEE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yunhaoyoung/article/details/113775320
版权

一、IOC

1. 什么是IOC

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

2. IOC的目的

  • 为了耦合度降低

3. IOC的底层原理

  • xml解析
  • 工厂模式
  • 反射

4. IOC过程

  • 创建xml配置文件，配置创建的对象
  <bean id="user" class="com.github.entity.User" >   </bean>
  • 创建工厂类
class UserFactory{
      public static User getUser(){
           String class = class的属性值  // xml解析获得类的名称
           Class clazz = Class.forName(class); //通过反射创建对象
           return (User)clazz.newInstance();
      }
 }

5. BeanFactory接口

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

在这里插入图片描述

二、IOC操作Bean管理

1. 什么是Bean管理

  • Spring创建对象
  • Spring注入属性

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

  • 基于xml配置方式实现
  • 基于注解方式实现

3. 基于XML方式

3.1 创建对象

  • 首先创建一个User类
public class User {
    private String name;
    private Integer age;
    private String gender;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

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

    public User(String name, Integer age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public User(){

    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }

    public void add(){
        System.out.println("hello");
    }
}
  • 配置xml文件
<bean id="user" class="com.github.entity.User"></bean>
  • 在Spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
  • 在bean标签里有很多属性，下面是常用的属性
  1. id属性：唯一标识
  2. class属性：类全路径
  3. name属性：也是标识，里面可以存在特殊字符
  4. scope属性：确定是否为单例对象

3.2 注入属性

  • DI：依赖注入，就是注入属性
3.2.1 set 方式注入
  • 配置xml文件
<!-- set注入属性 -->
<bean id="user" class="com.github.entity.User">
    <!-- 使用property完成属性注入
           name： 类里面属性名称
           value：向属性注入的值
    -->
    <property name="name" value="zhangsan"></property>
    <property name="age" value="15"></property>
    <property name="gender" value="男"></property>
</bean>
3.2.2 使用有参构造进行注入
  • 配置xml文件
<bean id="user1" class="com.github.entity.User">
    <constructor-arg name="name" value="wu"></constructor-arg>
    <constructor-arg name="age" value="16"></constructor-arg>
    <constructor-arg name="gender" value="女"></constructor-arg>
</bean>
3.2.3 p名称空间注入
  • 使用p名称空间注入，可以简化基于xml的配置方式
  • 添加p名称空间在配置文件中
<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  • 配置xml文件
<bean id="user2" class="com.github.entity.User" p:name="李四" p:age="21" p:gender="男"> </bean>
3.2.4 注入字面量
  • 扩展User类
 private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
  • NuLL值
 <bean id="user3" class="com.github.entity.User">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="15"></property>
        <property name="gender" value="男"></property>
        <property name="address">
            <null></null>
        </property>
    </bean>
  • 属性中包含特殊符号
 <bean id="user4" class="com.github.entity.User">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="15"></property>
        <property name="gender" value="男"></property>
        <property name="address">
            <value><![CDATA[<<西安>>]]></value>
        </property>
    </bean>
  • 测试类结果
    在这里插入图片描述
3.2.5 注入属性-外部bean
  • 创建两个类
public class Dept {
    private String dname;

    public Dept() {
    }

    public void setDname(String dname) {
        this.dname = dname;
    }
}

public class Emp {
    private String name;
    private Integer age;

    private Dept dept;

    public Emp() {
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", dept=" + dept +
                '}';
    }

}

xml配置文件

<bean id="emp" class="com.github.entity.Emp">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="20"></property>
        //级联的一种
        <property name="dept" ref="dept"></property>
    </bean>

    <bean id="dept" class="com.github.entity.Dept">
        <property name="dname" value="研发"></property>
    </bean>
3.2.6 注入属性-内部bean
  • xml配置
<bean id="emp" class="com.github.entity.Emp">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="20"></property>
        <property name="dept">
            <bean id="dept" class="com.github.entity.Dept">
                <property name="dname" value="研发"></property>
            </bean>
        </property>
    </bean>
3.2.7 注入属性-级联赋值
  • 级联赋值需要getter方法
public Dept getDept() {
        return dept;
    }
  • xml配置文件
<bean id="emp" class="com.github.entity.Emp">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="20"></property>
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="技术部"></property>
    </bean>

    <bean id="dept" class="com.github.entity.Dept">
    </bean>
3.2.8 注入集合属性
  • 注入数组类型属性
  • 注入List集合类型属性
  • 注入Set集合类型属性
  • 注入Map集合类型属性
package com.github.entity;

import java.awt.*;
import java.util.*;
import java.util.List;

public class CollcetionSum {

    private String[] string;

    private List<String> list;

    private Set<String> set;

    private Map<String,String> map;

    public void setString(String[] string) {
        this.string = string;
    }

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

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

    public void setMap(Map map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "CollcetionSum{" +
                "string=" + Arrays.toString(string) +
                ", list=" + list +
                ", set=" + set +
                ", map=" + map +
                '}';
    }
}


 <bean id="collectSum" class="com.github.entity.CollcetionSum">
        <property name="string">
            <array>
                <value>语文</value>
                <value>数学</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>张安</value>
                <value>李四</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="key1" value="value1"></entry>
                <entry key="key2" value="value2"></entry>
            </map>
        </property>
        <property name="set">
            <set>
                <value>123</value>
                <value>456</value>
            </set>
        </property>
    </bean>
</beans>

@Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans4.xml");
        CollcetionSum collcetionSum = context.getBean("collectSum",CollcetionSum.class);
        System.out.println(collcetionSum);
    }

在这里插入图片描述

  • 集合里面设置对象类型值
<bean id="dept" class="com.github.entity.Dept">
        <property name="dname" value="研发"></property>
    </bean>

    <bean id="listClass" class="com.github.entity.ListClass">
        <property name="list">
            <list>
                <ref bean="dept"></ref>
            </list>
        </property>
    </bean>
  • 把集合注入部分提取出来
  1. 添加名称util空间
<?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: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">
  1. 配置xml文件
<bean id="dept" class="com.github.entity.Dept">
        <property name="dname" value="研发"></property>
    </bean>

    <util:list id="deptlist">
        <ref bean="dept"></ref>
    </util:list>

    <bean id="listClass" class="com.github.entity.ListClass">
        <property name="list" ref="deptlist"></property>
    </bean>

3.3 FactoryBean

  • Spring有俩种类型bean，一种为普通bean，另一种为工厂bean（FactoryBean）
  • 普通bean：在配置文件中定义bean类型就是返回类型
  • 工厂bean：在配置文件中定义bean类型可以和返回类型不一样
3.3.1 如何实现
  • 创建类，让这个类作为工厂bean，实现接口FactoryBean
  • 实现接口里面的方法，在实现的方法中定义返回的bean类型
  • 创建类
public class MyBean implements FactoryBean<Dept> {
    @Override
    public Dept getObject() throws Exception {
        Dept dept = new Dept();
        dept.setDname("145");
        return dept;
    }

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

    @Override
    public boolean isSingleton() {
        return false;
    }
}
  • 配置xml
<bean id="mybean" class="com.github.entity.MyBean"> </bean>
  • 编写测试类
public void test2(){

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Dept dept = context.getBean("mybean",Dept.class);
        System.out.println(dept);
    }

4.xml自动装配

4.1 什么是自动装配

  • 根据指定装配规则，Spring自动将匹配的属性值进行注入

4.2 自动装配过程

  • bean标签的autowire属性，配置自动装配

1.byName:根据属性名称注入
2. byType:根据属性类型注入

  • xml配置文件
<bean id="emp" class="com.github.entity.Emp" autowire="byType">
    </bean>

    <bean id="dept" class="com.github.entity.Dept">
    </bean>

<bean id="emp" class="com.github.entity.Emp" autowire="byName">
    </bean>

    <bean id="dept" class="com.github.entity.Dept">
    </bean>

5.引入外部资源文件

  • 引入context名称空间
  • 配置文件
<context:property-placeholder location="classpath:djbc.properties"></context:property-placeholder>
诗ヾ语
关注
专栏目录
IoC详解
Forrest He的专栏
09-18 3606
1.定义：IoC是一种模式。IoC(Inversion of Control)中文译为控制反转(即“不用你找,我来提供给你”)。控制反转意味着在系统开发过程中，设计的类将交由容器(spring中是通过applicationContext.xml控制的)去控制，而不是在类的内部去控制，类与类之间的关系将交由容器处理，一个类在需要调用另一个类时，只要调用另一个类在容器中注册的名字就可以得到这个类的实例
IOC详解
Lavender-csdn的博客
02-24 200
IOC的概念和作用 1、采用new创建对象： 2、使用工厂模式创建对象 IOC：控制反转，把创建对象的权利交给框架，是框架的重要特征，并非面向对象编程的专用术语，它包括依赖注入和依赖查找 明确IOC的作用：削减计算机程序的耦合(解除我们代码中的依赖关系)，使用spring的IOC解决程序耦合。 Spring基于XML的IOC环境搭建 bean.xml文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmln..
IOC详解IOC详解IOC详解IOC详解
02-27
IOC详解IOC详解IOC详解IOC详解IOC详解IOC详解IOC详解IOC详解
Spring4 IOC详解
ITDragon博客
11-23 5790
Spring4 IOC详解 上一章对Spring做一个快速入门的教程，其中只是简单的提到了IOC的特性。本章便对Spring的IOC进行一个详解。主要从三个方面开始：基于xml文件的Bean配置，基于注解的Bean配置和IOC容器Bean的生命周期。 基于xml文件的Bean配置 首先是applicationContext.xml文件，这可是核心文件。 配置一个bean
AOP和IOC详解
最新发布
精神小牛马
08-20 1770
在Java中，AOP（面向切面编程）和IoC（控制反转）是两种常见的设计模式，它们在现代Java应用程序中，尤其是在Spring框架中扮演着重要的角色，在软件工程中广泛应用的设计原则，特别是在企业级应用程序开发中。它们都旨在提高代码的模块化、可维护性和可扩展性。通过结合使用AOP和IoC，Spring框架提供了一种强大的方式来构建松耦合、易于测试和维护的应用程序。AOP允许开发者将业务逻辑与横切关注点分离，而IoC则简化了组件之间的依赖管理和配置。
Spring IOC详解 以及 Bean生命周期详细过程
weixin_44098760的博客
05-25 342
Spring IOC详解 以及 Bean生命周期详细过程 IOC ：控制反转 对象交于容器控制 用户只关注业务需求 反转就是让实例来找对象 所以bean对象的创建是依赖容器的 通过容器注入bean对象 也就是说容器会自动找到和bean对象匹配的类型实例注入到对象中。 spring ioc的加载过程 BeanDefinitionReader是加载配置文件的统一接口 由各个加载方式进行实现，如果后期你想要用json的方式进行配置 只需要实现这个接口即可。 BeanDefinition：存储bean的定义信息
SpringIOC 详解
09-17
SpringIOC Spring 框架是一个流行J2EE的开源产品，它提供了统一的应用架构方式、大量的中间层功能模块，大大简化了传统J2EE的开发模式。它的核心代码均来自于真实的项目，是由Spring 之父Rod Johnson 从商业项目开发...
Spring中IOC详解
热门推荐
qq_41359998的博客
02-06 1万+
一、IOC的原型 IOC ----控制反转 比如我们有一个功能是获取用户数据，我们使用Dao层实现这个功能，再在Service层调用这个功能。但是我们每增加一个接口，比如获取mysql中的数据，就要修改原来的代码，如果再增加一个新的接口，又需要去service实现类中修改对应的实现。 解决方法 用户实际调用的是业务层，dao层他们不需要接触 UserServiceImpl userService = new UserServiceImpl(); userSe
Spring IOC原理详解
08-28
Spring IOC原理详解 Spring IOC（Inversion of Control，控制反转）是 Spring 框架的核心概念，它解决了对象之间的耦合问题，实现了松耦合编程。IOC 的思想是，Spring 容器来实现对象之间的创建、协调工作，而不是...
详解 IOC
weixin_30510153的博客
12-20 117
什么是IOC： 　　IOC—Inversion Of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，IOC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制如何理解好IOC呢？理解好IOC的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下： 　　谁控制谁，控制什么：传统Java ...
Spring 之IOC 详解
_清风明月的博客
02-24 396
第一节：spring ioc 简介 IOC（控制反转：Inverse of Control ），又称作 依赖注入，是一种重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的 Spring 框架的核心。 转存失败重新上传取消 第二节：spring ioc 实例讲解第三节：装配一个 bean 第四节：依赖...
Spring系列--IOC详解
qq_42194397的博客
11-25 2680
IOC笔记总结
Spring——IoC详解（IoC概览）
穷水叮咚的博客
09-17 251
一、IoC思想   首先想说说IoC（Inversion of Control，控制倒转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想...
Spring - IOC 详解
chuli0327的博客
11-17 408
IOC容器 1.什么是IOC ​ 1)控制反转 ,把对象创建和对象之间的调用过程,交给Spring进行管理 ​ 2)使用IOC的目的 : 为了耦合度降低 2. IOC 底层原理 XML 解析 : 工厂模式 : 反射 : 3.画图讲解IOC底层原理 4 IOC 接口 (BeanFactory) ​ 1.IOC思想基于IOC容器完成,IOC容器底层就是对象工程 ​ 2.Spring提供IOC容器实现的两种方式 : (两个接口) ​ 1) BeanFactory : IOC 容器基本实现,
Spring(2)——Spring IoC 详解
我没有三颗心脏的博客
04-11 525
Spring IoC 概述 IoC：Inverse of Control（控制反转） 读作“反转控制”，更好理解，不是什么技术，而是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。 正控：若要使用某个对象，需要自己去负责对象的创建 反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控...
Spring Ioc详解：李兴华教你依赖注入
"MLDN 李兴华 Spring IOC 教程，PDF 格式，涵盖了 Spring 框架中的核心概念——IOC（控制反转），通过具体的代码示例解释了如何使用配置文件来管理 Bean。" 在 Spring 框架中，IOC（Inversion of Control，控制反转...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值