控制反转(IOC)

最新推荐文章于 2024-07-18 15:34:18 发布
最新推荐文章于 2024-07-18 15:34:18 发布
阅读量145 收藏
点赞数
分类专栏： Java 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40298175/article/details/107699068
版权

控制反转

1.1 IoC介绍

IoC (Inverse of Control)控制反转，将原本由我们手动完成的创建对象的工作交由Spring对象工厂来完成

1.2 Spring对象工厂使用
创建Bean
public class Book {
    private int bookId;
    private String bookName;
}
配置Bean
<?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标签将实体类 配置给 spring管理，id是当前实体类在Spring容器中的唯一标识 -->
    <bean id="book" class="com.qfedu.entity.Book"></bean>

</beans>
获取Bean
//a.加载spring配置文件
ClassPathXmlApplicationContext context = 
    new ClassPathXmlApplicationContext("applicationContext.xml");

//b.从Spring对象工厂获取对象
Book book = (Book)context.getBean("book");
1.3 DI(Dependency Injection) 依赖注入
★ set方法注入 ：

使用property标签完成属性注入依赖于类中属性的set方法——set注入

1.3.1 依赖注入概念

Spring对象工厂完成对象创建的同时，为对象的属性赋值，称之为依赖注入。

  • 在配置文件指定bean的属性值
  • 通过对象工厂创建对象时，就会将指定的值注入
1.3.2 简单类型和字符串类型属性注入
public class Book {
    private int bookId;
    private String bookName;
}

<bean id="book" class="com.qfedu.entity.Book">
        <!--
        property标签，用于给创建的实例输入配置注入的值
        name 属性   指定对象的属性名
        value 属性  指定对象当前属性的值
        -->
        <property name="bookId" value="1001"/>
        <property name="bookName" value="Java程序设计"/>
</bean>
1.3.3 日期类型
public class Book {
    private int bookId;
    private String bookName;
    private Date bookTime;
}
  • 方式1：
<bean id="book" class="com.qfedu.entity.Book">
    <property name="bookId" value="1001"/>
    <property name="bookName" value="Java程序设计"/>
    <property name="bookTime" value="2020/07/29"/>
</bean>
  • 方式2：
<bean id="time" class="java.util.Date"/>

<bean id="book" class="com.qfedu.entity.Book">
    <property name="bookId" value="1001"/>
    <property name="bookName" value="Java程序设计"/>
    <property name="bookTime" ref="time"/>
</bean>
  • 方式3
<bean id="book" class="com.qfedu.entity.Book">
    <property name="bookId" value="1001"/>
    <property name="bookName" value="Java程序设计"/>
    <property name="bookTime" >
        <bean class="java.util.Date"/>
    </property>
</bean>
1.3.4 自建类型（自定义类类型）
public class Type {
    private int typeId;
    private String typeName;
}

public class Book {
    private int bookId;
    private String bookName;
    private Type type;
}
  • 方式1：
<bean id="book" class="com.qfedu.entity.Book">
    <property name="bookId" value="1"/>
    <property name="bookName" value="Java程序设计"/>
    <!--自定义类类型的属性-->
    <!--<property name="type" ref="type1"/>-->
    <property name="type">
        <bean class="com.qfedu.entity.Type">
            <property name="typeId" value="10003"/>
            <property name="typeName" value="地理"/>
        </bean>
    </property>
</bean>
  • 方式2：
<bean id="type1" class="com.qfedu.entity.Type">
    <property name="typeId" value="10001"/>
    <property name="typeName" value="IT"/>
</bean>

<bean id="book" class="com.qfedu.entity.Book">
    <property name="bookId" value="1"/>
    <property name="bookName" value="Java程序设计"/>
    <!--自定义类类型的属性-->
    <property name="type" ref="type1"/>
</bean>
1.3.5 集合类型
  • 单值集合（List\Set\数组）
public class Book {
    private List<String> marks;
    private Set<String> attrs1;
    private String[] attrs2;
}

