SpringBoot重写JSPM高校师资培训系统：从SSM迁移到自动装配的实战指南

1. 项目整体设计与思路拆解

1.1 别被JSPM三个字母唬住：这到底是什么技术组合

刚拿到这个项目时，团队里几个年轻同事第一反应是"JSPM是个啥框架"。其实JSPM不是什么新东西，在高校、政务这类老系统里非常常见，指的就是JSP + SpringMVC + MyBatis这套传统组合。JSP负责页面渲染，SpringMVC管请求路由，MyBatis做持久层访问。很多学校十年前的信息化系统都是这么搭的，稳定是稳定，但痛点也够明显：XML配置一堆、依赖管理靠手cv、内嵌容器部署费劲、前后端代码耦合严重。

这次要用SpringBoot重写"高校师资培训管理系统"，本质上就是把这套老技术栈的骨架换掉，用starter机制和自动装配把基础设施成本压下来。SpringBoot的核心思想是"约定大于配置"，它通过spring-boot-autoconfigure里的各种XXXAutoConfiguration类，在classpath下检测到对应依赖后自动完成Bean装配。比如你引入了spring-boot-starter-web，DispatcherServlet、内嵌Tomcat、默认的Jackson序列化器全部自动就位，这在传统SSM里至少要折腾大半天。

做个直观对比：

所以这个重写项目的技术路线非常清晰：后端用SpringBoot 2.7.x，前端延续JSP+jQuery+Bootstrap的模式，持久层继续用MyBatis但改成注解+XML混合方式，权限部分用Shiro。为什么不全盘换成Vue前后端分离？后面细说。

1.2 高校师资培训管理系统到底管什么

先别急着写代码，需求理不顺，技术再花哨也是白搭。高校师资培训的业务逻辑其实比想象中复杂，不是简单的"发通知-报名-签到"三步走。

一个完整的师资培训管理流程，至少要覆盖这些环节：

• 培训计划制定：人事处或教师发展中心发布年度培训计划，包括培训类型（岗前培训、在岗研修、企业实践、学术会议等）、学时数、培训时间、参训对象。
• 在线报名与审核：教师登录系统查看计划，在线报名，院系负责人审核，校级管理员终审。审核不通过要能退回并填写原因。
• 培训执行管理：培训开始前通知提醒，培训过程中支持扫码签到或线下签到导入，培训结束后可上传结业证明、心得报告等材料。
• 学时统计与认定：按教师、按院系、按年度统计学时，支持学时不足预警，支持Excel导出上报。
• 培训评价与效果追踪：参训教师对培训项目进行评价打分，管理员查看评价汇总。

角色权限方面，我最终设计了三类角色：

这个权限模型用Shiro的RBAC实现比较顺手，基于角色的访问控制，表结构就是经典的user-role-permission三张主表加两张关联表。为什么不用Spring Security？因为项目里需要大量JSP页面配合Shiro标签做细粒度显示控制，Shiro在服务端渲染场景下的TagLib（shiro:hasRole这类标签）比Security要直观得多，学习成本也低。

2. 技术选型与核心配置

2.1 版本怎么选：SpringBoot版本太高为什么反而麻烦

这是很多人上来就踩的坑。打开Spring Initializr，默认给你生成SpringBoot 3.x，JDK 17起步，看着很爽。但如果你要在这个项目里继续用JSP，事情就变得麻烦了。

SpringBoot 3.0基于Spring Framework 6，内嵌Tomcat直接跳到Tomcat 10.x，而Tomcat 10把javax.servlet包迁移到了jakarta.servlet。你以前写的JSP、Servlet、Filter、Listener，只要import的是javax.*，全部编译不过。更关键的是，SpringBoot 3.x对JSP的支持已经处于"能用但不推荐"的状态，官方文档明确说JSP是边缘化方案，很多第三方标签库、老工具类跟jakarta命名空间不兼容。

