1
package com.ruoyi.web.controller.monitor;
2

3
import org.apache.shiro.authz.annotation.RequiresPermissions;
4
import org.springframework.stereotype.Controller;
5
import org.springframework.ui.ModelMap;
6
import org.springframework.web.bind.annotation.GetMapping;
7
import org.springframework.web.bind.annotation.RequestMapping;
8
import com.ruoyi.common.core.controller.BaseController;
9
import com.ruoyi.framework.web.domain.Server;
10

11
/**
12
 * 服务器监控
13
 *
14
 * @author ruoyi
15
 */
16
@Controller
17
@RequestMapping("/monitor/server")
18
public class ServerController extends BaseController {
19
    private String prefix = "monitor/server";
20

21
    @RequiresPermissions("monitor:server:view")
22
    @GetMapping()
23
    public String server(ModelMap mmap) {
24
        Server server = new Server();
25
        server.copyTo();
26
        mmap.put("server", server);
27
        return prefix + "/server";
28
    }
29
}

1
package com.ruoyi.framework.web.domain;
2

3
import java.net.UnknownHostException;
4
import java.util.LinkedList;
5
import java.util.List;
6
import java.util.Properties;
7
import com.ruoyi.common.utils.Arith;
8
import com.ruoyi.common.utils.IpUtils;
9
import com.ruoyi.framework.web.domain.server.*;
10

11
/**
12
 * 服务器相关信息
13
 *
14
 * @author ruoyi
15
 */
