redis的实时监控

一，redis的监控信息

1，redis的监控信息通过客户端info命令就可以获取出来
2，redis的监控信息通过java代码获取使用JedisPool获取
代码如下：
RedisConfig：

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.password}")
    private String password;

    @Bean
    public JedisPool redisPoolFactory() {
        Logger.getLogger(getClass()).info("JedisPool注入成功！！");
        Logger.getLogger(getClass()).info("redis地址：" + host + ":" + port);
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout,password);
        return jedisPool;
    }


}

@Component
public class JedisUtil {
 @Autowired
    JedisPool jedisPool;
    // 获取redis 服务器信息
    public String getRedisInfo() {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            Client client = jedis.getClient();
            client.info();
            String info = client.getBulkReply();
            return info;
        }catch (Exception e) {
			e.printStackTrace();

		} 
        finally {
            // 返还到连接池
            jedis.close();
        }
        return null;
    }

    // 获取日志列表
    public List getLogs(long entries) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            List logList = jedis.slowlogGet(entries);
            return logList;
        } finally {
            // 返还到连接池
            jedis.close();
        }
    }

    // 获取日志条数
    public Long getLogsLen() {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            long logLen = jedis.slowlogLen();
            return logLen;
        } finally {
            // 返还到连接池
            jedis.close();
        }
    }

    // 清空日志
    public String logEmpty() {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.slowlogReset();
        } finally {
            // 返还到连接池
            jedis.close();
        }
    }

    // 获取占用内存大小
    public Long dbSize() {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            // TODO 配置redis服务信息
            Client client = jedis.getClient();
            client.dbSize();
            return client.getIntegerReply();
        } finally {
            // 返还到连接池
            jedis.close();
        }
    }

3，为获取出来的参数添加解释：
代码如下：

public class RedisInfoDetail {
    private static Map map = new HashMap();

