Spring学习( 二 )：IOC控制反转和DI依赖注入

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

Spring学习( 二 )：IOC控制反转和DI依赖注入

（一）、IOC的概念

一句话：把创建对象的权利交给了工厂，原来通过new 来创建，自己可以控制，如果通过Factory创建就把创建去权交出去了。

（二）、首先我们先介绍下ApplicationContext和它相关的类和接口

0

1、顶级接口

从图中可以看出BeanFactory是Spring容器的顶级接口，主要实现类有三个。

2、实现类

ClassPathXmlApplicationContext(最重要)：配置文件的相对路径
FileSystemXmlApplicationContext：绝对路径
AnnotationConfigApplicationContext：基于注解

（三）、BeanFactory和ApplicationContext的区别

1、功能不同

BeanFactory：最低层的接口，提供了最简单的容器的功能，只提供了实例化对象和拿对象的功能。
ApplicationContext：国际化、访问资源，如URL和文件（ResourceLoader）、AOP（拦截器）。

2、装载Bean的时机不同

BeanFactory是在第一次调用getBean的时候创建bean，ApplicationContext是在加载完配置就读取进去了，也可以在Bean配置lazy-init=true设为懒加载。（2种都是默认单例模式）

（四）、bean的三种创建方式

1、调用构造器创建Bean
2、调用实例工厂方法创建Bean
3、调用静态工厂方法创建Bean

下面逐个介绍

1、调用构造器创建Bean

注意点

默认是无参构造函数创建Bean，如果Bean中存在有参构造函数，没写无参构造且使用默认xml配置，那么程序会报错。（没没找到默认的无参构造方法）

要想不出错，直接加个无参构造，但是如果Bean是再JAR包中，我们无法修改代码，或者说我们想把Jar包中每个方法返回值（类）加载到Spring容器中，这时候就要用下面2中方法来获取Bean了。
在这里插入图片描述

xml配置

<bean id="userService" class="com.service.impl.UserServiceImpl" />

Bean对象

public class UserServiceImpl implements UserService {
    @Override
    public String getUser(String name) {
        return "我是：" + name;
    }
}

2、调用实例工厂方法创建Bean

应用场景：我们想把Jar包中每个方法返回值（类）加载到Spring容器中

xml配置

    <bean id="instanceFactory" class="com.factory.InstanceFactory"></bean>
    <bean id="userService" factory-bean="instanceFactory" factory-method="getUserservice" />

工厂Bean对象

/**
 * @author wangquan
 * @date 2020/12/11
 * 模拟一个工厂类，我们想把Jar包中每个方法返回值（类）加载到Spring容器中
 */
public class InstanceFactory {
    public UserServiceImpl getUserservice(){
        return new UserServiceImpl();
    }
}

3、调用静态工厂方法创建Bean

xml配置

    <bean id="userService" class="com.factory.StaticFactory" factory-method="getUserservice" />

静态工厂Bean对象

public class StaticFactory {
    public static UserServiceImpl getUserservice(){
        return new UserServiceImpl();
    }
}

（五）、bean的作用域

目前Bean的作用域有以下6种

作用域描述
singleton在spring IoC容器仅存在一个Bean实例，Bean以单例方式存在，bean作用域范围的默认值。
prototype每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时，相当于执行newXxxBean()。
request每次HTTP请求都会创建一个新的Bean，该作用域仅适用于web的Spring WebApplicationContext环境。
session同一个HTTP Session共享一个Bean，不同Session使用不同的Bean。该作用域仅适用于web的Spring WebApplicationContext环境。
application限定一个Bean的作用域为ServletContext的生命周期。该作用域仅适用于web的Spring WebApplicationContext环境。
global-session全局session，集群下的session，如果不是集群环境，和session没去别。

详情看这篇文章

Spring Bean的作用域

（六）、bean的生命周期

总的说下面8步

1、实例化Bean（通过构造方法或工厂创建）
2、注入属性（依赖注入）
3、执行实现Aware接口的方法，如实现了BeanNameAware接口，调用setBeanName()方法传递Bean的ID。
4、将Bean传递给Bean的前置处理器postProcessBeforeInitialization
5、调用Bean的初始化方法。
6、将Bean传递给Bean的后置处理器postProcessAfterInitialization
7、使用Bean
8、容器关闭前调用destroy方法。（如果作用域为prototype，不会调用，而是由垃圾回收器销毁）

代码演示

