05-多种认证方式

多种认证方式

统一认证入口

目前各大网站支持账号密码认证、手机验证码认证、扫码登录认证等多种认证方式,Spring Security框架也支持多样化的认证方案

• 账号和密码认证: 采用OAuth2协议的密码模式即可实现
• 手机号加验证码认证: 用户认证提交的是手机号和验证码并不是账号和密码
• 微信扫码认证: 基于OAuth2协议,目标网站会向微信服务器申请一个令牌,然后携带令牌去微信服务端查询用户信息,查询成功则用户在目标网站认证通过

第一步: 由于不同的认证提交方式的数据不一样如手机加验证码方式和账号加密码加验证码方式,所以我们需要创建一个DTO类用于接收各种认证参数

@Data
public class AuthParamsDto {
    // 用户名
    private String username; 
	// 域,用于扩展	
    private String password; 
	// 手机号
    private String cellphone;
	// 验证码
    private String checkcode;
	// 验证码对应的存储在Redis中的key
    private String checkcodekey;
	// 认证的类型,如password表示用户名密码模式类型,sms表示短信模式类型
    private String authType; 
	// 附加数据,不同认证类型可拥有不同的附加数据,如认证类型为短信时包含smsKey,另外所有认证都会包含clientId
    private Map<String, Object> payload = new HashMap<>();
}

第二步: 修改loadUserByUsername()方法,将用户提交的请求参数username的值改为JSON字符串,用来包含不同的认证方式所提交的各种参数

• 由DaoAuthenticationProvider调用我们自定义的UserDetailsService接口实现类UserDetailsImpl的loadUserByUsername()方法获取UserDetails用户信息

@Service
public class UserDetailsImpl implements UserDetailsService {
    @Autowired
    XcUserMapper xcUserMapper;
    /**
     * @param s AuthParamsDto类型的json数据
     * @return UserDetails
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
   		// 将包含认证参数的Json格式的字符串如`username={"username":"Kyle","authType":"password","password":"111111"}`转换为AuthParamsDto对象
        AuthParamsDto authParamsDto = null;
        try {
            authParamsDto = JSON.parseObject(s, AuthParamsDto.class);
        } catch (Exception e) {
            log.error("认证请求数据格式不对：{}", s);
            throw new RuntimeException("认证请求数据格式不对");
        }
        // 根据username去XcUser表中查询对应的用户信息
        String name = authParamsDto.getUsername();
        XcUser user = xcUserMapper.selectOne(new LambdaQueryWrapper<XcUser>().eq(XcUser::getUsername, name));
        // 返回空表示用户不存在，SpringSecurity会帮我们处理
        if (user == null) {
            return null;
        }
        // 取出数据库存储的密码
        String password = user.getPassword();
        user.setPassword(null);
        String userString = JSON.toJSONString(user);
        // 创建UserDetails对象并返回，注意这里的authorities必须指定
        return User.withUsername(userString).password(password).authorities("test").build();
    }
}

DaoAuthenticationProvider获取到UserDetails用户信息后会调用自身的additionalAuthenticationChecks()方法进行密码校验

• DaoAuthenticationProviderCustom类实现了DaoAuthenticationProvider接口并实现了additionalAuthenticationChecks()方法

protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
    if (authentication.getCredentials() == null) {
        this.logger.debug("Authentication failed: no credentials provided");
        throw new BadCredentialsException(this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
    } else {
        String presentedPassword = authentication.getCredentials().toString();
        if (!this.passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
            this.logger.debug("Authentication failed: password does not match stored value");
            throw new BadCredentialsException(this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
        }
    }
} 	

但是并不是所有的校验方式都需要密码,所以我们要自定义密码的校验逻辑

• 自定义DaoAuthenticationProviderCustom类继续DaoAuthenticationProviderCustom类然后重写additionalAuthenticationChecks方法

@Component
public class DaoAuthenticationProviderCustom extends DaoAuthenticationProvider {
    // 由于DaoAuthenticationProvider调用UserDetailsService，所以这里需要注入一个UserDetailsService接口的实现类
    @Autowired
    public void setUserDetailsService(UserDetailsService userDetailsService){
        super.setUserDetailsService(userDetailsService);
    }
    // 屏蔽密码对比，因为不是所有的认证方式都需要校验密码
    @Override
    protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
        // 里面啥也不写就不会校验密码了
    }
}

修改认证服务工程下的config/WebSecurityConfig类,使用我们自定义的DaoAuthenticationProviderCustom类

package com.xuecheng.auth.config;
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true,prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    DaoAuthenticationProviderCustom daoAuthenticationProviderCustom;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) {
        auth.authenticationProvider(daoAuthenticationProviderCustom);
    }
}

重启认证服务,测试申请令牌接口将传入的账号信息改为包含各种认证参数的JSON格式字符串

#### 密码模式
POST localhost:53070/auth/oauth/token?client_id=XcWebApp&client_secret=XcWebApp&grant_type=password&username={"username":"Kyle","authType":"password","password":"111111"}

自定义认证方式

有了认证参数对象AuthParamsDto,我们可以定义一个Service接口去进行各种方式的认证,通过Service接口的各种实现类来实现各种方式的认证

第一步: 定义用户信息,因为XcUser类对应的是数据库中的表后期不便修改,所以为了可扩展性定义一个XcUserExt类让其继承XcUser

@Data
public class XcUserExt extends XcUser {

}

第二步: 定义认证的AuthService接口

/**
 * 认证Service
 */
public interface AuthService {
    /**
     * 认证方法
     * @param authParamsDto 认证参数
     * @return  用户信息
     */
    XcUserExt execute(AuthParamsDto authParamsDto);
}

第三步: 定义AuthService接口的实现类PasswordAuthServiceImpl(实现密码认证)``WxAuthServiceImpl(扫码认证)和,依靠beanName区分不同的认证方式

@Service("password_authservice")
public class PasswordAuthServiceImpl implements AuthService {
    @Override
    public XcUserExt execute(AuthParamsDto authParamsDto) {
        return null;
    }
}
@Service("wx_authservice")// 微信扫码方式
public class WxAuthServiceImpl implements AuthService {

