Spring MVC 性能调优与部署运维-CFANZ编程社区

性能调优概述

性能调优的层次结构

应用层优化    ← 业务逻辑、算法优化
框架层优化    ← Spring MVC配置、功能调优  
容器层优化    ← Tomcat/Jetty配置优化
JVM层优化     ← 垃圾回收、内存管理
系统层优化    ← 操作系统、网络配置
硬件层优化    ← CPU、内存、存储优化

性能调优原则

测量优于猜测 - 先测量，再优化
瓶颈驱动 - 优化系统瓶颈，而非所有部分
渐进式优化 - 逐步优化，避免一次性大改
保持可维护性 - 优化不应牺牲代码可读性

性能监控指标

@Component
public class PerformanceMetrics {
    
    private final MeterRegistry meterRegistry;
    private final Counter requestCounter;
    private final Timer responseTimer;
    private final Gauge activeUsers;
    
    public PerformanceMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.requestCounter = Counter.builder("http.requests.total")
            .description("Total HTTP requests")
            .register(meterRegistry);
        this.responseTimer = Timer.builder("http.requests.duration")
            .description("HTTP request duration")
            .register(meterRegistry);
        this.activeUsers = Gauge.builder("users.active")
            .description("Active users")
            .register(meterRegistry, this, PerformanceMetrics::getActiveUserCount);
    }
    
    public void recordRequest() {
        requestCounter.increment();
    }
    
    public Timer.Sample startTimerSample() {
        return Timer.start(meterRegistry);
    }
    
    private double getActiveUserCount() {
        // 返回当前活跃用户数
        return getCurrentActiveUsers();
    }
}

JVM性能优化

JVM参数优化配置

生产环境JVM配置

#!/bin/bash
# 生产环境JVM启动参数
CATALINA_OPTS="-server \
-Xms4g -Xmx4g \
-XX:NewRatio=3 \
-XX:+UseG1GC \
-XX:MaxGCPauseMillis=200 \
-XX:G1HeapRegionSize=16m \
-XX:+UnlockExperimentalVMOptions \
-XX:+UseStringDeduplication \
-Djava.awt.headless=true \
-Djava.security.egd=file:/dev/./urandom \
-XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath=/var/logs/heapdump.hprof \
-verbose:gc \
-XX:+PrintGCDetails \
-XX:+PrintGCTimeStamps \
-Xloggc:/var/logs/gc.log"

垃圾回收监控

GC性能监控代码

@Component
public class GCMonitor {
    
    private static final Logger logger = LoggerFactory.getLogger(GCMonitor.class);
    
    @EventListener
    @Async
    public void onGCInfo(GCInfoEvent event) {
        logger.info("GC事件: {} - 耗时: {}ms, 释放内存: {}MB", 
                   event.getGcType(),
                   event.getDuration(),
                   event.getMemoryReleased());
        
        // 记录GC性能指标
        recordGCMetrics(event);
    }
    
    @Scheduled(fixedRate = 60000) // 每分钟检查
    public void checkGCPerformance() {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        
        long usedMemory = heapUsage.getUsed();
        long maxMemory = heapUsage.getMax();
        double memoryUsagePercent = (double) usedMemory / maxMemory * 100;
        
        if (memoryUsagePercent > 80) {
            logger.warn("内存使用率过高: {}%", memoryUsagePercent);
            
            // 触发GC建议
            System.gc();
        }
    }
}

Spring MVC性能调优

异步处理优化

异步控制器配置

@Configuration
public class AsyncConfig implements WebMvcConfigurer {
    
    @Bean(name = "taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolThreads(Runtime.getRuntime().availableProcessors());
        executor.setMaxPoolThreads(Runtime.getRuntime().availableProcessors() * 2);
        executor.setQueueCapacity(1000);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
    
    @Override
    public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
        configurer.setTaskExecutor(taskExecutor());
        configurer.setDefaultTimeout(30000); // 30秒超时
    }
}

消息转换器优化

高效的JSON序列化配置

@Configuration
public class MessageConverterConfig implements WebMvcConfigurer {
    
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        // Jackson JSON转换器优化
        Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.json()
            .featuresToDisable(SerializationFeature.FAIL_ON_EMPTY_BEANS)
            .featuresToDisable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
            .indentOutput(false) // 生产环境不格式化输出
            .dateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        
        converters.add(new MappingJackson2HttpMessageConverter(builder.build()));
        
        // 启用压缩
        converters.forEach(converter -> {
            if (converter instanceof MappingJackson2HttpMessageConverter) {
                ((MappingJackson2HttpMessageConverter) converter).setSupportedMediaTypes(
                    Arrays.asList(
                        MediaType.APPLICATION_JSON,
                        new MediaType("application", "*+json"),
                        new MediaType("application", "json", Charset.forName("UTF-8"))
                    )
                );
            }
        });
    }
}

静态资源优化

静态资源配置

@Configuration
public class StaticResourceConfig implements WebMvcConfigurer {
    
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        // CSS文件 - 长期缓存
        registry.addResourceHandler("/css/**")
            .addResourceLocations("classpath:/static/css/")
            .setCachePeriod(31536000) // 1年缓存
            .resourceChain(true)
            .addResolver(new VersionResourceResolver().addContentVersionStrategy("/**"));
        
        // JS文件 - 长期缓存
        registry.addResourceHandler("/js/**")
            .addResourceLocations("classpath:/static/js/")
            .setCachePeriod(31536000)
            .resourceChain(true);
        
        // 图片文件 - 长期缓存
        registry.addResourceHandler("/images/**")
            .addResourceLocations("classpath:/static/images/")
            .setCachePeriod(31536000);
        
        // 字体文件 - 长期缓存
        registry.addResourceHandler("/fonts/**")
            .addResourceLocations("classpath:/static/fonts/")
            .setCachePeriod(31536000);
    }
}

数据库性能优化

连接池优化

HikariCP配置

spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      idle-timeout: 300000
      max-lifetime: 1200000
      connection-timeout: 30000
      validation-timeout: 5000
      leak-detection-threshold: 60000
      pool-name: "SpringMvc-Pool"
      
  jpa:
    hibernate:
      ddl-auto: validate
    properties:
      hibernate:
        jdbc.batch_size: 25
        order_inserts: true
        order_updates: true
        jdbc.batch_versioned_data: true
        connection.provider_disables_autocommit: true
        show_sql: false
        format_sql: false

数据库查询优化

Repository优化

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    // 使用@Query优化查询
    @Query("SELECT u FROM User u WHERE u.status = :status AND u.createdDate >= :startDate")
    List<User> findActiveUsersSinceDate(@Param("status") UserStatus status, 
                                       @Param("startDate") LocalDateTime startDate);
    
    // 使用投影查询只获取需要的字段
    @Query("SELECT new com.example.dto.UserSummaryDTO(u.id, u.username, u.email, u.status) " +
           "FROM User u WHERE u.status = :status")
    List<UserSummaryDTO> findUserSummaries(@Param("status") UserStatus status);
    
    // 批量更新
    @Modifying
    @Query("UPDATE User u SET u.lastLoginTime = :loginTime WHERE u.id IN :userIds")
    int updateLastLoginTime(@Param("userIds") List<Long> userIds, 
                           @Param("loginTime") LocalDateTime loginTime);
    
    // 使用分页避免加载大量数据
    Page<User> findByNameContaining(String name, Pageable pageable);
}

N+1查询问题解决

批量查询优化

@Service
public class UserService {
    
    @Transactional(readOnly = true)
    public List<UserDetailDTO> findUsersWithDetails(List<Long> userIds) {
        // 避免N+1问题：一次性查询用户
        List<User> users = userRepository.findAllById(userIds);
        
        // 提取用户ID列表
        Set<Long> userIdSet = users.stream()
            .map(User::getId)
            .collect(Collectors.toSet());
        
        // 批量查询关联数据
        Map<Long, List<Role>> userRolesMap = roleRepository
            .findByUserIdIn(userIdSet)
            .stream()
            .collect(Collectors.groupingBy(UserRole::getUserId));
        
        Map<Long, List<Permission>> userPermissionsMap = permissionRepository
            .findByUserIdIn(userIdSet)
            .stream()
            .collect(Collectors.groupingBy(UserPermission::getUserId));
        
        // 组装结果
        return users.stream()
            .map(user -> UserDetailDTO.builder()
                .user(user)
                .roles(userRolesMap.getOrDefault(user.getId(), Collections.emptyList()))
                .permissions(userPermissionsMap.getOrDefault(user.getId(),
                    Collections.emptyList()))
                .build())
            .collect(Collectors.toList());
    }
}