    static {
        map.put("redis_version", "Redis 服务器版本");
        map.put("redis_git_sha1", "Git SHA1");
        map.put("redis_git_dirty", "Git dirty flag");
        map.put("os", "Redis 服务器的宿主操作系统");
        map.put("redis_build_id", "Redis 构建ID");
        map.put("redis_mode", "Redis启动模式：standalone、Sentinel、Cluster");
        map.put("arch_bits", " 架构（32 或 64 位）");
        map.put("multiplexing_api", "Redis 所使用的事件处理机制");
        map.put("gcc_version", "编译 Redis 时所使用的 GCC 版本");
        map.put("process_id", "服务器进程的 PID");
        map.put("run_id", "Redis 服务器的随机标识符（用于 Sentinel 和集群）");
        map.put("tcp_port", "TCP/IP 监听端口");
        map.put("uptime_in_seconds", "自 Redis 服务器启动以来，经过的秒数");
        map.put("uptime_in_days", "自 Redis 服务器启动以来，经过的天数");
        map.put("hz", "redis内部调度（进行关闭timeout的客户端，删除过期key等等）频率");
        map.put("configured_hz", "redis的配置状态频率");
        map.put("executable", "服务器可执行文件的路径");
        map.put("config_file", "启动 redis 配置文件");
        map.put("lru_clock", " 以分钟为单位进行自增的时钟，用于 LRU 管理");
        map.put("connected_clients", "已连接客户端的数量（不包括通过从属服务器连接的客户端）");
        map.put("client_longest_output_list", "当前连接的客户端当中，最长的输出列表");
        map.put("client_longest_input_buf", "当前连接的客户端当中，最大输入缓存");
        map.put("blocked_clients", "正在等待阻塞命令（BLPOP、BRPOP、BRPOPLPUSH）的客户端的数量");
        map.put("used_memory", "由 Redis 分配器分配的内存总量，以字节（byte）为单位");
        map.put("used_memory_human", "以人类可读的格式返回 Redis 分配的内存总量");
        map.put("used_memory_rss", "从操作系统的角度，返回 Redis 已分配的内存总量（俗称常驻集大小）。这个值和 top 、 ps 等命令的输出一致");
        map.put("used_memory_rss_human", "以可读的格式,操作系统角度,返回 redis 分配的内存总量");
        map.put("used_memory_peak", " Redis 的内存消耗峰值(以字节为单位)");
        map.put("used_memory_peak_human", "以人类可读的格式返回 Redis 的内存消耗峰值");
        map.put("total_system_memory", "主机拥有的内存总量");
        map.put("total_system_memory_human", "以可读的格式返回主机拥有的内存总量");
        map.put("used_memory_lua", "Lua 引擎所使用的内存大小（以字节为单位）");
        map.put("used_memory_lua_human", "以可读的格式返回Lua引擎使用内存");
        map.put("maxmemory_human", "以可读的格式返回Redis实例的最大内存配置");
        map.put("maxmemory", "Redis实例的最大内存配置");
        map.put("maxmemory_policy", "当达到maxmemory时的淘汰策略");
        map.put("loading", "服务器是否正在载入持久化文件");
        map.put("rdb_changes_since_last_save", "离最近一次成功生成rdb文件，写入命令的个数");
        map.put("rdb_bgsave_in_progress", "服务器是否正在创建rdb文件");
        map.put("rdb_last_save_time", "最近一次成功rdb文件的时间戳");
        map.put("rdb_last_bgsave_status", "最近一次成功rdb文件的状态");
        map.put("rdb_last_bgsave_time_sec", "最近一次成功rdb文件的耗时");
        map.put("rdb_current_bgsave_time_sec", "若当前正在创建rdb文件，指当前的创建操作已经耗费的时间");
        map.put("aof_enabled", "aof是否开启");
        map.put("aof_rewrite_in_progress", "aof的rewrite操作是否在进行中");
        map.put("aof_last_cow_size", "上一次AOF保存操作期间写时复制的大小（以字节为单位）");
        map.put("rdb_last_cow_size", "上一次RBD保存操作期间写时复制的大小（以字节为单位）");
        map.put("lazyfree_pending_objects", "等待释放的对象数（由于使用ASYNC选项调用UNLINK或FLUSHDB和FLUSHALL）");
        map.put("active_defrag_running", "碎片整理是否处于活动状态");
        map.put("mem_aof_buffer", "aof时，占用的缓冲");
        map.put("mem_allocator", "内存分配器（在编译时选择）");
        map.put("mem_clients_normal", "Redis的客户端主的分配信息量");
        map.put("mem_clients_slaves", "Redis的客户端从的分配信息量");
        map.put("mem_replication_backlog", "Redis的内存复制积压分配信息量");
        map.put("mem_not_counted_for_evict", "被驱逐的大小");
        map.put("mem_fragmentation_bytes", "内存碎片的大小（以字节为单位）");
        map.put("mem_fragmentation_ratio", "内存碎片率，used_memory_rss 和 used_memory 之间的比率");
        map.put("rss_overhead_ratio", "常驻内存开销比例");
        map.put("allocator_rss_bytes", "分配器的常驻内存大小（以字节为单位）");
        map.put("allocator_rss_ratio", "分配器常驻内存比例");
        map.put("allocator_frag_bytes", "分配器的碎片大小（以字节为单位）");
        map.put("allocator_frag_ratio", "分配器的碎片率");
        map.put("allocator_resident", "分配器常驻的内存");
        map.put("allocator_active", "分配器活跃的内存");
        map.put("allocator_allocated", "分配器分配的内存");
        map.put("used_memory_dataset_perc", "used_memory_dataset在净内存（used_memory-used_memory_startup）使用量中所占的百分比");
        map.put("used_memory_dataset", "数据集的大小（以字节为单位，used_memory - used_memory_overhead）");
        map.put("number_of_cached_scripts", "Redis缓存脚本的数量");
        map.put("used_memory_startup", "启动时消耗的初始内存量（以字节为单位）");
        map.put("used_memory_overhead", "数据集的大小（以字节为单位，used_memory - used_memory_overhead）");
        map.put("used_memory_peak_perc", "used_memory_peak在used_memory中所占的百分比");
        map.put("client_recent_max_output_buffer", "当前连接的客户端当中，最长的输出列表");
        map.put("client_recent_max_input_buffer", "当前连接的客户端当中，最大输入缓存");
        map.put("atomicvar_api", "Atomicvar API");
        map.put("used_memory_scripts_human", "人类使用过的记忆脚本");
        map.put("used_memory_scripts", "Redis使用的内存脚本");
        map.put("rss_overhead_bytes", "常驻内存开销大小(以字节为单位)");
        map.put("aof_rewrite_scheduled", "rewrite任务计划，当客户端发送bgrewriteaof指令，如果当前rewrite子进程正在执行，那么将客户端请求的bgrewriteaof变为计划任务，待aof子进程结束后执行rewrite");
        map.put("aof_last_rewrite_time_sec", "最近一次aof rewrite耗费时长");
        map.put("aof_current_rewrite_time_sec", "若当前正在执行aof rewrite，指当前的已经耗费的时间");
        map.put("aof_last_bgrewrite_status", "最近一次aof bgrewrite的状态");
        map.put("aof_last_write_status", "最近一次aof写入状态");
        map.put("aof_current_size", "aof文件当前大小");
        map.put("aof_pending_rewrite", "rewrite任务计划，当客户端发送bgrewriteaof指令，如果当前rewrite子进程正在执行，那么将客户端请求的bgrewriteaof变为计划任务，待aof子进程结束后执行rewrite");
        map.put("aof_buffer_length", "aof 缓冲区的大小");
        map.put("aof_rewrite_buffer_length", "aof 重写缓冲区的大小");
        map.put("aof_pending_bio_fsync", "后台IO队列中，等待fsync任务的个数");
        map.put("aof_delayed_fsync", "被延迟的 fsync 调用数量");
        map.put("total_connections_received", "自启动起连接过的总数。如果连接过多，说明短连接严重或连接池使用有问题，需调研代码的连接设置");
        map.put("total_commands_processed", "自启动起运行命令的总数");
        map.put("instantaneous_ops_per_sec", "每秒执行的命令数，相当于QPS");
        map.put("total_net_input_bytes", "网络入口流量字节数");
        map.put("total_net_output_bytes", "网络出口流量字节数");
        map.put("instantaneous_input_kbps", "网络入口kps");
        map.put("instantaneous_output_kbps", "网络出口kps");
        map.put("rejected_connections", "拒绝的连接个数，由于maxclients限制，拒绝新连接的个数");
        map.put("sync_full", "主从完全同步成功次数");
        map.put("sync_partial_ok", "主从部分同步成功次数");
        map.put("sync_partial_err", "主从部分同步失败次数");
        map.put("expired_keys", "自启动起过期的key的总数");
        map.put("evicted_keys", "使用内存大于maxmemory后，淘汰的key的总数");
        map.put("expired_stale_perc", "过期的比率");
        map.put("expired_time_cap_reached_count", "过期计数");
        map.put("keyspace_hits", "在main dictionary字典中成功查到的key个数");
        map.put("keyspace_misses","同上，未命中的key的个数");
        map.put("pubsub_channels","发布/订阅频道数");
        map.put("pubsub_patterns","发布/订阅模式数");
        map.put("latest_fork_usec","上次的fork操作使用的时间（单位ms）");
        map.put("migrate_cached_sockets","是否已经缓存了到该地址的连接");
        map.put("slave_expires_tracked_keys","从实例到期key数量");
        map.put("active_defrag_hits","主动碎片整理命中次数");
        map.put("active_defrag_misses","主动碎片整理未命中次数");
        map.put("active_defrag_key_hits","主动碎片整理key命中次数");
        map.put("active_defrag_key_misses","主动碎片整理key未命中次数");
        map.put("role","当前实例的角色master还是slave");
        map.put("connected_slaves","slave的数量");
        map.put("master_replid","主实例启动随机字符串");
        map.put("master_replid2","主实例启动随机字符串2");
        map.put("slave0","slave机器的信息、状态");
        map.put("master_repl_offset","主从同步偏移量,此值如果和上面的offset相同说明主从一致没延迟，与master_replid可被用来标识主实例复制流中的位置。");
        map.put("second_repl_offset","主从同步偏移量2,此值如果和上面的offset相同说明主从一致没延迟");
        map.put("repl_backlog_size","复制缓冲区大小");
        map.put("repl_backlog_first_byte_offset","复制缓冲区里偏移量的大小");
        map.put("repl_backlog_histlen","此值等于 master_repl_offset - repl_backlog_first_byte_offset,该值不会超过repl_backlog_size的大小");
        map.put("repl_backlog_active","复制缓冲区是否开启");
        map.put("used_cpu_sys","Redis 服务器耗费的系统 CPU");
        map.put("used_cpu_user","Redis 服务器耗费的用户 CPU");
        map.put("used_cpu_sys_children","后台进程的核心态cpu使用率");
        map.put("used_cpu_user_children","后台进程的用户态cpu使用率");
        map.put("cluster_enabled","例是否启用集群模式");
//        map.put("db.*","各个数据库（0-15）的 key 的数量，带有生存期的 key 的数量，平均存活时间");
        map.put("Keyspace","redis的Keyspace_db0值");
    }

