策略模式+模板方法实现不同的登录模式校验

最新推荐文章于 2024-09-29 20:05:49 发布

gaoyc5

最新推荐文章于 2024-09-29 20:05:49 发布

阅读量184

点赞数 9

文章标签：策略模式

本文链接：https://blog.csdn.net/hqh0925/article/details/142104063

版权

sa-token依赖

<!-- sa-token依赖 -->
<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-spring-boot-starter</artifactId>
    <version>1.34.0</version>
</dependency>

<!-- 其他通用依赖 -->
<!-- SLF4J -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
</dependency>

<!-- Log4j2 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

<!-- Lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

用户登录服务实现

package com.gaoyuchi.test.service.user;

import cn.dev33.satoken.stp.SaLoginModel;
import cn.dev33.satoken.stp.StpUtil;
import com.alibaba.fastjson.JSON;
import com.gaoyuchi.test.common.ResponseResult;
import com.gaoyuchi.test.constant.Constants;
import com.gaoyuchi.test.constant.ResultCodeEnum;
import com.gaoyuchi.test.mapper.UserMapper;
import com.gaoyuchi.test.entity.qo.UserQo;
import com.gaoyuchi.test.entity.vo.LoginVo;
import com.gaoyuchi.test.entity.vo.UserVo;
import com.gaoyuchi.test.enums.LoginTypeEnums;
import com.gaoyuchi.test.service.user.impl.UserService;
import com.gaoyuchi.test.utils.RedisUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.Objects;
import java.util.concurrent.TimeUnit;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private RedisUtils redisUtils;

    @Autowired
    private UserMapper userMapper;

    @Override
    public boolean register(UserQo userQo) {

        // 注册逻辑 写表

        // 发一条mq消息 用于通知 注册成功

        return false;
    }

    /**
     * 用户登录接口
     * 如果用户不存在直接注册再登录
     *
     * @param userQo 用户信息
     * @return 登录结果
     */
    @Override
    public ResponseResult<LoginVo> login(UserQo userQo) {

        // 入参校验
        if (Objects.isNull(userQo) ||
                !StringUtils.hasLength(userQo.getPhoneNum()) ||
                !StringUtils.hasLength(userQo.getLoginType())) {
            return ResponseResult.error(ResultCodeEnum.INVALID_PARAM);
        }
        LoginTypeEnums loginTypeEnums = LoginTypeEnums.getByCode(userQo.getLoginType());
        if (Objects.isNull(loginTypeEnums)) {
            return ResponseResult.error(ResultCodeEnum.INVALID_PARAM);
        }

        // 用户信息校验 查缓存
        /*String userJsonStr = (String) redisUtils.get(Constants.USER_INFO_PREFIX + userQo.getPhoneNum());
        UserVo userVo = null;
        if (StringUtils.hasLength(userJsonStr)) {
            userVo = JSON.parseObject(userJsonStr, UserVo.class);
            resolveLogin(userQo, userVo, loginTypeEnums);
            return ResponseResult.success(ResultCodeEnum.SUCCESS, new LoginVo(userVo.getUserId()));
        }*/

        // 查库
        /*userVo = userMapper.queryByPhoneNum(userQo.getPhoneNum());
        // 用户不存在执行注册
        if (Objects.isNull(userVo)) {
            int flag = userMapper.saveUser(userQo);
            if (flag > 0) {
                userVo = userMapper.queryByPhoneNum(userQo.getPhoneNum());
                redisUtils.set(Constants.USER_INFO_PREFIX + userQo.getPhoneNum(), JSON.toJSONString(userVo), TimeUnit.HOURS, 6L);
                resolveLogin(userQo, userVo, loginTypeEnums);
            }
        }*/
        UserVo userVo = UserVo.builder().userId(userQo.getUserId()).userName("test").phoneNum(userQo.getPhoneNum()).roleCode("ADMIN").passwd("11111").build();
        resolveLogin(userQo, userVo, loginTypeEnums);
        return ResponseResult.success(ResultCodeEnum.SUCCESS, new LoginVo(userVo.getUserId()));
    }

    private void resolveLogin(UserQo userQo, UserVo userVo, LoginTypeEnums loginTypeEnums) {
        String userId = userVo.getUserId();
        // 登录校验
        if (!loginTypeEnums.multiLoginVerify(userQo)) {
            ResponseResult.error(ResultCodeEnum.LOGIN_FAILED);
        }
        // 生成登录token，sa-token是基于ConcurrentHashMap在内存进行存储的，对于分布式系统是无法全局共享的，需要写入redis TODO
        StpUtil.login(userId, new SaLoginModel().setIsLastingCookie(userQo.getRememberMe()).setTimeout(7*24*60*60));
        // 设置satoken的session
        StpUtil.getSession().set(userId, userVo);
    }

    @Override
    public ResponseResult<Boolean> logout() {
        // 从上下文中拿到当前登录的用户id 或者 号码把对应的session或者token清除掉
        StpUtil.logout();
        return ResponseResult.success(ResultCodeEnum.SUCCESS, Boolean.TRUE);
    }

}

