Spring 学习笔记

简介

Spring 概述

​ Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control）控制反转 和 AOP（Aspect Oriented Programming）面向切面编程为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等技术，还能整合开源的第三方框架和类库，是使用最多的 Java EE 企业应用开源框架。

​ 我们平常说的 Spring 指的是 Spring Framework，其为 Java 程序提供全面的基础架构支持，Spring 处理基础结构，使得我们可以专注于业务本身。是非入侵式框架（导入项目不会破坏原有项目代码）

​ Spring 之父：Rod Johnson

Framework Modules 组成

​ Spring Framework 由组成大约 20 个模块的 feature 组成，这些模块分为：

• Core Container 核心容器

• Date Access/Integration 数据访问/整合

• Web

• AOP (Aspect Oriented Programming) 面向切面编程

• Instrumentation 检测

• Messaging 消息

• Test

​

IOC

导论

​ 在面向对象编程中，我们经常处理的问题就是解耦，程序的耦合性越低，表名这个程序的可读性以及可维护性越高。IoC（Inversion of Control） 控制反转，就是常用的面向对象编程的设计原则，使用这个原则我们可以降低耦合性。其中依赖注入是控制反转最常见的实现。

什么是程序耦合

• 耦合

  程序间的依赖关系

  ​ 包括：类之间的依赖

  ​ 方法之间的依赖

• 解耦

  降低程序间的依赖关系

  我们在开发中，有些依赖关系是必须的，有些依赖关系可以通过优化代码来解除的。

所以实际开发中应做到：编译期不依赖，运行时才依赖

解耦思路：

1. 使用反射来创建对象，而避免使用 new 关键词
2. 通过读取配置文件来获取要创建的对象全限定类名

范例：JDBC 连接数据库

public static void main(String[] args) throws Exception{
    //1.注册驱动
    /*使用new对象的方式注册驱动
    DriverManager.registerDriver(new com.mysql.jdbc.Driver());*/
    /*使用反射方式创建对象注册驱动，此时配置内容只作为一个字符串传递
    Class.forName("com.mysql.jdbc.Driver");*/
    
    //而通过读取配置文件的方式，解决上面将字符串在代码中写死的问题，便于修改配置
    Properties properties = new Properties();
    properties.load(new FileInputStream("src/main/resources/data.properties"));
    //略...
    //2.获取连接
    Connection conn = DriverManager.getConnection(url,user,password);
    //3.获取操作数据库的预处理对象
    PrepareStatement ps = conn.prepareStatement("select * from tb_students");
    //4.执行SQL，获取结果集
    result = ps.executeQuery();
    //5.遍历结果集
    while(result.next()){
        int no = result.getInt("no");
        String name = result.getString("name");
		System.out.println(no + "," + name);
    //6.释放资源
    result.close();
    ps.close();
    conn.close();
}

​ 传统的 JDBC 获取连接方式也是为了解耦而使用读取配置文件的方式配置数据源。

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调 用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立 性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。

在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个 准则就是高内聚低耦合

它有如下分类：

​ （1） 内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另 一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。 （2） 公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大 量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。 （3） 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传 递该全局变量的信息，则称之为外部耦合。

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

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

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

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

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

​ 内聚与耦合

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

​ 内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合

​ 具体到项目中，带来了哪些依赖问题呢：

使用工厂模式解耦

​ 先了解一下工厂模式解耦的思想，会给下面 Spring 控制反转使用带来启发。

​ 在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，可以直接拿过来用。

​ 那么，这个读取配置文件，创建和获取三层对象的类就是工厂（Factory）

范例：

项目结构：

对应代码：以表现层 - 业务层 - 持久层 - 工厂 顺序

表现层代码：

package com.yh.view;

import com.yh.factory.BeanFactory;
import com.yh.service.INameService;

/**
 * 模拟一个表现层用于调用业务层
 * @author YH
 * @create 2020-05-07 16:19
 */
public class Cilent {
    public static void main(String[] args){
        //想调用业务层方法依赖与其实现类对象
//        INameService service = new NameServiceImpl();
        INameService service = (INameService)BeanFactory.getBean("nameService");
        System.out.println("表现层后台代码执行调用业务逻辑层：1");
        service.method();
    }
}

业务层代码：

package com.yh.service;

/**
 * 业务逻辑层接口
 * @author YH
 * @create 2020-05-07 16:17
 */
public interface INameService {
    void method();
}

package com.yh.service.impl;

import com.yh.dao.INameDao;
import com.yh.dao.impl.NameDaoImpl;
import com.yh.factory.BeanFactory;
import com.yh.service.INameService;

/**
 * 模拟业务逻辑层调用持久层
 * @author YH
 * @create 2020-05-07 16:18
 */
public class NameServiceImpl implements INameService {
    @Override
    public void method() {
        //想调用持久层方法依赖与其实现类对象
//        INameDao nameDao = new NameDaoImpl();
        INameDao nameDao = (INameDao) BeanFactory.getBean("nameDao");
        System.out.println("业务逻辑层实现类执行调用持久层：2");
        nameDao.method();
    }
}

持久层代码：

package com.yh.dao;

/**
 * 持久层接口
 * @author YH
 * @create 2020-05-07 16:14
 */
public interface INameDao {
    void method();
}

package com.yh.dao.impl;

import com.yh.dao.INameDao;

/**
 * 模拟持久层
 * @author YH
 * @create 2020-05-07 16:15
 */
public class NameDaoImpl implements INameDao {
    @Override
    public void method() {
        System.out.println("持久层dao执行 3");
    }
}

工厂：

package com.yh.factory;

import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * 一个创建Bean对象的工厂
 * Bean：在计算机英语中，有可重用组件的含义
 * JavaBean：用java语言编写的可重用组件
 * 注意：JavaBean不等于实体类，且包含实体类，即 JavaBean > 实体类
 *
 * 创建service和dao对象
 *
 * 1.需要通过配置文件读取配置，可用两种方式： xml 或 properties
 *      配置的内容：唯一标识=全限定类名(key-value)
 * 2.再通过读取配置文件中配置的内容，反射创建对象
 * @author YH
 * @create 2020-05-07 17:14
 */
public class BeanFactory {
    private static Properties props;

    /**
     * 定义一个Map，作为存储对象的容器，存放我们要创建的对象
     */
    private static Map beans = null;

    /**
     * 静态代码块只执行一次，保证了从始至终只生成配置中对应的唯一一个实例
     */
    static {
        try {
            props = new Properties();
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("factory.properties");
            props.load(in);
            //实例化Map容器
            beans = new HashMap<>();
            //取出配置文件中所有的key
            Enumeration