【Spring】依赖注入的几种方式

最新推荐文章于 2024-08-22 01:24:27 发布
最新推荐文章于 2024-08-22 01:24:27 发布
阅读量3.2k 收藏 26
点赞数 5
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43418737/article/details/122565736
版权

        在上篇文章中我着重介绍了Spring的控制反转和依赖注入的概念，那么依赖注入有那几种方式呢？他们的优缺点分别是什么，我将在本章中详细讲解。

        Spring的依赖注入根据对象类型注入可以分为属性注入和对象注入，根据注入的方式可以分成xml配置文件注入和注解注入，其中xml有三种注入方式：

  1. 构造方法注入；
  2. setter方法注入；
  3. p名称空间注入。

注意：P名称空间为特殊的setter方法注入，因此也有人说xml有两种注入方式，本文为了详细介绍，所以分开讲解。

注解注入的方式分成三种：

  1. 构造方法注入；
  2. setter方法注入；
  3. 自动注入。

一、对象注入

1.1、xml文件注入

1.1.1、构造方法注入

public class A {

    private B b;

    private String name;

    public void a(){
        b.b();
        System.out.println("A中a方法执行了，name=" + name);
    }

    public A(B b, String name) {
        this.b = b;
        this.name = name;
    }
}
public class B {

    private String name;

    private Double age;

    public B(String name, Double age) {
        this.name = name;
        this.age = age;
    }

    public void b(){
        System.out.println("B中b方法执行了，name=" + name + ",age=" + age);
    }
}
    <!--创建B的Bean对象-->
    <!--
        constructor-arg:构造函数赋值，
        注意：需要提供一个有参的构造函数
        有以下取值：
            name：构造函数所需要的参数名称
            value：参数名称对应的值
            ref：参数为其他bean
            type:指定参数在构造函数中的数据类型
            index:指定参数在构造函数中的索引位置 -->
    <bean id="b" class="com.sxx.service.entity.B">
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="age" value="12.58"/>
    </bean>

    <bean name="a" class="com.sxx.service.entity.A">
        <constructor-arg name="b" ref="b"/>
        <constructor-arg name="name" value="王五"/>
    </bean>
public class IocTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean.xml");
        A a = (A) applicationContext.getBean("a");
        a.a();
    }
}

B中b方法执行了，name=张三,age=12.58
A中a方法执行了，name=王五

1.1.2、set方法注入

public class A {

    private B b;

    private String name;

    public void a(){
        b.b();
        System.out.println("A中a方法执行了，name=" + name);
    }
}
public class B {

    private String name;

    private String age;

    public void b(){
        System.out.println("B中b方法执行了，name=" + name + ",age=" + age);
    }
}
    <!--创建B的Bean对象-->
     <!--
        property:赋值属性，有以下取值：
            name：类中的属性值，实际找的是set方法对应的属性，比如setName -> name才能在此赋值，没有set方法会报错；
            value：给属性赋值，基本数据和String类型的用此种方法；
            ref：属性赋值是其他bean类型的
    -->
    <bean id="b" class="com.sxx.service.entity.B">
        <property name="name" value="张三"/>
        <property name="age" value="12"/>
    </bean>
     <bean name="a" class="com.sxx.service.entity.A">
        <property name="name" value="李四"/>
        <!--ref指向的是上面id="b"-->
        <property name="b" ref="b"/>
    </bean>
public class IocTest {
    public static void main(String[] args) {
       ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean.xml");
        A a = (A) applicationContext.getBean("a");
        a.a();
        B b = (B) applicationContext.getBean("b");
        b.b();
    }
}

 结果如下：

B中b方法执行了，name=张三,age=12.58
A中a方法执行了，name=李四
B中b方法执行了，name=张三,age=12.58

1.1.3、P名称空间注入

public class A {

    private B b;

    private String name;

    public void a(){
        b.b();
        System.out.println("A中a方法执行了，name=" + name);
    }
}
public class B {

    private String name;

    private Double age;

    public void b(){
        System.out.println("B中b方法执行了，name=" + name + ",age=" + age);
    }
}
<?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-3.0.xsd">
    <bean id="a" class="com.sxx.service.entity.A"
            p:name="李四" p:b-ref="b">
    </bean>
    <bean id="b" class="com.sxx.service.entity.B">
        <property name="name" value="张三"/>
        <property name="age" value="12.58"/>
    </bean>

</beans>
public class IocTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean.xml");
        A a = (A) applicationContext.getBean("a");
        a.a();
    }
}

