Spring框架

一、Spring介绍

        spring是一个轻量级开源的JAVAEE框架。由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。因此， Spring不仅仅能应用于J2EE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。

        在spring中有两个重要的部分，一是IOC，另一个是AOP

        IOC：控制反转。把创建Java对象的权力交于spring容器来管理，由spring来为我们创建对象，以此来降低程序的耦合性。

        AOP：面向切面编程，在不改变程序源代码的情况下可以扩充新的功能。

        spring特点：

        1、方便解耦，简化开发。

        2、声明事务的支持。

        3、在spring中提供单元测试的jar包，方便便程序的测试。

        4、方便集成各种优秀的框架。例如mybatis等。

二、为何使用spring框架

        例如：我们声明一个Food类，来供其他类使用，这样很多类都要依赖于Food类。一般的，我们会在使用Food类中创建Food对象，然后在通过对象来调用方法，完成功能。但这样的做法会出现一个很大的问题，假如我们的程序做的很大很大，成百上千的类都需要调用Food中的方法，这样我们就需要在这些类中创建Food对象，而当后期业务需要，我们对Food进行升级改变，Food变成了Food1。这时，我们程序中所有用到Food对象的类，都需要进行改变。而这样的程序，牵一发而动全身，耦合度太高，对后期的升级和维护都要付出很大的代价。

        如何解决上面提到的问题呢。利用工厂模式来解决问题。即我们为Food类创建工厂类，让这个工厂类来为我们创建Food对象。但这样一来，我们还是没有从根本上解决问题，以为底层的Food还是一个类，虽然使用了工厂类来创建对象，但还是需要一个Food对象去接这个创建出来对象。如果我们对Food做出改变，同样的在这些使用的类中都需要改变。

        如果我们创建一个IFood接口，让Food实现IFood接口，我们在工厂类中直接返回实现类对象，而我们在那些使用的类中，用接口对象来接工厂类创建创建出来的对象，利用接口的多态来进行解耦，这样无论在后期如何变动Food类，只要他实现了IFood类，我们只需要修改工厂类中这一点就行了，其他的代码就不需要修改了，这样一来，就降低了程序的耦合性。

 上面的是我们自己实现解耦的方法，我们的考虑还存在很多的欠缺，所以我们使用现成的框架来为我们管理对象与对象之间的解耦。即使用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，需要使用对象的时候直接从容器中获取。

三、如何使用spring

3.1 引入相关依赖

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

3.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.xrx.UserDao"></bean>
</beans>

3.3 创建一个dao类

public interface IUserDao {
    public void show();
}
public class UserDao implements IUserDao {

    public void show(){
        System.out.println("********");
    }
}

3.4 测试

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

四、BeanFactory和ApplicationContext的区别

4.1 BeanFactory

BeanFactory 是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名称的所有别名

         使用BeanFactory时，在程序运行时，用到哪个bean，spring才会调用构造函数帮你创建该bean的对象。

 4.2 ApplicationContext接口

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

ClassPathXmlApplicationContext：-classpath路径加载xml文件的

FileSystemXmlApplicationContext：基于项目根路径进行加载xml文件的

AnnotationConfigApplicationContext：基于注解的配置。基于类书写的配置。

        使用ApplicationContext时，在加载spring容器时，spring会把配置文件中所有的bean创建好。

4.3 BeanFactory和ApplicationContext区别:

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

五、获取bean的方式

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

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

 2、通过类型去获取

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

注意：通过类型去去获取对象时，要确保bean的类型是唯一的，不然会报错。

3、通过id+类型去获取。

优点：既保证了是哪一个bean，又不用强制转换。

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

六、bean的作用范围

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

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

scope：常用 singleton,prototype

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

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

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

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

 七、DI依赖注入

依赖注入(Dependency Injection)。

IOC控制反转的最终目的就是降低程序的耦合，也就是削减依赖关系。

依赖关系的管理以后都交给spring维护，依赖关系的管理就称之为依赖注入。也就是说在当前类需要用到其它类的对象时，由spring为我们提供，我们只需要在配置文件中说明依赖关系的维护就可以了。

依赖注入的方式：

依赖注入的数据：三种类型

​      1. 基本数据类型和String

      2. 其它bean实体对象类型(在配置文件中或者注解配置过的bean)
      3. 复杂类型/集合类型(集合类型只能通过配置文件注入)

什么时候使用IOC和DI创建对象？

        ​ 如果是单例对象，可以使用IOC和DI。整个程序运行期间只会创建一个对象，我们不用考虑对象中数据的改变。

        ​ 但是，如果我们要创建的对象中的属性值，一直在改变，此时就不推荐使用DI和IOC了。

