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 实例时,传统的方法是由调用者创建被调用者的 ...

随机推荐

android 管理fragment
要管理fragment们,需使用FragmentManager,要获取它,需在activity中调用方法getFragmentManager(). 你可以用FragmentManager来做以上事情: ...
ActivityGroup实现tab功能
android.app包中含有一个ActivityGroup类,该类是Activity的容器,可以包含多个嵌套进来的 Activitys,这篇文章就是借助ActivityGroup可以嵌套Activi ...
English trip M1 - PC12 I'd Like a Room Please Teacher:Taalan
In this lesson you will learn to say what you need. 在本课中,您将学习如何说出您的需求. Words list elevator 电梯 ...
English trip M1 - PC9 Where am I Teacher:Jade
In this lesson you will learn to ask for and give directions # 在本课中,您将学习如何提出要求并给出指示 Words North ...
3.6 MIPS指令简介
计算机组成 3 指令系统体系结构 3.6 MIPS指令简介 MIPS秉承着指令数量少,指令功能简单的设计理念.那这样的设计理念是如何实现的呢?在这一节,我们就将来分析MIPS指令的特点. 相比于X86 ...
synchronized同步代码块锁释放
今天发现自己写的线上程序出现数据库不能同步的问题,查看日志已经停止记录,随后使用jstack查看线程的运行状况,发现有个同步线程锁住了. 以下是jstack -l 637 问题线程的内容. &quo ...
Weird journey CodeForces - 788B (路径计数)
大意:$n$结点$m$条边无向图, 满足 $(1)$经过$m-2$条边$2$次 $(2)$经过其余$2$条边$1$次的路径为好路径, 求所有好路径数相当于边加倍后再删除两条边, 求欧拉路条数首先 ...
ZOJ-3329 One Person Game （有环期望问题）
题目大意:有3个骰子,各有k1,k2,k3个面,面值为1~ki.还有一个计数器,初始值为0,统计所有的面值和.每次同时置这三个骰子,如果第一个骰子的朝上的值为a.第二个值为b.第三个值为c,那么将计数 ...
最应该注意的Oracle版本之一
最近以来,两个用户的库接连出现问题,经过查阅资料和分析,确定为数据库bug所致,其实,早在很久前,也遭遇过这个版本的类似bug,当时似乎还惊动了原厂的技术人员,后来确定为这个版本的bug,这个版本就是 ...
JS获取昨天/今天/今年第一天的方法
talk is cheap,show me the code! //获取昨天 var day1 = new Date(); day1.setTime(day1.getTime()-24*60*60*1 ...

Spring DI

Spring DI的更多相关文章

随机推荐

热门专题