    @Override
    public XcUserExt execute(AuthParamsDto authParamsDto) {
        return null;
    }
}

第四步: 修改loadUserByUsername()方法,增加判断认证类型的逻辑

• 虽然不同的认证方式的认证逻辑不同,但最后都是调用AuthService接口实现类的execute方法,查询数据库中的用户信息并返回扩展的对象XcUserExt
• 由于所有的认证方式都会将查询得到的XcUserExt对象的信息封装到UserDetails对象中,所以我们可以将这一步抽取成一个方法

@Override
public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
    // 将包含认证参数的Json格式的字符串如`username={"username":"Kyle","authType":"password","password":"111111"}`转换为AuthParamsDto对象
    AuthParamsDto authParamsDto = null;
    try {
        authParamsDto = JSON.parseObject(s, AuthParamsDto.class);
    } catch (Exception e) {
        log.error("认证请求数据格式不对：{}", s);
        throw new RuntimeException("认证请求数据格式不对");
    }
    // 获取认证类型，beanName由认证类型和后缀组成,如password+_authservice=password_authservice
    String authType = authParamsDto.getAuthType();
    // 根据认证类型从Spring容器中取出对应的bean
    AuthService authService = applicationContext.getBean(authType + "_authservice", AuthService.class);
    // 不同认证方式的认证逻辑不同,但最后都是调用统一execute方法完成认证
    XcUserExt user = authService.execute(authParamsDto);
    // 封装xcUserExt用户信息为UserDetails,根据UserDetails对象生成令牌
    return getUserPrincipal(user);
}
// 查询用户的信息
public UserDetails getUserPrincipal(XcUserExt user) {
    // 设置权限
    String[] authorities = {"test"};
    // 取出数据库中用户的密码
    String password = user.getPassword();
    user.setPassword(null);
    String userJsonStr = JSON.toJSONString(user);
    // 创建UserDetails对象保存用户脱敏后的全部信息，注意这里的authorities必须指定,如果不加报`Cannot pass a null GrantedAuthority collection`错误
    UserDetails userDetails = User.withUsername(userJsonStr).password(password).authorities(authorities).build();
    // 返回UserDetails对象
    return userDetails;
}

第五步: 重启认证服务，测试申请令牌接口注意JSON数据中要带上authType

# 密码模式,账号密码正确,可以成功获取authType，并正确查询到用户信息
POST localhost:53070/auth/oauth/token?client_id=XcWebApp&client_secret=XcWebApp&grant_type=password&username={"username":"Kyle","password":"111111","authType":"password"}
# 测试密码错误的情况
POST localhost:53070/auth/oauth/token?client_id=XcWebApp&client_secret=XcWebApp&grant_type=password&username={"username":"Kyle","password":"111112","authType":"password"}
# 测试账号不存在的情况
POST localhost:53070/auth/oauth/token?client_id=XcWebApp&client_secret=XcWebApp&grant_type=password&username={"username":"Ky","password":"111112","authType":"password"}

密码认证具体实现

@Service("password_authservice")
public class PasswordAuthServiceImpl implements AuthService {
    @Autowired
    XcUserMapper xcUserMapper;
    @Autowired
    PasswordEncoder passwordEncoder;
    @Override
    public XcUserExt execute(AuthParamsDto authParamsDto) {
        // 1. 获取账号
        String username = authParamsDto.getUsername();
        // 2. 根据账号去数据库中查询用户是否存在
        XcUser xcUser = xcUserMapper.selectOne(new LambdaQueryWrapper<XcUser>().eq(XcUser::getUsername, username));
        // 3. 不存在抛异常
        if (xcUser == null) {
            throw new RuntimeException("账号不存在");
        }
        // 4. 校验密码
        // 4.1 获取用户输入的密码
        String passwordForm = authParamsDto.getPassword();
        // 4.2 获取数据库中存储的密码
        String passwordDb = xcUser.getPassword();
        // 4.3 比较密码
        boolean matches = passwordEncoder.matches(passwordForm, passwordDb);
        // 4.4 密码不匹配抛异常
        if (!matches) {
            throw new RuntimeException("账号或密码错误");
        }
        // 4.5 密码匹配将查询得到的xcUser对象中的数据封装到扩展的xcUserExt对象中并返回
        XcUserExt xcUserExt = new XcUserExt();
        BeanUtils.copyProperties(xcUser, xcUserExt);
        return xcUserExt;
    }
}