redis的使用和安装,redis基础和高级部分

1.redis的安装
2.redis常用的命令
3.在阿里云上面安装redis
4.在vwmare上安装redis
5.利用jedis连接redis进行存入和输出
6.redis的高可用,哨兵机制,主从复制（安装三台redis服务器,一台主redis）
7.redis常见错误
8.redis持久化(AOF与RDB区别)

tar xzf redis-3.2.9.tar.gz cd redis-3.2.9
make MALLOC=libc

1、注释掉redis安装目录下的redis.conf文件中的如下数据：bind 127.0.0.1，修改后为#bind 127.0.0.12、修改保护模式为非：默认为protected-mode yes ,修改后为protected-mode no3、设置redis连接密码：找到#requirepass foobared ,在下面添加requirepass 123456
然后启动redis server:输入指令src/redis-server redis.conf

常用指令
在以上过程中可能会需要重启redis server，终止和重启的命令如下：
1、终止，通过杀死redis的进程kill -9 进程ID （解释：-9的含义是强制杀死）
进程ID可以通过如下命令查询：
ps -ef | grep 'redis'
ps aux | grep '6379'  --- 查询端口kill -15 9886 --- 杀死重置kill -9 9886 --- 强制杀死

启动客户端并测试
src/redis-cli
带密码的启动方式
./redis-cli -h 127.0.0.1 -p 6379 -a 123456
-h 是主机IP地址
-p 是端口号
-a 是密码
也可以直接通过代码进行测试

需要在marven当中加入 <dependency>     <groupId>redis.clients</groupId>     <artifactId>jedis</artifactId>     <version>2.9.0</version> </dependency>

package com.winter.utils.redis;import org.junit.Test;import redis.clients.jedis.Jedis;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;public class TestRedis {    private Jedis jedis;//
    @Before    public void setup() {
       jedis = new Jedis("192.168.184.128", 6379);//连接服务器
        jedis.auth("123456");//密码//    }
    @Test    public void test哨兵机制(){
        Jedis jedis = new Jedis("192.168.184.128", 6379);//        //权限认证,密码设置的是123456
        jedis.auth("123456");
        jedis.set("name","我是192.168.184.128存在主服务器");
        Jedis jedis1 = new Jedis("192.168.184.136", 6379);//        //权限认证,密码设置的是123456
        jedis1.auth("123456");
        String name1 = jedis1.get("name");
        System.out.println("我是136从机"+name1);
        Jedis jedis2 = new Jedis("192.168.184.135", 6379);//        //权限认证,密码设置的是123456
        jedis2.auth("123456");
        String name2 = jedis2.get("name");
        System.out.println("我是135从机"+name2);
        System.out.println("测试从机是否可写");        try {
            jedis1.set("name2","测试从机是否可写");
            jedis2.set("name2","测试从机是否可写");
            System.out.println("测试不成功，135从机可以写");
        }catch (Exception e){
            System.out.println("说明从机没有写的权限");
            System.out.println("输出结果"+e.getMessage());
        }

    }    /**
     * redis存储字符串
     */
    @Test    public void testString() {
        jedis.set("name", "xinxin");//向key-->name中放入了value-->xinxin
        System.out.println(jedis.get("name"));//执行结果：xinxin

        jedis.append("name", " is my lover"); //拼接
        System.out.println(jedis.get("name"));

        jedis.del("name");  //删除某个键
        System.out.println(jedis.get("name"));        //设置多个键值对
        jedis.mset("name", "liuling", "age", "23", "qq", "476777XXX");
        jedis.incr("age"); //进行加1操作
        System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));

    }    /**
     * redis操作Map
     */
    @Test    public void testMap() {        //-----添加数据----------
        Map<String, String> map = new HashMap<String, String>();        map.put("name", "xinxin");        map.put("age", "22");        map.put("qq", "123456");
        jedis.hmset("user", map);        //取出user中的name，执行结果:[minxr]-->注意结果是一个泛型的List        //第一个参数是存入redis中map对象的key，后面跟的是放入map中的对象的key，后面的key可以跟多个，是可变参数
        List<String> rsmap = jedis.hmget("user", "name", "age", "qq");
        System.out.println(rsmap);        //删除map中的某个键值
        jedis.hdel("user", "age");
        System.out.println(jedis.hmget("user", "age")); //因为删除了，所以返回的是null
        System.out.println(jedis.hlen("user")); //返回key为user的键中存放的值的个数2
        System.out.println(jedis.exists("user"));//是否存在key为user的记录 返回true
        System.out.println(jedis.hkeys("user"));//返回map对象中的所有key
        System.out.println(jedis.hvals("user"));//返回map对象中的所有value

        Iterator<String> iter = jedis.hkeys("user").iterator();        while (iter.hasNext()) {
            String key = iter.next();
            System.out.println(key + ":" + jedis.hmget("user", key));
        }
    }    /**
     * jedis操作List
     */
    @Test    public void testList() {        //开始前，先移除所有的内容
        jedis.del("java framework");
        System.out.println(jedis.lrange("java framework", 0, -1));        //先向key java framework中存放三条数据
        jedis.lpush("java framework", "spring");
        jedis.lpush("java framework", "struts");
        jedis.lpush("java framework", "hibernate");        //再取出所有数据jedis.lrange是按范围取出，        // 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有
        System.out.println(jedis.lrange("java framework", 0, -1));

        jedis.del("java framework");
        jedis.rpush("java framework", "spring");
        jedis.rpush("java framework", "struts");
        jedis.rpush("java framework", "hibernate");
        System.out.println(jedis.lrange("java framework", 0, -1));
    }    /**
     * jedis操作Set
     */
    @Test    public void testSet() {        //添加
        jedis.sadd("user", "liuling");
        jedis.sadd("user", "xinxin");
        jedis.sadd("user", "ling");
        jedis.sadd("user", "zhangxinxin");
        jedis.sadd("user", "who");        //移除noname
        jedis.srem("user", "who");
        System.out.println(jedis.smembers("user"));//获取所有加入的value
        System.out.println(jedis.sismember("user", "who"));//判断 who 是否是user集合的元素
        System.out.println(jedis.srandmember("user"));
        System.out.println(jedis.scard("user"));//返回集合的元素个数
    }

    @Test    public void test() throws InterruptedException {        //jedis 排序        //注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）
        jedis.del("a");//先清除数据，再加入数据进行测试
        jedis.rpush("a", "1");
        jedis.lpush("a", "6");
        jedis.lpush("a", "3");
        jedis.lpush("a", "9");
        System.out.println(jedis.lrange("a", 0, -1));// [9, 3, 6, 1]
        System.out.println(jedis.sort("a")); //[1, 3, 6, 9]  //输入排序后结果
        System.out.println(jedis.lrange("a", 0, -1));
    }//    @Test//    public void testRedisPool() {//        RedisUtil.getJedis().set("newname", "中文测试");//        System.out.println(RedisUtil.getJedis().get("newname"));//    }
}

server:
  port: 8081

spring:
    datasource:
        name: test
        url: jdbc:mysql://127.0.0.1:3306/mytest?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
        username: root
        password: root        # 使用druid数据源#        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.jdbc.Driver
        filters: stat
        maxActive: 20
        initialSize: 1
        maxWait: 60000
        minIdle: 1
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: select 'x'
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        maxOpenPreparedStatements: 20
    redis:
      database: 0
      host: 101.132.191.77
      port: 6379
      password: 123456
      pool:
        max-idle: 8
        min-idle: 0
        max-active: 8
        max-wait: -1
      timeout: 5000
