shiro怎么集成redis

worktile 2年前其他 31

共3条回复我来回复

worktile

Worktile官方账号

要集成Redis，首先需要在pom.xml中添加Redis的依赖。可以使用Jedis或Lettuce来连接Redis。

对于Jedis，可以添加以下依赖：

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

对于Lettuce，可以添加以下依赖：

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.1.1</version>
</dependency>

然后，在shiro.ini或shiro.yml配置文件中配置Realm时，可以选择使用Redis作为缓存。例如，使用Jedis：

[main]
redisCacheManager = org.apache.shiro.cache.CacheManager
redisCacheManager.cacheManagerClass = org.apache.shiro.cache.jedis.JedisCacheManager
redisCacheManager.host = localhost
redisCacheManager.port = 6379

[users]
...

[roles]
...

[urls]
...

or 使用Lettuce：

[main]
redisCacheManager = org.apache.shiro.cache.CacheManager
redisCacheManager.cacheManagerClass = org.apache.shiro.cache.redis.RedisCacheManager
redisCacheManager.host = localhost
redisCacheManager.port = 6379

[users]
...

[roles]
...

[urls]
...

这样，就完成了将Shiro与Redis集成的配置。

值得注意的是，需要根据实际情况配置Redis的主机和端口，确保与Redis服务器的连接正确建立。另外，还需要确保Redis服务器已经正确安装和启动。

2年前 0条评论

fiy

Worktile&PingCode市场小伙伴

要将Shiro集成Redis，可以按照以下步骤进行操作：

添加Redis相关依赖：在项目的pom.xml文件中添加Redis相关的依赖，例如Jedis或Lettuce。
配置Redis的连接信息：在项目的配置文件中添加Redis的连接信息，包括主机地址、端口号、密码等。
创建Redis缓存管理器：使用Redis作为缓存存储时，需要创建Redis缓存管理器。可以通过继承AbstractCacheManager类，并重写其中的createCache方法来实现。
配置Shiro的CacheManager：在Shiro的配置文件中配置使用Redis作为缓存管理器。
配置RedisSessionDAO：使用Redis作为Session存储时，需要配置RedisSessionDAO。可以通过继承AbstractNativeSessionDAO类，并重写其中的doCreate、doRead、doUpdate和doDelete等方法来实现。
配置Shiro的SessionDAO：在Shiro的配置文件中配置使用Redis作为Session存储的SessionDAO。
配置Shiro的SessionManager：在Shiro的配置文件中配置使用Redis作为Session存储的SessionManager。

下面是一个示例配置文件的示例：

<!-- Redis连接信息 -->
<bean id="redisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
    <property name="hostName" value="localhost"/>
    <property name="port" value="6379"/>
    <property name="password" value="password"/>
</bean>

<!-- Redis缓存管理器 -->
<bean id="cacheManager" class="com.example.RedisCacheManager">
    <constructor-arg name="redisTemplate" ref="redisTemplate" />
</bean>

<!-- Shiro的缓存管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
    <property name="cacheManager" ref="cacheManager"/>
    <property name="sessionManager" ref="sessionManager"/>
    <!-- 其他配置... -->
</bean>

<!-- RedisSessionDAO -->
<bean id="redisSessionDAO" class="com.example.RedisSessionDAO">
    <property name="cacheManager" ref="cacheManager"/>
</bean>

<!-- Shiro的SessionDAO -->
<bean id="sessionDAO" class="org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO">
    <property name="cacheManager" ref="cacheManager"/>
    <property name="activeSessionsCacheName" value="shiro-activeSessionCache"/>
    <property name="sessionIdGenerator" ref="sessionIdGenerator"/>
</bean>

<!-- Redis的SessionManager -->
<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
    <property name="sessionDAO" ref="sessionDAO" />
    <!-- 其他配置... -->
</bean>

注意：以上仅为示例代码，实际配置中需要根据具体情况进行调整。

通过以上步骤，就可以将Shiro集成Redis，实现使用Redis作为缓存和Session存储。这样可以提高系统的性能和可扩展性，同时保证了数据的持久化和高可用性。

2年前 0条评论

不及物动词

这个人很懒，什么都没有留下～

Shiro是一款功能强大的Java安全框架，可以用于身份验证、授权、加密等安全功能的开发。而Redis是一种基于内存的NoSQL数据库，具有高速读写、持久化存储等特点。集成Shiro和Redis可以提高系统的性能和扩展性。本文将介绍如何在Java项目中集成Shiro和Redis。

