Spring Boot 医疗系统实体关系与安全实现指南

本文旨在探讨在Spring Boot应用中构建医生-患者关系管理系统的最佳实践。我们将深入分析如何设计灵活且可扩展的实体模型，以有效处理医生、患者和药物之间的多对多关联。同时，文章还将详细阐述如何结合Spring Security框架，为不同用户角色（如医生和患者）实现安全认证与精细化权限控制，确保系统的健壮性和数据安全。

1. 核心实体关系设计挑战

在设计医生-患者关系管理系统时，一个核心挑战在于如何有效地建模医生（doctor）、患者（patient）和药物（medicine）之间的复杂关联，并在此基础上实现用户认证与权限管理。常见的两种初步思路是：

• 方案A：独立实体与多对多关联 将医生和患者分别设计为独立的实体，并通过 @ManyToMany 关联起来。这种方式在数据模型上直观，但面临如何为医生和患者分别实现登录注册及权限控制的问题，可能需要为不同用户类型维护独立的认证流程或端点。

• 方案B：单一用户表与角色管理 引入一个通用的 User 表，包含角色（如 RoleType 枚举），医生和患者都作为 User 的一种类型。这种方式简化了认证逻辑，但可能导致 User 表中存在大量空字段（如医生没有药物列表，患者没有医生特有的属性），且业务逻辑需要根据用户角色进行大量条件判断，导致代码冗余和复杂性增加。

上述两种方案各有优缺点，但都存在一定局限性。方案A在安全管理上不够统一，而方案B则在数据模型和业务逻辑上引入了不必要的耦合和冗余。因此，我们需要一种更优化的混合方案。

2. 推荐的实体设计方案

为了兼顾通用性、扩展性和业务隔离，推荐采用一种混合实体设计模式：定义一个通用的 User 实体来处理所有用户的基本信息和认证凭据，然后为医生和患者创建各自的专属实体，并通过一对一关系与 User 实体关联。

2.1 实体模型定义

User 实体： 作为所有用户的基础，包含通用属性如ID、姓名、姓氏、以及用户类型（用于权限判断）。

import jakarta.persistence.*; import lombok.Getter; import lombok.Setter;  @Entity @Table(name = "app_users") // 避免与数据库保留字冲突 @Getter @Setter public class User {      @Id     @GeneratedValue(strategy = GenerationType.IDENTITY)     private Long id;     private String name;     private String surname;     private String username; // 用于登录的用户名     private String password; // 存储加密后的密码      @Enumerated(EnumType.STRING)     @Column(nullable = false)     private UserType userType; // 用户类型：DOCTOR, PATIENT, ADMIN等 }  // 用户类型枚举 public enum UserType {     DOCTOR,     PATIENT,     ADMIN }

Doctor 实体： 包含医生特有的属性，并通过 @OneToOne 关联到 User 实体。@MapsId 注解确保 Doctor 的主键与关联的 User 的主键相同，实现共享主键的一对一映射。

