支持的认证方式有：

  • 账号和密码认证
  • 手机号加验证码认证
  • 微信扫码认证

认证的流程如下图：

要点解析：

AuthenticationManager 会委托 DaoAuthenticationProvider 进行认证，该类中的方法会校验从 loadUserByUsername() 返回的用户信息中的密码。我们项目中只有一种需要进行密码校验，所以我们需要自定义 DaoAuthenticationProvider，自己进行密码校验工作。

DaoAuthenticationProvider 会调用 UserDetailsService 的 loadUserByUsername方法，去获取 UserDetails 对象。我们的用户信息都存放在数据库，所以这里需要自定义 UserDetailsService

此外，因为username为单一对象，所以我们在传入username时，使用JSON数据，在后端使用JSON工具将其转为对象，从对象中获取登陆信息进行校验。

注意到第 6 步会返回一个 UserDetails，其中的username属性，会被放到JWT的数据部分，为了能让JWT携带更多的用户信息，在设置username属性时，可以设置为用户的JSON字符串。

前端请求

使用密码获取Token时，前端请求链接如需下：

http://127.0.0.1:63010/auth/oauth/token?client_id=XcWebApp&client_secret=XcWebApp&grant_type=password&username={"username":"t1", "password":"111111","authType":"password","checkcode": "4WHU","checkcodekey": "checkcode:f2f2a238515e4c1a937fce77ab46bde3"}

参数解释：其中的username即为JSON字符串，包含了登录所需信息

client_id:XcWebApp
client_secret:XcWebApp
grant_type:password
username:{"username":"t1", "password":"111111","authType":"password","checkcode": "4WHU","checkcodekey": "checkcode:f2f2a238515e4c1a937fce77ab46bde3"}

项目中有两个前端项目，他们都会从本地cookie中获取登录时保存的JWT信息，这时要注意两个项目的域名。门户网站的域名为: www.51xuecheng.cn，管理网站的域名为: teacher.51xuecheng.cn，如果想让两个网站共享cookie，在保存cookie时域要设置到二级域名：.51xuecheng.cn。就先下面这样：

实体类

接受登陆参数的AuthParamDTO

AuthParamDTO
@Data
public class AuthParamDTO {
    /**
     * 用户名
     */
    private String username;

    /**
     * 密码
     */
    private String password;

    /**
     * 手机号
     */
    private String cellphone;

    /**
     * 验证码
     */
    private String checkcode;

    /**
     * 验证码key
     */
    private String checkcodekey;

    /**
     * 认证的类型 password 或 sms:短信模式
     */
    private String authType;

    /**
     * 附加数据
     */
    private Map<String, Object> payload = new HashMap<>();
}

保存到UserDetails中的信息

这里继承了XcUser，而不是直接使用。如果以后想添加别的内容可以直接在XcUserExt中添加。

@Data
@EqualsAndHashCode(callSuper = true)
public class XcUserExt extends XcUser {
}

自定义DaoAuthenticationProvider

我们项目中只有一种需要进行密码校验，所以我们需要自定义 DaoAuthenticationProvider，自己进行校验工作。

在auth.config包下创建 DaoAuthenticationProviderCustom 类，继承 DaoAuthenticationProvider，重写其中的密码校验方法，置空即可。

注意UserDetailsService引入我们自己定义的

DaoAuthenticationProviderCustom
import com.swx.ucenter.service.UserDetailsService;
/**
 * 重写DaoAuthenticationProvider校验密码方式
 * 有些校验方式不需要密码
 */
@Component
public class DaoAuthenticationProviderCustom extends DaoAuthenticationProvider {

    @Autowired
    public void setUserDetailsService(UserDetailsService userDetailsService) {
        super.setUserDetailsService(userDetailsService);
    }

    @Override
    protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
        
    }
}

统一认证校验Service

针对不同方式的校验（账户+密码、手机+验证码、微信扫码），使用策略模式，定义统一认证校验Service接口，并给予不同的实现类。

校验接口定义

在ucenter.service包下定义统一认证的接口

/**
 * 统一认证接口
 */
public interface AuthService {

    /**
     * 认证方法
     * @param dto 认证参数
     * @return XcUserExt
     */
    public XcUserExt execute(AuthParamDTO dto);
}

账户密码实现类

给该Bean的名称为 password_authService，其中password为认证方式，由前端传入，后面为固定字符串_authService，通过拼接方式可以拿到指定的BeanName

这里通过Feign远程调用了验证码微服务提供的校验方法，完成验证码校验。

CheckCodeClient
/**
 * 远程调用校验验证码
 */
@FeignClient(value = "checkcode", fallbackFactory = CheckCodeClientFallbackFactory.class)
public interface CheckCodeClient {

    @PostMapping("/checkcode/verify")
    public Boolean verify(@RequestParam("key") String key, @RequestParam("code") String code);
}
CheckCodeClientFallbackFactory
@Slf4j
@Component
public class CheckCodeClientFallbackFactory implements FallbackFactory<CheckCodeClient> {
    /**
     * @param throwable
     * @return
     */
    @Override
    public CheckCodeClient create(Throwable throwable) {
       return (key, code) -> {
           log.error("远程调用校验验证码服务失败，熔断降级, key: {}, code: {}", key, code);
           return false;
       };
    }
}
PasswordAuthServiceImpl
/**
 * 密码认证方式实现类
 */
@Slf4j
@Service("password_authService")
public class PasswordAuthServiceImpl implements AuthService {
    private final XcUserService xcUserService;
    private final PasswordEncoder passwordEncoder;
    private final CheckCodeClient checkCodeClient;

    public PasswordAuthServiceImpl(XcUserService xcUserService, PasswordEncoder passwordEncoder, CheckCodeClient checkCodeClient) {
        this.xcUserService = xcUserService;
        this.passwordEncoder = passwordEncoder;
        this.checkCodeClient = checkCodeClient;
    }

    /**
     * 认证方法
     *
     * @param dto 认证参数
     * @return XcUserExt
     */
    @Override
    public XcUserExt execute(AuthParamDTO dto) {
        String username = dto.getUsername();

        // 校验验证码
        String key = dto.getCheckcodekey();
        String code = dto.getCheckcode();
        if (StringUtils.isEmpty(key) || StringUtils.isEmpty(code)) {
            log.debug("认证失败: 验证码参数不完整");
            throw new BadCredentialsException("验证码参数不完整");
        }

        // 远程调用校验验证码服务，检验
        Boolean verify = checkCodeClient.verify(key, code);
        if (!verify) {
            log.debug("认证失败: 验证码不合法");
            throw new BadCredentialsException("验证码不合法");
        }
        // 查询数据库
        XcUser dbXcUser = Optional.ofNullable(xcUserService.getOne(Wrappers.<XcUser>lambdaQuery().eq(XcUser::getUsername, username)))
                .orElseThrow(() -> new UsernameNotFoundException("账号不存在"));
        //dbXcUser.getStatus()

        // 检验密码
        String password = dbXcUser.getPassword();
        if (!passwordEncoder.matches(dto.getPassword(), password)) {
            log.debug("认证失败: 密码错误");
            throw new BadCredentialsException("密码错误");
        }

        XcUserExt xcUserExt = new XcUserExt();
        BeanUtils.copyProperties(dbXcUser, xcUserExt);
        return xcUserExt;
    }
}

微信登录实现类

/**
 * 微信扫码认证方式
 */
@Slf4j
@RefreshScope
@Service("wx_authService")
public class WxAuthServiceImpl implements AuthService {

    private final XcUserService xcUserService;

    public WxAuthServiceImpl(XcUserService xcUserService) {
        this.xcUserService = xcUserService;
    }

    /**
     * 认证方法
     *
     * @param dto 认证参数
     * @return XcUserExt
     */
    @Override
    public XcUserExt execute(AuthParamDTO dto) {
        String username = dto.getUsername();
        if (StringUtils.isEmpty(username)) {
            throw new BizException(ResultCodeEnum.PARAM_INVALID);
        }
        // 查询数据库
        XcUser xcUser = xcUserService.getOne(Wrappers.<XcUser>lambdaQuery().eq(XcUser::getUsername, username));
        if (xcUser == null) {
            throw new BizException(ResultCodeEnum.DATA_NOT_EXIST);
        }
        XcUserExt xcUserExt = new XcUserExt();
        BeanUtils.copyProperties(xcUser, xcUserExt);
        return xcUserExt;
    }
}

自定义UserDetailsService

定义 UserDetailsService，继承Spring Security的 UserDetailsService，实现 loadUserByUsername 方法

UserDetailsService
public interface UserDetailsService extends org.springframework.security.core.userdetails.UserDetailsService {

    /**
     * 根据账号获取用户对象，获取不到直接抛异常
     *
     * @param account 账号
     * @return 用户完整信息
     */
    @Override
    UserDetails loadUserByUsername(String account) throws UsernameNotFoundException;
}

在impl包下实现该接口，传入的account参数，是从前端来的JSON字符对象，使用JSON工具将其转为 AuthParamDTO 对象：

  1. 以认证方式(AuthType)拼接beanName的方式获取指定的检验实现类，通过ApplicationContext获取到实现类对象，调用其中的 execute 方法完成校验。
  2. 将返回的用户信息转为JSON字符串，将其放到 UserDetails 中的 username 中，方便放到JWT的数据部分。
/**
 * 实现自定义UserDetailsService
 */
@Slf4j
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

   private final ApplicationContext applicationContext;

    public UserDetailsServiceImpl(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    /**
     * 根据账号获取用户对象，获取不到直接抛异常
     *
     * @param account 账号
     * @return 用户完整信息
     */
    @Override
    public UserDetails loadUserByUsername(String account) throws UsernameNotFoundException {
        AuthParamDTO authParamDTO = null;
        try {
            authParamDTO = JSON.parseObject(account, AuthParamDTO.class);
        } catch (Exception e) {
            throw new RuntimeException("认证请求参数不符合要求");
        }

        String authType = authParamDTO.getAuthType();
        if (StringUtils.isEmpty(authType)) {
            throw new RuntimeException("未指定认证方式");
        }
        String beanName = authType + "_authService";

        // 根据认证类型从spring容器中取出指定Bean
        AuthService authService = applicationContext.getBean(beanName, AuthService.class);
        // 调用统一execute方法完成认证
        XcUserExt xcUserExt = authService.execute(authParamDTO);

        return getUserPrincipal(xcUserExt);
    }

    /**
     * 查询用户信息
     * @param xcUserExt 用户信息
     * @return UserDetails
     */
    private UserDetails getUserPrincipal(XcUserExt xcUserExt) {
        String password = xcUserExt.getPassword();
        // 权限
        String[] authorities = {"test"};
        // 转JSON
        xcUserExt.setPassword(null);
        String userJson = JSON.toJSONString(xcUserExt);

        // 封装 UserDetails 对象
        return User.withUsername(userJson)
                .password(password)
                .authorities(authorities).build();
    }
}

接口测试

获取Token

用户名+密码方式获取Token

http://127.0.0.1:63010/auth/oauth/token?client_id=XcWebApp&client_secret=XcWebApp&grant_type=password&username={"username":"t1", "password":"111111","authType":"password"}

参数：

{
	"client_id": "XcWebApp",
	"client_secret": "XcWebApp",
	"grant_type": "password",
	"username": "{\"username\":\"t1\", \"password\":\"111111\",\"authType\":\"password\"}"
}
  • client_id: 客户端密钥
  • client_secret: 客户端密匙
  • grant_type: 认证方式
  • username: 登陆参数

集成微信扫码登录

网站应用微信登录开发获取access_token流程如下：

  1. 第三方发起微信授权登录请求，微信用户允许授权第三方应用后，微信会拉起应用或重定向到第三方网站，并且带上授权临时票据code参数；
  2. 通过code参数加上AppID和AppSecret等，通过API换取access_token；
  3. 通过access_token进行接口调用，获取用户基本数据资源或帮助用户实现基本操作。

请求code的参数如下：

self_redirect:true,
id:"login_container", 
appid: "wxed9954c01bb89b47", 
scope: "snsapi_login", 
redirect_uri: "http://localhost:8160/api/auth/wxLogin",
state: token,
style: "",
href: ""

微信扫码回调接口

在auth.controller包下创建 WxLoginController

WxLoginController
@Slf4j
@Controller
public class WxLoginController {

    private final String REDIRECT_URL = "redirect:http://www.51xuecheng.cn/sign.html?username=%s&authType=wx";
    private final WxAuthService wxAuthService;

    public WxLoginController(WxAuthService wxAuthService) {
        this.wxAuthService = wxAuthService;
    }

    @RequestMapping("/wxLogin")
    public String wxLogin(String code, String state) {
        log.debug("微信扫码回调, code: {}, state: {}", code, state);
        if (StringUtils.isEmpty(code)) {
            throw new RuntimeException("无code参数");
        }
        XcUser xcUser = wxAuthService.wxAuth(code);
        String username = xcUser.getUsername();
        return String.format(REDIRECT_URL, username);
    }

}

请求令牌方法

在ucenter.service下定义该方法的接口 WxAuthService，具体流程如下：

  • 使用 code、appid、secret等参数去请求 access_token
  • 使用 access_token 获取微信用户的基本信息
  • 根据基本信息中的 unionid（用户在授权网站的唯一ID），判断微信用户是否注册，如果注册返回用户信息；否则将用户数据保存到项目数据库。
WxAuthService
/**
 * 微信扫码接口
 */
public interface WxAuthService {

    /**
     * 微信扫码认证，携带令牌查询用户信息、保存到自己数据库
     *
     * @param code code
     * @return com.swx.ucenter.model.po.XcUser 用户信息
     */
    public XcUser wxAuth(String code);

}

实现放在 WxAuthServiceImpl 类中，添加实现父类 WxAuthService

WxAuthServiceImpl
/**
 * 微信扫码认证方式
 */
@Slf4j
@RefreshScope
@Service("wx_authService")
public class WxAuthServiceImpl implements AuthService, WxAuthService {

    @Value("${wechat.appid}")
    private String appid;
    @Value("${wechat.secret}")
    private String secret;
    private final RestTemplate restTemplate;
    private final XcUserService xcUserService;
    private final XcUserRoleService xcUserRoleService;
    private final TransactionTemplate transactionTemplate;

    public WxAuthServiceImpl(RestTemplate restTemplate, XcUserService xcUserService,
                             XcUserRoleService xcUserRoleService, TransactionTemplate transactionTemplate) {
        this.restTemplate = restTemplate;
        this.xcUserService = xcUserService;
        this.xcUserRoleService = xcUserRoleService;
        this.transactionTemplate = transactionTemplate;
    }

    /**
     * 认证方法
     *
     * @param dto 认证参数
     * @return XcUserExt
     */
    @Override
    public XcUserExt execute(AuthParamDTO dto) {
        String username = dto.getUsername();
        if (StringUtils.isEmpty(username)) {
            throw new BizException(ResultCodeEnum.PARAM_INVALID);
        }
        // 查询数据库
        XcUser xcUser = xcUserService.getOne(Wrappers.<XcUser>lambdaQuery().eq(XcUser::getUsername, username));
        if (xcUser == null) {
            throw new BizException(ResultCodeEnum.DATA_NOT_EXIST);
        }
        XcUserExt xcUserExt = new XcUserExt();
        BeanUtils.copyProperties(xcUser, xcUserExt);
        return xcUserExt;
    }

    /**
     * 微信扫码认证，申请令牌, 携带令牌查询用户信息、保存到自己数据库
     *
     * @param code code
     * @return com.swx.ucenter.model.po.XcUser 用户信息
     */
    @Override
    public XcUser wxAuth(String code) {
        // 申请令牌
        Map<String, String> accessTokenMap = getAccessToken(code);
        String accessToken = accessTokenMap.get("access_token");
        String openid = accessTokenMap.get("openid");
        // 携带令牌查询用户信息
        Map<String, String> userInfo = getUserInfo(accessToken, openid);
        // 保存到自己数据库
        return transactionTemplate.execute((status) -> {
            try {
                return addWxUser(userInfo);
            } catch (Exception e) {
                log.error("新增用户失败", e);
                status.setRollbackOnly();
            }
            return null;
        });
    }

    public XcUser addWxUser(Map<String, String> userInfoMap) {
        // unionid，用户在网站上的唯一ID。
        String unionid = userInfoMap.get("unionid");
        String nickname = userInfoMap.get("nickname");
        XcUser xcUser = xcUserService.getOne(Wrappers.<XcUser>lambdaQuery().eq(StringUtils.hasText(unionid), XcUser::getWxUnionid, unionid));
        // 已注册，直接返回
        if (xcUser != null) {
            return xcUser;
        }

        // 新增用户
        xcUser = new XcUser();
        xcUser.setId(UUID.randomUUID().toString());
        xcUser.setWxUnionid(unionid);
        xcUser.setPassword(unionid);
        xcUser.setUsername(unionid);
        xcUser.setNickname(nickname);
        xcUser.setName(nickname);
        xcUser.setCreateTime(LocalDateTime.now());
        xcUser.setUtype("101001");
        xcUser.setStatus("1");
        xcUser.setSex(userInfoMap.get("sex"));
        xcUserService.save(xcUser);

        // 新增用户角色信息
        XcUserRole xcUserRole = new XcUserRole();
        xcUserRole.setUserId(xcUser.getId());
        xcUserRole.setId(UUID.randomUUID().toString());
        xcUserRole.setRoleId("17"); // 17 表示学生角色
        xcUserRole.setCreateTime(LocalDateTime.now());
        xcUserRoleService.save(xcUserRole);

        return xcUser;
    }

    /**
     * 通过code获取access_token
     * https://api.weixin.qq.com/sns/oauth2/access_token?appid=APPID&secret=SECRET&code=CODE&grant_type=authorization_code
     * {
     * "access_token":"ACCESS_TOKEN",
     * "expires_in":7200,
     * "refresh_token":"REFRESH_TOKEN",
     * "openid":"OPENID",
     * "scope":"SCOPE",
     * "unionid": "o6_bmasdasdsad6_2sgVt7hMZOPfL"
     * }
     *
     * @param code code
     */
    private Map<String, String> getAccessToken(String code) {
        // 填充url
        String url = String.format(WxAuthURLConstants.ACCESS_TOKEN, appid, secret, code);
        // 发起请求
        ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.POST, null, String.class);
        String result = exchange.getBody();
        // 解析body
        return handleResult(result);
    }

    /**
     * 获取用户个人信息
     * https://api.weixin.qq.com/sns/userinfo?access_token=ACCESS_TOKEN&openid=OPENID
     * {
     * "openid":"OPENID",
     * "nickname":"NICKNAME",
     * "sex":1,
     * "province":"PROVINCE",
     * "city":"CITY",
     * "country":"COUNTRY",
     * "headimgurl": "https://thirdwx.qlogo.cn/mmopen/g3MonUZtNHkdmzicIlibx6iaFqAc56vxLSUfpb6n5WKSYVY0ChQKkiaJSgQ1dZuTOgvLLrhJbERQQ4eMsv84eavHiaiceqxibJxCfHe/0",
     * "privilege":[
     * "PRIVILEGE1",
     * "PRIVILEGE2"
     * ],
     * "unionid": " o6_bmasdasdsad6_2sgVt7hMZOPfL"
     * }
     *
     * @param accessToken 令牌
     * @param openId      用户的标识
     */
    private Map<String, String> getUserInfo(String accessToken, String openId) {
        // 填充url
        String url = String.format(WxAuthURLConstants.USER_INFO, accessToken, openId);
        // 发起请求
        ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.GET, null, String.class);
        String result = exchange.getBody();
        // 解析body
        return handleResult(result);
    }

    /**
     * 解析body
     *
     * @param body body
     */
    private Map<String, String> handleResult(String body) {
        if (StringUtils.isEmpty(body)) {
            log.error("请求access_token出错, body为空");
            throw new BizException("请求access_token出错");
        }
        String body_utf8 = new String(body.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8);
        // 将result转为Map
        Map<String, String> map = JSON.parseObject(body_utf8, new TypeReference<HashMap<String, String>>() {});
        // 错误判断
        if (StringUtils.hasText(map.get("errcode"))) {
            String errmsg = map.get("errmsg");
            String errcode = map.get("errcode");
            log.error("请求access_token出错, errcode: {}, errmsg: {}", errcode, errmsg);
            throw new BizException(errmsg);
        }
        return map;
    }
}

快来参与讨论吧~