服务器性能监控

可以在平台上集成以下代码，来获取服务器的实时状态，包括CPU、内存、磁盘、JVM用量、磁盘I/O以及其他相关信息。

可以定时执行后，将结果缓存到redis，考虑到分布式集群的情况，可以采用HASH结构存储，field为节点IP，value为结果List。List按照时间顺序保存结果，需要控制最大长度，例如10或者20

1. 引入依赖

```xml
<dependency>
	<groupId>com.github.oshi</groupId>
	<artifactId>oshi-core</artifactId>
	<version>6.3.2</version>
</dependency>
```

2. 实体类

- Server

```java

import com.acrel.utils.ArithUtils;
import com.acrel.utils.GsonUtils;
import com.acrel.utils.LocalDateUtils;
import lombok.Data;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.CentralProcessor.TickType;
import oshi.hardware.GlobalMemory;
import oshi.hardware.HWDiskStore;
import oshi.hardware.HardwareAbstractionLayer;
import oshi.hardware.NetworkIF;
import oshi.software.os.FileSystem;
import oshi.software.os.OSFileStore;
import oshi.software.os.OperatingSystem;
import oshi.util.Util;

import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;

@Data
public class Server {

private static final int OSHI_WAIT_SECOND = 1000;
    public static final Long EXPIRE_TIME = 10 * 60 * 1000L;
    public static final Long VISIBLE_TIME = 6 * 10 * 60 * 1000L;

/**
     * 节点信息
     */
    private String ip;

/**
     * 时间戳
     */
    private Long timestamp;

/**
     * CPU相关信息
     */
    private Cpu cpu = new Cpu();

/**
     * 內存相关信息
     */
    private Mem mem = new Mem();

/**
     * JVM相关信息
     */
    private Jvm jvm = new Jvm();

/**
     * 服务器相关信息
     */
    private Sys sys = new Sys();

/**
     * 磁盘信息
     */
    private Disk disk;

/**
 * 磁盘IO
 */
 private List<IORate> diskIORates = new ArrayList<>();

/**
 * 网络IO
 */
 private List<IORate> networkIORates = new ArrayList<>();

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

public Server() {
    }

public Server(String ip) {
        this.ip = ip;
    }

public List<ServerAlarm> alarm() {

//todo
 return new ArrayList<>();
 }

public void generate() {
        try {
            this.timestamp = LocalDateUtils.unixTimestamp();
            SystemInfo si = new SystemInfo();
            HardwareAbstractionLayer hal = si.getHardware();
            generateCpuInfo(hal.getProcessor());
            generateMemInfo(hal.getMemory());
            generateDiskIORate(hal.getDiskStores());
            generateNetworkIORate(hal.getNetworkIFs());
            generateSysInfo();
            OperatingSystem os = si.getOperatingSystem();
            generateSysFiles(os);
            calcDisk(os);
            generateJvmInfo();
        } catch (Exception e) {
        }
    }

/**
 * 获取磁盘IO
 *
 * @param stores
 */
 private void generateDiskIORate(List<HWDiskStore> stores) {
 if (stores == null || stores.isEmpty()) {
 return;
 }
 for (HWDiskStore store : stores) {
 try {
 HWDiskStore disk = store;
 long startRead = disk.getReadBytes();
 long startWrite = disk.getWriteBytes();
 // 等待1秒
 Thread.sleep(1000);
 // 更新磁盘属性
 disk.updateAttributes();
 long endRead = disk.getReadBytes();
 long endWrite = disk.getWriteBytes();
 long readRate = (endRead - startRead) / 1000;
 long writeRate = (endWrite - startWrite) / 1000;
 IORate ioRate = new IORate();
 ioRate.setInRate(writeRate);
 ioRate.setOutRate(readRate);
 ioRate.setName(disk.getName());
 this.diskIORates.add(ioRate);
 } catch (Exception ignored) {
 }
 }
 }

/**
 * 获取网络IO
 */
 private void generateNetworkIORate(List<NetworkIF> networkIFs) {
 if (networkIFs == null || networkIFs.isEmpty()) {
 return;
 }
 for (NetworkIF net : networkIFs) {
 try {
 net.updateAttributes();

long startRecv = net.getBytesRecv();
                long startSent = net.getBytesSent();

Thread.sleep(1000);
                net.updateAttributes();

long endRecv = net.getBytesRecv();
                long endSent = net.getBytesSent();

long recvRate = (endRecv - startRecv) / 1000;
                long sentRate = (endSent - startSent) / 1000;
                IORate ioRate = new IORate();
                ioRate.setInRate(recvRate);
                ioRate.setOutRate(sentRate);
                ioRate.setName(net.getName());
                this.networkIORates.add(ioRate);
            } catch (Exception ignored) {
            }
        }
    }

/**
     * 设置CPU信息
     */
    private void generateCpuInfo(CentralProcessor processor) {
        // CPU信息
        long[] prevTicks = processor.getSystemCpuLoadTicks();
        Util.sleep(OSHI_WAIT_SECOND);
        long[] ticks = processor.getSystemCpuLoadTicks();
        long nice = ticks[TickType.NICE.getIndex()] - prevTicks[TickType.NICE.getIndex()];
        long irq = ticks[TickType.IRQ.getIndex()] - prevTicks[TickType.IRQ.getIndex()];
        long softirq = ticks[TickType.SOFTIRQ.getIndex()] - prevTicks[TickType.SOFTIRQ.getIndex()];
        long steal = ticks[TickType.STEAL.getIndex()] - prevTicks[TickType.STEAL.getIndex()];
        long cSys = ticks[TickType.SYSTEM.getIndex()] - prevTicks[TickType.SYSTEM.getIndex()];
        long user = ticks[TickType.USER.getIndex()] - prevTicks[TickType.USER.getIndex()];
        long iowait = ticks[TickType.IOWAIT.getIndex()] - prevTicks[TickType.IOWAIT.getIndex()];
        long idle = ticks[TickType.IDLE.getIndex()] - prevTicks[TickType.IDLE.getIndex()];
        long totalCpu = user + nice + cSys + idle + iowait + irq + softirq + steal;
        cpu.setCoreNum(processor.getLogicalProcessorCount());
        cpu.setTotal(totalCpu);
        cpu.setSys(cSys);
        cpu.setUsed(user);
        cpu.setWait(iowait);
        cpu.setFree(idle);
        cpu.setUsage(ArithUtils.mul(ArithUtils.div(user, totalCpu, 4), 100));
    }

/**
     * 设置内存信息
     */
    private void generateMemInfo(GlobalMemory memory) {
        mem.setTotal(memory.getTotal());
        mem.setUsed(memory.getTotal() - memory.getAvailable());
        mem.setFree(memory.getAvailable());
    }

/**
     * 设置服务器信息
     */
    private void generateSysInfo() {
        Properties props = System.getProperties();
        sys.setOsName(props.getProperty("os.name"));
        sys.setOsArch(props.getProperty("os.arch"));
        sys.setUserDir(props.getProperty("user.dir"));
    }

/**
     * 设置Java虚拟机
     */
    private void generateJvmInfo() throws UnknownHostException {
        Properties props = System.getProperties();
        jvm.setTotal(Runtime.getRuntime().totalMemory());
        jvm.setMax(Runtime.getRuntime().maxMemory());
        jvm.setFree(Runtime.getRuntime().freeMemory());
        jvm.setVersion(props.getProperty("java.version"));
        jvm.setHome(props.getProperty("java.home"));
    }

/**
 * 设置磁盘信息
 */
 private void generateSysFiles(OperatingSystem os) {
 FileSystem fileSystem = os.getFileSystem();
 List<OSFileStore> fsArray = fileSystem.getFileStores();
 for (int i = 0; i < fsArray.size(); i++) {
 OSFileStore fs = fsArray.get(i);
 long free = fs.getUsableSpace();
 long total = fs.getTotalSpace();
 long used = total - free;
 SysFile sysFile = new SysFile();
 sysFile.setDirName(fs.getMount());
 sysFile.setSysTypeName(fs.getType());
 sysFile.setTypeName(fs.getName());
 sysFile.setTotal(convertFileSize(total));
 sysFile.setFree(convertFileSize(free));
 sysFile.setUsed(convertFileSize(used));
 sysFile.setUsage(ArithUtils.mul(ArithUtils.div(used, total, 4), 100));
 sysFiles.add(sysFile);
 }
 }

/**
 * 计算磁盘总用量
 *
 * @param os
 */
 private void calcDisk(OperatingSystem os) {
 FileSystem fileSystem = os.getFileSystem();
 List<OSFileStore> fsArray = fileSystem.getFileStores();
 switch (SystemInfo.getCurrentPlatform()) {
 case LINUX:
 this.disk = calcLinuxDisk(fsArray);
 break;
 case WINDOWS:
 this.disk = calcWindowsDisk(fsArray);
 break;
 case MACOS:
 this.disk = calcMacOSDisk(fsArray);
 break;
 }
 }

private Disk calcLinuxDisk(List<OSFileStore> fsArray) {
 Disk disk = new Disk();
 long diskTotal = 0L;
 long diskUsed = 0L;
 long diskFree = 0L;
 Map<String, String> tempDir = new HashMap<>();
 for (OSFileStore fs : fsArray) {
 String dir = fs.getMount();
 if (tempDir.containsKey(dir)) {
 continue;
 }
 tempDir.put(dir, dir);
 long total = fs.getTotalSpace();
 diskTotal += total;
 long free = fs.getUsableSpace();
 diskFree += free;
 long used = total - free;
 diskUsed += used;
 }
 disk.setTotal(convertFileSize(diskTotal));
 disk.setUsed(convertFileSize(diskUsed));
 disk.setFree(convertFileSize(diskFree));
 disk.setUsage(ArithUtils.mul(ArithUtils.div(diskUsed, diskTotal, 4), 100));
 return disk;
 }

private Disk calcWindowsDisk(List<OSFileStore> fsArray) {
 Disk disk = new Disk();
 long diskTotal = 0L;
 long diskUsed = 0L;
 long diskFree = 0L;
 for (OSFileStore fs : fsArray) {
 String dir = fs.getMount();
 long total = fs.getTotalSpace();
 diskTotal += total;
 long free = fs.getUsableSpace();
 diskFree += free;
 long used = total - diskFree;
 diskUsed += used;
 }
 disk.setTotal(convertFileSize(diskTotal));
 disk.setUsed(convertFileSize(diskUsed));
 disk.setFree(convertFileSize(diskFree));
 disk.setUsage(ArithUtils.mul(ArithUtils.div(diskUsed, diskTotal, 4), 100));
 return disk;
 }

private Disk calcMacOSDisk(List<OSFileStore> fsArray) {
 Disk disk = new Disk();
 long diskTotal = 0L;
 long diskUsed = 0L;
 long diskFree = 0L;
 for (OSFileStore fs : fsArray) {
 String dir = fs.getMount();
 if ("/".equals(dir)) {
 diskTotal = fs.getTotalSpace();
 diskFree = fs.getUsableSpace();
 diskUsed = diskTotal - diskFree;
 break;
 }
 }
 disk.setTotal(convertFileSize(diskTotal));
 disk.setUsed(convertFileSize(diskUsed));
 disk.setFree(convertFileSize(diskFree));
 disk.setUsage(ArithUtils.mul(ArithUtils.div(diskUsed, diskTotal, 4), 100));
 return disk;
 }

/**
     * 字节转换
     *
     * @param size 字节大小
     * @return 转换后值
     */
    public String convertFileSize(long size) {
        long kb = 1024;
        long mb = kb * 1024;
        long gb = mb * 1024;
        if (size >= gb) {
            return String.format("%.1f GB", (float) size / gb);
        } else if (size >= mb) {
            float f = (float) size / mb;
            return String.format(f > 100 ? "%.0f MB" : "%.1f MB", f);
        } else if (size >= kb) {
            float f = (float) size / kb;
            return String.format(f > 100 ? "%.0f KB" : "%.1f KB", f);
        } else {
            return String.format("%d B", size);
        }
    }

/**
 * 是否在线，超过10分钟没上报信息，则视为离线
 *
 * @return
 */
 public boolean isOnline() {
 Long now = LocalDateUtils.unixTimestamp();
 return Math.abs(now - this.timestamp) < EXPIRE_TIME;
 }

/**
 * 是否可见，超过1小时没上报信息，则视为已注销，不可见
 *
 * @return
 */
 public boolean isVisible() {
 Long now = LocalDateUtils.unixTimestamp();
 return Math.abs(now - this.timestamp) < VISIBLE_TIME;
 }

@Override
    public String toString() {
        return GsonUtils.toJson(this);
    }
}

```

