java执行IfConfig获取一些信息和网卡流量

通用功能

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.LinkedList;
import java.util.List;

/**
 * 调用init方法  执行命令获取信息
 * @author gaokuo
 */
public class IfConfig {

    private static final String CMD = "ifconfig";
    private String msg;
    private List<IfConfigModel> items;


    private IfConfig() {
    }

    public static IfConfig init(){
        IfConfig ifConfig = new IfConfig();
        ifConfig.msg = runShellReturn(CMD);
        if (ifConfig.msg.length() == 0){
            throw new RuntimeException(CMD + "未获取到响应");
        }
        ifConfig.items = parse(ifConfig.msg);
        return ifConfig;
    }

    /**
     * InputStream转数组
     */
    public static byte[] readStream(InputStream inStream) throws IOException {
        try(ByteArrayOutputStream outStream = new ByteArrayOutputStream()){
            byte[] buffer = new byte[1024];
            int len;
            while((len = inStream.read(buffer)) != -1){
                outStream.write(buffer, 0, len);
            }
            return outStream.toByteArray();
        } finally {
            inStream.close();
        }
    }

    /**
     * 同步执行shell  直至返回
     */
    private static String runShellReturn(String cmd) {
        InputStream is = null;
        Process process = null;
        try {
            process = Runtime.getRuntime().exec(new String[]{"sh", "-c", cmd});
            process.waitFor();
            is = process.getInputStream();
            return new String(readStream(is));
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (is != null) {
                    is.close();
                }
            } catch (Exception ignored) {
            }
            try {
                if (process != null) {
                    process.destroy();
                }
            } catch (Exception ignored) {
            }
        }
    }


    private static List<IfConfigModel> parse(String msg){
        LinkedList<IfConfigModel> items = new LinkedList<>();
        String afterNameMark = ": flags=";
        int nameIndex = msg.indexOf(afterNameMark);
        while (true){
            //游标往前扫后  在向后扫 收集网口名
            char[] nameCharArr = null;
            int nameIndexStart = 0;
            for(int i = nameIndex - 1; i < nameIndex;){
                if(nameCharArr != null){
                    nameCharArr[nameCharArr.length - (nameIndex - i)] = msg.charAt(i);
                    i++;
                    continue;
                }
                if(i < 0 || msg.charAt(i) == '\n'){
                    nameCharArr = new char[nameIndex - i - 1];
                    nameIndexStart = ++i;
                }else{
                    i--;
                }
            }
            assert nameCharArr != null;
            //把ifconfig响应设置到每一个网口中  同时还有该网口的信息对应的开始结束下标
            IfConfigModel ifConfigModel = new IfConfigModel(msg,new String(nameCharArr));
            ifConfigModel.setFocusMsgStart(nameIndexStart);
            int nextNameIndex = msg.indexOf(afterNameMark, nameIndex + afterNameMark.length());
            if(nextNameIndex == -1){
                ifConfigModel.setFocusMsgEnd(msg.length());
            }
            if(!items.isEmpty()){
                IfConfigModel last = items.getLast();
                last.setFocusMsgEnd(nameIndexStart);
            }
            items.add(ifConfigModel);
            if(nextNameIndex == -1){
                break;
            }
            nameIndex = nextNameIndex;
        }
        //解析
        for (IfConfigModel item : items) {
            item.autoConf();
        }
        return items;
    }


    public List<IfConfigModel> getItems() {
        return items;
    }

    public static void main(String[] args) {
        System.out.println(init().getItems());
    }
}

import java.util.Arrays;
import java.util.List;

/**
 * 包含了ifconfig 的一些返回信息  比较少 可以逐步完善
 * @author gaokuo
 */
public class IfConfigModel {

    /**
     * 网口名
     */
    private String name;
    /**
     * ifconfig原始信息
     */
    private String msg;
    /**
     * ifconfig当前网卡信息
     */
    private String focusMsg;
    /**
     * focusMsg在msg中的开始
     */
    private Integer focusMsgStart;
    /**
     * focusMsg在msg中的结束
     */
    private Integer focusMsgEnd;
    private String ipv4;
    private String ipv6;
    private String mac;
    private String netmask;
    private boolean running = false;
    private boolean up = false;
    private boolean lo = false;
    /**
     * 接收发送包
     */
    private Long rxPackets;
    /**
     * 接收字节
     */
    private Long rxBytes;
    /**
     * 发送包
     */
    private Long txPackets;
    /**
     * 发送字节
     */
    private Long txBytes;

