springboot 连接redis并监控

首先我们需要一个简单的springboot项目，这个项目可以在官网或自己手动构建，不做过多的阐述！

当我们有了一个springboot项目之后，我们就可以整合redis了！

1.java来操作redis有封装好的jedis包，所以首先我们需要给pom文件中引入我们所依赖的jedis

<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.0.0</version>
        </dependency>

2.在我们添加了jedis之后，我们在resources中新建redis的properties文件，实现redis的配置文件读取，这样方便我们以后在不同的服务器测试我们的redis，如下所示：

这里是redis.propreties的简单配置

#redis 服务器ip
redis.host=192.168.0.107
#redis.host=192.168.0.125
#redis 端口号
redis.port=6379
#redis 密码
redis.pass=
#maxIdle 最大空闲连接数
redis.maxIdle=10
#minIdle 最小空闲连接数
redis.minIdle=5
#maxTotal 最大活跃连接数
redis.maxTotal=10
#timeout 与服务器建立连接的超时时间
redis.timeout=5000
#jedis池没有连接对象返回时，等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。
#如果超过等待时间，则直接抛出JedisConnectionException
redis.maxWaitMillis=3000
redis.testOnBorrow=false
redis.testOnReturn=false
redis.database=0

3.接下来我们就可以写一个redis的工具来创建redis的连接池，用来加载Redis并初始化一系列的配置，读取我们刚才创建的redis.propreties文件

package com.xiaobai.test.redis;

import org.mybatis.logging.Logger;
import org.mybatis.logging.LoggerFactory;
import redis.clients.jedis.Client;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.io.IOException;
import java.util.Properties;

/**
 * redis工具类
 */
public class RedisUtils {

    private  static  final Logger logger = LoggerFactory.getLogger(RedisUtils.class);
    private static String redisConfigFile = "static/redis/redis.properties";
    public static JedisPool jedisPool;
    //初始化时将Jedis放入本地的线程内存中
    private static ThreadLocal<Jedis> local = new ThreadLocal<Jedis>();

    /**
     * 初始化redis连接池
     */
    static {
        try {
            //设置jedisPoolConfig
            Properties properties = new Properties();
            //加载配置文件
            properties.load(RedisUtils.class.getClassLoader().getResourceAsStream(redisConfigFile));

            JedisPoolConfig config = new JedisPoolConfig();
            //设置连接池属性
            config.setMaxIdle(Integer.valueOf(properties.getProperty("redis.maxIdle")));
            config.setMaxTotal(Integer.valueOf(properties.getProperty("redis.maxTotal")));
            config.setMinIdle(Integer.valueOf(properties.getProperty("redis.minIdle")));
            config.setMaxWaitMillis(Integer.valueOf(properties.getProperty("redis.maxWaitMillis")));

            //实例化jedis池
            jedisPool = new JedisPool(config,properties.getProperty("redis.host"),
                    Integer.valueOf(properties.getProperty("redis.port")),
                    Integer.valueOf(properties.getProperty("redis.timeout")),
                    "".equals(properties.getProperty("redis.pass"))?null:properties.getProperty("redis.pass"));

            System.out.println("redis连接池初始化成功！");
        } catch ( IOException e ) {
            e.printStackTrace();
            System.out.println("redis连接池初始化失败！");
        }
    }




    /**
     * 获取连接
     * @return
     */
    public static Jedis cli_single(){
        Jedis jedis = local.get();
        if (jedis == null){
            jedis = jedisPool.getResource();
            local.set(jedis);
        }
        return  jedis;
    }

    // 获取redis 服务器信息
    public static String getRedisInfo(Jedis jedis) {

        try {
            Client client = jedis.getClient();
            client.info();
            String info = client.getBulkReply();
            return info;
        } finally {
            // 返还到连接池
            jedis.close();
        }
    }

    /**
     * 关闭redis连接
     */
    public static void closeConn(){
        Jedis jedis =local.get();
        if(jedis!=null){
            jedis.close();
        }
        local.set(null);
    }

}

 4.redis的工具创建好之后，我们就可以进行连接测试了

@RequestMapping("/getList")
    @ResponseBody
    public LayuiParam getList(){
        List<RedisModel> list = new ArrayList<>();
        RedisModel redisModel;
        //获取本机信息
//        ConfigModel configModel = LocalUtils.config();
        Jedis jedis = RedisUtils.cli_single();
        //获取
        String info = RedisUtils.getRedisInfo(jedis);
        String[] strs = info.split("\r\n");
        if (strs != null && strs.length > 0){
            for (int i = 0; i < strs.length; i++) {
                String s = strs[i];
                String[] str = s.split(":");
                if (str != null && str.length > 1){
                    redisModel = new RedisModel();
                    redisModel.setKeyM(str[0]);
                    redisModel.setValueM(str[1]);
                    list.add(redisModel);
                    if ("used_cpu_sys".equals(str[0])){
                        int now = getSecondTimestamp(new Date());
                        redisModel = new RedisModel();
                        redisModel.setKeyM("cpu使用率");
                        double value = Double.parseDouble(str[1]);
                        //计算cpu使用率
                        double percent = ((value - used_cpu_sys_before) / (now - befor)) * 100;
                        DecimalFormat    df   = new DecimalFormat("######0.00");
                        String format = df.format(percent);
                        //cpu对象承载
                        redisModel.setValueM(format);
                        list.add(redisModel);
                        redisModel = new RedisModel();
                        redisModel.setKeyM("cpu承载");
                        boolean flag = (value - used_cpu_sys_before) / (now - befor) < 0.9;
                        if (flag){
                            redisModel.setValueM("正常！");
                        }else{
                            redisModel.setValueM("过载警告！");
                        }
                        list.add(redisModel);
                        used_cpu_sys_before = value;
                        befor = now;
                    }
                }
            }
        }
        RedisUtils.closeConn();
        return LayuiParam.successInfo(list.size(), "成功", list);
    }

5.这里我们要计算redis的cpu使用率，和cpu过载警告，就要使用到时间差去计算，下面是时间差的方法

/**
     * 精确到秒的时间戳
     * @param date
     * @return
     */
    public static int getSecondTimestamp(Date date){
        if (null == date) {
            return 0;
        }
        String timestamp = String.valueOf(date.getTime());
        int length = timestamp.length();
        if (length > 3) {
            return Integer.valueOf(timestamp.substring(0,length-3));
        } else {
            return 0;
        }
    }

基本的redis监控我们就可以实现了，这里只是做了一个简单的redis监测，具体的东西可能还要根据不同的业务需求去处理。

若有不足之处，请留言指出，互勉！