Spring Boot+Vue.js校园视频平台架构与实现

1. 校园视频平台系统架构解析

校园视频平台作为现代数字化校园建设的重要组成部分，其技术架构设计直接关系到系统的性能、扩展性和维护成本。本系统采用前后端分离架构，后端基于Spring Boot框架，前端使用Vue.js框架，数据库选用MySQL，形成了一套完整的技术解决方案。

1.1 后端技术栈：Spring Boot深度解析

Spring Boot作为本系统的后端框架，其核心价值在于简化了传统Spring应用的初始搭建和开发过程。在实际开发中，我们主要利用了以下特性：

自动配置机制：Spring Boot通过spring-boot-autoconfigure模块实现了"约定优于配置"的理念。例如，只需添加spring-boot-starter-data-jpa依赖，系统就会自动配置JPA相关bean，包括EntityManagerFactory和TransactionManager。这种机制大幅减少了XML配置的工作量。

java复制// 典型Spring Boot启动类配置
@SpringBootApplication
@EnableTransactionManagement
public class VideoPlatformApplication {
    public static void main(String[] args) {
        SpringApplication.run(VideoPlatformApplication.class, args);
    }
}

内嵌服务器支持：系统默认使用Tomcat作为内嵌服务器，无需额外部署WAR包。通过application.properties文件可以轻松配置服务器参数：

properties复制# 服务器配置示例
server.port=8080
server.servlet.context-path=/video-platform
server.tomcat.max-threads=200
server.tomcat.max-connections=10000

生产级特性：我们特别利用了Spring Boot Actuator模块来实现系统监控：

xml复制<!-- pom.xml中Actuator依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

通过配置可以暴露特定的监控端点：

properties复制# Actuator配置
management.endpoints.web.exposure.include=health,info,metrics
management.endpoint.health.show-details=always

1.2 前端技术栈：Vue.js实现细节

前端采用Vue 3的组合式API进行开发，主要实现了以下核心功能模块：

视频播放组件：使用video.js集成实现自适应播放器

vue复制<template>
  <div class="video-player">
    <video 
      ref="videoPlayer" 
      class="video-js"
      controls
      preload="auto"
      :poster="videoInfo.coverUrl"
    >
      <source :src="videoInfo.playUrl" type="video/mp4">
    </video>
  </div>
</template>

<script setup>
import { ref, onMounted, onBeforeUnmount } from 'vue'
import videojs from 'video.js'
import 'video.js/dist/video-js.css'

const props = defineProps({
  videoInfo: Object
})

const videoPlayer = ref(null)
let player = null

onMounted(() => {
  player = videojs(videoPlayer.value, {
    controls: true,
    autoplay: false,
    fluid: true,
    responsive: true
  })
})

onBeforeUnmount(() => {
  if (player) {
    player.dispose()
  }
})
</script>

状态管理：使用Pinia替代Vuex进行全局状态管理

javascript复制// stores/video.js
import { defineStore } from 'pinia'

export const useVideoStore = defineStore('video', {
  state: () => ({
    currentVideo: null,
    playHistory: [],
    favorites: []
  }),
  actions: {
    addToHistory(video) {
      // 去重逻辑
      if (!this.playHistory.some(v => v.id === video.id)) {
        this.playHistory.unshift(video)
        if (this.playHistory.length > 50) {
          this.playHistory.pop()
        }
      }
    },
    toggleFavorite(video) {
      const index = this.favorites.findIndex(v => v.id === video.id)
      if (index >= 0) {
        this.favorites.splice(index, 1)
      } else {
        this.favorites.unshift(video)
      }
    }
  },
  persist: {
    enabled: true,
    strategies: [
      {
        key: 'video_store',
        storage: localStorage
      }
    ]
  }
})

1.3 数据库设计：MySQL优化实践

数据库设计遵循第三范式，主要表结构如下：

视频表(video)

