【Spring学习笔记】—— （一）IOC/Bean/依赖注入DI

程序员文章站 2022-03-16 18:51:10

...

一、Spring 概述

1. Spring是什么

以IOC（反转控制）和AOP（面向切面编程）为内核

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果

2. Spring体系结构

【Spring学习笔记】—— （一）IOC/Bean/依赖注入DI
ORM: 对象关系映射（Object Relational Mapping，简称ORM）是通过使用描述对象和数据库之间映射的元数据，将面向对象语言程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式。

3. Spring的优势

方便解耦，简化开发
通过 Spring提供的 IoC容器，可以将对象间的依赖关系交由 Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
AOP编程的支持
通过 Spring的 AOP 功能，方便进行面向切面的编程，许多不容易用传统OOP(面向对象编程) 实现的功能可以通过 AOP 轻松应付。
声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。
方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
方便集成各种优秀框架
Spring可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz 等）的直接支持。
降低 JavaEE API的使用难度
Spring对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。

二、IOC 的概念和作用

1. 程序的耦合

类之间的依赖
方法间的依赖

解耦：降低程序间的依赖关系

实际开发中应该做到，编译期不依赖，运行时才依赖

我们在开发中，有些依赖关系是必须的，有些依赖关系可以通过优化代码来解除的。
// 账户的业务层实现类  
 public class AccountServiceImpl implements IAccountService {  
 	private IAccountDao accountDao = new AccountDaoImpl(); 
 }  
上面的代码表示：业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通过。这种编译期依赖关系，应该在我们开发中杜绝。我们需要优化代码解决。

再比如：
DriverManager.registerDriver(new com.mysql.jdbc.Driver())
改为
Class.forName("com.mysql.jdbc.Driver");
原因就是：我们的类依赖了数据库的具体驱动类（MySQL），如果这时候更换了数据库品牌（比> 如 Oracle），需要修改源码来重新数据库驱动。这显然不是我们想要的。

2. 解耦的思路

使用反射来创建对象，而避免使用new关键字

3. 工厂模式解耦

工厂模式中的问题

通过 Idea 创建 maven 项目
编写接口及实现类

IAccountDao

  /**
   * 账户的持久层接口
   */
  public interface IAccountDao {
  
      /**
       * 模拟保存账户
       */
      void saveAccount();
  }

IAccountService

  /**
   * 账户业务层的接口
   */
  public interface IAccountService {
  
      /**
       * 模拟保存账户
       */
      void saveAccount();
  }

AccountDaoImpl

  /**
   * 账户的持久层实现类
   */
  public class AccountDaoImpl implements IAccountDao {
  
      public  void saveAccount(){
  
          System.out.println("保存了账户");
      }
  }

AccountServiceImpl

  /**
   * 账户的业务层实现类
   */
  public class AccountServiceImpl implements IAccountService {
  
      private IAccountDao accountDao = new AccountDaoImpl();
  
      public void  saveAccount(){
          accountDao.saveAccount();
      }
  }

模拟一个表现层，用于调用业务层 ui/Client

public class Client {
    public static void main(String[] args) {
        IAccountService as = new AccountServiceImpl();
        as.saveAccount();
    }
}

传统JavaWeb写法耦合性太高，所有文件缺一不可

解耦（多例）

Bean: 可重用组件

javaBean: 用java语言编写的可重用组件。 javaBean > 实体类

解耦方法：

需要一个配置文件（xml/properties）来配置我们的service和dao
- 配置的内容：唯一标识 = 全限定类名
  
  resource/bean.properties
```
accountService = com.smallbeef.service.impl.AccountServiceImpl;
accountDao = com.smallbeef.service.impl.AccountDaoImpl;
```
通过过读取配置文件中内容，反射创建对象(用工厂模式创建对象)

bean/BeanFactory.java