<bean id="book" class="com.qfedu.entity.Book">
    <property name="marks">
        <list>
            <value>aa</value>
            <value>bb</value>
            <value>cc</value>
        </list>
    </property>
    <property name="attrs1">
        <set>
            <value>aa</value>
            <value>bb</value>
            <value>aa</value>
        </set>
    </property>
    <property name="attrs2">
        <array>
            <value>1</value>
            <value>2</value>
            <value>3</value>
            <value>4</value>
        </array>
    </property>
</bean>
  • 键值对集合（Map、Properties）
public class Book {
    private Map<String,Object> attrs3;
    private Properties attrs4;
}

<bean id="book" class="com.qfedu.entity.Book">

    <!--map-->
    <property name="attrs3">
        <map>
            <entry key="key1" value="value1"/>
            <entry key="key2" value-ref="date"/>
        </map>
    </property>
    <!--properties -->
    <property name="attrs4">
        <props>
            <prop key="k1">v1</prop>
            <prop key="k2">v3</prop>
        </props>
    </property>
</bean>
★ 构造器注入

如果类中没有set方法则不能使用property标签完成属性的注入，此时我们可以通过有参构造器完成注入

public class Type {

    private int typeId;
    private String typeName;

    public Type() {
    }

    public Type(int typeId, String typeName) {
        this.typeId = typeId;
        this.typeName = typeName;
    }
}

<bean id="type1" class="com.qfedu.entity.Type">
    <!--
        constructor-arg 指定构造器参数
        index属性指定构造器参数的索引
        value属性指定构造器参数的值
        ref属性，当构造器参数是对象类型时，用于指定对象
        -->
    <constructor-arg index="0" value="10001"/>
    <constructor-arg index="1" value="人文"/>
</bean>
1.4 使用SpringIoC解决项目中的耦合度问题
1.4.1 传统写法：Servlet对Service实现类存在依赖
public class LoginServlet extends HttpServlet {

    private UserService userService = new UserServiceImpl1();
    
    public void doGet(HttpServletRequest request,HttpServletResponse response){
        userService.login();
    }

}
1.4.2 解决方案
  • Servlet
public class LoginServlet extends HttpServlet {

    private UserService userService;
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    
    public void doGet(HttpServletRequest request,HttpServletResponse response){
        userService.login();
    }

}
  • applicationContext.xml
<?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="userService1" class="com.qfedu.service.impl.UserServiceImpl1"></bean>
    <bean id="userService2" class="com.qfedu.service.impl.UserServiceImpl2"></bean>

    <bean id="loginServlet" class="com.qfedu.servlets.LoginServlet">
        <property name="userService" ref="userService2"/>
    </bean>

</beans>
1.5 Bean的配置

bean标签，用来声明Spring容器对类的管理

  • id/name属性 是当前bean的唯一标识
  • class属性 用来指定被Spring容器管理的类路径
  • scope属性
  • lazy-init属性，设置Bean的初始化为懒初始化
  • autowire属性，设置Bean的属性自动装配
1.5.1 Bean的生命周期

通过scope属性可以指定对象的生命周期

  • singleton 默认 ，设置当前bean为单例模式（饿汉）

      1. Spring容器启动创建对象（分配内存空间）：创建对象—调用构造器—调用set方法—初始化方法
      1. 对象创建完成存放在Spring容器
      1. Spring容器关闭销毁对象

  • prototype 设置当前Bean为非单例模式

      1. Spring容器启动不会创建对象（加载配置文件）
      1. 调用getBean使用对象时创建对象：创建对象—调用构造器—调用set方法—初始化方法
      1. 对象创建完成可使用
      1. 对象使用完成之后被JVM垃圾回收
  • scope配置
<bean id="type1" class="com.qfedu.entity.Type" scope="singleton">
    <property name="typeId" value="10001"/>
    <property name="typeName" value="人文"/>
</bean>
1.5.2 初始化和销毁方法

初始化方法：实例创建完成之后执行的方法

销毁方法：实例销毁时执行的方法

public class Type {

    private int typeId;
    private String typeName;

    public void method1(){
        System.out.println("-------init");
    }
    public void method2(){
        System.out.println("-------destory");
    }
}

<bean id="type1" class="com.qfedu.entity.Type" scope="singleton" lazy-init="true"  
      init-method="method1" destroy-method="method2">
    <property name="typeId" value="10001"/>
    <property name="typeName" value="人文"/>