B中b方法执行了，name=张三,age=12.58
A中a方法执行了，name=李四

1.2、注解注入

1.2.1、构造方法注入

public class A {

    private B b;

    private String name;

    public void a(){
        b.b();
        System.out.println("A中a方法执行了，name=" + name);
    }

    public A(B b, String name) {
        this.b = b;
        this.name = name;
    }
}
public class B {

    private String name;

    private Double age;

    public void b(){
        System.out.println("B中b方法执行了，name=" + name + ",age=" + age);
    }

    public B(String name, Double age) {
        this.name = name;
        this.age = age;
    }
}
@Configuration
public class BeanConfig {
    @Bean("b")//指定name=b，而非默认B
    public B B(){
       return new B("张三", 12.4D);
    }
    @Bean
    public A a(){
       return new A(B(), "李四");
    }
}
<?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">
    <!--添加spring扫描，范围是com.sxx下所有包及其子包-->
    <context:component-scan base-package="com.sxx"/>
</beans>
public class IocTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean.xml");
        A a = (A) applicationContext.getBean("a");
        a.a();
    }
}

B中b方法执行了，name=张三,age=12.4
A中a方法执行了，name=李四

1.2.2、setter方法注入

public class A {

    private B b;

    private String name;

    public void a(){
        b.b();
        System.out.println("A中a方法执行了，name=" + name);
    }
}
public class B {

    private String name;

    private Double age;

    public void b(){
        System.out.println("B中b方法执行了，name=" + name + ",age=" + age);
    }
}
<!--添加spring扫描，范围是com.sxx下所有包及其子包-->
<context:component-scan base-package="com.sxx"/>
@Configuration
public class BeanConfig 
    @Bean
    //如果没有指定A在Ioc容器中的key，默认为方法名
    public B b(){
        B b = new B();
        b.setName("张三");
        b.setAge(20D);
        return b;
    }
    @Bean
    //如果没有指定A在Ioc容器中的key，默认为方法名
    public A a(){
        A a = new A();
        //引入的是上面的b()方法
        a.setB(b());
        a.setName("李四");
        return a;
    }
}
public class IocTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean.xml");
        A a = (A) applicationContext.getBean("a");
        a.a();
    }
}

B中b方法执行了，name=张三,age=20.0
A中a方法执行了，name=李四

1.2.3、自动注入

        自动注入最具代表性的就是@Resource和@Autowired两个注解，在容器中只存在单一对象的时候，两个注解功能都相同，可以相互的替换，不影响使用。

        但是如果存在多个对象的时候，@Autowired只根据type进行注入，不会去匹配name。如果涉及到type无法辨别注入对象时，那需要依赖@Qualifier或@Primary注解一起来修饰。

        @Resource 是JDK1.6支持的注解， 默认按照name进行装配，名称可以通过name属性进行指定，如果没有指定name属性，当注解写在字段上时，默认取字段名，按照名称查找。如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

1.3、注解注入的另外一种形式

        上面我们列举的注解注入的方法是通过在配置文件BeanConfig实现依赖注入的方式，还有另外一种方式可以直接在class文件中直接用@Resource或@Autowired直接引入。

1.3.1、构造方法注入

@Component
public class A {

    private B b;

    private String name;

    public void a(){
        b.b();
        System.out.println("A中a方法执行了，name=" + name);
    }

    @Autowired
    public A(B b) {
        this.b = b;
    }
}
@Component
public class B {

    private String name;

    private Double age;

    public void b(){
        System.out.println("B中b方法执行了，name=" + name + ",age=" + age);
    }
}
 <!--添加spring扫描，范围是com.sxx下所有包及其子包-->
 <context:component-scan base-package="com.sxx"/>
public class IocTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean.xml");
        A a = (A) applicationContext.getBean("a");
        a.a();
    }
}

B中b方法执行了，name=null,age=null
A中a方法执行了，name=null

1.3.2、setter方法注入

@Component
public class A {
    private B b;

    private String name;

    public void a(){
        b.b();
        System.out.println("A中a方法执行了，name=" + name);
    }

    @Autowired
    public void setB(B b) {
        this.b = b;
    }
}

其他方法及结果参照1.3.1 

1.3.3、直接注入

@Component
public class A {
    @Autowired
    private B b;

    private String name;

    public void a(){
        b.b();
        System.out.println("A中a方法执行了，name=" + name);
    }
}

其他方法及结果参照1.3.1

二、参数注入

 参数注入主要是通过@Value注入

