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