Spring为什么这么火 之 Spring蕴含的设计思想

目录

Spring是什么？

1、什么是IoC？

2、传统程序开发

3、控制反转式程序开发

4、理解Spring IoC

5、依赖注入【DI】

 总结

---

前言

        很多人说：“Java程序员都是Spring程序员”，从这句话就能看出，对于Java程序员来说，Spring是一项必备技能，

---

Spring是什么？

        Spring是包含了众多工具方法的IoC容器

---

1、什么是IoC？

 IoC = Inversion of Control【控制反转】

        即就是说Spring就是一个“控制反转”的容器，还是不懂，没关系，继续往下看，通过传统程序和控制反转式程序对比一下，就明白了~

---

2、传统程序开发

假设我们现在需要制作一个“口红”的程序，实现思路如下：

        制作一支口红（ lipstick），需要依赖于口红管（tube），而口红管则依赖于口红芯（core），口红芯依赖于口红颜料（pigment），最终代码实现如下：

/**
 * 口红对象
 */
class Lipstick {
    private Tube tube;

    public Lipstick() {
        tube = new Tube();
    }

    public void init() {
        System.out.println("执行了Lipstick  init方法");

        //依赖口红管
        tube.init();
    }
}

/**
 * 口红管
 */
class Tube{
    private Core core;

    public Tube() {
        core = new Core();

    }

    public void init() {
        System.out.println("执行了Tube  init方法");

        //依赖口红芯
        core.init();
    }
}

/**
 * 口红芯
 */
class Core {
    private Pigment pigment;

    public Core() {
        pigment = new Pigment();
    }

    public void init() {
        System.out.println("执行了core  init方法");

        //依赖口红颜料
        pigment.init();
    }
}

/**
 * 口红颜料
 */
class Pigment {
    private String color = "死亡芭比粉";
    public Pigment() {

    }
    public void init() {
        System.out.println("执行了pigment  init方法");
    }
}
public class NewLipstickExample {
    public static void main(String[] args) {
        Lipstick lipstick = new Lipstick();
        lipstick.init();
    }
}

打印结果：

         从这里，看起来没有问题呀，但是，我们一起仔细想想看，随着市场用户量越来越大，个性化需求就会越来越多，这个时候，可能需要我们加工出不同颜色的口红，修改后，如下：

/**
 * 口红对象
 */
class Lipstick {
    private Tube tube;

    public Lipstick(String color) {
        tube = new Tube(color);
    }

    public void init() {
        System.out.println("执行了Lipstick  init方法");

        //依赖口红管
        tube.init();
    }
}

/**
 * 口红管
 */
class Tube{
    private Core core;

    public Tube(String color) {
        core = new Core(color);

    }

    public void init() {
        System.out.println("执行了Tube  init方法");

        //依赖口红芯
        core.init();
    }
}

/**
 * 口红芯
 */
class Core {
    private Pigment pigment;

    public Core(String color) {
        pigment = new Pigment(color);
    }

    public void init() {
        System.out.println("执行了core  init方法");

        //依赖口红颜料
        pigment.init();
    }
}

/**
 * 口红颜料
 */
class Pigment {
    private String color ;
    public Pigment(String color) {
        this.color = color;
    }
    public void init() {
        System.out.println("执行了pigment  init方法" +
                " 口红颜色："+color);
    }
}
public class NewLipstickExample {
    public static void main(String[] args) {
        Lipstick lipstick = new Lipstick("豆沙色");
        lipstick.init();
    }
}

         从上述代码会发现，当我们增加一点点个性化设置，即更改最底层代码后，整个调用链上的代码都需要进行修改【耦合度太高，我们需要解耦】

---

3、控制反转式程序开发

        控制翻转式程序开发，其实就是对传统式程序开发进行优化【解耦】

        怎么理解呢，传统中，我们制作一支口红，需求者的需求发生改变时，口红的颜色不再是原来的颜色，我们就要去更改，而这里解耦，就是将口红颜色配制外包出去，这样一来，即使颜色发生改变了，我们只需要向代理厂下单即可，自身无需进行修改。

思路如下：

 代码实现：

/**
 * 口红对象
 */
class Lipstick {
    private Tube tube;

    public Lipstick(Tube tube) {

        this.tube = tube ;
    }

    public void init() {
        System.out.println("执行了Lipstick  init方法");

        //依赖口红管
        tube.init();
    }
}

/**
 * 口红管
 */
class Tube{
    private Core core;

    public Tube(Core core) {
        this.core = core;
    }

    public void init() {
        System.out.println("执行了Tube  init方法");

        //依赖口红芯
        core.init();
    }
}

/**
 * 口红芯
 */
class Core {
    private Pigment pigment;

    public Core(Pigment pigment) {
        this.pigment = pigment;
    }

    public void init() {
        System.out.println("执行了core  init方法");

        //依赖口红颜料
        pigment.init();
    }
}

/**
 * 口红颜料
 */
class Pigment {
    private String color ;
    public Pigment(String color) {

        this.color = color;
    }
    public void init() {
        System.out.println("执行了pigment  init方法" +
                " 口红颜色："+color);
    }
}
public class NewLipstickExample {
    public static void main(String[] args) {
        Pigment pigment = new Pigment("丝绒红棕色");
        Core core = new Core(pigment);
        Tube tube = new Tube(core);
        Lipstick lipstick = new Lipstick(tube);
        lipstick.init();
    }
}

结果：

 

        经过这样的调整后，无论底层类怎样变化，整个调用链是不需要做改变的，也就是完成了代码之间的解耦，实现了更加灵活、通用的程序设计啦~ 

二者对比：

        我们对比后，会发现，传统的程序的类的创建，和正常流程是反的，也就是我们都已经要去使用了，才开始去创建，改进后的控制权发生反转，就不再是上级对象创建并控制下级对象了，而是把下级对象注入到当前对象中，下级的控制权不再是由上级类控制了，这样即使下级类发生任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是IoC的实现思想 

---

4、理解Spring IoC

上述我们说，Spring是一个IoC容器，重点就是容器，容器所具备的功能就是：

• 放入东西至容器中
• 从容器中取出东西

即Spring最核心功能就是，学习如何将对象存入Spring中，再从Spring中获取对象的过程 

---

5、依赖注入【DI】

DI——Dependency Injection【依赖注入】

 你没见过？我不信，咱们之前学习Servlet可是见了很多次了

问：究竟注入是什么意思啊？

答：注入，就是将一个东西拿过来用

DI那就是引入依赖，直接拿过来用

        官方一点：所谓依赖，就是IoC容器在运行期间，动态的将某种依赖关系注入到对象之中。

        因此，依赖注入（DI）和控制反转（IoC）是从不同角度去描述同一件事物，就是指通过引入IoC容器，利用依赖关系注入的方式，实现对象之间的解耦 

IoC是一种思想，DI是一种实现

---

 总结

1. Spring是一个包含众多工具的IoC容器
2. IoC和DI的区别：IoC是一种思想，DI是具体实现
3. Spring两个核心功能：存 + 取

好啦！本期结束啦，我们下期见~