Spring（三）DI

最新推荐文章于 2024-08-20 21:20:17 发布
最新推荐文章于 2024-08-20 21:20:17 发布
阅读量76 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36675851/article/details/88218543
版权

（1）DI概念
利用spring IOC实例化了对象，而DI将实例化的对象注入到需要对象的地方，完成初始化任务。对象由spring创建，之后再由spring给属性赋值。
spring提供两种方式设置属性值：① setter方法注入。②构造方法注入
（2）set方法注入
Cat.java

public class Cat implements Serializable{
    
    private static final long serialVersionUID = 1L;
    
    private String type;
    private int age;
    
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

<!-- 实例化Cat对象
     <bean>节点是用来告知spring实例化对象
     <property>节点,是用来告知spring对象有注入
     name="type" type->Type->setType
     把名字的第一个字母大写，前面用字符串连接一个set,构建出一个新字符串,
     拿着个字符串去class属性所对应的类中寻找是否有此方法签名的方法.
     如果有就反射调用此setter方法.setter方法的参数是value="smallCat"
-->
<bean id="cat" class="com.hdu.setter.Cat">
    <!-- 单值注入 -->
    <property name="type" value="smallCat"></property>
    <property name="age" value="3"></property>
</bean>

测试

public class TestIOCDI {
    @Test
    public void testMethod() {
        ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_object.xml");
        Cat cat = context.getBean("cat",Cat.class);
        System.out.println(cat.getType()+" "+cat.getAge());
    }
}

（3）对象注入
Person.java

public class Person {
    private String name;
    private int age;
    private Cat cat;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Cat getCat() {
        return cat;
    }
    public void setCat(Cat cat) {
        this.cat = cat;
    }    
}

<!-- 实例化Cat对象 -->
<bean id="cat" class="com.hdu.setter.Cat">
    <!-- 单值注入 -->
    <property name="type" value="smallCat"></property>
    <property name="age" value="3"></property>
</bean>
<!-- name="cat" cat->Cat->setCat
     ref="cat" 引用对象,cat是spring容器中的唯一id,指上面已经实例化的cat对象
-->
<bean id="person" class="com.hdu.setter.Person">
<!-- 单值注入 -->
<property name="name" value="kuotian"></property>
<property name="age" value="23"></property>
<!-- 对象注入 -->
<property name="cat" ref="cat"></property>
</bean>

测试

public class TestIOCDI {
    @Test
    public void testMethod() {
        ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_object.xml");
        //对象都是由spring创建和管理,对象的关系也要由spring来维护
        Person person = context.getBean("person",Person.class);
        System.out.println("Person:name="+person.getName());
        System.out.println("Person:age="+person.getAge());
        System.out.println("Person:Cat:type="+person.getCat().getType());
        System.out.println("Person:Cat:age="+person.getCat().getAge());
    }
}

（4）集合注入
Message.java

public class Message {
    private List list;
    private Set set;
    private Map map;
    private Properties pros;
    public void setList(List list) {
        this.list = list;
    }
    public void setSet(Set set) {
        this.set = set;
    }
    public void setMap(Map map) {
        this.map = map;
    }
    public void setPros(Properties pros) {
        this.pros = pros;
    }
    @Override
    public String toString() {
        return "Message [list=" + list + ", set=" + set + ", map=" + map + ", pros=" + pros + "]";
    }
}

1、直接注入

<!-- 实例化Cat对象 -->
<bean id="cat" class="com.hdu.setter.Cat">
    <!-- 单值注入 -->
    <property name="type" value="smallCat"></property>
    <property name="age" value="3"></property>
</bean>
    
<!-- 直接集合注入 -->
<bean id="message" class="com.hdu.setter.Message">
    <property name="list">
        <list>
            <!-- value引用的是单值 ref引用的事对象 -->
            <value>杭州</value>
            <value>17</value>
            <ref bean="cat" />
        </list>
    </property>
    <property name="set">
        <set>
            <value>杭州</value>
            <value>17</value>
            <ref bean="cat" />
        </set>
    </property>
    <property name="map">
        <map>
            <entry key="bj" value="北京"></entry>
            <entry key="hz" value="杭州"></entry>
            <entry key="cc" value-ref="cat"></entry>
        </map>
    </property>
    <property name="pros">
        <props>
            <prop key="bj">北京</prop>
            <prop key="hz">杭州</prop>
            <prop key="sh">上海</prop>
        </props>
    </property>
</bean>

测试

public class TestIOCDI {
    @Test
    public void testMethod() {
        ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_collection.xml");
        //直接注入
        Message msg = context.getBean("message",Message.class);
        System.out.println(msg);
    }
}

2、间接注入
间接注入，集合可复用多次。beans需要引入util命名空间。

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/util 
        http://www.springframework.org/schema/util/spring-util.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 实例化Cat对象 -->
    <bean id="cat" class="com.hdu.setter.Cat">
        <!-- 单值注入 -->
        <property name="type" value="smallCat"></property>
        <property name="age" value="3"></property>
    </bean>
    <!-- 间接集合注入 -->
    <util:list id="list">
        <value>杭州</value>
        <value>17</value>
        <ref bean="cat" />
    </util:list>
    