- CPU

```java

import com.acrel.utils.ArithUtils;
import com.acrel.utils.GsonUtils;
import lombok.Data;

/**
 * CPU信息
 */
@Data
public class Cpu {

/**
     * 核心数
     */
    private int coreNum;

/**
     * CPU总的使用率
     */
    private double total;

/**
     * CPU系统使用率
     */
    private double sys;

/**
     * CPU用户使用率
     */
    private double used;

/**
     * CPU百分比
     */
    private double usage;

/**
     * CPU当前等待率
     */
    private double wait;

/**
     * CPU当前空闲率
     */
    private double free;

public double getTotal() {
        return ArithUtils.round(ArithUtils.mul(total, 100), 2);
    }

public double getSys() {
        return ArithUtils.round(ArithUtils.mul(sys / total, 100), 2);
    }

public double getUsed() {
        return ArithUtils.round(ArithUtils.mul(used / total, 100), 2);
    }

public double getWait() {
        return ArithUtils.round(ArithUtils.mul(wait / total, 100), 2);
    }

public double getFree() {
        return ArithUtils.round(ArithUtils.mul(free / total, 100), 2);
    }

@Override
    public String toString() {
        return GsonUtils.toJson(this);
    }
}
```

- Mem

```java

import com.acrel.utils.ArithUtils;
import com.acrel.utils.GsonUtils;
import lombok.Data;

/**
 * 內存相关信息
 */
@Data
public class Mem {

/**
     * 内存总量
     */
    private double total;

/**
     * 已用内存
     */
    private double used;

/**
     * 剩余内存
     */
    private double free;

public double getTotal() {
        return ArithUtils.div(total, (1024 * 1024 * 1024), 2);
    }

public double getUsed() {
        return ArithUtils.div(used, (1024 * 1024 * 1024), 2);
    }

public double getFree() {
        return ArithUtils.div(free, (1024 * 1024 * 1024), 2);
    }

public double getUsage() {
        return ArithUtils.mul(ArithUtils.div(used, total, 4), 100);
    }

@Override
    public String toString() {
        return GsonUtils.toJson(this);
    }
}
```

