Java点播系统案例

本文目录导读：

1. 系统架构设计
2. 核心代码实现
3. 运行测试
4. 系统演示示例
5. 系统特性

我来为您设计一个完整的Java点播系统案例,包含用户点播视频的核心功能。

系统架构设计

点播系统
├── 实体类 (entity)
├── 数据访问层 (DAO)
├── 业务逻辑层 (Service)
├── 控制层 (Controller)
└── 工具类 (util)

核心代码实现

实体类

// Video.java
package com.vod.entity;
import java.util.Date;
public class Video {
    private Long id;
    private String title;
    private String description;
    private String category;
    private String videoUrl;
    private String coverImage;
    private Double price;
    private Integer duration;  // 视频时长（秒）
    private Integer playCount;
    private Integer status;    // 1-上架 0-下架
    private Date createdAt;
    private Date updatedAt;
    // 构造器
    public Video() {}
    public Video(Long id, String title, String description, String category, 
                String videoUrl, String coverImage, Double price, Integer duration) {
        this.id = id;
        this.title = title;
        this.description = description;
        this.category = category;
        this.videoUrl = videoUrl;
        this.coverImage = coverImage;
        this.price = price;
        this.duration = duration;
        this.playCount = 0;
        this.status = 1;
        this.createdAt = new Date();
        this.updatedAt = new Date();
    }
    // Getter和Setter方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public String getDescription() { return description; }
    public void setDescription(String description) { this.description = description; }
    public String getCategory() { return category; }
    public void setCategory(String category) { this.category = category; }
    public String getVideoUrl() { return videoUrl; }
    public void setVideoUrl(String videoUrl) { this.videoUrl = videoUrl; }
    public String getCoverImage() { return coverImage; }
    public void setCoverImage(String coverImage) { this.coverImage = coverImage; }
    public Double getPrice() { return price; }
    public void setPrice(Double price) { this.price = price; }
    public Integer getDuration() { return duration; }
    public void setDuration(Integer duration) { this.duration = duration; }
    public Integer getPlayCount() { return playCount; }
    public void setPlayCount(Integer playCount) { this.playCount = playCount; }
    public Integer getStatus() { return status; }
    public void setStatus(Integer status) { this.status = status; }
    public Date getCreatedAt() { return createdAt; }
    public void setCreatedAt(Date createdAt) { this.createdAt = createdAt; }
    public Date getUpdatedAt() { return updatedAt; }
    public void setUpdatedAt(Date updatedAt) { this.updatedAt = updatedAt; }
    @Override
    public String toString() {
        return "Video{id=" + id + ", title='" + title + "', category='" + category + 
               "', price=" + price + ", playCount=" + playCount + "}";
    }
}

