初识Spring

初识Spring

什么是Spring

通常我们所说的Spring是指Spring Framework即Spring框架。

按照百度百科：Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

用一句话概括Spring就是包含了众多工具方法的IoC容器。

如何理解呢？

就比如
Tomcat是Web容器，List/Map是数据存储容器

什么是IoC

IoC—Inversion of Control，即“控制反转”。

将对象的生命周期进行控制反转：

传统开发如果想要在A类里面使用B类，我们需要new 一个B，则B的生命周期即对象的是由程序员控制的，而在Spring中呢，不需要程序员控制B的生命周期了，就是把B托管给Spring了，用的时候直接从Spring中拿B对象使用。

为什么要这样做？优点有什么？

答案是解耦合

举个例子：

A类B类，在A类中调用B类直接new 一个B，而直接new B会存在问题，如果B的构造方法发生变化的话，整个调用链都要改动。如果不new ，直接把当前对象传入进来，虽然整个调用链依旧是A调用B，B调用C，C调用D，但是D在发生改变的时候，整个调用链不用进行代码修改，从而达成解耦合的目的。

当然这么讲可能会有点抽象，接下来我们举个例子

比如说有一个汽车
有整体一个汽车，有车身，有底盘，有轮胎。

package pre;

public class App {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

package pre;

public class Car {
    private Framework framework;

    public Car() {
        framework = new Framework();
    }

    public void init() {
        //依赖车身
        System.out.println("执行了Car的init方法");
        framework.init();
    }
}

package pre;

public class Framework {
    private Bottom bottom;

    public Framework(){
        bottom = new Bottom();
    }
    public void init() {
        //依赖底盘
        System.out.println("执行了Framework的init方法");
        bottom.init();
    }
}

package pre;

public class Bottom {
    private Tire tire;

    public Bottom() {
        tire = new Tire();
    }

    public void init() {
        //依赖轮胎
        System.out.println("执行了Bottom的init方法");
        tire.init();
    }
}

package pre;

public class Tire {
    private int size = 20;

    public void init() {
        System.out.println("执行了Tire的初始化方法，size：" + this.size);
    }
}

如果根据不同的用户提供不同尺寸的轮胎呢？

package pre;

public class App {
    public static void main(String[] args) {
        Car car = new Car(15);
        car.init();
    }
}

package pre;

public class Car {
    private Framework framework;
	//改动
    public Car(int size) {
        framework = new Framework(size);
    }

    public void init() {
        //依赖车身
        System.out.println("执行了Car的init方法");
        framework.init();
    }
}

package pre;

public class Framework {
    private Bottom bottom;
	//改动
    public Framework(int size){
        bottom = new Bottom(size);
    }
    public void init() {
        //依赖底盘
        System.out.println("执行了Framework的init方法");
        bottom.init();
    }
}

package pre;

public class Bottom {
    private Tire tire;
	//改动
    public Bottom(int size) {
        tire = new Tire(size);
    }

    public void init() {
        //依赖轮胎
        System.out.println("执行了Bottom的init方法");
        tire.init();
    }
}

package pre;

public class Tire {
    private int size = 20;

    public Tire (int size) {
        this.size = size;
    }

    public void init() {
        System.out.println("执行了Tire的初始化方法，size：" + this.size);
    }
}

高耦合：TIre修改之后→Bottom修改→Framework修改→Car修改→APP修改

每个部分都需要更改，牵一发而动全身，一层一层依赖，这就是传统开发到的缺陷。

如果使用IoC

package ioc;

public class App {
    public static void main(String[] args) {
        Tire tire = new Tire(30, "pink");
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.init();
    }
}

package ioc;

public class Car {
    private Framework framework;

    public Car (Framework framework) {
        this.framework = framework;
    }
    public void init () {
        System.out.println("执行 Car");
        framework.init();
    }
}

package ioc;

public class Framework {
    private Bottom bottom;

    public Framework (Bottom bottom) {
        this.bottom = bottom;
    }

    public void init() {
        //依赖底盘
        System.out.println("执行Framework");
        bottom.init();
    }
}

package ioc;

public class Bottom {
    private Tire tire;

    //不new了，依赖注入，传递一个Tire对象给Bottom，怎么来的不关注
    public Bottom (Tire tire) {
        this.tire = tire;
    }

    public  void init() {
        //依赖轮胎
        System.out.println("执行Bottom");
        tire.init();
    }
}

package ioc;

public class Tire {
    private int size = 20;
    //增加一个颜色，代码不需改动,控制权不在当前类里面了
    private String color;

    public Tire(int size, String color) {
        this.size = size;
        this.color = color;
    }
    public void init() {
        System.out.println("轮胎——size：" + size);
    }
}

低耦合：TIre修改之后→APP修改，而整个调用链不需要修改。

不论是加颜色还是配件，调用链都不用修改。

当然代码并未使用IoC，只是一个简单的实例，去理解原理，使用IoC使控制权不在当前类里面了。

这就是控制反转

理解Spring IoC

上文我们讲Spring是包含了众多工具方法的IoC容器。

容器具有两个基本功能：

• 将对象放入到容器
• 从容器中取出对象

也就是说学 Spring 最核心的功能，就是学如何将对象存入到 Spring 中，再从 Spring 中获取对象。

将对象存放到容器中的好处：将对象存储在 IoC 容器相当于将以后可能用的所有工具制作好都放到仓库中，需要的时候直接取就行了，用完再把它放回到仓库。而 new 对象的方式相当于，每次需要工具了才现做，用完就扔掉了也不会保存，下次再用的时候还得重新做，这就是 IoC 容器和普通程序开发的区别。

Spring 是一个 IoC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身又具备了存储对象和获取对象的能力。

控制反转是一种设计思想，就比如CAS（Compare And Swap）和乐观锁，乐观锁就像IoC，是一种实现的思路，CAS就是实现的一个具体技术，在Spring里面有一个具体的实现技术叫DI。

DI概念说明

DI即Dependency Injection，翻译成中文就是“依赖注入”的意思，简而言之就是在程序运行期间，动态的将某个对象引入到当前类的机制。

回忆一下Dependency在maven的pom.xml中出现过，注入依赖需要标签。

拿上面的代码举例

 	private Framework framework;

    public Car (Framework framework) {
        this.framework = framework;
    }

将Framework引入当前类里面就是DI。

• 从广义上讲IoC和DI是同一个概念：他们是从不同维度描述同一个事件。

​ 就比如手机内存8G，这个8G指的是运行内存，而不是辅存。

• 从狭义上来说又是不一样的，IoC是思想，DI是具体的实现技术。

​ 就比如说拿了奖学金，想去玩犒劳自己，你们“出去玩”就是一种思想和目标（指IoC），但是出去玩是去旅游还是逛街买东西？这就是具体的实现（指DI）。