// 一个创建Bean对象的工厂
public class BeanFactory{
    //定义一个properties对象
    private static Properties props;
    //使用静态代码块为Properties对象赋值
    static{
        //实例化对象
        props = new Properties();
        //获取properties文件的流对象
        InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            props.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据Bean的名称获取bean对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        Object bean = null;
        String beanPath = props.getProperty(beanName);
        try {
            // 通过反射new一个对象
            //newInstance每次都会调用默认构造函数创建对象
            bean = Class.forName(beanPath).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return bean;
    }
}

修改创建对象的方式

public class Client {
    public static void main(String[] args) {
//        IAccountService as = new AccountServiceImpl();
        IAccountService as = (IAccountService) BeanFactory.getBean("accountService");
        as.saveAccount();

    }
}

public class AccountServiceImpl implements IAccountService {

//    private IAccountDao accountDao = new AccountDaoImpl();
    private IAccountDao accountDao = (IAccountDao) BeanFactory.getBean("accountDao");

    public void  saveAccount(){
        accountDao.saveAccount();
    }

}

即使缺少 serviceimpl 或 daoimpl 文件代码在编译时并不会报错

【Spring学习笔记】—— （一）IOC/Bean/依赖注入DI

工厂模式解耦升级版（单例）

利用容器存储每次new出来的对象

// 一个创建Bean对象的工厂
public class BeanFactory{
    
    //定义一个properties对象
    private static Properties props;
    
    // 定义一个Map,用于存放我们要创建的对象，我们把它称之为容器
   	private static Map<String, Object> beans;
    
    //使用静态代码块为Properties对象赋值
    static{
        //实例化对象
        props = new Properties();
        //获取properties文件的流对象
        InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            props.load(in);
            
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的key
            Enumeration keys = props.keys();
            //遍历枚举
            while(keys.hasMoreElements()){
                //取出每个key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
                
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
	 /**
     * 根据Bean的名称获取对象 单例
     * @param beanName
     * @return
     */
     public static Object getBean(String beanName){
         return beans.get(beanName);
     }
    
    /**
     * 根据Bean的名称获取bean对象 多例
     * @param beanName
     * @return
     */
//    public static Object getBean(String beanName){
//        Object bean = null;
//        String beanPath = props.getProperty(beanName);
//        try {
//            // 通过反射new一个对象
//            //newInstance每次都会调用默认构造函数创建对象
//            bean = Class.forName(beanPath).newInstance();
//        } catch (InstantiationException e) {
//            e.printStackTrace();
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        }
//        return bean;
//    }
}

4. IOC的概念

IOC = 控制反转 = Inversion Of Control

什么是工厂？
【Spring学习笔记】—— （一）IOC/Bean/依赖注入DI

ioc只能解决程序间的依赖关系，别的事情都干不了

三、使用 spring的 IOC解决程序耦合

1. 案例

建立Maven工程

导入springframework依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
    </dependencies>

创建配置文件bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <!--把对象的创建交割spring来管理-->
    <bean id = "accountService" class = "com.smallbeef.service.impl.AccountServiceImpl"></bean>
    <bean id = "accountDao" class = "com.smallbeef.dao.impl.AccountDaoImpl"></bean>
</beans>

ioc容器根据id唯一获取对象

测试

public class Client {

