一、spring框架简介

1. spring是一个轻量级开源的JAVAEE框架。
2. Spring提高了IOC和AOP
     IOC:控制反转。把创建java对象的权力交于spring容器来管理。
     AOP:面向切面编程.在不改变源代码的前提下可以扩充功能。
3. spring的特点:
    方便解耦，简化开发----层层之间的依赖降低。
    声明式事务的支持：
    方便程序的测试：----提供单元测试jar，
    方便集成各种优秀框架---集成第三方的框架---mybatis

二、为什么使用spring框架

目的：降低耦合----降低对象与对象之间的耦合

那么上面的这个问题该如何去解决呢？这时就有人提出了一种思想----工厂模式。

但是上面并没有解决问题.我们还需要一一的修改代码

 

运用这种工厂模式，就是将创建对象交给工厂，工厂生产对象，其他的类需要用对象时，只需要从工厂里面去拿生产好的对象即可。

        但是上述方法还没有彻底解决掉我们的问题，如果Food类升级改名为Food1后，我们还是需要一个一个去修改。那么我们该如何去解决呢？--------可以利用java里的多态和接口来解决。

 

        通过这种方法，以后就算Food类再怎么修改，我们也不需要在依赖Food类的类中一个一个去修改，只需要升级换代后的Food类实现了IFood接口，那么其他的代码都不需要修改。

        这种思想，就类似于我们的spring框架。目的就是为了降低对象与对象之间的耦合性，不会再有一种牵一发而动全身的感觉。

        上面这些代码是不是我们自己写的解耦的方法，我们自己写的解耦考虑很多欠缺的地方。那么这时，我们就需要运用到别人写好的解耦方法----spring框架

        程序的耦合

        耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。

        

它的分类如下：

（1）内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。

（2）公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。

（3） 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。

（4） 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。

（5）标记耦合 。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。

（6） 数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。

（7） 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。

        总结：耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。

         内聚与耦合：内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。  

        IOC控制反转

        

        控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

        也就是说，我们使用对象的时候不再是直接new了，而是将创建对象的权利交给框架的核心容器IOC，需要使用对象的时候直接从容器中获取。这和我们上面举得例子（BeanFactory）一个原理。

         IoC的思想早就出现了，但是没有一个具体的实现，大家都是各自根据这个思想去写代码(自己去创建工厂)。后来有一个大师 Rod Johnson（Spring Framework创始人，著名作者。 Rod在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位。），写了一个框架，将IoC思想具体的实现了，这个框架后来起了个名字叫做 Spring。（因为在这之前 大家都是用hibernate这个框架，这个框架中文名字叫做冬眠，并且这个框架比较笨重，耦合比较高。Rod Johnson写的框架就是用来解决类似于hibernate高耦合的问题 ，所以他将自己框架的名字命名为 Spring 告诉全世界 冬天过去了 春天来了）。
 

三、如何使用spring

        (1)引入相关的依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.15.RELEASE</version>
        </dependency>
    </dependencies>

 (2)创建Spring的配置文件

<?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">
 
    <!-- 可以理解为将一个类交于spring容器来创建
          id:bean的唯一标识。
          class: 类的全路径
    -->
     <bean id="userDao" class="com.aaa.UserDao"></bean>
</beans>

 (3)创建一个Dao类

public interface IUserDao {
    public void show();
}
public class UserDao implements IUserDao {
 
    public void show(){
        System.out.println("这是userDao的show方法");
    }
}

(4)测试

public class Test01 {
    public static void main(String[] args) {
        //读取spring配置文件
        ApplicationContext app=new ClassPathXmlApplicationContext("application.xml");
        //获取bean对象 多态.
        IUserDao userDao = (IUserDao) app.getBean("userDao");
        userDao.show();
    }

四、BeanFactory和ApplicationContext的区别

我们先看一下这两个类在jar中的位置：

 

