Spring

广义的 Spring：Spring 技术栈

广义上的 Spring 泛指以 Spring Framework 为核心的 Spring 技术栈。

经过十多年的发展，Spring 已经不再是一个单纯的应用框架，而是逐渐发展成为一个由多个不同子项目（模块）组成的成熟技术，例如 Spring Framework、Spring MVC、SpringBoot、Spring Cloud、Spring Data、Spring Security 等，其中 Spring Framework 是其他子项目的基础。

狭义的 Spring：Spring Framework

狭义的 Spring 特指 Spring Framework，通常我们将它称为 Spring 框架。

Spring是一个IoC容器

什么是IoC：（Inversion of Control，IoC），表示“控制反转”，指把创建对象过程交给 Spring 进行管理。

我们创建一台车：


public class demo {
    class car {
        //创建一辆车 依赖于车身
        public void init() {
            Carbody carbody = new Carbody();
            carbody.init();
        }
    }
 
    class Carbody {
        //构建车身 依赖于底座
 
        public void init() {
            Buttom buttom = new Buttom();
            buttom.init();
        }
    }
 
    class Buttom {
        public void init() {
            Tire tire = new Tire();//构建底座，依赖于车胎
            tire.init();
        }
    }
 
    class Tire {
        private int size = 30;
 
        public void init() {
            System.out.println(size);
        }
    }
 
    public static void main(String[] args) {
        demo.car car = new demo().new car();
        car.init();
    }
}

按照这种方式写，程序的耦合性是很高的，我们现在增加一个需求：客人要自己传入轮胎的大小，要求在主函数中传入参数，就导致所有类的init（）方法都要修改，程序的耦合性过高

我们对这个程序，解耦合


public class demo {
    class car {
        //创建一辆车 依赖于车身
        private Carbody carbody;
 
        public car(Carbody carbody) {
            this.carbody = carbody;
        }
 
        public void init() {
            carbody.init();
        }
    }
 
    class Carbody {
        //构建车身 依赖于底座
        private Buttom buttom;
 
        public Carbody(Buttom buttom) {
            this.buttom = buttom;
 
        }
 
        public void init() {
            buttom.init();
        }
    }
 
    class Buttom {
        private Tire tire;
 
        public Buttom(Tire tire) {
            this.tire = tire;
        }
 
        public void init() {
            tire.init();
        }
    }
 
    class Tire {
        private int size;
 
        public Tire(int size) {
            this.size = size;
        }
 
        public void init() {
            System.out.println(size);
        }
    }
 
    public static void main(String[] args) {
        demo demo = new demo();
        demo.Tire tire = demo.new Tire(3);
        demo.Buttom buttom = demo.new Buttom(tire);
        demo.Carbody carbody = demo.new Carbody(buttom);
        demo.car car = new demo().new car(carbody);
        car.init();
    }
}

对比发现：传统代码中是：car类调用carbody类，carbody类调用buttom类，buttom类调用tire类

改后的代码是：Tire类作为参数传入buttom类，buttom类作为参数传入carbody类，carbody类作为参数传入car类，控制权发生了反转，下级的生命周期不再由上级控制，下级类做出改变之后，对上级的影响不是太大，这就是控制反转

IoC：将对象（Bean）的控制权交给IoC容器，对象的生命周期由IoC容器管理

Spring是一个IoC容器，对象的销毁与创建交给Spring管理，创建好的对象存入Spring，随用随取，用完了放回Spring

DI

DI(Dependency Injections),意为"依赖注入"，说的是IoC容器在运行期间，动态的将依赖关系注入到对象之中，也就是说，DI和IoC是在不同层次上描述的同一个事件，IoC容器，通过依赖注入的方式，实现程序解耦

IoC可以说是思想，DI是具体实现

Spring使用

1、创建maven，在pom.xml引入Spring框架的依赖


<dependencies>
   <dependency>
<!--上下文-->
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
  <!--管理对象-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
</dependencies>

2、创建java类（创建Bean对象）


public class Demo {
  public void print(String name){
      System.out.println(name);
  }
}

3、在resoures下创建Spring的配置文件

resoures下创建文件spring-config.xml：文件内容


"1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
beans>

将bean对象交给Spring框架

根据键值对的形式，id是键值对的key，class是键值对的value


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="demo" class="Demo"></bean>
</beans>

4、获取并使用Bean对象

1、得到Spring上下文对象

2、根据上下文对象获取类对象

3、使用类对象


public class Use {
    public static void main(String[] args) {
        //1、获取上下文对象 传入配置文件的名称
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
 
        //2、获取bean对象
        Demo demo = (Demo) context.getBean("demo");//传入配置文件的id
 
        //3、使用对象
        demo.print("zs");
    }
}

在第二步，我们不是new对象的，new对象，对象的生命周期取决于代码，使用Spring，对象的生命周期取决于Spring；实现了控制权反转，并且实现了解耦。

1、通过上下文对象获取Bean对象时，可以有三种格式


     Demo demo = (Demo) context.getBean("demo");//传入配置文件的id
       Demo demo = context.getBean(Demo.class);
        Demo demo=context.getBean("demo",Demo.class);

第一种，根据id获取，要进行强制类型转化
第二种，根据类获取，但是如果这个类被在配置文件中注册了多次，这样就不知道要拿到哪一个注册信息，会报错
第三种，根据id和类获取，确保了唯一性，也不用强转

2、我们在获取上下文对象时，可以使用两种方法：

ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

还有一种是使用BeanFactory。

BeanFactory是一个接口，Bean 工厂是工厂模式的一个实现，提供了控制反转功能，用来把应用的配置和依赖从真正的应用代码中分离。常用的BeanFactory 实现有DefaultListableBeanFactory 、 XmlBeanFactory 、 ApplicationContext等。XmlBeanFactory已经被弃用了


public class Use {
    public static void main(String[] args) {
        //1、获取上下文对象 传入配置文件的名称
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
        //2、获取bean对象
 
        Demo demo = factory.getBean("demo", Demo.class);
        //3、使用对象
        demo.print("ww");
    }
}

那么：BeanFactory和ApplicationContext的区别是啥

1、两个都可以从容器中获取对象

2、ApplicationContext是BeanFactory的子类，不仅拥有父类的方法，还有一些额外的扩展

3、BeanFactory是按需加载，也就是懒汉模式，ApplicationContext是全部加载，也就是饿汉模式


public class Demo {
    public Demo() {
        System.out.println("Demo");
    }
 
    public void print(String name){
      System.out.println(name);
  }
}


public class Text {
    public Text() {
        System.out.println("Text");
    }
}

在获取上下文对象时，加载对象，一个是按需加载，一个是全部加载

相关阅读:
操作系统OS/存储管理/内存管理/内存管理的主要功能_基本原理_要求
 linux中 ~ / . ..分别表示什么
 基于Echarts实现可视化数据大屏高速综合管控大数据
 浅谈pytorch中的nn.Sequential(*net[3: 5])是啥意思
 maven使用时候出现，jdk1.5的情况的解决办法
 我眼中的大数据（三）——MapReduce
每日一题 494目标和（0-1背包）（灵神笔记）
牛逼啊！使用 Redis 实现一个轻量级的搜索引擎
 怎么裁剪视频时长？手把手教你裁剪
 android studio提示HAXM device is not found或者could not start avd
原文地址：https://blog.csdn.net/m0_58342797/article/details/126814333