import jakarta.persistence.*; import lombok.Getter; import lombok.Setter; import java.util.HashSet; import java.util.Set;  @Entity @Getter @Setter public class Doctor {      @Id     private Long id; // 与User实体共享主键      @OneToOne     @MapsId // 表示此实体的主键是其关联实体的主键     @JoinColumn(name = "id", nullable = false) // 外键列名     private User user;      // 医生与患者之间的多对多关系     @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}) // 级联操作     @JoinTable(         name = "doctor_patients", // 关系表名         joinColumns = @JoinColumn(name = "doctor_id"), // 本实体在关系表中的外键         inverseJoinColumns = @JoinColumn(name = "patient_id") // 对方实体在关系表中的外键     )     private Set<Patient> patients = new HashSet<>();      // 辅助方法，用于添加患者     public void addPatient(Patient patient) {         this.patients.add(patient);         patient.getDoctors().add(this); // 维护双向关系     }      // 辅助方法，用于移除患者     public void removePatient(Patient patient) {         this.patients.remove(patient);         patient.getDoctors().remove(this); // 维护双向关系     } }

Patient 实体： 包含患者特有的属性，同样通过 @OneToOne 关联到 User 实体。

import jakarta.persistence.*; import lombok.Getter; import lombok.Setter; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set;  @Entity @Getter @Setter public class Patient {      @Id     private Long id; // 与User实体共享主键      @OneToOne     @MapsId     @JoinColumn(name = "id", nullable = false)     private User user;      // 患者与药物之间的多对多关系     @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})     @JoinTable(         name = "patient_medicines",         joinColumns = @JoinColumn(name = "patient_id"),         inverseJoinColumns = @JoinColumn(name = "medicine_id")     )     private Set<Medicine> medicines = new HashSet<>();      // 患者与医生之间的多对多关系（通过Doctor实体维护）     @ManyToMany(mappedBy = "patients", fetch = FetchType.LAZY) // mappedBy指向Doctor实体中维护关系的字段     private Set<Doctor> doctors = new HashSet<>();      // 辅助方法，用于添加药物     public void addMedicine(Medicine medicine) {         this.medicines.add(medicine);         medicine.getPatients().add(this); // 维护双向关系     }      // 辅助方法，用于移除药物     public void removeMedicine(Medicine medicine) {         this.medicines.remove(medicine);         medicine.getPatients().remove(this); // 维护双向关系     } }

Medicine 实体： 药物信息。

import jakarta.persistence.*; import lombok.Getter; import lombok.Setter; import java.util.HashSet; import java.util.Set;  @Entity @Getter @Setter public class Medicine {      @Id     @GeneratedValue(strategy = GenerationType.IDENTITY)     private Long id;     private String name;     private String description;      // 药物与患者之间的多对多关系（通过Patient实体维护）     @ManyToMany(mappedBy = "medicines", fetch = FetchType.LAZY)     private Set<Patient> patients = new HashSet<>(); }

这种设计的好处是：

• 职责分离： User 负责认证和基本身份，Doctor 和 Patient 负责各自特有的业务属性和关系。
• 避免空字段： Doctor 和 Patient 表只包含各自特有的数据，避免了单一 User 表中的大量空字段。
• 灵活扩展： 如果未来有新的用户类型（如管理员、护士），只需创建新的实体并关联到 User 即可。
• 统一认证： 所有用户通过 User 实体进行认证，简化了安全配置。

3. 安全与权限集成 (Spring Security)

Spring Security 是 Spring 生态系统中强大的安全框架，非常适合处理用户认证和授权。

3.1 用户认证流程

1. UserDetailsService 实现： Spring Security 通过 UserDetailsService 接口加载用户信息。我们需要实现这个接口，根据用户名从 User 实体中获取用户信息，并将其转换为 Spring Security 的 UserDetails 对象。

   import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.core.userdetails.UsernameNotFoundException; import org.springframework.security.core.authority.SimpleGrantedAuthority; import org.springframework.stereotype.Service; import java.util.Collections;  @Service public class CustomUserDetailsService implements UserDetailsService {      private final UserRepository userRepository; // 假设你有一个UserRepository      public CustomUserDetailsService(UserRepository userRepository) {         this.userRepository = userRepository;     }      @Override     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {         User user = userRepository.findByUsername(username)             .orElseThrow(() -> new UsernameNotFoundException("User not found with username: " + username));          // 将UserType转换为Spring Security的GrantedAuthority         return new org.springframework.security.core.userdetails.User(             user.getUsername(),             user.getPassword(), // 密码需要是加密的             Collections.singletonList(new SimpleGrantedAuthority("ROLE_" + user.getUserType().name()))         );     } }

   在 User 实体中添加 username 和 password 字段，并确保密码在存储前进行加密（例如使用 BCryptPasswordEncoder）。

2. Spring Security 配置： 配置 SecurityFilterChain（Spring Boot 2.7+ 推荐）或 WebSecurityConfigurerAdapter（旧版本），定义认证方式、授权规则和密码编码器。

   import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.security.web.SecurityFilterChain;  @Configuration @EnableWebSecurity public class SecurityConfig {      @Bean     public PasswordEncoder passwordEncoder() {         return new BCryptPasswordEncoder();     }      @Bean     public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {         http             .csrf(csrf -> csrf.disable()) // 禁用CSRF，方便测试，生产环境请谨慎             .authorizeHttpRequests(authorize -> authorize                 .requestMatchers("/api/public/**").permitAll() // 允许公共访问的API                 .requestMatchers("/api/doctors/**").hasRole("DOCTOR") // 只有DOCTOR角色才能访问                 .requestMatchers("/api/patients/**").hasRole("PATIENT") // 只有PATIENT角色才能访问                 .anyRequest().authenticated() // 其他所有请求都需要认证             )             .formLogin(form -> form                 .permitAll() // 允许所有人访问登录页             )             .logout(logout -> logout                 .permitAll()             );         return http.build();     } }

3.2 权限控制与业务逻辑

在控制器或服务层，可以通过 @PreAuthorize 注解或在代码中获取当前认证用户的信息，然后根据 UserType 或其关联的 Doctor/Patient 实体来执行特定的业务逻辑。

• 基于角色授权：

  import org.springframework.security.access.prepost.PreAuthorize; import org.springframework.web.bind.annotation.*;  @RestController @RequestMapping("/api/doctors") public class DoctorController {      @PreAuthorize("hasRole('DOCTOR')") // 只有DOCTOR角色才能访问     @GetMapping("/{doctorId}/patients")     public List<Patient> getDoctorPatients(@PathVariable Long doctorId) {         // 获取当前登录的医生，并返回其关联的患者列表         // 注意：这里需要确保当前登录的医生ID与请求的doctorId匹配，防止越权         return doctorService.findPatientsByDoctorId(doctorId);     } }  @RestController @RequestMapping("/api/patients") public class PatientController {      @PreAuthorize("hasRole('PATIENT')") // 只有PATIENT角色才能访问     @PostMapping("/{patientId}/medicines")     public void addMedicineToPatient(@PathVariable Long patientId, @RequestBody Medicine medicine) {         // 只有当前登录的患者才能添加药物         patientService.addMedicine(patientId, medicine);     } }

• 获取当前用户信息： 可以通过 SecurityContextHolder 或 @AuthenticationPrincipal 获取当前登录用户的 UserDetails 对象，进而获取其 User 实体，再根据 UserType 进一步加载 Doctor 或 Patient 实体。

  import org.springframework.security.core.Authentication; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.security.core.userdetails.UserDetails;  // 在服务层或控制器中 public User getCurrentAuthenticatedUser() {     Authentication authentication = SecurityContextHolder.getContext().getAuthentication();     if (authentication != null && authentication.getPrincipal() instanceof UserDetails) {         UserDetails userDetails = (UserDetails) authentication.getPrincipal();         // 根据userDetails.getUsername()从UserRepository中获取完整的User实体         return userRepository.findByUsername(userDetails.getUsername()).orElse(null);     }     return null; }  // 然后可以根据UserType判断并加载具体的Doctor或Patient实体 public Doctor getCurrentDoctor() {     User currentUser = getCurrentAuthenticatedUser();     if (currentUser != null && currentUser.getUserType() == UserType.DOCTOR) {         return doctorRepository.findById(currentUser.getId()).orElse(null);     }     return null; }

3.3 特殊情况处理：医生同时是患者

在某些情况下，一个医生也可能同时是患者（例如，医生自己生病需要看病）。这种混合实体设计能够很好地支持这种情况。一个 User 实体可以同时关联到一个 Doctor 实体和一个 Patient 实体。在权限判断时，系统会根据其 UserType（或更精确地说，根据其拥有的角色列表）来决定其可以访问哪些资源和执行哪些操作。

例如，如果一个 User 同时拥有 ROLE_DOCTOR 和 ROLE_PATIENT 两个权限，那么他既可以访问医生相关的API，也可以访问患者相关的API。业务逻辑层则根据具体操作上下文，通过 user.getId() 去查询对应的 Doctor 或 Patient 实体来执行操作。

4. 注意事项与最佳实践

• 密码加密： 务必使用 PasswordEncoder 对用户密码进行加密存储，切勿明文存储。
• 事务管理： 确保涉及多个实体操作的业务逻辑处于事务中，以保证数据一致性。
• 懒加载（Lazy Loading）： 对于多对多关系，默认使用 FetchType.LAZY，避免加载不必要的数据，提高性能。只有在真正需要关联数据时才去加载。
• 级联操作（CascadeType）： 谨慎使用 CascadeType.ALL。通常，对于一对一或一对多关系，PERSIST 和 MERGE 足够。在多对多关系中，通常只在关系维护方使用 PERSIST 和 MERGE，避免不必要的级联删除。
• 服务层设计： 可以设计 UserService 处理通用用户操作，DoctorService 处理医生特有业务，PatientService 处理患者特有业务。这些服务可以互相协作，但保持各自职责清晰。
• API设计： 考虑为不同角色设计不同的API路径前缀（如 /api/doctors 和 /api/patients），使权限控制更加直观。
• 异常处理： 实现统一的异常处理机制，为API调用提供友好的错误响应。

总结

通过采用通用 User 实体与特定角色实体（Doctor、Patient）相结合的设计模式，我们能够构建出既能统一管理用户认证，又能灵活处理复杂业务逻辑和实体关系的Spring Boot应用。结合Spring Security，可以实现强大且精细的权限控制，确保医疗系统的数据安全和操作合规性。这种分层、模块化的设计思路，不仅提高了代码的可维护性和可扩展性，也为未来业务需求的变化预留了空间。