所以我给这个项目的SpringBoot版本定在2.7.18。这是2.x系列的最后一个版本，长期维护，社区资料最全，JSP生态完全兼容，JDK 8或者JDK 11都能跑。如果你的简历上写了SpringBoot项目经验，面试官问"为什么不用3.x"，你可以这么说：*3.x的体系更现代，但项目里JSP生态和若干老组件依赖javax.命名空间，迁移成本高于收益。技术选型不是越新越好，而是越合适越好。

2.2 JSP整合与视图解析配置

SpringBoot默认不支持JSP，因为它认为模板引擎应该是Thymeleaf、Freemarker这类。强行用JSP也得按它的规矩来。第一步在pom.xml里加依赖：

xml复制<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

注意JSTL版本用1.2就够了，网上很多老教程让你引jstl 1.1配standard，那套在SpringBoot里容易出幺蛾子。tomcat-embed-jasper的scope设置为provided，是为了部署到外部容器时不和容器自带的Jasper冲突。

然后是application.yml里的视图解析配置：

yaml复制spring:
  mvc:
    view:
      prefix: /WEB-INF/views/
      suffix: .jsp

关于JSP的存放路径，官方一直强调要放到/WEB-INF/下，而不是/src/main/resources/static/下。原因很简单：WEB-INF目录下的文件不受静态资源映射规则影响，用户无法通过URL直接访问到JSP源码，必须经过Servlet转发才能渲染。如果放到static目录下，等于把JSP裸奔在公网，别人可以直接下载你的页面文件。

这里还要补一个静态资源映射的细节。JSP页面里经常会有这种引用：

html复制<link href="${pageContext.request.contextPath}/css/style.css" rel="stylesheet">

SpringBoot默认会去classpath:/static/下找/css/style.css。如果你把CSS、JS文件放到src/main/webapp/static/下，有时候会404。因为SpringBoot的自动配置里，静态资源默认路径是classpath:/META-INF/resources/、classpath:/resources/、classpath:/static/、classpath:/public/。src/main/webapp在打JAR包时默认不会被打进去（当然如果你用WAR包部署就没这个问题）。所以我的习惯是：CSS/JS/images一律放src/main/resources/static/下，JSP页面一律放src/main/webapp/WEB-INF/views/下，两边井水不犯河水。

2.3 数据库设计与MyBatis整合

高校师资培训管理系统的数据库表，我梳理出这么八张核心表：

设计的时候有一个点特别坑：报名审核状态和培训记录状态必须分开。比如一个教师报名了培训，审核通过，但培训还没开始，这个人在"报名表"里状态是"已通过"，但在"培训记录表"里还不存在记录。只有当培训结束、学时认定完成后，才在t_train_records里插入一条数据。开始我只用一张表搞定，后来遇到学时统计口径对不上的问题，反复改了好几次，最后还是拆成两张表才彻底解决。

MyBatis整合SpringBoot很简单，引入mybatis-spring-boot-starter，然后在启动类上加@MapperScan("com.xxx.mapper")。如果你的SQL逻辑不复杂，用注解写SQL就够了；如果涉及多表关联、动态SQL，建议还是用XML，把复杂SQL放在resources/mapper/目录下，可维护性强很多。这里有个小建议：MyBatis的Mapper接口方法名尽量和业务语义绑定，不要用findByxxx这种无脑命名，查询条件变化太频繁的方法直接写XML动态SQL。

3. 核心功能实现与实操过程

3.1 登录认证与权限控制

登录认证这块我用的Shiro + Redis实现的Session共享。为什么用Redis存Session？因为JSP项目一般是多实例部署，如果Session存在每台服务器的内存里，用户第一次请求打到A机器，第二次请求负载均衡转到B机器，Session就丢了。用Redis统一存储Session，天然解决多实例会话共享问题。

引入依赖：

xml复制<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring-boot-starter</artifactId>
    <version>1.9.1</version>
</dependency>
<dependency>
    <groupId>org.crazycake</groupId>
    <artifactId>shiro-redis-spring-boot-starter</artifactId>
    <version>3.3.1</version>
</dependency>

shiro-redis这个starter是社区常用的第三方组件，它自动把DefaultWebSessionManager的sessionDAO换成RedisSessionDAO。需要注意版本兼容性，shiro-redis 3.3.1对应的是Shiro 1.9.x。如果你用了Shiro 1.10以上，可能得自己配RedisSessionDAO，不能直接套用默认配置。