- JVM

```java

import com.acrel.utils.ArithUtils;
import com.acrel.utils.GsonUtils;
import lombok.Data;

import java.lang.management.ManagementFactory;

/**
 * JVM相关信息
 */
@Data
public class Jvm {

/**
     * 当前JVM占用的内存总数(M)
     */
    private double total;

/**
     * JVM最大可用内存总数(M)
     */
    private double max;

/**
     * JVM空闲内存(M)
     */
    private double free;

/**
     * JDK版本
     */
    private String version;

/**
     * JDK路径
     */
    private String home;

public double getTotal() {
        return ArithUtils.div(total, (1024 * 1024), 2);
    }

public double getMax() {
        return ArithUtils.div(max, (1024 * 1024), 2);
    }

public double getFree() {
        return ArithUtils.div(free, (1024 * 1024), 2);
    }

public double getUsed() {
        return ArithUtils.div(total - free, (1024 * 1024), 2);
    }

public double getUsage() {
        return ArithUtils.mul(ArithUtils.div(total - free, total, 4), 100);
    }

/**
     * 获取JDK名称
     */
    public String getName() {
        return ManagementFactory.getRuntimeMXBean().getVmName();
    }

@Override
    public String toString() {
        return GsonUtils.toJson(this);
    }
}
```

- Sys

```java

import com.acrel.utils.GsonUtils;
import lombok.Data;

@Data
public class Sys {

/**
     * 项目路径
     */
    private String userDir;

/**
     * 操作系统
     */
    private String osName;

/**
     * 系统架构
     */
    private String osArch;

@Override
    public String toString() {
        return GsonUtils.toJson(this);
    }
}
```

- Disk

```java
import lombok.Data;

@Data
public class Disk {

/**
     * 总量
     */
    private String total;

/**
     * 用量
     */
    private String used;

/**
     * 空余
     */
    private String free;

/**
     * 使用百分比
     */
    private double usage;

}
```

- IORate

```java

import com.acrel.utils.GsonUtils;
import lombok.Data;

/**
 * @Author: Zhou Chenyu
 * @Date: 2024/8/22
 * @Description:
 */
@Data
public class IORate {

private String name;
    /**
     * 读写速率
     */
    private long inRate;
    private long outRate;

@Override
    public String toString() {
        return GsonUtils.toJson(this);
    }
}
```

- SysFile

