[oracle@localhost myredis]$ redis-server redis.conf
2533:C 29 May 11:10:32.669 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
2533:C 29 May 11:10:32.671 # Redis version=4.0.9, bits=64, commit=00000000, modified=0, pid=2533, just started
2533:C 29 May 11:10:32.672 # Configuration loaded
[oracle@localhost myredis]$ redis-cli -p 6379
127.0.0.1:6379> ping
PONG

127.0.0.1:6379> shutdown
(error) ERR Errors trying to SHUTDOWN. Check logs.
127.0.0.1:6379> exit

Dbsize：查看当前数据库的key的数量
set： 设置键值对,如 set jia haha 表示为键jia设置值为haha,注意：后面设置的能够覆盖前面的值
Keys * :查看当前数据库的所有的key
get ：精确获取某个key ，如果没有会报空
key k?:表示获取以k开头的键
flusthdb:清空当前数据库
flushAll:清空所有的数据库
exists key：判断某个键是否存在 ，存在返回1，不存在返回0 如：exists k1
move key 下标值：将键转移到某个数据库：如 move k3 2 表示将k3转移到3号库中
Expire key time:表示为指定键设置存活时间（防止某个不常用的数据常据内存）如：expire k2 10 表示为k2设置存活时间为10秒
ttl：表示查看某个值的存活时间：-1表示永远不消失-2 表示已经消失，过期，无法访问
del key:表示删除指定的key（redis语句执行成功为1，失败为0）
type key：表示查看指定key的数据类型
clear:(不属于redis命令)用于清除以上所有的编辑数据记录，用于长时间的编辑
append key value:用于在原有的字符串中叠加数据
Strlen key :查看指定的key的长度
incr key ：每执行一次，key值增加1（注意：该key值必须 为int型）
decr：    与上相反
incrby key number：每执行一次 ,为指定的key增长指定的值
Decrby key number:与上相反
getrange key number number：获得指定key的指定范围内的值，如getrange k1 0 3
setrange key number number:  将指定key的指定范围位置的覆盖成指定的内容
Setex key number :设置指定的key存活时间 ，如 setex k1 10 v4表示创建k1并且设置k1存活时间为10秒
Setnx key value:先判断key是否存在，存在此语句无效；不存在就创建ky并赋值
mset key value key value..：给多个key赋值
mget key key key:同时查看多个key的值
Msetnx：同时设置一个或者多个key-value，当且仅当所有给定key都不存在，即使只有一个给定key已经存在，msetnx也会拒绝执行所有给定key的设置操作

lpush list value value..:创建一个list的集合并向他左侧压入值,如：lpuh list01 1 2 3 4 5
lrange list01 0 -1 :(表示查看01集合，0表示从首位置查，-1表示到结尾 )
Rpush list value value：创建一个list的集合并向他右侧压入值
lrange list number number:从左侧遍历指定范围的list集合
Lpop list:左出栈第一个值，出栈后集合不存在该值
rpop list:右出栈第一个值，出栈后集合不存在该值
lindex number 集合:从左开始遍历并获得指定下表的值，没有返回空
llen list:查看指定list长度
Lrem list number value:删除指定集合的指定数量的值：如lrem list01 2 3 :表示删除list01集合中的两个3
Ltrim list number number:截取指定集合的指定范围内的值，原来的集合被截取的集合所取代
Rpoplpush list list:将第一个集合的最右的一个数压入第二个集合的最左边
Lset key index value:从左开始修改指定位置的值
LINSERT list after value01 value02:在value01前插入指定的内容value02
Set:(方法与list相似，只是不允许有重复的值出现)
Lset list number value:将指定集合的指定位置修改为指定值
Linsert list before value:在指定集合的指定值之前插入指定值

注意：向set集合添加的数据都是非重复的

Sadd set(集合) value：创建集合，压入值 如：sadd set01 1 2 3
Smembers set(集合):遍历集合的元素并返回出来
Scard set(集合)： 获取集合中的有多少个元素    
srem set(集合) value:删除集合中的指定元素
srandmember set(集合) number:在指定集合中随机抽取指定个数的元素
Spop set(集合)：随机出栈，个数为一
Smove set(集合) set(集合) value:将第一个集合中的制定个值转移到第二个集合中
Sdiff set(集合) set(集合) :取在第一个集合里面而不在后面任何一个sest里面的项
Sinter set（集合）set(集合) ：去集合的交集
Sunion set（集合）set(集合 )：去集合的并集

