[大数据]java远程监控redis

1.pom配置

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

2.springboot application.yml配置

单机

spring;
  redis:
    database: 3
    host: 10.136.88.94
    port: 6379
    timeout: 3000
#    password: bitnami
    connect-timeout: 5000

集群

spring:
  redis:
    database: 0
    timeout: 3000
#    password: bitnami
    connect-timeout: 5000
    cluster:
      nodes: 192.168.1.4:6379,192.168.1.4:6380,192.168.1.4:6381

?3.RedisTemplate初始化

@Configuration
@AutoConfigureAfter(SafeAppApplication.class)
public class RedisConfig {
    /**
     * 由于原生的redis自动装配，在存储key和value时，没有设置序列化方式，故自己创建redisTemplate实例
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

?4.监控代码

单机

RedisConnection redisConnection = redisTemplate.getRequiredConnectionFactory().getConnection();
            Properties info = redisConnection.info();
            monitor(info,redisIp);

集群

 RedisClusterConnection clusterConnection = redisTemplate.getRequiredConnectionFactory().getClusterConnection();

            Iterable<RedisClusterNode> clusterNodes =  clusterConnection.clusterGetNodes();
            for(RedisClusterNode node : clusterNodes){

                Properties info = clusterConnection.info(new RedisClusterNode(node.getHost(),node.getPort()));
                monitor(info,node.getHost());
            }

monitor方法

public void monitor(Properties info,String ip){
        String totalMemStr = info.getProperty("total_system_memory");
        String usedMemStr =  info.getProperty("used_memory_rss");
        //总内存
        Long totalMem = Long.parseLong(totalMemStr);
        //使用内存
        Long userdMem =  Long.parseLong(usedMemStr);
        int mem = Math.round(userdMem*100/totalMem);

        String usedCpuSysStr = info.getProperty("used_cpu_sys");
        String usedCpuSysChdStr =  info.getProperty("used_cpu_sys_children");
        String usedCpuUserStr = info.getProperty("used_cpu_user");
        String usedCpuUserChdStr =  info.getProperty("used_cpu_user_children");

        Double usedCpuSys = Double.parseDouble(usedCpuSysStr);
        Double usedCpuSysChd =  Double.parseDouble(usedCpuSysChdStr);
        Double usedCpuUser =  Double.parseDouble(usedCpuUserStr);
        Double usedCpuUserChd =  Double.parseDouble(usedCpuUserChdStr);
        
        //cpu占用时间减去上次占用总时间除以时间
        int cpu = (int)Math.round(((totalCpu - oldTotalCpu)/((new Date().getTime())-oldTime.getTime()/1000))*100);
}

5.redis info参数说明

Server 服务器参数

redis_version:3.2.11 # redis版本

redis_git_sha1:00000000 # Git SHA1

redis_git_dirty:0 # Git dirty flag

redis_build_id:20886e8636ba9141 # redis build id (这里三个不用理会，估计也就是git相关的校验和构建)

redis_mode:standalone # redis运行模式，这里是单机模式，集群则为cluster

os:Linux 2.6.32-042stab123.3 x86_64 # 操作系统的版本

arch_bits:64 # 64位

multiplexing_api:epoll # 事件循环处理机制epoll（可以跟select和poll对比下，epoll性能好）

gcc_version:4.8.5 # gcc版本

process_id:15148 # 进程id

run_id:270fdea9384db4b458c4d0dc7d77c4d872a8cd16 # redis服务器随机数标识（用于Sentinel和Cluster集群）

tcp_port:9736 # 监听的端口

uptime_in_seconds:198353 # redis上线之后的时间：秒

uptime_in_days:2 # # redis上线之后的天数

hz:10 # redis内部调度（进行关闭timeout的客户端，删除过期key等等）频率，程序规定serverCron每秒运行10次。

lru_clock:3737003 # 每分钟自增的时钟,用于LRU管理,该时钟100ms(hz=10,因此每1000ms/10=100ms执行一次定时任务)更新一次。

executable:/root/soft/redis-3.2.11/src/redis-server # redis服务启动执行的路径

config_file:/root/soft/redis-3.2.11/redis.conf # 配置文件路径

Clients 客户端信息

connected_clients:11 # 客户端的连接数（不包含salve的连接）

client_longest_output_list:0 # 当前连接的客户端当中，最长的输出列表，用client list命令观察omem字段最大值

client_biggest_input_buf:0 # 当前连接的客户端当中，最大输入缓存，用client list命令观察qbuf和qbuf-free两个字段最大值

blocked_clients:0 # 客户端阻塞数(使用BLPOP, BRPOP, BRPOPLPUSH命令)

Memory 内存信息

used_memory:1143896 # redis分配的内存(standard libc, jemalloc,tcmalloc) Byte

used_memory_human:1.09M # 以人类可读的redis分配的内存总大小

used_memory_rss:2666496 # 占用操作系统的资源大小 Byte

used_memory_rss_human:2.54M # 以人类可读的，redis从操作系统分配的内存大小（常驻集大小）

used_memory_peak:1649536 #

used_memory_peak_human:1.57M # redis内存消耗峰值

total_system_memory:4294967296 #

total_system_memory_human:4.00G # 操作系统内存总大小

used_memory_lua:37888 #

used_memory_lua_human:37.00K # lua使用的内存大小

maxmemory:0 #

maxmemory_human:0B # redis使用的最大内存限制，有设置的话会执行相应的淘汰机制策略与下面结合使用

maxmemory_policy:noeviction # 内存淘汰机制，默认noeviction不淘汰

mem_fragmentation_ratio:2.33 # used_memory_rss和used_memory之间的比率，小于1表示使用了swap，大于1表示碎片比较多

mem_allocator:jemalloc-4.0.3 # 在编译时指定的redis所使用的内存分配器。可以是libc、jemalloc或者tcmalloc

Persistence 持久化（rdb和aof相关）

loading:0 # 服务器是否正在加载持久化文件

rdb_changes_since_last_save:4 # 最近生成rdb文件，写入命令的个数，即有多少写入命令没有持久化

rdb_bgsave_in_progress:0 # 服务器是否正在创建rdb文件

rdb_last_save_time:1513686198 # 最近创建rdb的时间戳，当前时间戳-rdb_last_save_time=多少秒没有生成rdb

rdb_last_bgsave_status:ok # 最近一次rdb保存结果

rdb_last_bgsave_time_sec:0 # 最近一个保存rdb消耗的时间（秒）

rdb_current_bgsave_time_sec:-1 # 当前保存rdb耗时多少秒

aof_enabled:0 # 是否开启了aof，1是开

aof_rewrite_in_progress:0 # aof的rewrite是否正在进行中

aof_rewrite_scheduled:0 # rewrite任务计划，当客户端发送bgrewriteaof指令，如果当前rewrite子进程正在执行，那么将客户端请求的bgrewriteaof变为计划任务，待aof子进程结束后执行rewrite

aof_last_rewrite_time_sec:-1 # 最近一次aof rewrite耗时长

aof_current_rewrite_time_sec:-1 # 当前保存aof rewrite耗时多少秒

aof_last_bgrewrite_status:ok # 最近一次aof rewrite保存结果

aof_last_write_status:ok # 最近一次aof写入的状态

Stats 统计信息

total_connections_received:981874 # 新创建连接个数,如果新创建连接过多，过度地创建和销毁连接对性能有影响，说明短连接严重或连接池使用有问题，需调研代码的连接设置

total_commands_processed:1019076 # redis处理的命令数

instantaneous_ops_per_sec:0 # redis当前的qps，redis内部较实时的每秒执行的命令数

total_net_input_bytes:52200893 # redis网络入口流量字节数

total_net_output_bytes:13018780 # redis网络出口流量字节数

instantaneous_input_kbps:0.00 # redis网络入口kps

instantaneous_output_kbps:0.00 # redis网络出口kps

rejected_connections:0 # 拒绝的连接个数，redis连接个数达到maxclients限制，拒绝新连接的个数

sync_full:0 # 主从完全同步成功次数

sync_partial_ok:0 # 主从部分同步成功次数

sync_partial_err:0 # 主从部分同步失败次数

expired_keys:0 # 运行以来过期的key的数量

evicted_keys:0 # 运行以来剔除(超过了maxmemory后)的key的数量

keyspace_hits:8357 # 命中次数

keyspace_misses:8 # 没命中次数

pubsub_channels:0 # 当前使用中的channel数量

pubsub_patterns:0 # 当前使用的模式的数量

latest_fork_usec:164 # 最近一次fork操作阻塞redis进程的耗时数，单位微秒

migrate_cached_sockets:0 # socket缓冲？

Replication 复制(主从)信息

role:master # 实例充当的角色

connected_slaves:0 # 有多少从节点slave连接

master_repl_offset:0 # 复制偏移量

repl_backlog_active:0 # 复制积压缓冲区是否开启

repl_backlog_size:1048576 # 复制积压缓冲大小

repl_backlog_first_byte_offset:0 # 复制积压缓冲区里偏移量

repl_backlog_histlen:0 # 等于 master_repl_offset - repl_backlog_first_byte_offset,该值不会超过repl_backlog_size的大小

CPU CPU相关信息

used_cpu_sys:418.91 # redis主进程占用核心态的CPU总耗时

used_cpu_user:85.45 # redis主进程占用用户态的CPU总耗时

used_cpu_sys_children:0.27 # 后台进程占用核心态的CPU总耗时

used_cpu_user_children:0.28 # 后台进程占用用户态的CPU总耗时

Cluster 集群相关

cluster_enabled:0 # 是否开启集群模式 0,没有

Keyspace 数据库相关统计

db0:keys=3,expires=0,avg_ttl=0 # 数据库db0的key数量，带有生存期的key数量，平均存活时间

由于上面的信息是基于单机模式的，所以有其它信息并没有显示出来，比如常用的主从模式，这时信息会增加很多，如下：

Replication(主从信息，master上显示的信息)

role:master #实例的角色，是master or slave

connected_slaves:1 #连接的slave实例个数

slave0:ip=192.168.64.104,port=9021,state=online,offset=6713173004,lag=0 #lag从库多少秒未向主库发送REPLCONF命令

master_repl_offset:6713173145 #主从同步偏移量,此值如果和上面的offset相同说明主从一致没延迟

repl_backlog_active:1 #复制积压缓冲区是否开启

repl_backlog_size:134217728 #复制积压缓冲大小

repl_backlog_first_byte_offset:6578955418 #复制缓冲区里偏移量的大小

repl_backlog_histlen:134217728 #此值等于 master_repl_offset - repl_backlog_first_byte_offset,该值不会超过repl_backlog_size的大小

Replication(主从信息，slave上显示的信息)

role:slave #实例的角色，是master or slave

master_host:192.168.64.102 #此节点对应的master的ip

master_port:9021 #此节点对应的master的port

master_link_status:up #slave端可查看它与master之间同步状态,当复制断开后表示down

master_last_io_seconds_ago:0 #主库多少秒未发送数据到从库?

master_sync_in_progress:0 #从服务器是否在与主服务器进行同步

slave_repl_offset:6713173818 #slave复制偏移量

slave_priority:100 #slave优先级

slave_read_only:1 #从库是否设置只读

connected_slaves:0 #连接的slave实例个数

master_repl_offset:0

repl_backlog_active:0 #复制积压缓冲区是否开启

repl_backlog_size:134217728 #复制积压缓冲大小

repl_backlog_first_byte_offset:0 #复制缓冲区里偏移量的大小

repl_backlog_histlen:0 #此值等于 master_repl_offset - repl_backlog_first_byte_offset,该值不会超过repl_backlog_size的大小