JavaWeb编年史（白银时期）

经典三层架构模式，把项目分成了三层，分别是表示层，业务层，和数据库链接层。这个模式实现了对项目的横向拆分，使得项目的层次结构变得清晰无比。

但是，此时的表现层还是用传统的Servlet，一个Servlet程序只能应对一个URL请求。但是当项目越做越大，请求url的种类越来越多，就会难以招架。

于是，人们迎来了框架时代。

JavaWeb编年史（白银时代） SSM框架

所谓框架不出，谁与争锋？从最早的SSH架构，到后面经典的SSM架构，实际上都是着重解决了同一个问题，那就是路由分发的难题。由于后来Stucts2框架爆出严重的安全漏洞，后面相当长的一段时间内，都是SSM架构占据开发的主流。

所谓的SSM框架，就是Spring + SpringMVC + mybatis。

Spring的经典IOC模式实现了依赖注入，从此项目的Bean统一交给Spring来管理，依赖注入也叫做控制反转。核心理念就是通过反射的方式提前将需要的对象new出来，放在Spring的容器中进行保存。下次要使用的时候，则可以通过@Autowired注解等方式获取。

Spring的AOP模式则是利用动态代理，能够实现对指定的方法进行增强，一般用于记录日志和进行事务管理。所谓的方法增强，就是对某些方法的执行前后进行统一代码的植入，以实现某些统一的业务逻辑。

SpringMVC的工作流程: 用户通过视图层发送请求到服务器,在服务器中请求被Controller进行接收,Controller再调用相应的Module层进行处理,Module处理完毕再返回给Controller层,Controller层根据请求处理的结果找到相应的View视图,渲染数据后最终响应给浏览器。

接下来，我们会通过一个具体的案例，将之前的MVC项目改成SSM架构。为了简单起见，Mybatis的整合就不演示了。

1.导入相关的依赖

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.3.8</version>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>5.3.8</version>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.3.8</version>
</dependency>

2.新三层架构

BookDao

@Repository
public class BookDao {

    public List<Book> listBooks(){
        return new ArrayList<Book>(){{
            add(new Book("五年高考三年模拟"));
            add(new Book("王后雄教案"));
        }};
    }
}

dao层加上@Repository注解，交给Spring来管理。

BookService

@Service
public class BookService {

    @Autowired
    BookDao bookDao = new BookDao();

    public List<Book> listBooks(){
        return bookDao.listBooks();
    }
}

service层需要用@Autowired注解自动装配dao层的示例，这就说Spring的IOC。同时，service层本身需要打上@Service注解，交给Spring来管理。

BookController

@Controller
public class BookController {

    @Autowired
    BookService bookService;

    @GetMapping("book")
    public ModelAndView book(ModelAndView mav){
        List<Book> books = bookService.listBooks();
        //将数据（M）嵌入到页面（V），jsp就可以通过EL表达式来获取了
        mav.addObject("books",books);

        mav.setViewName("book");

        return mav;

    }
}

controller层需要用@Autowired注解自动装配service层的示例，这就说Spring的IOC。同时，service层本身需要打上@Service注解，交给Spring来管理。

springmvc最关键的一点就是允许你给类打上@Controller注解，然后这个类的方法中只要有打上 @GetMapping， @PostMapping，@RequestMapping等注解的，就可以被前端访问，也就是我们俗称的API接口。

相当于每一个方法就是一个Servlet。

3.springMVC配置

springMVC如何实现这一点的呢，其实也不复杂，它有一个统一的转发器--DispatcherServlet。

这个就是一个普通的Servlet，需要配置在web.xml中。

<!-- SpringMvc调度器配置 DispatcherServlet -->
<servlet>
  <servlet-name>dispatcherServlet</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <!--关联类路径下的mvc配置文件-->
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springmvc.xml</param-value>
  </init-param>
  <!-- 启动加载等级-->
  <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>dispatcherServlet</servlet-name>
  <url-pattern>/</url-pattern>
</servlet-mapping>