</bean>
1.5.3 自动装配

Bean的属性（一般指的是对象属性）也可以通过自动装配来完成赋值，自动装配的两种方式：

  • byType 根据当前对象属性的类型 从Spring容器中选择类型匹配的bean进行注入；如果没有找到对应类型的bean，则设置为null；如果找到多个类型匹配的Bean则抛出异常
  • byName 根据当前对象属性的属性名 从Spring容器选择bean 进行注入；如果没有找到同名的bean则设置为null；如果根据属性名找到bean类型不匹配则抛出异常
<bean id="book" class="com.qfedu.entity.Book" autowire="byName"></bean>
1.6 Spring对象工厂的工作原理

Spring对象工厂原理：xml解析、反射

  • Spring工作原理概念图

在这里插入图片描述

二、IoC注解配置

SpringIoC的使用，通过将我们创建的类声明给Spring对象工厂进行管理来实现对象创建和属性注入的；

Spring也提供了注解的配置形式，无需再xml文件中进行声明，直接在类中通过注解的形式进行声明即可。

2.1 配置声明使用注解
  • 在spring配置文件applicationContext.xml添加context的命名空间
  • 通过context:annotation-config标签声明使用注解
  • 通过context:component-scan声明注解使用的范围
<?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: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">

    <context:annotation-config/>
    <context:component-scan base-package="com.qfedu.entity"/>

</beans>
2.2 IoC常用注解
@Component /@Service/@Repository
  • 类注解，声明类被Spring管理，相当于bean标签的作用
  • value值相当于 bean标签的id属性，如果不设置value值，则默认id为 类名首字母小写
  • @Service 用于声明Service; @Repository用于声明DAO ； @Component用于一般声明
@Autowired

  • 属性注解/方法注解，用于声明当前属性为自动装配,默认根据byType类完成自动注入

  • @Autowired(required = false) 声明此自动装配非必须的，默认是必须的

  • 当Spring容器由多个可以注入的Bean时，我们需要结合@Qualifier注解来指定注入的Bean

    @Autowired
public void setType(@Qualifier("type1") Type type) {
    this.type = type;
}
@Scope
  • 类注解，用于声明当前类对象是否为单例模式，默认单例
  • @Scope(“prototype”) 设置为非单例模式
@Lazy(false)
  • 类注解，用于设置当前类的Bean是否为懒汉式(针对单例模式)、
  • 默认值为true，@Lazy(false)设置为非懒汉式
@PostConstruct 和 @PreDestroy
  • 方法注解，用于声明声明周期方法
  • @PostConstruct 声明初始化方法
  • @PreDestroy 声明销毁方法
@PostConstruct
public void method1(){
    System.out.println("---init");
}

@PreDestroy
public void method2(){
    System.out.println("----destory");
}
__追梦人
关注
专栏目录
IOC控制反转
03-09
本文文档中有 控制反转 DI依赖注入，希望可以给大家在技术上有一点的帮助
Android应用开发中控制反转IoC设计模式使用教程
09-02
【Android应用开发中控制反转IoC设计模式使用教程】 IoC（Inversion of Control，控制反转）是一种设计模式，常被称为依赖注入（Dependency Injection，DI）。在Android应用开发中，IoC模式能够显著降低组件之间的...
什么是IoC控制反转思想？
最新发布
luming的博客
07-18 1484
IoC（Inversion of Control）即控制反转，这里的控制是代表控制权的意思，IoC是一种编程思想，旨在降低代码之间的耦合度、降低代码的维护成本。这种思想的具体内容就是将对象的创建和管理交给外部的容器和框架，不再是由对象的调用者去new一个对象。在这个过程中，对象的创建和管理的权力由传统的对象调用者转移到了外部的容器和框架，即对象的控制权发生了反转。
IoC 控制反转
echojson的专栏
07-26 2166
  IoC是什么 Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下： 我们再来看看，控制反转(IOC)到底为...