@Component
public class A {
    @Autowired
    private B b;

    @Value("李四")
    private String name;

    public void a(){
        b.b();
        System.out.println("A中a方法执行了，name=" + name);
    }
}
@Component
public class B {

    @Value("张三")
    private String name;

    @Value("20.4")
    private Double age;

    public void b(){
        System.out.println("B中b方法执行了，name=" + name + ",age=" + age);
    }
}

其他配置可以参照其他依赖注入的方式

结果为：

B中b方法执行了，name=张三,age=20.4
A中a方法执行了，name=李四

注意：@Value不仅可以自己配置属性还可以从配置文件或者配置中心中获取对应的属性 

三、几种依赖注入的优缺点对比 

3.1、构造器注入

        优点：基于构造器注入，会固定依赖注入的顺序，不允许我们创建的bean对象之间存在循环依赖关系，这样Spring能解决循环依赖的问题。

        缺点：使用构造器注入的缺点是，当我们构造器需要注入的对象比较多时，会显得我们的构造器，冗余，不美观，可读性差，也不易维护。

3.2、基于setter方法注入

        优点：基于setter注入，只有对象是需要被注入的时候，才会注入依赖，而不是在初始化的时候就注入。

        缺点：当我们选择setter方法来注入的时候，我们不能将对象设为final的；

3.3、基于自动注入

        优点：在成员变量上写上注解来注入，这种方式，精短，可读性高，不需要多余的代码，也方便维护。

        缺点：

                1.这样不符合JavaBean的规范，而且很有可能引起空指针；

                2.同时也不能将对象标为final的；

                3.类与DI容器高度耦合，我们不能在外部使用它；

                4.类不通过反射不能被实例化（例如单元测试中），你需要用DI容器去实例化它，这更像集成测试；

