如何將SSM項目轉為SpringBoot項目

簡介

• 本篇將介紹SSM項目的整合，以及SSM項目轉SpringBoot項目的注意事項。

SSM項目配置

• 對於傳統的SSM項目來說，其中的要點就是整合Spring、MyBatis和Spring MVC三大框架。
• 而事實上，SSM項目的着重整合點是Spring和MyBatis，Spring與Spring MVC之間的聯系，是交由web.xml文件去建立的；Spring相當於MyBatis與Spring MVC之間的粘合劑，其本質上是一種組合的關系。
• SSM項目整合的難點只有一個，即需要將原本MyBatis的DataSource、SqlSession交由Spring去控制和創建。
• 將DataSource交由Spring管理的另一個意義，是可以使用Spring的TransactionManager對數據庫事務進行統一管理。

1. Spring、MyBatis整合

• 對於任何一種結構的項目來說，配置是最為重要的，首先需要進行整合的是MyBatis和Spring，步驟如下：
  1. 創建數據庫連接池的對象DataSource，交由Spring容器管理；
  2. MyBatis將使用DataSource創建SqlSession對象，並交由Spring容器管理；
  3. Spring將使用DataSource創建TransactionManager對象，並交由Spring容器管理；
  4. 使用Java配置類@Configuration統一加載@Import包含以上Bean的類；
  5. 如果使用的是配置文件.xml形式配置<bean>對象，在Java配置類中可以使用@ImportResource注解加載進行加載。
• JdbcConfig中創建DataSource對象引用，會注冊為Spring Bean，交由Spring容器管理，其中：
  1. @PropertySource：用於引入resources目錄下的jdbc.properties配置文件，其中配置了相關的數據庫源參數；
  2. @Value：使用占位符${}可以通過.properties配置文件中的鍵獲取其值，程序將自動將值賦值到當前字段中；
  3. @Bean：方法返回的對象將被Spring容器管理。

package cn.dylanphang.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

/**
 * 創建數據庫連接池Bean。
 */
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Value("${jdbc.testConnectionOnCheckout}")
    private boolean testConnectionOnCheckout;
    @Value("${jdbc.testConnectionOnCheckin}")
    private boolean textConnectionOnCheckin;
    @Value("${jdbc.idleConnectionTestPeriod}")
    private int idleConnectionTestPeriod;
    @Value("${jdbc.initialPoolSize}")
    private int initialPoolSize;
    @Value("${jdbc.minPoolSize}")
    private int minPoolSize;
    @Value("${jdbc.maxPoolSize}")
    private int maxPoolSize;


    /**
     * 使用c3p0連接池
     *
     * @return DataSource
     */
    @Bean(name = {"dataSource"})
    public DataSource dataSource() {
        try {
            ComboPooledDataSource cpds = new ComboPooledDataSource();

            cpds.setDriverClass(driver);
            cpds.setJdbcUrl(url);
            cpds.setUser(username);
            cpds.setPassword(password);

            cpds.setTestConnectionOnCheckout(testConnectionOnCheckout);
            cpds.setTestConnectionOnCheckin(textConnectionOnCheckin);
            cpds.setIdleConnectionTestPeriod(idleConnectionTestPeriod);

            cpds.setInitialPoolSize(initialPoolSize);
            cpds.setMinPoolSize(minPoolSize);
            cpds.setMaxPoolSize(maxPoolSize);

            return cpds;
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
        return null;
    }
}

• MyBatis使用DataSource創建SqlSession對象引用，注冊為Spring Bean，交由Spring容器管理，其中：
  1. classpath*:：將在resources目錄下查找指定的文件；
  2. SqlSessionTemplate：Spring所提供的SqlSession的實現類。

package cn.dylanphang.config;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;

@Import(JdbcConfig.class)
public class MyBatisConfig {

    private final DataSource dataSource;