    private String key;
    private String value;
    private String desctiption;
    public String getKey() {
        return key;
    }
    public void setKey(String key) {
        this.key = key;
        this.desctiption = map.get(this.key);
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    public String getDesctiption() {
        return desctiption;
    }
    public void setDesctiption(String desctiption) {
        this.desctiption = desctiption;
    }
    @Override
    public String toString() {
        return "RedisInfoDetail [key=" + key + ", value=" + value
                + ", desctiption=" + desctiption + "]";
    }
}

4，redis的慢日志查询
代码如下：

public class Operate {
    private long id;//slowlog唯一编号id
    private String executeTime;// 查询的时间戳
    private String usedTime;// 查询的耗时（微妙），如表示本条命令查询耗时47微秒
    private String args;// 查询命令，完整命令为 SLOWLOG GET，slowlog最多保存前面的31个key和128字符

    public Operate() {}


    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getExecuteTime() {
        return executeTime;
    }

    public void setExecuteTime(String executeTime) {
        this.executeTime = executeTime;
    }

    public String getUsedTime() {
        return usedTime;
    }

    public void setUsedTime(String usedTime) {
        this.usedTime = usedTime;
    }


    public String getArgs() {
        return args;
    }


    public void setArgs(String args) {
        this.args = args;
    }



}

5，redis的监控信息的实现
代码如下：
RedisMonitoringInfoService：

public interface RedisMonitoringInfo {