【Spring依赖注入的三种方式】
学无止境
03-05 433
【spring依赖注入的三种方式】
Spring依赖注入的方式
04-19
NULL 博文链接：https://huangminwen.iteye.com/blog/1041743
Spring系列之依赖注入的方式
weixin_34319999的博客
09-26 1686
一、依赖注入方式       对于spring配置一个bean时，如果需要给该bean提供一些初始化参数，则需要通过依赖注入方式，所谓的依赖注入就是通过spring将bean所需要的一些参数传递到bean实例对象的过程，spring的依赖注入有3种方式： ·使用属性的setter方法注入 ，这是最常用的方式；·使用构造器注入；·使用Filed注入（用于注解方式）。 1.使用属性注入    ...
Spring依赖注入的三种方式详解与实践
最新发布
m0_62153576的博客
08-22 511
在Spring框架中，依赖注入（DI）是一种核心概念，它允许我们以一种松耦合的方式管理组件之间的依赖关系。本文将详细介绍Spring中三种依赖注入的方式，并结合实例代码进行说明。
Spring依赖注入的几种方式
QING的博客
08-11 2559
一. 三种依赖注入 1. 字段注入 @Autowire private ExampleService exampleServiceImpl; 这种注入方式存在三个明显缺陷： 对象的外部可见性：也就是脱离了Spring容器那么这个对象就不会被注入进去。 循环依赖：字段注入不会被检测是否出现依赖循环。比如A类中注入B类，B类中又注入了A类。 无法设置注入对象为final：因为final的成员变量必须在实例化时同时赋值。 2. 构造器注入 private ExampleService exampleSer
Spring中依赖注入的四种方式
weixin_33756418的博客
11-21 1400
转载自：http://blog.163.com/qqabc20082006@126/blog/static/2292852520091125112112902/在Spring容器中为一个bean配置依赖注入有三种方式：· 使用属性的setter方法注入 这是最常用的方式；· 使用构造器注入；· 使用Filed注入（用于注解方式）.使用属性的setter方法注入首先要配置被注...
Spring 依赖注入的几种方式详解
08-31
在Spring中，依赖注入可以通过XML配置文件实现，本文将重点介绍两种常见的注入方式：Set注入和构造器注入。 1. Set注入 Set注入是最常见的注入方式，适用于对象没有默认构造函数或构造函数不接受参数的情况。首先，...
spring学习：依赖注入的几种方式讨论
08-09
Spring Boot引入了一种更智能的依赖注入方式——自动配置。自动配置是通过`@EnableAutoConfiguration`注解启动的，它根据项目中的类路径和特定条件自动配置Bean。例如，如果类路径下存在`MongoClient`的jar，Spring ...
Spring框架学习教程，详解Spring注入bean的几种方式
Java___interview的博客
09-29 1434
首先，要学习Spring中的Bean的注入方式，就要先了解什么是依赖注入。 依赖注入是指：让调用类对某一接口的实现类的实现类的依赖关系由第三方注入，以此来消除调用类对某一接口实现类的依赖。 Spring容器中支持的依赖注入方式主要有属性注入、构造函数注入、工厂方法注入。 接下来将为大家详细介绍这三种依赖注入的方式以及它们的具体配置方法。 1. 属性注入 属性注入即通过setXXX( )方法注入bean的属性值或依赖对象。由于属性注入方式具有可选择性和灵活性高的特点，因此它也是实际开发中最常用的
Spring依赖注入有哪些方式？
qq_46138725的博客
06-14 2389
有4中注入方式： 1.Set方法注入：注入最简单，最常用的注入方式，支持注解+xml。 2.构造器注入：是指带有参数的构造函数注入，支持注解+xml 3.静态工厂的方式注入：通过调用静态工厂的方法来获取自己需要的对象，只支持xml。 4.实例工厂的方式注入：获取对象实例的方法不是静态的，所以需要new一个工厂类，再调用普通的实例方法，只支持xml。 有两种实现方式： 1.注解（@Autowired,@Resource,@Required） 2.配置文件（xml） 简要回答 1.set注入，构造器注入，静态工
Spring中有几种依赖注入的方式
Tom弹架构
12-27 594
文末整理了一些我整理的从小白到架构师的学习资料，价值很高！Spring中，依赖注入的方式主要有以下三种：1、通过构造器注入，这也是Spring官方推荐的方式，如代码所示：这种方式，在注入对象很多的情况下，构造器参数列表会很长，所以，不够灵活。当然，好处就是，对象初始化完成后，就可可获得可使用的对象。另外，还可以检测循环依赖。2、通过Setter方法注入，这种方式在日常开发中不太常见，如代码所示：这种方式是利用set方法来注入，可以确保注入前不依赖Spring容器。
Spring实现依赖注入的几种方式
一只九菜的博客
06-15 532
1.通过构造器注入 1.1无参构造 1.2有参工 2.通过set注入 3.通过其它方式注入
Spring依赖注入的三种方式
热门推荐
weixiaohuai的博客
10-26 1万+
目录 一、变量注入（Field Injection） 二、构造器注入（Constructor Injection） 三、setter方法注入 （Setter Injection） 四、使用场景 Spring的依赖注入，我们一般使用@Autowired注解来完成，关于依赖注入一般有三种方式： 变量注入、构造器注入、setter方法注入，下面我们仔细分析一下三种注入方式各自的特点以及使用场景。 一、变量注入（Field Injection） 先看看怎么使用： @Service public
Spring 依赖注入有几种？各有什么优缺点？
CYK_byte的博客
02-07 2661
本篇文章主要内容来自于“Java中文社群”，真的写的太棒了！同时融入我自己的理解，希望能帮助到大家更加深入的去理解Spring注解注入的方式及优缺点！面试不再担忧~
spring 依赖注入的三种方式
qq_33732195的博客
12-07 2213
@Autowired：构造器，参数，方法，属性；都是从容器中获取参数组件的值； 1）、set方法注入； 2）、构造器注入； 3）、作为Bean方法的参数注入； 例子：Boss 注入Car类 第一种、set方式注入 //Car类 package com.spring.bean; @Component public class Car { public Car() { System.out.println("car...constructor"); } } //Boss类 package com.sp
Spring依赖注入的方式有几种
05-03
Spring依赖注入的方式有以下几种： 1. 构造器注入（Constructor Injection）：通过构造器来注入依赖项。这种方式可以保证依赖项不可变，并且可以确保依赖项在创建对象时已经初始化。 2. Setter方法注入（Setter Injection）：通过setter方法来注入依赖项。这种方式可以灵活地对依赖项进行修改，但是不能确保依赖项在对象创建时已经初始化。 3. 接口注入（Interface Injection）：通过接口来注入依赖项。这种方式需要实现一个特定的接口来提供依赖项的实现。 4. 注解注入（Annotation Injection）：通过注解来注入依赖项。这种方式可以在代码中使用注解来声明依赖项，使代码更加简洁清晰。常见的注解有@Autowired和@Resource等。 5. 自动装配（Autwiring）：Spring框架会自动根据依赖项的类型和名称来自动装配依赖项。这种方式可以减少配置工作，但是需要注意依赖项的名称和类型的匹配问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值