1、Student类实现了BeanNameAware接口，重写setBeanName方法

public class Student implements BeanNameAware {
    private String name;

    public Student(){
        System.out.println("1、调用构造方法初始化Bena");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("3、BeanNameAware设置BeanName：" + name);
    }

    public void setName(String name) {
        System.out.println("2、设置对象属性setName()..");
        this.name = name;
    }

    /**
     * Bean的使用
     */
    public void study() {
        System.out.println("7、Student这个Bean：使用,调用study()方法，此时我的名字：" + this.name);
    }

    public void initMethod(){
        System.out.println("5、设置Bean的初始化方法..");
    }

    public void destroyMethod(){
        System.out.println("8、设置Bean的销毁方法..");
    }

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

2、MyBeanPostProcessor实现BeanPostProcessor，重写前置和后置方法

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("4、对初始化之前的Bean进行处理,此时我的名字：" + bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Student stu = null;
        String xmlBeanName = "student";
        System.out.println("6、对初始化之后的Bean进行处理,将Bean的成员变量的值修改了");
        if(xmlBeanName.equals(beanName) || bean instanceof Student) {
            stu = (Student) bean;
            stu.setName("李四");
        }
        return stu;
    }
}

3、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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="com.bean.Student" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="张三"/>
    </bean>
    <!-- 配置bean的后置处理器,不需要id，IoC容器自动识别是一个BeanPostProcessor -->
    <bean class="com.MyBeanPostProcessor"></bean>
</beans>

4、测试类

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Student student = (Student) context.getBean("student");
student.study();
context.close();

5、打印结果

在这里插入图片描述

（七）、依赖注入

1、什么是依赖注入

一个类要用到另一个类，我们只需要到spring配置文件配置，让spring为我们提供，如MySQL的配置注入到连接类里面，我们可以直接拿到类，而不需要额外配置。

2、依赖注入类型和方式

能注入的类型

  • 基本类型和String
  • 其他bean类型（配置文件配置的bean或注解配置过的）
  • 复杂类型 / 集合类型

注入的方式

  • 构造方法注入
  • set注入
  • 注解注入

3、注入方式

1、构造方法注入

Bean：Student

public class Student {

    private String name;
    private Integer age;
    private Date birthday;

    public Student(String name, Integer age, Date birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public void getStudent(){
        System.out.println(this.name+" : " + age + " : " + birthday);
    }
}

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="com.bean.Student">
        <constructor-arg name="name" value="12"/>
        <constructor-arg name="age" value="12"/>
        <constructor-arg name="birthday" ref="date"/>
    </bean>
    <bean id="date" class="java.util.Date"></bean>
</beans>

测试类

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Student student = (Student) context.getBean("student");
student.getStudent();

在这里插入图片描述

优势
在获取Bean，注入操作必须的，否则无法创建Bean
劣势
改变了Bean的实例化方式，再创建对象的时候，如果用不到这些数据，也必须提供。

2、get方法注入

Bean：Student

public class Student {

    private String name;
    private Integer age;
    private Date birthday;
    // 省略set方法。。。
}

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="com.bean.Student">
        <property name="name" value="张三" />
        <property name="age" value="33" />
        <property name="birthday" ref="date" />
    </bean>
    <bean id="date" class="java.util.Date"></bean>
</beans>

测试类
和上面一样
在这里插入图片描述
复杂数据类型的注入
Bean

public class Student {

    private String[] array;
    private List<String> lists;
    private Set<String> sets;
    private Map<String,String> map;
    private Properties properties;
  	 // 省略set方法。。。
  	@Override
    public String toString() {
        return "Student{" +
                "array=" + Arrays.toString(array) +
                ", lists=" + lists +
                ", sets=" + sets +
                ", map=" + map +
                ", properties=" + properties +
                '}';
    }
}

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="com.bean.Student">
        <property name="array" >
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="strings">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>

        <property name="sets">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>

        <property name="map">
            <map>
                <entry key="aaa" value="bbb"/>
                <entry key="ccc" value="ddd"/>
                <entry key="eee" value="fff"/>
            </map>
        </property>