    public IfConfigModel(String msg,String name) {
        this.msg = msg;
        this.name = name;
    }

    private void confFocusMsg() {
        focusMsg = msg.substring(focusMsgStart,focusMsgEnd);
    }

    public void autoConf() {
        confFocusMsg();
        final String macStartStr = "ether ";
        final String ipv4StartStr = "inet ";
        final String ipv6StartStr = "inet6 ";
        final String netmaskStartStr = "netmask ";
        final String rxPacketsStartStr = "RX packets ";
        final String txPacketsStartStr = "TX packets ";
        final String bytesStartStr = "bytes ";
        final String blank = " ";
        final String valuesStartStr = "<";
        final String valuesEndStr = ">";
        ipv4 = parseStr(ipv4StartStr,blank);
        ipv6 = parseStr(ipv6StartStr,blank);
        mac = parseStr(macStartStr,blank);
        netmask = parseStr(netmaskStartStr,blank);
        rxPackets = toLong(parseStr(rxPacketsStartStr,blank));
        rxBytes = toLong(parseStr(rxPacketsStartStr,bytesStartStr,blank));
        txPackets = toLong(parseStr(txPacketsStartStr,blank));
        txBytes = toLong(parseStr(txPacketsStartStr,bytesStartStr,blank));
        String valuesStr = parseStr(valuesStartStr,valuesEndStr);
        if(valuesStr != null && valuesStr.length() != 0){
            List<String> valueItem = Arrays.asList(valuesStr.split(","));
            lo = valueItem.contains("LOOPBACK");
            up = valueItem.contains("UP");
            running = valueItem.contains("RUNNING");
        }
    }

    private Long toLong(String str){
        if(str == null || str.length() == 0){
            return null;
        }
        return Long.valueOf(str);
    }

    /**
     * 在focusMsg中获取字符串
     * @param startStr 结果在该字符串以后开始
     * @param endStr 结果在该字符串之前结束
     * @return ~
     */
    private String parseStr(String startStr,String endStr){
        int start = focusMsg.indexOf(startStr);
        if(start == -1){
            return null;
        }
        start = start + startStr.length();
        int end = focusMsg.indexOf(endStr, start);
        if(end == -1){
            return null;
        }
        return focusMsg.substring(start,end);
    }
    /**
     * 在focusMsg【afterStrIndex，end)中获取字符串
     * @param startStr 结果在该字符串以后开始
     * @param endStr 结果在该字符串之前结束
     * @return ~
     */
    private String parseStr(String afterStr,String startStr,String endStr){
        int afterIndex = focusMsg.indexOf(afterStr);
        if(afterIndex == -1){
            return null;
        }
        int start = focusMsg.indexOf(startStr,afterIndex);
        if(start == -1){
            return null;
        }
        start = start + startStr.length();
        int end = focusMsg.indexOf(endStr, start);
        if(end == -1){
            return null;
        }
        return focusMsg.substring(start,end);
    }

    public String getName() {
        return name;
    }

    public String getMsg() {
        return msg;
    }

    public String getFocusMsg() {
        return focusMsg;
    }

    public Integer getFocusMsgStart() {
        return focusMsgStart;
    }

    public Integer getFocusMsgEnd() {
        return focusMsgEnd;
    }

    public String getIpv4() {
        return ipv4;
    }

    public String getIpv6() {
        return ipv6;
    }

    public String getMac() {
        return mac;
    }

    public String getNetmask() {
        return netmask;
    }

    public boolean isRunning() {
        return running;
    }

    public boolean isUp() {
        return up;
    }

    public boolean isLo() {
        return lo;
    }

    public Long getRxPackets() {
        return rxPackets;
    }

    public Long getRxBytes() {
        return rxBytes;
    }

    public Long getTxPackets() {
        return txPackets;
    }

