[武汉|结业弟子]JAVA-王玉琛|2017年08月17日的日报-技能树.IT修真院

发表于： 2017-08-17 22:23:40

1 1060

今天完成的事情：改完BUG,调试。

昨天的bug，别人说是IDEA的问题换个开发工具用了STS。

spring在eclipse的基础上开发出来的一个开发工具。点击运行，正常启动。

运行效果图

登陆界面

后台界面

用redis做缓存，是通过redis-spring插件实现的，写了一个监控的页面

RedisInfoDetail

package com.wyc.entity;

import java.util.HashMap;
import java.util.Map;

public class RedisInfoDetail {
   private static Map<String, String> map = new HashMap<String, String>();
   
   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("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("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_peak", " Redis 的内存消耗峰值(以字节为单位)");
      map.put("used_memory_peak_human", "以人类可读的格式返回 Redis 的内存消耗峰值");
      map.put("used_memory_lua", "Lua 引擎所使用的内存大小（以字节为单位）");
      map.put("mem_fragmentation_ratio", "sed_memory_rss 和 used_memory 之间的比率");
      map.put("mem_allocator", "在编译时指定的， Redis 所使用的内存分配器。可以是 libc 、 jemalloc 或者 tcmalloc");
   }
   
   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 + "]";
   }
}

RedisService

package com.wyc.service;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSON;

import com.wyc.entity.Operate;
import com.wyc.entity.RedisInfoDetail;
import com.wyc.util.RedisUtil;
import redis.clients.util.Slowlog;

@Service
public class RedisService {
   
   @Autowired
   RedisUtil redisUtil;
   
   public List<RedisInfoDetail> getRedisInfo() {
      //获取redis服务器信息
      String info = redisUtil.getRedisInfo();
      List<RedisInfoDetail> ridList = new ArrayList<RedisInfoDetail>();
      String[] strs = info.split("\n");
      RedisInfoDetail rif = null;
      if (strs != null && strs.length > 0) {
         for (int i = 0; i < strs.length; i++) {
            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];
               rif.setKey(key);
               rif.setValue(value);
               ridList.add(rif);
            }
         }
      }
      return ridList;
   }
   
   //获取redis日志列表
   public List<Operate> getLogs(long entries) {
        List<Slowlog> list = redisUtil.getLogs(entries);
      List<Operate> opList = null;
      Operate op  = null;
      boolean flag = false;
      if (list != null && list.size() > 0) {
         opList = new LinkedList<Operate>();
         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<String,Object> getKeysSize() {
      long dbSize = redisUtil.dbSize();
      Map<String,Object> map = new HashMap<String, Object>();
      map.put("create_time", new Date().getTime());
      map.put("dbSize", dbSize);
      return map;
   }
   
   //获取当前redis使用内存大小情况
   public Map<String,Object> getMemeryInfo() {
      String[] strs = redisUtil.getRedisInfo().split("\n");
      Map<String, Object> map = null;
      for (int i = 0; i < strs.length; i++) {
         String s = strs[i];
         String[] detail = s.split(":");
         if (detail[0].equals("used_memory")) {
            map = new HashMap<String, Object>();
            map.put("used_memory",detail[1].substring(0, detail[1].length() - 1));
            map.put("create_time", new Date().getTime());
            break;
         }
      }
      return map;
   }
   private String getDateStr(long timeStmp) {
      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      return dateFormat.format(new Date(timeStmp));
   }
}

RedisUtil

package com.wyc.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Client;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.util.Slowlog;

import java.util.List;

@Component
public class RedisUtil {

   @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;
      } finally {
         // 返还到连接池
         jedis.close();
      }
   }

   // 获取日志列表
   public List<Slowlog> getLogs(long entries) {
      Jedis jedis = null;
      try {
         jedis = jedisPool.getResource();
         List<Slowlog> 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();
      }
   }
}

RedisController

package com.wyc.controller;

import java.util.List;

import com.alibaba.fastjson.JSON;
import com.wyc.entity.Operate;
import com.wyc.entity.RedisInfoDetail;
import com.wyc.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;


@Controller
@RequestMapping(value="redis")
public class RedisController {
   
   @Autowired
   RedisService redisService;
   
   //跳转到监控页面
   @RequestMapping(value="redisMonitor")
   public String redisMonitor(Model model) {
      //获取redis的info
      List<RedisInfoDetail> ridList = redisService.getRedisInfo();
      //获取redis的日志记录
      List<Operate> logList = redisService.getLogs(1000);
      //获取日志总数
      long logLen = redisService.getLogLen();
      model.addAttribute("infoList", ridList);
      model.addAttribute("logList", logList);
      model.addAttribute("logLen", logLen);
      return "redisMonitor";
   }
   //清空日志按钮
   @RequestMapping(value="logEmpty")
   @ResponseBody
   public String logEmpty(){
      return redisService.logEmpty();
   }
   
   //获取当前数据库中key的数量
   @RequestMapping(value="getKeysSize")
   @ResponseBody
   public String getKeysSize(){
      return JSON.toJSONString(redisService.getKeysSize());
   }
   
   //获取当前数据库内存使用大小情况
   @RequestMapping(value="getMemeryInfo")
   @ResponseBody
   public String getMemeryInfo(){
      return JSON.toJSONString(redisService.getMemeryInfo());
   }
}