    <util:set id="set">
        <value>杭州</value>
        <value>17</value>
        <ref bean="cat" />
    </util:set>
    
    <util:map id="map">
        <entry key="bj" value="北京"></entry>
        <entry key="hz" value="杭州"></entry>
        <entry key="cc" value-ref="cat"></entry>
    </util:map>
    
    <util:properties id="props">
        <prop key="bj">北京</prop>
        <prop key="hz">杭州</prop>
        <prop key="sh">上海</prop>
    </util:properties>
    
    <bean id="message1" class="com.hdu.setter.Message">
        <property name="list" ref="list"></property>
        <property name="set" ref="set"></property>
        <property name="map" ref="map"></property>
        <property name="pros" ref="props"></property>
    </bean>
</beans>

测试

public class TestIOCDI {
    @Test
    public void testMethod() {
        ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_collection.xml");
        //直接注入
        Message msg = context.getBean("message",Message.class);
        System.out.println("直接注入:"+msg);
        //间接注入
        Message msg1 = context.getBean("message1",Message.class);
        System.out.println("间接注入:"+msg1);
    }
}

（5）表达式注入
1、${}表达式
db.properties文件

jdbc_driverClass=com.mysql.jdbc.Driver
jdbc_url=jdbc:mysql://localhost:3306/tmpdb
jdbc_userName=root
jdbc_userPassword=root

JDBCUtil

public class JDBCUtil {
    private String driverClass;
    private String url;
    private String userName;
    private String password;
    public String getDriverClass() {
        return driverClass;
    }
    public void setDriverClass(String driverClass) {
        this.driverClass = driverClass;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "JDBCUtil [driverClass=" + driverClass + ", url=" + url + ", userName=" + userName + ", password="
                + password + "]";
    }
}

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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/util 
        http://www.springframework.org/schema/util/spring-util.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
        
    <!-- 优先加载 先把属性文件加载到spring容器中 多个文件用逗号间隔 -->
    <context:property-placeholder location="classpath:resources/mysql.properties,resources/page.properties"/>
    <!-- 表达式注入 ${} -->
    <bean id="jdbcUtil" class="com.hdu.util.JDBCUtil">
        <property name="driverClass" value="${jdbc_driverClass}"></property>
        <property name="url" value="${jdbc_url}"></property>
        <property name="userName" value="${jdbc_userName}"></property>
        <property name="password" value="${jdbc_userPassword}"></property>
    </bean>
</beans>

TestIOCDI

public class TestIOCDI {
    @Test
    public void testMethod() {
        ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_expression1.xml");
        //从容器中取出对象
        JDBCUtil jdbcUtil = context.getBean("jdbcUtil", JDBCUtil.class);
        System.out.println(jdbcUtil);
    }
}

2、#{}表达式
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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/util 
        http://www.springframework.org/schema/util/spring-util.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
        
