解决tokenService与userService循环调用

13693261870

2025-07-02 b3f851fe91664afe5f31e5dd2e5026c74e4ccec4

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

@@ -8,10 +8,11 @@
import com.lf.server.helper.StringHelper;
import com.lf.server.helper.WebHelper;
import com.lf.server.mapper.sys.TokenMapper;
import com.lf.server.mapper.sys.UserMapper;
import com.lf.server.service.all.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;
@@ -23,31 +24,30 @@
 * @author sws
 * @date 2022-09-28
 */

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

    @Autowired
    UserService usersService;
    @Resource
    UserMapper userMapper;

    @Autowired
    @Resource
    LoginService loginService;

    @Autowired
    @Resource
    RedisService redisService;

    @Override
    public Integer selectCount(String name, Integer type) {
        name = StringHelper.getLikeStr(name);
        name = StringHelper.getLikeUpperStr(name);

        return tokenMapper.selectCount(name, type);
    }

    @Override
    public List<TokenEntity> selectByPage(String name, Integer type, Integer limit, Integer offset) {
        name = StringHelper.getLikeStr(name);
        name = StringHelper.getLikeUpperStr(name);

        return tokenMapper.selectByPage(name, type, limit, offset);
    }
@@ -55,6 +55,16 @@
    @Override
    public TokenEntity selectToken(int id) {
        return tokenMapper.selectToken(id);
    }

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

    @Override
    public TokenEntity selectOneById(Integer id) {
        return tokenMapper.selectOneById(id);
    }

    @Override
@@ -79,11 +89,27 @@

    @Override
    public Integer deleteToken(int id) {
        TokenEntity entity = tokenMapper.selectToken(id);
        if (null == entity) {
            return 0;
        }

        clearCache(entity.getToken());

        return tokenMapper.deleteToken(id);
    }

    @Override
    public Integer deleteTokens(List<Integer> ids) {
        List<TokenEntity> list = tokenMapper.selectByIds(ids);
        if (null == list || list.isEmpty()) {
            return 0;
        }

        for (TokenEntity entity : list) {
            clearCache(entity.getToken());
        }

        return tokenMapper.deleteTokens(ids);
    }

@@ -94,6 +120,8 @@

    @Override
    public Integer updateTokenExpire(TokenEntity tokenEntity) {
        clearCache(tokenEntity.getToken());

        return tokenMapper.updateTokenExpire(tokenEntity);
    }

@@ -101,11 +129,18 @@
     * 获取新的令牌实体类
     */
    public TokenEntity getNewToken(UserEntity ue, HttpServletRequest req) {
        return getNewToken(0, SettingData.TOKEN_EXPIRE, ue, req);
    }

    /**
     * 获取新的令牌实体类
     */
    public TokenEntity getNewToken(Integer type, Integer min, 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.setDuration(min);
        te.setExpire(WebHelper.getTimestamp(min));
        te.setType(type);
        te.setIp(WebHelper.getIpAddress(req));
        te.setCreateUser(ue.getId());
        te.setUname(ue.getUname());
@@ -122,20 +157,9 @@
            return false;
        }

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

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

        return false;
        return null != te;
    }

    /**
@@ -143,7 +167,7 @@
     */
    public Boolean logout(String token, HttpServletRequest req, HttpServletResponse res) {
        TokenEntity te = getEntityByToken(token);
        if (te == null) {
        if (null == te) {
            return false;
        }

@@ -156,20 +180,10 @@
            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) {
        if (0 == rows) {
            return false;
        }

@@ -181,13 +195,19 @@
    }

    /**
     * 清除缓存
     */
    public void clearCache(String token) {
        String tokenKey = RedisCacheKey.signTokenKey(token);
        redisService.delete(tokenKey);
        String userKey = RedisCacheKey.signUserKey(token);
        redisService.delete(userKey);
    }

    /**
     * 根据令牌获取实体
     */
    public TokenEntity getEntityByToken(String token) {
        if (StringHelper.isNull(token)) {
            return null;
        }

        String tokenKey = RedisCacheKey.signTokenKey(token);

        // redis
@@ -198,8 +218,11 @@

        // db
        TokenEntity te = selectOneByToken(token);
        if (te != null) {
            redisService.put(tokenKey, te, te.getDuration(), TimeUnit.MINUTES);
        if (null != te) {
            long min = StringHelper.getMinuteDifference(te.getExpire());
            if (min > 0) {
                redisService.put(tokenKey, te, min, TimeUnit.MINUTES);
            }
        }

        return te;
@@ -226,25 +249,29 @@
     */
    public UserEntity getCurrentUser(HttpServletRequest req) {
        String token = WebHelper.getToken(req);

        return getUserByToken(token);
    }

    /**
     * 根据令牌获取用户
     */
    public UserEntity getUserByToken(String token) {
        if (StringHelper.isNull(token)) {
            return null;
        }

        String userKey = RedisCacheKey.signUserKey(token);

        // redis
        String userKey = RedisCacheKey.signUserKey(token);
        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);
            }
        UserEntity ue = userMapper.selectByToken(token);
        if (null != ue) {
            getEntityByToken(token);
        }

        return ue;
@@ -280,6 +307,6 @@
        String key = RedisCacheKey.signPwdError(ue.getUid());
        Object objCount = redisService.get(key);

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