    /**
     * 获取spring的Ioc容器，并根据id获取对象
     * @param args
     */
    public static void main(String[] args) {
        //1.使用 ApplicationContext 接口，就是在获取 spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2.根据 bean 的 id 获取对象
        IAccountService aService = (IAccountService) ac.getBean("accountService");
        System.out.println(aService);

        IAccountDao aDao = (IAccountDao) ac.getBean("accountDao");
        System.out.println(aDao);

    }
}

【Spring学习笔记】—— （一）IOC/Bean/依赖注入DI

2. ApplicationContext 的三个常用实现类

ClassPathXmlApplicationContext
它可以加载类路径下的配置文件，要求配置文件必须在类路径下。

 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

FileSystemXmlApplicationContext
它可以加载磁盘任意路径下的配置文件（必须有访问权限）

ApplicationContext ac = new FileSystemXmlApplicationContext("E:\\Codes\\Spring-Programs\\spring01\\src\\main\\resources\\bean.xml");

AnnotationConfigApplicationContext
它是用于读取注解创建容器的，见后续博客

3. BeanFactory和 ApplicationContext 的区别

ApplicationContext 单例对象适用（一般采用此接口，Spring可根据配置文件智能决定创建对象的方式）

它在创建容器时，创建对象采取的策略是采用立即加载的方式，也就是说，：只要一读取配置文件，默认情况下就马上会创建对象。

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

执行完这条语句即读取配置文件之后对象就被创建了
BeanFactory 多例对象适用

它在创建容器时，创建对象采取的策略是采用延迟加载的方式，也就是说，什么时候根据id获取对象了，什么时候才真正创建对象
```
//--------------BeanFactory-----------------
        Resource resource =  new ClassPathResource("bean.xml");
        BeanFactory factory = new XmlBeanFactory(resource);
        IAccountService aService = (IAccountService) factory.getBean("accountService");
        System.out.println(aService);
```
执行到IAccountService aService = (IAccountService) factory.getBean("accountService");这条语句，即对象需要被使用的时候对象才会被创建

四、IOC 中 bean 标签和管理对象细节

1. 创建bean的三种方式

第一种：使用默认构造函数创建

在spring的配置文件中使用bean标签，配以id和class属性后，且没有其他属性和标签时。采用的就是默认构造函数创建bean对象，此时如果 bean（类）中没有默认无参构造函数，将会创建失败

bean标签：

作用：用于配置对象让 spring 来创建的。默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

属性：

id：给对象在容器中提供一个唯一标识。用于获取对象。

class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。

scope：指定对象的作用范围。（见bean的生命周期）

<bean id = "accountService" class = "com.smallbeef.service.impl.AccountServiceImpl"></bean>
第二种：spring管理普通工厂- 使用普通工厂的方法创建对象(使用某个类中的方法创建对象，并存入spring容器)

  /** 
   * 模拟一个工厂类
   * 该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数
   * 此工厂创建对象，必须现有工厂实例对象，再调用方法  
   */ 
  public class InstanceFactory {   
      public IAccountService createAccountService(){   
          return new AccountServiceImpl();  
      }
}

  <bean id = "InstanceFactory" 
  		class = "com.smallbeef.factory.InstanceFactory">
  </bean>
  
  <bean id="accountService"  
  		factory-bean="InstanceFactory"     
  	 	factory-method="createAccountService">
  </bean>

先把工厂的创建交给 spring 来管理。然后在使用工厂的 bean 来调用里面的方法

id 属性：指定 bean 的 id，用于从容器中获取

factory-bean 属性：用于指定实例工厂 bean 的 id。

factory-method 属性：用于指定实例工厂中创建对象的方法。

第三种：spring管理静态工厂-使用静态工厂的方法创建对象 (使用某个类中的静态方法创建对象，并存入spring容器)

/** 
 * 模拟一个静态工厂类
 * 该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数
 */ 
public class StaticFactory {   
    public static IAccountService createAccountService(){   
        return new AccountServiceImpl();  
    } 
}

<bean id="accountService"  
   	  class="com.itheima.factory.StaticFactory"     
      factory-method="createAccountService">
</bean>

2. bean对象的作用范围

bean标签的scope属性：

作用：指定bean的作用范围

取值：

singleton : 默认值，单例的. （bean对象默认是单例模式）
prototype : 多例的.
request : 作用于web应用的请求范围。WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
session : 作用于web应用的会话范围。WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
global-session :作用于集群环境的会话范围。WEB 项目中,应用在 Portlet（集群）环境.如果没有 Portlet 环境那么 globalSession 相当于 session.

全局session

3. bean对象的生命周期

bean 标签：

init-method：指定类中的初始化方法名称。

destroy-method：指定类中销毁方法名称。

单例对象：scope="singleton"

一个应用只有一个对象的实例。它的作用范围就是整个引用。

生命周期：

对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

总结： 单例对象的生命周期和容器相同

多例对象：scope="prototype"

每次访问对象时，都会重新创建对象实例。

生命周期：

对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用，且没有别的对象引用时，由 java 的垃圾回收器进行回收。

五、spring的依赖注入 DI

1. 什么是依赖注入

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。

我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。 ioc 解耦只是降低他们的依赖关系，但不会消除。

例如：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。

简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

IOC的作用：
降低程序间的耦合（依赖关系）
依赖关系的管理：
都交给spring来管理。
在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件种说明
依赖关系的维护：就称之为依赖注入
依赖注入：
a. 能注入的数据有三类：
- 基本类型和String
- 其他bean类型（在配置文件中或者注解配置过的bean)
- 复杂类型/集合类型
b. 注入的方式有三种：
- 使用构造函数提供
- 使用set方法提供
- 使用注解提供（第二天内容）

2. 构造函数注入

顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。

构造函数注入：
使用的便签：constructor-arg
标签出现的位置：bean标签的内部
标签中的属性：
- index:指定要注入的数据在构造函数参数列表的索引位置，从0开始
- type: 用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
- name:用于给构造函数中指定名称的参数赋值
- value:它能赋的值是基本数据类型和 String 类型
- ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中或者注解中配置过的 bean

上面三个都是用于指定给谁赋值，下面两个指的是赋什么值的

具体代码如下：

public class AccountServiceImpl implements IAccountService {    
    private String name;  
    private Integer age;  
    private Date birthday;     
    public AccountServiceImpl(String name, Integer age, Date birthday) {   
        this.name = name;   
        this.age = age;   
        this.birthday = birthday;  
    }

