Spring DI - 依赖注入

1.IOC(DI) - 控制反转(依赖注入)

所谓的IOC称之为控制反转，简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不再需要关注对象的创建和生命周期的管理，而是在需要时由Spring框架提供，这个由spring框架管理对象创建和生命周期的机制称之为控制反转。而在创建对象的过程中Spring可以依据配置对对象的属性进行设置，这个过称之为依赖注入,也即DI。

2.set方法注入

通常的javabean属性都会私有化，而对外暴露setXxx()getXxx()方法，此时spring可以通过这样的setXxx()方法将属性的值注入对象。

a.Spring内置的可直接注入类型的注入：

package cn.tedu.beans;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Hero {

    private int id;
    private String name;
    private List<String> jobs;
    private Set<String> set;
    private Map<String,String> map;
    private Properties prop;
    private Cat cat;
    private Dog dog;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<String> getJobs() {
        return jobs;
    }
    public void setJobs(List<String> jobs) {
        this.jobs = jobs;
    }
    public Set<String> getSet() {
        return set;
    }
    public void setSet(Set<String> set) {
        this.set = set;
    }
    public Map<String, String> getMap() {
        return map;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    public Properties getProp() {
        return prop;
    }
    public void setProp(Properties prop) {
        this.prop = prop;
    }
    public Cat getCat() {
        return cat;
    }
    public void setCat(Cat cat) {
        this.cat = cat;
    }
    public Dog getDog() {
        return dog;
    }
    public void setDog(Dog dog) {
        this.dog = dog;
    }
    @Override
    public String toString() {
        return "Hero [id=" + id + ", name=" + name + ", jobs=" + jobs
                + ", set=" + set + ", map=" + map + ", prop=" + prop + ", cat="
                + cat + ", dog=" + dog + "]";
    }

}
<?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-3.2.xsd"
    default-lazy-init="true"
    >

    <bean id="hero" class="cn.tedu.beans.Hero">
        <property name="id" value="123"></property>
        <property name="name" value="亚瑟"></property>
        <property name="jobs">
            <list>
                <value>上单</value>
                <value>中弹</value>
                <value>辅助</value>
                <value>打野</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
                <value>ddd</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="addr" value="王者荣耀"></entry>
                <entry key="addr" value="英雄联盟"></entry>
                <entry key="skill" value="风火轮"></entry>
                <entry key="age" value="19"></entry>
            </map>
        </property>
        <property name="prop">
            <props>
                <prop key="k1">v1</prop>
                <prop key="k2">v1</prop>
                <prop key="k3">v1</prop>
                <prop key="k4">v1</prop>
            </props>
        </property>

    </bean>

</beans>
    @Test
    /**
     * SpringDI set方式注入 - Spring内置的可直接注入类型的注入
     */
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Hero hero = (Hero) context.getBean("hero");
        System.out.println(hero);
    }
Hero [id=123, name=亚瑟, jobs=[上单, 中弹, 辅助, 打野], set=[aaa, bbb, ccc, ddd], map={addr=英雄联盟, skill=风火轮, age=19},prop={k4=v1, k3=v1, k2=v1, k1=v1}, cat=null, dog=null]

b.非Spring内置的可以直接注入类型的注入：

package cn.tedu.beans;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Hero {

    private int id;
    private String name;
    private List<String> jobs;
    private Set<String> set;
    private Map<String,String> map;
    private Properties prop;
    private Cat cat;
    private Dog dog;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<String> getJobs() {
        return jobs;
    }
    public void setJobs(List<String> jobs) {
        this.jobs = jobs;
    }
    public Set<String> getSet() {
        return set;
    }
    public void setSet(Set<String> set) {
        this.set = set;
    }
    public Map<String, String> getMap() {
        return map;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    public Properties getProp() {
        return prop;
    }
    public void setProp(Properties prop) {
        this.prop = prop;
    }
    public Cat getCat() {
        return cat;
    }
    public void setCat(Cat cat) {
        this.cat = cat;
    }
    public Dog getDog() {
        return dog;
    }
    public void setDog(Dog dog) {
        this.dog = dog;
    }
    @Override
    public String toString() {
        return "Hero [id=" + id + ", name=" + name + ", jobs=" + jobs
                + ", set=" + set + ", map=" + map + ", prop=" + prop + ", cat="
                + cat + ", dog=" + dog + "]";
    }

}
<?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-3.2.xsd"
    default-lazy-init="true"
    >

    <bean id="hero" class="cn.tedu.beans.Hero">
        <property name="id" value="123"></property>
        <property name="name" value="亚瑟"></property>
        <property name="jobs">
            <list>
                <value>上单</value>
                <value>中弹</value>
                <value>辅助</value>
                <value>打野</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
                <value>ddd</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="addr" value="王者荣耀"></entry>
                <entry key="addr" value="英雄联盟"></entry>
                <entry key="skill" value="风火轮"></entry>
                <entry key="age" value="19"></entry>
            </map>
        </property>
        <property name="prop">
            <props>
                <prop key="k1">v1</prop>
                <prop key="k2">v1</prop>
                <prop key="k3">v1</prop>
                <prop key="k4">v1</prop>
            </props>
        </property>
        <property name="dog" ref="dog"></property>
        <property name="cat" ref="cat"></property>
    </bean>

    <bean id="dog" class="cn.tedu.beans.Dog"></bean>
    <bean id="cat" class="cn.tedu.beans.Cat"></bean>
</beans>

    @Test
    /**
     * SpringDI set方式注入 - 非Spring内置的可以直接注入类型的注入
     */
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Hero hero = (Hero) context.getBean("hero");
        System.out.println(hero);
    }

