JAVA面试题分享四百零九：Spring 框架中依赖注入的 11 种方式

最新推荐文章于 2024-04-27 19:39:46 发布
最新推荐文章于 2024-04-27 19:39:46 发布
阅读量1k 收藏 16
点赞数 26
分类专栏： JAVA 面试题分享 文章标签： java spring 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45038038/article/details/135938705
版权

目录

1、通过构造器注入

2、通过Set方式注入（重点）

2.1、搭建测试环境

2.2、常量注入

2.3、Bean注入

2.4、数组注入

2.5、List注入

2.6、Map注入

2.7、Set注入

2.8、Null注入

2.9、Properties（属性）注入

2.10、测试结果

3、p命名空间和c命名空间注入

3.1、p命名空间注入

3.2、c命名空间注入

依赖注入（Dependency Injection，DI）指的是Spring在创建对象时，IOC容器把对象依赖的属性注入到对象中的过程。

  • 依赖：Bean对象的创建依赖于容器。

  • 注入：Bean对象的所有属性由容器注入。

1、通过构造器注入

在4、IOC容器创建对象的方式一节中已经介绍了。

2、通过Set方式注入（重点）

2.1、搭建测试环境

（1）在父项目中新建一个模块（Module），并在其中创建一个普通的Maven子项目，项目名称为spring-04-di。

（2）填写子项目名称和Maven项目GAV，点击Finish按钮完成子项目创建，等待Maven依赖包导入完毕。

（3）在子项目的java目录下新建一个com.atangbiji.pojo包（用于存放我们自己编写的实体类），并在该包下新建两个名称分别为Student和Address的实体类。

Address.java文件：

package com.atangbiji.pojo;
//实体类
public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

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

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

Student.java文件：

package com.atangbiji.pojo;

import java.util.*;

//实体类
public class Student {
    //成员变量
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> card;//学生卡
    private Set<String> games;
    private String wife;//妻子（Null）
    private Properties info;//属性

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

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

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' + '\n' +
                ", address=" + address.toString() + '\n' +
                ", books=" + Arrays.toString(books) + '\n' +
                ", hobbies=" + hobbies + '\n' +
                ", card=" + card + '\n' +
                ", games=" + games + '\n' +
                ", wife='" + wife + '\'' + '\n' +
                ", info=" + info + '\n' +
                '}';
    }
}

（4）在子项目的resources目录下，新建一个beans.xml配置文件，用于配置Beans的元数据。

（5）在子项目的src/test/java目录下，新建一个MyTest测试类。

2.2、常量注入

beans.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就是那些组成我们应用程序的Java对象，由Spring中的IOC容器创建、组装和管理-->
    <!--（1）id：bean的唯一标识符。（相当于之前new的对象名）-->
    <!--（2）class：bean所对应对象的全限定类名。(全限定名=包名+类名)-->
    <!--（3）name：也是“别名”。-->
    <bean id="student" class="com.atangbiji.pojo.Student">
        <!--常量注入-->
        <property name="name" value="阿汤"/>
    </bean>
</beans>

2.3、Bean注入

beans.xml文件：

<bean id="address" class="com.atangbiji.pojo.Address">
    <property name="address" value="湖北省武汉市"/>
</bean>
<bean id="student" class="com.atangbiji.pojo.Student">
    <!--Bean注入-->
    <property name="address" ref="address"/>
</bean>

注：Bean注入时，value是一个引用，使用ref属性注入。

2.4、数组注入

beans.xml文件：

<bean id="student" class="com.atangbiji.pojo.Student">
    <!--数组注入-->
    <property name="books">
        <array>
            <value>红楼梦</value>
            <value>西游记</value>
            <value>水浒传</value>
            <value>三国演义</value>
        </array>
    </property>    
</bean>

2.5、List注入

beans.xml文件：

<bean id="student" class="com.atangbiji.pojo.Student">    
    <!--List注入-->
    <property name="hobbies">
        <list>
            <value>听歌</value>
            <value>编程</value>
            <value>看电影</value>
        </list>
    </property>    
</bean>

2.6、Map注入

beans.xml文件：

