Spring Boot中构建医患关系管理系统：实体设计与安全实现

本文探讨了在Spring Boot应用中构建医患关系管理系统的最佳实践，重点解决用户角色（医生、患者）的实体建模与Spring Security的集成挑战。通过引入一个通用用户实体与角色特定实体相结合的混合设计方案，我们能够高效管理用户基本信息、特定角色属性及其复杂的多对多关系，并为灵活的权限控制奠定坚实基础。

在开发复杂的业务系统时，如何高效地建模具有不同属性和行为的用户角色，并将其与认证授权机制（如spring security）无缝集成，是常见的挑战。以医患关系管理系统为例，医生和患者虽然都是用户，但他们各自拥有独特的属性和业务逻辑。传统的建模方式，无论是完全分离实体还是使用单一臃肿的用户实体，都可能在数据管理和安全集成方面带来不便。

医患关系实体建模的挑战与优化方案

在设计医患关系系统时，我们面临两种常见的初始思路：

完全分离的实体：为医生（Doctor）和患者（Patient）分别创建独立的实体，并通过@ManyToMany关联。这种方法在数据模型上清晰，但会给认证授权带来困扰，因为用户登录时需要区分是医生还是患者，并且可能需要为两者维护独立的认证流程。单一用户实体与角色区分：创建一个通用的User实体，包含所有用户共有的属性，并通过一个roleType字段区分医生或患者。这种方法简化了认证流程，但会导致User实体中存在大量空字段（例如，医生用户不需要“药物列表”字段），且业务逻辑需要通过if-else来区分角色，导致代码耦合度高。

为了克服上述挑战，推荐采用一种混合建模方案：将通用用户属性抽象到独立的User实体中，而将特定角色属性和关系分别映射到Doctor和Patient实体，并通过一对一关联将它们与User实体关联起来。 这种设计既保持了数据模型的清晰性，又便于统一的认证管理和灵活的权限控制。

核心实体设计

User 实体：User实体承载所有用户的通用信息，如ID、姓名、姓氏以及最重要的用户类型（UserType）。UserType枚举可以明确区分用户是医生还是患者。

import jakarta.persistence.*;import lombok.Getter;import lombok.Setter;@Entity@Table(name = "MY_USERS") // 避免与数据库保留字冲突@Setter@Getterpublic class User {    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private Long id;    private String username; // 用户名，用于登录    private String password; // 密码，需要加密存储    private String firstName;    private String lastName;    @Enumerated(EnumType.STRING)    @Column(nullable = false)    private UserType userType; // 用户类型：DOCTOR, PATIENT    // 构造函数、equals/hashCode等省略}public enum UserType {    DOCTOR,    PATIENT}

Doctor 实体：Doctor实体包含医生特有的属性和与患者的关系。它通过@OneToOne关联到User实体，并使用@MapsId注解表示Doctor的主键与关联的User实体的主键相同，从而实现共享主键。

