下面给出一个基于 Gradle 的 Java 17 控制台小项目（包名：app.taskmgr），围绕“任务管理器”场景，完整展示面向对象设计（不可变实体+构建器、策略模式、泛型+Comparator、分层架构）、线程安全的内存仓储、Javadoc、日志、受检异常、以及 JUnit 5 单元测试。示例 Main 会创建项目与任务，演示三种排序与状态变更。
一、项目结构树
- build.gradle
- settings.gradle
- src
- main
- java
- app
- taskmgr
- AppMain.java
- exception
- InvalidTaskOperationException.java
- model
- Priority.java
- Status.java
- Project.java
- User.java
- Task.java
- TaskBuilder.java
- repository
- Repository.java
- InMemoryTaskRepository.java
- InMemoryProjectRepository.java
- InMemoryUserRepository.java
- service
- TaskService.java
- sort
- Sorter.java
- TaskSortStrategy.java
- ByPriorityStrategy.java
- ByDueDateStrategy.java
- ByTitleStrategy.java
- test
- java
- app
- taskmgr
- TaskBuilderTest.java
- TaskServiceTest.java
- SortingStrategyTest.java
- RepositoryConcurrencyTest.java
二、Gradle 配置
build.gradle
plugins {
id 'java'
id 'application'
}
group = 'app.taskmgr'
version = '1.0.0'
java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}
repositories {
mavenCentral()
}
dependencies {
testImplementation 'org.junit.jupiter:junit-jupiter:5.10.2'
}
test {
useJUnitPlatform()
}
application {
mainClass = 'app.taskmgr.AppMain'
}
settings.gradle
rootProject.name = 'taskmgr'
三、源代码
src/main/java/app/taskmgr/model/Priority.java
package app.taskmgr.model;
/**
* Task priority. Natural order: HIGH < MEDIUM < LOW (so ascending = high-first).
*/
public enum Priority {
HIGH, MEDIUM, LOW
}
src/main/java/app/taskmgr/model/Status.java
package app.taskmgr.model;
/** Task status. */
public enum Status {
OPEN, CLOSED
}
src/main/java/app/taskmgr/model/Project.java
package app.taskmgr.model;
import java.util.Objects;
/**
* Project entity (immutable).
*/
public final class Project {
private final long id;
private final String name;
public Project(long id, String name) {
this.id = id;
this.name = Objects.requireNonNull(name, "name");
}
public long getId() { return id; }
public String getName() { return name; }
@Override public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Project)) return false;
Project that = (Project) o;
return id == that.id;
}
@Override public int hashCode() { return Long.hashCode(id); }
@Override public String toString() {
return "Project{id=" + id + ", name='" + name + "'}";
}
}
src/main/java/app/taskmgr/model/User.java
package app.taskmgr.model;
import java.util.Objects;
/**
* User entity (immutable).
*/
public final class User {
private final long id;
private final String name;
public User(long id, String name) {
this.id = id;
this.name = Objects.requireNonNull(name, "name");
}
public long getId() { return id; }
public String getName() { return name; }
@Override public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof User)) return false;
User that = (User) o;
return id == that.id;
}
@Override public int hashCode() { return Long.hashCode(id); }
@Override public String toString() {
return "User{id=" + id + ", name='" + name + "'}";
}
}
src/main/java/app/taskmgr/model/Task.java
package app.taskmgr.model;
import java.time.LocalDate;
import java.util.Objects;
/**
* Task entity: immutable; modifications produce a new instance via builder.
* Key immutable field: id.
*/
public final class Task {
private final long id; // 0 means unsaved/new
private final String title;
private final String description;
private final Priority priority;
private final LocalDate dueDate;
private final Status status;
Task(long id, String title, String description, Priority priority, LocalDate dueDate, Status status) {
this.id = id;
this.title = Objects.requireNonNull(title, "title");
this.description = description;
this.priority = Objects.requireNonNull(priority, "priority");
this.dueDate = dueDate;
this.status = Objects.requireNonNull(status, "status");
}
public long getId() { return id; }
public String getTitle() { return title; }
public String getDescription() { return description; }
public Priority getPriority() { return priority; }
public LocalDate getDueDate() { return dueDate; }
public Status getStatus() { return status; }
/** Create a builder pre-filled from this task. */
public TaskBuilder toBuilder() {
return new TaskBuilder()
.id(this.id)
.title(this.title)
.description(this.description)
.priority(this.priority)
.dueDate(this.dueDate)
.status(this.status);
}
@Override public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Task)) return false;
Task that = (Task) o;
return id > 0 && id == that.id; // Persisted identity
}
@Override public int hashCode() {
return id > 0 ? Long.hashCode(id) : Objects.hash(title, priority, dueDate, status);
}
@Override public String toString() {
return "Task{id=" + id +
", title='" + title + '\'' +
", priority=" + priority +
", dueDate=" + dueDate +
", status=" + status +
'}';
}
}
src/main/java/app/taskmgr/model/TaskBuilder.java
package app.taskmgr.model;
import java.time.LocalDate;
/**
* Builder for Task. Provides sensible defaults and validation in build().
*/
public final class TaskBuilder {
private long id = 0L;
private String title;
private String description = "";
private Priority priority = Priority.MEDIUM;
private LocalDate dueDate;
private Status status = Status.OPEN;
public TaskBuilder id(long id) { this.id = id; return this; }
public TaskBuilder title(String title) { this.title = title; return this; }
public TaskBuilder description(String description) { this.description = description; return this; }
public TaskBuilder priority(Priority priority) { this.priority = priority; return this; }
public TaskBuilder dueDate(LocalDate dueDate) { this.dueDate = dueDate; return this; }
public TaskBuilder status(Status status) { this.status = status; return this; }
/**
* Build immutable Task. Validates required fields.
*/
public Task build() {
if (title == null || title.isBlank()) throw new IllegalArgumentException("title is required");
if (priority == null) throw new IllegalArgumentException("priority is required");
if (status == null) status = Status.OPEN;
if (description == null) description = "";
return new Task(id, title, description, priority, dueDate, status);
}
}
src/main/java/app/taskmgr/repository/Repository.java
package app.taskmgr.repository;
import java.util.List;
import java.util.Optional;
/**
* Generic repository interface for simple CRUD-like operations.
*/
public interface Repository<T, ID> {
Optional<T> findById(ID id);
List<T> findAll();
T save(T entity); // insert or update
boolean deleteById(ID id);
long count();
}
src/main/java/app/taskmgr/repository/InMemoryTaskRepository.java
package app.taskmgr.repository;
import app.taskmgr.model.Task;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLong;
/**
* Thread-safe in-memory Task repository using ConcurrentHashMap.
* Assigns IDs for new tasks (id <= 0).
*/
public class InMemoryTaskRepository implements Repository<Task, Long> {
private final ConcurrentMap<Long, Task> store = new ConcurrentHashMap<>();
private final AtomicLong seq = new AtomicLong(0L);
@Override
public Optional<Task> findById(Long id) {
if (id == null) return Optional.empty();
return Optional.ofNullable(store.get(id));
}
@Override
public List<Task> findAll() {
return new ArrayList<>(store.values());
}
@Override
public Task save(Task entity) {
Task toSave = entity;
if (entity.getId() <= 0) {
long newId = seq.incrementAndGet();
toSave = entity.toBuilder().id(newId).build();
}
store.put(toSave.getId(), toSave);
return toSave;
}
@Override
public boolean deleteById(Long id) {
return store.remove(id) != null;
}
@Override
public long count() {
return store.size();
}
}
src/main/java/app/taskmgr/repository/InMemoryProjectRepository.java
package app.taskmgr.repository;
import app.taskmgr.model.Project;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
/** Simple thread-safe in-memory repository for Project. */
public class InMemoryProjectRepository implements Repository<Project, Long> {
private final ConcurrentHashMap<Long, Project> store = new ConcurrentHashMap<>();
private final AtomicLong seq = new AtomicLong(0L);
@Override
public Optional<Project> findById(Long id) {
return Optional.ofNullable(store.get(id));
}
@Override
public List<Project> findAll() {
return new ArrayList<>(store.values());
}
@Override
public Project save(Project entity) {
Project proj = entity;
if (entity.getId() <= 0) {
long id = seq.incrementAndGet();
proj = new Project(id, entity.getName());
}
store.put(proj.getId(), proj);
return proj;
}
@Override
public boolean deleteById(Long id) {
return store.remove(id) != null;
}
@Override
public long count() {
return store.size();
}
}
src/main/java/app/taskmgr/repository/InMemoryUserRepository.java
package app.taskmgr.repository;
import app.taskmgr.model.User;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
/** Simple thread-safe in-memory repository for User. */
public class InMemoryUserRepository implements Repository<User, Long> {
private final ConcurrentHashMap<Long, User> store = new ConcurrentHashMap<>();
private final AtomicLong seq = new AtomicLong(0L);
@Override
public Optional<User> findById(Long id) {
return Optional.ofNullable(store.get(id));
}
@Override
public List<User> findAll() {
return new ArrayList<>(store.values());
}
@Override
public User save(User entity) {
User u = entity;
if (entity.getId() <= 0) {
long id = seq.incrementAndGet();
u = new User(id, entity.getName());
}
store.put(u.getId(), u);
return u;
}
@Override
public boolean deleteById(Long id) {
return store.remove(id) != null;
}
@Override
public long count() {
return store.size();
}
}
src/main/java/app/taskmgr/exception/InvalidTaskOperationException.java
package app.taskmgr.exception;
/**
* Checked exception for invalid task operations (precondition violations, illegal state transitions).
*/
public class InvalidTaskOperationException extends Exception {
public InvalidTaskOperationException(String message) {
super(message);
}
}
src/main/java/app/taskmgr/service/sort/TaskSortStrategy.java
package app.taskmgr.service.sort;
import app.taskmgr.model.Task;
import java.util.Comparator;
/**
* Strategy for sorting tasks.
*/
public interface TaskSortStrategy {
Comparator<Task> comparator();
default String name() {
return this.getClass().getSimpleName();
}
}
src/main/java/app/taskmgr/service/sort/ByPriorityStrategy.java
package app.taskmgr.service.sort;
import app.taskmgr.model.Task;
import java.util.Comparator;
/**
* Sort tasks by priority (HIGH first), then dueDate asc, then title asc.
*/
public class ByPriorityStrategy implements TaskSortStrategy {
private static final Comparator<Task> CMP =
Comparator.comparing(Task::getPriority) // enum: HIGH < MEDIUM < LOW
.thenComparing(Task::getDueDate, Comparator.nullsLast(Comparator.naturalOrder()))
.thenComparing(Task::getTitle, String.CASE_INSENSITIVE_ORDER);
@Override
public Comparator<Task> comparator() { return CMP; }
}
src/main/java/app/taskmgr/service/sort/ByDueDateStrategy.java
package app.taskmgr.service.sort;
import app.taskmgr.model.Task;
import java.util.Comparator;
/**
* Sort by due date asc (nulls last), then priority, then title.
*/
public class ByDueDateStrategy implements TaskSortStrategy {
private static final Comparator<Task> CMP =
Comparator.comparing(Task::getDueDate, Comparator.nullsLast(Comparator.naturalOrder()))
.thenComparing(Task::getPriority)
.thenComparing(Task::getTitle, String.CASE_INSENSITIVE_ORDER);
@Override
public Comparator<Task> comparator() { return CMP; }
}
src/main/java/app/taskmgr/service/sort/ByTitleStrategy.java
package app.taskmgr.service.sort;
import app.taskmgr.model.Task;
import java.util.Comparator;
/**
* Sort by title (case-insensitive), then due date.
*/
public class ByTitleStrategy implements TaskSortStrategy {
private static final Comparator<Task> CMP =
Comparator.comparing(Task::getTitle, String.CASE_INSENSITIVE_ORDER)
.thenComparing(Task::getDueDate, Comparator.nullsLast(Comparator.naturalOrder()));
@Override
public Comparator<Task> comparator() { return CMP; }
}
src/main/java/app/taskmgr/service/sort/Sorter.java
package app.taskmgr.service.sort;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
/**
* Generic reusable sorter using Comparator and generics.
*/
public final class Sorter<T> {
public List<T> sort(List<T> list, Comparator<? super T> comparator) {
var copy = new ArrayList<>(list);
copy.sort(comparator);
return copy;
// original list remains unchanged (functional style)
}
}
src/main/java/app/taskmgr/service/TaskService.java
package app.taskmgr.service;
import app.taskmgr.exception.InvalidTaskOperationException;
import app.taskmgr.model.*;
import app.taskmgr.repository.Repository;
import app.taskmgr.service.sort.Sorter;
import app.taskmgr.service.sort.TaskSortStrategy;
import java.time.LocalDate;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Application service for Tasks: creation, update, close, sorting, assign to project.
* Uses repositories and enforces preconditions and state transitions.
*/
public class TaskService {
private static final Logger log = Logger.getLogger(TaskService.class.getName());
private final Repository<Task, Long> taskRepo;
private final Repository<Project, Long> projectRepo;
private final Repository<User, Long> userRepo;
// Project to task IDs mapping (thread-safe)
private final ConcurrentHashMap<Long, Set<Long>> projectTasks = new ConcurrentHashMap<>();
private final Sorter<Task> sorter = new Sorter<>();
public TaskService(Repository<Task, Long> taskRepo,
Repository<Project, Long> projectRepo,
Repository<User, Long> userRepo) {
this.taskRepo = taskRepo;
this.projectRepo = projectRepo;
this.userRepo = userRepo;
}
/** Create a project. */
public Project createProject(String name) throws InvalidTaskOperationException {
if (name == null || name.isBlank()) throw new InvalidTaskOperationException("Project name required");
Project p = new Project(0L, name);
p = projectRepo.save(p);
projectTasks.putIfAbsent(p.getId(), ConcurrentHashMap.newKeySet());
log.info(() -> "Created project: " + p);
return p;
}
/** Create a user. */
public User createUser(String name) throws InvalidTaskOperationException {
if (name == null || name.isBlank()) throw new InvalidTaskOperationException("User name required");
User u = new User(0L, name);
u = userRepo.save(u);
log.info(() -> "Created user: " + u);
return u;
}
/**
* Create a task and assign to a project.
* Preconditions: title not blank; status must be OPEN at creation; due date not in the past (if provided).
*/
public Task createTask(TaskBuilder builder, long projectId, long userId) throws InvalidTaskOperationException {
Objects.requireNonNull(builder, "builder");
Project p = projectRepo.findById(projectId)
.orElseThrow(() -> new InvalidTaskOperationException("Project not found: " + projectId));
userRepo.findById(userId)
.orElseThrow(() -> new InvalidTaskOperationException("User not found: " + userId));
Task task = builder.build();
if (task.getStatus() == Status.CLOSED) {
throw new InvalidTaskOperationException("Cannot create task in CLOSED state");
}
if (task.getDueDate() != null && task.getDueDate().isBefore(LocalDate.now())) {
throw new InvalidTaskOperationException("Due date cannot be in the past");
}
Task saved = taskRepo.save(task);
projectTasks.computeIfAbsent(p.getId(), k -> ConcurrentHashMap.newKeySet())
.add(saved.getId());
log.info(() -> "Created task " + saved + " in project " + p.getName());
return saved;
}
/**
* Update editable fields of a task (title, description, priority, due date).
* Closed tasks cannot be updated.
*/
public Task updateTask(long taskId, String newTitle, String newDescription,
Priority newPriority, LocalDate newDueDate) throws InvalidTaskOperationException {
Task existing = taskRepo.findById(taskId)
.orElseThrow(() -> new InvalidTaskOperationException("Task not found: " + taskId));
if (existing.getStatus() == Status.CLOSED) {
throw new InvalidTaskOperationException("Cannot update a CLOSED task");
}
if (newTitle == null || newTitle.isBlank()) {
throw new InvalidTaskOperationException("Title cannot be blank");
}
if (newDueDate != null && newDueDate.isBefore(LocalDate.now())) {
throw new InvalidTaskOperationException("Due date cannot be in the past");
}
if (newPriority == null) {
throw new InvalidTaskOperationException("Priority required");
}
Task updated = existing.toBuilder()
.title(newTitle)
.description(newDescription == null ? "" : newDescription)
.priority(newPriority)
.dueDate(newDueDate)
.build();
updated = taskRepo.save(updated);
log.info(() -> "Updated task " + updated);
return updated;
}
/** Close a task (state transition OPEN -> CLOSED only). */
public Task closeTask(long taskId) throws InvalidTaskOperationException {
Task existing = taskRepo.findById(taskId)
.orElseThrow(() -> new InvalidTaskOperationException("Task not found: " + taskId));
if (existing.getStatus() == Status.CLOSED) {
throw new InvalidTaskOperationException("Task already CLOSED");
}
Task closed = existing.toBuilder().status(Status.CLOSED).build();
closed = taskRepo.save(closed);
log.info(() -> "Closed task " + closed);
return closed;
}
/** Get tasks of a project. */
public List<Task> findTasksByProject(long projectId) throws InvalidTaskOperationException {
if (projectRepo.findById(projectId).isEmpty())
throw new InvalidTaskOperationException("Project not found: " + projectId);
var ids = projectTasks.getOrDefault(projectId, Set.of());
List<Task> result = new ArrayList<>();
for (Long id : ids) {
taskRepo.findById(id).ifPresent(result::add);
}
return result;
}
/** Sort tasks using a strategy. */
public List<Task> sortTasks(List<Task> tasks, TaskSortStrategy strategy) {
Objects.requireNonNull(strategy, "strategy");
try {
return sorter.sort(tasks, strategy.comparator());
} catch (Exception e) {
log.log(Level.WARNING, "Sorting failed", e);
return List.copyOf(tasks);
}
}
/** Get all tasks (for convenience). */
public List<Task> findAllTasks() {
return taskRepo.findAll();
}
}
src/main/java/app/taskmgr/AppMain.java
package app.taskmgr;
import app.taskmgr.exception.InvalidTaskOperationException;
import app.taskmgr.model.*;
import app.taskmgr.repository.InMemoryProjectRepository;
import app.taskmgr.repository.InMemoryTaskRepository;
import app.taskmgr.repository.InMemoryUserRepository;
import app.taskmgr.service.TaskService;
import app.taskmgr.service.sort.ByDueDateStrategy;
import app.taskmgr.service.sort.ByPriorityStrategy;
import app.taskmgr.service.sort.ByTitleStrategy;
import java.time.LocalDate;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Console demo: create tasks, assign to project, sort by different strategies, change status.
*/
public class AppMain {
private static final Logger log = Logger.getLogger(AppMain.class.getName());
public static void main(String[] args) {
// Basic logger config
Logger.getLogger("").getHandlers()[0].setLevel(Level.INFO);
var taskRepo = new InMemoryTaskRepository();
var projectRepo = new InMemoryProjectRepository();
var userRepo = new InMemoryUserRepository();
var service = new TaskService(taskRepo, projectRepo, userRepo);
try {
Project demo = service.createProject("Team Tools");
User alice = service.createUser("Alice");
// Create at least 5 tasks with various priority and dates
Task t1 = service.createTask(new TaskBuilder()
.title("Design CLI layout")
.description("Define command structure and help message")
.priority(Priority.HIGH)
.dueDate(LocalDate.now().plusDays(3)), demo.getId(), alice.getId());
Task t2 = service.createTask(new TaskBuilder()
.title("Implement sorting")
.description("Priority, due date, title")
.priority(Priority.MEDIUM)
.dueDate(LocalDate.now().plusDays(5)), demo.getId(), alice.getId());
Task t3 = service.createTask(new TaskBuilder()
.title("Write unit tests")
.description("Cover builder, service, strategies, concurrency")
.priority(Priority.HIGH)
.dueDate(LocalDate.now().plusDays(2)), demo.getId(), alice.getId());
Task t4 = service.createTask(new TaskBuilder()
.title("Add logging")
.description("Use java.util.logging")
.priority(Priority.LOW)
.dueDate(LocalDate.now().plusDays(7)), demo.getId(), alice.getId());
Task t5 = service.createTask(new TaskBuilder()
.title("Polish docs")
.description("README and Javadoc")
.priority(Priority.MEDIUM)
.dueDate(LocalDate.now().plusDays(4)), demo.getId(), alice.getId());
log.info("All tasks (unsorted):");
print(service.findTasksByProject(demo.getId()));
log.info("Sorted by priority:");
print(service.sortTasks(service.findTasksByProject(demo.getId()), new ByPriorityStrategy()));
log.info("Sorted by due date:");
print(service.sortTasks(service.findTasksByProject(demo.getId()), new ByDueDateStrategy()));
log.info("Sorted by title:");
print(service.sortTasks(service.findTasksByProject(demo.getId()), new ByTitleStrategy()));
// Update and close
Task updated = service.updateTask(t2.getId(), "Implement strategies", "Refactor into strategy classes",
Priority.HIGH, LocalDate.now().plusDays(1));
log.info("Updated: " + updated);
Task closed = service.closeTask(t1.getId());
log.info("Closed: " + closed);
log.info("After update/close, by priority:");
print(service.sortTasks(service.findTasksByProject(demo.getId()), new ByPriorityStrategy()));
} catch (InvalidTaskOperationException e) {
log.log(Level.SEVERE, "Operation failed: " + e.getMessage(), e);
}
}
private static void print(List<Task> tasks) {
tasks.forEach(t -> System.out.println(" - " + t));
}
}
四、测试代码
src/test/java/app/taskmgr/TaskBuilderTest.java
package app.taskmgr;
import app.taskmgr.model.*;
import org.junit.jupiter.api.Test;
import java.time.LocalDate;
import static org.junit.jupiter.api.Assertions.*;
/**
* Test builder and entity immutability behavior.
*/
public class TaskBuilderTest {
@Test
void buildTaskWithDefaults() {
Task t = new TaskBuilder()
.title("Sample")
.priority(Priority.MEDIUM)
.build();
assertEquals("Sample", t.getTitle());
assertEquals(Priority.MEDIUM, t.getPriority());
assertEquals(Status.OPEN, t.getStatus());
assertEquals(0L, t.getId());
}
@Test
void immutabilityCopyOnChange() {
Task t1 = new TaskBuilder()
.title("A")
.description("d")
.priority(Priority.HIGH)
.dueDate(LocalDate.now().plusDays(3))
.build();
Task t2 = t1.toBuilder().title("B").build();
assertNotSame(t1, t2);
assertEquals("A", t1.getTitle());
assertEquals("B", t2.getTitle());
}
@Test
void equalsHashCodeForPersistedId() {
Task t1 = new TaskBuilder().id(1).title("X").priority(Priority.HIGH).build();
Task t2 = new TaskBuilder().id(1).title("Y").priority(Priority.LOW).build();
assertEquals(t1, t2);
assertEquals(t1.hashCode(), t2.hashCode());
}
}
src/test/java/app/taskmgr/TaskServiceTest.java
package app.taskmgr;
import app.taskmgr.exception.InvalidTaskOperationException;
import app.taskmgr.model.*;
import app.taskmgr.repository.InMemoryProjectRepository;
import app.taskmgr.repository.InMemoryTaskRepository;
import app.taskmgr.repository.InMemoryUserRepository;
import app.taskmgr.service.TaskService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.time.LocalDate;
import static org.junit.jupiter.api.Assertions.*;
/**
* Test service flows for create/update/close.
*/
public class TaskServiceTest {
TaskService service;
Project project;
User user;
@BeforeEach
void setup() throws InvalidTaskOperationException {
service = new TaskService(new InMemoryTaskRepository(),
new InMemoryProjectRepository(),
new InMemoryUserRepository());
project = service.createProject("Demo");
user = service.createUser("Tester");
}
@Test
void createUpdateCloseFlow() throws Exception {
Task created = service.createTask(new TaskBuilder()
.title("T1")
.priority(Priority.MEDIUM)
.dueDate(LocalDate.now().plusDays(2)), project.getId(), user.getId());
assertTrue(created.getId() > 0);
assertEquals(Status.OPEN, created.getStatus());
Task updated = service.updateTask(created.getId(), "T1-upd", "desc", Priority.HIGH, LocalDate.now().plusDays(3));
assertEquals("T1-upd", updated.getTitle());
assertEquals(Priority.HIGH, updated.getPriority());
Task closed = service.closeTask(updated.getId());
assertEquals(Status.CLOSED, closed.getStatus());
assertThrows(InvalidTaskOperationException.class, () -> service.updateTask(closed.getId(),
"again", "x", Priority.LOW, LocalDate.now().plusDays(1)));
assertThrows(InvalidTaskOperationException.class, () -> service.closeTask(closed.getId()));
}
}
src/test/java/app/taskmgr/SortingStrategyTest.java
package app.taskmgr;
import app.taskmgr.model.*;
import app.taskmgr.service.sort.ByDueDateStrategy;
import app.taskmgr.service.sort.ByPriorityStrategy;
import app.taskmgr.service.sort.ByTitleStrategy;
import app.taskmgr.service.sort.Sorter;
import org.junit.jupiter.api.Test;
import java.time.LocalDate;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
/**
* Test that strategies produce expected ordering.
*/
public class SortingStrategyTest {
private Task t(String title, Priority p, int duePlusDays) {
return new TaskBuilder()
.title(title)
.priority(p)
.dueDate(LocalDate.now().plusDays(duePlusDays))
.build();
}
@Test
void byPriority() {
List<Task> src = List.of(
t("b", Priority.MEDIUM, 3),
t("a", Priority.HIGH, 5),
t("c", Priority.LOW, 1)
);
var sorted = new Sorter<Task>().sort(src, new ByPriorityStrategy().comparator());
assertEquals("a", sorted.get(0).getTitle()); // HIGH first
}
@Test
void byDueDate() {
List<Task> src = List.of(
t("x", Priority.MEDIUM, 5),
t("y", Priority.HIGH, 1),
t("z", Priority.LOW, 3)
);
var sorted = new Sorter<Task>().sort(src, new ByDueDateStrategy().comparator());
assertEquals("y", sorted.get(0).getTitle()); // earliest due date first
}
@Test
void byTitle() {
List<Task> src = List.of(
t("Zoo", Priority.LOW, 1),
t("alpha", Priority.HIGH, 2),
t("Beta", Priority.MEDIUM, 3)
);
var sorted = new Sorter<Task>().sort(src, new ByTitleStrategy().comparator());
assertEquals("alpha", sorted.get(0).getTitle());
}
}
src/test/java/app/taskmgr/RepositoryConcurrencyTest.java
package app.taskmgr;
import app.taskmgr.model.Priority;
import app.taskmgr.model.Task;
import app.taskmgr.model.TaskBuilder;
import app.taskmgr.repository.InMemoryTaskRepository;
import org.junit.jupiter.api.Test;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import static org.junit.jupiter.api.Assertions.*;
/**
* Basic concurrent safety test: concurrent inserts produce correct count.
*/
public class RepositoryConcurrencyTest {
@Test
void concurrentInserts() throws InterruptedException {
var repo = new InMemoryTaskRepository();
int threads = 10;
int perThread = 100;
CountDownLatch latch = new CountDownLatch(threads);
List<Thread> ts = new ArrayList<>();
for (int i = 0; i < threads; i++) {
Thread t = new Thread(() -> {
for (int j = 0; j < perThread; j++) {
Task task = new TaskBuilder()
.title("T-" + Thread.currentThread().getId() + "-" + j)
.priority(Priority.MEDIUM)
.dueDate(LocalDate.now().plusDays(1))
.build();
repo.save(task);
}
latch.countDown();
});
ts.add(t);
t.start();
}
latch.await();
assertEquals(threads * perThread, repo.count());
}
}
五、运行与测试
- 编译与运行
- 构建：./gradlew clean build
- 运行示例：./gradlew run
- 运行测试：./gradlew test
六、关键设计取舍与教学要点
- 面向对象与不可变性
- Task/Project/User 设计为不可变（final 字段、无 setter），通过 TaskBuilder 与 toBuilder 进行受控变更，保证线程安全、易推理。
- equals/hashCode 以持久化后的 id 为主（id>0 时），避免因字段变更导致集合行为异常。
- 构建器模式
- TaskBuilder 封装缺省值与必填校验，build() 负责参数合法性；服务层再做业务前置校验（如不能创建 CLOSED、截止日不得早于今天）。
- 分层与职责
- Repository 层：线程安全的 ConcurrentHashMap 实现，InMemoryTaskRepository 负责分配 ID。
- Service 层：封装业务流程与状态机规则（OPEN->CLOSED），记录项目与任务的关系映射。
- 策略模式 + Comparator + 泛型
- 三个策略类分别实现 TaskSortStrategy，返回 Comparator；Sorter 使用泛型与 Comparator 实现复用、返回新列表不修改原数据。
- Optional 使用
- Repository 的 findById 返回 Optional，服务层统一处理缺失情况并抛出受检异常，减少空指针风险。
- 异常与日志
- 对非法状态抛出受检异常 InvalidTaskOperationException；使用 java.util.logging 记录关键操作。
- 并发安全
- 仓储使用 ConcurrentHashMap + AtomicLong；单元测试验证并发插入计数，体现线程安全基础。
- 测试覆盖
- 构建器与不可变性测试；服务流程（新增/更新/关闭）；三种排序策略；仓储并发。
- Java 语言特性与最佳实践
- 使用 Java 17（records 可作为进一步演示选择，这里为教学清晰性采用显式类）。
- Comparator 组合、Optional、函数式风格的不可变列表返回。
- 日志与异常分离：日志用于运行信息，异常用于业务约束反馈。
七、学习建议（面向入门者）
- 概念梳理
- 从实体不可变性、构建器模式、策略模式入手，理解“封装变化点”的思路。
- 案例驱动
- 跟随 AppMain 通过增/改/关与排序快速理解业务流；尝试新增新的排序策略（如按状态+优先级）。
- 项目导向
- 添加命令行参数解析（如 picocli）扩展 CLI；引入持久化（H2/SQLite）替代内存仓储。
- 问题解决导向
- 尝试引入更多校验（截止日提醒、重复标题检测）；模拟并发场景与更严格的单元/集成测试。
- 工具使用
- 熟练使用 Gradle 任务（build/test/run）、Javadoc 生成、IDE 调试断点；结合日志定位问题。
- 跟进行业趋势
- 关注 Java 版本演进（模式匹配、record、sealed classes）、JUnit 5 特性、现代静态分析（SpotBugs/Checkstyle）、CI/CD 集成（GitHub Actions）。
至此，项目可直接构建运行与测试，展示了面向对象设计、策略模式、线程安全仓储、受检异常、日志与单元测试的综合实践。
