Java最小可行产品案例

本文目录导读：

1. 项目结构
2. Maven依赖 (pom.xml)
3. 任务模型 (Task.java)
4. 任务服务 (TaskService.java)
5. 主程序入口 (Main.java)
6. 快速运行
7. MVP核心功能

我来为您介绍一个Java最小可行产品（MVP）案例，实现一个简单的任务管理应用。

项目结构

task-manager/
├── src/
│   └── main/java/com/example/
│       ├── model/Task.java
│       ├── service/TaskService.java
│       └── Main.java
└── pom.xml

Maven依赖 (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>task-manager</artifactId>
    <version>1.0</version>
    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <!-- Jackson for JSON processing -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.0</version>
        </dependency>
    </dependencies>
</project>

任务模型 (Task.java)

package com.example.model;
import java.time.LocalDateTime;
import java.util.Objects;
import java.util.UUID;
public class Task {
    private String id;
    private String title;
    private String description;
    private boolean completed;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    public Task() {
        this.id = UUID.randomUUID().toString();
        this.createdAt = LocalDateTime.now();
        this.updatedAt = LocalDateTime.now();
        this.completed = false;
    }
    public Task(String title, String description) {
        this();
        this.title = title;
        this.description = description;
    }
    // Getters and Setters
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    public String getTitle() { return title; }
    public void setTitle(String title) { 
        this.title = title; 
        this.updatedAt = LocalDateTime.now();
    }
    public String getDescription() { return description; }
    public void setDescription(String description) { 
        this.description = description;
        this.updatedAt = LocalDateTime.now();
    }
    public boolean isCompleted() { return completed; }
    public void setCompleted(boolean completed) { 
        this.completed = completed;
        this.updatedAt = LocalDateTime.now();
    }
    public LocalDateTime getCreatedAt() { return createdAt; }
    public LocalDateTime getUpdatedAt() { return updatedAt; }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Task task = (Task) o;
        return Objects.equals(id, task.id);
    }
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
    @Override
    public String toString() {
        return String.format("Task{id='%s', title='%s', completed=%s, createdAt=%s}",
                id, title, completed, createdAt);
    }
}

任务服务 (TaskService.java)

package com.example.service;
import com.example.model.Task;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class TaskService {
    private final Map<String, Task> tasks;
    private final ObjectMapper objectMapper;
    private static final String DATA_FILE = "tasks.json";
    public TaskService() {
        this.tasks = new ConcurrentHashMap<>();
        this.objectMapper = new ObjectMapper();
        this.objectMapper.registerModule(new JavaTimeModule());
        loadTasks();
    }
    // 创建任务
    public Task createTask(String title, String description) {
        Task task = new Task(title, description);
        tasks.put(task.getId(), task);
        saveTasks();
        return task;
    }
    // 获取所有任务
    public List<Task> getAllTasks() {
        return new ArrayList<>(tasks.values());
    }
    // 获取单个任务
    public Optional<Task> getTask(String id) {
        return Optional.ofNullable(tasks.get(id));
    }
    // 更新任务
    public Optional<Task> updateTask(String id, String title, String description, Boolean completed) {
        Task task = tasks.get(id);
        if (task != null) {
            if (title != null) task.setTitle(title);
            if (description != null) task.setDescription(description);
            if (completed != null) task.setCompleted(completed);
            saveTasks();
            return Optional.of(task);
        }
        return Optional.empty();
    }
    // 删除任务
    public boolean deleteTask(String id) {
        Task removed = tasks.remove(id);
        if (removed != null) {
            saveTasks();
            return true;
        }
        return false;
    }
    // 搜索任务
    public List<Task> searchTasks(String keyword) {
        List<Task> result = new ArrayList<>();
        String lowerKeyword = keyword.toLowerCase();
        for (Task task : tasks.values()) {
            if (task.getTitle().toLowerCase().contains(lowerKeyword) ||
                task.getDescription().toLowerCase().contains(lowerKeyword)) {
                result.add(task);
            }
        }
        return result;
    }
    // 获取统计信息
    public Map<String, Object> getStatistics() {
        Map<String, Object> stats = new HashMap<>();
        List<Task> allTasks = getAllTasks();
        stats.put("total", allTasks.size());
        stats.put("completed", allTasks.stream().filter(Task::isCompleted).count());
        stats.put("pending", allTasks.stream().filter(t -> !t.isCompleted()).count());
        return stats;
    }
    // 持久化到文件
    private void saveTasks() {
        try {
            objectMapper.writerWithDefaultPrettyPrinter()
                       .writeValue(new File(DATA_FILE), getAllTasks());
        } catch (IOException e) {
            System.err.println("保存任务失败: " + e.getMessage());
        }
    }
    // 从文件加载
    private void loadTasks() {
        File file = new File(DATA_FILE);
        if (file.exists()) {
            try {
                List<Task> loadedTasks = objectMapper.readValue(
                    file, 
                    new TypeReference<List<Task>>() {}
                );
                loadedTasks.forEach(task -> tasks.put(task.getId(), task));
            } catch (IOException e) {
                System.err.println("加载任务失败: " + e.getMessage());
            }
        }
    }
}

主程序入口 (Main.java)