    <!-- 优先加载 先把属性文件加载到spring容器中 多个文件用逗号间隔 -->
    <util:properties id="manyProperties" location="classpath:resources/mysql.properties,resources/page.properties"></util:properties>
    <!-- 表达式注入 #{} -->
    <bean id="jdbcUtil" class="com.hdu.util.JDBCUtil">
        <property name="driverClass" value="#{manyProperties.jdbc_driverClass}"></property>
        <property name="url" value="#{manyProperties.jdbc_url}"></property>
        <property name="userName" value="#{manyProperties.jdbc_userName}"></property>
        <property name="password" value="#{manyProperties.jdbc_userPassword}"></property>
    </bean>
    
</beans>

TestIOCDI

public class TestIOCDI {
    @Test
    public void testMethod() {
        ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_expression2.xml");
        JDBCUtil jdbcUtil = context.getBean("jdbcUtil", JDBCUtil.class);
        System.out.println(jdbcUtil);
    }
}

（6）空值注入

public class Kong {
    private String str1;
    private String str2;
    public String getStr1() {
        return str1;
    }
    public void setStr1(String str1) {
        this.str1 = str1;
    }
    public String getStr2() {
        return str2;
    }
    public void setStr2(String str2) {
        this.str2 = str2;
    }
    @Override
    public String toString() {
        return "Kong [str1=" + str1 + ", str2=" + str2 + "]";
    }
}

<bean id="kong" class="com.hdu.util.Kong">
    <property name="str1" value=""></property>
    <property name="str2">
        <null></null>
    </property>
</bean>

public class TestIOCDI {
    @Test
    public void testMethod() {
        ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_kong.xml");
        Kong kong = context.getBean("kong", Kong.class);
        System.out.println(kong);
    }
}

（7）构造方法注入
ConstructorDI

public class ConstructorDI {
    private int age;
    private Cat cat;
    private String name;
    public ConstructorDI() {
        
    }
    