16
public class Server {
17
    private static final int OSHI_WAIT_SECOND = 1000;
18

19
    /**
20
     * CPU相关信息
21
     */
22
    private Cpu cpu = new Cpu();
23

24
    /**
25
     * 内存相关信息
26
     */
27
    private Mem mem = new Mem();
28

29
    /**
30
     * JVM相关信息
31
     */
32
    private Jvm jvm = new Jvm();
33

34
    /**
35
     * 服务器相关信息
36
     */
37
    private Sys sys = new Sys();
38

39
    /**
40
     * 磁盘相关信息
41
     */
42
    private List<SysFile> sysFiles = new LinkedList<SysFile>();
43

44
    public Cpu getCpu() {
45
        return cpu;
46
    }
47

48
    public void setCpu(Cpu cpu) {
49
        this.cpu = cpu;
50
    }
51

52
    public Mem getMem() {
53
        return mem;
54
    }
55

56
    public void setMem(Mem mem) {
57
        this.mem = mem;
58
    }
59

60
    public Jvm getJvm() {
61
        return jvm;
62
    }
63

64
    public void setJvm(Jvm jvm) {
65
        this.jvm = jvm;
66
    }
67

68
    public Sys getSys() {
69
        return sys;
70
    }
71

72
    public void setSys(Sys sys) {
73
        this.sys = sys;
74
    }
75

76
    public List<SysFile> getSysFiles() {
77
        return sysFiles;
78
    }
79

80
    public void setSysFiles(List<SysFile> sysFiles) {
81
        this.sysFiles = sysFiles;
82
    }
83

84
    /**
85
     * 复制服务器信息
86
     */
87
    public void copyTo() {
88
        try {
89
            // CPU信息
90
            Cpu cpu = getCpu();
91
            CentralProcessor processor = SystemInfo.getInstance().getHardware().getProcessor();
92
            long[] prevTicks = processor.getSystemCpuLoadTicks();
93
            Thread.sleep(OSHI_WAIT_SECOND);
94
            long[] ticks = processor.getSystemCpuLoadTicks();
95
            long nice = ticks[TickType.NICE.getIndex()] - prevTicks[TickType.NICE.getIndex()];
96
            long irq = ticks[TickType.IRQ.getIndex()] - prevTicks[TickType.IRQ.getIndex()];
97
            long softirq = ticks[TickType.SOFTIRQ.getIndex()] - prevTicks[TickType.SOFTIRQ.getIndex()];
98
            long steal = ticks[TickType.STEAL.getIndex()] - prevTicks[TickType.STEAL.getIndex()];
99
            long cSys = ticks[TickType.SYSTEM.getIndex()] - prevTicks[TickType.SYSTEM.getIndex()];
100
            long user = ticks[TickType.USER.getIndex()] - prevTicks[TickType.USER.getIndex()];
101
            long iowait = ticks[TickType.IOWAIT.getIndex()] - prevTicks[TickType.IOWAIT.getIndex()];
102
            long idle = ticks[TickType.IDLE.getIndex()] - prevTicks[TickType.IDLE.getIndex()];
103
            long totalCpu = user + nice + cSys + idle + iowait + irq + softirq + steal;
104
            cpu.setCpuNum(processor.getLogicalProcessorCount());
105
            cpu.setTotal(totalCpu);
106
            cpu.setSys(cSys);
107
            cpu.setUsed(user);
108
            cpu.setWait(iowait);
109
            cpu.setFree(idle);
110

111
            // 内存信息
112
            Mem mem = getMem();
113
            GlobalMemory memory = SystemInfo.getInstance().getHardware().getMemory();
114
            long totalByte = memory.getTotal();
115
            long availableByte = memory.getAvailable();
116
            long usedByte = totalByte - availableByte;
117
            mem.setTotal(totalByte);
118
            mem.setUsed(usedByte);
119
            mem.setFree(availableByte);
120
            mem.setUsage(Arith.mul(Arith.div(usedByte, totalByte, 4), 100));
121

122
            // JVM信息
123
            Jvm jvm = getJvm();
124
            Properties props = System.getProperties();
125
            jvm.setTotal(Runtime.getRuntime().totalMemory());
126
            jvm.setMax(Runtime.getRuntime().maxMemory());
127
            jvm.setFree(Runtime.getRuntime().freeMemory());
128
            jvm.setVersion(props.getProperty("java.version"));
129
            jvm.setHome(props.getProperty("java.home"));
130
            jvm.setStartTime(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS,
131
                    Date.from(Instant.ofEpochMilli(ManagementFactory.getRuntimeMXBean().getStartTime()))));
132
            jvm.setRunTime(DateUtils.getDatePoor(DateUtils.getNowDate(), jvm.getStartTime()));
133
            jvm.setInputArgs(ManagementFactory.getRuntimeMXBean().getInputArguments());
134

135
            // 服务器信息
136
            Sys sys = getSys();
137
            InetAddress addr = InetAddress.getLocalHost();
138
            sys.setComputerName(addr.getHostName());
139
            sys.setComputerIp(IpUtils.getHostIp());
140
            sys.setOsName(props.getProperty("os.name"));
141
            sys.setOsArch(props.getProperty("os.arch"));
142
            sys.setUserDir(props.getProperty("user.dir"));
143

144
            // 磁盘信息
145
            List<SysFile> sysFiles = getSysFiles();
146
            FileSystem fileSystem = SystemInfo.getInstance().getOperatingSystem().getFileSystem();
147
            for (OSFileStore fs : fileSystem.getFileStores()) {
148
                SysFile sysFile = new SysFile();
149
                sysFile.setDirName(fs.getMount());
150
                sysFile.setSysTypeName(fs.getType());
151
                sysFile.setTypeName(fs.getName());
152
                sysFile.setTotal(fs.getTotalSpace());
153
                sysFile.setFree(fs.getUsableSpace());
154
                sysFile.setUsed(fs.getTotalSpace() - fs.getUsableSpace());
155
                sysFile.setUsage(Arith.mul(Arith.div(sysFile.getUsed(), sysFile.getTotal(), 4), 100));
156
                sysFiles.add(sysFile);
157
            }
158
        } catch (Exception e) {
159
            e.printStackTrace();
160
        }
161
    }
162
}

1
package com.ruoyi.framework.web.domain.server;
2

3
import com.ruoyi.common.utils.Arith;
4

5
/**
6
 * CPU相关信息
7
 *
8
 * @author ruoyi
9
 */
