1

sws

2022-11-26 ab849f796bdc17236a95ea5fe5c166fb8f24a75c

 src/main/java/com/lf/server/service/sys/TokenService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,281 @@
package com.lf.server.service.sys;

import com.lf.server.entity.all.SettingData;
import com.lf.server.entity.sys.LoginEntity;
import com.lf.server.entity.sys.TokenEntity;
import com.lf.server.entity.sys.UserEntity;
import com.lf.server.entity.all.RedisCacheKey;
import com.lf.server.helper.StringHelper;
import com.lf.server.helper.WebHelper;
import com.lf.server.mapper.sys.TokenMapper;
import com.lf.server.service.all.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * ä»¤ç‰Œè¡¨
 * @author sws
 * @date 2022-09-28
 */

@Service
public class TokenService implements TokenMapper {
    @Autowired
    TokenMapper tokenMapper;

    @Autowired
    UserService usersService;

    @Autowired
    LoginService loginService;

    @Autowired
    RedisService redisService;

    @Override
    public Integer selectCount(String name, Integer type) {
        return tokenMapper.selectCount(name, type);
    }

    @Override
    public List<TokenEntity> selectByPage(String name, Integer type, Integer limit, Integer offset) {
        return tokenMapper.selectByPage(name, type, limit, offset);
    }

    @Override
    public TokenEntity selectToken(int id) {
        return tokenMapper.selectToken(id);
    }

    @Override
    public TokenEntity selectOneByToken(String token) {
        return tokenMapper.selectOneByToken(token);
    }

    @Override
    public List<TokenEntity> selectTokenAll() {
        return tokenMapper.selectTokenAll();
    }

    @Override
    public Integer insertToken(TokenEntity tokenEntity) {
        return tokenMapper.insertToken(tokenEntity);
    }

    @Override
    public Integer insertTokens(List<TokenEntity> tokenEntity) {
        return tokenMapper.insertTokens(tokenEntity);
    }

    @Override
    public Integer deleteToken(int id) {
        return tokenMapper.deleteToken(id);
    }

    @Override
    public Integer deleteTokens(List<Integer> ids) {
        return tokenMapper.deleteTokens(ids);
    }

    @Override
    public Integer updateToken(TokenEntity tokenEntity) {
        return tokenMapper.updateToken(tokenEntity);
    }

    @Override
    public Integer updateTokenExpire(TokenEntity tokenEntity) {
        return tokenMapper.updateTokenExpire(tokenEntity);
    }

    /**
     * èŽ·å–新的令牌实体类
     */
    public TokenEntity getNewToken(UserEntity ue, HttpServletRequest req) {
        TokenEntity te = new TokenEntity();
        te.setToken(WebHelper.getGuid());
        te.setDuration(SettingData.TOKEN_EXPIRE);
        te.setExpire(WebHelper.getTimestamp(SettingData.TOKEN_EXPIRE));
        te.setType(0);
        te.setIp(WebHelper.getIpAddress(req));
        te.setCreateUser(ue.getId());
        te.setUname(ue.getUname());

        return te;
    }

    /**
     * æ˜¯/否登录
     */
    public Boolean isLogin(HttpServletRequest req, HttpServletResponse res) {
        String token = WebHelper.getToken(req);
        if (StringHelper.isNull(token)) {
            return false;
        }

        // redis
        String tokenKey = RedisCacheKey.signTokenKey(token);
        if (redisService.hasKey(tokenKey)) {
            return true;
        }

        // db
        TokenEntity te = selectOneByToken(token);
        if (te != null) {
            redisService.put(tokenKey, te, te.getDuration(), TimeUnit.MINUTES);
            return true;
        }

        return false;
    }