添加依赖
首先，在你的项目中添加Shiro和Redis的依赖。你可以使用Maven或Gradle来管理依赖。在pom.xml文件中添加以下依赖：

<dependencies>
    <!-- Shiro -->
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.7.1</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-web</artifactId>
        <version>1.7.1</version>
    </dependency>
    
    <!-- Redis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.7.0</version>
    </dependency>
</dependencies>

配置Redis连接
接下来，需要在配置文件中配置Redis的连接信息。通过连接池管理Redis连接可以提高性能。示例配置如下：

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisUtil {
    private static JedisPool jedisPool;

    static {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(100);
        poolConfig.setMaxIdle(10);
        poolConfig.setMinIdle(1);
        poolConfig.setMaxWaitMillis(3000);
        
        String host = "localhost";
        int port = 6379;
        String password = "your_password";
        
        jedisPool = new JedisPool(poolConfig, host, port, 3000, password);
    }

    public static JedisPool getJedisPool() {
        return jedisPool;
    }
}

配置Shiro的Redis缓存管理器
接下来，需要配置Shiro的Redis缓存管理器，使其使用Redis作为缓存提供商。

import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.cache.CacheManagerAware;
import org.apache.shiro.cache.CacheManagerAwareInterceptor;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class RedisCacheManager implements CacheManager, CacheManagerAware {
    private CacheManagerAwareInterceptor cacheManagerAwareInterceptor;
    private String cacheKeyPrefix;
    
    private JedisPool jedisPool;

    public RedisCacheManager() {
        jedisPool = RedisUtil.getJedisPool();
    }

    public void setCacheManagerAwareInterceptor(CacheManagerAwareInterceptor cacheManagerAwareInterceptor) {
        this.cacheManagerAwareInterceptor = cacheManagerAwareInterceptor;
    }
    
    public void setCacheKeyPrefix(String cacheKeyPrefix) {
        this.cacheKeyPrefix = cacheKeyPrefix;
    }

    @Override
    public <K, V> org.apache.shiro.cache.Cache<K, V> getCache(String name) throws CacheException {
        return new RedisCache<>(name, jedisPool, cacheKeyPrefix);
    }

    @Override
    public void setCacheManager(CacheManagerAware cacheManager) {
        cacheManager.setCacheManager(this);
    }
}

配置Shiro的RedisSessionDAO
接下来，需要配置Shiro的RedisSessionDAO，使其使用Redis存储会话信息。

import org.apache.shiro.session.Session;
import org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.io.Serializable;

public class RedisSessionDAO extends EnterpriseCacheSessionDAO {
    private JedisPool jedisPool;

    public RedisSessionDAO() {
        jedisPool = RedisUtil.getJedisPool();
    }

    @Override
    protected Serializable doCreate(Session session) {
        Serializable sessionId = super.doCreate(session);
        
        Jedis jedis = jedisPool.getResource();
        try {
            jedis.set(sessionId.toString(), session.toString());
        } finally {
            jedis.close();
        }

        return sessionId;
    }

    @Override
    protected void doUpdate(Session session) {
        super.doUpdate(session);
        
        Jedis jedis = jedisPool.getResource();
        try {
            jedis.set(session.getId().toString(), session.toString());
        } finally {
            jedis.close();
        }
    }

    @Override
    protected void doDelete(Session session) {
        super.doDelete(session);
        
        Jedis jedis = jedisPool.getResource();
        try {
            jedis.del(session.getId().toString());
        } finally {
            jedis.close();
        }
    }
}

配置Shiro的RedisCache
接下来，需要配置Shiro的RedisCache，将Shiro的缓存抽象层与Redis缓存实现结合起来。

import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.CacheManager;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.util.Collection;
import java.util.Set;

public class RedisCache<K, V> implements Cache<K, V> {
    private String cacheKeyPrefix;
    
    private JedisPool jedisPool;

    public RedisCache(String name, JedisPool jedisPool, String cacheKeyPrefix) {
        this.jedisPool = jedisPool;
        this.cacheKeyPrefix = cacheKeyPrefix + name + ":";
    }

    private String getCacheKey(K key) {
        return cacheKeyPrefix + key.toString();
    }

