Spring01：框架介绍及ioc推导

1、Spring框架介绍

1、框架

官方介绍

框架就是一些类和接口的集合，通过这些类和接口协调来完成一系列的程序实现。
JAVA框架可以分为三层：表示层，业务层和物理层。框架又叫做开发中的半成品，
它不能提供整个WEB应用程序的所有东西，但是有了框架，我们就可以集中精力
进行业务逻辑的开发而不用去关心它的技术实现以及一些辅助的业务逻辑。
大家熟知的Structs和Spring就是表示层和业务层框架的强力代表。（说的太官方了）

通俗理解

框架就是某些个人或者组织定义了一系列的类或者接口，提前定义好了一些实现，用户可以在这些类和接口的基础之上，使用这些类来迅速的形成某个领域或者某个行业的解决方案，简化开发的过程，提高开发的效率。就好比：你要盖一座房子，先把柱子，房梁等先建设好，然后只需要向房子中填充就可以了，可以按照自己的需求进行设计，其实我们做的项目、系统都是类似的方式，如果所有的代码全部都需要自己实现，那么这个工程就太庞大了，所以可以先创建出一些基础的模板框架，开发人员只需要按照自己的需求向架子中填充内容，完成自己独特需求即可，这就是框架存在的意义。其实我们之前定义的简单的工具类这些东西也是类似的原理，只不过比较单一简单而已，因此，在现在的很多项目系统开发的过程中都是利用框架进行开发。

2、spring（春天）

架构设计

随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。

单一应用架构

​ 当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。

​ 垂直应用架构

​ 当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，提升效率的方法之一是将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。

​ 分布式服务架构

​ 当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。

​ 流动计算架构

​ 当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。

Java主流框架演变之路

​ 1、JSP+Servlet+JavaBean

​ 2、MVC三层架构

​ 3、使用EJB进行应用的开发，但是EJB是重量级框架（在使用的时候，过多的接口和依赖，侵入性强），在使用上比较麻烦

​ 4、Struts1/Struts2+Hibernate+Spring

​ 5、SpringMVC+Mybatis+Spring

​ 6、SpringBoot开发，约定大于配置

Spring官网

官网地址：https://spring.io/projects/spring-framework#overview

压缩包下载地址：https://repo.spring.io/release/org/springframework/spring/

源码地址：https://github.com/spring-projects/spring-framework

核心解释

​ spring是一个开源框架。

​ spring是为了简化企业开发而生的，使得开发变得更加优雅和简洁。

​ spring是一个IOC和AOP的容器框架。

​ IOC：控制反转

​ AOP：面向切面编程

​ 容器：包含并管理应用对象的生命周期，就好比用桶装水一样，spring就是桶，而对象就是水

使用spring的优点

​ 1、Spring通过DI、AOP和消除样板式代码来简化企业级Java开发

​ 2、Spring框架之外还存在一个构建在核心框架之上的庞大生态圈，它将Spring扩展到不同的领域，如Web服务、REST、移动开发以及NoSQL

​ 3、低侵入式设计，代码的污染极低

​ 4、独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺

​ 5、Spring的IoC容器降低了业务对象替换的复杂性，提高了组件之间的解耦

​ 6、Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式处理，从而提供了更好的复用

​ 7、Spring的ORM和DAO提供了与第三方持久层框架的的良好整合，并简化了底层的数据库访问

​ 8、Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

如何简化开发

​ 基于POJO的轻量级和最小侵入性编程

​ 通过依赖注入和面向接口实现松耦合

​ 基于切面和惯例进行声明式编程

​ 通过切面和模板减少样板式代码

spring的模块划分图

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器

核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

1、Spring 上下文

Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

2、Spring AOP

通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。

3、Spring DAO

JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

4、Spring ORM

Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

5、Spring Web 模块

Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

6、Spring MVC 框架

MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

3、IOC( Inversion of Control )控制反转

3.1、IOC理论推导

创建一个普通的java项目，完成下述功能

1 UserDao接口

package com.lian.dao;

public interface UserDao {

    void getUser();
}

2 UserDaoImpl 实现类

package com.lian.dao;

public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("默认获取用户的数据");
    }
}

3 新建service包， UserService 接口

package com.lian.service;

public interface UserService {
    void getUser();
}

4 UserServiceImpl 实现类

package com.lian.service;

import com.lian.dao.UserDao;
import com.lian.dao.UserDaoImpl;
import com.lian.dao.UserDaoMySqlImpl;

public class UserServiceImpl implements UserService{
    /**
    * 如果我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现
    * private UserDao userDao = new UserDaoMySqlImpl();
    */
    private UserDao userDao = new UserDaoImpl();

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

5 测试类

/**
 * 测试类用 @Test 比较好，主方法测试不兼容，无法打印出数据
 */
public class UserTest1 {

    @Test
    public void test1(){
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }
}

那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类对吧 , 每次变动 , 都需要修改大量代码 . 这种设计的耦合性太高了, 牵一发而动全身 .

那我们如何去解决呢 ?

我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下 .

1、增加UserDaoMySqlImpl 实现类

package com.lian.dao;

public class UserDaoMySqlImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("mysql获取用户的数据");
    }
}

2、增加UserDaoOracleImpl 实现类

package com.lian.dao;

public class UserDaoOracleImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("Oracle获取用户的数据");
    }
}

3、原有实现类引入接口而不去实现，生成set方法

package com.lian.service;

import com.lian.dao.UserDao;
import com.lian.dao.UserDaoImpl;
import com.lian.dao.UserDaoMySqlImpl;
import com.lian.dao.UserDaoOracleImpl;