        <property name="properties">
            <props>
                <prop key="aaa">bbb</prop>
                <prop key="ccc">ccc</prop>
                <prop key="eee">ddd</prop>
            </props>
        </property>
    </bean>
</beans>

测试结果
只要记住一个list一个map即可
在这里插入图片描述
发现互用也可以。
在这里插入图片描述

3、注解注入

1、找到对应的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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    <!--找到对应的XML头，打开包扫描-->
    <context:component-scan base-package="com"/>
</beans>

2、把要注入到spring容器的类加上注解

@Repository
public class UserDapImpl implements UserDao {

@Service("userService")
public class UserServiceImpl implements UserService {
P@ssW0rd
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMVC
weixin_43164309的博客
08-28 473
SpringMVC Spring与Web环境集成 springboot 添加webapp目录-百度经验 (baidu.com) ApplicationContext应用上下文获取方式 应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件)方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置文件加载多次，应用上下文对象创建多次，影响性能。 C
IOC控制反转&DI依赖注入
04-08
在本项目中，"IOC技术思想和DI依赖注入"的实现可能包括以下几个方面： 1. 创建一个Spring配置文件，定义bean及其依赖关系。 2. 使用注解（如@Service、@Autowired）来标注bean和它们的依赖。 3. 编写业务逻辑类，...
[Spring] IOC控制反转/DI依赖注入详细讲解
沫洺的博客
09-24 1503
IOC控制反转,DI依赖注入详细讲解,bean配置,bean初始化,bean生命周期,依赖注入方式,依赖自动装配,集合注入.第三方资源配置管理,加载properties文件,容器
Spring学习第2篇：IoC控制反转 与 DI依赖注入
怪咖@的博客
11-02 1852
`IOC`控制反转，是一种设计理念，并不是实际存在的东西，将对象创建和组装的主动控制权利交给了`spring`容器去做，控制的动作被反转了，降低了系统的耦合度，利于系统维护和扩展，主要就是指需要使用的对象的组装控制权被反转了，之前是自己要做的，现在交给`spring`容器做了。
深入理解 Spring IoC 与 DI：控制反转与依赖注入解析
最新发布
weixin_71246590的博客
08-15 913
在接触 Spring 框架之前，通常我们会在 main 方法或其他业务逻辑中手动 new 对象，然后调用这些对象的方法来完成任务。手动创建对象的方式意味着我们自己掌握了对象的控制权。 然而，在 Spring 中，我们不再直接在代码中手动创建对象，而是将对象的创建、管理、依赖注入等职责交给了 Spring 容器。Spring 框架通过 IoC（控制反转）和 DI（依赖注入）来实现这一点。
spring01：IOC控制反转、DI依赖注入
qq_44985812的博客
06-13 570
Spring框架的IOC和依赖注入
Spring：IoC（控制反转、依赖注入、循环依赖）
燕双嘤
01-21 1605
1，IoC（Spring的核心和基础） 1.1，IoC原理 纵观所有的Java应用（从基于Applet的小应用到多层结构的企业级应用），这些应用中大量存在A对象调用B对象方法的情况，者请情况被Spring称为依赖，即A对象依赖B对象。对于Java应用而言，它们总是由一些相互调用的对象构成的，Spring把这种相互调用的关系称为依赖关系。假如A组件调用了B组件的方法，即可称A组件依赖B组件。 Spring框架的核心功能有两个： Spring容器作为超级大工厂，负责创建、管理所有的Java对象，这些J
详解spring的IOC控制反转和DI依赖注入
qq_38122518的博客
06-05 6749
　学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来说，总觉得IoC 、DI这两个概念是模糊不清的，是很难理解的，今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。一、分享Iteye的开涛对Ioc的精彩讲解　　首先要分享的是Iteye的开涛这位技术牛人对Spring...
[Spring] IoC 控制反转和DI依赖注入和Spring中的实现以及常见面试题
weixin_64173948的博客
03-10 1261
Spring是一个开源框架,他让我们的开发更加简单,它支持广泛的应用场景,有着活跃而庞大的社区,这也是Spring能够长久不衰的原因.这个概念还是相对于比较抽象,我们用通俗易懂的话来讲,Spring是包含了众多工具方法的IoC容器 那么问题来了,容器是什么.什么是IoC容器。
【Spring】IoC控制反转和DI依赖注入概述
渐若窥宏大的博客
01-13 371
Spring框架的核心概念——IoC IoC IoC是Inversion of Control的简写，翻译成汉语就是“控制反转”。IoC并不是一门技术，而是一种设计思想,在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）,DI是实现IoC的一种方法。 在没有IoC设计的场景，没有IoC的程序，我们使用所需的对象时，需手动创建各种对象，...
Java：控制反转（IoC）与依赖注入（DI）
沉默王二
08-07 7497
很长一段时间里，我对控制反转和依赖注入这两个概念很模糊，闭上眼睛想一想，总有一种眩晕的感觉。但为了成为一名优秀的 Java 工程师，我花了一周的时间，彻底把它们搞清楚了。 01、紧耦合 在我们编码的过程中，通常都需要两个或者更多的类通过彼此的合作来实现业务逻辑，也就是说，某个对象需要获取与其合作对象的引用，如果这个获取的过程需要自己实现，代码的耦合度就会高，维护起来的成本就比较高。 我们来通过实战...
Spring框架控制反转IOC和依赖注入DI详解
01-20
本文介绍了Spring框架中的控制反转IOC和依赖注入DI，欢迎阅读，共同学习，一起进步。 Spring框架基础参考：深入学习Spring基础 文章目录一.入门程序和IOC简介二.IOC-控制反转三.DI-依赖注入四. IOC和DI五.Spring...
我的Pro Spring 学习笔记 之二 控制反转(IoC)和依赖注入(DI), Spring初步
03-06
在本文中，我们将深入探讨Spring框架的核心概念——控制反转（Inversion of Control，IoC）和依赖注入（Dependency Injection，DI）。这些概念是Spring框架的基础，对于理解和掌握Spring的使用至关重要。 首先，让...
Spring学习(五)：动态代理的两种实现方式（全网最容易懂）
qq_40205337的博客
12-20 6853
Spring学习(五)：动态代理的两种实现方式（全网最容易懂） 前言 要学习SpringAOP之前，肯定要弄清楚什么是动态代理，动态代理是怎样实现的，以及动态代理能解决什么问题。 一、什么是动态代理 1、字面意思，代理就是代替别人去做一些事情，如线下店代替工厂去卖电脑、代理工厂做售后工作，线下店就是代理商，从卖给工厂的获得的钱提取分成就是增强的方法。 2、Java中就是在不改变别别的类，对类做增强处理，如打印日志、事物的控制，权限的管理，后续我们都会介绍。 二、两种实现动态代理的方法 1、基于JDK的动
IDEA导入Spring源码环境搭建（图文解析）
qq_40205337的博客
10-24 941
IDEA导入Spring源码环境搭建（图文解析）IDEA导入Spring源码环境搭建（图文解析）一、环境准备二、下载源码2.1 fork出一个自己的仓库2.2 复制git地址去idea下载2.3 配置Gradle2.4 设置gradle-wrapper.properties2.5 配置build.gradle文件2.6 然后往下继续寻找，找到如下代码段三、spring-aspects模块 IDEA导入Spring源码环境搭建（图文解析） 一、环境准备 jdk1.8 IDEA2021 用来阅读和开发
spring源码-代码的特殊写法
qq_40205337的博客
06-11 623
在阅读spring源码中，可能会有很多种代码写法在工作中都没遇见过，阅读起来有一定的难度，在本文中，我会把我认为有难度的代码写法拿出来，并举例子说明清楚，方便大家阅读并理解源码。
Spring学习(四)：事务的学习之银行转账案例
qq_40205337的博客
10-21 425
Spring 银行转账1.编写一个TransationManager类2.编写一个ConnectionUtils类3.在AccountServiceImpl写业务层代码4.在AccountDaoImpl写实现类代码5.完成注解的注入6.测试 考察点：spring、事务 实现流程 1.编写一个TransationManager类 作用：提供一个事务管理相关的工具类，它包括了，开启事务，提交事务，回滚...
SpringBoot与前端交互遇到的一些问题
qq_40205337的博客
08-27 413
SpringBoot打的jar包在Linux运行报错百度找了很多都是一样的答案，但是解决不了我的问题，于是我新建了一个springboot项目发现打的jar包可以在Linux上运行。检查了下只要把下面这2个地方拷贝到我的项目里就能成功打包了。
Spring学习(三 )：注解的应用
qq_40205337的博客
12-14 223
Spring学习(三 )：注解的应用 （一）、把Bean注入容器的注解 名称 作用 @Component 通用组件 @Controller 控制层 @Service 服务层 @Repository 数据层 （二）、用于注入数据的 1、@Autowired，自动按照类型注入 如IAccountDao会按照类型找到AccountDaoImpl,如果没有类实现IAccountDao，使用Autowired会报错 如果有2个类实现了IAccountDao，首先按类型找到这2个实现类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值