// 项目中的实体类设计示例
@Data
@Entity
@Table(name = "projects")
public class Project {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @NotBlank(message = "项目名称不能为空")
    @Size(max = 100, message = "项目名称不能超过100个字符")
    private String name;
    
    private String description;
    
    @Enumerated(EnumType.STRING)
    private ProjectStatus status = ProjectStatus.ACTIVE;
    
    @ManyToOne
    @JoinColumn(name = "owner_id")
    private User owner;
    
    @OneToMany(mappedBy = "project", cascade = CascadeType.ALL)
    private List<Task> tasks = new ArrayList<>();
    
    @CreationTimestamp
    private LocalDateTime createdAt;
}

2. Spring核心概念理解

核心突破：理解IoC（控制反转）和DI（依赖注入）是掌握Spring框架的关键。

// 项目中的服务层示例，展示依赖注入
@Service
@Transactional
@Slf4j
public class ProjectService {
    
    private final ProjectRepository projectRepository;
    private final UserRepository userRepository;
    private final TaskService taskService;
    
    // 构造器注入（Spring推荐的方式）
    public ProjectService(ProjectRepository projectRepository,
                         UserRepository userRepository,
                         TaskService taskService) {
        this.projectRepository = projectRepository;
        this.userRepository = userRepository;
        this.taskService = taskService;
    }
    
    public Project createProject(CreateProjectRequest request, Long userId) {
        User owner = userRepository.findById(userId)
            .orElseThrow(() -> new ResourceNotFoundException("用户不存在"));
        
        Project project = new Project();
        project.setName(request.getName());
        project.setDescription(request.getDescription());
        project.setOwner(owner);
        
        log.info("用户 {} 创建项目: {}", userId, request.getName());
        return projectRepository.save(project);
    }
}

第二阶段：SpringBoot快速上手（提高效率）

SpringBoot核心特性

优势对比：相较于传统Spring MVC，SpringBoot的自动化配置和起步依赖大大提高了开发效率。

// 项目主启动类
@SpringBootApplication
@EnableJpaAuditing  // 启用JPA审计功能（自动填充创建时间等）
@EnableCaching      // 启用缓存
@EnableScheduling   // 启用定时任务
public class TaskManagementApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(TaskManagementApplication.class, args);
    }
    
    // 全局异常处理器配置
    @ControllerAdvice
    public static class GlobalExceptionHandler {
        @ExceptionHandler(ResourceNotFoundException.class)
        public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {
            ErrorResponse error = new ErrorResponse(
                HttpStatus.NOT_FOUND.value(),
                ex.getMessage(),
                LocalDateTime.now()
            );
            return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
        }
    }
}

项目配置文件示例

# application.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/task_management?useSSL=false&serverTimezone=UTC
    username: root
    password: ${DB_PASSWORD:password123}
    driver-class-name: com.mysql.cj.jdbc.Driver
    
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
        format_sql: true
        
  jackson:
    serialization:
      write-dates-as-timestamps: false
      
server:
  port: 8080
  servlet:
    context-path: /api
    
logging:
  level:
    com.example.taskmanagement: DEBUG
    org.springframework.web: INFO

第三阶段：数据持久化与API设计（核心技能）

Spring Data JPA实践

技术选型：我选择了JPA而非MyBatis，因为它更符合面向对象思维，能减少SQL编写。

// 项目中的Repository设计
@Repository
public interface TaskRepository extends JpaRepository<Task, Long> {
    
    // 方法名查询（Spring Data JPA的强大特性）
    List<Task> findByProjectIdAndStatus(Long projectId, TaskStatus status);
    
    List<Task> findByAssigneeIdAndDueDateBefore(Long assigneeId, LocalDate dueDate);
    
    @Query("SELECT t FROM Task t WHERE t.project.id = :projectId " +
           "AND (t.title LIKE %:keyword% OR t.description LIKE %:keyword%)")
    Page<Task> searchByProjectAndKeyword(@Param("projectId") Long projectId,
                                         @Param("keyword") String keyword,
                                         Pageable pageable);
    