hash 是个键值对的模式，其中k-v中的v是个键值对
hset:创建一个hashset并赋值 如：hset user id 11 这里的v为 id-11,其中k为id，value
为11
Hget: 获得hashset的值,如：hget user id
Hmset：:给hashset多重赋值,如：hmset customer id 11 name lisi age 26 
Hmget：查看hashset的多个值,如：hmget customer id name age
Hgetall : 获取一个key中所有值（键值对） 如：hgetall customer
Hdel  ：删除指定key中的指定值（键值对）如：hdel user name
Hlen  : 查看指定键的值的长度,如：hlen user
Hexists : 查看指定键是否存在指定值  如：hexists user name
Hkeys ：查看指定键中的所有值（键值对）中的键,如：hkeys user
Hvals ：查看指定键中的所有值（键值对）中的值,如：hvals  user
Hincrby :每执行一次为指定键中的值中指定的值增加指定的整数 如:hincrby user age 2 每执行一次，年龄增加2
Hincrbyfloat:每执行一次为指定键中的值中指定的值增加指定的小数
Hsetnx: 若不存在，为指定的键设置指定的值，否则执行失败

有序set集合，在set的基础上，加上了一个score的值，根据score值的大小达到排序
Zadd：将一个或多个 member 元素及其 score 值加入到有序集 key 当中。如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。score 值可以是整数值或双精度浮点数。如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。当 key 存在但不是有序集类型时，返回一个错误
如：zadd zset01 60 v1 70 v2 80 v3 90 v4 100 v5
表示创建zset01集合，并压入了v1 v2 v3 v4 v5键
Zrange :查看指定集合中的键 如 zrange zset01 0 -1  
        补充：zrange zset01 0 -1 withscores 返回携带分数的键
Zrangebyscore key :查找指定分数范围内的键 如：zrangebyscore zset01 60 90
                   补充：分数中间加个“（”表示不包含,如：zrangebyscore zset01 60 （90 表示大于等于60小于90
zrangebyscore zset01 (60 (90 表示大于60小于90
Zrangebyscore zset01 60 90 limit 2 2 :表示在获得60 到90范围内的数中从下表值为2开始抽取两个数
Zrem :删除指定的key  如：zrem zset01 v5
Zcard：统计key的个数 如：zcard zset01 
Zcount:统计指定分数范围内的key个数 如:zcount zset01 60 80
Zrank:返回有序集合key中成员member的排名
Zscore:返回指定集合中的key的指定分数 如：zscore zset01 v4 
Zrevrank:将指定的key反转，并返回反转后的下标值 如：zrevrank zset  v4
Zrevrange:将指定的集合中的key反转，并将它们遍历出来：如 ：zrevrange zset01 0 -1
zrevrangeByScore:将指定的集合的分数反转：如 zrevrangeByScore zset01 90 60

# Note on units: when memory size is needed, it is possible to specify
# it in the usual form of 1k 5GB 4M and so forth:
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes

bind 127.0.0.1
protected-mode yes

# Accept connections on the specified port, default is 6379 (IANA #815344).
# If port 0 is specified Redis will not listen on a TCP socket.
port 6379

# TCP listen() backlog.
#
# In high requests-per-second environments you need an high backlog in order
# to avoid slow clients connections issues. Note that the Linux kernel
# will silently truncate it to the value of /proc/sys/net/core/somaxconn so
# make sure to raise both the value of somaxconn and tcp_max_syn_backlog
# in order to get the desired effect.
tcp-backlog 511

################################# GENERAL #####################################

# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
daemonize no

# If a pid file is specified, Redis writes it where specified at startup
# and removes it at exit.
#
# When the server runs non daemonized, no pid file is created if none is
# specified in the configuration. When the server is daemonized, the pid file
# is used even if not specified, defaulting to "/var/run/redis.pid".
#
# Creating a pid file is best effort: if Redis is not able to create it
# nothing bad happens, the server will start and run normally.
pidfile /var/run/redis_6379.pid

# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)
loglevel notic

# Specify the log file name. Also the empty string can be used to force
# Redis to log on the standard output. Note that if you use standard
# output for logging but daemonize, logs will be sent to /dev/null
logfile ""

databases 16

#   save ""

save 900 1
save 300 10
save 60 10000

stop-writes-on-bgsave-error yes

rdbcompression yes

rdbchecksum yes

# The filename where to dump the DB
dbfilename dump.rdb

# slaveof <masterip> <masterport>
# masterauth <master-password>

slave-serve-stale-data yes

slave-read-only yes

slave-priority 100

################################## SECURITY ###################################

# Require clients to issue AUTH <PASSWORD> before processing any other
# commands.  This might be useful in environments in which you do not trust
# others with access to the host running redis-server.
#
# This should stay commented out for backward compatibility and because most
# people do not need auth (e.g. they run their own servers).
#
# Warning: since Redis is pretty fast an outside user can try up to
# 150k passwords per second against a good box. This means that you should
# use a very strong password otherwise it will be very easy to break.
#
# requirepass foobared

# maxclients 10000

# In short... if you have slaves attached it is suggested that you set a lower
# limit for maxmemory so that there is some free RAM on the system for slave
# output buffers (but this is not needed if the policy is 'noeviction').
#
# maxmemory <bytes>

lazyfree-lazy-eviction no       
lazyfree-lazy-expire no　　
lazyfree-lazy-server-del no
slave-lazy-flush no

appendonly no
appendfilename "appendonly.aof"

# is reached. You can select among five behaviors:
#
# volatile-lru -> Evict using approximated LRU among the keys with an expire set.
# allkeys-lru -> Evict any key using approximated LRU.
# volatile-lfu -> Evict using approximated LFU among the keys with an expire set.
# allkeys-lfu -> Evict any key using approximated LFU.
# volatile-random -> Remove a random key among the ones with an expire set.
# allkeys-random -> Remove a random key, any key.
# volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
# noeviction -> Don't evict anything, just return an error on write operations.
#
# LRU means Least Recently Used
# LFU means Least Frequently Used
#
# Both LRU, LFU and volatile-ttl are implemented using approximated
# randomized algorithms.
#
# Note: with any of the above policies, Redis will return an error on write
#       operations, when there are no suitable keys for eviction.
#
#       At the date of writing these commands are: set setnx setex append
#       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
#       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
#       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
#       getset mset msetnx exec sort
#
# The default is:
#
# maxmemory-policy noeviction

127.0.0.1:6379> config get requirepass               #查看当前密码
1) "requirepass"
2) ""　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #显示空说明默认没有　　
127.0.0.1:6379> config set requirepass "123456"　　　　#设置密码
OK
127.0.0.1:6379> ping　　　　　　　　　　　　　　　　　　　　　#验证
(error) NOAUTH Authentication required.　　　　　　　　　#显示此信息说明密码设置成功
127.0.0.1:6379> auth 123456　　　　　　　　　　　　　　　　　#用密码登录
OK
127.0.0.1:6379> ping　　　　　　　　　　　　　　　　　　　　　 #验证
PONG

# The default is:
#
# maxmemory-policy noeviction

save 900 1
save 300 10
save 60 10

-rw-r--r-- 1 root root   186 5月  28 21:53 dump.rdb

-rw-r--r-- 1 root root   186 5月  29 13:56 copydump.rdb
-rw-r--r-- 1 root root   186 5月  28 21:53 dump.rdb

appendonly yes

-rw-r--r-- 1 root root  1802 5月  28 10:29 appendonly.aof

# appendfsync always
appendfsync everysec

auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

MULTI                  #标记一个事务的开始
WATCH Key　　　　　　　　 #监视一个或多个键，若在事务执行之前被监视的key改动，那么事务将被打断
EXEC　　　　　　　　　　　　#执行所有事务快内命令
UNWATCH　　　　　　　　　　#取消监视
DISCARD　　　　　　　　　　#取消事务，放弃执行事务快内命令

开启事务
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> EXEC
1) OK
2) OK
127.0.0.1:6379> KEYS *
1) "k3"
2) "k2"
3) "k1"

放弃事务
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set k1 bb
QUEUED
127.0.0.1:6379> set k2 ss
QUEUED
127.0.0.1:6379> DISCARD
OK
127.0.0.1:6379> KEYS *
1) "k3"
2) "k2"
3) "k1"

一条语法出错，其他无法执行
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> setget k1 
(error) ERR unknown command 'setget'
127.0.0.1:6379> getset k3
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> EXEC
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> KEYS *
(empty list or set)

冤头债主(哪条执行不合乎语意，但不是语法错误，能入列，不报错，则只有它不执行)
K1为字符串
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> INCR k1
QUEUED
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> EXEC
1) (error) ERR value is not an integer or out of range
2) OK
127.0.0.1:6379> get k4
"v4"
127.0.0.1:6379> KEYS *
1) "k1"
2) "k4"

127.0.0.1:6379> clear
127.0.0.1:6379> set balance 100
OK
127.0.0.1:6379> ste dept 0
(error) ERR unknown command 'ste'
127.0.0.1:6379> set dept 0
OK
127.0.0.1:6379> WATCH balance
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> DECRBY balance 20
QUEUED
127.0.0.1:6379> INCRBY dept 20
QUEUED

127.0.0.1:6379> get balance
"80"
127.0.0.1:6379> set balance 800    #将balance变为800
OK
127.0.0.1:6379> 

127.0.0.1:6379> exec
(nil)　　　　　　　　　　　　　　　　　　　　 #因为中途有人更改过值，事务执行失败

PSUBSCRIBE pattern [pattern..]                 #订阅一个或多个符合给定模式的频道
PUBSUB subcommand [argument [argument..]]　　　 #查看订阅与发布系统状态
PUBLISH channel message　　　　　　　　　　　　　　 #将信息发送到指定的频道
PUNSUBSCRIBE [pattern[pattern..]]　　　　　　　　 #退订所有给定模式的频道
SUBSCRIBE channel [channel..]　　　　　　　　　　　#订阅给定的一个或多个频道的信息
UNSUBBSCRIBE [channel[channel]]　　　　　　　　　　#指退订给的频道

127.0.0.1:6379> SUBSCRIBE c1 c2 c3     #模拟订阅了c1,c2,c3频道
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "c1"
3) (integer) 1
1) "subscribe"
2) "c2"
3) (integer) 2
1) "subscribe"
2) "c3"
3) (integer) 3

127.0.0.1:6379> PUBLISH c2 hello-redis　　　
(integer) 1

2) "c2"
3) "hello-redis"

　 127.0.0.1:6379>PSUBSCIBE new*

127.0.0.1:6379> PUBLISH new1 redis2015
(integer) 1

sentinel monitor host6379 127.0.0.1 6379 1   #最后一个数字1，表示主机挂掉后salve投票看让谁接替成为主机，得票数多少后成为主机

 [root@localhost myredis]# redis-sentinel sentinel.conf

<!--引入java访问redis客户端:Jedis-->
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>2.7.3</version>
</dependency>

Jedis jedis=new Jedis("127.0.0.1",6379);
System.out.println(jedis.ping());

 Jedis jedis=new Jedis("127.0.0.1",6379);
         jedis.set("k1","v1");
         jedis.set("k2","v2");
         jedis.set("k3","v3");
         System.out.println(jedis.get("k3"));
         Set<String> set=jedis.keys("*");
         System.out.println(set.size());

public class Test02{
  public static void main(String[] args){

     Jedis jedis = new Jedis("127.0.0.1",6379);
     //key
     Set<String> keys = jedis.keys("*");
     for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
       String key = (String) iterator.next();
       System.out.println(key);
     }
     System.out.println("jedis.exists====>"+jedis.exists("k2"));
     System.out.println(jedis.ttl("k1"));
     //String
     //jedis.append("k1","myreids");
     System.out.println(jedis.get("k1"));
     jedis.set("k4","k4_redis");
     System.out.println("----------------------------------------");
     jedis.mset("str1","v1","str2","v2","str3","v3");
     System.out.println(jedis.mget("str1","str2","str3"));
     //list
     System.out.println("----------------------------------------");
     //jedis.lpush("mylist","v1","v2","v3","v4","v5");
     List<String> list = jedis.lrange("mylist",0,-1);
     for (String element : list) {
       System.out.println(element);
     }
     //set
     jedis.sadd("orders","jd001");
     jedis.sadd("orders","jd002");
     jedis.sadd("orders","jd003");
     Set<String> set1 = jedis.smembers("orders");
     for (Iterator iterator = set1.iterator(); iterator.hasNext();) {
       String string = (String) iterator.next();
       System.out.println(string);
     }
     jedis.srem("orders","jd002");
     System.out.println(jedis.smembers("orders").size());
     //hash
     jedis.hset("hash1","userName","lisi");
     System.out.println(jedis.hget("hash1","userName"));
     Map<String,String> map = new HashMap<String,String>();
     map.put("telphone","13811814763");
     map.put("address","atguigu");
     map.put("email","abc@163.com");
     jedis.hmset("hash2",map);
     List<String> result = jedis.hmget("hash2", "telphone","email");
     for (String element : result) {
       System.out.println(element);
     }
     //zset
     jedis.zadd("zset01",60d,"v1");
     jedis.zadd("zset01",70d,"v2");
     jedis.zadd("zset01",80d,"v3");
     jedis.zadd("zset01",90d,"v4");
     
     Set<String> s1 = jedis.zrange("zset01",0,-1);
     for (Iterator iterator = s1.iterator(); iterator.hasNext();) {
       String string = (String) iterator.next();
       System.out.println(string);
     }       
  }
}

 Jedis jedis=new Jedis("127.0.0.1",6379);
          //开启事务
          Transaction transaction=jedis.multi();
          transaction.set("k4", "v44");
          transaction.set("k5", "v55");
        //  transaction.exec();
          //放弃事务
          transaction.discard();

public boolean transMethod() throws InterruptedException{
        Jedis jedis=new Jedis("127.0.0.1",6379);
        int balance;//余额
        int debt;//欠额
        int amtToSubtract=10;//实刷额度
        jedis.watch("balance");//加入监控
        //模拟异常时，将屏蔽的代码打开
        //Thread.sleep(7000); //模拟网络拥堵
        //在拥堵过期间，在redis客户端将balance的值设置为7，模拟两人同时操作一个资源
        balance=Integer.parseInt(jedis.get("balance"));
        if(balance<amtToSubtract){
            jedis.unwatch();
            System.out.println("modify");//已经有人修改
            return false;//提交失败，必须得重新获得版本号，重新设置事务并且进行提交
        }else{
            System.out.println("**************transaction");
            Transaction transaction=jedis.multi();
            transaction.decrBy("balance", amtToSubtract);//消费
            transaction.incrBy("debt", amtToSubtract);//欠下
            transaction.exec();//提交，进行批处理
            balance=Integer.parseInt(jedis.get("balance"));
            debt=Integer.parseInt(jedis.get("debt"));
            System.out.println("******"+balance);
            System.out.println("******"+debt);
            return true;
        }
        
    }
   /**
    * 通俗的讲，watch命令就是标记一个键，如果标记了一个键
    * 在提交事务前如果该键被别人标记修改过，那事务就会失败，这种情况通常可以再程序中
    * 重新尝试
    * 首先标记了键balance，然后检查余额是否只够，不足取消标记，并不做扣减；
    * 足够的话，就启动事务进行更行操作
    * 如果在此期间 键balance被其他人修改过，那么在提交 事务（执行exec）时就会报错
    * 程序中通常可以捕获这类错误再重新执行一次，直到成功。
 * @throws InterruptedException 
    * 
    */
    public static void main(String[] args) throws InterruptedException{
        TestDemoTX test=new TestDemoTX();
        boolean retValue=test.transMethod();
        System.out.println("main retValue----"+retValue);
    }

Jedis jedis_M=new Jedis("127.0.0.1",6379);
        Jedis jedis_S=new Jedis("127.0.0.1",6380);
        jedis_S.slaveof("127.0.0.1", 6379);
        jedis_M.set("class", "1122");
        String result=jedis_S.get("class");
        System.out.println(result );