    @Override  
    public void saveAccount() {   
        System.out.println(name+","+age+","+birthday);   
    } 
}

<bean id = "accountService" class = "com.smallbeef.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="test"></constructor-arg>
        <constructor-arg name = "age" value="20"></constructor-arg>
        <constructor-arg name = "birthday" ref="now"></constructor-arg>
    </bean>

    <!--配置一个日期对象
        读取这个类名通过反射创建对象并存入spring容器中，我们可以通过id来使用它
    -->
    <bean id="now" class="java.util.Date"></bean>

public class Client {

    /**
     * 获取spring的Ioc容器，并根据id获取对象
     * @param args
     */
    public static void main(String[] args) {
        //1.使用 ApplicationContext 接口，就是在获取 spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2.根据 bean 的 id 获取对象
        IAccountService aService = (IAccountService) ac.getBean("accountService");
        aService.saveAccount();

    }
}

构造函数的优点：
在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功
缺点：
改变了bean对象的实例化方式，使我们在创建对象时，即使用不到这些数据时，也得给他们都赋值

2. set方法注入常用

顾名思义，就是在类中提供需要注入成员的 set 方法。

涉及的标签：property
出现的位置：bean标签的内部
标签的属性：
- name: 指定注入时所调用的set方法名称
- value: 它能赋的值是基本数据类型和 String 类型
- ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中或者注解中配置过的 bean

具体代码如下：

public class AccountServiceImpl implements IAccountService {
    private String name;
    private Integer age;
    private Date birthday;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public void saveAccount() {
        System.out.println(name+","+age+","+birthday);
    }
}

<bean id = "accountService" class = "com.smallbeef.service.impl.AccountServiceImpl">
        <property name="name" value="test"></property>
        <property name="age" value="20"></property>
        <property name="birthday" ref = "now"></property>
    </bean>

    <bean id="now" class="java.util.Date"></bean>

set注入的优势：
创建对象时没有明确的限制，可以直接使用默认构造函数
缺点：
如果某个成员必须有值，则获取对象时有可能set方法没有执行

3. 集合类型的注入(本质还是set)

用于给list结构集合注入数据的标签：list、array、set

用于给Map结构集合注入数据的标签 : map、props

结构相同，标签可以互换

public class AccountServiceImpl implements IAccountService {
    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;

    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    @Override
    public void saveAccount() {
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);
    }
}