    /**
     * @return 监控页面数据
     */
   Map getMonitoringInfo();
}

RedisMonitoringService：

public interface RedisMonitoring {
    /**
     * @param qps  进程数
     * @param time 页面差值
     * @return
     */
    //监控页面动态图形数据
    Map getMonitoring(Integer qps, Integer time);
}

public interface RedisIdService {

    public List> getRedisInfo();

    public Double getDbSizeQps(Integer qps,Integer time);

    //获取redis日志列表
    public List getLogs(long entries);
    //获取日志总数
    public Long getLogLen();
    //清空日志
    public String logEmpty();
    //获取当前数据库中key的数量
    public Map getKeysSize();

    //获取当前redis使用内存大小情况
    public Map getMemeryInfo() ;

    public Map getMemeryInfolist();
    //获取redis内存大小
    public String getUsedMemory();
    //获取 比率
    public String getMemFragmentationRatio();
    //获取cpu值
    public String getUsedCpuSys();

    public  String getUsedCpuUserChildren();

    public  String getTotalConnectionsReceived();
    //内存使用剩余值
    public  String getUsedMemoryRss();
    //客户端连接数
    public  String getConnectedClients();
    //缓存命中率
    public String getHitProbability();
    //獲取進程id
    public  String getProcessId();

    //获取redis的db库的总值
    public Integer getDbId();
    //Keyspace
    public  String getKeyspace();

    //获取key值
    List> getAllRedisVal2(Integer pageSize, Integer pageNumber,Integer id,String key);