将new Jedis的操作交给jedis_Pool，减少内存损耗
/**
 * Jedis工具类,利用单列模式懒汉模式
 * @author Administrator
 *
 */
public class JedisPoolUtil {
    //一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
    //1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
    //2）禁止进行指令重排序。
    private static volatile JedisPool jedisPool=null; 
    private JedisPoolUtil(){} 
    public static JedisPool getJedisPoolInstance(){
        if(null==jedisPool){
            synchronized (JedisPoolUtil.class) {
                if(null==jedisPool){
                    JedisPoolConfig poolConfig=new JedisPoolConfig();
                    poolConfig.setMaxActive(1000);//设置最大连接数
                    poolConfig.setMaxIdle(32);//设置最大空闲数
                    poolConfig.setMaxWait(100*1000);//最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException
                    poolConfig.setTestOnBorrow(true);//设置是否检查连接成功
                    jedisPool=new JedisPool(poolConfig,"127.0.0.1",6379);
                }
            }
        }
        return jedisPool;
    }
    public static void release(JedisPool jedisPool,Jedis jedis){
        if(null!=jedis){
            jedisPool.returnResourceObject(jedis);
        }
    }
}
/**
 * 测试应用连接池工具
 * @author Administrator
 *
 */
public class TestConnect {
    public static void main(String[] args){
        JedisPool jedisPool=JedisPoolUtil.getJedisPoolInstance();

        Jedis jedis=null;
        try{
            jedis=jedisPool.getResource();
            jedis.set("aa","bb");
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            JedisPoolUtil.release(jedisPool, jedis);
        }
    }
}

<!--引入java访问redis客户端:Jedis-->
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>2.7.3</version>
</dependency>

<!--使用开源社区高效序列化插件-->
<!--protostuff序列化依赖-->
<!-- https://mvnrepository.com/artifact/com.dyuproject.protostuff/protostuff-core -->
<dependency>
  <groupId>com.dyuproject.protostuff</groupId>
  <artifactId>protostuff-core</artifactId>
   <version>1.0.8</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.dyuproject.protostuff/protostuff-runtime -->
<dependency>
  <groupId>com.dyuproject.protostuff</groupId>
  <artifactId>protostuff-runtime</artifactId>
  <version>1.0.8</version>
</dependency>

