据我所学,spring实现依赖注入(DI)的方式分为三大类:基于构造器(构造方法)的依赖注入、基于setter的依赖注入、其他方式(c命名空间、p命名空间等)。其中推荐使用setter方法注入,这种注入方式也是最多人使用的。

下面我们通过代码来举例三种注入方式:

1.基于构造器(构造方法)的依赖注入

这种方式是通过实体类中的构造方法来完成属性的赋值,所以实体类中必须含有带参的构造方法!

首先先编写实体类User,如下:

  1. public class User {
  2. private int id;
  3. private String name;
  4. private int age;
  5. private String pwd;
  6.  
  7. public User() {
  8. }
  9. public User(int id, String name, int age, String pwd) {
  10. this.id = id;
  11. this.name = name;
  12. this.age = age;
  13. this.pwd = pwd;
  14. System.out.println("User的全参构造");
  15. }
  16.  
  17. @Override
  18. public String toString() {
  19. return "User{" +
  20. "id=" + id +
  21. ", name='" + name + '\'' +
  22. ", age=" + age +
  23. ", pwd='" + pwd + '\'' +
  24. '}';
  25. }
  26. }

然后我们就可以编写配置文件了,一共有三种方式,这三种方式都是一样的,掌握一种便可以了,推荐使用方式一。

方式一:通过属性名称赋值

  1. <bean id="user" class="com.kuang.pojo.User">
  2. <constructor-arg name="id" value="0000"/>
  3. <constructor-arg name="age" value="21"/>
  4. <constructor-arg name="pwd" value="123456"/>
  5. <constructor-arg name="name" value="张三"/>
  6. </bean>

方式二:通过下标赋值

注意:这里index就是实体类中属性的索引,从0开始,实体类中从上到下第一个属性的索引为0,第二个属性的索引为1....以此类推。

  1. <!--通过下标赋值-->
  2. <bean id="user" class="com.kuang.pojo.User">
  3. <constructor-arg index="0" value="0000"/>
  4. <constructor-arg index="1" value="张三"/>
  5. <constructor-arg index="2" value="21"/>
  6. <constructor-arg index="3" value="123456"/>
  7. </bean>

方式三:通过类型赋值

  1. <bean id="user" class="com.kuang.pojo.User">
  2. <constructor-arg type="int" value="0000"/>
  3. <constructor-arg type="java.lang.String" value="张三"/>
  4. <constructor-arg type="int" value="21"/>
  5. <constructor-arg type="java.lang.String" value="123456"/>
  6. </bean>

2.基于setter的依赖注入

这种方式是通过实体类中的setter方法来完成属性的赋值的,所以实体类中必须有各个属性的setter方法!

Student实体类如下:

  1. public class Student {
  2. private String name;
  3. private Address address;
  4. private String[] books;
  5. private List<String> hobbys;
  6. private Map<String,String> card;
  7. private Set<String> game;
  8. private String wife;
  9. private Properties info;
  10.  
  11. public String getName() {
  12. return name;
  13. }
  14.  
  15. public void setName(String name) {
  16. this.name = name;
  17. }
  18.  
  19. public Address getAddress() {
  20. return address;
  21. }
  22.  
  23. public void setAddress(Address address) {
  24. this.address = address;
  25. }
  26.  
  27. public String[] getBooks() {
  28. return books;
  29. }
  30.  
  31. public void setBooks(String[] books) {
  32. this.books = books;
  33. }
  34.  
  35. public List<String> getHobbys() {
  36. return hobbys;
  37. }
  38.  
  39. public void setHobbys(List<String> hobbys) {
  40. this.hobbys = hobbys;
  41. }
  42.  
  43. public Map<String, String> getCard() {
  44. return card;
  45. }
  46.  
  47. public void setCard(Map<String, String> card) {
  48. this.card = card;
  49. }
  50.  
  51. public Set<String> getGame() {
  52. return game;
  53. }
  54.  
  55. public void setGame(Set<String> game) {
  56. this.game = game;
  57. }
  58.  
  59. public String getWife() {
  60. return wife;
  61. }
  62.  
  63. public void setWife(String wife) {
  64. this.wife = wife;
  65. }
  66.  
  67. public Properties getInfo() {
  68. return info;
  69. }
  70.  
  71. public void setInfo(Properties info) {
  72. this.info = info;
  73. }
  74.  
  75. @Override
  76. public String toString() {
  77. return "Student{" +
  78. "name='" + name + '\'' +
  79. ", address=" + address +
  80. ", books=" + Arrays.toString(books) +
  81. ", hobbys=" + hobbys +
  82. ", card=" + card +
  83. ", game=" + game +
  84. ", wife='" + wife + '\'' +
  85. ", info=" + info +
  86. '}';
  87. }
  88. }