结果：

Hero [id=123, name=亚瑟, jobs=[上单, 中弹, 辅助, 打野], set=[aaa, bbb, ccc, ddd], map={addr=英雄联盟, skill=风火轮, age=19}, prop={k4=v1, k3=v1, k2=v1, k1=v1}, [email protected], [email protected]]

3.基于构造方法的注入

对象属性设置的另一种方式是在对象创建的过程中通过构造方法传入并设置对象的属性。

spring也可以通过这样的构造方法实现属性的注入。

package cn.tedu.beans;

public class Student {
    private int id;
    private String name;
    private Dog dog;

    public Student(int id, String name, Dog dog) {
        super();
        this.id = id;
        this.name = name;
        this.dog = dog;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", dog=" + dog + "]";
    }
}
<?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-3.2.xsd"
    default-lazy-init="true"
    >

    <bean id="student" class="cn.tedu.beans.Student">
        <!--
            index:为构造方法的第几个参数 进行配置
            name:为构造方法的哪个名字的参数进行配置
                 **index 和 name 可以配置任何一个或同时配置 但要求一旦配置必须正确
                 **推荐优先使用index方式配置 防止没有源码造成name无法匹配到对应参数
            type:该构造方法参数的类型
            value:该构造方法参数的值 ,用来指定基本值
            ref:该构造方法参数的值,用来指定引用其他bean的值
         -->
        <constructor-arg index="0" name="id" value="999"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" value="张无忌"></constructor-arg>
        <constructor-arg name="dog" ref="dog"></constructor-arg>
    </bean>

    <bean id="dog" class="cn.tedu.beans.Dog"></bean>
</beans>
    @Test
    /**
     * SpringDI 构造方法方式属性注入
     */
    public void test3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student);
    }

运行结果：

Student [id=999, name=张无忌, [email protected]]

4.自动装配

在Spring的set方式实现的注入过程中，支持自动装配机制，所谓自动装配机制，会根据要设置的javabean属性的名字 或 类型 到spring中自动寻找对应id 或 类型的<bean>进行设置，从而 省去依次配置的过程，简化了配置。

为指定<bean>开启自动装配：

<?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-3.2.xsd"
    >

    <!--
        autowire设定自动装配：
        byName:根据javabean中需要注入的属性的名字 ，在spring容器中找对应id的<bean>将该<bean>的对象复制给 当前的属性
        byType:根据javabean中需要注入的属性的类型，在spring容器中找对应class类型的<bean>将该<bean>的对象复制给 当前的属性
        **byType方式 根据类型进行匹配，可能匹配到多个<bean>,此时会抛出异常。而byName是通过id来寻找<bean>，id没有重复，不会有这方面的问题，所以推荐使用byName方式
    -->

    <bean id="teacher" class="cn.tedu.beans.Teacher" autowire="byName"></bean>
    <bean id="dog" class="cn.tedu.beans.Dog"></bean>
    <bean id="cat" class="cn.tedu.beans.Cat"></bean>
</beans>

为全局配置自动装配：

package cn.tedu.beans;

public class Teacher {
    private Dog dog;
    private Cat cat;
    public void setDog(Dog dog) {
        this.dog = dog;
    }
    public void setCat(Cat cat) {
        this.cat = cat;
    }