mybatis:
  mapper-locations: classpath:mapping/*.xml  type-aliases-package: com.winter.model#pagehelper
pagehelper:
    helperDialect: mysql
    reasonable: true
    supportMethodsArguments: true
    params: count=countSql###########################################################Redis (RedisConfiguration)###########################################################spring.redis.database=0###spring.redis.host=127.0.0.1###spring.redis.port=6379###spring.redis.password=123456###spring.redis.pool.max-idle=8###spring.redis.pool.min-idle=0###spring.redis.pool.max-active=8###spring.redis.pool.max-wait=-1###spring.redis.timeout=5000

redis的主从复制是什么?
redis的主从复制主要还是读写分离，一台主redis有读和写的权限，其他从机redis只有读的权限，这样做的好处是为了减轻redis主机的压力。
redis的哨兵机制?
例:有3台redis,一台是主redis，2台是从机，开启哨兵机制后，3台redis开启后会发送心跳包到哨兵这里。如果主机挂了，那么哨兵会从另外2台从机这里选出一台作为主机（从原来只有读权限升级为读写权限）
那如果3台都挂了怎么办呢，一般企业会有备用机，或者利用zookper的监听重启服务器。
哨兵的功能+zookper重启服务器功能=redis的高可用

步骤一：启动sshd服务器1，sshd服务安装2，[root@localhost /]# vi /etc/ssh/sshd_config
Port 22
Protocol 2
PermitRootLogin yes
去掉这三行的注释
最后一个重要！因为它是允许root用户直接使用sshd服务登录服务器的！3，重新启动sshd服务
[root@localhost /]# service sshd restart4，设置sshd为系统自动启动

修改从服务器redis中的 redis.conf文件slaveof 192.168.33.130 6379  这个是主服务器的地址和端口，就是把从的和主的进行关联masterauth 123456--- 主redis服务器配置了密码,则需要配置
通过redis-cli连接后输入info命令查看role:master,role:slave可以查看主服务器和从服务器

1.修改sentinel monitor mymaster 192.168.184.128 6379 1   这里的128是主redis，6379是端口号，1是投票，哨兵根据投票数选取一个从redis作为主服务器，一般都是设置为1. 不需要在主redis当中配置哨兵
2.sentinel down-after-milliseconds mymaster 5000  心跳检测，5秒钟没访问到就换服务器
3.sentinel parallel-syncs mymaster 2   最多有2个子节点，就是备份服务器
4.启动的时候src/redis-server redis.conf 
然后开启客户端sentinel.conf --sentinel &    要将redis，redis配置文件还有哨兵都开开来

#dbfilename：持久化数据存储在本地的文件
dbfilename dump.rdb#dir：持久化数据存储在本地的路径，如果是在/redis/redis-3.0.6/src下启动的redis-cli，则数据会存储在当前src目录下
dir ./##snapshot触发的时机，save   
##如下为900秒后，至少有一个变更操作，才会snapshot 
##对于此值的设置，需要谨慎，评估系统的变更操作密集程度 
##可以通过“save “””来关闭snapshot功能 
#save时间，以下分别表示更改了1个key时间隔900s进行持久化存储；更改了10个key300s进行存储；更改10000个key60s进行存储。
save 900 1
save 300 10
save 60 10000##当snapshot时出现错误无法继续时，是否阻塞客户端“变更操作”，“错误”可能因为磁盘已满/磁盘故障/OS级别异常等 
stop-writes-on-bgsave-error yes 
##是否启用rdb文件压缩，默认为“yes”，压缩往往意味着“额外的cpu消耗”，同时也意味这较小的文件尺寸以及较短的网络传输时间 
rdbcompression yes 

##此选项为aof功能的开关，默认为“no”，可以通过“yes”来开启aof功能 
##只有在“yes”下，aof重写/文件同步等特性才会生效 
appendonly yes 
##指定aof文件名称 
appendfilename appendonly.aof 
##指定aof操作中文件同步策略，有三个合法值：always everysec no,默认为everysec 
appendfsync everysec 
##在aof-rewrite期间，appendfsync是否暂缓文件同步，"no"表示“不暂缓”，“yes”表示“暂缓”，默认为“no” 
no-appendfsync-on-rewrite no 
##aof文件rewrite触发的最小文件尺寸(mb,gb),只有大于此aof文件大于此尺寸是才会触发rewrite，默认“64mb”，建议“512mb” 
auto-aof-rewrite-min-size 64mb 
##相对于“上一次”rewrite，本次rewrite触发时aof文件应该增长的百分比。 
##每一次rewrite之后，redis都会记录下此时“新aof”文件的大小(例如A)，那么当aof文件增长到A*(1 + p)之后 
##触发下一次rewrite，每一次aof记录的添加，都会检测当前aof文件的尺寸。 
auto-aof-rewrite-percentage 100