public class RedisDao {
     private JedisPool jedisPool;
    //自定义序列化（推荐用类实现serilazible,因为性能不高），此需要加入protostuff
    private RuntimeSchema<Seckill> schema=RuntimeSchema.createFrom(Seckill.class);
    public RedisDao(String ip,int port){
        jedisPool=new JedisPool(ip,port);
    }
    //获取秒杀对象
    public Seckill getSeckill(long seckillId){
        //redis操作逻辑
        try{
            Jedis jedis=jedisPool.getResource();
            try {  //快速生成try/catch:Ctr+Alt+T
                String key="seckill:"+seckillId;
                //redis对于类的操作并没有实现内部序列化操作，它存储的都是一个二进制数组，必须通过反序列化将二进制转化为类
                // 思路：1.seckill实现serilizable(不高效，jdk内部方法)；2.采用开源社区较高效的
                //get->byte[] ->反序列化->Object(Seckill)
                //采用自定义序列化
                byte[] bytes=jedis.get(key.getBytes());
                if(bytes!=null){
                    //空对象
                    Seckill seckill=schema.newMessage();
                    //将数据传送到空对象中
                    ProtobufIOUtil.mergeFrom(bytes,seckill,schema);
                    //seckill被序列化
                    return seckill;
                }
            }finally {
                jedis.close();
            }

        }catch(Exception e){
            e.printStackTrace();
        }
        return null;
    }
    //将seckill对象存进redis中，存取秒杀对象
    public String putSeckill(Seckill seckill){
        //set Object(Seckill) -->序列化-->byte[]-->redis
        try {
            Jedis jedis=jedisPool.getResource();
            try {
                String key="seckill:"+seckill.getSeckillId();
                //LinkedBuffer缓存器，当数据较大时会有一定缓存
                byte[] bytes=ProtobufIOUtil.toByteArray(seckill,schema,
                        LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
                //超时缓存
                int timeout=60*60;//缓存一个小时
                //返回结果，如果错误返回错误信息，正确则返回“ok”
                String result=jedis.setex(key.getBytes(),timeout,bytes);
                return result;
            } finally {
                jedis.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

<!--注入RedisDao-->
<bean id="redisDao" class="org.seckill.dao.cache.RedisDao">
     <!--配置该Dao层的构造方法中的两个参数，否则无法使用-->
     <!--配置IP-->
     <constructor-arg index="0" value="localhost"/>
     <!--配置port端口号，redis端口号默认为6379-->
     <constructor-arg index="1" value="6379"/>
</bean>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:spring/spring-dao.xml"})
public class RedisDaoTest{
    private long id=1001;
    @Autowired
    private RedisDao redisDao;
    @Autowired
    private SeckillDao seckillDao;
    @Test
    public void testSeckill() throws Exception {
        //get and put
        Seckill seckill=redisDao.getSeckill(id);
        if(seckill==null){
            //如果缓存没有，从数据库中拿取数据
            seckill=seckillDao.queryById(id);
            if(seckill!=null){
                //将数据库中拿取的数据放进缓存中
                String result=redisDao.putSeckill(seckill);
                System.out.println(result);
                seckill=redisDao.getSeckill(id);
                System.out.println(seckill);

            }
        }
    }

public class TestDemo {
    public static void main(String[] args) {
        Set<String> set=new HashSet<String>();
        set.add("192.168.174.130:6379");
        set.add("192.168.174.130:6380");
        set.add("192.168.174.130:6381");
        JedisSentinelPool pool=new JedisSentinelPool("myMaster", set);
        //没隔1秒，访问一次redis
        while(true){
            Jedis jedis=null;
            try {
                jedis=pool.getResource();
                String value=jedis.get("hello");
                System.out.println(System.currentTimeMillis()+"-从redis中抽取的结果-");
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                if(jedis!=null){
                    jedis.close();
                }
            }
        }
        
    }
}

/**
 * Redis客户端底层
 * 底层就是Socket编程
 * @author Administrator
 *
 */
public class RedisClient {

    public static void main(String[] args) throws Exception {
        Socket client=new Socket("192.168.174.133",6379);
        /*发送语句一：
         * 发包\r\n表示一段数据的结束(不配置否则会报错)
         * 结果：-ERR unknown command 'hello-redis'（因为语法，需要遵守redis相关协议）
        client.getOutputStream().write("hello-redis\r\n".getBytes());*/
        /*发送语句二：
         * 结果：:10
         */    
        client.getOutputStream().write("dbsize\r\n".getBytes());
        //接受redis server响应
        byte[] response=new byte[1024];
        client.getInputStream().read(response);
        System.out.println(new String(response));
    }
}

/**
 * 手写客户端
 * 
 * @author Administrator
 * 
 */
public class RedisClient2 {
    // 每段数据 分隔 \r\n
    // *数组
    // $多行字符串
    // +单行信息
    // -错误信息
    // ：整形数字
    private OutputStream writer;
    private InputStream reader;

    public RedisClient2(String host, int port) throws Exception {
        Socket client = new Socket(host, port);
        writer = client.getOutputStream();
        reader = client.getInputStream();
    }

    // set key value
    public String set(String Key, String value) throws Exception {
        // 组装一个请求报文 -RESP
        StringBuffer command = new StringBuffer();
        command.append("*3").append("\r\n");// 开头,报文包含几个部分
        command.append("$3").append("\r\n");// 第一部分命令的类型是多行字符串，长度为3
        command.append("set").append("\r\n");// 第一部分命令的数据值
        // 为什么要转为字节数组因为要将中文转化为字节数组才能识别
        command.append("$").append(Key.getBytes().length).append("\r\n");// 第二部分数据的长度
        command.append(Key).append("\r\n");// 第二部分数据的值

        command.append("$").append(value.length()).append("\r\n");// 第二部分数据的长度
        command.append(value).append("\r\n");// 第二部分数据的值

        // 发送一个命令报文到redis服务器
        writer.write(command.toString().getBytes());

        // 接受redis执行结果
        byte[] response = new byte[1024];
        reader.read(response);
        return new String(response);
    }

    // get key
    public String get(String key) throws Exception {
        // 组成一个请求报文RESP
        StringBuffer command = new StringBuffer();
        command.append("*2").append("\r\n");

        command.append("$3").append("\r\n");
        command.append("get").append("\r\n");

        command.append("$").append(key.getBytes().length).append("\r\n");
        command.append(key).append("\r\n");

        // 发送一个命令报文到redis服务器
        writer.write(command.toString().getBytes());

        // 接受redis执行结果
        byte[] response = new byte[1024];
        reader.read(response);
        return new String(response);
    }

    public static void main(String[] args) throws Exception {
        RedisClient2 redis = new RedisClient2("192.168.174.133", 6379);
        String info = redis.set("liyiling", "iloveu");
        System.out.println(info);// 结果：+OK
        String result=redis.get("liyiling");
        System.out.println(result);//结果：$6 iloveu
    }
}

/**
 * 订阅机制的实现
 * @author Administrator
 *
 */
public class Subscribe {
    private OutputStream writer;
    private InputStream reader;
    //支持订阅的程序
    public Subscribe(OutputStream writer,InputStream reader){
        this.writer=writer;
        this.reader=reader;
    }
    //订阅一个消息频道
    public void news(String myNew) throws Exception{
        //和redis-server通信
        //subscribe channel
        //组装一个请求报文 -RESP
        StringBuffer command = new StringBuffer();
        command.append("*2").append("\r\n");

        command.append("$9").append("\r\n");
        command.append("subscribe").append("\r\n");

        command.append("$").append(myNew.getBytes().length).append("\r\n");
        command.append(myNew).append("\r\n");
        writer.write(command.toString().getBytes());
        //实现实时接收
        while(true){
            byte[] dontai=new byte[1024];
            reader.read(dontai);
            System.out.println(myNew+"订阅的消息有动态了");
            System.out.println(new String(dontai));
        }
    }
    public static void main(String[] args) throws Exception {
        RedisClient2 redis = new RedisClient2("192.168.174.133", 6379);
        Subscribe subscribe=redis.subscribe();
        subscribe.news("liyiling");
    }
}

127.0.0.1:6379> publish liyiling smile
(integer) 1

        long currentTimeMills=System.currentTimeMillis();
        Jedis jedis=new Jedis("192.168.174.133",6379);
        for(int i=0;i<1000;i++){
            jedis.set("test"+i,"test"+i);
        }
        long endTimeMills=System.currentTimeMillis();
        System.out.println(endTimeMills-currentTimeMills);

    long currentTimeMills=System.currentTimeMillis();
        Jedis jedis=new Jedis("192.168.174.133",6379);
        Pipeline pipeline=jedis.pipelined();
        for(int i=0;i<1000;i++){
            pipeline.set("test"+i,"test"+i);
        }
        pipeline.sync();
        long endTimeMills=System.currentTimeMillis();
        System.out.println(endTimeMills-currentTimeMills);

public class TestDemo2 {
    
        String host="192.168.174.133";
        int port=6379;
        Jedis jedis=new Jedis(host,port);
        /**
         * 限制网站访问频率，一分钟之内最多访问10次
         */
        public void test3() throws Exception{
            //模拟用户频繁请求
            for(int i=0;i<20;i++){
                boolean result=testLogin("192.168.174.133");
                if(result){
                    System.out.println("正常访问");
                }else{
                    System.out.println("访问受限制");
                }
            }
        }
        public boolean testLogin(String ip){
            String value=jedis.get(ip);
            if(value==null){
                //初始化时设置IP访问此时
                jedis.set(ip,"1");
                //设置IP的生存时间为60秒，60秒内IP的访问次数由程序控制
                jedis.expire(ip,60);
            }else{
                int parsetInt=Integer.parseInt(value);
                //如果60秒内IP的访问次数超过10，返回false，实现了超过10次禁止分的功能
                if(parsetInt>10){
                    return false;
                }else{
                    //如果没有10次。可以自增
                   jedis.incr(ip);
                }
            }
            return true;
        }
    public static void main(String[] args) throws Exception {
        TestDemo2 t=new TestDemo2();
        t.test3();
    }
}