package com.example;
import com.example.model.Task;
import com.example.service.TaskService;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
public class Main {
    private static final Scanner scanner = new Scanner(System.in);
    private static final TaskService taskService = new TaskService();
    public static void main(String[] args) {
        System.out.println("=== 任务管理器 MVP ===");
        System.out.println("最小可行产品 - 基于控制台的简单任务管理");
        while (true) {
            showMenu();
            String choice = scanner.nextLine().trim();
            if ("0".equals(choice)) {
                System.out.println("谢谢使用，再见！");
                break;
            }
            handleChoice(choice);
        }
        scanner.close();
    }
    private static void showMenu() {
        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("0. 退出");
        System.out.print("请输入选择: ");
    }
    private static void handleChoice(String choice) {
        switch (choice) {
            case "1":
                createTask();
                break;
            case "2":
                listAllTasks();
                break;
            case "3":
                viewTaskDetails();
                break;
            case "4":
                updateTask();
                break;
            case "5":
                deleteTask();
                break;
            case "6":
                searchTasks();
                break;
            case "7":
                showStatistics();
                break;
            default:
                System.out.println("无效选择，请重新输入");
        }
    }
    private static void createTask() {
        System.out.print("请输入任务标题: ");
        String title = scanner.nextLine().trim();
        System.out.print("请输入任务描述: ");
        String description = scanner.nextLine().trim();
        if (title.isEmpty()) {
            System.out.println("标题不能为空！");
            return;
        }
        Task task = taskService.createTask(title, description);
        System.out.println("任务创建成功！ID: " + task.getId());
    }
    private static void listAllTasks() {
        List<Task> tasks = taskService.getAllTasks();
        if (tasks.isEmpty()) {
            System.out.println("暂无任务");
            return;
        }
        System.out.println("\n=== 任务列表 ===");
        for (int i = 0; i < tasks.size(); i++) {
            Task task = tasks.get(i);
            String status = task.isCompleted() ? "[已完成]" : "[待完成]";
            System.out.printf("%d. %s %s%n", i + 1, status, task.getTitle());
        }
    }
    private static void viewTaskDetails() {
        System.out.print("请输入任务ID: ");
        String id = scanner.nextLine().trim();
        taskService.getTask(id).ifPresentOrElse(
            task -> {
                System.out.println("\n=== 任务详情 ===");
                System.out.println("ID: " + task.getId());
                System.out.println("标题: " + task.getTitle());
                System.out.println("描述: " + task.getDescription());
                System.out.println("状态: " + (task.isCompleted() ? "已完成" : "待完成"));
                System.out.println("创建时间: " + task.getCreatedAt());
                System.out.println("更新时间: " + task.getUpdatedAt());
            },
            () -> System.out.println("任务不存在")
        );
    }
    private static void updateTask() {
        System.out.print("请输入要更新的任务ID: ");
        String id = scanner.nextLine().trim();
        System.out.print("新标题 (直接回车保持不变): ");
        String title = scanner.nextLine().trim();
        title = title.isEmpty() ? null : title;
        System.out.print("新描述 (直接回车保持不变): ");
        String description = scanner.nextLine().trim();
        description = description.isEmpty() ? null : description;
        System.out.print("是否完成? (y/n/直接回车保持不变): ");
        String completeInput = scanner.nextLine().trim().toLowerCase();
        Boolean completed = null;
        if ("y".equals(completeInput)) completed = true;
        else if ("n".equals(completeInput)) completed = false;
        taskService.updateTask(id, title, description, completed)
            .ifPresentOrElse(
                task -> System.out.println("更新成功！"),
                () -> System.out.println("更新失败，任务不存在")
            );
    }
    private static void deleteTask() {
        System.out.print("请输入要删除的任务ID: ");
        String id = scanner.nextLine().trim();
        System.out.print("确认删除? (y/n): ");
        String confirm = scanner.nextLine().trim().toLowerCase();
        if ("y".equals(confirm)) {
            if (taskService.deleteTask(id)) {
                System.out.println("删除成功！");
            } else {
                System.out.println("删除失败，任务不存在");
            }
        } else {
            System.out.println("已取消删除");
        }
    }
    private static void searchTasks() {
        System.out.print("请输入搜索关键词: ");
        String keyword = scanner.nextLine().trim();
        List<Task> results = taskService.searchTasks(keyword);
        if (results.isEmpty()) {
            System.out.println("未找到匹配的任务");
            return;
        }
        System.out.println("\n=== 搜索结果 ===");
        for (Task task : results) {
            String status = task.isCompleted() ? "[已完成]" : "[待完成]";
            System.out.printf("- %s %s (ID: %s)%n", status, task.getTitle(), task.getId());
        }
    }
    private static void showStatistics() {
        Map<String, Object> stats = taskService.getStatistics();
        System.out.println("\n=== 统计信息 ===");
        System.out.println("总任务数: " + stats.get("total"));
        System.out.println("已完成: " + stats.get("completed"));
        System.out.println("待完成: " + stats.get("pending"));
        long total = (long) stats.get("total");
        if (total > 0) {
            long completed = (long) stats.get("completed");
            double completionRate = (double) completed / total * 100;
            System.out.printf("完成率: %.1f%%%n", completionRate);
        }
    }
}

快速运行

# 编译
mvn clean compile
# 运行
mvn exec:java -Dexec.mainClass="com.example.Main"

MVP核心功能

✅ CRUD操作：创建、读取、更新、删除任务
✅ 数据持久化：保存到JSON文件
✅ 搜索功能：按关键字搜索
✅ 统计信息：查看任务完成情况
✅ 友好的命令行界面：交互式操作
✅ 错误处理：基本的异常处理

这个MVP包含了任务管理应用的核心功能,可以直接运行使用，您可以根据需要扩展更多功能，如数据库支持、REST API、图形界面等。