    @SuppressWarnings("unchecked")
    @Override
    public V get(K key) throws CacheException {
        Jedis jedis = jedisPool.getResource();
        try {
            byte[] value = jedis.get(getCacheKey(key).getBytes());
            if (value != null) {
                return (V) SerializationUtils.deserialize(value);
            }
            return null;
        } finally {
            jedis.close();
        }
    }

    @Override
    public V put(K key, V value) throws CacheException {
        Jedis jedis = jedisPool.getResource();
        try {
            jedis.set(getCacheKey(key).getBytes(), SerializationUtils.serialize(value));
            return value;
        } finally {
            jedis.close();
        }
    }

    @SuppressWarnings("unchecked")
    @Override
    public V remove(K key) throws CacheException {
        Jedis jedis = jedisPool.getResource();
        try {
            byte[] value = jedis.get(getCacheKey(key).getBytes());
            if (value != null) {
                V previousValue = (V) SerializationUtils.deserialize(value);
                jedis.del(getCacheKey(key).getBytes());
                return previousValue;
            }
            return null;
        } finally {
            jedis.close();
        }
    }

    @Override
    public void clear() throws CacheException {
        Jedis jedis = jedisPool.getResource();
        try {
            Set<byte[]> keys = jedis.keys((cacheKeyPrefix + "*").getBytes());
            for (byte[] key : keys) {
                jedis.del(key);
            }
        } finally {
            jedis.close();
        }
    }

    @Override
    public int size() {
        Jedis jedis = jedisPool.getResource();
        try {
            Set<byte[]> keys = jedis.keys((cacheKeyPrefix + "*").getBytes());
            return keys.size();
        } finally {
            jedis.close();
        }
    }

    @Override
    public Set<K> keys() {
        Jedis jedis = jedisPool.getResource();
        try {
            Set<byte[]> keys = jedis.keys((cacheKeyPrefix + "*").getBytes());
            Set<K> result = new HashSet<>();
            for (byte[] key : keys) {
                result.add((K) key);
            }
            return result;
        } finally {
            jedis.close();
        }
    }

    @Override
    public Collection<V> values() {
        Jedis jedis = jedisPool.getResource();
        try {
            Set<byte[]> keys = jedis.keys((cacheKeyPrefix + "*").getBytes());
            List<V> result = new ArrayList<>();
            for (byte[] key : keys) {
                byte[] value = jedis.get(key);
                if (value != null) {
                    result.add((V) SerializationUtils.deserialize(value));
                }
            }
            return result;
        } finally {
            jedis.close();
        }
    }
}

配置Shiro的SecurityManager
最后，需要配置Shiro的SecurityManager，将以上配置整合起来。示例配置如下：

import org.apache.shiro.cache.MemoryConstrainedCacheManager;
import org.apache.shiro.cache.ehcache.EhCacheManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.mgt.SessionManager;
import org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.subject.SubjectContext;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.mgt.WebSecurityManager;

public class ShiroConfig {
    public static SecurityManager getSecurityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        // 设置Realm
        securityManager.setRealm(new MyRealm());
        
        // 设置Session管理器
        securityManager.setSessionManager(sessionManager());
        
        // 设置缓存管理器
        securityManager.setCacheManager(cacheManager());
        
        return securityManager;
    }
    
    public static SessionManager sessionManager() {
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        
        // 设置SessionDAO
        sessionManager.setSessionDAO(redisSessionDAO());
        
        return sessionManager;
    }
    
    public static EnterpriseCacheSessionDAO redisSessionDAO() {
        EnterpriseCacheSessionDAO sessionDAO = new RedisSessionDAO();
        sessionDAO.setActiveSessionsCacheName("shiro-activeSessionCache");
        sessionDAO.setCacheManager(cacheManager());
        
        return sessionDAO;
    }
    
    public static CacheManager cacheManager() {
        RedisCacheManager cacheManager = new RedisCacheManager();
        cacheManager.setCacheManagerAwareInterceptor(cacheManagerAwareInterceptor());
        cacheManager.setCacheKeyPrefix("shiro:cache:");
        
        return cacheManager;
    }
    
    public static CacheManagerAwareInterceptor cacheManagerAwareInterceptor() {
        CacheManagerAwareInterceptor cacheManagerAwareInterceptor = new CacheManagerAwareInterceptor();
        
        return cacheManagerAwareInterceptor;
    }
}

至此，已完成Shiro和Redis的集成配置。你可以根据需要自定义Shiro的Realm、Filter等组件，以满足你的具体业务需求。

2年前 0条评论