    public ConstructorDI(int age, Cat cat, String name) {
        super();
        this.age = age;
        this.cat = cat;
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "ConstructorDI [age=" + age + ", cat=" + cat + ", name=" + name + "]";
    }
}

xml配置文件

<!-- 实例化Cat对象 -->
<bean id="cat" class="com.hdu.setter.Cat">
    <property name="type" value="smallCat"></property>
    <property name="age" value="3"></property>
</bean>
<!-- 
     index:从0开始,代表参数的位置
 -->
<bean id="constructor" class="com.hdu.constructor.ConstructorDI">
    <constructor-arg index="0" value="20"></constructor-arg>
    <constructor-arg index="1" ref="cat"></constructor-arg>
    <constructor-arg index="2" value="张三"></constructor-arg>
</bean>

TestIOCDI

public class TestIOCDI {
    @Test
    public void testMethod() {
        ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_constructor.xml");
        ConstructorDI constructor = context.getBean("constructor", ConstructorDI.class);
        System.out.println(constructor);
    }
}
LoveMsChen
关注
专栏目录
SpringIOC DI循环依赖实例详解
08-24
SpringIOC DI 循环依赖实例详解 SpringIOC 是一个基于依赖注入（Dependency Injection，简称 DI）的容器，用于管理 Bean 的生命周期。 DI 循环依赖是指在 Bean 初始化过程中出现的循环依赖问题，即一个 Bean 依赖于...
Spring-DI时序图.png
05-14
Spring Ioc DI 时序图分享给大家，希望对大家看源码有所帮助，不足之处欢迎批评指正，可以在下方留言
Spring中DI介绍
WYSCODER的博客
04-24 5841
文章目录Spring中DI介绍一、基于XML配置注入依赖1. 有参构造函数注入依赖2. set方法注入依赖 Spring中DI介绍 DI（Dependency Injection）即依赖注入，对象之间的依赖由容器在运行期决定，即容器动态的将某个依赖注入到对象之中。 一、基于XML配置注入依赖 1. 有参构造函数注入依赖 ①bean类实现有参构造函数 ②在配置文件中配置参数通过有参构造函数给对象属性赋值 有参构造是使用constructor-arg标签 <bean id="student4" c
Spring DI详解
热门推荐
qq_42603060的博客
01-23 1万+
1.IOC（DI）-控制反转（依赖注入） 所谓的IOC称之为控制反转，简单来说就是将对象 的创建的权力及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不在需要关注对象的创建和生命周期的管理,而是在需要的时候由Spring框架提供，这个由Spring框架管理对象创建和生命周期的机制称之为控制反转。而在创建对象的过程中Spring可以依据配置对象的属性进行设置，这个过程称之为依...
Spring 之 DI 详解
岁月安然
05-30 2646
概念 DI(Dependency Injection)依赖注入：依赖注入是指在程序运行期间,由外部容器动态地将依赖对象注入到组件中如：一般，通过构造函数注入、Setter注入、注解注入。 Setter注入与注解注入类似，区别在于：Setter 注入是通过 Set 方法对属性进行赋值，而注解注入是通过反射为属性赋值。 时机 当 Spring IOC 容器完成了 Bean 定义资源的定位、载入、解析和注册以后，IOC 容器中已经管理类 BeanDefinition 的相关数据，但是此时 IOC 容器还没有对所管
Spring DI 概述
weixin_60934893的博客
10-18 395
DI注入
Spring IOC 和 DI详解
m0_61876562的博客
04-22 1260
IOC 是Spring的核心思想。其实IOC在前面 Spring MVC 部分我们就已经用到了。代码部分，我们在类上添加@RestController 和 @Controller 注解, 就是把这个对象交给Spring管理Spring 框架启动时就会加载该类。把对象交给Spring管理, 就是IoC思想。IOC: Inversion of Control (控制反转), 也就是说 Spring 是一个"控制反转"的容器.什么是控制反转呢?也就是控制权反转。什么的控制权发生了反转?
Spring：DI思想的详细图解
最新发布
Shine0115的博客
08-20 1198
DI 就是依赖注入，，简单来讲，其实就是，把 IoC 容器中的 bean 对象取出来直接放到某个类的属性中，不再需要我们自己手的的new对象。例如下面代码，
SpringIOC/DI详解
qq_63688997的博客
07-19 1199
SpringIOC/DI详细讲述，概念，包含内容实例化bean常用注解实现方式等等。
Spring DI实现方式
m0_65347933的博客
08-12 1251
Spring DI实现方式：set注入；构造注入；注解注入
spring DI的三种注入方式分析
weixin_40910372的博客
01-23 5764
一.前言： IOC（控制反转）与DI（依赖注入） Spring框架对Java开发的重要性不言而喻，其核心特性就是IOC（Inversion of Control， 控制反转）和AOP，平时使用最多的就是其中的IOC，我们通过将组件交由Spring的IOC容器管理，将对象的依赖关系由Spring控制，避免硬编码所造成的过度程序耦合。 在讲依赖注入之前，我觉得有必要了解一下IOC（控制反转）与DI（...
Spring——IoC和DI
浪漫不死的博客
03-02 3606
目录一、初识Spring为什么要使用Spring什么是SpringSpring框架的核心由哪些模块组成二、Core Container（核心容器）IoC（控制反转）什么是 IoCIoC 的作用IoC 的优点IoC 的缺点DI（依赖注入）什么是DI依赖注入的基本原则依赖注入的优势不同类型的依赖注入实现方式构造器依赖注入和 Setter方法注入的区别顶级接口BeanFactory 和 ApplicationContext 的区别BeanFactory和ApplicationContext的关系详解Applica
java Spring DI依赖注入.rar
01-30
Java Spring 框架是企业级Java应用开发的首选框架之一，其核心特性之一就是依赖注入（Dependency Injection，简称DI）。依赖注入是一种设计模式，它允许我们解耦组件，提高代码的可测试性和可维护性。Spring框架通过...
Spring 的DI和IoC实例详解(转)
07-26
在Java开发领域，Spring框架是应用最广泛的轻量级框架之一，它以其强大的依赖注入（Dependency Injection，简称DI）和控制反转（Inversion of Control，简称IoC）特性深受开发者喜爱。本文将深入探讨Spring的DI和IoC...
SpringDI.rar
05-10
本压缩包"SpringDI.rar"包含了关于Spring DI的实例，帮助开发者深入理解这一关键特性。 依赖注入允许我们解耦组件之间的关系，使得组件之间不再直接引用彼此，而是通过容器来管理这些依赖关系。这种设计模式提高了...
SpringMVC（一）MVC思想
qq_36675851的博客
03-25 550
（1）
Spring（八）Spring对事务支持
qq_36675851的博客
03-20 364
（1）ThreadLocal 在写Spring对事务的支持之前要先了解一下ThreadLocal，当多个线程访问同一个成员变量时，如果这个变量不做处理，那肯定会造成线程不安全的问题啊。使用ThreadLocal就可以解决这个问题，ThreadLocal为每一个线程创建变量的一个副本，这样线程操作的其实是各自的副本，就不会产生线程不安全的问题。下面看个例子： public class ThreadL...
SpringMVC（三）SpringMVC第一个helloworld程序
qq_36675851的博客
03-27 213
（1）
Spring（一）第一个helloworld程序
qq_36675851的博客
02-26 182
（1）
spring ioc DI
07-23
在Spring框架中，IOC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）是两个重要的概念。 IOC是一种设计原则，它反转了传统的程序设计中对象的创建和依赖关系的管理方式。传统方式中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值