Spring学习--DI依赖注入

**依赖与依赖注入：**
    传统应用程序设计中所说的依赖一般指“类之间的关系”，那先让我们复习一下类之间的关系：
         **泛化：**表示类与类之间的继承关系、接口与接口之间的继承关系；
         **实现：**表示类对接口的实现；
         **依赖：**当类与类之间有使用关系时就属于依赖关系，不同于关联关系，依赖不具有“拥有关系”，而是一种“相识关系”，只在某个特定地方（比如某个方法体内）才有关系。
         **关联：**表示类与类或类与接口之间的依赖关系，表现为“拥有关系”；具体到代码可以用实例变量来表示；
         **聚合：**属于是关联的特殊情况，体现部分-整体关系，是一种弱拥有关系；整体和部分可以有不一样的生命周期；是一种弱关联；
         **组合：**属于是关联的特殊情况，也体现了体现部分-整体关系，是一种强“拥有关系”；整体与部分有相同的生命周期，是一种强关联；
**Spring IoC容器的依赖有两层含义：Bean依赖容器和容器注入Bean的依赖资源**：
     **Bean依赖容器：**也就是说Bean要依赖于容器，这里的依赖是指容器负责创建Bean并管理Bean的生命周期，正是由于由容器来控制创建Bean并注入依赖，也就是控制权被反转了，这也正是IoC名字的由来，此处的有依赖是指Bean和容器之间的依赖关系。
     **容器注入Bean的依赖资源：**容器负责注入Bean的依赖资源，依赖资源可以是Bean、外部文件、常量数据等，在Java中都反映为对象，并且由容器负责组装Bean之间的依赖关系，此处的依赖是指Bean之间的依赖关系，可以认为是传统类与类之间的“关联”、“聚合”、“组合”关系。
**为什么要应用依赖注入，应用依赖注入能给我们带来哪些好处呢？**
     **动态替换Bean依赖对象，程序更灵活：**替换Bean依赖对象，无需修改源文件：应用依赖注入后，由于可以采用配置文件方式实现，从而能随时动态的替换Bean的依赖对象，无需修改java源文件；
     **更好实践面向接口编程，代码更清晰：**在Bean中只需指定依赖对象的接口，接口定义依赖对象完成的功能，通过容器注入依赖实现；
     **更好实践优先使用对象组合，而不是类继承：**因为IoC容器采用注入依赖，也就是组合对象，从而更好的实践对象组合。采用对象组合，Bean的功能可能由几个依赖Bean的功能组合而成，其Bean本身可能只提供少许功能或根本无任何功能，      全部委托给依赖Bean，对象组合具有动态性，能更方便的替换掉依赖Bean，从而改变Bean功能；而如果采用类继承，Bean没有依赖Bean，而是采用继承方式添加新功能，，而且功能是在编译时就确定了，不具有动态性，而且采用类继承导致Bean与子Bean之间高度耦合，难以复用。
     **增加Bean可复用性：**依赖于对象组合，Bean更可复用且复用更简单；
     **降低Bean之间耦合：**由于我们完全采用面向接口编程，在代码中没有直接引用Bean依赖实现，全部引用接口，而且不会出现显示的创建依赖对象代码，而且这些依赖是由容器来注入，很容易替换依赖实现类，从而降低Bean与依赖之间耦合；
     **代码结构更清晰：**要应用依赖注入，代码结构要按照规约方式进行书写，从而更好的应用一些最佳实践，因此代码结构更清晰。
**Spring IoC容器注入依赖资源主要有以下两种基本实现方式：**
     **构造器注入：**就是容器实例化Bean时注入那些依赖，通过在在Bean定义中指定构造器参数进行注入依赖，包括实例工厂方法参数注入依赖，但静态工厂方法参数不允许注入依赖；
     **setter注入：**通过setter方法进行注入依赖；

---

entity

package org.liang.entity;

import java.util.Arrays;
import java.util.Map;

/**
 * Created by rcc on 2018/1/20.
 */
public class StudentName {
    private String[] names;
    private Map address;
    private User user;

    public StudentName(User user) {
        this.user = user;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public StudentName(Map address) {
        this.address = address;
    }

    public StudentName(String[] names, Map address) {
        this.names = names;
        this.address = address;
    }

    public StudentName(String[] names, Map address, User user) {
        this.names = names;
        this.address = address;
        this.user = user;
    }

    public Map getAddress() {
        return address;
    }

    public void setAddress(Map address) {
        this.address = address;
    }

    public StudentName() {
    }

    public StudentName(String[] names) {
        this.names = names;
    }

    public String[] getNames() {
        return names;
    }

    public void setNames(String[] names) {
        this.names = names;
    }

    @Override
    public String toString() {
        return "StudentName{" +
                "names=" + Arrays.toString(names) +
                ", address=" + address +
                ", user=" + user +
                '}';
    }
}

spring-config.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.xsd">


   

    <bean id="userService" class="org.liang.service.UserServiceImpl" />

    <bean id="persion" class="org.liang.entity.Persion">
        <constructor-arg index="0" value="doudou"/>
        <constructor-arg name="nickName" value="zhuzhu"/>
        <constructor-arg type="java.lang.Integer" value="18"/>
    bean>

    
    <bean id="userFactory" class="org.liang.factory.BeanFactory" factory-method="newInstance">
        <constructor-arg index="0" value="施瓦辛格"/>
        <constructor-arg name="gender" value="男"/>
        <constructor-arg type="java.lang.Integer" value="50"/>
    bean>

    
    <bean id="user" class="org.liang.entity.User">
        <property name="name" value="张三"/>
        <property name="gender" value="男"/>
        <property name="age" value="18"/>
    bean>

    
    <bean id="students" class="org.liang.entity.StudentName">
        <property name="names">
            <list value-type="java.lang.String">
                <value>张三value>
                <value>李四value>
                <value>王二value>
            list>
        property>
        <property name="address">
            <map key-type="java.lang.String" value-type="java.lang.String">
                <entry>
                    <key><value>10010value>key>
                    <value>张三value>
                entry>
                <entry>
                    <key><value>10020value>key>
                    <value>李四value>
                entry>
                <entry>
                    <key><value>10030value>key>
                    <value>王二value>
                entry>
            map>
        property>
        <property name="user" ref="user">
        property>
    bean>
beans>

test

package org.liang.test;

import org.liang.entity.Persion;
import org.liang.entity.StudentName;
import org.liang.entity.User;
import org.liang.factory.BeanFactory;
import org.liang.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by rcc on 2018/1/19.
 * 测试类
 */
public class TestUser {
    public static void main(String [] args){

        /*ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        Persion persion = context.getBean("persion", Persion.class);
        System.out.print(persion);*/
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        StudentName students = (StudentName) context.getBean("students");
        System.out.println(students);

    }
}

以上的示例呢是一个错误的示例，在工作或者学习中需要避免产生这种循环注入的情况，一旦产生这样的情况后果是很严重的，所以，在依赖注入的时候需要避免这样的你中有我我中有你的情况。