认识Spring（上）-CSDN博客

本文链接：https://blog.csdn.net/m0_56911284/article/details/129099567

这篇文章介绍了Spring框架的基础知识，包括Spring的定义、IOC（控制反转）的概念，通过传统开发模式与IOC模式的对比解释了控制反转的重要性。接着，文章详细阐述了DI（依赖注入）如何实现，并展示了如何在Spring中创建和使用bean。最后，提到了ApplicationContext和BeanFactory的区别，前者提供更多的功能和支持，而后者则更为基础。

摘要由CSDN通过智能技术生成

作者：~小明学编程

文章专栏：Spring框架

格言：热爱编程的，终将被编程所厚爱。

ApplicationContext 和 BeanFactory 的区别

今天开始给大家带来一些关于spring框架的知识，这里要迎接我的新篇章了。

什么是spring

Spring 是指 SpringFramework，就是 Spring 框架，可以让 Java企业级的应用程序开发起来更简单。有一句话概括起来就是：Spring 是包含了众多工具方法的 IoC 容器。容器就是容纳某种物品的装置。像 List/Map 就是数据存储的容器。Tomcat 就是 web容器。

什么是IOC

前面我们了解了spring就是包含众多工具的Ioc容器那么什么是IOC呢？

IoC 就是 Inversion of Control ，就是 “控制反转” 。控制反转是两个词：控制+反转。指的是：之前程序的控制权限是在我们自己手上，现在，我们把这个控制权交出去了。

传统开发

下面通过一个例子来给大家说说什么是控制反转：

就拿我们造车来说：我们想要一辆车就必须得有车身，然后车身的大小需要依赖我们车地盘的大小，最后车地盘的大小可能要取决于轮胎的大小。

如果我们用代码来表示的话就是下面这样子：

public class NewCar {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
    /**
     * 汽车对象
     */
    static class Car {
        public void init() {
            // 依赖车身
            Framework framework = new Framework();
            framework.init();
        }
    }
    /**
     * 车身类
     */
    static class Framework {
        public void init() {
            // 依赖底盘
            Bottom bottom = new Bottom();
            bottom.init();
        }
    }
    /**
     * 底盘类
     */
    static class Bottom {

        public void init() {
            // 依赖轮胎
            Tire tire = new Tire();
            tire.init();
        }
    }
    /**
     * 轮胎类
     */
    static class Tire {
        // 尺寸
        private int size = 30;

        public void init() {
            System.out.println("轮胎尺寸：" + size);
        }
    }
}

其关系就是上层的对象需要new一个下层的对象，这个时候就会产生一个问题，如果我们的轮胎想要增加属性的话就需要更改我们的每一个类，这样的话代码的耦合性就太高了，我们需要的是一个低耦合的代码，所以这个时候我们就可以将控制权给反转过来。由原先的车需要车身，车身需要车地盘，车底盘需要车轮胎最后变成把车轮胎给车地盘，再将车地盘交给车身，最后将车身交给车。

IOC

这么一来的话我们想要改变轮胎的话那就直接改变然后交给车地盘就好了。

代码如下：

public class NewCar {
    public static void main(String[] args) {
        Tire tire = new Tire(50, "红色");
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.run();
    }

    static class Car {
        private Framework framework;

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

        public void run() {
            framework.init();
        }
    }

    static class Framework {
        private Bottom bottom;

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

        public void init() {
            bottom.init();
        }
    }

    static class Bottom {
        private Tire tire;

        public Bottom(Tire tire) {
            this.tire = tire;
        }

        public void init() {
            tire.init();
        }
    }

    static class Tire {
        private int size;

        private String color;

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

        public void init() {
            System.out.println("轮胎：" + size + " | 颜色：" + color);
        }
    }
}

这样我们就理解了我们为什么需要ioc的容器了，因为我们需要将我们的类给放在一个特定的容器中然后再给取出来。

DI

IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。理解了IoC和DI的概念后，一切都将变得简单明了，剩下的工作只是在spring的框架中堆积木而已。

spring的创建使用

创建spring项目的时候我们需要去引入相关的依赖，然后我们才能够去使用。

pom.xml

    <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>

spring.xml

<?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="user" class="com.beans.UserBean"></bean>
    <bean id="user1" class="com.beans.User"></bean>
</beans>

因为我们的bean对象要放在spring中所以这里要创建一个beans来存放我们bean对象，其中的id和class类似于一种键值对的关系。

可以看到这里我们就相当于把我们的对象放在了spring容器中去了，在我们放完之后接下来就是要想办法将我们的对象从容器中给取出来了。

取出bean对象

ApplicationContext

public static void main(String[] args) {
        //1.得到spring上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        //2.根据上下文提供的方法获取到bean
//        UserBean userBean = (UserBean) context.getBean("user");
//        UserBean userBean = context.getBean(UserBean.class);
        UserBean userBean = context.getBean("user",UserBean.class);
        //3.使用
        userBean.print();
    }

首先我们会获取一个上下文的对象，这也是我们前面所创建的资源里面的文件名，接下来就是获取里面的bean对象了，我们有三种方式，第一种是给一个user也就是我们的key值，当时这种方式需要我们的强制类型转换。第二种是直接输入我们的类对象，这种方式虽然不用进行强制类型的转换但是当我们注入多个对象的时候会报错。第三种方式是我们最常用的方法也是最安全的。

BeanFactory

通过BeanFactory也可以获取我们的上下文的依对象

public static void main1(String[] args) {
        //1.得到spring上下文对象
        BeanFactory context = new XmlBeanFactory(new ClassPathResource("spring.xml"));
        //根据上下文提供的方法获取到bean
        UserBean userBean = (UserBean) context.getBean("user");
        //3.使用
        userBean.print();
    }

ApplicationContext 和 BeanFactory 的区别

相同点：都实现了从容器中获取 Bean，都提供了 getBean 方法。
不同点：
a）ApplicationContext 属于 BeanFactory 的子类。
b）BeanFactory 只提供了基础访问 Bean 的方法。而 ApplicationContext 除了拥有 BeanFactory 的所有功能之外，还提供了更多的方法实现，比如对国际化的支持，资源访问的支持，以及事件和传播等方面的支持。
c）从性能方面来说二者是不同的，BeanFactory 是按需加载 Bean，而 ApplicationContext 就是全部加载，以备之后使用。对于用户来说肯定是想要第二种这样可以节约时间的开销嘛。