SpringSession会话管理

一. Session详情实体类

package cn.zzzykj.session.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.util.Date;

/**
 * @author TheEnd
 */
@Data
@Accessors(chain = true)
@NoArgsConstructor
@AllArgsConstructor
public class SessionInfoVO {

    private String id;
    private String sessionId;
    private String name;
    private Date creationTime;
    private Date lastAccessedTime;

}

二. 会话管理器

1. 创建会话管理器接口

package cn.zzzykj.session;

import java.util.List;

/**
 * @author TheEnd
 */
public interface ISessionManager {

    /**
     * 获取所有会话信息
     * @return 会话信息列表
     */
    List<SessionInfoVO> getAllSessionInfo();

    /**
     * 使指定会话失效
     * @param sessionId 会话id
     */
    void invalidateSession(String sessionId);

}

2.编写实现类并注入到Spring容器中

package cn.zzzykj.session;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextImpl;
import org.springframework.session.Session;
import org.springframework.session.SessionRepository;
import org.springframework.session.data.redis.RedisIndexedSessionRepository;
import org.springframework.session.jdbc.JdbcIndexedSessionRepository;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author Lenovo
 */
@Slf4j
@Component
public class DefaultSessionManager implements SessionManager {

    /**
     * 会话仓库
     */
    private SessionRepository<?> sessionRepository;
    @Autowired
    public DefaultSessionManager setSessionRepository(SessionRepository<?> sessionRepository) {
        this.sessionRepository = sessionRepository;
        return this;
    }

    /**
     * jdbc模板
     */
    private JdbcTemplate jdbcTemplate;
    @Autowired
    public DefaultSessionManager setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
        return this;
    }

    /**
     * redis模板
     */
    private RedisTemplate<String, String> redisTemplate;
    @Autowired
    public DefaultSessionManager setRedisTemplate(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
        return this;
    }

    @Override
    public List<SessionInfoVO> getAllSessionInfo() {
        ArrayList<Session> sessions;
        if (sessionRepository instanceof JdbcIndexedSessionRepository) {
            sessions = getJdbcSessions();
        } else if (sessionRepository instanceof RedisIndexedSessionRepository) {
            sessions = getRedisSessions();
        } else {
            log.error("不支持的SessionRepository类型: {}", sessionRepository.getClass().getName());
            throw new RuntimeException("不支持的SessionRepository类型: " + sessionRepository.getClass().getName());
        }

        ArrayList<SessionInfoVO> sessionInfos = new ArrayList<>();
        for (Session session : sessions) {
            SessionInfoVO sessionInfo = new SessionInfoVO();

            String id = session.getId();
            sessionInfo.setId(id);
            sessionInfo.setSessionId(id);

            String username = getPrincipalNameFromSession(session);
            sessionInfo.setName(username);

            Instant creationTime = session.getCreationTime();
            sessionInfo.setCreationTime(new Date(creationTime.toEpochMilli()));

            Instant lastAccessedTime = session.getLastAccessedTime();
            sessionInfo.setLastAccessedTime(new Date(lastAccessedTime.toEpochMilli()));

            sessionInfos.add(sessionInfo);
        }
        return sessionInfos;
    }

    @Override
    public void invalidateSession(String sessionId) {
        sessionRepository.deleteById(sessionId);
    }

    private ArrayList<Session> getJdbcSessions() {
        ArrayList<Session> sessions = new ArrayList<>();
        jdbcTemplate.query("SELECT SESSION_ID FROM SPRING_SESSION", resultSet -> {
            String sessionId = resultSet.getString("SESSION_ID");
            Session session = sessionRepository.findById(sessionId);
            sessions.add(session);
        });
        return sessions;
    }

    private ArrayList<Session> getRedisSessions() {
        ArrayList<Session> sessions = new ArrayList<>();

        ScanOptions options = ScanOptions.scanOptions()
                .match(RedisIndexedSessionRepository.DEFAULT_NAMESPACE + ":sessions:*")
                .build();

        RedisConnectionFactory connectionFactory = redisTemplate.getConnectionFactory();
        if (connectionFactory != null) {
            try (RedisConnection connection = connectionFactory.getConnection()) {
                try (Cursor<byte[]> cursor = connection.scan(options)) {
                    while (cursor.hasNext()) {
                        String key = new String(cursor.next());
                        String sessionId = key.substring(RedisIndexedSessionRepository.DEFAULT_NAMESPACE.length() + 10);
                        if (sessionId.contains(":")) {
                            continue;
                        }
                        Session session = sessionRepository.findById(sessionId);
                        if (session != null) {
                            sessions.add(session);
                        }
                    }
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }


        return sessions;
    }


    private String getPrincipalNameFromSession(Session session) {
        Object springSecurityContext = session.getAttribute("SPRING_SECURITY_CONTEXT");
        if (springSecurityContext instanceof SecurityContextImpl) {
            Authentication authentication = ((SecurityContextImpl) springSecurityContext).getAuthentication();
            if (authentication != null) {
                return authentication.getName();
            }
        }

        return null;
    }
}