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、传统程序开发

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

Spring为什么这么火 之 Spring蕴含的设计思想_第1张图片

        制作一支口红( 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();
    }
}

打印结果:

Spring为什么这么火 之 Spring蕴含的设计思想_第2张图片

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



/**
 * 口红对象
 */
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、控制反转式程序开发

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

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

思路如下:

Spring为什么这么火 之 Spring蕴含的设计思想_第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();
    }
}

结果:

 Spring为什么这么火 之 Spring蕴含的设计思想_第4张图片

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

二者对比:

Spring为什么这么火 之 Spring蕴含的设计思想_第5张图片

Spring为什么这么火 之 Spring蕴含的设计思想_第6张图片

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


4、理解Spring IoC

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

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

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


5、依赖注入【DI】

DI——Dependency Injection【依赖注入】

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

Spring为什么这么火 之 Spring蕴含的设计思想_第7张图片

问:究竟注入是什么意思啊?

答:注入,就是将一个东西拿过来用

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

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

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

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


 总结

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

好啦!本期结束啦,我们下期见~ 

你可能感兴趣的:(Spring,spring,java)