    public Long getTxBytes() {
        return txBytes;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public void setFocusMsg(String focusMsg) {
        this.focusMsg = focusMsg;
    }

    public void setFocusMsgStart(Integer focusMsgStart) {
        this.focusMsgStart = focusMsgStart;
    }

    public void setFocusMsgEnd(Integer focusMsgEnd) {
        this.focusMsgEnd = focusMsgEnd;
    }

    public void setIpv4(String ipv4) {
        this.ipv4 = ipv4;
    }

    public void setIpv6(String ipv6) {
        this.ipv6 = ipv6;
    }

    public void setMac(String mac) {
        this.mac = mac;
    }

    public void setNetmask(String netmask) {
        this.netmask = netmask;
    }

    public void setRunning(boolean running) {
        this.running = running;
    }

    public void setUp(boolean up) {
        this.up = up;
    }

    public void setLo(boolean lo) {
        this.lo = lo;
    }

    public void setRxPackets(Long rxPackets) {
        this.rxPackets = rxPackets;
    }

    public void setRxBytes(Long rxBytes) {
        this.rxBytes = rxBytes;
    }

    public void setTxPackets(Long txPackets) {
        this.txPackets = txPackets;
    }

    public void setTxBytes(Long txBytes) {
        this.txBytes = txBytes;
    }

    @Override
    public String toString() {
        return "IfConfigModel{" +
                "name='" + name + '\'' +
                ", ipv4='" + ipv4 + '\'' +
                ", ipv6='" + ipv6 + '\'' +
                ", mac='" + mac + '\'' +
                ", netmask='" + netmask + '\'' +
                ", running=" + running +
                ", up=" + up +
                ", lo=" + lo +
                ", rxPackets=" + rxPackets +
                ", rxBytes=" + rxBytes +
                ", txPackets=" + txPackets +
                ", txBytes=" + txBytes +
                '}';
    }
}

使用方法：将上面两个文件放到同一个目录下，比如：

命令行执行 javac -encoding utf-8 .\IfConfig.java

将两个class文件放到linux服务器任何目录下，如果服务器有java服务环境的话，执行命令java IfConfig即可看到效果。

获取网卡速率

/**
 * 值、单位
 * @param <T> 值类型
 * @author gaokuo
 */
public class ValueUnitModel<T> {

    private T value;
    private String unit;

    public ValueUnitModel(T value, String unit) {
        this.value = value;
        this.unit = unit;
    }

    public ValueUnitModel() {
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public String getUnit() {
        return unit;
    }

    public void setUnit(String unit) {
        this.unit = unit;
    }

    @Override
    public String toString() {
        return "ValueUnitModel{" +
                "value=" + value +
                ", unit='" + unit + '\'' +
                '}';
    }
}

    /**
     * 字节转换
     *
     * @param size 字节大小
     * @return 转换后值
     */
    private static ValueUnitModel<String> convertFileSize(long size) {
        long kb = 1024;
        long mb = kb * 1024;
        long gb = mb * 1024;
        if (size >= gb) {
            return new ValueUnitModel<>(String.format("%.1f", (double) size / gb),"GB");
        } else if (size >= mb) {
            double d = (double) size / mb;
            return new ValueUnitModel<>(String.format("%.1f", d),"MB");
        } else if (size >= kb) {
            double d = (double) size / kb;
            return new ValueUnitModel<>(String.format("%.1f", d),"KB");
        } else {
            return new ValueUnitModel<>(size + ".0", "B");
        }
    }

    /**
     * 阻塞一段时间
     */
    public static void await(long time, TimeUnit unit) throws InterruptedException {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        long waitNanos = unit.toNanos(time);
        lock.lock();
        try {
            while (waitNanos > 0){
                waitNanos = condition.awaitNanos(waitNanos);
            }
        }finally {
            lock.unlock();
        }
    }

    /**
     * 获取网口速率列表
     * @return Rate of List
     */
    public static List<Rate> getNetRateList(){
        Map<String, IfConfigModel> startMap = getNetMap();
        int wait = 200;
        try {
            await(wait,TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        Map<String, IfConfigModel> endMap = getNetMap();
        List<Rate> list = new LinkedList<>();
        for (String netName : startMap.keySet()) {
            IfConfigModel start = startMap.get(netName);
            IfConfigModel end = endMap.get(netName);
            if(end == null){
                continue;
            }
            Rate rate = new Rate();
            rate.setPort(netName);
            rate.setSend(convertFileSize((end.getTxBytes() - start.getTxBytes()) * (1000/wait)));
            rate.setReceive(convertFileSize((end.getRxBytes() - start.getRxBytes()) * (1000/wait)));
            list.add(rate);
        }
        list.sort(Comparator.comparing(Rate::getPort));
        return list;
    }

    /**
     * @return key为网口名
     */
    private static Map<String, IfConfigModel> getNetMap() {
        IfConfig startIfConfig = IfConfig.init();
        List<IfConfigModel> startItems = startIfConfig.getItems();
        return startItems.stream()
                .filter(i -> !i.isLo())
                .filter(IfConfigModel::isRunning)
                .collect(Collectors.toMap(IfConfigModel::getName, Function.identity()));
    }