<bean id = "accountService" class = "com.smallbeef.service.impl.AccountServiceImpl">

        <property name="myStrs">
            <array>
                <value>A</value>
                <value>B</value>
                <value>C</value>
            </array>
        </property>

        <property name="myList">
            <list>
                <value>A</value>
                <value>B</value>
                <value>C</value>
            </list>
        </property>

        <property name="mySet">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>

        <property name="myMap">
            <map>
                <entry key="testA" value="A"></entry>
                <entry key="testB">
                    <value>B</value>
                </entry>
            </map>
        </property>

        <property name="myProps">
            <props>
                <prop key="testC">C</prop>
                <prop key="testD">D</prop>
            </props>
        </property>

    </bean>

【Spring学习笔记】—— （一）IOC/Bean/依赖注入DI

文章目录

一、Spring 概述

1. Spring是什么

2. Spring体系结构

3. Spring的优势

二、IOC 的概念和作用

1. 程序的耦合

2. 解耦的思路

3. 工厂模式解耦

工厂模式中的问题

解耦（多例）

工厂模式解耦升级版（单例）

4. IOC的概念

三、使用 spring的 IOC解决程序耦合

1. 案例

2. ApplicationContext 的三个常用实现类

3. BeanFactory和 ApplicationContext 的区别

四、IOC 中 bean 标签和管理对象细节

1. 创建bean的三种方式

2. bean对象的作用范围

3. bean对象的生命周期

五、spring的依赖注入 DI

1. 什么是依赖注入

2. 构造函数注入

2. set方法注入常用

3. 集合类型的注入(本质还是set)

MVC使用Spring.Net应用IOC（依赖倒置）学习笔记3

荐 Spring 学习笔记①：IoC容器、Bean与注入

ASP.NET MVC 中 Autofac依赖注入DI 控制反转IOC 了解一下

Spring:依赖注入(DI)学习笔记

大话DI依赖注入+IOC控制反转（一）之定义

在Spring IoC中，依赖注入和依赖查找的数据来源一样吗？

Spring IOC DI依赖注入 IOC容器 Spring Bean的声明周期

Spring入门 IOC理论，第一个spring程序Di依赖注入，Bean的自动装配

spring-依赖注入(DI)&控制反转(Ioc)&Bean的三种装配方式

Spring(一)----IOC控制反转、DI依赖注入

【Spring学习笔记】—— （一）IOC/Bean/依赖注入DI

文章目录

一、Spring 概述

1. Spring是什么

2. Spring体系结构

3. Spring的优势

二、IOC 的概念和作用

1. 程序的耦合

2. 解耦的思路

3. 工厂模式解耦

工厂模式中的问题

解耦（多例）

工厂模式解耦升级版（单例）

4. IOC的概念

三、使用 spring的 IOC解决程序耦合

1. 案例

2. ApplicationContext 的三个常用实现类

3. BeanFactory和 ApplicationContext 的区别

四、IOC 中 bean 标签和管理对象细节

1. 创建bean的三种方式

2. bean对象的作用范围

3. bean对象的生命周期

五、spring的依赖注入 DI

1. 什么是依赖注入

2. 构造函数注入

2. set方法注入 常用

3. 集合类型的注入(本质还是set)

MVC使用Spring.Net应用IOC（依赖倒置）学习笔记3

荐 Spring 学习笔记①：IoC容器、Bean与注入

ASP.NET MVC 中 Autofac依赖注入DI 控制反转IOC 了解一下

Spring:依赖注入(DI)学习笔记

大话DI依赖注入+IOC控制反转（一） 之 定义

在Spring IoC中，依赖注入和依赖查找的数据来源一样吗？

Spring IOC DI依赖注入 IOC容器 Spring Bean的声明周期

Spring入门 IOC理论，第一个spring程序Di依赖注入，Bean的自动装配

spring-依赖注入(DI)&控制反转(Ioc)&Bean的三种装配方式

Spring(一)----IOC控制反转、DI依赖注入

2. set方法注入常用

大话DI依赖注入+IOC控制反转（一）之定义