<bean id="student" class="com.atangbiji.pojo.Student">
    <!--Map注入-->
    <property name="card">
        <map>
            <entry key="身份证" value="888888888"/>
            <entry key="学生卡" value="123456789"/>
        </map>
    </property>
</bean>

2.7、Set注入

beans.xml文件：

<bean id="student" class="com.atangbiji.pojo.Student">
    <!--Set注入-->
    <property name="games">
        <set>
            <value>英雄联盟</value>
            <value>王者荣耀</value>
            <value>绝地求生</value>
        </set>
    </property>
</bean>

2.8、Null注入

beans.xml文件：

<bean id="student" class="com.atangbiji.pojo.Student">
    <!--Null注入-->
    <property name="wife">
        <null/>
    </property>    
</bean>

2.9、Properties（属性）注入

beans.xml文件：

<bean id="student" class="com.atangbiji.pojo.Student">    
    <!--Properties（属性）注入-->
    <property name="info">
        <props>
            <prop key="学号">20221125</prop>
            <prop key="用户名">root</prop>
            <prop key="密码">123456</prop>
        </props>
    </property>
</bean>

2.10、测试结果

MyTest.java文件：

import com.atangbiji.pojo.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void testDI(){
        //解析beans.xml文件，IOC容器生成并管理相应的Bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //通过Spring的上下文对象，从IOC容器中获取Bean对象
        Student student = (Student)context.getBean("student");
        //调用Bean对象的方法
        System.out.println(student.toString());
    }
}

运行测试程序，依赖注入成功。执行结果如下图所示：

3、p命名空间和c命名空间注入

首先，在子项目的com.atangbiji.pojo包下新建一个名称为User的实体类。

User.java文件：

package com.atangbiji.pojo;
//实体类
public class User {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

注：此时User实体类没有有参构造器，各属性依然要设置set方法。

然后，再在子项目的resources目录下，新建一个userBeans.xml配置文件，用于配置Beans的元数据。

3.1、p命名空间注入

通过P（properties，属性）命名空间注入，可以直接注入属性的值。它对应的就是Set方式注入，具体使用步骤如下：

（1）在xml配置文件的头部导入约束。

xmlns:p="http://www.springframework.org/schema/p"

（2）在bean标签中使用p命名空间注入。

userBeans.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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--bean就是那些组成我们应用程序的Java对象，由Spring中的IOC容器创建、组装和管理-->
    <!--（1）id：bean的唯一标识符。（相当于之前new的对象名）-->
    <!--（2）class：bean所对应对象的全限定类名。(全限定名=包名+类名)-->
    <!--通过P（properties，属性）命名空间注入, 可以直接注入属性的值。-->
    <bean id="user" class="com.atangbiji.pojo.User" p:name="阿汤" p:age="18"/>
</beans>

（3）测试。

MyTest.java文件：

import com.atangbiji.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void testDI2(){
        //userBeans.xml文件，IOC容器生成并管理相应的Bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("userBeans.xml");
        //通过Spring的上下文对象，从IOC容器中获取Bean对象
        User user = (User)context.getBean("user");
        //调用Bean对象的方法
        System.out.println(user.toString());
    }
}

运行测试程序testDI2，执行结果如下图所示：

 

3.2、c命名空间注入

通过C（Constructor，构造器）命名空间注入，也可以直接注入属性的值。它对应的就是构造器注入，具体使用步骤如下：

（1）在实体类中添加有参构造函数。

User.java文件：

//有参构造函数
public User(String name, int age) {
    this.name = name;
    this.age = age;
}

注：c命名空间注入的对象，其实体类必须要有有参构造函数。

（2）在xml配置文件的头部导入约束。

xmlns:c="http://www.springframework.org/schema/c"

（3）在bean标签中使用c命名空间注入。

userBeans.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:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--bean就是那些组成我们应用程序的Java对象，由Spring中的IOC容器创建、组装和管理-->
    <!--（1）id：bean的唯一标识符。（相当于之前new的对象名）-->
    <!--（2）class：bean所对应对象的全限定类名。(全限定名=包名+类名)-->
    <!--通过C（Constructor，构造器）命名空间注入, 可以直接注入属性的值。-->
    <bean id="user" class="com.atangbiji.pojo.User" c:name="阿汤" c:age="20"/>
