Spring bean为什么需要依赖注入

目录
  • 具体步骤:
    • 样例1:
    • 样例2:
  • Spring单例模式和原型模式
    • 一、单例模式
    • 二、原型模式
    • 思考 为什么需要依赖注入
  • 总结

具体步骤:

1.创建一个maven项目 spring-day1-constructor

2.导入依赖

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!--这里是java 版本号-->
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <!--这里是方便版本控制-->
        <spring.version>5.3.1</spring.version>
        <lombok.version>1.18.20</lombok.version>
        <junit.version>4.12</junit.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
    </dependencies>

3.工程项目结构

样例1:

1.创建一个Student类

public class Student {
    private Long number;
    private String name;
    private String school;
    public void setNumber(Long number) {
        this.number = number;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setSchool(String school) {
        this.school = school;
    }
    public Student() {
    }
    public Student(Long number, String name, String school) {
        this.number = number;
        this.name = name;
        this.school = school;
    }
    @Override
    public String toString() {
        return "Student{" +
                "number=" + number +
                ", name='" + name + '\'' +
                ", school='" + school + '\'' +
                '}';
    }
}

写一个配置文件

<?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="s1" class="com.crush.pojo.Student">
       <constructor-arg index="0" value="12"/>
        <constructor-arg index="1" value="wyh"/>
        <constructor-arg index="2" value="北大"/>
    </bean>
    <!--这里是根据构造函数中的 类型来进行注入 -->
    <bean id="s2" class="com.crush.pojo.Student">
        <constructor-arg type="java.lang.Long" value="123"/>
        <constructor-arg type="java.lang.String" value="crush"/>
        <constructor-arg type="java.lang.String" value="浙江大学"/>
    </bean>
</beans>

3.测试

   @org.junit.Test
    public void testStudent(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        Student student = applicationContext.getBean("s2", Student.class);
        System.out.println(student);
    }

样例2:

1.创建Teacher类

public class Teacher {
    private String name;
    private String school;
    private List<Student> studentList;
    private Map<String,String> map;
    private Set<String> set;
    public Teacher(String name, String school, List<Student> studentList, Map<String, String> map, Set<String> set) {
        this.name = name;
        this.school = school;
        this.studentList = studentList;
        this.map = map;
        this.set = set;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", school='" + school + '\'' +
                ", studentList=" + studentList +
                ", map=" + map +
                ", set=" + set +
                '}';
    }
}public class Teacher {
    private String name;
    private String school;
    private List<Student> studentList;
    private Map<String,String> map;
    private Set<String> set;
    public Teacher(String name, String school, List<Student> studentList, Map<String, String> map, Set<String> set) {
        this.name = name;
        this.school = school;
        this.studentList = studentList;
        this.map = map;
        this.set = set;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", school='" + school + '\'' +
                ", studentList=" + studentList +
                ", map=" + map +
                ", set=" + set +
                '}';
    }
}

2.beans.xml

<bean id="teacher" class="com.crush.pojo.Teacher">
    <constructor-arg index="0" value="xxx"/>
    <constructor-arg index="1" value="北京大学"/>
    <constructor-arg index="2" >
        <list>
            <ref bean="s1"/>
            <ref bean="s2"/>
        </list>
    </constructor-arg>
    <constructor-arg index="3">
        <map>
            <entry key="k1" value="xiaowang"/>
        </map>
    </constructor-arg>
    <constructor-arg index="4">
        <set>
            <value>1</value>
            <value>2</value>
        </set>
    </constructor-arg>
</bean>

3.测试

    @org.junit.Test
    public void testTeacher(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        Teacher teacher  = applicationContext.getBean("teacher", Teacher.class);
        System.out.println(teacher);
    }

Spring单例模式和原型模式

一、单例模式

Spring默认是单例模式的。

以Student的那个样例1 为例。 scope=“singleton” 加上这么一个设置 当然默认也是它。

bean id="s1" class="com.crush.pojo.Student" scope="singleton">
    <constructor-arg index="0" value="12"/>
    <constructor-arg index="1" value="wyh"/>
    <constructor-arg index="2" value="北大"/>
</bean>

这个时候我们来进行测试

    @org.junit.Test
    public void testStudent(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        Student student1 = applicationContext.getBean("s1", Student.class);
        Student student2 = applicationContext.getBean("s1", Student.class);
        // 并且如果我们对其中一个做了修改 ,其余也会跟着一起被修改
        // 可以看到我们只修改了一个
        student1.setSchool("梦中的学校");
        System.out.println(student1);
        System.out.println(student2);
        System.out.println(student1==student2);
    }

二、原型模式

我们还是以**Student来做例子讲解 ** 注意:我们把原来设置改成了 scope=“prototype” 也就是原型模式

<!--这里是根据构造函数中的 类型来进行注入 -->
<bean id="s2" class="com.crush.pojo.Student" scope="prototype">
    <constructor-arg type="java.lang.Long" value="123"/>
    <constructor-arg type="java.lang.String" value="crush"/>
    <constructor-arg type="java.lang.String" value="浙江大学"/>
</bean>

接着测试

