SSM之Spring系列（一）---- Spring框架的概述和IoC概念和作用

Spring的概述

什么是Spring

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

Spring 的优势

• 方便解耦，简化开发

  通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

• AOP 编程的支持

  通过 Spring 的 AOP功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付。

• 声明式事务的支持

  可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。

• 方便程序的测试

  可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

• 方便集成各种优秀框架

Spring
  可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。

• 降低 JavaEE API 的使用难度

  Spring 对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。

• Java 源码是经典学习范例

  Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java 设计模式灵活运用以及对 Java技术的高深造诣。它的源代码无意是 Java 技术的最佳实践的范例。（这个因人而异，大家如果有时间和精力的话就去翻阅一下）

对于以上的优势会在以后的文章一一讲解

Spring 的体系结构

程序的耦合和解耦

什么是耦合和解耦？

耦合：简单来说就是程序间的依赖关系(包括类之间的依赖，方法之间的依赖)，在开发中我们应该尽量做到编译期不依赖，运行时才依赖。

它有如下分类：

1. 内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
2. 公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
3. 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
4. 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。
5. 标记耦合 。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。
6. 数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。
7. 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。

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

解耦：降低程序间的依赖关系。可以通过读取配置文件来获取要创建的对象的全限定类名，并使用反射来创建对象，避免使用 new关键字。

耦合的实例

• 我们以注册 JDBC 驱动为例子：

public class JdbcDemo1 {
    
    
    public static void main(String[] args) throws Exception{
    
    
        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");

这里我们为什么不使用DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());呢？

  当我们使用DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver()); 来注册驱动的时候，我们的测试类就依赖于 MySQL的驱动 jar 包。此时如果我们的项目中没有引入驱动 jar 包，那么测试类在编译期就会报错 （Error），如下图所示：

  而当我们使用反射的时候，我们的测试类并不依赖于驱动类，对于 Class.forName() 来说，此时的com.mysql.cj.jdbc.Driver仅仅只是一个字符串，只有当运行时找不到该类才会抛出异常 （Exception），如下图所示：

  但是 Class.forName("com.mysql.cj.jdbc.Driver");这样写还是有点缺陷的，因为这样导致这个字符串在我们类中写死了，要是以后我们不用MySQL而用其他的数据库，这个驱动还是要改，那我们该怎么办呢？
  我们可以通过配置文件来获取要创建的对象全限定类名。就是说，我们可以创建一个配置文件把那个字符串配置进去，然后通过读取配置文件的方式来得到要创建的对象全限定类名，在用反射来创建对象。

  另一个例子就是在平时开发的三层结构中，我们经常会写以下的代码，在这种情况下，我们说接口和接口实现类耦合度比较高，在后期维护中，如果需要更改接口实现类，修改起来不灵活。

UserService service = new UserServiceImpl();

解耦的实例

• 为了降低耦合度，这里我们可以创建配置文件，配置文件中存放着我们需要用到的类的全限定类名（唯一标识=全限定类名），如下所示：

accountService=com.cz.service.impl.AccountServiceImpl
accountDao=com.cz.dao.impl.AccountDaoImpl

• 当我们需要某个类对象的时候，就通过工厂来加载。工厂类代码如下：

package com.cz.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语言编写的可重用组件
 -   他就是创建我们的service和dao对象的。
 - 步骤：
 -      第一：需要一个配置文件来配置我们的service和dao
 -              配置的内容：唯一标识 = 全限定类名（key=value）
 -      第二：通过读取配置文件中配置的内容，反射创建对象
 -   配置文件可以是xml，也可以是properties
 */
public class BeanFactory {
    
    

    //用于加载配置文件的的Properties对象
    private static Properties props;
    //创建一个Map，容器，用于存放所有的Bean对象，确保对象都是单例的
    private static Map<String, Object> beans;
    //使用静态代码块为Properties赋值
    static {
    
    
        try {
    
    
            // 实例化Properties对象
            props = new Properties();
            // 获取配置文件路径，使用类加载器（不要使用src路径，因为部署后不存在src目录；也不要使用绝对路径，耦合度高）
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String, Object>();
            //取出配置文件中所有的key
            Enumeration<Object> keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
    
    
                //取出每个key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch (Exception e){
    
    
            throw new ExceptionInInitializerError("初始化Properties失败!");
        }
    }

    /**
     * 根据Bean的名称获取Bean对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
    
    
        return beans.get(beanName);
    }
    /**
     * 禁止外界初始化
     */
    private BeanFactory() {
    
    
    
    }
}

上面解耦的思路有 2 个问题：

1. 存哪去？

• 分析：
  • 由于我们是很多对象，肯定要找个集合来存。这时候有Map和 List供选择。到底选 Map 还是 List 就看我们有没有查找需求。有查找需求，选 Map。
• 所以我们的答案就是：
  • 在应用加载时，创建一个 Map，用于存放三层对象。我们把这个 map 称之为容器。

• 什么是工厂？

• 工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。

• 原来：

  • 我们在获取对象时，都是采用 new的方式。是主动的。

• 现在：

  • 我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。
    上面说的获取对象的方式的改变。就是IoC的概念了。控制反转

IoC 概念和作用

IoC 的概念

• 控制反转（Inversion of Control，缩写IoC）是指把创建对象的权利交给框架。简单来说就是，以前我们创建对象的时候，是通过new关键字来创建的，这种方式是主动的；而通过IoC，我们把创建对象的任务交给了它，这种方式是被动的，我们只需要列出一个清单，表明需要什么对象，IoC 就会帮我们创建好对象，当我们需要使用时，只需要向 IoC 容器获取即可。它包括依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）

明确 ioc 的作用：

削减计算机程序的耦合(解除我们代码中的依赖关系)。
别的事他都干不了。