package com.wgcloud.util;

import com.wgcloud.entity.SnmpInfo;
import com.wgcloud.entity.SnmpInterfaceInfo;
import com.wgcloud.util.staticvar.StaticKeys;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.snmp4j.*;
import org.snmp4j.event.ResponseEvent;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.security.SecurityLevel;
import org.snmp4j.security.SecurityModel;
import org.snmp4j.smi.*;
import org.snmp4j.transport.DefaultUdpTransportMapping;

import java.io.IOException;
import java.net.InetAddress;
import java.util.*;

/**
 * @version V1.0
 * @ClassName:SnmpUtil.java
 * @author: wgcloud
 * @date: 2022年4月10日
 * @Description: snmp监测工具类
 * @Copyright: 2019-2021 wgcloud. All rights reserved.
 */
public class SnmpUtil {

    private static final Logger logger = LoggerFactory.getLogger(SnmpUtil.class);


    /**
     * 设定CommunityTarget
     *
     * @param ip          设备IP
     * @param community   团体名称
     * @param port        snmp服务的端口号，默认161
     * @param snmpVersion snmp版本，0对应version1，1对应version2c，3对应version3
     * @return
     */
    public static Target createDefault(String ip, String community, String port, int snmpVersion) {
        if (StringUtils.isBlank(ip)) {
            logger.error("ip is null.");
            return null;
        }

        if (StringUtils.isBlank(community)) {
            logger.error("community is null.");
            return null;
        }

        //定义远程主机的地址
        Address address = GenericAddress.parse("udp:" + ip + "/" + port);
        //设定CommunityTarget
        Target target = null;

        //设置使用的snmp版本 begin
        if (snmpVersion == SnmpConstants.version3) {
            target = new UserTarget();
            //snmpV3需要设置安全级别和安全名称，其中安全名称是创建snmp指定user设置的new OctetString("SNMPV3")
            target.setSecurityLevel(SecurityLevel.AUTH_PRIV);
            target.setSecurityName(new OctetString(community));
        } else {
            //snmpV1和snmpV2需要指定团体名名称
            target = new CommunityTarget();
            ((CommunityTarget) target).setCommunity(new OctetString(community));
            if (snmpVersion == SnmpConstants.version2c) {
                target.setSecurityModel(SecurityModel.SECURITY_MODEL_SNMPv2c);
            }
        }
        target.setVersion(snmpVersion);
        //设置使用的snmp版本 end

        // 设定机器的地址
        target.setAddress(address);
        //设置超时的时间，毫秒
        target.setTimeout(15000);
        //设置超时重试次数
        target.setRetries(2);
        return target;
    }

    /**
     * 处理snmp设备集合，标注设备是否在线，返回MAP集合<IP，状态1在线2下线>
     *
     * @param snmpInfoAllList
     * @return
     */
    public static Map<String, String> getOnLineList(List<SnmpInfo> snmpInfoAllList) {
        Map<String, String> resultMap = new HashMap<>();
        Set<String> set = new HashSet<>();
        for (SnmpInfo snmpInfo : snmpInfoAllList) {
            set.add(snmpInfo.getHostname());
        }
        for (String hostName : set) {
            if (!isEthernetConnection(hostName)) {
                resultMap.put(hostName, StaticKeys.DOWN_STATE);
            } else {
                resultMap.put(hostName, StaticKeys.ON_STATE);
            }
        }
        logger.info("snmp设备在线集合：" + resultMap.toString());
        return resultMap;
    }

    /**
     * 测网络通不通 类似 ping ip，通的话返回true，不通返回false
     *
     * @param ip
     * @return
     * @throws IOException
     */
    public static boolean isEthernetConnection(String ip) {
        try {
            InetAddress ad = InetAddress.getByName(ip);
            // 测试是否可以达到该地址 3秒超时
            boolean state = ad.isReachable(3000);
            return state;
        } catch (Exception e) {
            logger.error("isEthernetConnection错误", e);
        }
        return false;
    }