    @org.junit.Test
    public void testStudent(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        Student student1 = applicationContext.getBean("s2", Student.class);
        Student student2 = applicationContext.getBean("s2", Student.class);
        // 并且如果我们对其中一个做了修改 ,其余也会跟着一起被修改
        // 可以看到我们只修改了一个
        student1.setSchool("梦中的学校");
        System.out.println(student1);
        System.out.println(student2);
        System.out.println(student1==student2);
    }

思考 为什么需要依赖注入

为什么我们以前用一个对象 new一下就好了,但用了Spring 之后,反而还需要写

这样一段代码再去获取勒?明明感觉更麻烦啦丫?用这个又有什么样的好处呢?

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Student student1 = applicationContext.getBean("s2", Student.class);

总结

本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • 详解Spring bean的注解注入之@Autowired的原理及使用

    一.@Autowired 概念: @Autowired 注释,它可以对类成员变量.方法及构造函数进行标注,完成自动装配的工作. 通过 @Autowired的使用来消除 set ,get方法. 在使用@Autowired之前,我们对一个bean配置起属性时,用的是 <property name="属性名" value=" 属性值"/> 使用@Autowired之后,我们只需要在需要使用的地方使用一个@Autowired 就可以了. 代码使用: public

  • Spring bean 四种注入方式详解

