Spring Boot中构建医患关系管理系统：实体设计与安全实现-java教程-PHP中文网

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
@Getter
public 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
@Getter
public 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<Patient> 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
@Getter
public 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<Medicine> medicines = new HashSet<>();

    @ManyToMany(mappedBy = "patients", fetch = FetchType.LAZY)
    private Set<Doctor> 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
@Getter
public class Medicine {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String dosage; // 剂量等

    @ManyToMany(mappedBy = "medicines", fetch = FetchType.LAZY)
    private Set<Patient> 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;

@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
        List<SimpleGrantedAuthority> authorities = Collections.singletonList(
            new SimpleGrantedAuthority("ROLE_" + user.getUserType().name())
        );

        return new org.springframework.security.core.userdetails.User(
                user.getUsername(),
                user.getPassword(), // 实际应用中密码应为加密后的
                authorities
        );
    }
}

登录后复制

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

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;

@Service
public 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中构建医患关系管理系统：实体设计与安全实现的详细内容，更多请关注php中文网其它相关文章！