```java

import com.acrel.utils.GsonUtils;
import lombok.Data;

@Data
public class SysFile {

/**
     * 盘符路径
     */
    private String dirName;

/**
     * 盘符类型
     */
    private String sysTypeName;

/**
     * 文件类型
     */
    private String typeName;

/**
     * 总大小
     */
    private String total;

/**
     * 剩余大小
     */
    private String free;

/**
     * 已经使用量
     */
    private String used;

/**
     * 资源的使用率
     */
    private double usage;

@Override
    public String toString() {
        return GsonUtils.toJson(this);
    }

}
```

3. 工具类

- ArithUtils

```java

import java.math.BigDecimal;
import java.math.RoundingMode;

public class ArithUtils {
    /**
     * 默认除法运算精度
     */
    private static final int DEF_DIV_SCALE = 10;

/**
     * 这个类不能实例化
     */
    private ArithUtils() {
    }

/**
     * 提供精确的加法运算。
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

/**
     * 提供精确的减法运算。
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

/**
     * 提供精确的乘法运算。
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

/**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后10位，以后的数字四舍五入。
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */
    public static double div(double v1, double v2) {
        return div(v1, v2, DEF_DIV_SCALE);
    }

/**
 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
 * 定精度，以后的数字四舍五入。
 * @param v1 被除数
 * @param v2 除数
 * @param scale 表示表示需要精确到小数点以后几位。
 * @return 两个参数的商
 */
 public static double div(double v1, double v2, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException(
 "The scale must be a positive integer or zero");
 }
 BigDecimal b1 = new BigDecimal(Double.toString(v1));
 BigDecimal b2 = new BigDecimal(Double.toString(v2));
 if (b1.compareTo(BigDecimal.ZERO) == 0) {
 return BigDecimal.ZERO.doubleValue();
 }
 return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
 }

/**
 * 提供精确的小数位四舍五入处理。
 * @param v 需要四舍五入的数字
 * @param scale 小数点后保留几位
 * @return 四舍五入后的结果
 */
 public static double round(double v, int scale) {
 if (scale < 0) {
 throw new IllegalArgumentException(
 "The scale must be a positive integer or zero");
 }
 BigDecimal b = new BigDecimal(Double.toString(v));
 BigDecimal one = new BigDecimal("1");
 return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
 }
}

```

- GsonUtils

```java

import com.google.gson.Gson;
import com.google.gson.JsonObject;

/**
 * @Author: Zhou Chenyu
 * @Date: 2024/4/16
 * @Description:
 */
public class GsonUtils {

public static final Gson GSON = new Gson();

public static <T> T fromJson(String json, Class<T> classOfT) {
 return GSON.fromJson(json, classOfT);
 }

public static String toJson(Object object) {
        return GSON.toJson(object);
    }

public static JsonObject parseJsonObject(String jsonString) {
        return GSON.fromJson(jsonString, JsonObject.class);
    }

}
```

- LocalDateUtils

