基于 Spring Boot 的电影交流平台设计与实现

主要数据表及其关系如下：

-- 用户表
CREATE TABLE `user` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password` varchar(100) NOT NULL,
  `avatar` varchar(255) DEFAULT NULL,
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `idx_username` (`username`)
);

-- 电影表
CREATE TABLE `movie` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `title` varchar(100) NOT NULL,
  `cover_url` varchar(255) DEFAULT NULL,
  `description` text,
  `rating` decimal(3,1) DEFAULT NULL,
  `release_year` int DEFAULT NULL,
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  KEY `idx_title` (`title`),
  KEY `idx_rating` (`rating`)
);

-- 用户行为表（用于推荐）
CREATE TABLE `user_behavior` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `user_id` bigint NOT NULL,
  `movie_id` bigint NOT NULL,
  `behavior_type` tinyint NOT NULL COMMENT '1-浏览 2-收藏 3-评论',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  KEY `idx_user_movie` (`user_id`,`movie_id`)
);

三、关键技术实现

3.1 基于协同过滤的推荐算法

系统采用基于用户的协同过滤算法实现推荐功能，核心代码如下：

public List<Movie> recommendMovies(Long userId, int limit) {
    // 1. 获取目标用户的行为数据
    List<UserBehavior> targetBehaviors = behaviorMapper.selectByUserId(userId);
    // 2. 找到相似用户
    Map<Long, Double> similarUsers = findSimilarUsers(userId, targetBehaviors);
    // 3. 获取相似用户喜欢的电影
    List<RecommendItem> recommendItems = new ArrayList<>();
    for (Map.Entry<Long, Double> entry : similarUsers.entrySet()) {
        Long similarUserId = entry.getKey();
        Double similarity = entry.getValue();
        List<UserBehavior> behaviors = behaviorMapper.selectByUserId(similarUserId);
        for (UserBehavior behavior : behaviors) {
            if (targetBehaviors.stream().noneMatch(b -> b.getMovieId().equals(behavior.getMovieId()))) {
                recommendItems.add(new RecommendItem(behavior.getMovieId(), similarity));
            }
        }
    }
    // 4. 排序并返回推荐结果
    return recommendItems.stream()
            .sorted(Comparator.comparingDouble(RecommendItem::getScore).reversed())
            .limit(limit)
            .map(item -> movieMapper.selectById(item.getMovieId()))
            .collect(Collectors.toList());
}

private Map<Long, Double> findSimilarUsers(Long userId, List<UserBehavior> targetBehaviors) {
    // 简化的相似度计算，实际项目中可以使用更复杂的算法
    List<Long> targetMovieIds = targetBehaviors.stream()
            .map(UserBehavior::getMovieId)
            .collect(Collectors.toList());
    List<UserSimilarity> similarities = behaviorMapper.calculateUserSimilarities(userId, targetMovieIds);
    return similarities.stream()
            .filter(sim -> sim.getSimilarity() > 0.3)
            .collect(Collectors.toMap(UserSimilarity::getOtherUserId, UserSimilarity::getSimilarity));
}

3.2 JWT 认证实现

系统采用 JWT 进行用户认证，Spring Security 配置如下：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/api/auth/").permitAll()
            .antMatchers("/api/admin/").hasRole("ADMIN")
            .anyRequest().authenticated()
            .and()
            .addFilter(new JwtAuthenticationFilter(authenticationManager()))
            .addFilter(new JwtAuthorizationFilter(authenticationManager()))
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

JWT 生成工具类：

public class JwtUtil {
    private static final String SECRET = "your-secret-key";
    private static final long EXPIRATION = 86400000L; // 24 小时

    public static String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("roles", userDetails.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList()));
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(userDetails.getUsername())
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
                .signWith(SignatureAlgorithm.HS512, SECRET)
                .compact();
    }
    // 其他验证方法...
}

3.3 评论功能实现

评论系统支持多级回复，核心数据结构设计如下：

// 评论实体
@Data
public class Comment {
    private Long id;
    private Long movieId;
    private Long userId;
    private Long parentId; // 父评论 ID，0 表示一级评论
    private String content;
    private Date createTime;
    private Integer likeCount;
    private List<Comment> replies; // 子评论
}

// 评论服务层
@Service
public class CommentService {
    @Autowired
    private CommentMapper commentMapper;

    public List<Comment> getCommentsByMovie(Long movieId) {
        // 获取所有评论
        List<Comment> allComments = commentMapper.selectByMovieId(movieId);
        // 构建评论树
        Map<Long, Comment> commentMap = new HashMap<>();
        List<Comment> rootComments = new ArrayList<>();
        for (Comment comment : allComments) {
            comment.setReplies(new ArrayList<>());
            commentMap.put(comment.getId(), comment);
            if (comment.getParentId() == 0) {
                rootComments.add(comment);
            } else {
                Comment parent = commentMap.get(comment.getParentId());
                if (parent != null) {
                    parent.getReplies().add(comment);
                }
            }
        }
        return rootComments;
    }
    // 其他方法...
}

四、开发中的挑战与解决方案

4.1 性能优化

问题： 当用户量和电影数据增加后，系统响应变慢。

解决方案：

1. 引入 Redis 缓存热门数据和推荐结果
2. 数据库查询优化，添加适当索引
3. 实现分页查询，避免一次性加载过多数据

// 使用 Redis 缓存的示例
@Service
public class MovieServiceImpl implements MovieService {
    @Autowired
    private MovieMapper movieMapper;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final String CACHE_KEY_PREFIX = "movie:";
    private static final long CACHE_EXPIRE = 3600; // 1 小时

    @Override
    @Cacheable(value = "movies", key = "#id")
    public Movie getMovieById(Long id) {
        String cacheKey = CACHE_KEY_PREFIX + id;
        Movie movie = (Movie) redisTemplate.opsForValue().get(cacheKey);
        if (movie == null) {
            movie = movieMapper.selectById(id);
            if (movie != null) {
                redisTemplate.opsForValue().set(cacheKey, movie, CACHE_EXPIRE, TimeUnit.SECONDS);
            }
        }
        return movie;
    }
}

4.2 跨域问题

问题： 前后端分离开发时遇到跨域请求限制。

解决方案： 配置 CorsFilter 解决跨域问题。

@Configuration
public class CorsConfig {
    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        // 允许所有域名访问（生产环境应指定具体域名）
        config.addAllowedOrigin("*");
        // 允许的请求方法
        config.addAllowedMethod("*");
        // 允许的请求头
        config.addAllowedHeader("*");
        // 允许携带凭证
        config.setAllowCredentials(true);
        source.registerCorsConfiguration("/", config);
        return new CorsFilter(source);
    }
}

4.3 推荐算法优化

问题： 初期实现的推荐算法准确度不高。

解决方案： 改进相似度计算方法，引入更多用户行为特征。

// 改进后的用户相似度计算
public double calculateUserSimilarity(Long userId1, Long userId2) {
    // 获取两个用户的行为数据
    List<UserBehavior> behaviors1 = behaviorMapper.selectByUserId(userId1);
    List<UserBehavior> behaviors2 = behaviorMapper.selectByUserId(userId2);

    // 计算共同行为项
    Set<Long> commonMovies = new HashSet<>();
    Map<Long, Integer> behaviorWeights1 = new HashMap<>();
    Map<Long, Integer> behaviorWeights2 = new HashMap<>();

    // 行为权重：浏览 1，收藏 3，评论 5
    behaviors1.forEach(b -> {
        int weight = b.getBehaviorType() == 1 ? 1 : (b.getBehaviorType() == 2 ? 3 : 5);
        behaviorWeights1.put(b.getMovieId(), weight);
        commonMovies.add(b.getMovieId());
    });
    behaviors2.forEach(b -> {
        int weight = b.getBehaviorType() == 1 ? 1 : (b.getBehaviorType() == 2 ? 3 : 5);
        behaviorWeights2.put(b.getMovieId(), weight);
        commonMovies.add(b.getMovieId());
    });

    // 计算余弦相似度
    double dotProduct = 0;
    double norm1 = 0;
    double norm2 = 0;
    for (Long movieId : commonMovies) {
        int w1 = behaviorWeights1.getOrDefault(movieId, 0);
        int w2 = behaviorWeights2.getOrDefault(movieId, 0);
        dotProduct += w1 * w2;
        norm1 += w1 * w1;
        norm2 += w2 * w2;
    }
    return norm1 == 0 || norm2 == 0 ? 0 : dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
}

五、项目总结与展望

5.1 项目成果

通过本次项目，我实现了以下目标：

1. 完成了功能完善的电影交流平台
2. 掌握了 Spring Boot 全栈开发技能
3. 深入理解了推荐系统的基本原理
4. 积累了解决实际问题的经验

5.2 未来改进方向

1. 推荐算法优化：尝试深度学习模型提升推荐准确度
2. 实时互动功能：集成 WebSocket 实现用户实时聊天
3. 微服务架构改造：将系统拆分为多个微服务提高可扩展性
4. 移动端适配：开发 React Native 或 Flutter 版本移动应用