当前位置：首页 > 文章列表 > 文章 > java教程 > SpringBoot医疗系统实体关系与安全实现解析

SpringBoot医疗系统实体关系与安全实现解析

2025-09-14 08:15:46 0浏览收藏

本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《Spring Boot 医疗系统实体关系与安全实现指南》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~

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 用户认证流程

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 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，可以实现强大且精细的权限控制，确保医疗系统的数据安全和操作合规性。这种分层、模块化的设计思路，不仅提高了代码的可维护性和可扩展性，也为未来业务需求的变化预留了空间。

好了，本文到此结束，带大家了解了《SpringBoot医疗系统实体关系与安全实现解析》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！