    /**
     * ç™»å‡º
     */
    public Boolean logout(String token, HttpServletRequest req, HttpServletResponse res) {
        TokenEntity te = getEntityByToken(token);
        if (te == null) {
            return false;
        }

        // æ¸…除Cookie
        WebHelper.deleteCookies(req, res);

        // èŽ·å–当前用户
        UserEntity ue = getCurrentUser(req);
        if (ue == null) {
            return false;
        }

        // æ¸…除缓存
        String tokenKey = RedisCacheKey.signTokenKey(token);
        if (redisService.hasKey(tokenKey)) {
            redisService.delete(tokenKey);
        }
        String userKey = RedisCacheKey.signUserKey(te.getToken());
        if (redisService.hasKey(userKey)) {
            redisService.delete(userKey);
        }

        // db，设置令牌过期
        te.setUpdateUser(ue.getId());
        Integer rows = updateTokenExpire(te);
        if (rows == 0) {
            return false;
        }

        // å†™æ—¥å¿—
        LoginEntity le = loginService.getNewLogin(ue.getId(), 1, 3, 1, req);
        rows = loginService.insertLogin(le);

        return rows > 0;
    }

    /**
     * æ ¹æ®ä»¤ç‰ŒèŽ·å–实体
     */
    public TokenEntity getEntityByToken(String token) {
        if (StringHelper.isNull(token)) {
            return null;
        }

        String tokenKey = RedisCacheKey.signTokenKey(token);

        // redis
        Object obj = redisService.get(tokenKey);
        if (obj instanceof TokenEntity) {
            return (TokenEntity) obj;
        }

        // db
        TokenEntity te = selectOneByToken(token);
        if (te != null) {
            redisService.put(tokenKey, te, te.getDuration(), TimeUnit.MINUTES);
        }

        return te;
    }

    /**
     * ä¿å­˜token
     */
    public void saveToken(UserEntity ue, TokenEntity te, HttpServletRequest req, HttpServletResponse res) {
        // ä¿å­˜è‡³Cookie
        WebHelper.saveToken2Cookie(te.getToken(), req, res);

        // ä»¤ç‰Œä¿å­˜è‡³Redis
        String tokenKey = RedisCacheKey.signTokenKey(te.getToken());
        redisService.put(tokenKey, te, te.getDuration(), TimeUnit.MINUTES);

        String userKey = RedisCacheKey.signUserKey(te.getToken());
        ue.setBak(StringHelper.YMDHMS_FORMAT.format(new Date()));
        redisService.put(userKey, ue, te.getDuration(), TimeUnit.MINUTES);
    }

    /**
     * èŽ·å–当前用户
     */
    public UserEntity getCurrentUser(HttpServletRequest req) {
        String token = WebHelper.getToken(req);
        if (StringHelper.isNull(token)) {
            return null;
        }

        String userKey = RedisCacheKey.signUserKey(token);

        // redis
        Object obj = redisService.get(userKey);
        if (obj instanceof UserEntity) {
            return (UserEntity) obj;
        }

        // db
        UserEntity ue = usersService.selectByToken(token);
        if (ue != null) {
            TokenEntity te = getEntityByToken(token);
            if (te != null) {
                redisService.put(userKey, ue, te.getDuration(), TimeUnit.MINUTES);
            }
        }

        return ue;
    }

    /**
     * è®¾ç½®å¯†ç é”™è¯¯ç¼“å­˜
     */
    public void setPwdErrCache(UserEntity ue) {
        String key = RedisCacheKey.signPwdError(ue.getUid());
        Object objCount = redisService.get(key);

        int count = objCount == null ? 1 : (int) objCount + 1;
        redisService.put(key, count, SettingData.PWD_ERR_TIME, TimeUnit.MINUTES);

        // è®°å½•æ—¥å¿—
        HttpServletRequest req = WebHelper.getRequest();
        LoginEntity le = loginService.getNewLogin(ue.getId(), 1, 1, 0, req);
        le.setDescr("密码不正确");
        loginService.insertLogin(le);

        if (count >= SettingData.PWD_ERR_COUNT) {
            String token = WebHelper.getToken(req);
            HttpServletResponse res = WebHelper.getResponse();
            logout(token, req, res);
        }
    }

    /**
     * ç”¨æˆ·ID是/否禁用
     */
    public boolean isUidDisable(UserEntity ue) {
        String key = RedisCacheKey.signPwdError(ue.getUid());
        Object objCount = redisService.get(key);

        return objCount != null && (int) objCount >= SettingData.PWD_ERR_COUNT;
    }
}