    @Query(value = """
        SELECT t.status as status, COUNT(t) as count 
        FROM Task t 
        WHERE t.project.id = :projectId 
        GROUP BY t.status
        """)
    List<TaskStatusCount> countTasksByStatus(@Param("projectId") Long projectId);
    
    // 自定义DTO投影
    @Query("SELECT new com.example.taskmanagement.dto.TaskSummaryDTO(" +
           "t.id, t.title, t.status, u.username, t.dueDate) " +
           "FROM Task t JOIN t.assignee u WHERE t.project.id = :projectId")
    List<TaskSummaryDTO> findTaskSummariesByProject(@Param("projectId") Long projectId);
}

// 自定义统计接口
public interface TaskStatusCount {
    String getStatus();
    Long getCount();
}

RESTful API设计最佳实践

设计原则：遵循RESTful规范，合理设计资源路径和HTTP方法。

// 项目中的REST控制器设计
@RestController
@RequestMapping("/api/projects/{projectId}/tasks")
@Validated
@Tag(name = "任务管理", description = "任务相关的API")
public class TaskController {
    
    private final TaskService taskService;
    
    @GetMapping
    @Operation(summary = "获取项目任务列表", description = "支持分页和过滤")
    public ResponseEntity<PageResponse<TaskDTO>> getTasks(
            @PathVariable Long projectId,
            @RequestParam(required = false) TaskStatus status,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size,
            @RequestParam(defaultValue = "createdAt,desc") String sort) {
        
        Pageable pageable = PageRequest.of(page, size, Sort.by(sort.split(",")));
        Page<TaskDTO> taskPage = taskService.getTasksByProject(projectId, status, pageable);
        
        return ResponseEntity.ok(PageResponse.fromPage(taskPage));
    }
    
    @PostMapping
    @Operation(summary = "创建新任务")
    public ResponseEntity<TaskDTO> createTask(
            @PathVariable Long projectId,
            @Valid @RequestBody CreateTaskRequest request,
            @AuthenticationPrincipal UserDetails userDetails) {
        
        TaskDTO createdTask = taskService.createTask(projectId, request, userDetails);
        return ResponseEntity.created(URI.create("/tasks/" + createdTask.getId()))
                .body(createdTask);
    }
    
    @PutMapping("/{taskId}")
    @Operation(summary = "更新任务")
    public ResponseEntity<TaskDTO> updateTask(
            @PathVariable Long projectId,
            @PathVariable Long taskId,
            @Valid @RequestBody UpdateTaskRequest request) {
        
        TaskDTO updatedTask = taskService.updateTask(projectId, taskId, request);
        return ResponseEntity.ok(updatedTask);
    }
    
    @PatchMapping("/{taskId}/status")
    @Operation(summary = "更新任务状态")
    public ResponseEntity<TaskDTO> updateTaskStatus(
            @PathVariable Long projectId,
            @PathVariable Long taskId,
            @RequestParam TaskStatus status) {
        
        TaskDTO updatedTask = taskService.updateTaskStatus(projectId, taskId, status);
        return ResponseEntity.ok(updatedTask);
    }
}

第四阶段：安全与认证（关键环节）

Spring Security与JWT整合

安全设计：基于Token的无状态认证，配合角色权限控制。

// JWT认证过滤器
@Component
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    
    private final JwtService jwtService;
    private final UserDetailsService userDetailsService;
    
    @Override
    protected void doFilterInternal(
            @NonNull HttpServletRequest request,
            @NonNull HttpServletResponse response,
            @NonNull FilterChain filterChain
    ) throws ServletException, IOException {
        
        final String authHeader = request.getHeader("Authorization");
        final String jwt;
        final String userEmail;
        
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            filterChain.doFilter(request, response);
            return;
        }
        
        jwt = authHeader.substring(7);
        userEmail = jwtService.extractUsername(jwt);
        
        if (userEmail != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(userEmail);
            
            if (jwtService.isTokenValid(jwt, userDetails)) {
                UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(
                    userDetails,
                    null,
                    userDetails.getAuthorities()
                );
                authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authToken);
            }
        }
        filterChain.doFilter(request, response);
    }
}