sql复制CREATE TABLE `video` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `title` varchar(100) NOT NULL COMMENT '视频标题',
  `cover_url` varchar(255) NOT NULL COMMENT '封面图URL',
  `video_url` varchar(255) NOT NULL COMMENT '视频文件URL',
  `duration` int(11) NOT NULL DEFAULT '0' COMMENT '视频时长(秒)',
  `category_id` int(11) NOT NULL COMMENT '分类ID',
  `user_id` bigint(20) NOT NULL COMMENT '上传用户ID',
  `description` text COMMENT '视频描述',
  `status` tinyint(4) NOT NULL DEFAULT '1' COMMENT '状态(0:下架,1:正常)',
  `view_count` int(11) NOT NULL DEFAULT '0' COMMENT '播放量',
  `like_count` int(11) NOT NULL DEFAULT '0' COMMENT '点赞数',
  `collect_count` int(11) NOT NULL DEFAULT '0' COMMENT '收藏数',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  KEY `idx_category` (`category_id`),
  KEY `idx_user` (`user_id`),
  KEY `idx_status` (`status`),
  FULLTEXT KEY `ft_title_desc` (`title`,`description`) COMMENT '全文索引'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='视频信息表';

性能优化措施：

1. 为常用查询字段创建合适的索引
2. 使用InnoDB引擎支持事务
3. 对搜索字段建立全文索引
4. 采用分库分表策略应对大数据量（视频评论表按视频ID分片）
5. 使用连接池管理数据库连接（HikariCP配置）

properties复制# application.properties数据库配置
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000

2. 系统核心功能实现

2.1 视频上传与处理流程

视频上传功能采用了分块上传策略，提高大文件上传的可靠性和效率：

java复制@RestController
@RequestMapping("/api/upload")
public class UploadController {
    
    @PostMapping("/chunk")
    public ResponseEntity<?> uploadChunk(
            @RequestParam("file") MultipartFile file,
            @RequestParam("chunkNumber") int chunkNumber,
            @RequestParam("totalChunks") int totalChunks,
            @RequestParam("identifier") String identifier,
            @RequestParam("filename") String filename) {
        
        // 检查文件是否为空
        if (file.isEmpty()) {
            return ResponseEntity.badRequest().body("上传文件不能为空");
        }
        
        try {
            // 创建临时目录存储分块
            String tempDir = System.getProperty("java.io.tmpdir") + "/uploads/" + identifier;
            File dir = new File(tempDir);
            if (!dir.exists()) {
                dir.mkdirs();
            }
            
            // 保存分块文件
            File chunkFile = new File(dir, filename + ".part" + chunkNumber);
            file.transferTo(chunkFile);
            
            // 检查是否所有分块都已上传完成
            if (chunkNumber == totalChunks - 1) {
                // 合并分块逻辑
                mergeFiles(tempDir, filename, totalChunks);
                
                // 视频转码处理
                processVideo(filename);
                
                return ResponseEntity.ok().body("上传完成");
            }
            
            return ResponseEntity.ok().body("分块上传成功");
        } catch (IOException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("上传失败: " + e.getMessage());
        }
    }
    
    private void mergeFiles(String tempDir, String filename, int totalChunks) 
            throws IOException {
        // 合并逻辑实现
    }
    
    private void processVideo(String filename) {
        // 使用FFmpeg进行视频转码
        // 生成不同清晰度的视频版本
        // 提取视频封面
    }
}

视频处理关键点：

1. 使用FFmpeg进行视频转码，生成多种分辨率（1080p、720p、480p）
2. 视频封面提取策略：
   • 默认截取第10秒的画面
   • 如果视频时长小于10秒，截取中间帧
   • 支持用户自定义上传封面
3. 视频元数据提取（时长、编码格式、分辨率等）
4. 视频内容安全审核（对接第三方审核API）

2.2 视频播放与推荐算法

视频播放页面实现了以下核心功能：

播放统计与热度计算

java复制@Service
public class VideoService {
    
    @Transactional
    public VideoVO getVideoDetail(Long videoId, Long userId) {
        // 记录观看历史
        if (userId != null) {
            historyService.recordViewHistory(userId, videoId);
        }
        
        // 原子性更新播放量
        videoMapper.incrementViewCount(videoId);
        
        // 获取视频详情
        VideoVO video = videoMapper.selectDetailById(videoId);
        
        // 计算视频热度得分（基于播放量、点赞、收藏、时间衰减）
        video.setHotScore(calculateHotScore(video));
        
        return video;
    }
    
    private double calculateHotScore(VideoVO video) {
        // 播放量权重
        double viewWeight = Math.log10(video.getViewCount() + 1) * 0.4;
        
        // 互动权重（点赞+收藏）
        double interactionWeight = Math.log10(video.getLikeCount() + video.getCollectCount() + 1) * 0.3;
        
        // 时间衰减因子（新视频有加成）
        long hoursSinceUpload = ChronoUnit.HOURS.between(
                video.getCreateTime().toInstant(), 
                Instant.now());
        double timeDecay = 1 / (1 + hoursSinceUpload / 48.0);
        
        return (viewWeight + interactionWeight) * timeDecay;
    }
}

推荐算法实现：

1. 基于内容的推荐：分析用户观看历史，推荐相似标签的视频
2. 协同过滤推荐：发现相似兴趣的用户群体，推荐他们喜欢的视频
3. 热门推荐：按热度得分排序
4. 新视频推荐：给予新上传视频一定的曝光机会

java复制public List<VideoVO> recommendVideos(Long userId, int pageSize) {
    List<VideoVO> recommendations = new ArrayList<>();
    
    // 1. 基于用户历史的推荐
    if (userId != null) {
        List<Long> historyVideoIds = historyService.getRecentViewedVideoIds(userId, 20);
        if (!historyVideoIds.isEmpty()) {
            List<Tag> userTags = tagService.getTagsByVideoIds(historyVideoIds);
            recommendations.addAll(
                videoMapper.selectByTags(userTags, pageSize / 2)
            );
        }
    }
    
    // 2. 热门推荐补全
    if (recommendations.size() < pageSize) {
        int remaining = pageSize - recommendations.size();
        recommendations.addAll(
            videoMapper.selectHotVideos(remaining)
        );
    }
    
    // 3. 新视频补全（确保多样性）
    if (recommendations.size() < pageSize) {
        int remaining = pageSize - recommendations.size();
        recommendations.addAll(
            videoMapper.selectNewVideos(remaining)
        );
    }
    
    return recommendations.stream()
            .distinct()
            .limit(pageSize)
            .collect(Collectors.toList());
}

2.3 弹幕功能实现

弹幕系统采用WebSocket实现实时通信：

java复制@ServerEndpoint("/barrage/{videoId}")
@Component
public class BarrageEndpoint {
    private static final ConcurrentHashMap<Long, CopyOnWriteArraySet<Session>> videoSessions = 
            new ConcurrentHashMap<>();
    
    @OnOpen
    public void onOpen(Session session, @PathParam("videoId") Long videoId) {
        videoSessions.computeIfAbsent(videoId, k -> new CopyOnWriteArraySet<>()).add(session);
    }
    
    @OnClose
    public void onClose(Session session, @PathParam("videoId") Long videoId) {
        Set<Session> sessions = videoSessions.get(videoId);
        if (sessions != null) {
            sessions.remove(session);
        }
    }
    
    @OnMessage
    public void onMessage(String message, Session session, @PathParam("videoId") Long videoId) {
        // 解析弹幕消息
        BarrageDTO barrage = parseMessage(message);
        
        // 保存到数据库
        saveBarrage(barrage);
        
        // 广播给所有观看同一视频的用户
        broadcast(videoId, toJson(barrage));
    }
    
    private void broadcast(Long videoId, String message) {
        Set<Session> sessions = videoSessions.get(videoId);
        if (sessions != null) {
            sessions.forEach(session -> {
                try {
                    session.getBasicRemote().sendText(message);
                } catch (IOException e) {
                    // 异常处理
                }
            });
        }
    }
}

弹幕优化策略：

1. 弹幕合并：短时间内相似内容的弹幕进行合并显示
2. 频率限制：同一用户发送弹幕的最小间隔时间控制
3. 敏感词过滤：实时检测弹幕内容中的敏感词
4. 弹幕轨道算法：自动分配弹幕显示轨道，避免重叠
5. 历史弹幕加载：视频播放时加载历史弹幕数据

3. 系统安全与性能优化

3.1 安全防护措施

认证与授权：采用JWT实现无状态认证

java复制@Component
public class JwtTokenProvider {
    private final String secretKey;
    private final long validityInMilliseconds;
    
    public JwtTokenProvider(
            @Value("${security.jwt.token.secret-key}") String secretKey,
            @Value("${security.jwt.token.expire-length}") long validityInMilliseconds) {
        this.secretKey = Base64.getEncoder().encodeToString(secretKey.getBytes());
        this.validityInMilliseconds = validityInMilliseconds;
    }
    
    public String createToken(String username, List<String> roles) {
        Claims claims = Jwts.claims().setSubject(username);
        claims.put("roles", roles);
        
        Date now = new Date();
        Date validity = new Date(now.getTime() + validityInMilliseconds);
        
        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(now)
                .setExpiration(validity)
                .signWith(SignatureAlgorithm.HS256, secretKey)
                .compact();
    }
    
    public Authentication getAuthentication(String token) {
        UserDetails userDetails = userDetailsService.loadUserByUsername(getUsername(token));
        return new UsernamePasswordAuthenticationToken(
                userDetails, "", userDetails.getAuthorities());
    }
    
    public boolean validateToken(String token) {
        try {
            Jws<Claims> claims = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
            return !claims.getBody().getExpiration().before(new Date());
        } catch (JwtException | IllegalArgumentException e) {
            throw new InvalidJwtAuthenticationException("Expired or invalid JWT token");
        }
    }
}

安全防护策略：

1. SQL注入防护：使用MyBatis预编译语句
2. XSS防护：前端使用DOMPurify净化输入，后端使用Jackson转义HTML
3. CSRF防护：Spring Security默认启用CSRF保护
4. 文件上传安全：
   • 限制文件类型（白名单机制）
   • 病毒扫描
   • 重命名存储文件
5. 敏感数据保护：
   • 密码加盐哈希存储
   • 隐私数据加密
6. 接口限流：Guava RateLimiter防止暴力请求

java复制@Aspect
@Component
public class RateLimitAspect {
    private final ConcurrentHashMap<String, RateLimiter> limiters = 
            new ConcurrentHashMap<>();
    
    @Value("${rate.limit.default:100}")
    private int defaultLimit;
    
    @Around("@annotation(rateLimit)")
    public Object rateLimit(ProceedingJoinPoint joinPoint, RateLimit rateLimit) 
            throws Throwable {
        String key = getRateLimitKey(joinPoint);
        RateLimiter limiter = limiters.computeIfAbsent(
                key, 
                k -> RateLimiter.create(rateLimit.value() > 0 ? 
                        rateLimit.value() : defaultLimit));
        
        if (limiter.tryAcquire()) {
            return joinPoint.proceed();
        } else {
            throw new RateLimitException("Too many requests");
        }
    }
    
    private String getRateLimitKey(ProceedingJoinPoint joinPoint) {
        // 生成基于方法和参数的唯一key
    }
}

3.2 性能优化实践

缓存策略：

1. 多级缓存架构：
   • 本地缓存（Caffeine）：高频访问数据
   • 分布式缓存（Redis）：共享数据
   • CDN缓存：静态资源

java复制@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .initialCapacity(100)
                .maximumSize(1000)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .recordStats());
        return cacheManager;
    }
    
    @Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1))
                .disableCachingNullValues()
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2JsonRedisSerializer()));
        
        return RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .transactionAware()
                .build();
    }
}

数据库优化：

1. 读写分离：Spring配置多数据源
2. 慢查询监控：开启MySQL慢查询日志
3. 索引优化：使用EXPLAIN分析查询计划
4. 批量操作：减少数据库交互次数

java复制@Repository
public class VideoRepositoryImpl implements VideoRepositoryCustom {
    
    @PersistenceContext
    private EntityManager em;
    
