Spring学习——DI依赖注入-蒲公英云

Spring DI（Dependency Injection，依赖注入）GitHub demo源码

   是指程序运行过程中，如果需要调用另一个对象协助时，**无须在代码中创建被调用者，而是依赖于外部的注入**。Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。

1、基于构造函数的依赖注入

java 类

package com.spring.DI.example;
public class AConstructor {
    private B b;
    public AConstructor(B b){
        System.out.println("AConstructor 构造函数");
        this.b = b;
    }
    public void aConstructorSpeack(){
        b.bSpeack();
    }
}

Beans1.xml配置文件 使用指定标签声明

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   <bean id="AConstructor" class="com.spring.DI.example.AConstructor">
       <!-- 构造函数依赖注入 -->
      <constructor-arg ref="B"/>
   </bean>
   <bean id="B" class="com.spring.DI.example.B">
   </bean>
</beans>

2、基于get/set函数的依赖注入

java类：

package com.spring.DI.example;
public class AFunction {
    private B b;
    public void setB(B b){
        System.out.println("AFunction 设置B");
        this.b = b;
    }
    public B getB(){
        return b;
    }
    public void aFunctionSpeack(){
        b.bSpeack();
    }
}

Beans2.xml:

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="AFunction" class="com.spring.DI.example.AFunction">
       <!-- get/set函数依赖注入 -->
      <property name="b" ref="B"/>
   </bean>
   <bean id="B" class="com.spring.DI.example.B">
   </bean>
</beans>

3、基于注入内部bean的依赖注入

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="AFunction" class="com.spring.DI.example.AFunction">
           <!-- 内部beans依赖注入 -->
          <property name="b">
              <bean id="B" class="com.spring.DI.example.B"/>
          </property>
   </bean>
</beans>

4、java集合依赖注入

java类

package com.spring.DI.example;
import java.util.*;
public class JavaCollection {
    private List list;
    private Set  set;
    private Map  map;
    private Properties properties;
    public List getList() {
        return list;
    }
    public void setList(List list) {
        this.list = list;
    }
    public Set getSet() {
        return set;
    }
    public void setSet(Set set) {
        this.set = set;
    }
    public Map getMap() {
        return map;
    }
    public void setMap(Map map) {
        this.map = map;
    }
    public Properties getProperties() {
        return properties;
    }
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
}

Beans4.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="JavaCollection" class="com.spring.DI.example.JavaCollection">
           <!-- list依赖注入 -->
          <property name="list">
              <list>
                  <value>list1</value>
                  <value>list2</value>
                  <value>list3</value>
                  <value>list4</value>
              </list>
          </property>
          <!-- set依赖注入 -->
          <property name="set">
              <set>
                  <value>set1</value>
                  <value>set2</value>
                  <value>set3</value>
                  <value>set4</value>
              </set>
          </property>
          <!-- map依赖注入 -->
          <property name="map">
              <map>
                  <entry key="1" value="map1"/>
                  <entry key="2" value="map2"/>
                  <entry key="3" value="map3"/>
                  <entry key="4" value="map4"/>
              </map>
          </property>
          <!-- property依赖注入 -->
          <property name="properties">
         <props>
            <prop key="one">prop1</prop>
            <prop key="two">prop2</prop>
            <prop key="three">prop3</prop>
            <prop key="four">prop4</prop>
         </props>
      </property>
   </bean>
</beans>

主程序：SpringMain

package com.spring.DI.example;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringMain {
    public static void main(String[] arg){
        System.out.println("-------读取beans1文件---------");
        ApplicationContext context1 = new ClassPathXmlApplicationContext("Beans1.xml");
        System.out.println("----构造函数依赖注入------");
        AConstructor ac =(AConstructor) context1.getBean("AConstructor");
        ac.aConstructorSpeack();
        System.out.println("-------读取beans2文件---------");
        ApplicationContext context2 = new ClassPathXmlApplicationContext("Beans2.xml");
        System.out.println("----get/set依赖注入------");
        AFunction af = (AFunction) context2.getBean("AFunction");
        af.aFunctionSpeack();
        System.out.println("-------读取beans3文件---------");
        ApplicationContext context3 = new ClassPathXmlApplicationContext("Beans3.xml");
        System.out.println("----get/set依赖注入------");
        AFunction af1 = (AFunction) context3.getBean("AFunction");
        af.aFunctionSpeack();
        System.out.println("-------读取beans4文件---------");
        ApplicationContext context4 = new ClassPathXmlApplicationContext("Beans4.xml");
        System.out.println("----集合依赖注入------");
        JavaCollection js = (JavaCollection) context4.getBean("JavaCollection");
        System.out.println("list"+js.getList());
        System.out.println("map"+js.getMap());
        System.out.println("set"+js.getSet());
        System.out.println("properties"+js.getProperties());
    }
}