Spring依赖注入的几种方式

最新推荐文章于 2024-07-23 22:36:48 发布
最新推荐文章于 2024-07-23 22:36:48 发布
阅读量4.1k 收藏 13
点赞数 4
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BruceLiu_code/article/details/86712825
版权

1.依赖注入

测试类:Person.java
创建配置文件：applicationContext-injection.xml
创建测试代码：InjectionTest.java

1.1 set方法注入

1.1.1基本类型值注入

使用value

  • 配置:
  <!-- value值为基本类型 -->
  <bean name="person"  class="com.bruceliu.spring.bean.Person" >
       <property name="name" value="jeck" />
       <property name="age" value="11"/>
  </bean>
  • 测试代码:
  @Test
  public  void  test1(){
        //TODO 测试基本数据类型注入数据
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-injection.xml");
        Person person = context.getBean("person", Person.class);
        System.out.println("person = " + person);
		//输出结果:------------> Person.Person
		//person = Person{name='jeck', age=11}
 }

1.2 引入类型值注入

  • 使用ref
    创建 Car.java:
public class Car {
    private String name;
    private String color;
    
    public Car() {
        super();
        System.out.println("Car的空参构造方法");
    }
    //getter、setter、toString
}
  • 修改Person.java,在Person中引入Car:
public class Person {

    private String name;
    private Integer age;
    private Car car;
 	//构造方法 getter setter toString方法 
}
  • 配置:利用ref属性给 person的car属性赋值
  <bean name="person1" class="com.bruceliu.spring.bean.Person">
      <property name="name" value="helen"></property>
      <property name="age" value="18"></property>
      <property name="car" ref="car"></property>
  </bean>
    
  <bean name="car" class="com.bruceliu.spring.bean.Car">
      <property name="name" value="MINI"></property>
      <property name="color" value="灰色" ></property>
  </bean>

1.2 构造函数注入

1.2.1 单个有参构造方法注入
  • 在Person中创建有参构造函数:
 public  Person(String  name , Car car){
        this.name = name;
        this.car = car;
        System.out.println("Person的有参构造方法:"+name+car);
 }
  • 配置:
<bean name="person" class="com.bruceliu.spring.bean.Person">
           <constructor-arg name="name" value="rose"/>
           <constructor-arg name="car"  ref="car"/>
 </bean>
 <!-- 构造函数car时候引入 -->
 <bean name="car"  class="com.bruceliu.spring.bean.Car" >
           <property name="name" value="mime"/>
           <property name="color" value="白色"/>
 </bean>
  • 测试:
  @Test
  public  void test2(){
		//TODO 测试参构造方法
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-injection.xml");

        Person person = context.getBean("person", Person.class);

        System.out.println(person);
index属性
  • 按参数索引注入
    参数名一致，但位置不一致时，使用 index
    例如以下两个构造函数（第二个是新添加）：
    public Person(String name, Car car) {
        super();
        System.out.println("Person(String name, Car car)");
        this.name = name;
        this.car = car;
    }
    
    public Person(Car car, String name) {
        super();
        System.out.println("Person(Car car, String name)");
        this.name = name;
        this.car = car;
    }
  • 配置：使用 index 确定调用哪个构造函数
    <bean name="person2" class="com.bruceliu.spring.bean.Person">
        <constructor-arg name="name" value="helen" index="0"></constructor-arg>
        <constructor-arg name="car" ref="car" index="1"></constructor-arg>
    </bean>
  • 测试：
    重新执行第一步的测试用例，执行结果调用了第一个构造函数
type属性
  • 按参数类型注入
    参数名和位置一致，但类型不一致时，使用type
    例如以下两个构造函数（第二个是新添加）：
    public Person(Car car, String name) {
        super();
        System.out.println("Person(Car car, String name)");
        this.name = name;
        this.car = car;
    }
    
    public Person(Car car, Integer name) {
        super();
        System.out.println("Person(Car car, Integer name)");
        this.name = name + "";
        this.car = car;
    }
  • 配置：使用type指定参数的类型
    <bean name="person2" class="com.bruceliu.spring.bean.Person">
        <constructor-arg name="name" value="988" type="java.lang.Integer"></constructor-arg>
        <constructor-arg name="car" ref="car" ></constructor-arg>
    </bean>
  • 测试：
    重新执行前面的测试用例，执行结果调用了第二个构造函数

1.3 p名称空间注入

导入p名称空间:
使用p:属性名 完成注入,走set方法
基本类型值: p:属性名=“值”
引入类型值: P:属性名-ref=“bean名称”

  • 配置:
//1.第一步配置文件中 添加命名空间p 
 xmlns:p="http://www.springframework.org/schema/p"

<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.xsd">
  
       //使用 p命称空间进行赋值
        <bean name="person" class="com.bruceliu.spring.bean.Person"  p:name="人名" p:age="11"    p:car-ref="car">

       </bean>

       <bean name="car"  class="com.bruceliu.spring.bean.Car" >
           <property name="name" value="mime" />
           <property name="color" value="白色"/>
       </bean>
  • 测试:
@Test
public  void test2(){
	//TODO 测试p命名空间注入
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-injection.xml");
    Person person = context.getBean("person", Person.class);
    System.out.println(person);
 }

1.4 spel注入

spring Expression Language：spring表达式语言

  • 配置:
 <bean name="car"  class="com.bruceliu.spring.bean.Car" >
           <property name="name" value="mime" />
           <property name="color" value="白色"/>
  </bean>

   <!--利用spel引入car的属性 -->
   <bean  name="person1"  class="com.bruceliu.spring.bean.Person"  p:car-ref="car">
            <property name="name" value="#{car.name}"/>
            <property name="age" value="#{person.age}"/>

   </bean>
  • 测试
@Test
public  void test3(){
	//TODO 测试spel注入
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-injection.xml");
    Person person = context.getBean("person1", Person.class);
    System.out.println(person);
	
 }

1.5 复杂类型注入

创建配置文件:application-collection.xml
创建测试代码:CollectionTest.java
创建测试实体类:TestCollection

  • 创建TestCollection:
/**
 * arr list map properties的注入
 */
public class TestCollection {

    private Object [] arrs;
    private List<Object> list;
    private Map<String,Object> map;
    private Properties properties;

    public Object[] getArrs() {
        return arrs;
    }

    public void setArrs(Object[] arrs) {
        this.arrs = arrs;
    }

    public List<Object> getList() {
        return list;
    }

    public void setList(List<Object> list) {
        this.list = list;
    }

    public Map<String, Object> getMap() {
        return map;
    }

    public void setMap(Map<String, Object> map) {
        this.map = map;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "TestCollection{" +
                "arrs=" + Arrays.toString(arrs) +
                ", list=" + list +
                ", map=" + map +
                ", properties=" + properties +
                '}';
    }
}
  • 配置:
<?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 name="car" class="com.bruceliu.spring.bean.Car">
             <property name="name" value="保时捷"/>
             <property name="color" value="红色" />
       </bean>


       <bean name="testColl" class="com.bruceliu.spring.bean.TestCollection">

           <!-- 数组变量注入 -->
           <property name="arrs">
               <list>
                   <value>数组1</value>
                   <!--引入其他类型-->
                   <ref bean="car"/>
               </list>
           </property>

           <!-- 集合变量赋值-->
           <property name="list">
                <list>
                    <value>集合1</value>
                    <!--集合变量内部包含集合-->
                    <list>
                        <value>集合中的集合1</value>
                        <value>集合中的集合2</value>
                        <value>集合中的集合3</value>
                    </list>
                    <ref bean="car" />
                </list>
           </property>

           <!--map赋值 -->
           <property name="map">
               <map>
                   <entry key="car" value-ref="car" />
                   <entry key="name" value="保时捷" />
                   <entry key="age"  value="11"/>
               </map>

           </property>

           <!-- properties赋值 -->
           <property name="properties">
                <props>
                    <prop key="name">pro1</prop>
                    <prop key="age">111</prop>
                </props>
           </property>
       </bean>

</beans>
  • 测试:
 @Test
 public  void  test4(){
        //复杂类型注入练习
     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-collection.xml");
     TestCollection textColl = context.getBean("testColl", TestCollection.class);
     System.out.println("testColl = " + textColl);
   }
熊猫-IT
关注
专栏目录
【Spring依赖注入的三种方式】
学无止境
03-05 398
【spring依赖注入的三种方式】
Spring依赖注入的方式
04-19
NULL 博文链接：https://huangminwen.iteye.com/blog/1041743
Spring依赖注入方式
ganshisheng的专栏
04-06 310
一、依赖注入（DI）简介     依赖注入背后的基本原理是对象之间的依赖关系,可以通过以下几种方式来实现：构造器的参数、工厂方法的参数，或给由构造函数或者工厂方法创建的对象设置属性。因此，容器的工作就是创建bean时注入那些依赖关系。相对于由bean自己来控制其实例化、直接在构造器中指定依赖关系或者类似服务定位器模式这3种自主控制依赖关系注入的方法来说，控制从根本上发生了倒转，这也正是控制反转名字
(十二)Spring教程——依赖注入之构造函数注入
最新发布
07-23 1262
构造函数注入是除属性注入外的另一种常用的注入方式，它保证一些必要的属性在Bean实例化时就得到设置，确保Bean在实例化后就可以使用。
spring 注入方式
海子
03-21 544
平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我们程序员，而...
Spring系列之依赖注入的方式
weixin_34319999的博客
09-26 1619
一、依赖注入方式       对于spring配置一个bean时，如果需要给该bean提供一些初始化参数，则需要通过依赖注入方式，所谓的依赖注入就是通过spring将bean所需要的一些参数传递到bean实例对象的过程，spring的依赖注入有3种方式： ·使用属性的setter方法注入 ，这是最常用的方式；·使用构造器注入；·使用Filed注入（用于注解方式）。 1.使用属性注入    ...
spring依赖注入
weixin_30537391的博客
08-21 57
使用构造器注入 使用属性setter方法注入 使用Field注入（用于注解方式） 注入依赖对象可以采用手工装配或自动装配，在实际应用中建议使用手工装配，因为自动装配会产生未知情况,开发人员无法预见最终的装配结果。 1.手工装配依赖对象 手工装配依赖对象，在这种方式中又有两种编程方式 * 在xml配置文件中...
关于Spring依赖注入的几种方式
哎喵泡泡的专栏
09-06 4242
今天在开发的过程中，突然对Spring的依赖注入几种方式出现混交，打算做个简单的小结，如有总结不对的地方，请大家不吝指教！在Spring中依赖注入有四种方式：set注入(通常也叫属性注入)，构造函数注入，接口注入(这个现在基本不用)，注解注入(@Autowire)，下面对set方法注入，构造函数注入，以及注解注入的用法举例说明。1、set方法注入(属性注入) UserDao.javapublic
Spring 依赖注入的几种方式详解
08-31
在Spring中，依赖注入可以通过XML配置文件实现，本文将重点介绍两种常见的注入方式：Set注入和构造器注入。 1. Set注入 Set注入是最常见的注入方式，适用于对象没有默认构造函数或构造函数不接受参数的情况。首先，...
spring学习：依赖注入的几种方式讨论
08-09
Spring Boot引入了一种更智能的依赖注入方式——自动配置。自动配置是通过`@EnableAutoConfiguration`注解启动的，它根据项目中的类路径和特定条件自动配置Bean。例如，如果类路径下存在`MongoClient`的jar，Spring ...
Spring依赖注入的三种方式实例详解
01-08
Spring依赖注入（DI）的三种方式，分别为： 1． 接口注入 2． Setter方法注入 3． 构造方法注入 下面介绍一下这三种依赖注入在Spring中是怎么样实现的。 首先我们需要以下几个类： 接口 Logic.java 接口实现类 LogicImpl.java 一个处理类 LoginAction.java 还有一个测试类 TestMain.java Logic.java如下： package com.spring.test.di; public interface Logic { public String getName(); } LogicImpl.java如下： p
Spring 核心机制（依赖注入）
03-06
全面的Spring 核心机制 依赖注入 的描述，运用，实例开发运用,
依赖注入的方式有几种，各是什么?
NZC2237的博客
01-14 887
依赖注入（Dependency Injection，DI）是一种设计模式，用于实现对象之间的解耦。在依赖注入中，依赖关系不是由对象自己创建或控制，而是由外部容器（通常是一个框架或容器）来注入。在实际应用中，通常会选择构造器注入或Setter方法注入，具体选择取决于需求和设计偏好。Spring框架等依赖注入容器通常支持这两种方式。
spring依赖注入的方式
layAlex的博客
03-30 209
摘要 Spring 为何如此流行?我们用 Spri...
Spring——依赖注入的方式
万里顾一程的博客
04-08 208
文章目录Spring——依赖注入的方式1、构造器注入2、Set注入方式（常用）3、拓展方式注入 Spring——依赖注入的方式 依赖注入(DI) 依赖注入(DI)是一个过程，通过该过程，对象只能通过构造函数参数，工厂方法的参数或在构造或创建对象实例后在对象实例上设置的属性来定义其依赖关系(即，与它们一起工作的其他对象)。从工厂方法返回。然后，容器在创建 bean 时注入那些依赖项。从根本上讲，此过程是通过使用类的直接构造或服务定位器模式来自己控制其依赖关系的实例化或位置的 Bean 本身的逆过程(因此称为
Spring依赖注入的方式有几种
05-03
Spring依赖注入的方式有以下几种： 1. 构造器注入（Constructor Injection）：通过构造器来注入依赖项。这种方式可以保证依赖项不可变，并且可以确保依赖项在创建对象时已经初始化。 2. Setter方法注入（Setter ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

熊猫-IT

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

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

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

打赏作者

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

抵扣说明：

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

余额充值