    @Override
    @Transactional
    public void batchInsert(List<Video> videos) {
        for (int i = 0; i < videos.size(); i++) {
            em.persist(videos.get(i));
            if (i % 50 == 0) {
                em.flush();
                em.clear();
            }
        }
        em.flush();
        em.clear();
    }
}

前端性能优化：

1. 组件懒加载
2. 路由懒加载
3. 图片懒加载
4. 资源预加载
5. 虚拟列表优化长列表渲染

javascript复制// 路由懒加载示例
const routes = [
  {
    path: '/video/:id',
    component: () => import('./views/VideoDetail.vue'),
    meta: { preload: true } // 标记为需要预加载的路由
  }
]

// 图片懒加载指令
app.directive('lazy', {
  mounted(el, binding) {
    const observer = new IntersectionObserver((entries) => {
      entries.forEach(entry => {
        if (entry.isIntersecting) {
          el.src = binding.value
          observer.unobserve(el)
        }
      })
    })
    observer.observe(el)
  }
})

4. 测试与部署方案

4.1 自动化测试策略

单元测试：使用JUnit 5 + Mockito

java复制@ExtendWith(MockitoExtension.class)
class VideoServiceTest {
    
    @Mock
    private VideoMapper videoMapper;
    
    @Mock
    private HistoryService historyService;
    
    @InjectMocks
    private VideoServiceImpl videoService;
    
    @Test
    void getVideoDetail_shouldIncrementViewCount() {
        // 准备测试数据
        Long videoId = 1L;
        Long userId = 100L;
        Video video = new Video();
        video.setId(videoId);
        video.setViewCount(10);
        
        // 模拟依赖行为
        when(videoMapper.selectById(videoId)).thenReturn(video);
        doNothing().when(historyService).recordViewHistory(userId, videoId);
        
        // 调用测试方法
        Video result = videoService.getVideoDetail(videoId, userId);
        
        // 验证结果
        assertEquals(11, result.getViewCount());
        verify(videoMapper).incrementViewCount(videoId);
        verify(historyService).recordViewHistory(userId, videoId);
    }
}

集成测试：使用TestContainers进行真实数据库测试

java复制@SpringBootTest
@Testcontainers
class VideoIntegrationTest {
    
    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0");
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", mysql::getJdbcUrl);
        registry.add("spring.datasource.username", mysql::getUsername);
        registry.add("spring.datasource.password", mysql::getPassword);
    }
    
    @Autowired
    private VideoRepository videoRepository;
    
    @Test
    void shouldSaveAndRetrieveVideo() {
        // 创建测试数据
        Video video = new Video();
        video.setTitle("Test Video");
        video.setVideoUrl("http://example.com/video.mp4");
        
        // 保存到数据库
        Video saved = videoRepository.save(video);
        
        // 查询验证
        Optional<Video> found = videoRepository.findById(saved.getId());
        assertTrue(found.isPresent());
        assertEquals("Test Video", found.get().getTitle());
    }
}

端到端测试：使用Cypress进行UI测试

javascript复制describe('Video Page', () => {
  beforeEach(() => {
    cy.login('testuser', 'password123')
    cy.visit('/video/1')
  })
  
  it('should play video when click play button', () => {
    cy.get('.video-player').should('be.visible')
    cy.get('.play-button').click()
    cy.get('.video-player video').should('have.prop', 'paused', false)
  })
  
  it('should add to history after watching 30 seconds', () => {
    cy.get('.play-button').click()
    cy.wait(30000) // 等待30秒
    cy.get('.history-tab').click()
    cy.get('.history-list').should('contain', 'Test Video')
  })
})

4.2 持续集成与部署

CI/CD流程：

1. 代码提交触发GitHub Actions工作流
2. 运行单元测试和集成测试
3. 构建Docker镜像
4. 部署到测试环境
5. 运行端到端测试
6. 人工确认后部署到生产环境

