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 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 medicines = new HashSet<>();
// 患者与医生之间的多对多关系（通过Doctor实体维护）
@ManyToMany(mappedBy = "patients", fetch = FetchType.LAZY) // mappedBy指向Doctor实体中维护关系的字段
private Set 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 patients = new HashSet<>();
} 这种设计的好处是：
- 职责分离： User 负责认证和基本身份，Doctor 和 Patient 负责各自特有的业务属性和关系。
- 避免空字段： Doctor 和 Patient 表只包含各自特有的数据，避免了单一 User 表中的大量空字段。
- 灵活扩展： 如果未来有新的用户类型（如管理员、护士），只需创建新的实体并关联到 User 即可。
- 统一认证： 所有用户通过 User 实体进行认证，简化了安全配置。
3. 安全与权限集成 (Spring Security)
Spring Security 是 Spring 生态系统中强大的安全框架，非常适合处理用户认证和授权。
3.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）。
-
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 ListgetDoctorPatients(@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，可以实现强大且精细的权限控制，确保医疗系统的数据安全和操作合规性。这种分层、模块化的设计思路，不仅提高了代码的可维护性和可扩展性，也为未来业务需求的变化预留了空间。
