初探Spring

Spring框架

Spring概述

简介

• Spring：春天 —> 给软件行业带来了春天

• 2002年，[Rod Johnson](https://www.baike.com/wiki/Rod Johnson)首次推出了Spring框架的雏形：interface21框架！其实这里的21指的是21世纪~

• Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。

• Rod Johnson，Spring Framework创始人，著名作者。很难想象他的学历，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

• Spring理念：目的是解决企业应用开发的复杂性，使现有的技术更加容易使用，本身是一个大杂烩，它整合了现有的技术框架！

• SSH：Structs2 + Spring + Hibernate

• SSM：SpringMVC + Spring + Mybatis（现在常用）

常用网站整理：

• 官网：https://spring.io/

• 官方文档：https://docs.spring.io/spring-framework/docs/current/reference/html/

• 中文文档：https://www.docs4dev.com/docs/zh/spring-framework/5.1.3.RELEASE/reference/overview.html

• GitHub托管地址：https://github.com/spring-projects/spring-framework

• Maven仓库：https://mvnrepository.com/

  搜索Spring，找到Spring Web，导入这个包，会自动导入其他的相关依赖

  
  <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webmvcartifactId>
      <version>6.0.11version>
  dependency>
  

优点

• Spring 是一个开源的，免费的框架（容器）！
• Spring 是一个轻量级的、非入侵式的（导入Spring后并不会对原来的项目产生任何影响）框架！
• Spring 最核心的两个特点控制反转（IOC）、面向切面编程（AOP）
• Spring 支持事务的处理，支持了框架的整合

总结：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！

组成

拓展

现代化的Java开发，其实就是基于Spring的Java开发。

• Spring Boot
  • 一个快速开发的脚手架
  • 基于SpringBoot可以快速的开发单个微服务
  • 和Maven一样，约定大于配置
• Spring Cloud
  • SpringCloud是基于SpringBoot实现的

现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提需要完全掌握Spring和SpringMVC。Spring起到承上启下的作用~

**Spring的弊端：**发展了很久后，许多配置变得十分繁琐，人称：”配置地狱“_{所以SpringBoot出现来解决这个问题}

IOC理论推导和本质

IOC的理论推导

以前我们实现一个业务需要：

1. UserDao 接口
2. UserDaoImpl 实现类
3. UserService 业务接口
4. UserServiceImpl 业务员实现类

演示：

在IDEA中新建Maven项目，导入Spring依赖，删除src目录（方便建立子项目）

pom.xml：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>org.examplegroupId>
    <artifactId>Spring-StudyartifactId>
    <version>1.0-SNAPSHOTversion>

    <properties>
        <maven.compiler.source>17maven.compiler.source>
        <maven.compiler.target>17maven.compiler.target>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    properties>

    <dependencies>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>6.0.11version>
        dependency>
    dependencies>

project>

新建一个子模块；

目录结构：

可以看到很多相关依赖都自动导入了~

UserDao接口，用户数据相关操作：

package xyz.luck1y.dao;

public interface UserDao {
    void getUser();
}

UserDao实现类1，默认获取用户数据：

package xyz.luck1y.dao;

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

接下来去服务层，处理数据：

业务层接口：

package xyz.luck1y.service;

public interface UserService {
    void getUser();
}

业务层接口实现类：

package xyz.luck1y.service;

import xyz.luck1y.dao.UserDao;
import xyz.luck1y.dao.UserDaoImpl;

public class UserServiceImpl implements UserService{

    private UserDao userDao = new UserDaoImpl();

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

然后去用户层测试：

import xyz.luck1y.service.UserServiceImpl;

public class MyTest {
    public static void main(String[] args) {
        // 用户实际调用的是业务层，dao层他们不需要接触
        UserServiceImpl userService = new UserServiceImpl();
        userService.getUser();
    }
}

结果：

但是如果现在用户的请求有变化，要用MySQL获取，那我们就要去Dao层的UserDao接口实现MySQL方法：

package xyz.luck1y.dao;

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

还要修改业务层接口的实现类这里：

原来：

private UserDao userDao = new UserDaoImpl();

修改后：

private UserDao userDao = new UserDaoMySQLImpl();

这样在用户层，调用业务层才能实现用户的需求：用MySQ来实现~

这时候用户又想用Oracle的，那我们还要重复这个过程吗？现在不是真实的业务，代码量很少，但是如果在现实中每次都要去修改UserDao接口的不同实现类，是很麻烦的，效率也很低！

于是我们用set进行动态实现值的注入~

• 原来的业务层：

  package xyz.luck1y.service;
  
  import xyz.luck1y.dao.UserDao;
  import xyz.luck1y.dao.UserDaoImpl;
  import xyz.luck1y.dao.UserDaoMySQLImpl;
  
  public class UserServiceImpl implements UserService{
  
      private UserDao userDao = new UserDaoMySQLImpl();
  
      @Override
      public void getUser() {
          userDao.getUser();
      }
  }
  

• 动态实现：

  package xyz.luck1y.service;
  
  import xyz.luck1y.dao.UserDao;
  
  public class UserServiceImpl implements UserService{
  
      private UserDao userDao;
  
      // 利用set进行动态实现值的注入
      public void setUserDao(UserDao userDao) {
          this.userDao = userDao;
      }
  
      @Override
      public void getUser() {
          userDao.getUser();
      }
  }
  

• 此时，我们只需要在用户层让用户自行选择使用哪种方式实现：

  import xyz.luck1y.dao.UserDaoImpl;
  import xyz.luck1y.dao.UserDaoMySQLImpl;
  import xyz.luck1y.service.UserServiceImpl;
  
  public class MyTest {
      public static void main(String[] args) {
          // 用户实际调用的是业务层，dao层他们不需要接触
          UserServiceImpl userService = new UserServiceImpl();
  
          userService.setUserDao(new UserDaoImpl());
          // 可以自行随意指定UserService接口中调用Dao层的任意一个实现
  //        userService.setUserDao(new UserDaoMySQLImpl());
          userService.getUser();
      }
  }
  

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求对代码进行增删改，如果程序代码量十分大，修改一次的成本代价十分昂贵，而之后我们使用set一个接口实现，这样已经发生了革命性的变化

之前程序是主动创建对象，控制权在程序员手里。

使用set注入后，程序不再具有主动性，而是变成了被动的接收对象。

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了，系统的耦合性大大降低，可以更加专注的在业务的实现了。**这就是IOC的原型！**控制反转，将自己的控制权反转到用户手里。

这样一来整体的架构没有发生变化，但是本质发生了变化，我们只需要专注于业务的实现，用户自行决定要使用哪种实现方法~

IOC的本质

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

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

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

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

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