yaml复制# .github/workflows/deploy.yml
name: Build and Deploy

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    
    services:
      mysql:
        image: mysql:8.0
        env:
          MYSQL_ROOT_PASSWORD: root
          MYSQL_DATABASE: video_platform_test
        ports:
          - 3306:3306
        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
    
    steps:
      - uses: actions/checkout@v2
      
      - name: Set up JDK 11
        uses: actions/setup-java@v2
        with:
          java-version: '11'
          distribution: 'adopt'
          
      - name: Build with Maven
        run: mvn clean package -DskipTests
        
      - name: Run tests
        run: mvn test
        
      - name: Build Docker image
        run: docker build -t video-platform:${{ github.sha }} .
        
      - name: Login to Docker Hub
        if: github.ref == 'refs/heads/main'
        uses: docker/login-action@v1
        with:
          username: ${{ secrets.DOCKER_HUB_USERNAME }}
          password: ${{ secrets.DOCKER_HUB_TOKEN }}
          
      - name: Push to Docker Hub
        if: github.ref == 'refs/heads/main'
        run: |
          docker tag video-platform:${{ github.sha }} ${{ secrets.DOCKER_HUB_USERNAME }}/video-platform:latest
          docker push ${{ secrets.DOCKER_HUB_USERNAME }}/video-platform:latest

部署架构：

1. 使用Docker Compose编排服务

yaml复制version: '3.8'

services:
  app:
    image: username/video-platform:latest
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - DB_URL=jdbc:mysql://db:3306/video_platform
      - DB_USER=root
      - DB_PASSWORD=root
    depends_on:
      - db
      - redis
    
  db:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=video_platform
    volumes:
      - mysql_data:/var/lib/mysql
    
  redis:
    image: redis:6.2
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    
  nginx:
    image: nginx:1.21
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./static:/usr/share/nginx/static
    depends_on:
      - app

volumes:
  mysql_data:
  redis_data:

2. 生产环境使用Kubernetes集群部署

yaml复制# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: video-platform
spec:
  replicas: 3
  selector:
    matchLabels:
      app: video-platform
  template:
    metadata:
      labels:
        app: video-platform
    spec:
      containers:
      - name: app
        image: username/video-platform:latest
        ports:
        - containerPort: 8080
        envFrom:
        - configMapRef:
            name: video-platform-config
        resources:
          requests:
            cpu: "500m"
            memory: "512Mi"
          limits:
            cpu: "1000m"
            memory: "1Gi"
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: video-platform
spec:
  selector:
    app: video-platform
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

4.3 监控与日志

监控系统：

1. Prometheus收集指标
2. Grafana可视化监控数据
3. ELK收集和分析日志
4. 自定义业务指标监控

java复制@RestController
@RequestMapping("/api/videos")
public class VideoController {
    
    private final Counter videoViewCounter;
    
    public VideoController(MeterRegistry registry) {
        videoViewCounter = Counter.builder("video.views")
                .description("Number of video views")
                .tags("region", "us-east")
                .register(registry);
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<VideoDTO> getVideo(@PathVariable Long id) {
        videoViewCounter.increment();
        // 其他业务逻辑
    }
}

日志配置：

xml复制<!-- logback-spring.xml -->
<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    
    <springProperty scope="context" name="appName" source="spring.application.name"/>
    
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/${appName}.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/${appName}-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxHistory>30</maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy 
                class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <root level="INFO">
        <appender-ref ref="FILE"/>
    </root>
</configuration>

告警策略：

1. 错误率超过阈值
2. 响应时间超过SLA
3. 服务不可用
4. 异常流量波动
5. 数据库连接池耗尽

5. 开发经验与优化建议

在实际开发过程中，我们积累了一些有价值的经验教训和优化建议，这些都是在官方文档中难以找到的实战心得。

5.1 视频处理优化经验

FFmpeg参数调优：

java复制// 高质量转码参数（H.264编码）
String[] ffmpegCmd = {
    "ffmpeg",
    "-i", inputPath,
    "-c:v", "libx264",
    "-preset", "slow",
    "-crf", "22",
    "-profile:v", "high",
    "-level", "4.0",
    "-pix_fmt", "yuv420p",
    "-movflags", "+faststart",
    "-c:a", "aac",
    "-b:a", "128k",
    "-f", "mp4",
    outputPath
};

关键发现：

1. 使用-preset slow比ultrafast节省30%以上码率，画质更好
2. -movflags +faststart实现视频流式播放，用户无需等待完整下载
3. 并行编码大幅提升处理速度：

