java - 如何使用spring security对两种不同类型的用户进行身份验证？

Question

在我的 Spring Boot 应用程序中，我将有两种不同类型的用户，即

1. 管理员用户
2. 客户

这些用户将存储在两个不同的表中。 这两个表只有电子邮件 ID 是共同的。其他一切都会有所不同。

另外，没有。客户数量将非常庞大，例如 1 至 5 百万客户。另一方面，管理员用户很少，比如不到 10 个。因此有两个不同的表。

我想要两个不同的登录页面。一个位于/customer/login 供所有客户使用，另一个位于/admin/login 供所有管理员使用。登录详细信息应使用各自的表进行身份验证。登录时，客户应转到/customer/home，管理员应转到/admin/home。

注销时，客户应重定向到/customer/login，管理员应重定向到/admin/login

我正在使用 java 配置来实现 Spring 安全性。在 Spring Security 中如何做到这一点？

以下是我的单用户配置，可以正常工作。

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private AccessDecisionManager accessDecisionManager;

    @Autowired
    private ApplicationProperties applicationProperties;

    @Bean
    public Integer applicationSessionTimeout(){
        return applicationProperties.getSecurity().getSessionTimeout();
    }

    @Bean
    @Autowired
    public AccessDecisionManager accessDecisionManager(AccessDecisionVoterImpl accessDecisionVoter) {
        List<AccessDecisionVoter<?>> accessDecisionVoters = new ArrayList<AccessDecisionVoter<?>>();
        accessDecisionVoters.add(new WebExpressionVoter());
        accessDecisionVoters.add(new AuthenticatedVoter());
        accessDecisionVoters.add(accessDecisionVoter);
        UnanimousBased accessDecisionManager = new UnanimousBased(accessDecisionVoters);
        return accessDecisionManager;
    }

    @Override
    @Autowired
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder(){
        PasswordEncoder passwordEncoder = new PasswordEncoder();
        passwordEncoder.setStringDigester(stringDigester());
        return passwordEncoder;
    }

    @Bean
    public PooledStringDigester stringDigester() {
        PooledStringDigester psd = new PooledStringDigester();

        psd.setPoolSize(2);
        psd.setAlgorithm("SHA-256");
        psd.setIterations(1000);
        psd.setSaltSizeBytes(16);
        psd.setSaltGenerator(randomSaltGenerator());

        return psd;
    }

    @Bean
    public RandomSaltGenerator randomSaltGenerator() {
        RandomSaltGenerator randomSaltGenerator = new RandomSaltGenerator();
        return randomSaltGenerator;
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring()
                .antMatchers("/static/**")
                .antMatchers("/i18n/**");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .exceptionHandling().
                accessDeniedPage("/accessDenied")
                .and()
            .authorizeRequests()
                .accessDecisionManager(accessDecisionManager)
                .antMatchers("/login**").permitAll()
                .antMatchers("/error**").permitAll()
                .antMatchers("/checkLogin**").permitAll()
                .anyRequest().fullyAuthenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .loginProcessingUrl("/checkLogin")
                .defaultSuccessUrl("/home?menu=homeMenuOption")
                .failureUrl("/login?login_error=1")
                .usernameParameter("username")
                .passwordParameter("password")
                .permitAll()
                .and()
            .logout()
                .logoutUrl("/logout")
                .logoutSuccessHandler(new LogoutSuccessHandlerImpl())
                .deleteCookies("JSESSIONID")
                .invalidateHttpSession(true)
                .permitAll()
                .and()
            .headers()
                .frameOptions()
                .disable()
            .and()
                .sessionManagement()
                .maximumSessions(1);
    }

}

下面是我的 UserDetailsS​​ervice，它检查数据库是否进行正确的身份验证。

@Service("userDetailsService")
public class UserDetailsService implements org.springframework.security.core.userdetails.UserDetailsService {

    private static final Logger log = LoggerFactory.getLogger(UserDetailsService.class);

    @Autowired
    private UserService userService;

    @Autowired
    private ModuleService moduleService;

    @Override
    public UserDetails loadUserByUsername(final String userName) throws UsernameNotFoundException, DataAccessException {
        log.debug("Authenticating : {}", userName);

        SecurityUser securityUser = null;

        try {

            User user = userService.findUserByEmail(userName);

            if (user != null) {
                log.debug("User with the username {} FOUND ", userName);
                securityUser = new SecurityUser(user.getEmail(), user.getPassword(), true, true, true, true, getGrantedAuthorities(user.getRole().getId()));
                securityUser.setUser(user);
            } else {
                log.debug("User with the username {}  NOT FOUND", userName);
                throw new UsernameNotFoundException("Username not found.");
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }

        return securityUser;
    }

    private List<GrantedAuthority> getGrantedAuthorities(Long roleId) {
        log.debug("Populating user authorities");

        List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
        List<Module> allModules = moduleService.findAllModules();
        Map<Long, Module> moduleMap = new HashMap<Long, Module>();

        for(Module module : allModules){
            moduleMap.put(module.getModuleId(), module);
        }

        List<ModuleOperation> moduleOperationList = moduleService.findModuleOperationsByRoleId(roleId);

        for (ModuleOperation moduleOperation : moduleOperationList) {
            moduleOperation.setModuleName(moduleMap.get(moduleOperation.getModuleId()).getModuleName());
            authorities.add(moduleOperation);
        }

        return authorities;
    }
}

Answer 1

为 Spring 安全性设置不同的登录页面确实是一个坏主意，因为这不是它设计的方式。您将在定义要使用的身份验证入口点时遇到麻烦，并且需要大量的沸点板。根据您的其他要求，我建议您采用以下方式:

• 使用一个登录页面和一个 AuthenticationManager(默认的 ProviderManager 就可以了)
• 使用两个不同的 AuthenticationProvider 配置它，两者都是 DaoAuthenticationProvider，每个都指向 2 个用户表之一
• 将这些提供程序配置为自动设置不同的角色，ROLE_ADMIN 表示前者将处理管理员，ROLE_USER 表示后者

这样您就可以完全依赖 SpringSecurity 基础设施，只需进行尽可能少的修改即可满足您的要求。

但是您还应该想知道您是否真的需要不同的数据库。至少对于主要提供商(Oracle、PostgreSQL、MariaDB...)来说，记录中包含许多空列没有坏处。恕我直言，您应该进行认真的分析来比较这两种方式，无论是一个表(对于 Spring Security 设置更简单)还是两个表。