作者：狮子也疯狂

专栏：《spring开发》

坚持做好每一步，幸运之神自然会驾凌在你的身上

目录

• 一. 🦁 前言
• 二. 🦁 控制反转（IOC）
• • Ⅰ. 🐇主要思想
  • Ⅱ. 🐇原生技术创建实例弊端
  • Ⅲ. 🐇自定义对象容器
  • • 3.1 准备数据
    • 3.2 创建配置文件
    • 3.3 创建容器管理类
    • 3.4 创建StudentService对象
    • 3.5 测试StudentService
    • Ⅳ. 🐇Spring实现IOC
    • • 4.1 创建Maven工程
      • 4.2 创建dao
      • 4.3 编写xml配置文件
      • 4.4 测试
      • Ⅵ. 🐇常见的spring容器类型
      • • 6.1 容器接口
        • Ⅶ. 🐇IOC生命周期方法
        • Ⅷ. 🐇依赖注入
        • • 8.1 原理
          • 8.2 注入方式
          • • 8.2.1 Setter注入
            • 8.2.2 构造方法注入
            • 8.2.3 自动注入
            • 三. 🦁总结

              一. 🦁 前言

              Spring框架是狮子入坑Java的第一个开源框架。当我们接触到它时，总会发现老师或者书本介绍这两个词汇——IOC和AOP,它们分别是控制反转和面向切面，是Spring的思想内核，提供了控制层SpringMVC、数据层SpringData、服务层事务管理等众多技术，并可以整合众多第三方框架。现在我们通过自己手写一个简单的模板来深入地认识一下IOC。

              二. 🦁 控制反转（IOC）

              

              Ⅰ. 🐇主要思想

              IOC(Inversion of Control) ：程序将创建对象的权利交给框架，框架会帮助我们创建对象，分配对象的使用，控制权由程序代码转移到了框架中，控制权发生了反转，这就是Spring的IOC思想。

              Ⅱ. 🐇原生技术创建实例弊端

              我们之前在开发过程中，对象实例的创建是由调用者直接管理的，在每个层，需要用到某个对象时，都需要重新实现。我们通过一个简单的例子，来搞清楚这个方法的弊端：

              public interface StudentDao {    
              	// 根据id查询学生
                  Student findById(int id);
               }
              public class StudentDaoImpl implements StudentDao{
                  @Override
                 public Student findById(int id) {
                        // 模拟从数据库查找出学生
                       return new Student(1,"JackieYe","茂名");
                 }
              }
              public class StudentService {
                  public Student findStudentById(int id){
                         // 此处就是调用者在创建对象
                      StudentDao studentDao = new StudentDaoImpl();
                      return studentDao.findById(1);
                 }
              }
              

              这样的写法，缺点有二：

              • 浪费资源：StudentService调用方法时即会创建一个对象，如果不断调用 方法则会创建大量StudentDao对象。
              • 代码耦合度高：假设随着开发，我们创建了StudentDao另一个更加完善的实现类StudentDaoImpl2，如果在StudentService中想使StudentDaoImpl2，则必须修改源码。

              Ⅲ. 🐇自定义对象容器

              现在我们来通过一段手写代码模拟一下spring的IOC思想。过程如下：

              1. 创建一个集合容器。
              2. 创建对象，然后放到容器中。
              3. 从容器中获取对象。

              3.1 准备数据

              在此之前，我们先准备一点数据，我们在上面的例子的基础上，再添加一个StudentDao实例：

              public interface StudentDao {    
              	// 根据id查询学生
                  Student findById(int id);
               }
              public class StudentDaoImpl implements StudentDao{
                  @Override
                 public Student findById(int id) {
                        // 模拟从数据库查找出学生
                       return new Student(1,"JackieYe","茂名");
                 }
              }
              //重新实例化一个，数据一样，再在控制台输出一句话。
              public class StudentDaoImpl2 implements StudentDao{
                  @Override
                  public Student findById(int id) {
                      // 模拟根据id查询学生
                      System.out.println("新方法！！！");
                      return new Student(1,"JackieYe","茂名");
                 }
              }
              

              3.2 创建配置文件

              创建配置文件bean.properties，该文件中定义管理的对象。

              前面我们添加了一个StudentDaoImpl2，如果需要调用它，则只需要更改该配置文件的名字，并不需要更改源代码。

              studentDao=com.jackie.dao.StudentDaoImpl
              

              3.3 创建容器管理类

              创建容器管理类，该类在类加载时读取配置文件，将配置文件中配置的对象全部创建并放入容器中。代码如下：

              public class Container {
                  static Map map = new HashMap();
                  static {
                      // 读取配置文件
                    InputStream is = Container
                                     .class.getClassLoader()
                    			       .getResourceAsStream("bean.properties");
                    Properties properties = new Properties();
                      try {
                         properties.load(is);
                    }catch(IOException e) {
                         e.printStackTrace();
                          }
                              // 遍历配置文件的所有配置
                    Enumeration