初始redis

最新推荐文章于 2024-03-11 09:59:37 发布

白鹿青崖_

最新推荐文章于 2024-03-11 09:59:37 发布

阅读量625

点赞数

分类专栏： NoSQL

本文链接：https://blog.csdn.net/lyandyhk/article/details/52086607

版权

NoSQL 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文内容：

为啥使用redis+redis可以做啥+redis基本命令行命令+redis在JAVA中的使用

redis的认识

1.相对于关系型数据库，redis是部署在内存里的存储机制，可以用来做缓存使用，同时，你也可以把它独立出来做成单独的缓存机制，来存储一些实时数据，比如SessionId啊，xxx的最后活动时间啊之类的，我觉得用来解决是否过期这问题挺好的

2.redis是一个非关系型数据库，和关系型数据库相比，好处就是省的麻烦，不需要建表，比如你要存一个张三这个人的信息，什么姓名啊，性别啊，出生年月，地址啊什么的，在关系型数据库中，你需要先建一张User表，然后填一行信息保存，在redis中你可以创建一个Hash类型的数据，key直接取为zhangsan，之后这个Hash中的存一系列的Field对应的Value就行了，取出来也相当方便，直接hget zhangsan Fieldname 就好了，正因为这一点，redis用来存json相当方便。

redis可以做啥

1.实时数据，也就是一时使用的数据，例如SessionID啊，一些实时榜单排名啥的，先存在redis里很快。

2.消息队列，用redis中的List类型的对象来做，一个或几个应用做生产者，一个或几个应用做消费者（也符合实时数据的定义，消息队列也就当时使用，没有太大的必要把这个存起来，有日志可以查嘛）

redis基本命令行操作

前提：

1.建起一个redis后，它被分为了好多个数据库，比如1,2,3,4,5,6等等可以选（一开始我就没看懂）

2.默认端口是6379，这个安装的时候可以看到，Linux版的不给了，windows版的

在https://github.com/MSOpenTech/redis，进去点release会出现安装包下载的

3.redis有5种存储格式，但是最后一种Sorted Set我是没用过，但是知道它开销很大

使用：

数据库

flushdb 清空当前数据库

flushall 清空所有数据库

select index 选择index数据库

简单字符串存储操作

get key 获取

set key value 增或改

del key 删

exists key 是否存在

type key 查看类型

expire key time 设置生存时间单位秒

rename oldname newname 重命名

字符串

move key db 将当前数据库中的key-value移动到指定数据库中（若已存在则移动失

败，原库中将消失，相当于剪切操作）

decr key 整型-1，非整型报错，若该key不存在，则操作前默认为0（操作为-1）

decrby key number 整型-number，非整型报错，若该key不存在，则操作前默认为0

incr key 同上

incrby key number 规则同decrby

strlen key 返回字符串长度，非字符串报错

Hash类型

Hash类型分为键->域->值 hset zhangsan username zhangsan

hset key field value 一个hash可以存一堆键值对，比如：hset zs username zs

hget key field 获取该key的field字段的值

hexists key field 查看该key上是否存在该field

hlen key 获取该key上有多少个field

List类型

链表类型，尾部插入，头部取出，如果某链表最后一个元素被取出，则该链表一并消失

可用于消息队列服务，一个服务生产，一个服务消费

lpush key value 增或更新

lpushx key value 只有链表存在时才能往链表中加，否则报错

llen key 返回该链表长度

Set类型

查找很快，成员唯一性,CRUD复杂度为1，可以看成是无重复的ArrayList吧

sadd key value 存

scard key 获取该key中成员的数量

sismember key member 查看该member是不是key成员

srem key memeber 删除

smembers key 列出key中所有成员

redis在Java中的使用（Jedis）

前提：说白了就是Java中有一个工具包封装了命令行的操作，你只需要使用这个工具包就好了，以下Spring环境下

俩配置bean

</bean>

config.properties中redis的配置

# redis
redis.host =xx.xx.xx.xx
#redis.host=127.0.0.1
redis.port = 6379
redis.url = http://100.73.17.56:6379/1(这个1说的就是redis中的1号数据库)
redis.password =
redis.maxIdle = 1000
redis.maxActive = -1
redis.timeout = 100000
redis.testOnBorrow = true

RedisService 接口

import redis.clients.jedis.exceptions.JedisException ;