```java

import org.apache.commons.lang3.StringUtils;

import java.math.BigDecimal;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalAdjusters;
import java.util.*;

/**
 * Java8时间工具类
 */
public class LocalDateUtils {

public final static BigDecimal BIG_DECIMAL_1 = new BigDecimal("1");
    public final static BigDecimal BIG_DECIMAL_60 = new BigDecimal("60");
    public final static BigDecimal BIG_DECIMAL_100 = new BigDecimal("100");

/**
     * 显示年月日时分秒，例如 2015-08-11 09:51:53.
     */
    public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

/**
     * 仅显示年月日，例如 2015-08-11.
     */
    public static final String DATE_PATTERN = "yyyy-MM-dd";

/**
     * 仅显示时分秒，例如 09:51:53.
     */
    public static final String TIME_PATTERN = "HH:mm:ss";

/**
     * 显示年月日时分秒(无符号)，例如 20150811095153.
     */
    public static final String UNSIGNED_DATETIME_PATTERN = "yyyyMMddHHmmss";

/**
     * 仅显示年月日(无符号)，例如 20150811.
     */
    public static final String UNSIGNED_DATE_PATTERN = "yyyyMMdd";

/**
     * 仅显示年月(无符号)，例如 201508.
     */
    public static final String UNSIGNED_MONTH_PATTERN = "yyyyMM";

/**
     * 春天;
     */
    public static final Integer SPRING = 1;

/**
     * 夏天;
     */
    public static final Integer SUMMER = 2;

/**
     * 秋天;
     */
    public static final Integer AUTUMN = 3;

/**
     * 冬天;
     */
    public static final Integer WINTER = 4;

/**
     * 星期日;
     */
    public static final String SUNDAY = "星期日";

/**
     * 星期一;
     */
    public static final String MONDAY = "星期一";

/**
     * 星期二;
     */
    public static final String TUESDAY = "星期二";

/**
     * 星期三;
     */
    public static final String WEDNESDAY = "星期三";

/**
     * 星期四;
     */
    public static final String THURSDAY = "星期四";

/**
     * 星期五;
     */
    public static final String FRIDAY = "星期五";

/**
     * 星期六;
     */
    public static final String SATURDAY = "星期六";

/**
     * 年
     */
    private static final String YEAR = "year";

/**
     * 月
     */
    private static final String MONTH = "month";

/**
     * 周
     */
    private static final String WEEK = "week";

/**
     * 日
     */
    private static final String DAY = "day";

/**
     * 时
     */
    private static final String HOUR = "hour";

/**
     * 分
     */
    private static final String MINUTE = "minute";

/**
     * 秒
     */
    private static final String SECOND = "second";

public static String DEFAULT_EIOT_TIME_ZONE;

public static String SERVER_TIMEZONE;
 public static String DEFAULT_STANDARD_TIME_ZONE;
 public static String DEFAULT_STANDARD_TIME_ZONE_HOUR;
 public static String DEFAULT_STANDARD_TIME_ZONE_MIN;
 public static Set<String> TIMEZONE_MIN_SET;
 public static Set<String> TIMEZONE_HOUR_SET;

static {
 int offset = TimeZone.getDefault().getRawOffset();
 int second = offset / 1000;
 int hr = second / 3600;
 int min = second % 60;
 StringBuilder sb = new StringBuilder();
 String symbol = hr < 0 ? "-" : "+";
 sb.append(symbol);
 String hrStr = String.valueOf(Math.abs(hr));
 if (Math.abs(hr) < 10) {
 hrStr = "0" + hrStr;
 }
 sb.append(hrStr).append(":");
 String minStr = String.valueOf(min);
 if (min < 10) {
 minStr = "0" + minStr;
 }
 sb.append(minStr);
 SERVER_TIMEZONE = sb.toString();
 DEFAULT_STANDARD_TIME_ZONE = SERVER_TIMEZONE;
 DEFAULT_STANDARD_TIME_ZONE_HOUR = String.valueOf(hr);
 DEFAULT_STANDARD_TIME_ZONE_MIN = minStr;
 DEFAULT_EIOT_TIME_ZONE = symbol + String.valueOf(Math.abs(hr));
 TIMEZONE_HOUR_SET = new HashSet<>();
 for (int i = -12; i <= 14; i++) {
 TIMEZONE_HOUR_SET.add(String.valueOf(i));
 }
 TIMEZONE_MIN_SET = new HashSet<>();
 TIMEZONE_MIN_SET.add("00");
 TIMEZONE_MIN_SET.add("15");
 TIMEZONE_MIN_SET.add("30");
 TIMEZONE_MIN_SET.add("45");
 }

/**
     * 获取当前日期和时间字符串.
     *
     * @return String 日期时间字符串，例如 2015-08-11 09:51:53
     */
    public static String getLocalDateTimeStr() {
        return format(LocalDateTime.now(), DATETIME_PATTERN);
    }

/**
     * 获取当前日期字符串.
     *
     * @return String 日期字符串，例如2015-08-11
     */
    public static String getLocalDateStr() {
        return format(LocalDate.now(), DATE_PATTERN);
    }

/**
     * 获取当前时间字符串.
     *
     * @return String 时间字符串，例如 09:51:53
     */
    public static String getLocalTimeStr() {
        return format(LocalTime.now(), TIME_PATTERN);
    }

/**
     * 获取当前星期字符串.
     *
     * @return String 当前星期字符串，例如 星期二
     */
    public static String getDayOfWeekStr() {
        return format(LocalDate.now(), "E");
    }

/**
     * 获取指定日期是星期几
     *
     * @param localDate 日期
     * @return String 星期几
     */
    public static String getDayOfWeekStr(LocalDate localDate) {
        String[] weekOfDays = {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};
        int dayOfWeek = localDate.getDayOfWeek().getValue() - 1;
        return weekOfDays[dayOfWeek];
    }

/**
     * 获取日期时间字符串
     *
     * @param temporal 需要转化的日期时间
     * @param pattern  时间格式
     * @return String 日期时间字符串，例如 2015-08-11 09:51:53
     */
    public static String format(TemporalAccessor temporal, String pattern) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
        return dateTimeFormatter.format(temporal);
    }

/**
     * 日期时间字符串转换为日期时间(java.time.LocalDateTime)
     *
     * @param localDateTimeStr 日期时间字符串
     * @param pattern          日期时间格式 例如DATETIME_PATTERN
     * @return LocalDateTime 日期时间
     */
    public static LocalDateTime parseLocalDateTime(String localDateTimeStr, String pattern) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
        return LocalDateTime.parse(localDateTimeStr, dateTimeFormatter);
    }

/**
     * 日期字符串转换为日期(java.time.LocalDate)
     *
     * @param localDateStr 日期字符串
     * @param pattern      日期格式 例如DATE_PATTERN
     * @return LocalDate 日期
     */
    public static LocalDate parseLocalDate(String localDateStr, String pattern) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
        return LocalDate.parse(localDateStr, dateTimeFormatter);
    }

/**
     * 获取指定日期时间加上指定数量日期时间单位之后的日期时间.
     *
     * @param localDateTime 日期时间
     * @param num           数量
     * @param chronoUnit    日期时间单位
     * @return LocalDateTime 新的日期时间
     */
    public static LocalDateTime plus(LocalDateTime localDateTime, int num, ChronoUnit chronoUnit) {
        return localDateTime.plus(num, chronoUnit);
    }

/**
     * 获取指定日期时间减去指定数量日期时间单位之后的日期时间.
     *
     * @param localDateTime 日期时间
     * @param num           数量
     * @param chronoUnit    日期时间单位
     * @return LocalDateTime 新的日期时间
     */
    public static LocalDateTime minus(LocalDateTime localDateTime, int num, ChronoUnit chronoUnit) {
        return localDateTime.minus(num, chronoUnit);
    }

/**
     * 根据ChronoUnit计算两个日期时间之间相隔日期时间
     *
     * @param start      开始日期时间
     * @param end        结束日期时间
     * @param chronoUnit 日期时间单位
     * @return long 相隔日期时间
     */
    public static long getChronoUnitBetween(LocalDateTime start, LocalDateTime end, ChronoUnit chronoUnit) {
        return Math.abs(start.until(end, chronoUnit));
    }

/**
     * 根据ChronoUnit计算两个日期之间相隔年数或月数或天数
     *
     * @param start      开始日期
     * @param end        结束日期
     * @param chronoUnit 日期时间单位,(ChronoUnit.YEARS,ChronoUnit.MONTHS,ChronoUnit.WEEKS,ChronoUnit.DAYS)
     * @return long 相隔年数或月数或天数
     */
    public static long getChronoUnitBetween(LocalDate start, LocalDate end, ChronoUnit chronoUnit) {
        return Math.abs(start.until(end, chronoUnit));
    }

/**
     * 获取本年第一天的日期字符串
     *
     * @return String 格式：yyyy-MM-dd 00:00:00
     */
    public static String getFirstDayOfYearStr() {
        return getFirstDayOfYearStr(LocalDateTime.now());
    }

/**
     * 获取本年最后一天的日期字符串
     *
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getLastDayOfYearStr() {
        return getLastDayOfYearStr(LocalDateTime.now());
    }

/**
     * 获取指定日期当年第一天的日期字符串
     *
     * @param localDateTime 指定日期时间
     * @return String 格式：yyyy-MM-dd 00:00:00
     */
    public static String getFirstDayOfYearStr(LocalDateTime localDateTime) {
        return getFirstDayOfYearStr(localDateTime, DATETIME_PATTERN);
    }

/**
     * 获取指定日期当年最后一天的日期字符串
     *
     * @param localDateTime 指定日期时间
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getLastDayOfYearStr(LocalDateTime localDateTime) {
        return getLastDayOfYearStr(localDateTime, DATETIME_PATTERN);
    }

/**
     * 获取指定日期当年第一天的日期字符串,带日期格式化参数
     *
     * @param localDateTime 指定日期时间
     * @param pattern       日期时间格式
     * @return String 格式：yyyy-MM-dd 00:00:00
     */
    public static String getFirstDayOfYearStr(LocalDateTime localDateTime, String pattern) {
        return format(localDateTime.withDayOfYear(1).withHour(0).withMinute(0).withSecond(0), pattern);
    }

/**
     * 获取指定日期当年最后一天的日期字符串,带日期格式化参数
     *
     * @param localDateTime 指定日期时间
     * @param pattern       日期时间格式
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getLastDayOfYearStr(LocalDateTime localDateTime, String pattern) {
        return format(localDateTime.with(TemporalAdjusters.lastDayOfYear()).withHour(23).withMinute(59).withSecond(59), pattern);
    }

/**
     * 获取本月第一天的日期字符串
     *
     * @return String 格式：yyyy-MM-dd 00:00:00
     */
    public static String getFirstDayOfMonthStr() {
        return getFirstDayOfMonthStr(LocalDateTime.now());
    }

/**
     * 获取本月最后一天的日期字符串
     *
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getLastDayOfMonthStr() {
        return getLastDayOfMonthStr(LocalDateTime.now());
    }

/**
     * 获取指定日期当月第一天的日期字符串
     *
     * @param localDateTime 指定日期时间
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getFirstDayOfMonthStr(LocalDateTime localDateTime) {
        return getFirstDayOfMonthStr(localDateTime, DATETIME_PATTERN);
    }

/**
     * 获取指定日期当月最后一天的日期字符串
     *
     * @param localDateTime 指定日期时间
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getLastDayOfMonthStr(LocalDateTime localDateTime) {
        return getLastDayOfMonthStr(localDateTime, DATETIME_PATTERN);
    }

/**
     * 获取指定日期当月第一天的日期字符串,带日期格式化参数
     *
     * @param localDateTime 指定日期时间
     * @return String 格式：yyyy-MM-dd 00:00:00
     */
    public static String getFirstDayOfMonthStr(LocalDateTime localDateTime, String pattern) {
        return format(localDateTime.withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0), pattern);
    }

/**
     * 获取指定日期当月最后一天的日期字符串,带日期格式化参数
     *
     * @param localDateTime 指定日期时间
     * @param pattern       日期时间格式
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getLastDayOfMonthStr(LocalDateTime localDateTime, String pattern) {
        return format(localDateTime.with(TemporalAdjusters.lastDayOfMonth()).withHour(23).withMinute(59).withSecond(59), pattern);
    }

/**
     * 获取本周第一天的日期字符串
     *
     * @return String 格式：yyyy-MM-dd 00:00:00
     */
    public static String getFirstDayOfWeekStr() {
        return getFirstDayOfWeekStr(LocalDateTime.now());
    }

/**
     * 获取本周最后一天的日期字符串
     *
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getLastDayOfWeekStr() {
        return getLastDayOfWeekStr(LocalDateTime.now());
    }

/**
     * 获取指定日期当周第一天的日期字符串,这里第一天为周一
     *
     * @param localDateTime 指定日期时间
     * @return String 格式：yyyy-MM-dd 00:00:00
     */
    public static String getFirstDayOfWeekStr(LocalDateTime localDateTime) {
        return getFirstDayOfWeekStr(localDateTime, DATETIME_PATTERN);
    }

/**
     * 获取指定日期当周最后一天的日期字符串,这里最后一天为周日
     *
     * @param localDateTime 指定日期时间
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getLastDayOfWeekStr(LocalDateTime localDateTime) {
        return getLastDayOfWeekStr(localDateTime, DATETIME_PATTERN);
    }

/**
     * 获取指定日期当周第一天的日期字符串,这里第一天为周一,带日期格式化参数
     *
     * @param localDateTime 指定日期时间
     * @param pattern       日期时间格式
     * @return String 格式：yyyy-MM-dd 00:00:00
     */
    public static String getFirstDayOfWeekStr(LocalDateTime localDateTime, String pattern) {
        return format(localDateTime.with(DayOfWeek.MONDAY).withHour(0).withMinute(0).withSecond(0), pattern);
    }

/**
     * 获取指定日期当周最后一天的日期字符串,这里最后一天为周日,带日期格式化参数
     *
     * @param localDateTime 指定日期时间
     * @param pattern       日期时间格式
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getLastDayOfWeekStr(LocalDateTime localDateTime, String pattern) {
        return format(localDateTime.with(DayOfWeek.SUNDAY).withHour(23).withMinute(59).withSecond(59), pattern);
    }

/**
     * 获取今天开始时间的日期字符串
     *
     * @return String 格式：yyyy-MM-dd 00:00:00
     */
    public static String getStartTimeOfDayStr() {
        return getStartTimeOfDayStr(LocalDateTime.now());
    }

/**
     * 获取今天结束时间的日期字符串
     *
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getEndTimeOfDayStr() {
        return getEndTimeOfDayStr(LocalDateTime.now());
    }

/**
     * 获取指定日期开始时间的日期字符串
     *
     * @param localDateTime 指定日期时间
     * @return String 格式：yyyy-MM-dd 00:00:00
     */
    public static String getStartTimeOfDayStr(LocalDateTime localDateTime) {
        return getStartTimeOfDayStr(localDateTime, DATETIME_PATTERN);
    }

/**
     * 获取指定日期结束时间的日期字符串
     *
     * @param localDateTime 指定日期时间
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getEndTimeOfDayStr(LocalDateTime localDateTime) {
        return getEndTimeOfDayStr(localDateTime, DATETIME_PATTERN);
    }

/**
     * 获取指定日期开始时间的日期字符串,带日期格式化参数
     *
     * @param localDateTime 指定日期时间
     * @param pattern       日期时间格式
     * @return String 格式：yyyy-MM-dd HH:mm:ss
     */
    public static String getStartTimeOfDayStr(LocalDateTime localDateTime, String pattern) {
        return format(localDateTime.withHour(0).withMinute(0).withSecond(0), pattern);
    }

/**
     * 获取指定日期结束时间的日期字符串,带日期格式化参数
     *
     * @param localDateTime 指定日期时间
     * @param pattern       日期时间格式
     * @return String 格式：yyyy-MM-dd 23:59:59
     */
    public static String getEndTimeOfDayStr(LocalDateTime localDateTime, String pattern) {
        return format(localDateTime.withHour(23).withMinute(59).withSecond(59), pattern);
    }

/**
 * 切割日期。按照周期切割成小段日期段。例如： 
 *
 * @param startDate 开始日期（yyyy-MM-dd）
 * @param endDate 结束日期（yyyy-MM-dd）
 * @param period 周期（天，周，月，年）
 * @return 切割之后的日期集合
 * <li>startDate="2019-02-28",endDate="2019-03-05",period="day"</li>
 * <li>结果为：[2019-02-28, 2019-03-01, 2019-03-02, 2019-03-03, 2019-03-04, 2019-03-05]</li> 
 * <li>startDate="2019-02-28",endDate="2019-03-25",period="week"</li>
 * <li>结果为：[2019-02-28,2019-03-06, 2019-03-07,2019-03-13, 2019-03-14,2019-03-20,
 * 2019-03-21,2019-03-25]</li> 
 * <li>startDate="2019-02-28",endDate="2019-05-25",period="month"</li>
 * <li>结果为：[2019-02-28,2019-02-28, 2019-03-01,2019-03-31, 2019-04-01,2019-04-30,
 * 2019-05-01,2019-05-25]</li> 
 * <li>startDate="2019-02-28",endDate="2020-05-25",period="year"</li>
 * <li>结果为：[2019-02-28,2019-12-31, 2020-01-01,2020-05-25]</li> 
 */
 public static List<String> splitDateList(String startDate, String endDate, String period) {
 List<String> result = new ArrayList<>();
 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(DATE_PATTERN);
 LocalDate end = LocalDate.parse(endDate, dateTimeFormatter);
 LocalDate start = LocalDate.parse(startDate, dateTimeFormatter);
 LocalDate tmp = start;
 switch (period) {
 case DAY:
 while (start.isBefore(end) || start.isEqual(end)) {
 result.add(start.toString());
 start = start.plusDays(1);
 }
 break;
 case WEEK:
 while (tmp.isBefore(end) || tmp.isEqual(end)) {
 if (tmp.plusDays(6).isAfter(end)) {
 result.add(tmp + "," + end);
 } else {
 result.add(tmp + "," + tmp.plusDays(6));
 }
 tmp = tmp.plusDays(7);
 }
 break;
 case MONTH:
 while (tmp.isBefore(end) || tmp.isEqual(end)) {
 LocalDate lastDayOfMonth = tmp.with(TemporalAdjusters.lastDayOfMonth());
 if (lastDayOfMonth.isAfter(end)) {
 result.add(tmp + "," + end);
 } else {
 result.add(tmp + "," + lastDayOfMonth);
 }
 tmp = lastDayOfMonth.plusDays(1);
 }
 break;
 case YEAR:
 while (tmp.isBefore(end) || tmp.isEqual(end)) {
 LocalDate lastDayOfYear = tmp.with(TemporalAdjusters.lastDayOfYear());
 if (lastDayOfYear.isAfter(end)) {
 result.add(tmp + "," + end);
 } else {
 result.add(tmp + "," + lastDayOfYear);
 }
 tmp = lastDayOfYear.plusDays(1);
 }
 break;
 default:
 break;
 }
 return result;
 }

/**
     * 获取当前的时间戳
     *
     * @return 时间戳
     */
    public static Long unixTimestamp() {
        return Clock.systemUTC().millis();
    }

/**
     * 获取当前的时间戳
     *
     * @return 时间戳
     */
    public static Long unixTimestampInSecond() {
        return unixTimestamp() / 1000;
    }

/**
     * LocalDateTime对象转为Date对象
     *
     * @param localDateTime 时间对象
     * @param atZone        表示时间对象是哪个时区生成的
     * @return 在atZone生成的localDateTime，被转换到服务器所在时区的Date对象
     */
    public static Date localDateTimeToDate(LocalDateTime localDateTime, String atZone) {
        return Date.from(localDateTime.toInstant(parseZoneOffset(atZone)));
    }

/**
     * 时间戳转为Date对象
     *
     * @param timestamp
     * @param atZone
     * @return
     */
    public static Date unixTimestampToDate(Long timestamp, String atZone) {
        if (timestamp == null) {
            return null;
        }
        if (StringUtils.isBlank(atZone)) {
            atZone = localTimezone();
        }
        LocalDateTime localDateTime = fromTimestamp(timestamp, atZone);
        return localDateTimeToDate(localDateTime, atZone);
    }

/**
     * 当前服务器的本地时间
     * @return
     */
    public static LocalDateTime localDateTime() {
        return LocalDateTime.now();
    }

/**
     * 当前服务器时间
     * @return
     */
    public static Date serverDate() {
        LocalDateTime now = LocalDateTime.now();
        Date date = Date.from(now.toInstant(parseZoneOffset(SERVER_TIMEZONE)));
        return date;
    }

/**
     * LocalDateTime转为UnixTimestamp
     *
     * @param localDateTime 时间对象
     * @param atZone        时间对象所在时区
     * @return UnixTimestamp
     */
    public static Long localDateTimeToMillis(LocalDateTime localDateTime, String atZone) {
        return localDateTime.toInstant(parseZoneOffset(atZone)).toEpochMilli();
    }

/**
     * LocalDateTime转为UnixTimestamp秒数
     *
     * @param localDateTime 时间对象
     * @param atZone        时间对象所在时区
     * @return UnixTimestamp秒数
     */
    public static Long localDateTimeToSecond(LocalDateTime localDateTime, String atZone) {
        return localDateTime.toEpochSecond(parseZoneOffset(atZone));
    }

/**
     * LocalDate的开始时间转为UnixTimestamp
     *
     * @param localDate 日期对象
     * @param atZone    时间对象所在时区
     * @return UnixTimestamp
     */
    public static Long localDateStartToMillis(LocalDate localDate, String atZone) {
        return localDate.atStartOfDay(parseZoneOffset(atZone)).toInstant().toEpochMilli();
    }

/**
     * LocalDate的开始时间转为UnixTimestamp秒数
     *
     * @param localDate 日期对象
     * @param atZone    时间对象所在时区
     * @return UnixTimestamp秒数
     */
    public static Long localDateStartToSecond(LocalDate localDate, String atZone) {
        return localDateStartToMillis(localDate, atZone) / 1000;
    }

/**
     * 字符串转时区偏移量
     *
     * @param atZone 所在时区的字符串
     * @return 时区偏移用于指明LocalDateTime所在时区
     */
    public static ZoneOffset parseZoneOffset(String atZone) {
        if (StringUtils.isBlank(atZone)) {
            atZone = localTimezone();
        }
        try {
            return ZoneOffset.of(atZone);
        } catch (Exception e) {
            return ZoneOffset.of(localTimezone());
        }
    }

/**
     * 时间戳转LocalDateTime
     *
     * @param timestamp 时间戳
     * @param timezone  所在时区
     * @return 指定时区的时间
     */
    public static LocalDateTime fromTimestamp(Long timestamp, String timezone) {
        try {
            Long second = timestamp;
            long nano = 0L;
            if (timestamp > Integer.MAX_VALUE) {
                second = timestamp / 1000;
                nano = timestamp - second * 1000;
                nano *= 1000000;
            }
            LocalDateTime localDateTime = LocalDateTime.ofEpochSecond(second, Math.toIntExact(nano), parseZoneOffset(timezone));
            return localDateTime;
        } catch (Exception e) {
            return null;
        }
    }

/**
 * 获取服务器所在时区
 *
 * @return
 */
 public static String localTimezone() {
 int offset = TimeZone.getDefault().getRawOffset();
 int second = offset / 1000;
 int hr = second / 3600;
 int min = second % 60;
 StringBuilder sb = new StringBuilder();
 String symbol = hr < 0 ? "-" : "+";
 sb.append(symbol);
 if (Math.abs(hr) < 10) {
 sb.append("0");
 }
 sb.append(Math.abs(hr)).append(":");
 if (min < 10) {
 sb.append("0");
 }
 sb.append(min);
 return sb.toString();
 }

public static String formatTimezone(String hour, String minute) {
 if (StringUtils.isBlank(hour)) {
 hour = LocalDateUtils.DEFAULT_STANDARD_TIME_ZONE_HOUR;
 }
 if (StringUtils.isBlank(minute)) {
 minute = LocalDateUtils.DEFAULT_STANDARD_TIME_ZONE_MIN;
 }
 if (hour.indexOf(".") > 0) {
 BigDecimal decimal = new BigDecimal(hour);
 hour = String.valueOf(decimal.intValue());
 int min = decimal.subtract(new BigDecimal(hour))
 .multiply(new BigDecimal("60"))
 .intValue();
 minute = String.valueOf(min);
 if (min < 10) {
 minute = "0" + minute;
 }
 }
 int hr = Integer.valueOf(hour);
 int min = Integer.valueOf(minute);
 StringBuilder sb = new StringBuilder();
 String symbol = hr < 0 ? "-" : "+";
 sb.append(symbol);
 if (Math.abs(hr) < 10) {
 sb.append("0");
 }
 sb.append(Math.abs(hr)).append(":");
 if (min < 10) {
 sb.append("0");
 }
 sb.append(min);
 return sb.toString();
 }

public static String standardTimezone() {
        String hour = "08";
        String minute = "00";
        try {
            if (hour.indexOf(".") > 0) {
                String[] arr = hour.split("\\.");
                if (arr != null && arr.length >= 2) {
                    hour = arr[0];
                    minute = "0." + arr[1];
                    BigDecimal min = new BigDecimal(minute)
                            .multiply(LocalDateUtils.BIG_DECIMAL_60);
                    minute = String.valueOf(min.intValue());
                }
            }
        } catch (Exception e) {
        }
        return LocalDateUtils.formatTimezone(hour, minute);
    }
}
```

4. 使用方法

```java
// IP_ADDR由平台获取网卡信息生成
Server server = new Server(IP_ADDR);
server.generate();
log.info(server.toString());
```