   bash复制-threads 4 -x264-params "frame-threads=4"
   

4. 硬件加速方案：
   • Intel Quick Sync: -hwaccel qsv -c:v h264_qsv
   • NVIDIA NVENC: -hwaccel cuda -c:v h264_nvenc

封面提取优化：

1. 多帧采样选择最优封面

   bash复制ffmpeg -i input.mp4 -vf "select=gt(scene\,0.4)" -frames:v 5 -vsync vfr thumb-%02d.png
   

2. 使用AI模型自动选择最具吸引力的封面
3. 封面图片压缩优化：

   bash复制ffmpeg -i thumb.png -q:v 2 -compression_level 6 thumb.jpg
   

5.2 数据库优化技巧

分页查询优化：

sql复制-- 低效写法（偏移量大时性能差）
SELECT * FROM video ORDER BY create_time DESC LIMIT 10000, 20;

-- 高效写法（使用索引覆盖）
SELECT * FROM video 
WHERE id < (SELECT id FROM video ORDER BY create_time DESC LIMIT 10000, 1)
ORDER BY create_time DESC 
LIMIT 20;

实战经验：

1. 评论表按视频ID分片，避免单表过大
2. 热点数据缓存策略：
   • 一级缓存：本地缓存（Caffeine）
   • 二级缓存：Redis集群
   • 缓存失效策略：主动更新+被动过期
3. 连接池配置经验：

   properties复制# 根据系统负载动态调整
   spring.datasource.hikari.maximum-pool-size=CPU核心数 * 2 + 有效磁盘数
   spring.datasource.hikari.minimum-idle=CPU核心数
   

4. 批量插入使用rewriteBatchedStatements=true参数提升性能

5.3 前端性能关键点

视频播放器优化：

1. 自适应码率切换（DASH/HLS）
2. 预加载策略：

   html复制<video preload="metadata">
     <source src="video.mp4#t=0.1" type="video/mp4">
   </video>
   

3. 缓冲区管理：

   javascript复制// 手动控制缓冲区大小
   video.addEventListener('progress', () => {
     if (video.buffered.length > 0) {
       const bufferEnd = video.buffered.end(video.buffered.length - 1);
       const currentTime = video.currentTime;
       
       if (bufferEnd - currentTime > 30) {
         // 暂停加载
         video.removeAttribute('src');
         video.load();
       }
     }
   });
   

组件优化技巧：

1. 虚拟滚动优化长列表：

   vue复制<RecycleScroller
     class="video-list"
     :items="videos"
     :item-size="210"
     key-field="id"
   >
     <template #default="{ item }">
       <VideoCard :video="item" />
     </template>
   </RecycleScroller>
   

2. 防抖节流应用：

   javascript复制// 滚动事件优化
   window.addEventListener('scroll', throttle(() => {
     // 检查是否滚动到底部
   }, 200));
   

3. Web Worker处理复杂计算：

   javascript复制// 在worker中处理弹幕数据分析
   const worker = new Worker('danmu-worker.js');
   worker.postMessage(danmuData);
   worker.onmessage = (e) => {
     updateDanmu(e.data);
   };
   

5.4 扩展功能建议

未来可考虑的功能扩展：

1. 视频AI分析：
   • 自动生成字幕
   • 内容摘要
   • 敏感场景检测
2. 互动功能增强：
   • 实时在线人数显示
   • 协同观看（同步播放控制）
   • 直播连麦
3. 多端适配：
   • PWA支持离线观看
   • 电视大屏适配
   • 微信小程序端
4. 数据分析：
   • 观看热力图
   • 用户行为分析
   • 内容推荐优化

架构演进方向：

1. 微服务化拆分：
   • 用户服务
   • 视频服务
   • 推荐服务
   • 互动服务
     2