10
public class Cpu {
11
    /**
12
     * 核心数
13
     */
14
    private int cpuNum;
15

16
    /**
17
     * CPU总的使用率
18
     */
19
    private double total;
20

21
    /**
22
     * CPU系统使用率
23
     */
24
    private double sys;
25

26
    /**
27
     * CPU用户使用率
28
     */
29
    private double used;
30

31
    /**
32
     * CPU当前等待率
33
     */
34
    private double wait;
35

36
    /**
37
     * CPU当前空闲率
38
     */
39
    private double free;
40

41
    public int getCpuNum() {
42
        return cpuNum;
43
    }
44

45
    public void setCpuNum(int cpuNum) {
46
        this.cpuNum = cpuNum;
47
    }
48

49
    public double getTotal() {
50
        return Arith.round(Arith.mul(total, 100), 2);
51
    }
52

53
    public void setTotal(long total) {
54
        this.total = total;
55
    }
56

57
    public double getSys() {
58
        return Arith.div(Arith.mul(sys, 100), total, 2);
59
    }
60

61
    public void setSys(double sys) {
62
        this.sys = sys;
63
    }
64

65
    public double getUsed() {
66
        return Arith.div(Arith.mul(used, 100), total, 2);
67
    }
68

69
    public void setUsed(double used) {
70
        this.used = used;
71
    }
72

73
    public double getWait() {
74
        return Arith.div(Arith.mul(wait, 100), total, 2);
75
    }
76

77
    public void setWait(double wait) {
78
        this.wait = wait;
79
    }
80

81
    public double getFree() {
82
        return Arith.div(Arith.mul(free, 100), total, 2);
83
    }
84

85
    public void setFree(double free) {
86
        this.free = free;
87
    }
88
}

1
package com.ruoyi.web.controller.monitor;
2

3
import org.apache.shiro.authz.annotation.RequiresPermissions;
4
import org.springframework.beans.factory.annotation.Autowired;
5
import org.springframework.data.redis.core.RedisCallback;
6
import org.springframework.data.redis.core.RedisTemplate;
7
import org.springframework.stereotype.Controller;
8
import org.springframework.ui.ModelMap;
9
import org.springframework.web.bind.annotation.GetMapping;
10
import org.springframework.web.bind.annotation.RequestMapping;
11
import com.ruoyi.common.constant.Constants;
12
import com.ruoyi.common.core.controller.BaseController;
13
import com.ruoyi.common.core.redis.RedisCache;
14

15
import java.util.*;
16

17
/**
18
 * 缓存监控
19
 *
20
 * @author ruoyi
21
 */
