SpringBoot医患系统设计与安全方案

本文深入探讨了基于Spring Boot构建安全可靠的医患系统的设计与实现。针对医患系统中用户角色建模的复杂性，提出了一种混合实体设计方案，巧妙地将通用用户属性与医生、患者的特定属性分离，并通过共享主键的一对一关联实现数据整合，为Spring Security集成奠定基础。通过自定义UserDetailsService，利用UserType字段实现细粒度的角色认证和授权，确保系统安全。该方案不仅简化了数据模型，还提升了系统的可维护性和扩展性，为构建高效、安全的医患关系管理系统提供了最佳实践。

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

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

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

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

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

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

核心实体设计

1. 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
   }

2. 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 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); // 维护双向关系
       }
   }

3. 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 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); // 维护双向关系
       }
   }

4. 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 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 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，我们可以轻松实现基于角色的认证和授权，并在业务逻辑层面进行细粒度的权限控制。这种模块化和可扩展的设计模式，对于构建健壮且易于管理的企业级应用具有重要的指导意义。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。