    /**
     * 获取设备流量累积和平均值
     *
     * @param snmpInfo
     * @return
     */
    public static SnmpInfo getAvgSnmpInfo(SnmpInfo snmpInfo) {
        SnmpInfo snmpInfo2 = new SnmpInfo();
        try {
            /*if (!isEthernetConnection(snmpInfo.getHostname())) {
                return null;
            }*/
            SnmpInfo snmpInfo1 = SnmpUtil.snmpGet(snmpInfo);
            long beginBytesRecv = Long.valueOf(snmpInfo1.getBytesRecv());
            long beginBytesSent = Long.valueOf(snmpInfo1.getBytesSent());

            //暂停3秒，再次获取流量，然后计算平均值
            Thread.sleep(3000);

            snmpInfo2 = SnmpUtil.snmpGet(snmpInfo);
            long endBytesRecv = Long.valueOf(snmpInfo2.getBytesRecv());
            long endBytesSent = Long.valueOf(snmpInfo2.getBytesSent());

            double recvAvg = (endBytesRecv - beginBytesRecv) / (double) 3;
            double sentAvg = (endBytesSent - beginBytesSent) / (double) 3;
            snmpInfo2.setRecvAvg(FormatUtil.formatDouble(recvAvg, 2) + "");
            snmpInfo2.setSentAvg(FormatUtil.formatDouble(sentAvg, 2) + "");

            //CPU使用率% = 100 - 空闲CPU使用率%
            if (!StringUtils.isEmpty(snmpInfo.getCpuPerOID())) {
                double cpuPer = 100 - Double.valueOf(snmpInfo2.getCpuPer());
                snmpInfo2.setCpuPer(FormatUtil.formatDouble(cpuPer, 2) + "");
            } else {
                snmpInfo2.setCpuPer("0");
            }

            //计算内存使用率% begin
            if (!StringUtils.isEmpty(snmpInfo.getMemSizeOID()) && !StringUtils.isEmpty(snmpInfo.getMemTotalSizeOID())) {
                long memSize = Long.valueOf(snmpInfo2.getMemSize());
                long memTotalSize = Long.valueOf(snmpInfo2.getMemTotalSize());
                snmpInfo2.setMemPer(FormatUtil.formatDouble(((double) memSize / memTotalSize) * 100, 2) + "");
            } else {
                snmpInfo2.setMemPer("0");
            }
            //计算内存使用率% end

            return snmpInfo2;
        } catch (Exception e) {
            logger.error("getAvgSnmpInfo错误", e);
            snmpInfo2.setRecvAvg("0");
            snmpInfo2.setSentAvg("0");
            snmpInfo2.setMemSize("0");
            snmpInfo2.setMemTotalSize("1");
            snmpInfo2.setCpuPer("0");
            snmpInfo2.setMemPer("0");
        }
        return snmpInfo2;
    }