22
@Controller
23
@RequestMapping("/monitor/cache")
24
public class CacheController extends BaseController {
25
    @Autowired
26
    private RedisTemplate<String, String> redisTemplate;
27

28
    private final static List<CacheInfo> caches = new ArrayList<CacheInfo>();
29
    {
30
        caches.add(new CacheInfo(Constants.LOGIN_TOKEN_KEY, "用户信息"));
31
        caches.add(new CacheInfo(Constants.SYS_DICT_KEY, "配置信息"));
32
        caches.add(new CacheInfo(Constants.CAPTCHA_CODE_KEY, "验证码"));
33
        caches.add(new CacheInfo(Constants.REPEAT_SUBMIT_KEY, "防重提交"));
34
        caches.add(new CacheInfo(Constants.RATE_LIMIT_KEY, "限流处理"));
35
        caches.add(new CacheInfo(Constants.PWD_ERR_CNT_KEY, "密码错误次数"));
36
    }
37

38
    @RequiresPermissions("monitor:cache:view")
39
    @GetMapping()
40
    public String cache(ModelMap mmap) {
41
        mmap.put("caches", caches);
42
        return "monitor/cache/cache";
43
    }
44

45
    @RequiresPermissions("monitor:cache:view")
46
    @GetMapping("/getNames")
47
    public String getCacheNames(ModelMap mmap) {
48
        mmap.put("caches", caches);
49
        return "monitor/cache/cache :: cacheNames";
50
    }
51

52
    @RequiresPermissions("monitor:cache:view")
53
    @GetMapping("/getKeys/{cacheName}")
54
    public String getCacheKeys(@PathVariable String cacheName, ModelMap mmap) {
55
        List<String> cacheKeys = redisTemplate.keys(cacheName + "*");
56
        mmap.put("cacheKeys", cacheKeys);
57
        mmap.put("cacheName", cacheName);
58
        return "monitor/cache/cache :: cacheKeys";
59
    }
60

61
    @RequiresPermissions("monitor:cache:view")
62
    @GetMapping("/getValue/{cacheName}/{cacheKey}")
63
    public String getCacheValue(@PathVariable String cacheName, @PathVariable String cacheKey, ModelMap mmap) {
64
        String cacheValue = redisTemplate.opsForValue().get(cacheKey);
65
        CacheInfo cacheInfo = new CacheInfo();
66
        cacheInfo.setCacheName(cacheName);
67
        cacheInfo.setCacheKey(cacheKey);
68
        cacheInfo.setCacheValue(cacheValue);
69
        mmap.put("cache", cacheInfo);
70
        return "monitor/cache/cache :: cacheValue";
71
    }
72

73
    @RequiresPermissions("monitor:cache:view")
74
    @GetMapping("/clearCacheName/{cacheName}")
75
    public String clearCacheName(@PathVariable String cacheName, ModelMap mmap) {
76
        redisTemplate.delete(redisTemplate.keys(cacheName + "*"));
77
        return "monitor/cache/cache :: cacheNames";
78
    }
79

80
    @RequiresPermissions("monitor:cache:view")
81
    @GetMapping("/clearCacheKey/{cacheKey}")
82
    public String clearCacheKey(@PathVariable String cacheKey, ModelMap mmap) {
83
        redisTemplate.delete(cacheKey);
84
        return "monitor/cache/cache :: cacheKeys";
85
    }
86

87
    @RequiresPermissions("monitor:cache:view")
88
    @GetMapping("/clearCacheAll")
89
    public String clearCacheAll(ModelMap mmap) {
90
        redisTemplate.execute((RedisCallback<Boolean>) connection -> {
91
            connection.flushAll();
92
            return true;
93
        });
94
        return "monitor/cache/cache :: cacheNames";
95
    }
96

97
    static class CacheInfo {
98
        private String cacheName;
99
        private String cacheKey;
100
        private String cacheValue;
101
        private String remark;
102

103
        public CacheInfo() {}
104

105
        public CacheInfo(String cacheName, String remark) {
106
            this.cacheName = cacheName;
107
            this.remark = remark;
108
        }
109

110
        // Getter 和 Setter 省略...
111
    }
112
}

1
package com.ruoyi.web.controller.monitor;
2

3
import java.util.List;
4
import org.apache.shiro.session.Session;
5
import org.apache.shiro.session.mgt.eis.SessionDAO;
6
import org.apache.shiro.authz.annotation.RequiresPermissions;
7
import org.springframework.beans.factory.annotation.Autowired;
8
import org.springframework.stereotype.Controller;
9
import org.springframework.ui.ModelMap;
10
import org.springframework.web.bind.annotation.*;
11
import com.ruoyi.common.core.controller.BaseController;
12
import com.ruoyi.common.core.domain.AjaxResult;
13
import com.ruoyi.common.core.page.TableDataInfo;
14
import com.ruoyi.common.core.text.Convert;
15
import com.ruoyi.common.utils.ShiroUtils;
16
import com.ruoyi.framework.shiro.session.OnlineSession;
17
import com.ruoyi.system.domain.SysUserOnline;
18
import com.ruoyi.system.service.ISysUserOnlineService;
19

20
/**
21
 * 在线用户监控
22
 *
23
 * @author ruoyi
24
 */