    @Override
    public String toString() {
        return "Teacher [dog=" + dog + ", cat=" + cat + "]";
    }
}
<?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-3.2.xsd"
    default-autowire="byName"
    >

    <!--
        autowire设定自动装配：
        byName:根据javabean中需要注入的属性的名字 ，在spring容器中找对应id的<bean>将该<bean>的对象复制给 当前的属性
        byType:根据javabean中需要注入的属性的类型，在spring容器中找对应class类型的<bean>将该<bean>的对象复制给 当前的属性
        **byType方式 根据类型进行匹配，可能匹配到多个<bean>,此时会抛出异常。而byName是通过id来寻找<bean>，id没有重复，不会有这方面的问题，所以推荐使用byName方式
    -->

    <bean id="teacher" class="cn.tedu.beans.Teacher"></bean>
    <bean id="dog" class="cn.tedu.beans.Dog"></bean>
    <bean id="cat" class="cn.tedu.beans.Cat"></bean>
</beans>
    @Test
    /**
     * SpringDI 自动装配
     */
    public void test4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Teacher teacher = (Teacher) context.getBean("teacher");
        System.out.println(teacher);
    }

运行结果：

Teacher [[email protected], [email protected]]

原文地址：https://www.cnblogs.com/chuijingjing/p/9787386.html

时间： 2024-12-01 18:01:01

Spring DI - 依赖注入的相关文章

spring -di依赖注入，seter方法

[applicationContext.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.sprin

Spring的依赖注入（DI）三种方式

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 {

Spring详解（三）------DI依赖注入

上一篇博客我们主要讲解了IOC控制反转,也就是说IOC 让程序员不在关注怎么去创建对象,而是关注与对象创建之后的操作,把对象的创建.初始化.销毁等工作交给spring容器来做.那么创建对象的时候,有可能依赖于其他的对象,即类的属性如何赋值?这也是我们这篇博客讲解 Spring 另一个核心要点:DI依赖注入. PS:本篇博客源码下载链接:http://pan.baidu.com/s/1c2xVUDi密码:v1h3 1.什么是DI依赖注入? spring动态的向某个对象提供它所需要的其他对象.这一点

初识Spring框架实现IOC和DI(依赖注入)

学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的, IoC是什么 Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想. 在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制.如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转

Spring：（二）DI依赖注入方式

DI 依赖注入 DI(Dependency Injection)依赖注入,说简单一点就将类里面的属性在创建类的过程中给属性赋值,即将对象依赖属性(简单值,集合,对象)通过配置设值给该对象. 属性注入的方式 构造方法的方式 set方法的方式 工厂方法注入 主要学习前两种方式 构造方法的方式 当是构造方法时注入Bean的属性值(简单值,集合,对象) 利用<constructor-arg>标签进行属性的注入 name:被设置属性的名 value:被设置属性的值 编写用构造方法的pojo 1 pack

Spring学习三、Spring配置与DI依赖注入

五.Spring配置 5.1别名 <!-- 别名--> <alias name="user" alias="user2"/> 5.2 Bean的配置 <!-- id : bean的唯一标识符,相当于对象名 class : 全限定名 包名 + 类名 name : 也是别名,name可以同时起多个别名 --> <bean id="userT" class="cn.imut.pojo.User&quo

【Spring】DI 依赖注入传递参数的方式

DI依赖注入传入参数的方式,这里介绍了基本数据类型,集合,符合数据类型的传递(String类型比较特殊,其传递值和基本数据类型的方法一致) 注入基本数据类型和String类型 通过setter方法注入基本数据类型与String 案例: <bean id="book" class="cn.xdl.bean.Book"> <!-- 对于基本数据类型 与 String的注入操作 通过set方法 ,完成注入 name: 属性的名称 value: 属性要赋的

第二十七天 春之细雨润物于无形 —Spring的依赖注入

6月11日,晴."夏条绿已密,朱萼缀明鲜.炎炎日正午,灼灼火俱燃." IT人习惯把具体的事物加工成的形状一致的类,正是这样的一致,加上合适的规范,才能彰显对象筋道的牙感和bean清香的味道.Spring比谁都清楚OO的奥妙,让组件之间的依赖关系由容器在运行时期决定,称作依赖注入(Dependency Injection). 下面用一通俗的例子,一探依赖注入奥妙. 设计模式中的一个原则:针对接口编程,不要针对实现编程. 一.设计两个接口: (1)奶制品接口-MilkProductInte

二、Spring的依赖注入

Spring的依赖注入 1.理解依赖注入 (1)A对象需要调用B对象的方法,这种情形被称为依赖注入,即A对象依赖B对象:依赖注入(DI)也被成为控制反转(IoC): (2)依赖注入的两种方式: 1)设值注入:IoC容器通过使用成员变量的setter方法来注入被依赖对象: 2)构造注入:IoC容器通过使用构造器来注入被依赖的对象: 2.设置注入 (1)Bean与Bean之间的依赖关系由Spring管理,Spring采用setter方法为目标Bean注入所需要的值,这种注入方式被称为设值注入: (2