import java.util.List ;
import java.util.Map ;
import java.util.Set ;

/**
* Redis相关的服务接口
*
* @author Michael
*/
public interface RedisServer {
   public static final String CRM_REDIS = "thirdpa_crm_" ;

   /**
* 获得一个Redis客户端（注意，在使用完毕后需要手动close掉）
*
* @return redis客户端对象
*/
   //ShardedJedis getRedisClient();

   /**
* 执行一个Redis命令
*
* @param command redis命令对象
*/
  < T> T execute(RedisCommand< T> command) ;

public List<String> hmget(String key , String field) ;

public String hmset(String key , Map map) ;

public void hset(String key , String field , String value) ;

public String hget(String key , String field) ;

public Long sadd(String key , String... members) ;

public String spop(String key) ;

public String set(String key , String value) ;

public String get(String key) ;

public Long del(String key) ;

public Long hdel(String key , String... fields) ;

public List<String> lrange(String key , long start , long end) ;

public String lpop(String key) ;

public String rpop(String key) ;

public Long srem(String key , String... member) ;

public Long lpush(String key , String str) ;

public Long rpush(String key , String str) ;

public Long lrem(String key ,int count ,String value) ;

public Long llen(String key) ;

public Long incrby(String key , long val) throws JedisException ;

public Set<String> hkeys(String key) ;

}

RedisServiceImpl Bean的实例

package com.michael.cache.redis ;

import org.apache.commons.lang.StringUtils ;
import org.apache.log4j.Logger ;
import org.springframework.stereotype.Service ;
import redis.clients.jedis.ShardedJedis ;
import redis.clients.jedis.ShardedJedisPool ;

import javax.annotation.Resource ;
import java.util.List ;
import java.util.Map ;
import java.util.Set ;

/**
* @author Michael
*/
@Service
public class RedisServerImpl implements RedisServer {
   @Resource
   private ShardedJedisPool shardedJedisPool ;
private ShardedJedis shardedJedis ;

public RedisServerImpl() {
Logger logger = Logger. getLogger(RedisServerImpl. class) ;
  logger.info( "启动Redis服务...") ;
  }

   private ShardedJedis getRedisClient() {
   this. shardedJedis = shardedJedisPool.getResource() ;
return this. shardedJedis ;
  }

   public String getKey(String key) {
   if (StringUtils. isNotEmpty(key)) {
   return RedisServer. CRM_REDIS + key ; //这个静态字段在接口中定义了，算是唯一标识前缀
  }
   return null;
  }

   @Override
   public < T> T execute(RedisCommand< T> command) {
ShardedJedis jedis = shardedJedisPool.getResource() ;
   T o = command.invoke(jedis , shardedJedisPool) ;
if (! shardedJedisPool.isClosed()) {
jedis.close() ;
  }
   return o ;
  }