public class UserServiceImpl implements UserService{
    // 留出一个接口不去实现具体类
    private UserDao userDao;

    // 利用set实现，选择要实现的子类
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

4、现在去我们的测试类里 , 进行测试 ;

package com.lian.dao;

import com.lian.service.UserService;
import com.lian.service.UserServiceImpl;
import org.junit.Test;

/**
 * 1、这样每次都需要在测试类里生成一个对象，但是实际开发我们不会先去生成类，太麻烦
 * 2、如果把这个创建对象的过程交给第三方，我们就省事了
 * 3、spring就是这个第三方，我们把类托管给spring容器
 * 4、ioc的重点是反射
 * 注：测试类用 @Test 比较好，主方法测试不兼容，无法打印出数据
 */
public class UserTest1 {

    @Test
    public void test1(){
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }

    /**
     * 注意：类的 继承 问题
     * 子类 继承 父类，子类可以访问父类的所有非静态方法
     * 如果 子类重写了 父类的方法，父类的引用会指向子类
     * 如果 子类没有重写父类的方法，纯属时子类自己的方法，父类时无法访问到的，除非强制转换为子类才可
     *
     * 根据等号 左边的类型，判断类是 子类还是父类
     *
     * 子类 生成实例对象，访问权限大，
     * UserServiceImpl userService = new UserServiceImpl();
     *
     * 父类生成实例对象
     * UserService userService = new UserServiceImpl();
     */
    @Test
    public void test2(){
        UserServiceImpl userService = new UserServiceImpl();

        /**
         * 当左边类型是子类型时，子类可访问自己和父类的方法
         * 因为set方法是子类自己的方法，并不是重写的父类的方法，所以，只能子类自己才可调用
         */

        //调用mysql实现
        userService.setUserDao(new UserDaoMySqlImpl());
        userService.getUser();

        //那我们现在又想用Oracle去实现呢
        userService.setUserDao(new UserDaoOracleImpl());
        userService.getUser();
    }
}

大家发现了区别没有 ? 可能很多人说没啥区别 . 但是同学们 , 他们已经发生了根本性的变化 , 很多地方都不一样了 . 仔细去思考一下 , 以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者，程序不用去管怎么创建，怎么实现了，它只负责提供一个接口 .

这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !

3.2、IOC本质

想要搞明白IOC，那么需要搞清楚如下几个问题：

1、谁控制谁
2、控制什么
3、什么是反转
4、哪些方面被反转

基本概念

官方Spring Framework Documentation，点击查看

IoC is also known as dependency injection (DI). It is a process whereby objects define their dependencies (that is, the other objects they work with) only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse (hence the name, Inversion of Control) of the bean itself controlling the instantiation or location of its dependencies by using direct construction of classes or a mechanism such as the Service Locator pattern.

IOC与大家熟知的依赖注入同理，. 这是一个通过依赖注入对象的过程 也就是说，它们所使用的对象，是通过构造函数参数，工厂方法的参数或这是从工厂方法的构造函数或返回值的对象实例设置的属性，然后容器在创建bean时注入这些需要的依赖。 这个过程相对普通创建对象的过程是反向的（因此称之为IoC），bean本身通过直接构造类来控制依赖关系的实例化或位置，或提供诸如服务定位器模式之类的机制。

如果这个过程比较难理解的话，那么可以想象自己找女朋友和婚介公司找女朋友的过程。如果这个过程能够想明白的话，那么我们现在回答上面的问题：

1、谁控制谁：在之前的编码过程中，都是需要什么对象自己去创建什么对象，有程序员自己来控制对象，而有了IOC容器之后，就会变成由IOC容器来控制对象，
2、控制什么：在实现过程中所需要的对象及需要依赖的对象
3、什么是反转：在没有IOC容器之前我们都是在对象中主动去创建依赖的对象，这是正转的，而有了IOC之后，依赖的对象直接由IOC容器创建后注入到对象中，由主动创建变成了被动接受，这是反转
4、哪些方面被反转：依赖的对象

DI与IOC

很多人把IOC和DI说成一个东西，笼统来说的话是没有问题的，但是本质上还是有所区别的,希望大家能够严谨一点，IOC和DI是从不同的角度描述的同一件事，IOC是从容器的角度描述，而DI是从应用程序的角度来描述，也可以这样说，IOC是设计思想，而DI是具体的实现方式

总结

​ 在此处总结中，希望大家能够能够明白两件事：

​ 1、解耦

​ 在面向对象设计的软件系统中，底层的实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。

​ 需要注意的是，在这样的组合关系中，一旦某一个对象出现了问题，那么其他对象肯定回有所影响，这就是耦合性太高的缘故，但是对象的耦合关系是无法避免的，也是必要的。随着应用程序越来越庞大，对象的耦合关系可能越来越复杂，经常需要多重依赖关系，因此，无论是架构师还是程序员，在面临这样的场景的时候，都需要减少这些对象的耦合性。

​ 耦合的关系不仅仅是对象与对象之间，也会出现在软件系统的各个模块之间，是我们需要重点解决的问题。而为了解决对象之间的耦合度过高的问题，我们就可以通过IOC来实现对象之间的解耦，spring框架就是IOC理论最最广泛的应用。

​ 从上图中可以看到，当引入了第三方的容器之后，几个对象之间就没有了耦合关系，全部对象都交由容器来控制，这个容器就相当于粘合剂，将系统的对象粘合在一起发挥作用。

2、生态

​ 任何一个语言或者任何一个框架想要立于不败之地，那么很重要的就是它的生态。

3、控制反转

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。