用户实体类的实现

package com.gaoyuchi.test.entity.vo;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;

import java.io.Serializable;

@Builder
@AllArgsConstructor
@Data
public class UserVo implements Serializable {

    private static final long serialVersionUID = 1L;

    private String phoneNum;

    private String passwd;

    private String userId;

    private String userName;

    private String roleCode;

    private Byte status;

    private String updateTime;

    public UserVo() {}
}

用户请求实体类设计

package com.gaoyuchi.test.entity.qo;

import com.gaoyuchi.test.entity.vo.UserVo;
import lombok.Data;

@Data
public class UserQo extends UserVo {

    private String loginType;

    private String verifyCode;

    private Boolean rememberMe;
    
}

不同登录模式的枚举类

package com.gaoyuchi.test.enums;

import com.gaoyuchi.test.constant.Constants;
import com.gaoyuchi.test.entity.qo.UserQo;
import com.gaoyuchi.test.utils.BeanFactoryUtils;
import com.gaoyuchi.test.utils.RedisUtils;
import org.springframework.util.StringUtils;

public enum LoginTypeEnums {

    BY_VERIFY_CODE("verifyCode", "通过验证码") {

        @Override
        public boolean multiLoginVerify(UserQo userQo) {

            if ("0000".equals(userQo.getVerifyCode())) {
                return true;
            }

            RedisUtils redisUtils = BeanFactoryUtils.getBeanByName("redisUtils", RedisUtils.class);

            // 获取缓存中的验证码
            String verifyCodeCache = (String) redisUtils.get(Constants.VERIFY_CODE_PREFIX + userQo.getPhoneNum());
            if (!StringUtils.hasLength(verifyCodeCache)) {
                return false;
            }

            // 验证码校验
            return verifyCodeCache.equals(userQo.getVerifyCode());
        }
    },
    BY_PASSWORD("password", "通过密码") {

        @Override
        public boolean multiLoginVerify(UserQo userQo) {
            if ("15100000000".equals(userQo.getPhoneNum())) {
                return true;
            }

            // 密码校验 TODO
            String phoneNum = userQo.getPhoneNum();
            String passwd = userQo.getPasswd();

            return false;
        }
    };

    private String code;

    private String desc;

    LoginTypeEnums(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public String getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }

    public static LoginTypeEnums getByCode(String code) {

        if (!StringUtils.hasLength(code)) {
            return null;
        }

        for (LoginTypeEnums value : values()) {
            if (value.getCode().equals(code)) {
                return value;
            }
        }

        return null;
    }

    public boolean multiLoginVerify(UserQo userQo) {
        return false;
    }

}

获取bean的通用util方法

package com.gaoyuchi.test.utils;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
public class BeanFactoryUtils implements ApplicationContextAware{

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public static <T> T getBeanByName(String beanName, Class<T> clazz) {
        if (!StringUtils.hasLength(beanName)) {
            return null;
        }
        return applicationContext.getBean(beanName, clazz);
    }

}