    @Autowired
    public MyBatisConfig(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory() {
        try {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            sqlSessionFactoryBean.setDataSource(dataSource);

            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            Resource[] resources = resolver.getResources("classpath*:cn/dylanphang/mapper/*Mapper.xml");
            sqlSessionFactoryBean.setMapperLocations(resources);

            return sqlSessionFactoryBean.getObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Bean("sqlSession")
    public SqlSessionTemplate sqlSessionTemplate(@Autowired SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

• Spring使用DataSource創建TransactionManager對象引用，注冊為Spring Bean，交由Spring容器管理：

package cn.dylanphang.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionManager;

import javax.sql.DataSource;

/**
 * @author dylan
 */
@Import(JdbcConfig.class)
public class TransactionManagerConfig {
    private final DataSource dataSource;

    public TransactionManagerConfig(@Autowired DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * 可以直接在業務層中使用注解Transactional對事務進行管理，該種事務管理要求拋出RuntimeException或Error，對於其他類型的異常，
     * 將不做回滾處理。需要擴大處理異常的范圍，需要在注解中傳入rollbackFor = Exception.class，擴大異常抓取的范圍。
     *
     * @return DataSourceTransactionManager對象
     */
    @Bean
    public TransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource);
    }
}

• 最后使用Java配置類統一加載以上配置類：
  1. 此配置類SpringConfiguration最終由web.xml配置，交由web容器加載；
  2. @ComponentScan：Spring除了加載必要的環境所依賴的Bean對象之外，還需要加載用戶自定義類的Bean對象，使用@ComponentScan設定Spring加載自定義Bean的包路徑；
  3. excludeFilters：用於排除掃描指定注解。該屬性接收一個@Filter類的參數，該類在@ComponectScan中，而@Filter類則默認接收一個注解類型的類對象作為參數；
  4. @Import：用於加載類文件，其中Jdbc.class已經在MybatisConfig.class和TransactionManagerConfig.class中加載過了，可以不再進行二次加載；
  5. @EnableTransactionManagement：是否允許Spring事務管理。

package cn.dylanphang.config;

import org.springframework.context.annotation.*;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * @author dylan
 */
@Configuration
@ComponentScan(
        basePackages = "cn.dylanphang",
        excludeFilters = {
                @ComponentScan.Filter({Controller.class})
        })
@Import({MyBatisConfig.class, TransactionManagerConfig.class})
@EnableTransactionManagement
public class SpringConfiguration {
}

2. Spring MVC配置

• Spring MVC只需要完成標准配置即可，選用.xml配置的方式：
  1. <context:component-scan>：同樣需要設置包掃描，並只需要管理@Controller注解；
  2. <mvc:annotation-driven/>：開啟注解支持；
  3. InternalResourceViewResolver：視圖解析器，當你需要返回一個邏輯視圖並需要解析為物理視圖時，需要配置；
  4. CommonsMultipartResolver：當你在Controller方法中使用對象MutilpartFile時，需要配置。

<?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">

    <!-- 配置spring創建容器時要掃描的包 -->
    <context:component-scan base-package="cn.dylanphang.controller">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 配置視圖解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/page/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 配置文件解析器對象，要求id名稱必須為multipartResolver-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 配置文件上傳的最大size為10mb -->
        <property name="maxUploadSize" value="10485760"/>
    </bean>

    <!-- 配置spring開啟注解mvc的支持 -->
    <mvc:annotation-driven/>
</beans>

• 注：許多新的項目已經摒棄了jsp視圖了，如果使用SpringBoot構建項目，那么完全不會使用jsp視圖。但即使如此，知道得越多總是越好的，至少在面對一些歷史遺留的代碼時，不會慌。
• 之后介紹SpringBoot構建時，會展示如何開啟SpringBoot對jsp視圖的支持。

3. SSM整合

• 當完成了Spring與MyBatis的整合，及Spring MVC的基礎配置后，就可以開始最后的整合工作了。
• 使用web.xml文件將以上兩部分進行整合即可，配置文件如下：
  1. web容器將加載web.xml配置文件，首先讀取標簽<context-param>和<listener>，此時Spring和MyBatis整合的配置類將被加載進內存，各種Bean會被創建出來並放入Spring的容器ApplicationContext中進行統一管理；
  2. web容器緊接着會讀取<filter>標簽並加載相關配置；
  3. web容器最后將讀取<servlet>標簽，此時會加載Spring MVC的配置文件，其中配置的<bean>也會被加載進內存。

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <display-name>Archetype Created Web Application</display-name>

    <!-- 當Spring使用的是配置類時，需要提供一個用於加載配置類的對象AnnotationConfigWebApplicationContext -->
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </context-param>
    <!-- contextConfigLocation中，即可以配置“classpath*：xxx.xml”文件，也可配置Java配置類 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>cn.dylanphang.config.SpringConfiguration</param-value>
    </context-param>

    <!--
        配置過濾器，解決中文亂碼的問題；
        服務器啟動的時候就會創建該Filter，將init-param中的參數加載，注入到CharacterEncodingFilter類中，
        瀏覽器每次發送請求都會經過這個過濾器，然后調用doFilterInternal方法
    -->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <!-- 指定字符集 -->
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <!-- 指定對哪些資源使用characterEncodingFilter規則 -->
    <!-- 配置為"/*"的時候，即對路徑型url和后綴型url都會進行攔截 -->
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- listener監聽器必須配置 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 前端/核心控制器加載Spring MVC -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置Servlet的初始化參數，讀取springmvc中的配置，並創建spring容器 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:springmvc.xml</param-value>
        </init-param>
        <!-- 但為正整數的時候，即配置servlet啟動時加載該DispatcherServlet對象 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!-- 配置為"/"的時候，即對路徑型url進行攔截，但不會攔截后綴型url -->
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

• 至此，SSM環境已經搭建完畢。

SpringBoot項目配置

• 那么如何獲取一個完全等價的SpringBoot項目呢？在此之前，你需要了解一些前置知識。
• 對於SpringBoot來說，它已經幫我們整合了web容器、Spring MVC及MyBatis了，並且事務管理的對象也提前自動創建了，但這不意味着無事可做，你仍需要稍微進行一些自定義的配置。
• 需要額外進行的配置如下：
  1. 數據庫連接池DataSource的參數配置，你仍然需要告訴SpringBoot你的數據庫在哪、用戶名密碼是什么等；
  2. 配置MyBatis中Mapper.xml路徑，需要告訴SpringBoot需要在哪個目錄中查找你的Mapper.xml文件。
• 關於SpringBoot的自動配置，SpringBoot默認會使用一些初始參數加載相關的Bean對象，對於用戶來說，我們完全可以在application.properties或application.yml中修改創建這些Bean的初始參數。

1. 創建SpringBoot項目

• 首先需要創建一個SpringBoot項目，你可以不引入任何的依賴，但如果后續你需要用到相關的支持自動配置的框架，則需要自行尋找並添加到項目的pom.xml文件中，在以下網址中，你可以看到一些SpringBoot支持自動配置的框架：
  • https://docs.spring.io/spring-boot/docs/2.4.0/reference/html/using-spring-boot.html#using-boot-starter
• 因此，你可以選擇在項目創建之初，勾選相關需要使用到的框架，SpringBoot會在項目構建時添加這些框架的自動配置依賴到項目的pom.xml文件中，免去手動查找的繁瑣步驟：
  1. 注意，對於打包類型為war包的SpringBoot項目來說，項目構建完畢會自動生成一個ServletInitializer類，該類實現了WebApplicationInitializer，可以看做是web.xml的替代，一般情況下用不上；
  2. 相關運行應用在Application類上的注解，也可以轉移到ServletInitializer類上，但是沒有必要；
  3. 因此，在一般情況下，選擇打包成jar包，將配置注解標注在Application類上。

• SpringBoot將在項目的pom.xml中添加以下坐標：

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2. DataSource配置

• 在此前SSM項目中，我們使用了c3p0的數據庫連接池（詳細請參見JdbcConfig.java源碼），由於是項目的遷移實驗，因此需要同樣的依賴到SpringBoot項目中。
• 但也許你希望更新一下DataSource，比如使用druid數據庫連接池，在pom.xml中添加以下依賴引入druid坐標：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.23</version>
</dependency>

• 需要SpringBoot連接到MySQL中，還需要提供url、username和password等信息。
• 找到resources目錄下的SpringBoot配置文件application.properties，添加以下配置即可完成對DataSource配置：

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://localhost:3306/upload_download?serverTimezone=GMT%2B8&useAffectedRows=true
spring.datasource.username=root
spring.datasource.password=root

• 其中只需要表明需要使用的數據庫池類型spring.datasource.type即可，不需要配置driver的信息，SpringBoot會自動查找並使用MySQL的驅動，當然你也可以選擇手動配置驅動的全限定類名。
• 完成以上配置后，SpringBoot將自動使用以上的配置信息，去創建一個DruidDataSource。

3. MyBatis配置

• 如同配置DataSource一樣簡單，我們只需要在application.properties中添加以下代碼：

mybatis.mapper-locations=classpath:mapper/*.xml

• 以上代碼即等同於告訴SpringBoot存放Mapper.xml的路徑在resources/mapper/目錄下，SpringBoot將自動為相關的Mapper類匹配對應的Mapper.xml，此時僅要求Mapper類與其映射文件Mapper.xml同名。
• 關於如何讓SpringBoot知道Mapper.java所在的包的位置，有兩種方法：
  1. 在Mapper.java中使用@Mapper注解；
  2. 在ServletInitializer或Application類上使用@MapperScan注解。
• 可以選擇在Mapper上添加注解@Mapper，如下：
  1. 此時如果不使用@Repository，會導致@Autowried注解的字段報錯，但不會影響程序正常運行；
  2. 如果一定不希望使用@Repository注解，可以選擇使用@Resource注解替代@Autowried，此時字段不會報錯。

package cn.dylanphang.uploaddownload2.mapper;

import cn.dylanphang.uploaddownload2.pojo.Student;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @author dylan
 */
@Repository
@Mapper
public interface StudentMapper {

    /**
     * 查詢所有信息。
     *
     * @return List對象
     */
    List<Student> findAll();

    /**
     * 保存所有信息
     *
     * @param list List對象
     */
    void saveAll(List<Student> list);
}

• 也可以選擇在ServletInitializer上使用@MapperScan注解，配置Mapper類的包名：
  1. 使用@MapperScan注解，可以省去Mapper類中的@Repository和@Mapper注解；
  2. 此時Mapper的依賴注入，既可以使用@Resource，也可以使用@Autowired。

package cn.dylanphang.uploaddownload2;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

/**
 * @author dylan
 */
@MapperScan({"cn.dylanphang.uploaddownload2.mapper"})
public class ServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(UploadDownload2Application.class);
    }

}

• 關於注解的使用方面，選擇有很多，但在大多數協同辦公的情況下，務必優先選擇最為通俗易懂的注解。盡管某些情況下多一個注解並不會影響什么，但細節往往最能反映個人對知識點的理解是否透徹。

4. 遺留問題

• 至此，你的項目已經可以運行了。但仍存在遺留問題，SpringBoot中存放靜態資源頁面的目錄一般是resource/templates，通過一些第三方的視圖模板庫如Thymeleaf，可以在靜態頁面中使用代碼調用Controller中Model存儲的數據。
• 但傳統SSM大多使用的是.jsp，項目啟動后默認的訪問資源位於webapp/目錄下，你只要將index.jsp或index.html放置於該目錄下，頁面即可被訪問到。而Spring MVC視圖解析器的配置，多數指向的是/WEB-INF/**/.jsp頁面。
• 這導致了一個問題，SpringBoot默認並不支持.jsp視圖，更不用提及根本不存在項目中的webapp目錄了。
• 舊的SSM項目轉為新的SpringBoot項目中，我們必須要解決這個問題。如何免去重新編寫頁面邏輯，直接使用原本的jsp視圖呢？可以通過自定義Spring MVC視圖解析器，以及添加支持.jsp視圖的相關依賴解決這個問題。

a. 自定義Spring MVC視圖解析器

• SpringBoot支持部分個性化配置Spring MVC的功能，當然也支持全覆蓋地配置，我們需要編寫一個Java配置類，並讓該配置類去實現WebMvcConfigurer接口：
  • 需要覆寫其中的configureViewResolvers方法，並使用ViewResolverRegistry注冊自定義的jsp視圖解析器。

package cn.dylanphang.uploaddownload2.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 如果你舊項目需要轉SpringBoot，需要定義此配置類，覆蓋默認的視圖解析器。
 * 在此類中不添加@EnableWebMvc注解，則會保留SpringBoot原本的Mvc配置；否則，會覆蓋所有的SpringBoot對Spring MVC的默認配置。
 *
 * 在application.properties中配置：spring.mvc.view.prefix/spring.mvc.view.suffix是沒有作用的！！！
 *
 * @author dylan
 */
@Configuration
public class PersonalMvcConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.jsp("/WEB-INF/page/", ".jsp");
    }
}