        Spring容器顶层接口：获取Bean对象;管理类和类之间的关系(依赖关系)BeanFactory由org.springframework.beans.factory.BeanFactory接口定义 BeanFactory是工厂模式（Factory pattern）的实现，是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖  

        BeanFactory接口包含以下基本方法：

    containsBean(String beanName) 判断工厂中是否包含给定名称的bean定义，若有则返回true。
    Object  getBean(String  str) 返回给定名称注册的bean实例。根据bean的配置情况，如果是singleton模式将返回一个共享实例，否则将返回一个新建的实例，如果没有找到指定bean,该方法可能会抛出异常。
    Object  getBean(String, Class) 返回以给定名称注册的bean实例，并转换为给定class类型
    Class  getType(String name) 返回给定名称的bean的Class,如果没有找到指定的bean实例，则排除NoSuchBeanDefinitionException异常
    boolean  isSingleton(String) 判断给定名称的bean定义是否为单例模式      
    String[]  getAliases(String name) 返回给定bean名称的所有别名

ApplicationContext接口

是基于BeanFactory之上的，提供了应用程序框架服务，扩展的新功能如下：提供国际化的支持资源访问，如URL和文件 事件传递载入多个配置文件等 实现类常见有三个：

    ClassPathXmlApplicationContext：-classpath路径加载xml文件的
    FileSystemXmlApplicationContext：基于项目根路径进行加载xml文件的
    AnnotationConfigApplicationContext：基于注解的配置。基于类书写的配置。

/**
 * Created by Intellij IDEA
 *
 * @author 王俊凯
 * @Date: 2022/6/13 8:51
 * @Version 1.0
 */
package com.aaa;

import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

public class TestBeanFactoryAndApplication {
    public static void main(String[] args) {
        //读取配置文件
        ClassPathResource resource=new ClassPathResource("spring.xml");
        //解析配置文件
        XmlBeanFactory factory=new XmlBeanFactory(resource);
        Object userDao = factory.getBean("userDao");//拿到哪个bean时 才会调用构造函数  创造该bean

        //当spring对象时 spring才会帮你创建
        Object people = factory.getBean("people");//拿到哪个bean时 才会调用构造函数  创造该bean
    }

    public static void main(String[] args) {
        //在加载spring容器时，spring会把配置文件中所有的bean创建好
        ApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");

    }
}

        BeanFactory和ApplicationContext区别:

1. BeanFactory 才是 Spring 容器中的顶层接口
2. ApplicationContext 是它的子接口
3. 单例模式下创建对象的时间点不一样
4. ApplicationContext：(饿汉模式)只要一读取配置文件，马上就会创建配置文件中配置的对象
5. BeanFactory：(懒汉模式)什么时候getBean("id")，也就是说当根据id获取对象时，才会创建。

五、获取bean的方式

（1）通过bean.xml文件中的bean标签的id值获取bean(使用默认构造方法)

IUserDao iUserDao= (IUserDao) app.getBean("userDao");//根据bean的id获取Bean对象，强制转换.

 （2） 通过类型去获取

IUserDao userDao = app.getBean(IUserDao.class);  //通过类型获取bean对象。

注意：确保bean的类型是唯一的 不然会报错：org.springframework.beans.factory.NoUniqueBeanDefinitionException  

（3） 通过 id + 类型去获取

IUserDao userDao = app.getBean("userDao2", IUserDao.class);

六、bean的作用范围

bean对象的作用范围调整需要配置scope属性，设置单例还是多例（只针对ApplicationContext接口来说，默认是单例的）

单例:---无论创建多少次对象 他们始终指向同一个实例。

scope：常用 singleton,prototype

​ singleton：单例的（默认值）当加载配置文件时，就会创建对象。

​ prototype：多例的（当getBean时才会创建对象）

​ request：作用于请求范围---同一个那么使用bean同一个。

​ session：作用于会话范围---同一个会话