统计用户在线时长(Redis、web-socket)

小黑luck

已于 2024-08-20 10:33:44 修改

阅读量1.9k

点赞数 52

于 2024-08-20 10:29:06 首次发布

本文链接：https://blog.csdn.net/weixin_48904737/article/details/141347863

版权

所有方案均基于用户异常下线。非正常调用登出API下线

方案一

心跳机制：用户调用登陆API后，持续向服务端发送心跳，向服务端告知自己健康。等服务端x分钟没有收到客户端的心跳。则视为用户下线，记录下线时间。

实现：基于Redis的 zset特性

用户调用登陆API后，将用户的登录时间记录在LOGIN_KEY

客户端启用心跳(调用心跳API)，记录HEART_KEY

服务端启动轮询任务：

1.通过 zset.rangeByScore 查询x分钟以前数据

2.取出用户最新心跳时间(可能在x分钟内再次有了心跳，所以要取最新的)

3.计算最后心跳时间和当前时间间隔，如果超过x分钟，则为离线

4.如果离线，调用 logout,并计算用户时长，将用户时长记录在 ONLINE_KEY

@Slf4j
@Component
public class OnlineService {
    /**
     * 登陆key
     */
    private static final String LOGIN_KEY = "online:login";
    /**
     * 在线时长
     */
    private static final String ONLINE_KEY = "online:live";
    /**
     * 心跳
     */
    private static final String HEART_KEY = "online:heart";

    //默认4分钟判定为离线
    private static final Integer DEAD_LINE = 4*60;

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    private ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();

    /**
     * 退出
     *
     * @param userId
     */
    public void login(String userId) {
        redisTemplate.opsForHash().putIfAbsent(LOGIN_KEY, userId, System.currentTimeMillis());
    }

    public void loginOut(String userId) {
        Object loginTime = redisTemplate.opsForHash().get(LOGIN_KEY, userId);
        if (loginTime != null) {
            doLogout(userId, loginTime, Instant.now());
            log.info("user {} is logout", userId);
        }
    }

    private void doLogout(String userId, Object loginTime, Instant lastTime) {
        Instant login = Instant.ofEpochMilli(Long.valueOf(loginTime.toString()));
        Duration liveDuration = Duration.between(login, lastTime);
        redisTemplate.opsForZSet().add(ONLINE_KEY, userId, liveDuration.getSeconds());
        //删除登陆记录
        redisTemplate.opsForHash().delete(LOGIN_KEY, userId);
    }


    /**
     * 心跳
     *
     * @param userId
     */
    public void heartBeat(String userId) {
        redisTemplate.opsForZSet().add(HEART_KEY, userId, System.currentTimeMillis());
    }

    /**
     * 获取用户登陆时长
     * @param userId
     * @return
     */
    public Long getOnlineDuration(String userId) {
        Double score = redisTemplate.opsForZSet().score(ONLINE_KEY, userId);
        return score != null ? score.longValue() : null;
    }


    @PostConstruct
    public void offlineJob() {
        //假定3分钟没有心跳就是离线
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            Instant now = Instant.now();
            log.info("online scan: {}",
                    LocalDateTime.ofInstant(now, ZoneId.systemDefault()).format(DateTimeFormatter.ofPattern("yyyy-MM" +
                            "-dd HH:mm:ss")));
            Instant deadline = now.minusSeconds(DEAD_LINE);
            //查询4分钟以前数据
            Set<Object> userListTmp = redisTemplate.opsForZSet().rangeByScore(HEART_KEY, 0, deadline.toEpochMilli());
            if (CollectionUtils.isEmpty(userListTmp)) {
                log.info("无记录");
                return;
            }
            //查询所有用户记录
            List<String> userList = userListTmp.stream().map(Object::toString).collect(Collectors.toList());
            for (String u : userList) {
                //取出用户最新心跳时间(可能在结束时间内再次有了心跳，所以要取最新的)
                Double score = redisTemplate.opsForZSet().score(HEART_KEY, u);
                if (score != null) {
                    //只要有一条记录，就和当前时间比较，是否超过结束时间分钟
                    Instant lastTime = Instant.ofEpochMilli(score.longValue());
                    Duration duration = Duration.between(lastTime, now);
                    if (duration.getSeconds() >= DEAD_LINE) {
                        //判定为离线
                        //取登陆时间   和用户最后一次心跳时间差即为登录时间
                        Object loginTime = redisTemplate.opsForHash().get(LOGIN_KEY, u);
                        if (loginTime != null) {
                            doLogout(u, loginTime, lastTime);
                            log.info("user {} is offline", u);
                        } else {
                            
                        }
                        //删除用户心跳记录
                        redisTemplate.opsForZSet().remove(HEART_KEY,u);
                    }
                }
            }
//每30秒轮询一次
        }, 5, 30, TimeUnit.SECONDS);
    }


}

@RestController
public class OnlineController {

    @Autowired
    private OnlineService onlineService;

    /**
     * 登陆
     * @param userId
     */
    @GetMapping("/online/{userId}")
    public String login(@PathVariable("userId") String userId) {
        onlineService.login(userId);
        return "success";
    }

    /**
     * 登出
     * @param userId
     */
    @GetMapping("/online/logout/{userId}")
    public String loginOut(@PathVariable("userId") String userId) {
        onlineService.loginOut(userId);
        return "success";
    }

    /**
     * 心跳API
     * @param userId
     */
    @GetMapping("/online/heart/{userId}")
    public String heart(@PathVariable("userId") String userId) {
        onlineService.heartBeat(userId);
        return "success";
    }


    /**
     * 获取用户在线时长
     */
    @GetMapping("/online/duration/{userId}")
    public Long duration(@PathVariable("userId") String userId) {
        return onlineService.getOnlineDuration(userId);
    }


}