25
@Controller
26
@RequestMapping("/monitor/online")
27
public class OnlineController extends BaseController {
28
    private String prefix = "monitor/online";
29

30
    @Autowired
31
    private ISysUserOnlineService userOnlineService;
32

33
    @Autowired
34
    private SessionDAO sessionDAO;
35

36
    @RequiresPermissions("monitor:online:view")
37
    @GetMapping()
38
    public String online() {
39
        return prefix + "/online";
40
    }
41

42
    @RequiresPermissions("monitor:online:list")
43
    @PostMapping("/list")
44
    @ResponseBody
45
    public TableDataInfo list(SysUserOnline userOnline) {
46
        startPage();
47
        List<SysUserOnline> list = userOnlineService.selectUserOnlineList(userOnline);
48
        return getDataTable(list);
49
    }
50

51
    @RequiresPermissions("monitor:online:batchForceLogout")
52
    @PostMapping("/batchForceLogout")
53
    @ResponseBody
54
    public AjaxResult batchForceLogout(@RequestParam("ids[]") String[] ids) {
55
        for (String sessionId : ids) {
56
            try {
57
                Session session = sessionDAO.readSession(sessionId);
58
                if (session != null) {
59
                    session.setTimeout(1000);
60
                    userOnlineService.deleteById(sessionId);
61
                }
62
            } catch (Exception e) {
63
                // 忽略异常
64
            }
65
        }
66
        return success();
67
    }
68

69
    @RequiresPermissions("monitor:online:forceLogout")
70
    @PostMapping("/forceLogout")
71
    @ResponseBody
72
    public AjaxResult forceLogout(String sessionId) {
73
        try {
74
            Session session = sessionDAO.readSession(sessionId);
75
            if (session != null) {
76
                session.setTimeout(1000);
77
                userOnlineService.deleteById(sessionId);
78
            }
79
        } catch (Exception e) {
80
            // 忽略异常
81
        }
82
        return success();
83
    }
84
}

1
package com.ruoyi.framework.config;
2

3
import java.util.HashMap;
4
import java.util.Map;
5
import javax.sql.DataSource;
6
import org.springframework.boot.context.properties.ConfigurationProperties;
7
import org.springframework.context.annotation.Bean;
8
import org.springframework.context.annotation.Configuration;
9
import org.springframework.context.annotation.Primary;
10
import com.alibaba.druid.pool.DruidDataSource;
11
import com.alibaba.druid.support.http.StatViewServlet;
12
import com.alibaba.druid.support.http.WebStatFilter;
13
import org.springframework.boot.web.servlet.FilterRegistrationBean;
14
import org.springframework.boot.web.servlet.ServletRegistrationBean;
15

16
/**
17
 * druid 配置多数据源
18
 *
19
 * @author ruoyi
20
 */
21
@Configuration
22
public class DruidConfig {
23
    @Bean
24
    @ConfigurationProperties("spring.datasource.druid.master")
25
    public DataSource masterDataSource() {
26
        DruidDataSource dataSource = new DruidDataSource();
27
        return dataSource;
28
    }
29

30
    @Bean
31
    @ConfigurationProperties("spring.datasource.druid.slave")
32
    public DataSource slaveDataSource() {
33
        DruidDataSource dataSource = new DruidDataSource();
34
        return dataSource;
35
    }
36

37
    /**
38
     * Druid 监控页面
39
     */
40
    @Bean
41
    public ServletRegistrationBean<StatViewServlet> statViewServlet() {
42
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(
43
                new StatViewServlet(), "/druid/*");
44
        // 配置监控页面访问登录名和密码
45
        Map<String, String> initParams = new HashMap<>();
46
        initParams.put("loginUsername", "admin");
47
        initParams.put("loginPassword", "123456");
48
        // 是否允许删除数据
49
        initParams.put("resetEnable", "false");
50
        bean.setInitParameters(initParams);
51
        return bean;
52
    }
53

54
    /**
55
     * Druid Web 监控过滤器
56
     */
57
    @Bean
58
    public FilterRegistrationBean<WebStatFilter> webStatFilter() {
59
        FilterRegistrationBean<WebStatFilter> bean = new FilterRegistrationBean<>(new WebStatFilter());
60
        Map<String, String> initParams = new HashMap<>();
61
        initParams.put("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
62
        bean.setInitParameters(initParams);
63
        bean.addUrlPatterns("/*");
64
        return bean;
65
    }
66
}