对应的，springMVC本身有一个配置文件，用于确定包扫描的路径，是否开启注解驱动，以及配置视图解析器。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--    启用注解支持，开启Bean扫描  -->
    <context:component-scan base-package="com.example"/>
    <mvc:annotation-driven/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

<mvc:annotation-driven/>

这个配置代表开启注解驱动，就是把原先spring的配置文件给取消了，一个类想要交给Spring管理，只需要打上对应的注解即可，比如@Service。

项目整体结构如下：

启动一下，看下效果：

OK，至此以及集成完毕。

SpringMVC执行流程

SSM架构的缺陷

SSM架构的项目极大程度上解决了Servlet过多的问题，并且得到了进一步的解耦合。每次多一个业务模块，你只需要新增一套controller、service、dao、model即可。

但是，SSM架构依然存在问题，就是目前我们依然还是用xml配置文件的方式来管理各种第三方组件的。比如你要引入一个shiro框架，不仅pom.xml中要改，spring的bean工厂配置文件也需要改。当引入的组件过多，xml配置文件就会变得很臃肿，不好维护。

于是，就引入了一个约定大于配置的理念。简单来说就是，很多时候我们引入第三方框架的时候，配置用默认的就足够了，根本不需要每次都为了引入一个组件，就去写一大堆类似的xml。

所以，SpringBoot框架应运而生。

SpringBoot时代

Springboot是一个微服务框架，延续了spring框架的核心思想IOC和AOP，简化了应用的开发和部署。Spring Boot是为了简化Spring应用的创建、运行、调试、部署等而出现的，使用它可以做到专注于Spring应用的开发，而无需过多关注XML的配置。提供了一堆依赖打包，并已经按照使用习惯解决了依赖问题—>习惯大于约定。

SpringBoot和SpringMVC的区别

形式上：SpringBoot是一个自动化配置的工具；SpringMVC是一个web框架 。

在搭建项目时：SpringMVC需要手动配置xml文件，同时需要配置Tomcat服务器。而SpringBoot采用约定大于配置的方式，进行自动装配，同时内置服务器，打开就可以直接用。

演示从SpringMVC转到SpringBoot

首先，maven的依赖发生重大改变，不需要引入spring那些依赖了，直接继承springboot父工程。

<!--导入springboot 父工程-->
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.5.1</version>
  <relativePath/> <!-- lookup parent from repository -->
</parent>

springMVC那一套是javaweb项目的必备依赖，所以要单独导入：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

秒就妙在，你只需要导入这两个依赖，就默认了相关的配置，不需要再去web.xml中配置dispatcherServlet了，也没有springmvc的配置了。

这就是自动配置的魅力。

因为我们还是用的jsp模板引擎，所以要导入下面三个依赖：

<!-- servlet依赖. -->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
</dependency>

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>jstl</artifactId>
</dependency>

<dependency>
  <groupId>org.apache.tomcat.embed</groupId>
  <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

引入tomcat-embed-jasper是因为，现在我们用的是内嵌tomcat，需要用这个依赖来返回和解析jsp页面。没有它的话就没法解析jsp了。

springboot并非完全零配置，比如视图解析器还是得自己配一下，让系统知道我们把jsp页面放在哪里了。

创建yml格式的配置文件

配置视图解析器，其他配置就用默认的即可。

spring:
  #视图解析器
  mvc:
    view:
      prefix: /
      suffix: .jsp

因为现在使用的是内嵌tomcat，所以我们需要一个启动类。

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

要想启动项目，只需要运行这个类即可。其他类都不用修改。

访问：http://localhost:8080/book

成功了，以上就是旧项目切换到SpringBoot架构的一个简单过程。实际项目开发的时候，有大量第三方组件，我们需要去查询具体的依赖，主要改动就是修改pom.xml和application.yml文件。

好了，从JavaWeb开发的发展来说，到目前为止已经是SpringBoot的天下。项目结构也从原先的单体项目发展成了前后端分离的形式，下一节开始，我们会开始讲述JavaWeb项目的架构演变。