代码过长就折叠了

Address实体类如下:

  1. public class Address {
  2. private String address;
  3.  
  4. public String getAddress() {
  5. return address;
  6. }
  7.  
  8. public void setAddress(String address) {
  9. this.address = address;
  10. }
  11.  
  12. @Override
  13. public String toString() {
  14. return "Address{" +
  15. "address='" + address + '\'' +
  16. '}';
  17. }
  18. }

配置文件的代码如下:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. https://www.springframework.org/schema/beans/spring-beans.xsd">
  6.  
  7. <bean id="Address" class="com.kuang.pojo.Address">
        <property name="address" value="北京"/>
      </bean>
  1. <bean id="student" class="com.kuang.pojo.Student">
  2. <property name="name" value="张三"/>
  3. <property name="address" ref="Address" />
  4.  
  5. <property name="books">
  6. <array>
  7. <value>红楼梦</value>
  8. <value>西游记</value>
  9. <value>水浒传</value>
  10. <value>三国演义</value>
  11. </array>
  12. </property>
  13.  
  14. <property name="hobbys">
  15. <list>
  16. <value>游泳</value>
  17. <value>跑步</value>
  18. <value>爬山</value>
  19. </list>
  20. </property>
  21.  
  22. <property name="card">
  23. <map>
  24. <entry key="身份证" value="123456789987654"/>
  25. <entry key="银行卡" value="654873264654879"/>
  26. </map>
  27. </property>
  28.  
  29. <property name="game">
  30. <set >
  31. <value>英雄联盟</value>
  32. <value>王者荣耀</value>
  33. <value>穿越火线</value>
  34. </set>
  35. </property>
  36.  
  37. <property name="wife" >
  38. <null/>
  39. </property>
  40.  
  41. <property name="info">
  42. <props>
  43. <prop key="学号">1665487956</prop>
  44. <prop key="性别"></prop>
  45. <prop key="姓名">小明</prop>
  46. </props>
  47. </property>
  48. </bean>
  49.  
  50. </beans>

3.其他方式(c命名空间、p命名空间等)

