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

随机推荐

《剑指offer》第二十二题（链表中倒数第k个结点）
// 面试题22:链表中倒数第k个结点 // 题目:输入一个链表,输出该链表中倒数第k个结点.为了符合大多数人的习惯, // 本题从1开始计数,即链表的尾结点是倒数第1个结点.例如一个链表有6个结点, ...
java日期操作大全
先来一个: 取得指定月份的第一天与取得指定月份的最后一天 http://iamin.blogdriver.com/iamin/847990.html )); } ...
JavaScript权威指南--脚本化CSS
知识要点客户端javascript程序员对CSS感兴趣的是因为样式可以通过脚本编程.脚本化css启用了一系列有趣的视觉效果.例如:可以创建动画让文档从右侧“滑入”.创造这些效果的javascript ...
Cocos2dx 3.x 屏幕适配
Cocos2dx 3.10+Cocos Studio3.10 1.在适配过程中必须明确几个概念: ①Frame大小:这个值在windows/mac/linux下就是创建窗体的大小,在手机上就是屏幕大小 ...
Unity + NGUI 实现人物头顶UI的信息展示
1.思路: (1)信息数据:需要展示属性信息 (2)信息的展示:负责显示UI属性信息 (3)UI的跟随:负责实现UI对人物的跟随 (4)UI的管理:负责对UI进行创建于回收,游戏中需要用到UI的地方都 ...
Linux系统基本常识
在虚拟机里装一个Linux(centos),有时间可以装个mac玩一下.(使用centos或者Ubuntu时安装软件将会非常方便) ifconfig –a 显示当前Linux主机的 ip 地址如何让 ...
3.4 复杂的x86指令举例
计算机组成 3 指令系统体系结构 3.4 复杂的x86指令举例 x86作为复杂指令系统的代表,自然会有不少相当复杂的指令.在这一节我们将会看到其中有代表性的一些例子. 关于复杂的x86指令,我们这里举 ...
hdu 6396 Swordsman (技巧)
大意: n个怪, m种能力值, 当自己所有能力值不低于某只怪时可以杀死它, 并获得它的所有能力, 求最大杀几只将每只怪拆成$m$个, 排下序贪心即可, 复杂度$O(nm)$, 原题极其卡时间, 我的 ...
『cs231n』作业3问题4选讲_图像梯度应用强化
[注],本节(上节也是)的model是一个已经训练完成的CNN分类网络. 随机数图片向前传播后对目标类优化,反向优化图片本体 def create_class_visualization(target ...
Angular2 -- 生命周期
组件生命周期钩子指令和组件的实例有一个生命周期:新建.更新和销毁. 每个接口都有唯一的一个钩子方法,它们的名字是由接口名加上 ng前缀构成的.比如,OnInit接口的钩子方法叫做ngOnInit. ...

Spring DI

Spring DI的更多相关文章

随机推荐

热门专题