Spring的DI依赖注入详解

1、什么是di依赖注入？

spring动态的向某个对象提供它所需要的其他对象。这一点是通过di（dependency injection，依赖注入）来实现的。比如对象a需要操作数据库，以前我们总是要在a中自己编写代码来获得一个connection对象，有了 spring我们就只需要告诉spring，a中需要一个connection，至于这个connection怎么构造，何时构造，a不需要知道。在系统运行时，spring会在适当的时候制造一个connection，然后像打针一样，注射到a当中，这样就完成了对各个对象之间关系的控制。a需要依赖 connection才能正常运行，而这个connection是由spring注入到a中的，依赖注入的名字就这么来的。那么di是如何实现的呢？ java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

简单来说什么是依赖注入，就是给属性赋值（包括基本数据类型和引用数据类型）

2、利用 set 方法给属性赋值

第一步：创建工程，并导入相应的 jar 包

第二步：创建实体类 person

package com.ys.di;
 
import java.util.list;
import java.util.map;
import java.util.properties;
import java.util.set;
 
public class person {
    private long pid;
    private string pname;
    private student students;
    private list lists;
    private set sets;
    private map maps;
    private properties properties;
     
    public long getpid() {
        return pid;
    }
    public void setpid(long pid) {
        this.pid = pid;
    }
    public string getpname() {
        return pname;
    }
    public void setpname(string pname) {
        this.pname = pname;
    }
    public student getstudents() {
        return students;
    }
    public void setstudents(student students) {
        this.students = students;
    }
    public list getlists() {
        return lists;
    }
    public void setlists(list lists) {
        this.lists = lists;
    }
    public set getsets() {
        return sets;
    }
    public void setsets(set sets) {
        this.sets = sets;
    }
    public map getmaps() {
        return maps;
    }
    public void setmaps(map maps) {
        this.maps = maps;
    }
    public properties getproperties() {
        return properties;
    }
    public void setproperties(properties properties) {
        this.properties = properties;
    }
     
}

我们看到这个实体类包括引用类型 student 类，基本数据类以及集合数据类型。

第三步：在 applicationcontext.xml 中进行赋值

<!--
    property是用来描述一个类的属性
    基本类型的封装类、string等需要值的类型用value赋值
    引用类型用ref赋值
-->
<bean id="person" class="com.ys.di.person">
    <property name="pid" value="1"></property>
    <property name="pname" value="vae"></property>
    <property name="students">
        <ref bean="student"/>
    </property>
     
    <property name="lists">
        <list>
            <value>1</value>
            <ref bean="student"/>
            <value>vae</value>
        </list>
    </property>
     
    <property name="sets">
        <set>
            <value>1</value>
            <ref bean="student"/>
            <value>vae</value>
        </set>
    </property>
     
    <property name="maps">
        <map>
            <entry key="m1" value="1"></entry>
            <entry key="m2" >
                <ref bean="student"/>
            </entry>
        </map>
    </property>   
     
    <property name="properties">
        <props>
            <prop key="p1">p1</prop>
            <prop key="p2">p2</prop>
        </props>
    </property>  
     
</bean>
 
 
<bean id="student" class="com.ys.di.student"></bean>

第四步：测试

//利用 set 方法给对象赋值
    @test
    public void testset(){
        //1、启动 spring 容器
        //2、从 spring 容器中取出数据
        //3、通过对象调用方法
        applicationcontext context =
                new classpathxmlapplicationcontext("applicationcontext.xml");
        person person = (person) context.getbean("person");
        system.out.println(person.getpname());//vae
    }

3、利用 构造函数 给属性赋值

第一步：在实体类 per'son.java 中添加两个构造方法：有参和无参

//默认构造函数
    public person(){}
    //带参构造函数
    public person(long pid,student students){
        this.pid = pid;
        this.students = students;
    }

第二步：在 applicationcontext.xml 中进行赋值

<!-- 根据构造函数赋值 -->
    <!--
        index  代表参数的位置  从0开始计算
        type   指的是参数的类型,在有多个构造函数时，可以用type来区分，要是能确定是那个构造函数，可以不用写type
        value  给基本类型赋值
        ref    给引用类型赋值
      -->
    <bean id="person_con" class="com.ys.di.person">
        <constructor-arg index="0" type="java.lang.long" value="1">
        </constructor-arg>       
        <constructor-arg index="1" type="com.ys.di.student" ref="student_con"></constructor-arg>
    </bean>
    <bean id="student_con" class="com.ys.di.student"></bean>

第三步：测试

//利用 构造函数 给对象赋值
    @test
    public void testconstrutor(){
        applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
        person person = (person) context.getbean("person_con");
        system.out.println(person.getpid());//1
    }

总结：

1、如果spring的配置文件中的bean中没有<constructor-arg>该元素，则调用默认的构造函数

2、如果spring的配置文件中的bean中有<constructor-arg>该元素，则该元素确定唯一的构造函数

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