缓存策略优化

多级缓存架构

缓存配置

@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        // 使用Caffeine作为本地缓存
        CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
        caffeineCacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(Duration.ofMinutes(30))
            .expireAfterAccess(Duration.ofMinutes(10))
            .recordStats());
        
        // 使用Redis作为分布式缓存
        RedisCacheManager.Builder builder = RedisCacheManager
            .RedisCacheManagerBuilder
            .fromConnectionFactory(redisConnectionFactory())
            .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1))
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                    .fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                    .fromSerializer(new GenericJackson2JsonRedisSerializer())));
        
        // 简单缓存管理器
        SimpleCacheManager simpleCacheManager = new SimpleCacheManager();
        simpleCacheManager.setCaches(Arrays.asList(
            caffeineCacheManager.getCache("users"),
            caffeineCacheManager.getCache("products"),
            caffeineCacheManager.getCache("categories")
        ));
        
        return simpleCacheManager;
    }
}

缓存策略实现

智能缓存服务

@Service
public class CachedUserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // L1缓存：本地缓存
    @Cacheable(value = "users", key = "#id")
    public User findById(Long id) {
        log.debug("从数据库查询用户: {}", id);
        return userRepository.findById(id).orElse(null);
    }
    
    // L2缓存：分布式缓存
    public List<User> findAllUsers() {
        String cacheKey = "users:all";
        
        // 先从Redis获取
        List<User> users = (List<User>) redisTemplate.opsForValue().get(cacheKey);
        
        if (users == null) {
            // Redis中没有，从数据库查询
            log.debug("从数据库查询所有用户");
            users = userRepository.findAll();
            
            // 存入Redis，缓存1小时
            redisTemplate.opsForValue().set(cacheKey, users, Duration.ofHours(1));
        } else {
            log.debug("从Redis缓存获取用户列表");
        }
        
        return users;
    }
    
    // 缓存失效策略
    @CacheEvict(value = "users", key = "#user.id")
    @Transactional
    public User updateUser(User user) {
        User updatedUser = userRepository.save(user);
        
        // 清除相关缓存
        evictUserListCache();
        
        return updatedUser;
    }
    
    private void evictUserListCache() {
        String cacheKey = "users:all";
        redisTemplate.delete(cacheKey);
        log.debug("清除用户列表缓存: {}", cacheKey);
    }
}

生产环境部署

Spring Boot应用配置

生产环境配置

# application-prod.yml
server:
  port: 8080
  servlet:
    session:
      timeout: 30m
    context-path: /api
  tomcat:
    max-threads: 200
    min-spare-threads: 10
    max-connections: 8192
    accept-count: 100
    connection-timeout: 20000ms
    max-swallow-size: 2MB
    compression:
      enabled: true
      min-response-size: 1024
      mime-types: text/html,text/xml,text/plain,text/css,text/javascript,application/javascript,application/json

spring:
  profiles:
    active: prod
  datasource:
    url: jdbc:postgresql://localhost:5432/proddb
    username: ${DB_USERNAME:produser}
    password: ${DB_PASSWORD}
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  endpoint:
    health:
      show-details: when-authorized
  metrics:
    export:
      prometheus:
        enabled: true

logging:
  level:
    root: INFO
    com.example: DEBUG
  file:
    name: /var/logs/spring-mvc-app.log
  logback:
    rollingpolicy:
      max-file-size: 100MB
      max-history: 30
      total-size-cap: 3GB

启动脚本

生产环境启动脚本

#!/bin/bash
# start.sh
APP_NAME="spring-mvc-app"
APP_PORT=8080
JAVA_OPTS="-server -Xms2g -Xmx2g -XX:+UseG1GC"

PID_FILE="/var/run/${APP_NAME}.pid"
LOG_FILE="/var/logs/${APP_NAME}.log"

