Shiro会话管理1

Shiro会话管理1

pom.xml
通过redis实现session共享

<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
   <version>2.7.3</version>
 </dependency>

spring-redis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!--JedisPool:Jedis连接池-->
	<bean id="jedisPool" class="redis.clients.jedis.JedisPool" >
		<constructor-arg name="poolConfig" ref="jedisPoolConfig" />
		<constructor-arg name="host" value="127.0.0.1" />
		<constructor-arg name="port" value="6379" />
	</bean>

	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"/>
</beans>

redis的访问工具包

package com.shiro.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.util.Set;

/**
 * redis的访问工具包
 */
@Component
public class JedisUtil {

    /**
     * 通过JedisPool(Jedis连接池获取redis连接)
     */
    @Autowired
    private JedisPool jedisPool;

    /**
     * 获取redis连接
     * @return
     */
    private Jedis getResource() {
        return jedisPool.getResource();
    }

    /**
     * 增
     * @param key
     * @param value
     */
    public void set(byte[] key, byte[] value) {
        Jedis jedis = getResource();
        try {
            jedis.set(key, value);
        } finally {
            jedis.close();
        }
    }

    /**
     * 设置超时时间(min)
     * @param key
     * @param i
     */
    public void expire(byte[] key, int i) {
        Jedis jedis = getResource();
        try {
            jedis.expire(key, i);
        } finally {
            jedis.close();
        }
    }


    /**
     * 查
     * @param key
     * @return
     */
    public byte[] get(byte[] key) {
        Jedis jedis = getResource();
        try {
            return jedis.get(key);
        } finally {
            jedis.close();
        }
    }

    /**
     * 删
     * @param key
     */
    public void del(byte[] key) {
        Jedis jedis = getResource();
        try {
            jedis.del(key);
        } finally {
            jedis.close();
        }
    }

    /**
     * 获取搜索前缀是sessionPrefix的key
     * @param sessionPrefix
     * @return
     */
    public Set<byte[]> keys(String sessionPrefix) {
        Jedis jedis = getResource();
        try {
            return jedis.keys((sessionPrefix + "*").getBytes());
        } finally {
            jedis.close();
        }
    }
}

redis存储session,实现session的共享

package com.shiro.session;

import com.shiro.util.JedisUtil;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.UnknownSessionException;
import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
import org.apache.shiro.util.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.SerializationUtils;

import java.io.Serializable;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

/**
 * redis存储session,实现session的共享
 */
public class RedisSessionDao extends AbstractSessionDAO {

    @Autowired
    private JedisUtil jedisUtil;

    public static final String SESSION_PREFIX = "test_session:";

    private byte[] getKey(String key) {
        return (SESSION_PREFIX + key).getBytes();
    }

    @Override
    protected Serializable doCreate(Session session) {
        //1.获取sessionid
        Serializable sessionId = generateSessionId(session);
        //2.关联sessionId和session
        assignSessionId(session, sessionId);
        //3.存储到redis中
        saveSession(session);
        return sessionId;
    }

    /**
     * 增
     * @param session
     */
    private void saveSession(Session session) {
        if (session != null && session.getId() != null) {
            byte[] key = getKey(session.getId().toString());
            byte[] value = SerializationUtils.serialize(session);
            jedisUtil.set(key, value);
//            10分钟后超时
            jedisUtil.expire(key, 600);
        }
    }

    /**
     * 查
     * @param sessionId
     * @return
     */
    @Override
    protected Session doReadSession(Serializable sessionId) {
        //默认会读取多次的session
        System.out.println("read redis session");
        if (sessionId != null) {
            byte[] value = jedisUtil.get(getKey(sessionId.toString()));
            return (Session) SerializationUtils.deserialize(value);
        }
        return null;
    }

    /**
     * 改
     * @param session
     * @throws UnknownSessionException
     */
    @Override
    public void update(Session session) throws UnknownSessionException {
        saveSession(session);
    }

    /**
     * 删
     * @param session
     */
    @Override
    public void delete(Session session) {
        if (session != null && session.getId() != null) {
            jedisUtil.del(getKey(session.getId().toString()));
        }
    }

    /**
     * 获取所有活动的session
     * @return
     */
    @Override
    public Collection<Session> getActiveSessions() {
        Set<byte[]> keys =  jedisUtil.keys(SESSION_PREFIX);
        Set<Session> sessions = new HashSet<>();
        //若查询到的redis中的keys为空，则返回空列表
        if (CollectionUtils.isEmpty(keys)) {
            return sessions;
        }
        for (byte[] key : keys) {
            Session session = (Session) SerializationUtils.deserialize(jedisUtil.get(key));
            sessions.add(session);
        }
        return sessions;
    }
}