Spring核心与设计思想

文章目录:

1.Spring的含义

2.IOC是什么

3.DI是什么

4.IOC和DI的区别

一.Spring是什么？

Spring是一个包含众多方法和工具的IOC容器

二.什么是IOC

IOC指的是控制反转（也就是控制权反转），这里举一个详细的例子，来理解一下控制权反转是什么意思，我们知道车有车身，底盘，和轮胎，它们之间形成了一种依赖关系。

构建一辆车需要车依赖于车身，车身依赖于车底盘，车底盘依赖于轮胎，我们用代码把他们之间的关系给表示一下

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

    }
    public void say()
    {
        System.out.println("这是车");
        framework.say();
    }
}
public class Framework {
    public Bottom bottom;
    public Framework()
    {
        bottom=new Bottom();
    }
    public void say()
    {
        System.out.println("这是车身");
        bottom.say();
    }

}
public class Bottom {
    public Tire tire;
    public Bottom()
    {
        tire=new Tire();
    }
    public void say()
    {
        System.out.println("这是车底盘");
        tire.say();
    }
}
public class Tire {
    
    public void say()
    {
        System.out.println("这是车轮胎");
    }
}
public class Text {
    public static void main(String[] args) {
        Car car=new Car();
        car.say();
    }
}

由代码我们能看到需要依赖别的类的类需要在类里面去实例化这个类，负责这个类对象的创建与使用，像这种由上级依赖于下级，并由上级去创建、管理下级，其实存在一个很大的问题，如果我想给每个用户可能对轮胎有不同的尺寸要求，然后打印一下，这时我们的Tire这个类的代码就需要改动一下

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

    }

    public void say()
    {
        System.out.println("这是车轮胎"+"车轮胎大小为:"+size);
    }
}

那么Tire构造方法里的这个size变量又需要Bootom类把这个参数传过来，同理又需要Framework把参数传给Bootom,逐层往上，代码修改如下:

public class Text {
    public static void main(String[] args) {
        Car car=new Car(10);
        car.say();
    }
}
public class Car {
    public Framework framework;
    public Car(int size)
    {
        framework=new Framework(size);

    }
    public void say()
    {
        System.out.println("这是车");
        framework.say();
    }
}
public class Framework {
    public Bottom bottom;
    public Framework(int size)
    {
        bottom=new Bottom(size);
    }
    public void say()
    {
        System.out.println("这是车身");
        bottom.say();
    }

}
public class Bottom {
    public Tire tire;
    public Bottom(int size)
    {
        tire=new Tire(size);
    }
    public void say()
    {
        System.out.println("这是车底盘");
        tire.say();
    }
}
public class Tire {
    public int size;
    public Tire(int size)
    {
        this.size=size;

    }

    public void say()
    {
        System.out.println("这是车轮胎"+"车轮胎大小为:"+size);
    }
}

由这段代码我们看到如果Tire类构造方法的类一旦发生变化了，它的上级类都需要改动，耦合性很强，那有没有什么办法来解决这个问题呢？这里就涉及到了控制权的反转问题，上级调用者不再去创建这个类，不再实例化这个类，只是去使用，把创建、管理的权利交给Spring容器，自己只使用这个类，我们来看一下这个代码的写法

public class Text2 {
    public static void main(String[] args) {
        Tire tire=new Tire(5);
        Bottom bottom=new Bottom(tire);
        Framework framework=new Framework(bottom);
        Car car=new Car(framework);
        car.say();
    }
}
public class Car {
    public Framework framework;
    public Car(Framework framework)
    {
        this.framework=framework;

    }
    public void say()
    {
        System.out.println("这是车");
        framework.say();
    }
}
public class Bottom {
    public Tire tire;
    public Bottom(Tire tire)
    {
        this.tire=tire;
    }
    public void say()
    {
        System.out.println("这是车底盘");
        tire.say();
    }
}
public class Tire {
    public int size;
    public Tire(int size)
    {
        this.size=size;

    }
    public void say()
    {
        System.out.println("这是车轮胎"+size);

    }


}

由上面的代码我们看到我们再去修改Tire类的时候，它的上级调用类是不用再作修改的的，由负责创建它的Text2这个类做出对应的修改就可以，同时我们发现类的创建顺序发生了变化。

由此我们发现IOC是一种指导思想，它指的是控制权的反转，不再由上级对象创建下级对象并管理了，而是交给Spring容器去负责创建并管理，把控制权交给了容器。

Spring容器既然是个容器的话，那么它还具备存取对象的功能，它具备存bean对象和取bean对象的功能，把bean对象放到Spring容器里，这样可以随用随取，不需要去创建的时候，再去new对象，大大提高了效率

三.DI是什么

DI是依赖注入，它指的是将依赖关系注入当前类中，把需要依赖的对象注入到当前类中，这个工作由Spring容器完成，而不是由调用者实现

四.DI 和 IOC的区别

DI和IOC本质上是从不同角度描述了同一概念，但是IOC是一种指导思想，而DI是实践。

Spring核心与设计思想

猜你喜欢