自定义Realm时，核心就是两个方法：

java复制@Component
public class UserRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

    // 认证：根据登录名查用户，校验密码
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) {
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        String username = upToken.getUsername();
        User user = userService.findByUsername(username);
        if (user == null) {
            return null; // Shiro会自动抛出UnknownAccountException
        }
        // 密码校验交给Shiro的CredentialsMatcher，这里只返回用户信息
        return new SimpleAuthenticationInfo(user, user.getPassword(), ByteSource.Util.bytes(user.getSalt()), getName());
    }

    // 授权：查询用户的角色和权限集合
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        User user = (User) principals.getPrimaryPrincipal();
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        Set<String> roles = userService.findRolesByUserId(user.getId());
        Set<String> perms = userService.findPermsByUserId(user.getId());
        info.setRoles(roles);
        info.setStringPermissions(perms);
        return info;
    }
}

很多新手会在doGetAuthorizationInfo里连表查权限，导致每次请求都要访问数据库。我的优化方案是：登录成功后，在doGetAuthenticationInfo里查出用户的角色和权限，放到User对象里缓存起来，授权方法直接从principals里取，不再查库。如果后面权限被调整，再调用Shiro的realm.clearCachedAuthorizationInfo(cacheKey)强制刷新缓存。

密码加密用的MD5 + Salt。我知道MD5已经过时了，但老系统迁移上来的用户密码已经是MD5加盐存的了，为了兼容历史数据只能用MD5。新项目建议用BCrypt。如果你们是全新系统，直接上BCrypt，别犹豫。

3.2 培训计划、报名与审核流程

培训计划模块是最能体现状态机设计功底的地方。一个计划从创建到结束，要经历这些状态：

text复制草稿 -> 已发布 -> 报名中 -> 报名截止 -> 培训中 -> 已结束 -> 已归档

我维护了一个状态枚举：

java复制public enum PlanStatus {
    DRAFT(0, "草稿"),
    PUBLISHED(1, "已发布"),
    REGISTERING(2, "报名中"),
    REGISTER_CLOSED(3, "报名截止"),
    TRAINING(4, "培训中"),
    FINISHED(5, "已结束"),
    ARCHIVED(6, "已归档");

    private final int code;
    private final String desc;
}

状态流转不能由前端随意跳转，后端要对状态变更做校验。比如"已发布"的计划不能直接改成"已结束"，必须经过"报名中"、"培训中"。这个我用一个简单的状态机校验方法搞定：

java复制private static final Map<Integer, Set<Integer>> ALLOWED_TRANSITIONS = new HashMap<>();

static {
    ALLOWED_TRANSITIONS.put(PlanStatus.DRAFT.getCode(), Set.of(PlanStatus.PUBLISHED.getCode()));
    ALLOWED_TRANSITIONS.put(PlanStatus.PUBLISHED.getCode(), Set.of(PlanStatus.REGISTERING.getCode(), PlanStatus.DRAFT.getCode()));
    ALLOWED_TRANSITIONS.put(PlanStatus.REGISTERING.getCode(), Set.of(PlanStatus.REGISTER_CLOSED.getCode(), PlanStatus.DRAFT.getCode()));
    // ...其余状态流转
}

public void changeStatus(Plan plan, int targetStatus) {
    Set<Integer> allowed = ALLOWED_TRANSITIONS.get(plan.getStatus());
    if (allowed == null || !allowed.contains(targetStatus)) {
        throw new BusinessException("非法状态流转: " + plan.getStatus() + " -> " + targetStatus);
    }
    plan.setStatus(targetStatus);
}

报名审核这块有个并发问题：培训计划设置了名额上限，比如50人，报名时如果并发超过50人，数据库里count+1的操作可能会出现超卖现象。解决方式是在t_train_signup表上加一个唯一约束(plan_id, user_id)，同时报名时用SQL原子更新已报名人数：

sql复制UPDATE t_train_plan SET registered_count = registered_count + 1 
WHERE id = #{planId} AND registered_count < limit_count