    //连接数据切换redis_db库
    public List> getSwitchoverRedis ();


}

6，监控信息的实现
代码如下：
RedisMonitoringInfoServiceImpl：

@Service
public class RedisMonitoringInfoServiceImpl implements RedisMonitoringInfoService {
    @Autowired
    private RedisIdService redisService;
    @Override
    public Map getMonitoringInfo() {
        Map map = new HashMap<>();
        Integer dbId = redisService.getDbId();
        String processId = redisService.getProcessId();
        String usedMemory = redisService.getUsedMemory();
        String connectedClients = redisService.getConnectedClients();
        String hitProbability = redisService.getHitProbability();
        map.put("processId", processId);
        map.put("hitProbability", hitProbability);
        map.put("connectedClients", connectedClients);
        map.put("keysSize", dbId);
        map.put("usedMemory", usedMemory+"M");
        return map;
    }
}

RedisMonitoringServiceImpl：

@Service
public class RedisMonitoringServiceImpl implements RedisMonitoringService {
    @Autowired
    private RedisIdService redisService;
    @Autowired
    private RedisUtil redisUtils;
    @Override
    public Map getMonitoring(Integer qps, Integer time) {
        SimpleDateFormat sdf =new SimpleDateFormat("HH:mm:ss" );
        Map item = new HashMap();
        List> arrayList = new ArrayList>();
        String usedMemory = redisService.getUsedMemory();
        String usedCpuSys = redisService.getUsedCpuSys();
        String usedMemoryRss = redisService.getUsedMemoryRss();
        Double dbSizeQps = redisService.getDbSizeQps(qps, time);
        Map memeryInfomap = new HashMap();
        memeryInfomap.put("usedMemoryRss",usedMemoryRss);
        memeryInfomap.put("usedMemory",usedMemory+"M");
        item.put("dbSizeQps",dbSizeQps);
        item.put("memeryInfomap",memeryInfomap);
        item.put("usedCpuSys", usedCpuSys);
        Date d= new Date();
        String str = sdf.format(d);
        item.put("date",str);

//            String key = "redis_id";
//        boolean redis = redisUtils.hasKey(key);
//        List list = new ArrayList();
//        SimpleDateFormat sdf =new SimpleDateFormat("HH:mm:ss" );
//        if (!redis){
//            Map item = new HashMap();
//            for (Integer i = 0; i <= 20; i++) {
//                item.put("dbSizeQps",null);
//                item.put("memeryInfomap",null);
//                item.put("usedCpuSys", null);
//                Date d= new Date();
//                String str = sdf.format(d);
//                item.put("date",null);
//                System.out.println("item" + item);
//                list.add(item);
//            }
//        }else {
//          list = (List)redisUtils.get(key);
//            list.remove(0);
//            Map item = new HashMap();
//            List arrayList = new ArrayList();
//            String usedMemory = redisService.getUsedMemory();
//            String usedCpuSys = redisService.getUsedCpuSys();
//            String usedMemoryRss = redisService.getUsedMemoryRss();
//            Double dbSizeQps = redisService.getDbSizeQps(qps, time);
//            Map memeryInfomap = new HashMap();
//            memeryInfomap.put("usedMemoryRss",usedMemoryRss);
//            memeryInfomap.put("usedMemory",usedMemory);
//            item.put("dbSizeQps",dbSizeQps);
//            item.put("memeryInfomap",memeryInfomap);
//            item.put("usedCpuSys", usedCpuSys);
//            Date d= new Date();
//            String str = sdf.format(d);
//            item.put("date",str);
//            System.out.println("item" + item);
//
//            list.add(item);
//        }
//        redisUtils.set(key, list);



//        List> list1 = new ArrayList>();
//        Map map = new HashMap<>();
//        String usedMemory = redisService.getUsedMemory();
//        String usedCpuSys = redisService.getUsedCpuSys();
//        String usedMemoryRss = redisService.getUsedMemoryRss();
//        Double dbSizeQps = redisService.getDbSizeQps(qps, time);
//        map.put("usedCpuSys", usedCpuSys);
//        map.put("usedMemoryRss",usedMemoryRss);
//        list1.add(map);
//        Map item = new HashMap();
//        Map memeryInfomap = new HashMap();
//        memeryInfomap.put("usedMemoryRss",usedMemoryRss);
//        memeryInfomap.put("usedMemory",usedMemory);
//        List list = new ArrayList();
//
//        SimpleDateFormat sdf =new SimpleDateFormat("HH:mm:ss" );
//        for (Integer i = 1; i <= 21; i++) {
//
//            //place here
//
//            item.put("dbSizeQps",dbSizeQps);
//            item.put("memeryInfomap",memeryInfomap);
//            item.put("usedCpuSys", usedCpuSys);
//            Date d= new Date();
//            String str = sdf.format(d);
//            item.put("date",str);
//            System.out.println("item" + item);
//
//            list.add(item);
//        }
//        String usedMemory = redisService.getUsedMemory();
//        String usedCpuSys = redisService.getUsedCpuSys();
//        String usedMemoryRss = redisService.getUsedMemoryRss();
//        Double dbSizeQps = redisService.getDbSizeQps(qps, time);
//        Map memeryInfomap = new HashMap();
//        memeryInfomap.put("usedMemoryRss",usedMemoryRss);
//        memeryInfomap.put("usedMemory",usedMemory);
//        List list = new ArrayList();
//        SimpleDateFormat sdf =new SimpleDateFormat("HH:mm:ss" );
//        Boolean result = false;
//        int count = 0;
//        Map item = new HashMap();
//        while(!result) {
//            try {
//                Thread.sleep(10 * 1000); //设置暂停的时间 10 秒
//                count ++ ;
//                item.put("dbSizeQps",dbSizeQps);
//                item.put("memeryInfomap",memeryInfomap);
//                item.put("usedCpuSys", usedCpuSys );
//                String format = sdf.format(new Date());
//                item.put("date", format);
//                System.out.println("item" + item);
//                System.out.println(sdf.format(new Date()) + "--循环执行第" + count + "次");
//                if (count == 21) {
//                    result = true;
//                    break ;
//                }
//           } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            list.add(item);
//        }
//            if(list.size()==20) {
//                list.remove(0);
//                list.add()
//            }
        return item;
    }

}

@Service
public class RedisIdServiceImpl implements RedisIdService {
    protected static Logger LOGGER = LoggerFactory.getLogger(RedisIdServiceImpl.class);
    @Autowired
    JedisUtil redisUtil;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private RedisConnectMapper mapper;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private RedisUtil redisUtils;

    public List> getRedisInfo() {
        //获取redis服务器信息
        String info = redisUtil.getRedisInfo();
        List> ridList = new ArrayList>();
        String[] strs = info.split("\n");
        RedisInfoDetail rif = null;
        if (strs != null && strs.length > 0) {
            for (int i = 0; i < strs.length; i++) {
                Map map = new HashMap();
                rif = new RedisInfoDetail();
                String s = strs[i];
                String[] str = s.split(":");
                if (str != null && str.length > 1) {
                    String key = str[0];
                    String value = str[1];
//                    String desctiption = str[2];
                    map.put("key", key);
                    map.put("value", value);
                    rif.setKey(key);
                    String desctiption = rif.getDesctiption();
                    map.put("desctiption", desctiption);
//                    rif.setKey(key);
//                    rif.setValue(value);
                    ridList.add(map);
                }
            }
        }
        return ridList;
    }