</beans>

（4）再次运行测试程序testDI2，执行结果如下图所示：

之乎者也·
关注
  • 26
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring的配置及依赖注入(详细）
七一
08-11 1267
1、spring的配置 1.1、起别名 alias设置别名，为bean设置别名，可以设置多个别名 <!--设置别名：在获取Bean的时候可以使用别名获取--> <alias name="user" alias="user2"/> 1.2、bean的配置 <!--注册一个javabean到spring容器中,这里name属性也可以设置多个别名，--> <bean id="user" class="com.lili.entity.User" name="user3
spring注入list集合
小小少年的博客
05-15 9771
spring可以帮助我们自动的完成bean属性的注入，其中有一个比较特殊的，就是list集合 spring中，在使用@Autowired注解注入list集合的时候，并不会根据注入属性值的类型去容器中查找，而是根据list集合的元素类型，从spring容器中找到所有的实现类，放在list集合中，然后注入到bean中 ...
SpringBoot 常用注解总结超详细（面试）
最新发布
白白白鲤鱼的博客
04-27 1075
SpringBoot 常用注解总结超详细（面试工作总结）
依赖的注入方式有几种？各是什么？如何实现？
ManuMAX的博客
02-11 674
若有多种注入方式，每种方式只需注入指定几个依赖，那么就需要提供多个重载的构造函数，（复杂）。如果类A要使用别人提供的一个功能，若为了使用这功能，需要在自己的类中增加额外的代码，这就是侵入性。依赖类必须要实现指定的接口，然后实现该接口中的一个函数，该函数就是用于依赖注入。优点 ：接口注入中，接口的名字、函数的名字都不重要，只要保证函数的参数是要注入的对象类型即可。将被依赖对象通过构造函数的参数注入给依赖对象，并且在初始化对象的时候注。缺点： 依赖对象初始化完成后由于尚未注入被依赖对象，因此还不能使用。
java 注入方式_spring入门——3种注入方式
weixin_30624767的博客
02-13 1012
1. 属性注入声明成员属性的注入声明一个成员变量同时生成set方法成员属性类型分类：基本数据类型+String集合(List、set、map)自定义类都是在 bean 节点中，以子节点方式注入2. 构造方法注入都是在 bean 节点中，以子节点方式注入3.接口注入( spring 没有提供，所以可以不用研究)一、基本类型注入1. 创建 Test01 类，含一个基本数据类型的成员变量2. 在 bea...
Spring进阶（三）之依赖注入详解
weixin_56644618的博客
09-27 308
1. 本文主要讲解了xml中bean的依赖注入，都是采用硬编码的方式进行注入的，这种算是手动的方 式2. 注入普通类型通过value属性或者value元素设置注入的值；注入对象如果是容器的其他bean的时 候，需要使用ref属性或者ref元素或者内置bean元素的方式3. 还介绍了其他几种类型List、Set、Map、数组、Properties类型的注入，多看几遍加深理解4. 后面我们将介绍spring为我们提供的更牛逼的自动注入。
开源框架面试题系列集：Spring+SpringMVC+MyBatis.zip
08-29
Spring框架是Java开发中的一个全能型容器，它提供了依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）等核心特性，大大简化了企业级应用的复杂性。面试中，可能会涉及到以下...
2024年java面试题-SpringCloud面试题
04-22
微服务架构就是将单体的应用程序分成多个应用程序，这多个应用程序就成为微服务，每个...本资料提供了在java面试过程关于微服务SpringCloud方面的相关面试题，里面不乏有一些八股文，大伙儿该背还是要背一下！！！
Java、数据库、spring框架等面试题及答案
06-17
开源框架面试.pdf 多线程面试.pdf 并发编程面试（下）.pdf 并发编程（上）.pdf zookeeper面试.pdf Tomcat面试.pdf SQL优化面试.pdf Spring面试.pdf SpringMVC面试.pdf SpringCloud面试.pdf SpringBoot面试.pdf Redis...
Java-spring框架面试题
07-25
"Java-Spring框架面试题" 在本篇文章中，我们将详细讨论Java-Spring框架中的一些重要知识点，包括单例bean的线程安全性、AOP的应用、事务的实现、事务失效的场景、bean的生命周期、循环依赖等。 单例bean的线程...
java面试题，java基础，javaweb,spring,springmvc,mybatis等
10-19
Java 是一种广泛应用于软件开发的高级编程语言，以下是 Java 面试题相关知识点总结： 一、Java 基础部分 1. Java 源文件中是否可以包括多个类？可以，但是只能有一个 public 类，其他类可以是默认或私有的。 2. &&...
依赖注入的方式有几种，各是什么?
NZC2237的博客
01-14 817
依赖注入（Dependency Injection，DI）是一种设计模式，用于实现对象之间的解耦。在依赖注入中，依赖关系不是由对象自己创建或控制，而是由外部容器（通常是一个框架或容器）来注入。在实际应用中，通常会选择构造器注入或Setter方法注入，具体选择取决于需求和设计偏好。Spring框架等依赖注入容器通常支持这两种方式。
详解Spring@AutoWired多种方式的依赖注入——List，Map类型
qq_43842093的博客
12-13 1569
在Spring框架进行bean对象依赖注入时，@Autowired利用可以对成员变量、方法和构造函数进行标注，来完成自动装配的工作。@Autowired可标注在成员变量，也可以标注在成员变量的set方法上，以及类得构造函数上。对于标注在成员变量上的方式，通常的做法是标注在单个类型的变量上，Spring框架提供了强大的DI能力能够实现对Collection类型的自动注入。
依赖注入的几种方式
薛定谔的猫的博客
07-18 1941
对象装配的实现方法有3种：1.属性注入；2.构造方法注入；3.Setter注入。再讲本节内容之前，我们先来提两个传参的方式，首先呢，上节的文章里边，我们提到了五大类注解和@Bean注解，@Bean注解式可以传参的，他的方式就是：这就是@bean的传参，很简单，但是有几个需要注意的点：1.@bean传参的时候记得给配置参数的方法也要加上@bean注解，一定要加上，否则会报错；3.还有一个问题就是，大家可以看到上边写了参数匹配的方法，但是是什么样的匹配规则呢？
Spring系列之依赖注入的方式
weixin_34319999的博客
09-26 1568
一、依赖注入方式       对于spring配置一个bean时，如果需要给该bean提供一些初始化参数，则需要通过依赖注入方式，所谓的依赖注入就是通过spring将bean所需要的一些参数传递到bean实例对象的过程，spring的依赖注入有3种方式： ·使用属性的setter方法注入 ，这是最常用的方式；·使用构造器注入；·使用Filed注入（用于注解方式）。 1.使用属性注入    ...
这6种 Spring 依赖注入方式，你都会吗？
m0_73311735的博客
06-29 529
Spring框架提供了多种依赖注入方式，包括构造器注入、Setter方法注入、接口注入、自动装配、注解注入和Java配置等。不同的注入方式适用于不同的场景，开发人员可以根据具体需求选择合适的方式。依赖注入使得应用程序的组件之间解耦合，提高了代码的可测试性、可维护性和可扩展性。通过灵活使用Spring框架提供的依赖注入方式，可以更加方便地管理和维护应用程序的依赖关系，从而提升开发效率和代码质量。在实际开发中，根据具体的需求和项目特点，我们可以组合使用不同的依赖注入方式。
依赖注入的三种方式
热门推荐
weixin_45723046的博客
03-24 1万+
DI(依赖注入) 注入的三种方法：构造器方法注入，set注入，基于注解的注入（接口注入） 1：构造器方法注入 创建一个Address类； public class Address { private String address; public Address() { } public Address(String address) { this.address = address; } public String getAddre
spring注入List集合
m0_67401606的博客
04-27 1177
【例】spring注入List集合 创建User类 package com.shw; public class User { private String username; private String password; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public Strin
Java-Spring面试题大全: Spring的优点、DI实现方式和ORM框架支持
在Spring中，实现依赖注入的几种方式有： 1. 接口注入：在实际中广泛应用的方式，即使在控制反转的概念尚未确立时，这种方式已经频繁出现在代码中。 2. Setter注入：在对象创建之后，通过set方法将依赖对象设置进去...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

之乎者也·

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值