Spring:DI依赖注入的几种方式的更多相关文章

  1. Spring中依赖注入的四种方式

    在Spring容器中为一个bean配置依赖注入有三种方式: · 使用属性的setter方法注入  这是最常用的方式: · 使用构造器注入: · 使用Filed注入(用于注解方式). 使用属性的sett ...

  2. Spring IOC 依赖注入的两种方式XML和注解

    依赖注入的原理 依赖注入的方式---XML配置 依赖注入的方式---注解的方式 Spring 它的核心就是IOC和AOP.而IOC中实现Bean注入的实现方式之一就是DI(依赖注入). 一 DI的原理 ...

  3. Spring注解依赖注入的三种方式的优缺点以及优先选择

    当我们在使用依赖注入的时候,通常有三种方式: 1.通过构造器来注入: 2.通过setter方法来注入: 3.通过filed变量来注入: 那么他们有什么区别吗?应该选择哪种方式更好? 三种方式的区别小结 ...

  4. spring的依赖注入的四种方式,数组与集合注入;引用注入;内部bean注入

    三种注入方式 第一种: 基于构造函数 hi.java (bean) package test_one; public class hi { private String name; public hi ...

  5. Spring的依赖注入的2种方式(1天时间)

    今天花了一天的时间才调试出来 private      接口   实现类的那个bean; 最后面的那个名字不能随便的写,必须是配置文件中,实现类的那个bean 就是后面的那个名字写错了,花了整整一天 ...

  6. spring Di依赖注入

    依赖注入有两种方式 通过 get   set 方法 Person.java package cn.itcast.spring.sh.di.set; import java.util.List; imp ...

  7. 峰Spring4学习(2)依赖注入的几种方式

    一.装配一个bean 二.依赖注入的几种方式 com.cy.entity   People.java: package com.cy.entity; public class People { pri ...

  8. ASP.NET MVC中使用Unity进行依赖注入的三种方式

    在ASP.NET MVC中使用Unity进行依赖注入的三种方式 2013-12-15 21:07 by 小白哥哥, 146 阅读, 0 评论, 收藏, 编辑 在ASP.NET MVC4中,为了在解开C ...

  9. SSH深度历险记(八) 剖析SSH核心原则+Spring依赖注入的三种方式

           于java发育.一类程序猿必须依靠类的其他方法,它是通常new依赖类的方法,然后调用类的实例,这样的发展问题new良好的班统一管理的例子.spring提出了依赖注入的思想,即依赖类不由程 ...

随机推荐

  1. 【JavaScript】Leetcode每日一题-在D天内送包裹的能力

    [JavaScript]Leetcode每日一题-在D天内送包裹的能力 [题目描述] 传送带上的包裹必须在 D 天内从一个港口运送到另一个港口. 传送带上的第 i 个包裹的重量为 weights[i] ...

  2. Wampserver-添加虚拟主机

    鼠标左键点击,之后点击第一个 localhost(有一个小房子) 添加虚拟地址 具体添加 完成界面 注意:这个时候一定需要重启一个Wampserver64 如果没有重启直接进入4这个步骤,会发现进入的 ...

  3. WPF使用自定义Main函数

    一.自定义Main函数 在WPF中,我们添加一个Program静态类,添加一个Main静态方法,需要注意的是该方法需要添加"STAThread",表示WPF程序需运行在单一线程单元 ...

  4. 手把手教你部署验证freeswitch(避免踩坑)

    前言:请各大网友尊重本人原创知识分享,谨记本人博客:南国以南i 介绍:freeswitch可集成ASR(语音识别)和TTS(文本转语音)创建智能电话机器人和用户通话,可用于问卷调查,自动催缴等业务,电 ...

  5. readdir_r()读取目录内容

    readdir()在多线程操作中不安全,Linux提供了readdir_r()实现多线程读取目录内容操作. #include <stdio.h> #include <stdlib.h ...

  6. [DB] Kafka

    介绍 一种高吞吐量的分布式发布订阅消息系统 消息类型:主体Topic(广播).队列Queue(一对一) 消息系统类型:同步消息系统.异步消息系统 常见消息产品:Redis.Kafka.JMS 术语 P ...

  7. Boostrap bootstrap-table插件使用教程

    bootstrap table 简介及特性 简介 Bootstrap table 是国人开发的一款基于 Bootstrap 的 jQuery 表格插件,通过简单的设置,就可以拥有强大的单选.多选.排序 ...

  8. Tomcat参数

    解析Tomcat的启动脚本--startup.bat:https://www.jb51.net/article/99857.htm 解析Tomcat的启动脚本--catalina.bat:https: ...

  9. 发现新大陆 --21lic

    21lic网上发单平台 http://project.21ic.com/p/97250

  10. Redis()- 布隆过滤器

    一.布隆过滤器 布隆过滤器:一种数据结构.由二进制数组(很长的二进制向量)组成的.布隆过滤器可以用于检索一个元素是否在一个集合中.它的优点是空间效率和查询时间都比一般的算法要好的多,缺点是有一定的误识 ...