    /**
     * @param qps
     * @param time
     * @return
     */
    //获取qps参数
    @Override
    public Double getDbSizeQps(Integer qps, Integer time) {
        Double process = null;
        Double qpsTime = null;
//        Double qps = null;
//        //获取redis服务器信息
//        String info = redisUtil.getRedisInfo();
//        List> ridList = new ArrayList>();
//        String[] strs = info.split("\n");
//        RedisInfoDetail rif = null;
//        if (strs != null && strs.length > 0) {
//            for (int i = 0; i < strs.length; i++) {
//                Map map =new HashMap();
//                rif = new RedisInfoDetail();
//                String s = strs[i];
//                String[] str = s.split(":");
//                if (str != null && str.length > 1) {
//                    String key = str[0];
//                    System.out.println("[][][][]"+key.length());
//                    String value = str[1];
//                    System.out.println("[][][][]"+value.length());
//                    rif.setKey(key);
//                    String value1 = rif.getValue();
//                    process =  (double) map.put("process_id", value1);
//
//                    qps = (process*0.8)/(24 * 3600 * 0.2);
//                    ridList.add(map);
//                }
//            }
//        }
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;

        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("process_id")) {
                process = Double.valueOf((detail[1].substring(0, detail[1].length() - 1)));
                break;
            }
        }
        if (process!=null){

            qpsTime = (process - qps) / (time);
        }

//        qps = (process*0.8)/(qps * 3600 * 0.2);
        return qpsTime;
    }

    //获取redis日志列表
    public List getLogs(long entries) {
        List list = redisUtil.getLogs(entries);
        List opList = null;
        Operate op = null;
        boolean flag = false;
        if (list != null && list.size() > 0) {
            opList = new LinkedList();
            for (Slowlog sl : list) {
                String args = JSON.toJSONString(sl.getArgs());
                if (args.equals("[\"PING\"]") || args.equals("[\"SLOWLOG\",\"get\"]") || args.equals("[\"DBSIZE\"]") || args.equals("[\"INFO\"]")) {
                    continue;
                }
                op = new Operate();
                flag = true;
                op.setId(sl.getId());
                op.setExecuteTime(getDateStr(sl.getTimeStamp() * 1000));
                op.setUsedTime(sl.getExecutionTime() / 1000.0 + "ms");
                op.setArgs(args);
                opList.add(op);
            }
        }
        if (flag)
            return opList;
        else
            return null;
    }

    //获取日志总数
    public Long getLogLen() {
        return redisUtil.getLogsLen();
    }

    //清空日志
    public String logEmpty() {
        return redisUtil.logEmpty();
    }

    //获取当前数据库中key的数量
    public Map getKeysSize() {
        long dbSize = redisUtil.dbSize();
        Map map = new HashMap();
        map.put("dbSize", dbSize);
        return map;
    }

    //获取当前redis使用内存大小情况
    public Map getMemeryInfo() {

        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;

        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("used_memory")) {
                map = new HashMap();
                map.put("used_memory", detail[1].substring(0, detail[1].length() - 1));
                map.put("create_time", new Date().getTime());
                break;
            } else {
                if (detail[0].equals("used_memory_rss")) {
                    map = new HashMap();
                    map.put("used_memory_rss", detail[1].substring(0, detail[1].length() - 1));
                    map.put("create_time", new Date().getTime());
                    break;

                }
            }
        }
        return map;
    }

    //获取当前redis使用内存大小情况
    public Map getMemeryInfolist() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Long aLong1 = redisUtil.dbSize();
        HttpServletRequest request = null;
        List list = null;
        Map map = null;
        //判断前端请求资源
        if (request != null) {
            list = new LinkedList<>();
            if (list != null && list.size() > 0) {
                for (String s : strs) {
                    String[] detail = s.split(":");
                    if (detail[0].equals("used_memory")) {
                        map = new HashMap();
                        map.put("used_memory", detail[1].substring(0, detail[1].length() - 1));
                        map.put("create_time", new Date().getTime());
                        break;
                    }
                }
            }
            list.add(map);
            if (list.size() < 20) {

                return (Map) list;
            }
            return null;
        } else {
            return null;
        }
    }

    //获取内存大小
    @Override
    public String getUsedMemory() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;
        String memory = null;
        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("used_memory")) {
                memory = detail[1].substring(0, detail[1].length() - 1);
                System.out.println(memory);
                break;
            }
        }
        System.out.println();
        return memory;
    }

    //比率
    @Override
    public String getMemFragmentationRatio() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;
        String memory = null;
        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("mem_fragmentation_ratio")) {
                memory = detail[1].substring(0, detail[1].length() - 1);
                System.out.println(memory);
                break;
            }
        }
        System.out.println();
        return memory;
    }

    @Override
    public String getUsedCpuSys() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;
        String memory = null;
        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("used_cpu_sys")) {
                memory = detail[1].substring(0, detail[1].length() - 1);
                System.out.println(memory);
                break;
            }
        }
        System.out.println();
        return memory;
    }

    @Override
    public String getUsedCpuUserChildren() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;
        String memory = null;
        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("used_cpu_user_children")) {
                memory = detail[1].substring(0, detail[1].length() - 1);
                System.out.println(memory);
                break;
            }
        }
        System.out.println();
        return memory;
    }

    //命中
    @Override
    public String getTotalConnectionsReceived() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;
        String memory = null;
        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("total_connections_received")) {
                memory = detail[1].substring(0, detail[1].length() - 1);
                System.out.println(memory);
                break;
            }
        }
        System.out.println();
        return memory;
    }

    @Override
    public String getUsedMemoryRss() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;
        String memory = null;
        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("used_memory_rss")) {
                memory = detail[1].substring(0, detail[1].length() - 1);
                System.out.println(memory);
                break;
            }
        }
        System.out.println();
        return memory;
    }

    @Override
    public String getConnectedClients() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;
        String memory = null;
        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("connected_clients")) {
                memory = detail[1].substring(0, detail[1].length() - 1);
                System.out.println(memory);
                break;
            }
        }
        System.out.println();
        return memory;
    }

    /**
     * @return probability 缓存命中率
     * keyspace_hits：命中的次数
     * keyspace_misses：没有命中的次数
     */
    //缓存命中概率
    @Override
    public String getHitProbability() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;
        Double memohitsry = null;
        Double memorymisses = null;
        Double probability = null;
        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("keyspace_hits")) {
                memohitsry = Double.valueOf(detail[1].substring(0, detail[1].length() - 1));
                System.out.println("keyspace_hits----=" + memohitsry);
            } else if (detail[0].equals("keyspace_misses")) {
                memorymisses = Double.valueOf(detail[1].substring(0, detail[1].length() - 1));
                System.out.println("keyspace_misses=-------=" + memorymisses);
                break;
            }

        }
        if (memohitsry!=null&&memorymisses!=null){

            probability = memohitsry / (memohitsry + memorymisses);

            BigDecimal mData = new BigDecimal(probability).setScale(2, BigDecimal.ROUND_HALF_UP);
            NumberFormat percent = NumberFormat.getPercentInstance();
            percent.setMaximumFractionDigits(2);
            return   percent.format(mData.doubleValue());
        }
    return null;
    }

    @Override
    public String getProcessId() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;
        String memory = null;
        for (String s : strs) {
            String[] detail = s.split(":");
            if (detail[0].equals("process_id")) {
                memory = detail[1].substring(0, detail[1].length() - 1);
                System.out.println(memory);
                break;
            }
        }
        System.out.println();
        return memory;
    }

    private Map getRedisInfo(String str){
        //s:1\n a=2,B:W=1
        Map result =  new HashMap();
        String [] arr = str.split("\n");
        String [] istr;
        String [] jsrt;
        String [] jjstr;

        for (int i = 0; i < arr.length; i++){
            istr = arr[i].split(":");
            if(istr.length >=2 ){
                jsrt = istr[1].split(",");
                if(jsrt.length >= 2){
                    for (int j=0; j < jsrt.length; j++){

                        jjstr = jsrt[j].split("=");
                        if(jjstr.length >= 2){
                            result.put(jjstr[0],jjstr[1]);
                        }
                    }
                }else{
                    result.put(istr[0],istr[1]);
                }
            }
        }

        return result;

    }

    @Override
    public Integer getDbId() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = new HashMap();
        String[] split;
        String[] dh;
        String[] dd;
        int sun =0;
        int js = 0;
        int zh = 0;
        int ss = 0;
        for (String s : strs) {
             split = s.split(":");
            for (int i = 0; i < 16; i++) {
                if (split[0].equals("db" + i)) {
                    if (split.length >= 2) {

                        dh = split[1].split(",");
                        for (int j = 0; j < dh.length; j++) {
                            if (dh.length >= 2) {
                                dd = dh[j].split("=");
                                if (dd.length >= 2) {
                                    if (dd[0].equals("keys")){
                                        sun= Integer.parseInt(dd[1]);
                                        zh += sun;
                                    }
                                }
                            }
                        }
                        System.out.println(zh);
                    } else {
                        map.put(split[0], split[1]);
                    }
                }
            }
        }
        Object keys = map.get("keys");
        System.out.println("----===="+keys);