第一种方式：使用构造函数提供注入

argument

​ 如果使用构造函数注入，需要在bean.xml文件的bean标签中添加constructor-arg标签

​ 标签中的属性：

​ type : 用于指定要注入的数据的类型，该数据类型也是构造函数中某个或某些参数的类型。

​ index: 用指定给构造函数中指定索引位置的参数赋值，索引从0开始。

​ name: 用于给构造函数的参数赋值，指定参数的名称直接赋值 （常用）

​ value : 用于提供基本类型和String类型的数据

​ ref : 用于指定其它的bean类型数据，它指的就是在spring的IOC核心容器中出现过的bean

​ 注意：在获取bean对象时，必须要注入数据，否则对象无法创建成功。

​ 缺点：改变了bean对象的实例化方式，就算我们在创建对象时，用不到这些数据，也必须提供。

 <!--构造注入-->
    <bean id="p1" class="com.bai.demo2.entity.Person">
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="name" value="张三"></constructor-arg>
        <constructor-arg name="date" ref="d1"></constructor-arg>
    </bean>

    <!--日期对象的bean-->
    <bean id="d1" class="java.util.Date"></bean>

 第二种方式：使用set方法注入（常用）

如果使用set函数注入，需要在bean.xml文件的bean标签中添加 property 标签

​ 需要属性：

​ name: 用于给无参空构造函数的参数赋值，指定设值的set方法（将set方法的set去掉把大写字母变小写 setAge()====>age）

​ value : 用于提供基本类型和String类型的数据

​ ref : 用于指定其它的bean类型数据，它指的就是在spring的IOC核心容器中出现过的bean

​ 优点：解决了构造注入时的问题，可以选择性的注入值，不是必须注入全部了。

<!--注入java提供的Date类-->
    <bean id="date" class="java.util.Date"></bean>
    <!--set方法注入-->
    <bean id="person" class="com.aaa.ioc.Person">
        <property name="name" value="李四"></property>
        <property name="age" value="29"></property>
        <property name="birthday" ref="date"></property>
    </bean>

 第三种方式：使用注解提供

注意：一定要开启包扫描

<context:component-scan base-package="要扫描的包全名"></context:component-scan>

注解分类

1、用于创建对象的

这一类注解的作用和在xml配置文件中编写一个< bean>标签实现的功能一样

   @Component:（只要不属于三层架构 就使用）
    作用：用于把当前类对象存入spring容器中。
    具有value属性，用于指定bean的id，如果不写value，默认跟当前类名对应(首字母改小写)
    @Component("student1")作用就相当于：
    <bean id="id" class="全类名"></bean>
衍生三个注解：
@Controller(表现层)     @Service(业务层)      @Repository(持久层)
    这三个注解的作用和@Component注解一样，是spring框架为我们提供的明确的三层架构使用的注解，让我们的三层架构更加清晰。

2、用于注入数据的 

这一类的注解作用和xml文件中bean标签中的property标签的作用一样

@Autowired *****重点
作用：自动按照类型注入，只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功。
    如果IOC容器中没有任何bean的类型和要注入的变量类型匹配，则报错
    如果IOC容器中有多个类型匹配时，会根据要注入的变量名作为id去匹配，如果匹配到了，就可以执行，否则，报错。
注意：使用注解时，set方法就不是必要的了。
以上@Autowired注解存在一定的局限性，(如果核心容器中有多个相同对象，只使用@Autowired是无法注入成功的)

@Qualifier
    作用：在按照类型注入的基础上再按照名称注入。它再给类成员注入时不能单独使用。但是再给方法注入时可以。
    属性：value 用于指定注入的bean的id 

@Resource
    作用：直接按照bean的id注入。它可以独立使用。
    属性：name   用于指定bean的id
以上三个注解都只能注入其它bean类型的数据，而基本类型和String类型无法使用上述注解。那么如何注入基本数据类型和String类型呢？（集合类型只能通过xml注入） 

 @Value
    作用：用于注入基本数据类型和String数据类型。

 3、用于改变作用范围的：

作用和bean标签中的scope属性的功能一样

@Scope:
    作用：用于指定bean的作用范围
    属性：value  指定范围的取值。常用  singleton  prototype

4.和生命周期相关的：

​ 作用和bean标签中的init-method和destory-method方法的作用一样

@PostConstruct:用于指定初始化方法
@PreDestroy      :用于指定销毁方法