如果update返回的受影响行数为0，说明名额满了，直接抛出"报名人数已满"的异常。这种方案比"先select再insert"在高并发下靠谱得多。

3.3 学时统计、导出与定时任务

学时统计是这个系统的核心业务，也是评审专家最爱盯的地方。每年教师需要完成一定数量的继续教育学时，系统要按照培训类型、院系、年度等多个维度统计。

我的表结构里t_train_records存了每条培训认定的学时数。学时统计SQL大概是：

sql复制SELECT 
    u.id AS user_id,
    u.name AS user_name,
    d.dept_name,
    SUM(CASE WHEN r.finish_status = 1 THEN r.hours ELSE 0 END) AS total_hours,
    COUNT(CASE WHEN r.finish_status = 1 THEN 1 END) AS total_count
FROM t_user u
LEFT JOIN t_dept d ON u.dept_id = d.id
LEFT JOIN t_train_records r ON r.user_id = u.id
WHERE r.train_year = #{year}
GROUP BY u.id, u.name, d.dept_name
ORDER BY total_hours DESC

导出Excel用的EasyExcel，阿里巴巴开源的那个库。相比Apache POI，EasyExcel内存占用低很多，对几万条数据完全不虚。一个常用的导出工具方法：

java复制public void exportTeacherHours(HttpServletResponse response, List<TeacherHoursVO> dataList) {
    response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
    response.setCharacterEncoding("utf-8");
    String fileName = URLEncoder.encode("教师学时统计", "UTF-8").replaceAll("\\+", "%20");
    response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");
    EasyExcel.write(response.getOutputStream(), TeacherHoursVO.class).sheet("学时统计").doWrite(dataList);
}

Quartz定时任务用来自动触发一些周期性的操作。比如：每周日晚自动给学时不足的教师发送提醒通知；每月初自动汇总上月培训数据生成统计报表。SpringBoot里用Quartz很简单，引入spring-boot-starter-quartz，写一个Job类继承QuartzJobBean，再用@Scheduled或者通过SchedulerFactoryBean注册触发器。我建议用Quartz而不是纯@Scheduled，因为我们的定时任务可能需要支持动态调整执行时间，Quartz的触发器可以随时修改，而@Scheduled的cron表达式是编译期写死的。

3.4 文件上传与附件管理

培训通知附件、结业证书、培训心得材料，这些都是文件上传的场景。最开始我图省事，把文件保存在本地磁盘的/opt/uploads/目录，数据库只存相对路径。但后来发现问题的隐患：如果将来要上多台服务器，本地文件无法共享；如果服务器磁盘坏了，数据全丢了。

后来我把文件存储切到了MinIO。MinIO是开源的、兼容S3协议的对象存储服务，部署轻量，几行命令就能跑起来，非常契合中小型项目的需求。SpringBoot整合MinIO的步骤不复杂：

yaml复制minio:
  endpoint: http://localhost:9000
  access-key: minioadmin
  secret-key: minioadmin
  bucket: teacher-train

java复制@Configuration
public class MinioConfig {

    @Value("${minio.endpoint}")
    private String endpoint;

    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
            .endpoint(endpoint)
            .credentials(accessKey, secretKey)
            .build();
    }
}

文件上传时，一个最容易忽略的问题：把文件名用UUID重命名。用户上传的原始文件名可能包含中文、特殊字符、路径符号，直接存到对象存储里，一方面会有安全风险（比如文件名里带../），另一方面下载的时候Content-Type容易识别错。我的做法是把原始文件名存在数据库字段中，存储到MinIO的objectName用UUID生成。

SpringBoot里控制上传大小：

yaml复制spring:
  servlet:
    multipart:
      max-file-size: 50MB
      max-request-size: 100MB

如果配置了这个属性还是不生效，大多是版本问题，2.x默认的单位是MB，3.x默认单位是B，注意区分。有时候你设置max-file-size: 10，结果只能传10字节的文件，就是单位搞错了。

4. 常见问题与排查技巧实录

4.1 JSP页面渲染相关的三个坑

坑一：访问JSP返回404。

这个问题的根源基本是漏了依赖。SpringBoot项目里如果只加了spring-boot-starter-web，没有加tomcat-embed-jasper，JSP文件根本不会被编译和渲染。还有一个隐蔽的情况：如果你用的是SpringBoot 3.x + JDK 17，JSP支持是残缺的，很多标签库不兼容，强烈建议老项目用2.7.x。

坑二：页面样式全部失效。

JSP能打开但CSS/JS加载不出来，控制器F12看一下静态资源请求，十有八九路径不对。JSP里引用静态资源，一定要用${pageContext.request.contextPath}拼上绝对路径，不要写相对路径。相对路径在不同的Controller转发层级下解析结果不一样，容易乱套。推荐在JSP页面顶部统一声明：

jsp复制<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<c:set var="ctx" value="${pageContext.request.contextPath}" />

后边引用全部写${ctx}/css/xxx.css。

坑三：开发环境修改JSP不生效。

默认SpringBoot的模板引擎有缓存，JSP编译一次就缓存起来。你改了页面，刷新浏览器还是旧页面。解决办法是在开发配置里关掉缓存：

yaml复制spring:
  thymeleaf:
    cache: false
  web:
    resources:
      cache:
        period: 0

不过，说实话开发JSP项目最推荐的还是用JRebel或者直接重启应用。JSP热加载本来就是Servlet容器的老毛病，别指望完美解决。

4.2 事务失效的几个容易踩的场景

师资培训系统里很多操作都涉及多表更新，比如报名审核通过后，要更新报名表状态、更新培训计划的已报名人数、写入一条学时认定记录。这三个操作必须在同一个事务里，否则一个成功一个失败，数据就乱了。

SpringBoot默认已经开启了事务管理，@Transactional直接可用。但事务失效的场景有一大堆，我踩过的至少这三个：

场景一：同类内部方法调用。类的内部，A方法调用B方法，B上标了@Transactional，B的事务不会生效。因为事务是Spring通过AOP动态代理实现的，内部调用走的是this.method()，没有经过代理对象。解决办法是把B方法拆到另一个Service类里，或者注入自己（AopContext.currentProxy()）。

场景二：非public方法上标注@Transactional。Spring的声明式事务基于代理，非public方法不会走代理逻辑。如果你在private方法上加@Transactional，编译器不会报错，但它就是静默失效。

场景三：异常被catch吞掉。@Transactional默认只在抛出RuntimeException和Error时回滚，如果你在方法里catch住了异常不往外抛，事务不会回滚。更隐蔽的是，catch住异常后抛出一个自定义的受检异常，事务照样不回滚，需要加rollbackFor = Exception.class。

java复制@Transactional(rollbackFor = Exception.class)
public void auditSignup(Long signupId, boolean pass) {
    // 1. 更新报名状态
    // 2. 更新已报名人数
    // 3. 写入学时记录
}

这是我在项目里总结的事务三问：这个事务要保证哪几个数据一致？这个异常会不会被吞掉？这个方法是不是被代理调用的？ 每次写@Transactional前先过一遍这三问，能挡掉大多数坑。

4.3 连接池和内存相关问题

SpringBoot 2.x默认的数据源连接池是HikariCP，它很快，但参数不调优也会出问题。我遇到过一个典型故障：系统上线运行一天后，突然所有数据库操作都报"Connection is not available, request timed out after 30000ms"。排查下来是连接池最大连接数太小，默认值10，而系统用的是Druid监控平台的连接数远超10。

HikariCP的配置：

yaml复制spring:
  datasource:
    hikari:
      maximum-pool-size: 50
      minimum-idle: 10
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000

这里有个经验值：max-lifetime要小于数据库的wait_timeout，比如MySQL默认wait_timeout是8小时，HikariCP的max-lifetime设1800秒（30分钟）就比较合理。如果max-lifetime大于wait_timeout，MySQL会主动断开空闲连接，而连接池这边还不知道，下次请求拿到的就是一个死连接。

关于JSP项目的内存，也是要提前规划的。每次请求JSP都要经过Jasper编译、渲染，CPU和内存占用比纯API接口高不少。线上部署我建议JVM堆内存至少给2G起，如果并发量一般的话，可以给到4G。启动参数大致这样：

bash复制java -Xms2g -Xmx4g -XX:+UseG1GC -jar springboot-teacher-training-system.jar

5. 项目上线前后的几点优化建议

5.1 Redis缓存：从简单到进阶

这个系统有很多查询接口是典型的"读多写少"：培训计划列表、院系教师列表、字典数据。如果不加缓存，每次请求都打到MySQL，压力大且响应慢。我的第一版实现很朴素，在Service层加一个RedisTemplate手动缓存：

java复制public List<TrainPlanVO> getPublishedPlans() {
    String cacheKey = "train:plans:published";
    String cached = redisTemplate.opsForValue().get(cacheKey);
    if (StringUtils.isNotEmpty(cached)) {
        return JSON.parseArray(cached, TrainPlanVO.class);
    }
    List<TrainPlanVO> plans = trainPlanMapper.selectPublishedPlans();
    redisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(plans), 30, TimeUnit.MINUTES);
    return plans;
}

这个写法有个问题：缓存穿透。如果数据库里本来就没有数据，Redis里也没缓存，所有请求都会打到数据库。后来我改成缓存空值，并且给空值设置一个较短的过期时间（比如5分钟），问题才缓解。

再进阶一些，可以用Spring Cache的@Cacheable注解，更优雅：

java复制@Cacheable(value = "trainPlan", key = "#planId", unless = "#result == null")
public TrainPlanVO getPlanDetail(Long planId) {
    // ...
}

用Spring Cache需要配置CacheManager指向Redis：

java复制@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofMinutes(30))
        .serializeValuesWith(SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
    return RedisCacheManager.builder(connectionFactory).cacheDefaults(config).build();
}

5.2 Docker部署与资源规划

这项目最终要交付给学校信息中心运维，环境是两台虚拟机，没装Tomcat、没装JDK，但装了Docker。所以我把项目打成了Docker镜像。先写Dockerfile：

dockerfile复制FROM openjdk:8-jdk-alpine
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
COPY target/teacher-training-system.jar /app/app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

然后构建和推送：

bash复制mvn clean package -DskipTests
docker build -t teacher-training-system:1.0.0 .
docker run -d -p 8080:8080 \
  -e DB_HOST=192.168.1.10 \
  -e SPRING_PROFILES_ACTIVE=prod \
  --restart=always teacher-training-system:1.0.0

生产环境里我把数据库连接信息、Redis地址都放到环境变量里了，不写死在application.yml中。application-prod.yml里用${DB_HOST}这种方式占位：

yaml复制spring:
  datasource:
    url: jdbc:mysql://${DB_HOST}:${DB_PORT}/${DB_NAME}?useUnicode=true&characterEncoding=utf8
    username: ${DB_USER}
    password: ${DB_PASSWORD}

这样做的好处是：镜像只有一个，不同环境通过环境变量区分，不会把生产库密码泄露到代码仓库里。如果用K8s部署，还能配合ConfigMap和Secret管理这些变量，那就更规范了。

这里再提一个部署细节：如果你的JSP页面包含中文字符，Docker基础镜像建议带中文字体，不然页面上有些中文显示会变方块。用openjdk:8-jdk-alpine没问题，但更保险的是用eclipse-temurin:8-jdk这个镜像，字体更全。

我个人接手这个项目最大的感受是，SpringBoot重写JSPM系统，最花时间的不是写新功能，而是处理各种新旧技术栈衔接的边界问题。JSP的渲染方式、Shiro的会话机制、MyBatis的SQL兼容、旧系统数据的迁移清洗，每一样都要单独花心思。如果时间允许，我强烈建议你在项目动工前，先拿一个最复杂的页面（比如培训计划管理）完整跑通，把JSP渲染、权限控制、CRUD、文件上传这些基础链路全部验证一遍，再铺开做其他模块。这样后面会顺很多。最后再分享一个小技巧：JSP项目在IDEA里调试时，打开自动编译开关，设置里搜Build project automatically勾上，配合devtools重启，一天的开发效率能顶上平时两天。