//
//        for (int i = 0; i < 16; i++) {
//
//             keysh = info.get("db"+i);
//            System.out.println(keysh);
//        }

//        String[] strs = redisUtil.getRedisInfo().split("\n");
//        Map map = null;
//        String[] memory = null;
//        int key = Integer.parseInt(null);
//        String[] split = null;
//        String[] detail;
//        String[] keys;
//        String istr;
//        String [] jsrt;
//        String [] jjstr;
//        Integer sun =null;
//        Integer zh =null;
//        Map result =  new HashMap();
//        for (String s : strs) {
//            for (int i = 0; i < 16; i++) {
//                detail = s.split(":");
//                if (detail[0].equals("db"+i)) {
//                    detail[1].substring(0, detail[1].length()- 1);
//                    if (jsrt.length>2){
//                        jsrt = s.split(",");
//                        istr = detail[1].substring(0, jsrt[1].length() - 1);
//                        if (keys[0].equals("keys")) {
//                            keys = s.split("=");
//                            key = Integer.parseInt(keys[1].substring(0, keys[1].length() - 1));
//                        }
//                    }else{
//                    result.put(detail[0],jsrt[1]);
//                }
//                    //String keys = "keys=1,expires=0,avg_ttl=0";
//                    break;
//                }
//                sun =key;
//                zh = key+sun;
//            }
//
//        }
       return zh;
    }

    @Override
    public String getKeyspace() {
        String[] strs = redisUtil.getRedisInfo().split("\n");
        Map map = null;
        String memory = null;
        for (int i = 0; i < strs.length; i++) {
            String s = strs[i];
            String[] detail = s.split(":");
            if (detail[0].equals("keyspace")) {
                memory = detail[1].substring(0, detail[1].length() - 1);
                System.out.println(memory);
                break;
            }
        }
        System.out.println();
        return memory;

    }


    /**
     * @param pageSize   当前页面 数据个数
     * @param pageNumber 当前页面
     * @param id         切换redis db库数据
     * @param keysid     根据 keysid 查询单个
     * @return
     */
    @Override
    public List> getAllRedisVal2(Integer pageSize, Integer pageNumber, Integer id, String keysid) {
        LOGGER.info("======================开始 Redis查询数据======================");
        Long startTime = System.nanoTime();
        List> list = new ArrayList<>();
        int startIndex = pageSize * (pageNumber - 1) + 1;
        //       String redis = redisUtil.get("redis", id);
        String redisId = redisUtil.getRedisId(id);
        System.out.println("redis" + redisId);
        LOGGER.info("redis" + redisId);

        LettuceConnectionFactory connectionFactory = (LettuceConnectionFactory) redisTemplate.getConnectionFactory();
        if (connectionFactory != null && id != connectionFactory.getDatabase()) {
            LOGGER.info("当前所在的db=" + connectionFactory.getDatabase());
            connectionFactory.setDatabase(id);
            connectionFactory.afterPropertiesSet();
            redisTemplate.setConnectionFactory(connectionFactory);
            connectionFactory.resetConnection();

//            redisTemplate.opsForValue().set("redistest", "测试切换");
//            Object redisId1 = redisTemplate.opsForValue().get("redistest");
//            LOGGER.info("-------------=="+(String) redisId1);
            LOGGER.info("切换redisdb库成功当前所在的db=" + connectionFactory.getDatabase());
//            System.out.println("-------------e" + e);
        }
        //使用scan的方法
        Map result = (Map) redisTemplate.execute(new RedisCallback() {
            /**
             * @param redisConnection 连接redsi
             * @return
             * @throws DataAccessException
             */
            @Nullable
            @Override
            public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
                Cursor results = redisConnection.scan(new ScanOptions.ScanOptionsBuilder().match("*").build());
                List keys = new LinkedList<>();
                Map map = new HashMap<>();
                try {
                    int index = 1;
                    while (results.hasNext()) {

                        if (startIndex <= index && index < pageSize + startIndex) {
                            keys.add(new String(results.next(), "UTF-8"));
                        } else results.next();
                        index++;
                    }

                    map.put("count", index);
                    map.put("keys", keys);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                return map;
            }
        });
        List keys = (List) result.get("keys");
        long start = System.currentTimeMillis();
        for (String key : keys) {
            HashMap map = new HashMap<>();
            if (keysid != null ) {
                /*
                 * key 判断查询key的类型
                 * keysid判断传进来的key类型
                 * */
                Set set = stringRedisTemplate.keys("*" + keysid + "*");
                if (redisTemplate.type(key).code().equals("list")) {

                    assert set != null;
                    set.forEach(keyList -> {
                            if (Objects.requireNonNull(redisTemplate.type(keyList)).code().equals("list")){
                                List