Spring DI

一. Spring DI 依赖注入

利用spring IOC实例化了对象，而DI将实例化的对象注入到需要对象的地方，完成初始化任务。

对象由spring创建，之后再由spring给属性赋值

spring提供两种方式设置属性值：

① setter方法注入

②构造方法注入

二. set方法注入

2.1单值注入

Cat有type和age属性，采用单值注入的方式，进行初始化。

 package com.hdu.setter;

 import java.io.Serializable;

 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;

     }

 }

Class Cat

<!-- 实例化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>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.setter.Cat;

 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());

     }

 }

2.2对象注入

人人有猫。将Cat对象注入到Person对象中。

 package com.hdu.setter;

 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;

     }

 }

Class Person

<!-- 实例化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>

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.setter.Person;

 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());

     }

 }

2.3集合注入

toString是为了便于测试。

 package com.hdu.setter;

 import java.util.List;

 import java.util.Map;

 import java.util.Properties;

 import java.util.Set;

 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 + "]";

     }

 }

2.3.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>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.setter.Message;

 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.3.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>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.setter.Message;

 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);

     }

 }

从结果看出两种注入方式的效果是一样的。

2.4表达式注入

2.4.1 ${}表达式

参考手册中的事例。

①准备一个properties文件。

jdbc_driverClass=com.mysql.jdbc.Driver

jdbc_url=jdbc:mysql://localhost:3306/tmpdb

jdbc_userName=root

jdbc_userPassword=root

mysql.properties

②存放数据相关类

 package com.hdu.util;

 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 + "]";

     }

 }

Class JDBCUtil

③xml中beans需要引入context命名空间。

<?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>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.util.JDBCUtil;

 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.4.1 #{}表达式

③xml中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">

    <!-- 优先加载 先把属性文件加载到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>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.util.JDBCUtil;

 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);

     }

 }

结果：

2.5空值注入

其中str2注入的是空值，而str1注入的只是空字符串。在测试方法中str1= str2=null的结果可以证明。

 package com.hdu.util;

 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 + "]";

     }

 }

str2才是注入空值。

<bean id="kong" class="com.hdu.util.Kong">

    <property name="str1" value=""></property>

    <property name="str2">

        <null></null>

    </property>

</bean>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.util.Kong;

 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);

     }

 }

结果：

其中str2注入的是空值，而str1注入的只是空字符串。在测试方法中str1= str2=null的结果可以证明。

三.构造方法注入

 package com.hdu.constructor;

 import com.hdu.setter.Cat;

 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 + "]";

     }

 }

<!-- 实例化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>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.constructor.ConstructorDI;

 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);

     }

 }

Spring DI的更多相关文章

4.spring di
spring di,即依赖注入,从应用的浅显意义来讲就是对属性赋值 1.用setter赋值,在spring的applicationContext.xml配置文件的bean下的property标签属性 ...
Spring DI使用详解
Spring DI使用详解一.介绍 DI的定义:依赖注入,为类里面的属性设值.例如,我们之前的setName方法就是在为name属性设值. IOC与DI的关系:IOC进行对象的创建,DI进行值的注入 ...
手写Spring DI依赖注入，嘿，你的益达！
目录提前实例化单例Bean DI分析 DI的实现构造参数依赖一:定义分析二:定义一个类BeanReference 三:BeanDefinition接口及其实现类四:DefaultBeanFa ...
Java Spring DI之旅
做过.NET的人很多都用过Microsoft Enterprise Library,里面有一个Dependency injection工具Unity,我们可以使用它来实现依赖注入:什么是依赖注入呢?我 ...
Spring DI模式小样例
今儿跟同事讨论起来spring早期的,通过大篇幅xml的配置演变到今天annotation的过程,然后随手写了个小样例,感觉还不错,贴到这里留个纪念. 样例就是用JAVA API的方式, ...
Spring DI - 依赖注入
1.IOC(DI) - 控制反转(依赖注入) 所谓的IOC称之为控制反转,简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理,从此在开发过程中不再需要关注对象的创建和生 ...
spring Di依赖注入
依赖注入有两种方式通过 get set 方法 Person.java package cn.itcast.spring.sh.di.set; import java.util.List; imp ...
Spring知识点总结(三)之Spring DI
1. IOC(DI) - 控制反转(依赖注入) 所谓的IOC称之为控制反转,简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理,从此在开发过程中不再需要关注对象的创建和 ...
吴裕雄--天生自然JAVA SPRING框架开发学习笔记：Spring DI（依赖注入）的实现方式属性注入和构造注入
依赖注入(Dependency Injection,DI)和控制反转含义相同,它们是从两个角度描述的同一个概念. 当某个 Java 实例需要另一个 Java 实例时,传统的方法是由调用者创建被调用者的 ...

随机推荐

python3.6 ImportWarning: can't resolve package from __spec__ or __package__, falling back on __name__ and __path__
Cython emulates Python 2-style implicit relative imports on Python 3 Cython的锅(也就是绝大多数下载安装的python)新的i ...
一分钟搞定：spring boot 热部署（基于Idea）
什么是热部署? 对于spring boot项目,修改后台的java类,不要重启整个项目,就可以测试/使用刚修改的功能! 怎么为项目添加/设置热部署 maven项目在pom.xml添加下方代码,联网引入 ...
jsp post/get中接处理
jsp post/get中接处理以参数:username为便 post接收中文比get接收中文要方便多了. <%@ page contentType="text/html;chars ...
只输FLOAT值 TEXTBOX
if (((int)e.KeyChar < 48 || (int)e.KeyChar > 57) && (int)e.KeyChar != 8 && (in ...
JDBC 与 Bean Shell的使用（一）获取值，并且传递
1.在使用Jmeter进行接口测试的时候,会使用到JDBC,连接数据库,操作数据库其得到的数据后续操作需要使用,这里我们使用了BeanShell的概念来获取JDBC的返回值如下说明了联合使用的2种方 ...
21 模块（collections,time,random,os,sys）
关于模块importfrom xxx import xxx2. Collections1. Counter 计数器2. 栈: 先进后出.队列:先进先出deque:双向队列3. defaultdict ...
Liebig's Barrels CodeForces - 985C (贪心)
链接大意:给定$nk$块木板, 要制作$n$个$k$块板的桶, 要求任意两桶容积差不超过$l$, 每个桶的容积为最短木板长, 输出$n$个桶的最大容积和假设最短板长$m$, 显然最后桶的体积都在$ ...
Python下尝试实现图片的高斯模糊化
资源下载 #本文PDF版下载Python下尝试实现图片的高斯模糊化#本文代码下载高斯模糊代码下载高斯模糊是什么? (先来看一下维基百科对它的定义) 高斯模糊是模糊图像的结果.它是一种广泛使用的图形软 ...
python-day21--os模块
os模块是与操作系统交互的一个接口''' os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径 os.chdir("dirname") 改变当前脚本工作 ...
nyoj 1237 简单dfs
最大岛屿时间限制:1000 ms | 内存限制:65535 KB 难度:2 描述神秘的海洋,惊险的探险之路,打捞海底宝藏,激烈的海战,海盗劫富等等.加勒比海盗,你知道吧?杰克船长驾驶着自己 ...

Spring DI

Spring DI的更多相关文章

随机推荐

热门专题