    /**
     * 获取接口信息
     *
     * @param snmpInfo
     * @return
     */
    public static List<SnmpInterfaceInfo> getInterfaceSnmpInfo(SnmpInfo snmpInfo) {

        //接口名称OID
        String interfaceNameOID = snmpInfo.getInterfaceNameOID();
        //接口状态 OID
        String interfaceStatusOID = snmpInfo.getInterfaceStatusOID();
        //速率 OID
        String actualSpeedOID = snmpInfo.getActualSpeedOID();
        //工作模式OID
        String workMTUOID = snmpInfo.getWorkMTUOID();
        //双工模式OID
        String actualMTUOID = snmpInfo.getActualMTUOID();
        //环回检测 OID
        String loopbackOID = snmpInfo.getLoopbackOID();
        //描述OID
        String descriptionOID = snmpInfo.getDescriptionOID();

        List<Map<String,Object>> interfaceStatusList = new ArrayList<>();
        List<Map<String,Object>> interfaceNameList = new ArrayList<>();
        List<Map<String,Object>> actualSpeedList = new ArrayList<>();
        List<Map<String,Object>> workMTUList = new ArrayList<>();
        List<Map<String,Object>> actualMTUList = new ArrayList<>();
        List<Map<String,Object>> loopbackList = new ArrayList<>();
        List<Map<String,Object>> descriptionList = new ArrayList<>();

        List<SnmpInterfaceInfo> interfaceInfos = new ArrayList<>();

        if(StringUtils.isNotEmpty(interfaceNameOID)){
            interfaceNameList = snmpGetInterface(snmpInfo, interfaceNameOID);
        }
        if(StringUtils.isNotEmpty(interfaceStatusOID)){
            interfaceStatusList = snmpGetInterface(snmpInfo, interfaceStatusOID);
        }
        if(StringUtils.isNotEmpty(actualSpeedOID)){
            actualSpeedList = snmpGetInterface(snmpInfo, actualSpeedOID);
        }
        if(StringUtils.isNotEmpty(workMTUOID)){
            workMTUList = snmpGetInterface(snmpInfo, workMTUOID);
        }
        if(StringUtils.isNotEmpty(actualMTUOID)){
            actualMTUList = snmpGetInterface(snmpInfo, actualMTUOID);
        }
        if(StringUtils.isNotEmpty(loopbackOID)){
            loopbackList = snmpGetInterface(snmpInfo, loopbackOID);
        }
        if(StringUtils.isNotEmpty(descriptionOID)){
            descriptionList = snmpGetInterface(snmpInfo, descriptionOID);
        }

        if (interfaceNameList.size() >0 ){
            for (int i = 0; i < interfaceNameList.size(); i++) {
                Map<String, Object> stringObjectMap = interfaceNameList.get(i);
                for (Map.Entry<String, Object> stringObjectEntry : stringObjectMap.entrySet()) {
                    SnmpInterfaceInfo snmpInterfaceInfo = new SnmpInterfaceInfo();
                    snmpInterfaceInfo.setId(UUIDUtil.getUUID());
                    snmpInterfaceInfo.setCreateTime(new Date());
                    snmpInterfaceInfo.setHostname(snmpInfo.getHostname());
                    snmpInterfaceInfo.setInterfaceName(stringObjectEntry.getValue().toString().trim());
                    interfaceInfos.add(snmpInterfaceInfo);
                }
            }
        }
        if(interfaceStatusList.size() > 0){
            for (int i = 0; i < interfaceStatusList.size(); i++) {
                Map<String, Object> stringObjectMap = interfaceStatusList.get(i);
                SnmpInterfaceInfo snmpInterfaceInfo = interfaceInfos.get(i);
                for (Map.Entry<String, Object> stringObjectEntry : stringObjectMap.entrySet()) {
                    try {
                        snmpInterfaceInfo.setIsUp(Integer.parseInt(stringObjectEntry.getValue().toString().trim()));
                    }catch (Exception e){
                        snmpInterfaceInfo.setIsUp(0);
                        e.printStackTrace();
                    }
                }
            }
        }
        if (actualSpeedList.size()>0){
            for (int i = 0; i < actualSpeedList.size(); i++) {
                Map<String, Object> stringObjectMap = actualSpeedList.get(i);
                SnmpInterfaceInfo snmpInterfaceInfo = interfaceInfos.get(i);
                for (Map.Entry<String, Object> stringObjectEntry : stringObjectMap.entrySet()) {
                    try {
                        snmpInterfaceInfo.setActualSpeed(Long.parseLong(stringObjectEntry.getValue().toString().trim()));
                    }catch (Exception e){
                        snmpInterfaceInfo.setActualSpeed(100000L);
                        e.printStackTrace();
                    }
                }
            }
        }
        if (workMTUList.size()>0){
            for (int i = 0; i < workMTUList.size(); i++) {
                Map<String, Object> stringObjectMap = workMTUList.get(i);
                SnmpInterfaceInfo snmpInterfaceInfo = interfaceInfos.get(i);
                for (Map.Entry<String, Object> stringObjectEntry : stringObjectMap.entrySet()) {
                    try {
                        snmpInterfaceInfo.setWorkMTU(Integer.parseInt(stringObjectEntry.getValue().toString().trim()));
                    }catch (Exception e){
                        snmpInterfaceInfo.setWorkMTU(1500);
                        e.printStackTrace();
                    }
                }
            }
        }
        if (actualMTUList.size()>0){
            for (int i = 0; i < actualMTUList.size(); i++) {
                Map<String, Object> stringObjectMap = actualMTUList.get(i);
                SnmpInterfaceInfo snmpInterfaceInfo = interfaceInfos.get(i);
                for (Map.Entry<String, Object> stringObjectEntry : stringObjectMap.entrySet()) {
                    try {
                        snmpInterfaceInfo.setActualMTU(Integer.parseInt(stringObjectEntry.getValue().toString().trim()));
                    }catch (Exception e){
                        snmpInterfaceInfo.setActualMTU(1500);
                        e.printStackTrace();
                    }
                }
            }
        }
        if (loopbackList.size()>0){
            for (int i = 0; i < loopbackList.size(); i++) {
                Map<String, Object> stringObjectMap = loopbackList.get(i);
                SnmpInterfaceInfo snmpInterfaceInfo = interfaceInfos.get(i);
                for (Map.Entry<String, Object> stringObjectEntry : stringObjectMap.entrySet()) {
                    try {
                        snmpInterfaceInfo.setLoopback(Integer.parseInt(stringObjectEntry.getValue().toString().trim()));
                    }catch (Exception e){
                        snmpInterfaceInfo.setLoopback(0);
                        e.printStackTrace();
                    }
                }
            }
        }
        if (descriptionList.size()>0){
            for (int i = 0; i < descriptionList.size(); i++) {
                Map<String, Object> stringObjectMap = descriptionList.get(i);
                SnmpInterfaceInfo snmpInterfaceInfo = interfaceInfos.get(i);
                for (Map.Entry<String, Object> stringObjectEntry : stringObjectMap.entrySet()) {
                    try {
                        snmpInterfaceInfo.setDescription(stringObjectEntry.getValue().toString().trim());
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }
        return interfaceInfos;
    }

    /**
     * snmpGet方式 获取交换机设备的发送、接收流量数据
     */
    public static SnmpInfo snmpGet(SnmpInfo snmpInfo) {
        Snmp snmp = null;
        TransportMapping transport = null;
        SnmpInfo snmpInfoRes = new SnmpInfo();
        Vector<? extends VariableBinding> vector = null;
        try {
            //设备IP
            String ip = snmpInfo.getHostname();
            //团体名称
            String community = snmpInfo.getSnmpCommunity();
            //snmp服务的端口号，默认161
            String port = snmpInfo.getSnmpPort();
            //snmp版本，0对应version1，1对应version2c，3对应version3
            int snmpVersion = Integer.valueOf(snmpInfo.getSnmpVersion());
            //上行出口流量字节数 OID
            String sendOID = snmpInfo.getSentOID();
            //下行入口流量字节数 OID
            String receiveOID = snmpInfo.getRecvOID();
            //空闲%CPU使用率 OID
            String cpuPerOID = snmpInfo.getCpuPerOID();
            //内存已使用大小 OID
            String memSizeOID = snmpInfo.getMemSizeOID();
            //内存总大小 OID
            String memTotalSizeOID = snmpInfo.getMemTotalSizeOID();
            if (StringUtils.isEmpty(sendOID) || StringUtils.isEmpty(receiveOID)) {
                snmpInfoRes.setBytesSent("0");
                snmpInfoRes.setBytesRecv("0");
            }
            if (StringUtils.isEmpty(cpuPerOID)) {
                snmpInfoRes.setCpuPer("100");
            }
            if (StringUtils.isEmpty(memSizeOID)) {
                snmpInfoRes.setMemSize("0");
            }
            if (StringUtils.isEmpty(memTotalSizeOID)) {
                snmpInfoRes.setMemTotalSize("1");
            }
            //设定CommunityTarget
            Target myTarget = createDefault(ip, community, port, snmpVersion);

            // 设定采取的协议 // 设定传输协议为UDP
            transport = new DefaultUdpTransportMapping();
            // 调用TransportMapping中的listen()方法，启动监听进程，接收消息，由于该监听进程是守护进程，最后应调用close()方法来释放该进程
            transport.listen();
            // 创建SNMP对象，用于发送请求PDU
            snmp = new Snmp(transport);
            // 创建请求pdu,获取mib
            PDU request = new PDU();

            // 调用的add方法绑定要查询的OID
            //上行，端口出口流量(byte)，绑定多个OID
            String[] sendOIDs = sendOID.split(StaticKeys.SPLIT_ENTER);
            for (String sendOIDTmp : sendOIDs) {
                request.add(new VariableBinding(new OID(sendOIDTmp.trim())));
            }

            //下行，端口入口流量(byte)，绑定多个OID
            String[] receiveOIDs = receiveOID.split(StaticKeys.SPLIT_ENTER);
            for (String receiveOIDTmp : receiveOIDs) {
                request.add(new VariableBinding(new OID(receiveOIDTmp.trim())));
            }

            //绑定空闲cpu使用率OID
            if (!StringUtils.isEmpty(cpuPerOID)) {
                request.add(new VariableBinding(new OID(cpuPerOID.trim())));
            }

            //绑定内存已使用大小OID和内存总大小OID
            if (!StringUtils.isEmpty(memSizeOID) && !StringUtils.isEmpty(memTotalSizeOID)) {
                request.add(new VariableBinding(new OID(memSizeOID.trim())));
                request.add(new VariableBinding(new OID(memTotalSizeOID.trim())));
            }


            // 调用setType()方法来确定该pdu的类型
            request.setType(PDU.GET);
            // 调用 send(PDU pdu,Target target)发送pdu，返回一个ResponseEvent对象
            ResponseEvent responseEvent = snmp.send(request, myTarget);
            // 通过ResponseEvent对象来获得SNMP请求的应答pdu，方法：public PDU getResponse()
            PDU response = responseEvent.getResponse();
            vector = response.getVariableBindings();

            long bytesSentSum = 0;
            long bytesRecvSum = 0;

            // 通过应答pdu获得mib信息（之前绑定的OID的值），方法：VaribleBinding get(int index)
            for (int i = 0; i < vector.size(); i++) {
                try {
                    VariableBinding vb1 = vector.get(i);
                    if (sendOID.contains(String.valueOf(vb1.getOid()))) {
                        bytesSentSum += Long.valueOf(String.valueOf(vb1.getVariable()));
                        continue;
                    }
                    if (receiveOID.contains(String.valueOf(vb1.getOid()))) {
                        bytesRecvSum += Long.valueOf(String.valueOf(vb1.getVariable()));
                        continue;
                    }
                    if (cpuPerOID.contains(String.valueOf(vb1.getOid()))) {
                        snmpInfoRes.setCpuPer(String.valueOf(vb1.getVariable()));
                        continue;
                    }
                    if (memSizeOID.contains(String.valueOf(vb1.getOid()))) {
                        snmpInfoRes.setMemSize(String.valueOf(vb1.getVariable()));
                        continue;
                    }
                    if (memTotalSizeOID.contains(String.valueOf(vb1.getOid()))) {
                        snmpInfoRes.setMemTotalSize(String.valueOf(vb1.getVariable()));
                        continue;
                    }
                } catch (Exception e) {
                    logger.error("snmp应答pdu获得mib信息错误", e);
                }
            }
            snmpInfoRes.setBytesSent(String.valueOf(bytesSentSum));
            snmpInfoRes.setBytesRecv(String.valueOf(bytesRecvSum));
            return snmpInfoRes;
        } catch (Exception e) {
            logger.error("snmp检测错误", e);
        } finally {
            // 调用close()方法释放该进程
            closeTransport(transport);
            closeSnmp(snmp);
        }
        return snmpInfoRes;
    }


    /**
     * WALK方式请求
     *功能简介：这个方法是getnext，就是遍历该oid下的所有子节点
     */
    public static List<Map<String,Object>> snmpGetInterface(SnmpInfo snmpInfo, String oid) {
        Snmp snmp = null;
        try {
            List<Map<String,Object>> list = new ArrayList<>();

            //1、初始化snmp,并开启监听
            snmp = new Snmp(new DefaultUdpTransportMapping());
            //开启监听
            snmp.listen();
            //2、创建目标对象
            Target target = createTarget(snmpInfo.getHostname(),snmpInfo.getSnmpPort(),snmpInfo.getSnmpCommunity());
            //3、创建报文
            PDU pdu = createPDU(Integer.parseInt(snmpInfo.getSnmpVersion()), PDU.GETNEXT,oid );
            //4、发送报文，并获取返回结果
            boolean matched = true;
            while (matched) {
                ResponseEvent responseEvent = snmp.send(pdu, target);
                if (responseEvent == null || responseEvent.getResponse() == null) {
                    //LogUtil.info("snmp TimeOut...");
                    break;
                }
                PDU response = responseEvent.getResponse();
                String nextOid = null;
                Vector<? extends VariableBinding> variableBindings = response.getVariableBindings();
                for (int i = 0; i < variableBindings.size(); i++) {

                    VariableBinding variableBinding = variableBindings.elementAt(i);
                    Variable variable = variableBinding.getVariable();
                    nextOid = variableBinding.getOid().toDottedString();
                    //如果不是这个节点下的oid则终止遍历，否则会输出很多，直到整个遍历完。
                    if (!nextOid.startsWith(oid)) {
                        matched = false;
                        break;
                    }
                    Map<String,Object> map = new HashMap();
                    //放入oid以及oid对应获得的值
                    map.put(nextOid,variable);
                    list.add(map);
                }
                if (!matched) {
                    break;
                }
                pdu.clear();
                pdu.add(new VariableBinding(new OID(nextOid)));
            }
            System.out.println("list的大小 = " +list.size());
            System.out.println(list);
            return list;

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    private static PDU createPDU(int version, int type, String oid) {
        PDU pdu = null;
        if (version == SnmpConstants.version3) {
            pdu = new ScopedPDU();
        } else {
            pdu = new PDUv1();
        }
        pdu.setType(type);
        pdu.add(new VariableBinding(new OID(oid.trim())));
//        //接口状态OID
//        if (!StringUtils.isEmpty(actualSpeedOID)) {
//            pdu.add(new VariableBinding(new OID(interfaceStatusOID.trim())));
//        }
//        //绑定速率 OID
//        if (!StringUtils.isEmpty(actualSpeedOID)) {
//            pdu.add(new VariableBinding(new OID(actualSpeedOID.trim())));
//        }
//        //工作模式OID
//        if (!StringUtils.isEmpty(workMTUOID)) {
//            pdu.add(new VariableBinding(new OID(workMTUOID.trim())));
//        }
//        //双工模式OID
//        if (!StringUtils.isEmpty(actualMTUOID)) {
//            pdu.add(new VariableBinding(new OID(actualMTUOID.trim())));
//        }
//        //环回检测 OID
//        if (!StringUtils.isEmpty(loopbackOID)) {
//            pdu.add(new VariableBinding(new OID(loopbackOID.trim())));
//        }
//        //描述OID
//        if (!StringUtils.isEmpty(descriptionOID)) {
//            pdu.add(new VariableBinding(new OID(descriptionOID.trim())));
//        }
        return pdu;
    }


    private static Target createTarget(String hostIp, String port, String community) {
        //先得到连接的ip和端口号
        String addressGet = "udp:" + hostIp+"/"+port;

        Target target = null;
        int version = 1;
        if (!(version == SnmpConstants.version3 || version == SnmpConstants.version2c || version == SnmpConstants.version1)) {
            return target;
        }
//        if (version == SnmpConstants.version3) {
//            target = new UserTarget();
//            //snmpV3需要设置安全级别和安全名称，其中安全名称是创建snmp指定user设置的new OctetString("SNMPV3")
//            target.setSecurityLevel(SecurityLevel.AUTH_PRIV);
//            target.setSecurityName(new OctetString(this.username));
//        } else
        {
            //snmpV1和snmpV2需要指定团体名名称
            target = new CommunityTarget();
            ((CommunityTarget) target).setCommunity(new OctetString(community));
            if (version == SnmpConstants.version2c) {
                target.setSecurityModel(SecurityModel.SECURITY_MODEL_SNMPv2c);
            }
        }
        target.setVersion(version);
        //必须指定，没有设置就会报错。
        target.setAddress(GenericAddress.parse(addressGet));
        target.setRetries(3);
        target.setTimeout(2000);
        return target;
    }



    /**
     * 调用close()方法释放该进程
     *
     * @param transport
     */
    private static void closeTransport(TransportMapping transport) {
        try {
            if (null != transport) {
                transport.close();
            }
        } catch (Exception e) {
            logger.error("closeTransport错误", e);
        }
    }

    /**
     * 关闭snmp
     *
     * @param snmp
     */
    private static void closeSnmp(Snmp snmp) {
        try {
            if (null != snmp) {
                snmp.close();
            }
        } catch (Exception e) {
            logger.error("closeSnmp错误", e);
        }
    }

    public static void main(String[] args) {
        SnmpInfo snmpInfo = new SnmpInfo();
        snmpInfo.setHostname("192.168.8.150");
        snmpInfo.setSnmpCommunity("public");
        snmpInfo.setSnmpVersion("1");
        snmpInfo.setSnmpPort("161");
        snmpInfo.setInterfaceNameOID("1.3.6.1.2.1.31.1.1.1.1");
        snmpInfo.setInterfaceStatusOID("1.3.6.1.2.1.2.2.1.8");
        snmpInfo.setActualSpeedOID("1.3.6.1.2.1.2.2.1.5");
        snmpInfo.setActualMTUOID("1.3.6.1.2.1.10.7.2.1.19");
        snmpInfo.setDescriptionOID("1.3.6.1.2.1.2.2.1.2");
        List<Map<String, Object>> maps = snmpGetInterface(snmpInfo, snmpInfo.getDescriptionOID());
        for (Map<String, Object> map : maps) {
            for (Map.Entry<String, Object> stringObjectEntry : map.entrySet()) {
                Object value = stringObjectEntry.getValue();
                System.out.println(value);
            }
        }
    }


}