IOC 控制反转
qq_61453770的博客
10-31 7277
（80左右都是使用的set注入）属性：value就是对象的名称，也就是bean的id值，value的值是唯一的，创建的对象在整个spring的容器中就一个。创建对象，给属性赋值。DI：依赖注入，只需要在程序中提供要使用的对象的名称就可以，至于对象如何在容器中创建，赋值，查找都由容器内部实现。的上面）：放在控制器（处理器）类的上面，创建控制器对象的，控制器对象，能够接受用户提交的参数，显示请求的处理结果。描述的：把对象的创建，赋值，管理工作都交给代码之外的容器实现，也就是对象的创建是有其它外部资源完成。
Spring框架控制反转IOC和依赖注入DI详解
01-20
本文介绍了Spring框架中的控制反转IOC和依赖注入DI，欢迎阅读，共同学习，一起进步。 Spring框架基础参考：深入学习Spring基础 文章目录一.入门程序和IOC简介二.IOC-控制反转三.DI-依赖注入四. IOC和DI五.Spring...
浅析springboot通过面向接口编程对控制反转IOC的理解
08-24
浅析SpringBoot通过面向接口编程对控制反转IOC的理解 控制反转（IOC）是一种设计思想，而不是一种技术。它将对象的控制权交给容器，而不是传统的在对象内部直接控制。IOC的关键是要明确“谁控制谁，控制什么，为何...
Spring.Net控制反转IoC入门使用
08-30
本文主要关注的是Spring.NET的核心特性——控制反转（Inversion of Control，简称IoC）。 控制反转是一种设计模式，它将对象的创建和依赖关系的管理从应用代码中解耦出来。通过IoC，对象不再负责创建和管理其依赖项...
IoC控制反转
u013571202的博客
05-08 1万+
IoC控制反转 核心概念 1. IoC（Inversion of Control）控制反转 使用对象时，由主动new产生对象转换成，从外部提供对象，在这个过程中，对象的创建控制权由程序转移到外部，此思想称为控制反转。 2. DI（Dependency Injection）依赖注入 在容器中建立bean与bean之间的依赖关系的整个过程，成为依赖注入。 3. Spring技术对IoC思想进行了实现 Spring提供了一个容器，称为IoC容器，用来充当IoC思想的外部。 IoC容器负责对象的搭建，初始化一系列工
IOC(控制反转)
欢迎来到我的博客，在这里我会用我的方式来讲解知识，请大家多多关照
05-24 7165
所谓依赖注⼊，就是由 IoC 容器在运⾏期间，动态地将某种依赖关系注⼊到对象之中依赖注入就是在程序运行的时候由IOC容器动态的将我所依赖的对象加入到当前类中的过程谁依赖于谁 : 应用程序依赖于IOC容器为什么需要依赖 : 应用程序需要IOC容器来提供对象所需要的外部资源谁注入谁 : IOC容器注入应用程序依赖的对象注入了什么 : 注入某个对象所依赖的外部资源(包括对象,资源,常量数据...)
IOC （控制反转）
weixin_46942121的博客
04-29 4019
Spring框架——IOC部分
spring IOC容器管理必须知道这些操作——基于XML方式
热门推荐
学而时习
07-01 5万+
Spring——IOC（控制反转） 一、IOC容器 ​ 1、什么是IOC（控制反转） ​ a）把对象创建和对象之间的调用过程，交给Spring进行管理 ​ b）使用IOC目的：为了降低耦合度 ​ 2、IOC底层 ​ a）xml解析、工厂模式、反射 ​ 3、Spring提供的IOC容器实现的两种方式（两个接口） ​ a）BeanFactory接口：IOC容器基本实现是Spring内部接口的使用接口，不提供给开发人员进行使用（加载配置文件时候不会创建对象，在获取对象时才会创建对象。） ​ b）App
IOC（控制反转）
fhjkkkjh的博客
02-28 170
IOC（控制反转）
寻的见的影子_原理_IOC控制反转
chiyuan1282的博客
01-02 90
以下来着百度词条： 控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Depe...
Spring.NET框架解析：理解控制反转IoC与依赖注入
在软件开发中，Spring.NET是一个基于.NET Framework的轻量级开源框架，它提供了控制反转（IoC）和面向切面编程（AOP）的功能，帮助开发者实现更加灵活和解耦的代码结构。控制反转（Inversion of Control，IoC）和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值