// 安全配置类
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfiguration {
    
    private final JwtAuthenticationFilter jwtAuthFilter;
    private final AuthenticationProvider authenticationProvider;
    
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(AbstractHttpConfigurer::disable)
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .requestMatchers("/api/projects/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .authenticationProvider(authenticationProvider)
            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);
        
        return http.build();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

第五阶段：高级特性与项目优化

1. 缓存优化

// Redis缓存配置与使用
@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .disableCachingNullValues()
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()));
        
        return RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(config)
            .build();
    }
}

@Service
@CacheConfig(cacheNames = "projects")
public class ProjectService {
    
    @Cacheable(key = "'project:' + #id")
    public ProjectDTO getProjectById(Long id) {
        // 数据库查询逻辑
    }
    
    @CacheEvict(key = "'project:' + #id")
    public void deleteProject(Long id) {
        // 删除逻辑
    }
}

2. 异步处理与消息队列

// 异步任务处理示例
@Service
@Slf4j
public class NotificationService {
    
    @Async
    @EventListener
    public void handleTaskAssignedEvent(TaskAssignedEvent event) {
        log.info("异步处理任务分配通知: 任务 {} 分配给用户 {}", 
                event.getTaskId(), event.getAssigneeId());
        
        // 发送邮件、站内信等通知
        // 这里可以集成邮件服务、WebSocket推送等
    }
    
    @Scheduled(cron = "0 0 9 * * ?") // 每天上午9点执行
    public void sendDailyReminders() {
        log.info("发送每日任务提醒");
        // 查询今日到期的任务，发送提醒
    }
}

// 事件定义
@Getter
@AllArgsConstructor
public class TaskAssignedEvent {
    private Long taskId;
    private Long assigneeId;
    private String taskTitle;
}

第六阶段：测试与部署（质量保障）

1. 分层测试策略

// 单元测试示例
@ExtendWith(MockitoExtension.class)
class ProjectServiceTest {
    
    @Mock
    private ProjectRepository projectRepository;
    
    @Mock
    private UserRepository userRepository;
    
    @InjectMocks
    private ProjectService projectService;
    
    @Test
    void createProject_WithValidData_ShouldReturnProject() {
        // Given
        CreateProjectRequest request = new CreateProjectRequest("新项目", "项目描述");
        User mockUser = new User();
        mockUser.setId(1L);
        
        when(userRepository.findById(1L)).thenReturn(Optional.of(mockUser));
        when(projectRepository.save(any(Project.class))).thenAnswer(invocation -> {
            Project project = invocation.getArgument(0);
            project.setId(100L);
            return project;
        });
        
        // When
        Project result = projectService.createProject(request, 1L);
        
        // Then
        assertNotNull(result);
        assertEquals(100L, result.getId());
        assertEquals("新项目", result.getName());
        verify(projectRepository, times(1)).save(any(Project.class));
    }
}

// 集成测试示例
@SpringBootTest
@AutoConfigureMockMvc
@TestPropertySource(locations = "classpath:application-test.yml")
class TaskControllerIntegrationTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Test
    @WithMockUser(username = "testuser", roles = {"USER"})
    void getTasks_ShouldReturnTaskList() throws Exception {
        mockMvc.perform(get("/api/projects/1/tasks")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.content", hasSize(greaterThanOrEqualTo(0))));
    }
}

2. Docker化部署

# Dockerfile
FROM openjdk:17-jdk-slim
VOLUME /tmp
COPY target/task-management-*.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

# docker-compose.yml
version: '3.8'
services:
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: task_management
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
  
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"
  
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/task_management
      SPRING_DATASOURCE_USERNAME: root
      SPRING_DATASOURCE_PASSWORD: rootpassword
      SPRING_REDIS_HOST: redis
    depends_on:
      - mysql
      - redis

volumes:
  mysql_data: