redis的使用

最新推荐文章于 2022-11-25 01:24:46 发布
最新推荐文章于 2022-11-25 01:24:46 发布
阅读量88 收藏
点赞数
文章标签： 数据库
原文链接：https://my.oschina.net/u/3045515/blog/1634599
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

1.引入redis依赖

<dependency>
			<groupId>redis-client</groupId>
			<artifactId>redis-client</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>

2.创建对应的redisManager类

import java.util.Set;


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

public class RedisManager {

	
	private String host = "127.0.0.1";
	
	private int port = 6379;
	
	// 0 - never expire
	private int expire = 0;
	
	//timeout for jedis try to connect to redis server, not expire time! In milliseconds
	private int timeout = 0;
	
	private String password = "";
	
	private int database = Protocol.DEFAULT_DATABASE;
	
	private static JedisPool jedisPool = null;
	
	public RedisManager(){
		
	}
	
//	public static void main(String[] args) {
//		RedisManager a = new RedisManager();
//		a.setMaster("redis-1");
//		a.setHost("192.168.100.24");
//		a.setPort(26379);
//		a.setDatabase(2);
//		a.init();
//	}
	
	/**
	 * 初始化方法
	 */
	public void init(){
		if(jedisPool == null){  
            if(password != null && !"".equals(password)){  
                jedisPool = new JedisPool(new JedisPoolConfig(), host, port, timeout, password);  
            }else if(timeout != 0){  
                jedisPool = new JedisPool(new JedisPoolConfig(), host, port,timeout);  
            }else{  
                jedisPool = new JedisPool(new JedisPoolConfig(), host, port);  
            }  
              
        }  
	}
	
	/**
	 * get value from redis
	 * @param key
	 * @return
	 */
	public byte[] get(byte[] key){
		byte[] value = null;
		Jedis jedis = jedisPool.getResource();
		try{
			value = jedis.get(key);
		}finally{
			jedisPool.returnResource(jedis);
		}
		return value;
	}
	
	/**
	 * 将字符串值 value 关联到 key 。
	 * 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。
	 * <P>Author : zhangjun </P>.
	 * <P>Date : 2015-1-23 </P>
	 * @param key
	 * @param value
	 * @return 总是返回 OK ，因为 SET 不可能失败。
	 */
	public String set(String key,Object object) {
		String l = null;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			l = jedis.set(SerializeUtils.serialize(key), SerializeUtils.serialize(object));
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(jedis != null){
				try {
					jedisPool.returnResource(jedis);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return l;
	}
	
	/**
	 * 将字符串值 value 关联到 key 。
	 * <P>Author : zhangjun </P>.
	 * <P>Date : 2015-1-23 </P>
	 * @param key
	 * @param value
	 */
	public Object getObject(String key) {
		Object o = null;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			byte[] bs = jedis.get(SerializeUtils.serialize(key));
			if(bs != null){
				o = SerializeUtils.deserialize(bs);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(jedis != null){
				try {
					jedisPool.returnResource(jedis);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return o;
	}
	
	
	/**
	 * 将字符串值 value 关联到 key 。
	 * <P>Author : zhangjun </P>.
	 * <P>Date : 2015-1-23 </P>
	 * @param key
	 * @param value
	 */
	public String get(String key) {
		String str = null;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			str = jedis.get(key);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(jedis != null){
				try {
					jedisPool.returnResource(jedis);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return str;
	}
	
	/**
	 * 将字符串值 value 关联到 key 。
	 * 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。
	 * <P>Author : zhangjun </P>.
	 * <P>Date : 2015-1-23 </P>
	 * @param key
	 * @param value
	 * @return 总是返回 OK ，因为 SET 不可能失败。
	 */
	public String set(final String key, final String value) {
		String l = null;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			l = jedis.set(key, value);
			if(this.expire != 0){
				jedis.expire(key, this.expire);
		 	}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (jedis != null) {
				try {
					jedisPool.returnResource(jedis);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return l;
	}
	
	/**
	 * set 
	 * @param key
	 * @param value
	 * @return
	 */
	public byte[] set(byte[] key,byte[] value){
		Jedis jedis = jedisPool.getResource();
		try{
			jedis.set(key,value);
			if(this.expire != 0){
				jedis.expire(key, this.expire);
		 	}
		}finally{
			jedisPool.returnResource(jedis);
		}
		return value;
	}
	
	/**
	 * set 
	 * @param key
	 * @param value
	 * @param expire
	 * @return
	 */
	public byte[] set(byte[] key,byte[] value,int expire){
		Jedis jedis = jedisPool.getResource();
		try{
			jedis.set(key,value);
			if(expire != 0){
				jedis.expire(key, expire);
		 	}
		}finally{
			jedisPool.returnResource(jedis);
		}
		return value;
	}
	
	/**
	 * 删除
	 * @param key
	 * @return
	 */
	public Long del(byte[] key){
		Long flag;
		Jedis jedis = jedisPool.getResource();
		try{
			flag = jedis.del(key);
		}finally{
			jedisPool.returnResource(jedis);
		}
		return flag;
	}
	
	/**
	 * 删除
	 * @param key
	 * @return
	 */
	public Long del(String key){
		Long flag;
		Jedis jedis = jedisPool.getResource();
		try{
			flag = jedis.del(key);
		}finally{
			jedisPool.returnResource(jedis);
		}
		return flag;
	}
	
	/**
	 * flush
	 */
	public void flushDB(){
		Jedis jedis = jedisPool.getResource();
		try{
			jedis.flushDB();
		}finally{
			jedisPool.returnResource(jedis);
		}
	}
	
	
	/**
	 * size
	 */
	public Long dbSize(){
		Long dbSize = 0L;
		Jedis jedis = jedisPool.getResource();
		try{
			dbSize = jedis.dbSize();
		}finally{
			jedisPool.returnResource(jedis);
		}
		return dbSize;
	}

	/**
	 * keys
	 * @param regex
	 * @return
	 */
	public Set<byte[]> keys(String pattern){
		Set<byte[]> keys = null;
		Jedis jedis = jedisPool.getResource();
		try{
			keys = jedis.keys(pattern.getBytes());
		}finally{
			jedisPool.returnResource(jedis);
		}
		return keys;
	}
	
	

	public String getHost() {
		return host;
	}

	public void setHost(String host) {
		this.host = host;
	}

	public int getPort() {
		return port;
	}

	public void setPort(int port) {
		this.port = port;
	}

	public int getExpire() {
		return expire;
	}

	public void setExpire(int expire) {
		this.expire = expire;
	}

	public int getTimeout() {
		return timeout;
	}

	public void setTimeout(int timeout) {
		this.timeout = timeout;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public int getDatabase() {
		return database;
	}

	public void setDatabase(int database) {
		this.database = database;
	}
}

3.用redis使用Cachemanager接口 在Spring中缓存主要有一个缓存接口（Cache）与缓存管理接口（CacheManager）。可以通过扩展这两个接口实现对应的缓存管理。

@SuppressWarnings("rawtypes")
//SuppressWarnings压制警告，即去除警告 
//rawtypes是说传参时也要传递带泛型的参数
public class RedisCacheManager implements CacheManager {

	private static final Logger logger = LoggerFactory.getLogger(RedisCacheManager.class);

	// fast lookup by name map
	private final ConcurrentMap<String, Cache> caches = new ConcurrentHashMap<String, Cache>();

	private RedisManager redisManager;

	/**
	 * The Redis key prefix for caches 
	 */
	private String keyPrefix = "rbac_permissions:";
	
	/**
	 * Returns the Redis session keys
	 * prefix.
	 * @return The prefix
	 */
	public String getKeyPrefix() {
		return keyPrefix;
	}

	/**
	 * Sets the Redis sessions key 
	 * prefix.
	 * @param keyPrefix The prefix
	 */
	public void setKeyPrefix(String keyPrefix) {
		this.keyPrefix = keyPrefix;
	}
	
	@SuppressWarnings("unchecked")
	@Override
	public <K, V> Cache<K, V> getCache(String name) throws CacheException {
		logger.debug("获取名称为: " + name + " 的RedisCache实例");
		
		Cache c = caches.get(name);
		
		if (c == null) {

			// initialize the Redis manager instance
			redisManager.init();
			
			// create a new cache instance
			c = new RedisCache<K, V>(redisManager, keyPrefix);
			
			// add it to the cache collection
			caches.put(name, c);
		}
		return c;
	}

	public RedisManager getRedisManager() {
		return redisManager;
	}

	public void setRedisManager(RedisManager redisManager) {
		this.redisManager = redisManager;
	}
}

4.在配置文件中，初始化，redismanager和redisCacheManage,并将redisCachemanager注入到spring的securitymanager的cacheManager中。

5.其中使用实体类

public class RedisCache<K, V> implements Cache<K, V> {
	
	private Logger logger = LoggerFactory.getLogger(this.getClass());
		
	/**
     * The wrapped Jedis instance.
     */
	private RedisManager cache;
	
	/**
	 * The Redis key prefix for the sessions 
	 */
	private String keyPrefix = "shiro_redis_session:";
	
	/**
	 * Returns the Redis session keys
	 * prefix.
	 * @return The prefix
	 */
	public String getKeyPrefix() {
		return keyPrefix;
	}

	/**
	 * Sets the Redis sessions key 
	 * prefix.
	 * @param keyPrefix The prefix
	 */
	public void setKeyPrefix(String keyPrefix) {
		this.keyPrefix = keyPrefix;
	}
	
	/**
	 * 通过一个JedisManager实例构造RedisCache
	 */
	public RedisCache(RedisManager cache){
		 if (cache == null) {
	         throw new IllegalArgumentException("Cache argument cannot be null.");
	     }
	     this.cache = cache;
	}
	
	/**
	 * Constructs a cache instance with the specified
	 * Redis manager and using a custom key prefix.
	 * @param cache The cache manager instance
	 * @param prefix The Redis key prefix
	 */
	public RedisCache(RedisManager cache, 
				String prefix){
		 
		this( cache );
		
		// set the prefix
		this.keyPrefix = prefix;
	}
	
	/**
	 * 获得byte[]型的key
	 * @param key
	 * @return
	 */
	private byte[] getByteKey(K key){
		if(key instanceof String){
			String preKey = this.keyPrefix + key;
    		return preKey.getBytes();
    	}else{
    		return SerializeUtils.serialize(key);
    	}
	}
 	
	@Override
	public V get(K key) throws CacheException {
		logger.debug("根据key从Redis中获取对象 key [" + key + "]");
		try {
			if (key == null) {
	            return null;
	        }else{
	        	byte[] rawValue = cache.get(getByteKey(key));
	        	@SuppressWarnings("unchecked")
				V value = (V)SerializeUtils.deserialize(rawValue);
	        	return value;
	        }
		} catch (Throwable t) {
			throw new CacheException(t);
		}

	}

	@Override
	public V put(K key, V value) throws CacheException {
		logger.debug("根据key从存储 key [" + key + "]");
		 try {
			 	cache.set(getByteKey(key), SerializeUtils.serialize(value));
	            return value;
	        } catch (Throwable t) {
	            throw new CacheException(t);
	        }
	}

	@Override
	public V remove(K key) throws CacheException {
		logger.debug("从redis中删除 key [" + key + "]");
		try {
            V previous = get(key);
            cache.del(getByteKey(key));
            return previous;
        } catch (Throwable t) {
            throw new CacheException(t);
        }
	}

	@Override
	public void clear() throws CacheException {
		logger.debug("从redis中删除所有元素");
		try {
            cache.flushDB();
        } catch (Throwable t) {
            throw new CacheException(t);
        }
	}

	@Override
	public int size() {
		try {
			Long longSize = new Long(cache.dbSize());
            return longSize.intValue();
        } catch (Throwable t) {
            throw new CacheException(t);
        }
	}

	@SuppressWarnings("unchecked")
	@Override
	public Set<K> keys() {
		try {
            Set<byte[]> keys = cache.keys(this.keyPrefix + "*");
            if (CollectionUtils.isEmpty(keys)) {
            	return Collections.emptySet();
            }else{
            	Set<K> newKeys = new HashSet<K>();
            	for(byte[] key:keys){
            		newKeys.add((K)key);
            	}
            	return newKeys;
            }
        } catch (Throwable t) {
            throw new CacheException(t);
        }
	}

	@Override
	public Collection<V> values() {
		try {
            Set<byte[]> keys = cache.keys(this.keyPrefix + "*");
            if (!CollectionUtils.isEmpty(keys)) {
                List<V> values = new ArrayList<V>(keys.size());
                for (byte[] key : keys) {
                    @SuppressWarnings("unchecked")
					V value = get((K)key);
                    if (value != null) {
                        values.add(value);
                    }
                }
                return Collections.unmodifiableList(values);
            } else {
                return Collections.emptyList();
            }
        } catch (Throwable t) {
            throw new CacheException(t);
        }
	}

}

转载于:https://my.oschina.net/u/3045515/blog/1634599

weixin_34255793
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Shiro集成redis实现session共享
qq_46826837的博客
10-15 933
Shiro集成redis实现session共享
阿里巴巴Redis使用规范
04-14
"阿里巴巴Redis使用规范" 本文将详细介绍阿里巴巴28条Redis使用规范，涵盖了Redis性能优化、数据存储、安全、实例管理等方面的内容。 规范一：控制key的长度 为了避免Redis中的keys过长，阿里巴巴建议控制key的...
【Shiro学习】一一一一集成redis缓存（一）
XiaoCoder的博客
06-11 462
Shiro学习笔记_01:集成redis缓存 1.引入依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>${shiro.version}</version> </dependency> <dependency> ...
shiro开发文档阅读（四）缓存组件
kevin的博客
02-22 283
shiro缓存 1.cache接口 cache接口主要定义了针对缓存的一些操作，下边是shiro中cache接口的一些相关方法 public interface Cache&amp;lt;K, V&amp;gt; { // 得到缓存 V get(K var1) throws CacheException; // 放入缓存 V put(K var1, V var2) throws...
复习步骤11-缓存管理--缓存角色数据和权限数据 自定义RedisCache和RedisCacheManager
香帅的博客
04-03 2810
项目结构 新建的JAVA类如下 RedisCache.java package com.xiangshuai.cache; import java.util.Collection; import java.util.Set; import org.apache.shiro.cache.Cache; import org.apache.shiro.cache.Cache...
Apache shiro集群实现 （七）分布式集群系统下---cache共享
热门推荐
04-24 2万+
上一篇已经解决了第一个问题，session的共享，现在我们解决第二个问题cache的共享。     先看下spring的配置文件，上一篇已经提到过了 这里cacheManager我们注入了shiro自定的本机内存实现的cacheManager类，当然，这肯定不满足我们集群的需要，所以我们要自己实现cacheManager类，这里我还是用了redis作为cache的存储，先创建RedisCacheManager实现类 这里cacheManager我们注
Redis使用教程，详解
02-07
Redis 使用教程详解 Redis 是一个高性能的 NoSQL 键值存储数据库，广泛应用于缓存、任务列表、网站访问统计数据、过期处理、应用排行榜、分布式集群架构中的 session 分离等领域。下面是 Redis 的详细使用教程。 ...
Redis使用认证密码登录
08-19
Redis 使用认证密码登录 Redis 默认配置是不需要密码认证的，这在安全性上会有一定的问题，因此需要启用 Redis 的密码认证功能，以增加 Redis 服务器的安全性。 1. 配置 Redis 认证密码 要启用 Redis 的密码认证...
redis使用进阶.pptx
10-21
Redis 使用进阶 Redis 是一个开源的、基于内存的数据结构存储系统，可以用作数据库、缓存和消息中间件。Redis 提供了丰富的数据结构，如字符串、哈希表、列表、集合、有序集合等，同时支持事务、持久化、主从复制等...
redis使用语法讲解
最新发布
01-15
redis使用语法
shiro源码分析篇5:结合redis实现session跨域
samll leaf
10-22 1588
相信大家对session跨域也比较了解了。以前单台服务器session本地缓存就可以了，现在分布式后，session集中管理，那么用redis来管理是一个非常不错的选择。在结合redis做session缓存的时候，也遇到了很多坑，不过还算是解决了。和上篇讲述一样，实现自定义缓存，需要实现两个接口Cache,CachaManager。 RedisCache.javapackage com.share
shiro缓存配置流程
风团团
11-21 685
以前搞shiro的时候没有刻意去研究过这些配置文件，导致用shiro的时候也是迷迷糊糊，惭愧啊，要想成为人上人，读源码，懂配置是真滴重要！ 配置项 意思 一 setCacheManager 配置缓存管理器用来缓存realm和session信息 二 setRealm 登录时假如用的UsernamePasswordToken，会来调用我们这里设置过的realm中找符合条件的realm，执行对应的逻辑 三 setSessi
百分百解决 Jedis 远程连 接connect time out问题
Code-zyc的博客
05-23 596
这里写目录标题出错效果图：解决方法：方法一：关闭防火墙：方法二修改配置文件：方法三：那一定是 没加规则！！！方法四 ：检查一下 代码的端口号和ip地址是否正确。 出错效果图： 解决方法： 方法一：关闭防火墙： 这个是暂时关闭（重启服务器就开启了） systemctl stop firewalld.service 这个是直接关闭： systemctl disable firewalld.service 然后检查 是否关闭： firewall-cmd --state 就关闭成功了 方法二修改配置
Jedis远程访问redis 链接超时
m0_63038549的博客
11-25 557
redis默认只允许本地访问，要使redis可以远程访问可以修改redis.conf 1）打开配置文件（redis.conf）把下面对应的注释掉 # bind 127.0.0.1 2）将保护模式修改为为no protected-mode no 3）Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程，设置为no daemonize no 4）然后在redis.conf文件的当前目录下执行下方命令试一下。 redis-server r
用jedis连接redis出现connect timed out 报错
weixin_57109001的博客
12-12 1453
1，首先查看我们是否在redis.conf文件里进行配置，进入到redis.conf中。 （1）在NETWORK下面找到bind 127.0.0.1,把这一行注释掉。 （2）再在NETWORK下面找到protected-mode yes,把yes改为no。 2.如果这样修改后还没有解决，那么查看一下防火墙。 systemctl status firewalld 如果像这个样子，我们关闭下防火墙即可。 systemctl stop firewalld 然后我们再来测试一下 .
第11章 缓存机制
weixin_30839881的博客
05-13 62
Shiro提供了类似于Spring的Cache抽象，即Shiro本身不实现Cache，但是对Cache进行了又抽象，方便更换不同的底层Cache实现。对于Cache的一些概念可以参考《Spring Cache抽象详解》：http://jinnianshilongnian.iteye.com/blog/2001040。 Shiro提供的Cache接口： public interfa...
C# Redis实战(六)
12-12 666
六、查询数据 在C# Redis实战(五)中介绍了如何删除Redis中数据，本篇将继续介绍Redis中查询的写法。 1、使用Linq匹配关键字查询 using (var redisClient = RedisManager.GetClient()) { var user = redisCli...
redis的两种存储方式string和byte对比
eng63538505的博客
07-07 2万+
redis版本：2.9.1 redis环境：redis集群（含哨兵模式，部在了两台Linux系统的机器上，每台机器四个节点，2主2备） 存储内容：Submit对象（公司代码里面的，对象里只有手机号码和短信内容不同，其他字段值都一样） 主要逻辑：存：生成submit对象-->对象转json/byte数组-->向redis存入json字符串/byte数组 · 取：根据key值（先设定好）从re
redisManager逻辑
weixin_33829657的博客
01-15 175
2019独角兽企业重金招聘Python工程师标准>>> ...
redis 使用手册
09-07
Redis使用手册可以在Redis官方网站上找到。官方网站提供了英文版和中文版的Redis命令大全，其中包含了Redis的各种命令和用法。此外，还可以参考一些详细的Redis入门教程，这些教程可以帮助用户更好地理解和使用Redis...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值