    目录 一.Set方式注入 pojo层: 1.xml 文件 test测试 二.构造函数方式注入 pojo层 2.xml文件 test测试 三.注解注入 pojo层 3.xml文件 test测试 四.JavaConfig 方式注入 pojo层 JavaConfig 类 xml文件 扫描包 测试: 五.Service层注入详解 service serviceImpl xml配置文件 总结 一.Set方式注入 pojo层: /** * @Author: crush * @Date: 2021-06-17

  • Java 如何使用@Autowired注解自动注入bean

    Java @Autowired注解自动注入bean annotationWire.xml (一定记得配置context:annotation-config/) <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001

  • 普通类注入不进spring bean的解决方法

    解决问题:我在做移动端accessToken的使用遇到一个问题,就是普通类死活注入不进去spring bean,我和同事雷杰通过各种注解,xml配置搞了好久都搞不定,这里插个眼,有空补一下spring,得深入研究一下 解决办法:后面通过一个spring工具类搞定,这里贴上代码 1.引入这个springUtil类 2.通过构造方法注入 贴上SpringUtils代码: package com.dt.base.weixin.util; import org.springframework.aop.f

  • 创建动态代理对象bean,并动态注入到spring容器中的操作

    使用过Mybatis的同学,应该都知道,我们只需要编写mybatis对应的接口和mapper XML文件即可,并不需要手动编写mapper接口的实现.这里mybatis就用到了JDK动态代理,并且将生成的接口代理对象动态注入到Spring容器中. 这里涉及到几个问题.也许有同学会有疑问,我们直接编写好类,加入@Component等注解不是可以注入了吗?或者在配置类(@Configuration)中直接声明该Bean类型不也可以注入吗? 但具体到mybatis,这里我们用的是接口.由于spring

  • Spring bean为什么需要依赖注入

    目录 具体步骤: 样例1: 样例2: Spring单例模式和原型模式 一.单例模式 二.原型模式 思考 为什么需要依赖注入 总结 具体步骤: 1.创建一个maven项目 spring-day1-constructor 2.导入依赖 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <!--这里是java 版本号--> <maven.compil

  • 详解Spring的核心机制依赖注入

    详解Spring的核心机制依赖注入 对于一般的Java项目,他们都或多或少有一种依赖型的关系,也就是由一些互相协作的对象构成的.Spring把这种互相协作的关系称为依赖关系.如A组件调用B组件的方法,可称A组件依赖于B组件,依赖注入让Spring的Bean以配置文件组织在一起,而不是以硬编码的方式耦合在一起 一.理解依赖注入 依赖注入(Dependency Injection) = 控制反转(Inversion ofControl,IoC):当某个Java实例(调用者)需另一个Java实例(被调

  • 浅谈Spring IoC容器的依赖注入原理

    本文介绍了浅谈Spring IoC容器的依赖注入原理,分享给大家,具体如下: IoC容器初始化的过程,主要完成的工作是在IoC容器中建立 BeanDefinition 数据映射,并没有看到IoC容器对Bean依赖关系进行注入, 假设当前IoC容器已经载入用户定义的Bean信息,依赖注入主要发生在两个阶段 正常情况下,由用户第一次向IoC容器索要Bean时触发 但我们可以在 BeanDefinition 信息中通过控制 lazy-init 属性来让容器完成对Bean的预实例化,即在初始化的过程中就

  • 详解Spring Bean的循环依赖解决方案

    如果使用构造函数注入,则可能会创建一个无法解析的循环依赖场景. 什么是循环依赖 循环依赖其实就是循环引用,也就是两个或则两个以上的bean互相持有对方,最终形成闭环.比如A依赖于B,B依赖于C,C又依赖于A.如下图: 注意,这里不是函数的循环调用,是对象的相互依赖关系.循环调用其实就是一个死循环,除非有终结条件. Spring中循环依赖场景有: (1)构造器的循环依赖 (2)field属性的循环依赖. 怎么检测是否存在循环依赖 检测循环依赖相对比较容易,Bean在创建的时候可以给该Bean打标,

  • Spring 控制反转和依赖注入的具体使用

    目录 控制反转的类型 1.依赖查找 1.1依赖拉取 1.2上下文依赖查找 2.依赖注入 2.1构造函数注入 2.2setter函数注入 Spring中的控制反转 1.Bean和BeanFactory 2.设置Spring配置 2.1XML配置 2.2注解配置 2.3Java配置 3.setter注入 4.构造函数注入 控制反转的类型 控制反转(IOC)旨在提供一种更简单的机制,来设置组件的依赖项,并在整个生命周期管理这些依赖项.通常,控制反转可以分成两种子类型:依赖注入(DI)和依赖查找(DL)

  • Spring入门基础之依赖注入

    目录 一.构造器注入 二.set注入 三.其他方式注入 (1)导入约束 (2)p命名注入 (3)c命名注入 一.构造器注入 在前几节已经做过了详细的说明讲解,我们先跳过 二.set注入 依赖注入 依赖: bean对象的创建以及管理都依赖于Spring IOC容器 注入: bean对象中的所有属性,都有容器进行注入 在前面我们已经见识过了 普通类型注入和 bean注入的方式,那么对于复杂类型List.数组类型.Map.Set属性等怎么进行注入呢? 我们先提供一个包含各种类型的实体类 Student

  • Spring使用Setter完成依赖注入方式

    目录 对依赖注入的理解 使用Setter完成不同类型属性的注入 整体配置文件 Spring解决setter方式的循环依赖的原理 对依赖注入的理解 依赖:实体间的所有依赖由容器创建 注入:容器负责完成实体间依赖互相注入的任务 使用Setter完成不同类型属性的注入 实体类Student package indi.stitch.pojo; import java.util.*; public class Student { private String name; private Address a

  • 因Spring AOP导致@Autowired依赖注入失败的解决方法

    发现问题: 之前用springAOP做了个操作日志记录,这次在往其他类上使用的时候,service一直注入失败,找了网上好多内容,发现大家都有类似的情况出现,但是又和自己的情况不太符合.后来总结自己的情况发现:方法为private修饰的,在AOP适配的时候会导致service注入失败,并且同一个service在其他的public方法中就没有这种情况,十分诡异. 解决过程: 结合查阅的资料进行了分析:在org.springframework.aop.support.AopUtils中: publi

  • Spring bean的实例化和IOC依赖注入详解

    前言 我们知道,IOC是Spring的核心.它来负责控制对象的生命周期和对象间的关系. 举个例子,我们如何来找对象的呢?常见的情况是,在路上要到处去看哪个MM既漂亮身材又好,符合我们的口味.就打听她们的电话号码,制造关联想办法认识她们,然后...这里省略N步,最后谈恋爱结婚. IOC在这里就像婚介所,里面有很多适婚男女的资料,如果你有需求,直接告诉它你需要个什么样的女朋友就好了.它会给我们提供一个MM,直接谈恋爱结婚,完美! 下面就来看Spring是如何生成并管理这些对象的呢? 1.方法入口 o

  • Spring依赖注入的三种方式小结

    Spring的主要特性包括IOC和DI,其中DI是IOC的基础.在以前的Spring使用过程中大部分都是使用XML配置文件显式配置spring组件,导致大量的XML配置文件以及冗余的XML配置代码.阅读<Spring in Action>后总结Spring的DI功能的三种主要装配方式以及混合装配方式 根据注解自动装配 Spring中有非常丰富的注解,通过这些注解可以方便地配置Spring容器,使得Spring容器可以自动识别相关Bean并做自动注入装配. 使用注解 @Component注解:标

随机推荐