Spring Data实体继承实现：Spring Boot用户角色体系开发问询

Great call using entity inheritance to handle your Admin and Client users—this is a clean, maintainable way to reuse common attributes while keeping user-specific fields organized. Let’s walk through how to implement this properly with Spring Boot, Hibernate, and Spring Security:

Hibernate offers three main inheritance strategies; for your use case, Joined Table is the most normalized and recommended choice (it avoids redundant columns while keeping data separated). Alternatively, you could use Single Table if you prefer simpler database setup (with a discriminator column to distinguish user types).

Create an abstract base entity with all shared fields, and implement Spring Security's UserDetails interface to integrate with authentication:

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
@Table(name = "users")
public abstract class User implements UserDetails {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String username;

    @Column(nullable = false)
    private String password;

    // Link to your Roles entity (many-to-many association)
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles;

    // Constructors, getters, and setters

    // Implement UserDetails methods for Spring Security
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return roles.stream()
                .map(role -> new SimpleGrantedAuthority(role.getName()))
                .collect(Collectors.toList());
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

Extend the base User entity for each user type, adding only their unique fields:

@Entity
@Table(name = "admins")
public class Admin extends User {
    // No extra fields needed—inherits all from User
}

@Entity
@Table(name = "clients")
public class Client extends User {
    @Column(nullable = false)
    private String email;

    @Column(nullable = false)
    private String phoneNumber;

    // Constructors, getters, and setters
}

You only need one repository for the base User entity—Spring Data JPA automatically supports querying across inherited entities:

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
}

If you need Admin/Client-specific queries later, you can create sub-repositories like AdminRepository extends UserRepository—Spring Data will handle this seamlessly.

Implement a custom UserDetailsService to fetch users from your repository, and configure password encoding:

@Service
public class CustomUserDetailsService implements UserDetailsService {

    private final UserRepository userRepository;

    public CustomUserDetailsService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        return userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("User not found: " + username));
    }
}

@Configuration
public class SecurityConfig {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    // Add HttpSecurity configuration here to define role-based access rules
    // Example: .authorizeHttpRequests(auth -> auth.requestMatchers("/admin/**").hasRole("ADMIN"))
}

• Strategy Tradeoffs: If you want simpler database setup over normalization, switch to InheritanceType.SINGLE_TABLE (add @DiscriminatorColumn(name = "user_type") to the base User entity).
• Role Handling: Ensure your Role entity uses Spring Security's standard naming convention (e.g., "ROLE_ADMIN", "ROLE_CLIENT") for seamless authority checks.
• Data Access: When saving users, you can directly persist Admin or Client instances—Hibernate will handle inserting into the correct tables.

内容的提问来源于stack exchange，提问作者dEs12ZER