   public Long sadd(String key , String... members) {
   this.getRedisClient() ;
  Long val = null;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
val = this. shardedJedis.sadd(getKey(key) , members) ;
  } finally {
   this.close() ;
  }
}
   return val ;
  }

   public String spop(String key) {
   this.getRedisClient() ;
  String val = null;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
val = this. shardedJedis.spop(getKey(key)) ;
  } finally {
   this.close() ;
  }
}
   return val ;
  }

   @Override
   public void hset(String key , String field , String value) {
   this.getRedisClient() ;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
   this. shardedJedis.hset(getKey(key) , field , value) ;
  } finally {
   this.close() ;
  }
}
}

   @Override
   public String hget(String key , String field) {
   this.getRedisClient() ;
  String value = null;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
value = this. shardedJedis.hget(getKey(key) , field) ;
  } finally {
   this.close() ;
  }
}
   return value ;
  }

   @Override
   public List<String> hmget(String key , String field) {
   this.getRedisClient() ;
  List<String> value = null;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
value = this. shardedJedis.hmget(getKey(key) , field) ;
  } finally {
   this.close() ;
  }
}
   return value ;
  }

   @Override
   public String hmset(String key , Map map) {
   this.getRedisClient() ;
  String value = null;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
value = this. shardedJedis.hmset(getKey(key) , map) ;
  } finally {
   this.close() ;
  }
}
   return value ;
  }

   @Override
   public Long hdel(String key , String... fields) {
   this.getRedisClient() ;
  Long val = null;
if ( this. shardedJedis != null && fields != null && fields. length > 0  && StringUtils. isNotEmpty(key)) {
   try {
val = this. shardedJedis.hdel(getKey(key) , fields) ;
  } finally {
   this.close() ;
  }
}
   return val ;
  }

   @Override
   public List<String> lrange(String key , long start , long end) {
   this.getRedisClient() ;
  List<String> list = null;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
list = this. shardedJedis.lrange(getKey(key) , start , end) ;
  } finally {
   this.close() ;
  }
}
   return list ;
  }

   public Long lpush(String key , String str) {
   this.getRedisClient() ;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
   return this. shardedJedis.lpush(getKey(key) , str) ;
  } finally {
   this.close() ;
  }
}
   return 0L ;
  }

   @Override
   public Long rpush(String key , String str) {
   this.getRedisClient() ;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
   return this. shardedJedis.rpush(getKey(key) , str) ;
  } finally {
   this.close() ;
  }
}
   return 0L ;
  }

   @Override
   public Long llen(String key) {
   this.getRedisClient() ;
  Long val = null;
if(StringUtils. isEmpty(key)){
   return val ;
  }
   if( this. shardedJedis == null){
   return val ;
  }
   try {
val = this. shardedJedis.llen(getKey(key)) ;
  } finally {
   this.close() ;
  }
   return val ;
  }

   @Override
   public Long lrem(String key ,int count ,String value) {
   this.getRedisClient() ;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
   return this. shardedJedis.lrem(getKey(key) ,count ,value) ;
  } finally {
   this.close() ;
  }
}
   return 0L ;
  }

   @Override
   public Long incrby(String key , long val) {
   this.getRedisClient() ;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
   return this. shardedJedis.incrBy(getKey(key) , val) ;
  } finally {
   this.close() ;
  }
}
   return 0L ;
  }

   @Override
   public String lpop(String key) {
   this.getRedisClient() ;
  String val = null;
if(StringUtils. isEmpty(key)){
   return val ;
  }
   if( this. shardedJedis == null){
   return val ;
  }
   try {
val = this. shardedJedis.lpop(getKey(key)) ;
  } finally {
   this.close() ;
  }
   return val ;
  }

   @Override
   public String rpop(String key) {
   this.getRedisClient() ;
  String val = null;
if(StringUtils. isEmpty(key)){
   return val ;
  }
   if( this. shardedJedis == null){
   return val ;
  }
   try {
val = this. shardedJedis.rpop(getKey(key)) ;
  } finally {
   this.close() ;
  }
   return val ;
  }

   @Override
   public Long srem(String key , String... member) {
   this.getRedisClient() ;
  Long val = null;
if(StringUtils. isEmpty(key)){
   return val ;
  }
   if( this. shardedJedis == null){
   return val ;
  }
   try {
val = this. shardedJedis.srem(getKey(key) , member) ;
  } finally {
   this.close() ;
  }
   return val ;
  }

   @Override
   public String set(String key , String value) {
   this.getRedisClient() ;
  String val = null;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
val = this. shardedJedis.set(getKey(key) , value) ;
  } finally {
   this.close() ;
  }
}
   return val ;
  }

   @Override
   public String get(String key) {
   this.getRedisClient() ;
  String val = null;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
val = this. shardedJedis.get(getKey(key)) ;
  } finally {
   this.close() ;
  }
}
   return val ;
  }

   @Override
   public Long del(String key) {
   this.getRedisClient() ;
  Long val = null;
if ( this. shardedJedis != null && StringUtils. isNotEmpty(key)) {
   try {
val = this. shardedJedis.del(getKey(key)) ;
  } finally {
   this.close() ;
  }
}
   return val ;
  }

   private void close() {
   if ( this. shardedJedis != null && ! shardedJedisPool.isClosed()) {
   try{
   this. shardedJedis.close() ;
  } catch (Exception e){
   //e.printStackTrace();
  } finally {
   this. shardedJedis = null;
  }
}
}

   @Override
   public Set<String> hkeys(String key) {
   this.getRedisClient() ;
  Set<String> stringSet = null;
if (StringUtils. isEmpty(key)) {
   return stringSet ;
  }
   if( this. shardedJedis == null){
   return stringSet ;
  }

   try {
stringSet = this. shardedJedis.hkeys(getKey(key)) ;
  } finally {
   this.close() ;
  }

   return stringSet ;
  }

}

大概就这是这样子了