// User.java
package com.vod.entity;
import java.util.Date;
import java.util.List;
public class User {
    private Long id;
    private String username;
    private String password;
    private String nickname;
    private String email;
    private String phone;
    private Date registerDate;
    private Integer vipLevel;    // 0-普通用户 1-VIP
    private List<Long> purchasedVideoIds;  // 已购买视频ID列表
    public User() {}
    public User(String username, String password, String nickname, String email, String phone) {
        this.username = username;
        this.password = password;
        this.nickname = nickname;
        this.email = email;
        this.phone = phone;
        this.registerDate = new Date();
        this.vipLevel = 0;
    }
    // Getter和Setter方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public String getNickname() { return nickname; }
    public void setNickname(String nickname) { this.nickname = nickname; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getPhone() { return phone; }
    public void setPhone(String phone) { this.phone = phone; }
    public Date getRegisterDate() { return registerDate; }
    public void setRegisterDate(Date registerDate) { this.registerDate = registerDate; }
    public Integer getVipLevel() { return vipLevel; }
    public void setVipLevel(Integer vipLevel) { this.vipLevel = vipLevel; }
    public List<Long> getPurchasedVideoIds() { return purchasedVideoIds; }
    public void setPurchasedVideoIds(List<Long> purchasedVideoIds) { this.purchasedVideoIds = purchasedVideoIds; }
}

// PlayRecord.java
package com.vod.entity;
import java.util.Date;
public class PlayRecord {
    private Long id;
    private Long userId;
    private Long videoId;
    private Integer progress;   // 播放进度（秒）
    private Date playTime;
    private Date lastPlayTime;
    private Integer playCount;
    public PlayRecord() {}
    public PlayRecord(Long userId, Long videoId) {
        this.userId = userId;
        this.videoId = videoId;
        this.progress = 0;
        this.playTime = new Date();
        this.lastPlayTime = new Date();
        this.playCount = 1;
    }
    // Getter和Setter方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public Long getUserId() { return userId; }
    public void setUserId(Long userId) { this.userId = userId; }
    public Long getVideoId() { return videoId; }
    public void setVideoId(Long videoId) { this.videoId = videoId; }
    public Integer getProgress() { return progress; }
    public void setProgress(Integer progress) { this.progress = progress; }
    public Date getPlayTime() { return playTime; }
    public void setPlayTime(Date playTime) { this.playTime = playTime; }
    public Date getLastPlayTime() { return lastPlayTime; }
    public void setLastPlayTime(Date lastPlayTime) { this.lastPlayTime = lastPlayTime; }
    public Integer getPlayCount() { return playCount; }
    public void setPlayCount(Integer playCount) { this.playCount = playCount; }
}

数据访问层 (DAO)

// VideoDAO.java
package com.vod.dao;
import com.vod.entity.Video;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
public class VideoDAO {
    private static List<Video> videos = new ArrayList<>();
    private static Long idCounter = 1L;
    // 静态初始化一些测试数据
    static {
        // 添加示例数据
        videos.add(new Video(idCounter++, "Java基础教程", "从零开始学习Java编程基础", 
                "编程", "/videos/java-tutorial.mp4", "/images/java.jpg", 99.9, 3600));
        videos.add(new Video(idCounter++, "MySQL数据库实战", "MySQL数据库设计与优化",
                "数据库", "/videos/mysql-course.mp4", "/images/mysql.jpg", 129.9, 5400));
        videos.add(new Video(idCounter++, "Spring Boot入门到精通", "Spring Boot快速开发企业级应用",
                "框架", "/videos/spring-boot.mp4", "/images/spring.jpg", 199.9, 7200));
    }
    // 添加视频
    public Video save(Video video) {
        if (video.getId() == null) {
            video.setId(idCounter++);
            videos.add(video);
        } else {
            // 更新已有视频
            deleteById(video.getId());
            videos.add(video);
        }
        return video;
    }
    // 根据ID查询视频
    public Optional<Video> findById(Long id) {
        return videos.stream()
                .filter(v -> v.getId().equals(id))
                .findFirst();
    }
    // 查询所有视频
    public List<Video> findAll() {
        return new ArrayList<>(videos);
    }
    // 根据分类查询
    public List<Video> findByCategory(String category) {
        return videos.stream()
                .filter(v -> v.getCategory().equals(category))
                .collect(Collectors.toList());
    }
    // 根据标题搜索
    public List<Video> searchByTitle(String keyword) {
        return videos.stream()
                .filter(v -> v.getTitle().contains(keyword))
                .collect(Collectors.toList());
    }
    // 删除视频
    public boolean deleteById(Long id) {
        return videos.removeIf(v -> v.getId().equals(id));
    }
    // 更新播放次数
    public void incrementPlayCount(Long id) {
        findById(id).ifPresent(v -> {
            v.setPlayCount(v.getPlayCount() + 1);
        });
    }
}

// UserDAO.java
package com.vod.dao;
import com.vod.entity.User;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
public class UserDAO {
    private static List<User> users = new ArrayList<>();
    private static Long idCounter = 1L;
    // 注册用户
    public User register(User user) {
        user.setId(idCounter++);
        users.add(user);
        return user;
    }
    // 根据用户名查找用户
    public Optional<User> findByUsername(String username) {
        return users.stream()
                .filter(u -> u.getUsername().equals(username))
                .findFirst();
    }
    // 用户登录验证
    public Optional<User> login(String username, String password) {
        return users.stream()
                .filter(u -> u.getUsername().equals(username) && u.getPassword().equals(password))
                .findFirst();
    }
    // 根据ID查找用户
    public Optional<User> findById(Long id) {
        return users.stream()
                .filter(u -> u.getId().equals(id))
                .findFirst();
    }
    // 更新用户信息
    public void update(User user) {
        users.removeIf(u -> u.getId().equals(user.getId()));
        users.add(user);
    }
    // 购买视频
    public boolean purchaseVideo(Long userId, Long videoId) {
        Optional<User> userOpt = findById(userId);
        if (userOpt.isPresent()) {
            User user = userOpt.get();
            if (user.getPurchasedVideoIds() == null) {
                user.setPurchasedVideoIds(new ArrayList<>());
            }
            if (!user.getPurchasedVideoIds().contains(videoId)) {
                user.getPurchasedVideoIds().add(videoId);
                update(user);
                return true;
            }
        }
        return false;
    }
    // 检查用户是否已购买视频
    public boolean hasPurchased(Long userId, Long videoId) {
        Optional<User> userOpt = findById(userId);
        return userOpt.map(user -> user.getPurchasedVideoIds() != null 
                && user.getPurchasedVideoIds().contains(videoId)).orElse(false);
    }
}

业务逻辑层 (Service)

// VideoService.java
package com.vod.service;
import com.vod.dao.VideoDAO;
import com.vod.entity.Video;
import java.util.List;
import java.util.Optional;
public class VideoService {
    private VideoDAO videoDAO;
    public VideoService() {
        this.videoDAO = new VideoDAO();
    }
    // 上传视频
    public Video uploadVideo(Video video) {
        if (video.getTitle() == null || video.getTitle().isEmpty()) {
            throw new IllegalArgumentException("视频标题不能为空");
        }
        if (video.getVideoUrl() == null || video.getVideoUrl().isEmpty()) {
            throw new IllegalArgumentException("视频URL不能为空");
        }
        return videoDAO.save(video);
    }
    // 获取所有上架视频
    public List<Video> getAvailableVideos() {
        return videoDAO.findAll().stream()
                .filter(v -> v.getStatus() == 1)
                .toList();
    }
    // 根据分类获取视频
    public List<Video> getVideosByCategory(String category) {
        return videoDAO.findByCategory(category);
    }
    // 搜索视频
    public List<Video> searchVideos(String keyword) {
        if (keyword == null || keyword.trim().isEmpty()) {
            return getAvailableVideos();
        }
        return videoDAO.searchByTitle(keyword.trim());
    }
    // 获取视频详情
    public Optional<Video> getVideoDetail(Long videoId) {
        return videoDAO.findById(videoId);
    }
    // 播放视频并增加播放次数
    public String playVideo(Long videoId) {
        Optional<Video> videoOpt = videoDAO.findById(videoId);
        if (videoOpt.isPresent()) {
            Video video = videoOpt.get();
            if (video.getStatus() == 0) {
                return "视频已下架";
            }
            videoDAO.incrementPlayCount(videoId);
            return video.getVideoUrl();
        }
        return "视频不存在";
    }
    // 更新视频信息
    public void updateVideo(Video video) {
        videoDAO.save(video);
    }
    // 上下架视频
    public void changeStatus(Long videoId, Integer status) {
        videoDAO.findById(videoId).ifPresent(v -> {
            v.setStatus(status);
            videoDAO.save(v);
        });
    }
}

// UserService.java
package com.vod.service;
import com.vod.dao.UserDAO;
import com.vod.entity.User;
import java.util.Optional;
public class UserService {
    private UserDAO userDAO;
    public UserService() {
        this.userDAO = new UserDAO();
    }
    // 用户注册
    public User register(String username, String password, String nickname, 
                        String email, String phone) {
        // 验证用户名是否已存在
        if (userDAO.findByUsername(username).isPresent()) {
            throw new RuntimeException("用户名已存在");
        }
        // 基本验证
        if (username == null || username.length() < 3) {
            throw new RuntimeException("用户名长度至少3位");
        }
        if (password == null || password.length() < 6) {
            throw new RuntimeException("密码长度至少6位");
        }
        User user = new User(username, password, nickname, email, phone);
        return userDAO.register(user);
    }
    // 用户登录
    public User login(String username, String password) {
        Optional<User> userOpt = userDAO.login(username, password);
        if (userOpt.isPresent()) {
            return userOpt.get();
        } else {
            throw new RuntimeException("用户名或密码错误");
        }
    }
    // 购买视频
    public boolean purchaseVideo(Long userId, Long videoId) {
        return userDAO.purchaseVideo(userId, videoId);
    }
    // 检查用户是否可以播放视频
    public boolean canPlay(Long userId, Long videoId, boolean isVipOnly) {
        if (!isVipOnly) {
            return true;  // 免费视频，直接播放
        }
        Optional<User> userOpt = userDAO.findById(userId);
        if (userOpt.isPresent()) {
            User user = userOpt.get();
            // VIP用户或已购买视频
            return user.getVipLevel() > 0 || userDAO.hasPurchased(userId, videoId);
        }
        return false;
    }
    // 获取用户信息
    public Optional<User> getUserInfo(Long userId) {
        return userDAO.findById(userId);
    }
    // 升级VIP
    public void upgradeVip(Long userId) {
        userDAO.findById(userId).ifPresent(user -> {
            user.setVipLevel(1);
            userDAO.update(user);
        });
    }
}

控制层 (Controller/API)

// vodController.java
package com.vod.controller;
import com.vod.entity.Video;
import com.vod.entity.User;
import com.vod.service.UserService;
import com.vod.service.VideoService;
import java.util.List;
import java.util.Optional;
import java.util.Scanner;
public class VodController {
    private Scanner scanner;
    private VideoService videoService;
    private UserService userService;
    private User currentUser;
    public VodController() {
        scanner = new Scanner(System.in);
        videoService = new VideoService();
        userService = new UserService();
    }
    // 主菜单
    public void showMainMenu() {
        while (true) {
            System.out.println("\n========== 点播系统 ==========");
            System.out.println("1. 视频浏览");
            System.out.println("2. 视频搜索");
            System.out.println("3. 视频分类");
            System.out.println("4. 播放视频");
            System.out.println("5. 用户登录");
            System.out.println("6. 用户注册");
            System.out.println("7. 购买视频");
            System.out.println("8. 我的历史记录");
            System.out.println("9. 退出系统");
            System.out.print("请选择操作：");
            int choice = scanner.nextInt();
            scanner.nextLine();  // 清除缓冲区
            switch (choice) {
                case 1:
                    showAllVideos();
                    break;
                case 2:
                    searchVideos();
                    break;
                case 3:
                    showVideosByCategory();
                    break;
                case 4:
                    playVideo();
                    break;
                case 5:
                    login();
                    break;
                case 6:
                    register();
                    break;
                case 7:
                    purchaseVideo();
                    break;
                case 8:
                    showPlayHistory();
                    break;
                case 9:
                    System.out.println("感谢使用点播系统，再见！");
                    return;
                default:
                    System.out.println("无效的选择，请重新选择！");
            }
        }
    }
    // 显示所有视频
    private void showAllVideos() {
        System.out.println("\n===== 所有视频 =====");
        List<Video> videos = videoService.getAvailableVideos();
        displayVideoList(videos);
    }
    // 搜索视频
    private void searchVideos() {
        System.out.print("请输入搜索关键词：");
        String keyword = scanner.nextLine();
        List<Video> videos = videoService.searchVideos(keyword);
        if (videos.isEmpty()) {
            System.out.println("没有找到相关视频");
        } else {
            System.out.println("\n===== 搜索结果 =====");
            displayVideoList(videos);
        }
    }
    // 按分类显示视频
    private void showVideosByCategory() {
        System.out.println("选择分类：");
        System.out.println("1. 编程");
        System.out.println("2. 数据库");
        System.out.println("3. 框架");
        System.out.print("请输入分类编号：");
        int choice = scanner.nextInt();
        scanner.nextLine();
        String category = switch (choice) {
            case 1 -> "编程";
            case 2 -> "数据库";
            case 3 -> "框架";
            default -> "编程";
        };
        List<Video> videos = videoService.getVideosByCategory(category);
        System.out.println("\n===== " + category + " 分类视频 =====");
        displayVideoList(videos);
    }
    // 播放视频
    private void playVideo() {
        if (currentUser == null) {
            System.out.println("请先登录后再播放视频！");
            return;
        }
        System.out.print("请输入视频ID：");
        Long videoId = scanner.nextLong();
        scanner.nextLine();
        // 查找视频
        Optional<Video> videoOpt = videoService.getVideoDetail(videoId);
        if (videoOpt.isEmpty()) {
            System.out.println("视频不存在");
            return;
        }
        Video video = videoOpt.get();
        // 检查播放权限
        boolean canPlay;
        if (video.getPrice() > 0) {
            // 付费视频需要验证购买状态或VIP身份
            canPlay = userService.canPlay(currentUser.getId(), videoId, true);
        } else {
            // 免费视频直接播放
            canPlay = true;
        }
        if (canPlay) {
            String result = videoService.playVideo(videoId);
            if (result.equals("视频不存在") || result.equals("视频已下架")) {
                System.out.println(result);
            } else {
                System.out.println("正在播放视频：" + video.getTitle());
                System.out.println("视频地址：" + result);
                System.out.println("播放成功！");
            }
        } else {
            System.out.println("该视频为付费视频，请购买或升级VIP后观看");
        }
    }
    // 用户登录
    private void login() {
        System.out.print("请输入用户名：");
        String username = scanner.nextLine();
        System.out.print("请输入密码：");
        String password = scanner.nextLine();
        try {
            currentUser = userService.login(username, password);
            System.out.println("登录成功！欢迎 " + currentUser.getNickname());
        } catch (RuntimeException e) {
            System.out.println("登录失败：" + e.getMessage());
        }
    }
    // 用户注册
    private void register() {
        System.out.print("请输入用户名：");
        String username = scanner.nextLine();
        System.out.print("请输入密码：");
        String password = scanner.nextLine();
        System.out.print("请输入昵称：");
        String nickname = scanner.nextLine();
        System.out.print("请输入邮箱：");
        String email = scanner.nextLine();
        System.out.print("请输入手机号：");
        String phone = scanner.nextLine();
        try {
            currentUser = userService.register(username, password, nickname, email, phone);
            System.out.println("注册成功！请重新登录");
            currentUser = null;
        } catch (RuntimeException e) {
            System.out.println("注册失败：" + e.getMessage());
        }
    }
    // 购买视频
    private void purchaseVideo() {
        if (currentUser == null) {
            System.out.println("请先登录后再购买视频！");
            return;
        }
        System.out.print("请输入要购买的视频ID：");
        Long videoId = scanner.nextLong();
        scanner.nextLine();
        if (userService.purchaseVideo(currentUser.getId(), videoId)) {
            System.out.println("购买成功！可以开始观看视频了。");
        } else {
            System.out.println("购买失败，可能您已经购买过该视频");
        }
    }
    // 显示播放历史
    private void showPlayHistory() {
        if (currentUser == null) {
            System.out.println("请先登录！");
            return;
        }
        System.out.println("正在查询播放历史...");
        // 此处简化处理，实际应根据用户ID查询播放记录
        System.out.println("暂无播放历史记录");
    }
    // 显示视频列表
    private void displayVideoList(List<Video> videos) {
        if (videos.isEmpty()) {
            System.out.println("暂无视频");
            return;
        }
        System.out.println("+------+--------------------+----------+----------+--------+");
        System.out.println("| ID   | 标题               | 分类     | 播放次数 | 价格   |");
        System.out.println("+------+--------------------+----------+----------+--------+");
        for (Video video : videos) {
            System.out.printf("| %-4d | %-18s | %-8s | %-8d | %.1f  |%n",
                video.getId(),
                video.getTitle(),
                video.getCategory(),
                video.getPlayCount(),
                video.getPrice()
            );
        }
        System.out.println("+------+--------------------+----------+----------+--------+");
    }
    // 主方法
    public static void main(String[] args) {
        VodController controller = new VodController();
        controller.showMainMenu();
    }
}

附加功能类

// PlayRecordDAO.java
package com.vod.dao;
import com.vod.entity.PlayRecord;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
public class PlayRecordDAO {
    private static List<PlayRecord> records = new ArrayList<>();
    private static Long idCounter = 1L;
    // 保存播放记录
    public PlayRecord save(PlayRecord record) {
        record.setId(idCounter++);
        records.add(record);
        return record;
    }
    // 根据用户ID查询播放记录
    public List<PlayRecord> findByUserId(Long userId) {
        return records.stream()
                .filter(r -> r.getUserId().equals(userId))
                .collect(Collectors.toList());
    }
    // 更新播放记录
    public void update(PlayRecord record) {
        records.removeIf(r -> r.getId().equals(record.getId()));
        records.add(record);
    }
    // 查找用户的特定视频播放记录
    public Optional<PlayRecord> findRecord(Long userId, Long videoId) {
        return records.stream()
                .filter(r -> r.getUserId().equals(userId) && r.getVideoId().equals(videoId))
                .findFirst();
    }
}

// 播放历史历史记录Service
package com.vod.service;
import com.vod.dao.PlayRecordDAO;
import com.vod.entity.PlayRecord;
import java.util.List;
import java.util.Optional;
public class PlayRecordService {
    private PlayRecordDAO recordDAO;
    public PlayRecordService() {
        this.recordDAO = new PlayRecordDAO();
    }
    // 记录播放历史
    public void recordPlay(Long userId, Long videoId, int progress) {
        Optional<PlayRecord> existing = recordDAO.findRecord(userId, videoId);
        if (existing.isPresent()) {
            // 更新已有记录
            PlayRecord record = existing.get();
            record.setProgress(progress);
            record.setPlayCount(record.getPlayCount() + 1);
            recordDAO.update(record);
        } else {
            // 创建新记录
            PlayRecord record = new PlayRecord(userId, videoId);
            record.setProgress(progress);
            recordDAO.save(record);
        }
    }
    // 获取用户的播放历史
    public List<PlayRecord> getUserHistory(Long userId) {
        return recordDAO.findByUserId(userId);
    }
    // 获取播放进度
    public int getProgress(Long userId, Long videoId) {
        Optional<PlayRecord> record = recordDAO.findRecord(userId, videoId);
        return record.map(PlayRecord::getProgress).orElse(0);
    }
}

运行测试

创建测试主类：

// Main.java
package com.vod;
import com.vod.controller.VodController;
public class Main {
    public static void main(String[] args) {
        System.out.println("欢迎使用Java点播系统！");
        VodController controller = new VodController();
        controller.showMainMenu();
    }
}

系统演示示例

运行系统后的交互示例：

========== 点播系统 ==========
1. 视频浏览
2. 视频搜索
3. 视频分类
4. 播放视频
5. 用户登录
6. 用户注册
7. 购买视频
8. 我的历史记录
9. 退出系统
请选择操作：1
===== 所有视频 =====
+------+--------------------+----------+----------+--------+
| ID   | 标题               | 分类     | 播放次数 | 价格   |
+------+--------------------+----------+----------+--------+
| 1    | Java基础教程       | 编程     | 0        | 99.9   |
| 2    | MySQL数据库实战   | 数据库   | 0        | 129.9  |
| 3    | Spring Boot入门    | 框架     | 0        | 199.9  |
+------+--------------------+----------+----------+--------+

系统特性

核心功能

1. 用户管理：注册、登录、VIP升级
2. 视频管理：上传、分类、搜索、上下架
3. 播放权限：免费视频直接播放，付费视频需购买或VIP
4. 播放记录：记录播放进度和历史

扩展建议

• 添加数据库支持（MySQL）
• 实现视频评论功能
• 添加推荐算法
• 支持弹幕功能
• 接入第三方支付
• 添加CDN加速

这个案例提供了一个完整的点播系统基础架构,可以根据实际需求进行扩展和优化。