import jakarta.persistence.*;import lombok.Getter;import lombok.Setter;import java.util.HashSet;import java.util.Set;@Entity@Setter@Getterpublic class Doctor {    @Id    private Long id; // 与User实体共享主键    @OneToOne(fetch = FetchType.LAZY)    @MapsId // 表示Doctor的主键映射到User的主键    @JoinColumn(name = "id") // 外键列名    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();    // 构造函数、equals/hashCode等省略    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 实体：Patient实体包含患者特有的属性，如药物列表，以及与医生和药物的关系。它同样通过@OneToOne和@MapsId关联到User实体。

import jakarta.persistence.*;import lombok.Getter;import lombok.Setter;import java.util.HashSet;import java.util.Set;@Entity@Setter@Getterpublic class Patient {    @Id    private Long id; // 与User实体共享主键    @OneToOne(fetch = FetchType.LAZY)    @MapsId // 表示Patient的主键映射到User的主键    @JoinColumn(name = "id") // 外键列名    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();    @ManyToMany(mappedBy = "patients", fetch = FetchType.LAZY)    private Set doctors = new HashSet();    // 构造函数、equals/hashCode等省略    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 实体：Medicine实体代表药物信息，与Patient实体存在多对多关系。

import jakarta.persistence.*;import lombok.Getter;import lombok.Setter;import java.util.HashSet;import java.util.Set;@Entity@Setter@Getterpublic class Medicine {    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private Long id;    private String name;    private String dosage; // 剂量等    @ManyToMany(mappedBy = "medicines", fetch = FetchType.LAZY)    private Set patients = new HashSet();    // 构造函数、equals/hashCode等省略}

注意事项：

@MapsId注解是实现共享主键的关键，它使得Doctor和Patient实体的主键直接引用User实体的主键。@JoinTable用于定义多对多关系的中间表。在Doctor和Patient实体中，手动维护双向关系（addPatient/removePatient等方法）是良好的实践，以确保数据一致性。CascadeType.PERSIST和CascadeType.MERGE是常用的级联操作，可以根据业务需求进行调整。

Spring Security集成与权限管理

在上述实体设计的基础上，Spring Security的集成将变得相对简单和直观。核心思想是利用User实体中的userType字段进行认证和授权。

1. 自定义 UserDetailsService

你需要实现UserDetailsService接口，Spring Security会使用它来加载用户详情。在这个实现中，你将根据用户名查找User实体，并将其userType映射为Spring Security的GrantedAuthority。

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;import java.util.List;import java.util.stream.Collectors;@Servicepublic 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        List authorities = Collections.singletonList(            new SimpleGrantedAuthority("ROLE_" + user.getUserType().name())        );        return new org.springframework.security.core.userdetails.User(                user.getUsername(),                user.getPassword(), // 实际应用中密码应为加密后的                authorities        );    }}

注意： 密码在实际应用中必须是加密存储的，例如使用BCryptPasswordEncoder。

乾坤圈新媒体矩阵管家

新媒体账号、门店矩阵智能管理系统

17 查看详情

2. Spring Security 配置

在Spring Security配置中，你需要指定自定义的UserDetailsService和密码编码器。

import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;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@EnableMethodSecurity(prePostEnabled = true) // 启用方法级别的安全注解public class SecurityConfig {    private final CustomUserDetailsService customUserDetailsService;    public SecurityConfig(CustomUserDetailsService customUserDetailsService) {        this.customUserDetailsService = customUserDetailsService;    }    @Bean    public PasswordEncoder passwordEncoder() {        return new BCryptPasswordEncoder();    }    @Bean    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {        http            .csrf(csrf -> csrf.disable()) // 生产环境应考虑启用CSRF保护            .authorizeHttpRequests(auth -> auth                .requestMatchers("/public/**", "/auth/**").permitAll() // 允许公共访问和认证接口                .requestMatchers("/api/doctors/**").hasRole("DOCTOR") // 只有医生角色才能访问                .requestMatchers("/api/patients/**").hasRole("PATIENT") // 只有患者角色才能访问                .anyRequest().authenticated() // 其他所有请求需要认证            )            .formLogin(form -> form // 或者使用httpBasic, oauth2Login等                .loginPage("/login").permitAll() // 自定义登录页                .defaultSuccessUrl("/dashboard", true)            )            .logout(logout -> logout                .permitAll()            );        return http.build();    }}

@EnableMethodSecurity(prePostEnabled = true) 允许你在方法级别使用@PreAuthorize等注解进行更细粒度的权限控制。

3. 业务逻辑层面的权限控制

在Service层或Controller层，你可以根据当前认证用户的UserType来执行不同的业务逻辑或验证权限。

import org.springframework.security.access.prepost.PreAuthorize;import org.springframework.security.core.Authentication;import org.springframework.security.core.context.SecurityContextHolder;import org.springframework.stereotype.Service;@Servicepublic class PatientService {    private final PatientRepository patientRepository;    private final UserRepository userRepository;    public PatientService(PatientRepository patientRepository, UserRepository userRepository) {        this.patientRepository = patientRepository;        this.userRepository = userRepository;    }    @PreAuthorize("hasRole('PATIENT')") // 只有患者角色才能调用此方法    public void addMedicineToPatient(Long medicineId) {        // 获取当前认证的用户ID        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();        String username = authentication.getName();        User currentUser = userRepository.findByUsername(username)                                       .orElseThrow(() -> new RuntimeException("Authenticated user not found"));        // 确保当前用户是患者，并获取对应的Patient实体        if (currentUser.getUserType() != UserType.PATIENT) {            throw new RuntimeException("Only patients can add medicine.");        }        // 根据 currentUser.getId() 或其他方式获取Patient实体，然后添加药物        // ... 实际的业务逻辑，例如：        // Patient patient = patientRepository.findById(currentUser.getId()).orElseThrow(...);        // Medicine medicine = medicineRepository.findById(medicineId).orElseThrow(...);        // patient.addMedicine(medicine);        // patientRepository.save(patient);    }}

通过@PreAuthorize(“hasRole(‘PATIENT’)”)，你可以在方法执行前进行角色检查。在方法内部，你可以通过SecurityContextHolder获取当前认证用户的详细信息，包括其ID，然后根据ID查询对应的Patient或Doctor实体来执行特定角色的业务操作。

总结

本文提出的医患关系实体建模方案，通过将通用用户属性与角色特定属性分离，并使用共享主键的@OneToOne关联，有效地解决了复杂用户角色的数据建模问题。这种设计不仅使实体结构清晰、易于维护，也为Spring Security的集成提供了天然的便利。通过UserType字段和CustomUserDetailsService，我们可以轻松实现基于角色的认证和授权，并在业务逻辑层面进行细粒度的权限控制。这种模块化和可扩展的设计模式，对于构建健壮且易于管理的企业级应用具有重要的指导意义。

以上就是Spring Boot中构建医患关系管理系统：实体设计与安全实现的详细内容，更多请关注创想鸟其它相关文章！