start() {
    if [ -f $PID_FILE ]; then
        PID=$(cat $PID_FILE)
        if ps -p $PID > /dev/null 2>&1; then
            echo "应用程序已在运行 (PID: $PID)"
            return 1
        fi
    fi
    
    echo "启动 ${APP_NAME}..."
    nohup java $JAVA_OPTS \
        -Dspring.profiles.active=prod \
        -jar ${APP_NAME}-1.0.0.jar \
        > $LOG_FILE 2>&1 &
    
    echo $! > $PID_FILE
    echo "应用程序已启动 (PID: $(cat $PID_FILE))"
}

stop() {
    if [ -f $PID_FILE ]; then
        PID=$(cat $PID_FILE)
        if ps -p $PID > /dev/null 2>&1; then
            echo "停止 ${APP_NAME}..."
            kill $PID
            rm $PID_FILE
            echo "应用程序已停止"
        else
            echo "应用程序未运行"
            rm $PID_FILE
        fi
    else
        echo "应用程序未运行"
    fi
}

restart() {
    stop
    sleep 5
    start
}

case "$1" in
    start) start ;;
    stop) stop ;;
    restart) restart ;;
    *) echo "Usage: $0 {start|stop|restart}" ;;
esac

容器化部署

Dockerfile配置

多阶段构建Dockerfile

# 构建阶段
FROM maven:3.8.5-openjdk-11-slim AS builder

WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline -B

COPY src ./src
RUN mvn clean package -DskipTests

# 运行阶段
FROM openjdk:11-jre-slim

# 安全用户
RUN groupadd -r appgroup && useradd -r -g appgroup appuser

WORKDIR /app

# 复制JAR文件
COPY --from=builder /app/target/*.jar app.jar

# 创建日志目录
RUN mkdir -p /app/logs && chown -R appuser:appgroup /app

USER appuser

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8080/actuator/health || exit 1

EXPOSE 8080

ENTRYPOINT ["java", \
    "-server", \
    "-Xms512m", \
    "-Xmx1024m", \
    "-XX:+UseG1GC", \
    "-Djava.security.egd=file:/dev/./urandom", \
    "-Dspring.profiles.active=prod", \
    "-jar", "app.jar"]

Docker Compose配置

多服务编排

version: '3.8'

services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - DB_HOST=postgres
      - REDIS_HOST=redis
    depends_on:
      - postgres
      - redis
    volumes:
      - /var/logs:/app/logs
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  postgres:
    image: postgres:13
    environment:
      POSTGRES_DB: springapp
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./scripts/init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5432:5432"
    restart: unless-stopped

  redis:
    image: redis:6-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis_data:/data
    ports:
      - "6379:6379"
    restart: unless-stopped

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/ssl:/etc/nginx/ssl
    depends_on:
      - app
    restart: unless-stopped

volumes:
  postgres_data:
  redis_data:

监控与运维

应用性能监控

Micrometer集成

@Component
public class ApplicationMetrics {
    
    private final MeterRegistry meterRegistry;
    
    public ApplicationMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        initializeCustomMetrics();
    }
    
    private void initializeCustomMetrics() {
        // 自定义业务指标
        Counter.builder("user.registrations")
            .description("用户注册次数")
            .register(meterRegistry);
        
        Timer.builder("user.login.duration")
            .description("用户登录响应时间")
            .register(meterRegistry);
        
        Gauge.builder("user.active.count")
            .description("当前活跃用户数")
            .register(meterRegistry, this, ApplicationMetrics::getActiveUserCount);
    }
    
    public void recordUserRegistration() {
        Counter.builder("user.registrations")
            .register(meterRegistry)
            .increment();
    }
    
    public void recordLoginTime(Duration duration) {
        Timer.builder("user.login.duration")
            .register(meterRegistry)
            .record(duration);
    }
    
    private double getActiveUserCount() {
        // 返回当前活跃用户数
        return getCurrentActiveUsers();
    }
}

健康检查

自定义健康检查器

@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    
    @Autowired
    private DataSource dataSource;
    
    @Override
    public Health health() {
        try (Connection connection = dataSource.getConnection()) {
            DatabaseMetaData metaData = connection.getMetaData();
            String productName = metaData.getDatabaseProductName();
            String productVersion = metaData.getDatabaseProductVersion();
            
            return Health.up()
                .withDetail("database", productName)
                .withDetail("version", productVersion)
                .withDetail("connection", "success")
                .build();
        } catch (SQLException e) {
            return Health.down()
                .withDetail("database", "unknown")
                .withDetail("connection", "failed")
                .withDetail("error", e.getMessage())
                .build();
        }
    }
}

@Component
public class CacheHealthIndicator implements HealthIndicator {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Override
    public Health health() {
        try {
            String pong = redisTemplate.getConnectionFactory()
                .getConnection()
                .ping();
            
            return Health.up()
                .withDetail("redis", "Redis")
                .withDetail("ping", pong)
                .build();
        } catch (Exception e) {
            return Health.down()
                .withDetail("redis", "Redis")
                .withDetail("error", e.getMessage())
                .build();
        }
    }
}

日志分析

结构化日志配置

<!-- logback-spring.xml -->
<configuration>
    <springProfile name="prod">
        <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>/var/logs/spring-mvc-app.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>/var/logs/spring-mvc-app.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>100MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                <maxHistory>30</maxHistory>
            </rollingPolicy>
            <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
                <providers>
                    <timestamp/>
                    <logLevel/>
                    <loggerName/>
                    <message/>
                    <mdc/>
                    <stackTrace/>
                </providers>
            </encoder>
        </appender>
        
        <root level="INFO">
            <appender-ref ref="FILE" />
        </root>
    </springProfile>
</configuration>

高并发架构设计

集群部署架构

负载均衡配置

# nginx.conf
upstream spring_backend {
    server app1:8080 weight=3 max_fails=3 fail_timeout=30s;
    server app2:8080 weight=3 max_fails=3 fail_timeout=30s;
    server app3:8080 weight=2 max_fails=3 fail_timeout=30s;
    
    keepalive 32;
}

server {
    listen 80;
    server_name api.example.com;
    
    location / {
        proxy_pass http://spring_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        proxy_connect_timeout 5s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
        proxy_buffer_size 8k;
        proxy_buffers 8 8k;
        
        # 启用keepalive
        proxy_http_version 1.1;
        proxy_set_header Connection "";
    }
    
    location /health {
        access_log off;
        proxy_pass http://spring_backend;
    }
}

会话管理

分布式会话配置

@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 1800) // 30分钟
public class SessionConfig {
    
    @Bean
    public LettuceConnectionFactory connectionFactory() {
        return new LettuceConnectionFactory(
            new RedisStandaloneConfiguration("redis", 6379));
    }
    
    @Bean
    public RedisTemplate<?, ?> redisTemplate() {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory());
        return template;
    }
}

总结

Spring MVC性能调优与部署运维是实现企业级应用的关键环节。本教程全面介绍了：

核心优化策略

JVM性能优化 - 内存管理、垃圾回收调优
Spring MVC优化 - 异步处理、消息转换器、静态资源优化
数据库性能优化 - 连接池调优、查询优化、N+1问题解决
缓存策略优化 - 多级缓存架构、智能缓存策略
并发处理优化 - 线程池配置、异步处理机制

部署运维实践

生产环境部署 - 完整的生产级配置和启动脚本
容器化部署 - Docker多阶段构建和服务编排
监控与运维 - 性能监控、健康检查、日志分析
高并发架构 - 负载均衡、分布式会话、集群部署

最佳实践建议

循序渐进：从单个指标开始，逐步完善监控体系
数据驱动：基于监控数据进行优化决策
自动化优先：尽可能实现部署和运维的自动化
持续改进：建立性能优化和运维改进的持续流程

完整学习路径

结合前面6个Spring MVC教程，完整的知识体系为：

基础模块教程 - 入门基础 🚀
控制器模块教程 - 核心功能 🎮
视图技术模块教程 - 前端集成 🎨
表单处理模块教程 - 用户交互 📝
高级特性模块教程 - 企业功能 ⚡
测试调试模块教程 - 质量保证 🧪
性能优化模块教程 - 生产运维 📊 (本篇)
后续也会继续更新多种多样的关于springmvc的教程
这部分教程构建了一个完整的Spring MVC学习生态，从基础入门到生产运维，全面覆盖企业级Java Web开发的各个层面，为学习者提供了一个系统化、深入的学习路径！