• 完成以上操作后，我們需要創建一個jsp視圖所指向的資源目錄，因此需要在main目錄下新建一個webapp目錄，並在webapp目錄下放置舊的jsp視圖資源。
• 至此，我們所自定義的視圖解析器所指向的根目錄webapp創建完畢。

b. 添加依賴

• 為了讓SpringBoot至此jsp視圖，需要額外添加支持jsp視圖的依賴：

<!-- 轉SpringBoot項目之后，原生不支持JSP，需要添加以下依賴，否則.jsp會跳轉下載頁面 -->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <version>9.0.39</version>
    <exclusions>
        <exclusion>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

• 其中tomcat-embed-core依賴已經被spring-boot-starter-tomcat關聯了，可以使用<exclusion>排除它。
• 至此，所有問題都解決了，SSM項目已經完美轉為SpringBoot項目。

注意事項

• SpringBoot中總是優先訪問Controller，如果你具有首頁或登錄頁面，可以配置一個RouterController，在其中編寫方法，當訪問指定url的時候，跳轉到指定的頁面，如首頁、登錄頁面；
• 由於自定義視圖解析器的存在，Controller跳轉的頁面總是在視圖解析器指向的目錄下；因此某些頁面的url可能需要在轉為新項目之后，作相關的調整，同樣某些頁面的存放路徑，也需要進行調整；
• 舊項目中的一些路徑獲取情況，在轉到了新項目后，可能會發生變化，如使用getRealPath獲取到的路徑可能不一致，往路徑中存放文件時，文件可能出現在意料之外的目錄中，此時就需要對相關代碼進行調整。

總結

• 使用SpringBoot創建項目更為推薦使用第三方的視圖模板庫，Java Servlet Page已經漸漸被淘汰了；
• 作為后端，對於視圖模板庫了解即可。在前后端分離的時代，數據交互一般使用JSON數據。