Question

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.management.MemoryUsage;
import java.lang.management.OperatingSystemMXBean;
import java.util.HashMap;
import java.util.Map;

import javax.management.JMX;
import javax.management.MBeanServerConnection;
import javax.management.ObjectName;
import javax.management.openmbean.CompositeDataSupport;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.tuniu.myMonitor.dataCollection.IDataCollection;
import com.tuniu.myMonitor.protocol.Performance.GCInfo;
import com.tuniu.myMonitor.protocol.Performance.PerformanceBean;
import com.tuniu.myMonitor.utils.CommonConstants;
import com.tuniu.myMonitor.utils.CommonUtils;


public class DataCollectionImpl implements IDataCollection{

    private static final Logger LOGGER = LoggerFactory
            .getLogger(DataCollectionImpl.class);

    private static final String SERVICE_URL = new StringBuffer(CommonConstants.RMI_PREFIX)
    .append(CommonConstants.RMI_HOST).append(CommonConstants.RMI_PORT).append(CommonConstants.RMI_SUFFIX)
    .toString();

    public PerformanceBean collectPerformanceInfo() {
        long startTime = System.currentTimeMillis();

        MBeanServerConnection mBeanSConnection = null;
        MemoryUsage heapMemoryUsage = null;
        MemoryUsage nonHeapMemoryUsage = null;
        OperatingSystemMXBean osInfo = null;
        Map<String, String> gcInfo = null;
        try {
            mBeanSConnection = CommonUtils.getMBeanSConnector(SERVICE_URL);
            heapMemoryUsage = getMemoryUsage(mBeanSConnection, CommonConstants.HEAPMEMORYUSAGE_ATTRIBUTE_NAME);
            nonHeapMemoryUsage = getMemoryUsage(mBeanSConnection, CommonConstants.NONHEAPMEMORYUSAGE_ATTRIBUTE_NAME);
            osInfo = getOSInfo(mBeanSConnection);
            gcInfo = getJstatFields();
        } catch (Exception e) {
            // TODO
            e.printStackTrace();
        }

        if (isNotNull(mBeanSConnection, heapMemoryUsage, nonHeapMemoryUsage, osInfo, gcInfo)) {
            // TODO add log
            return null;
        }

        PerformanceBean performBean = null;
        performBean = PerformanceBean
                .newBuilder()
                .setArch(osInfo.getArch())
                .setAvailableProcessors(osInfo.getAvailableProcessors())
                .setOsName(osInfo.getName())
                .setSystemLoadAverage(osInfo.getSystemLoadAverage())
                .setCommittedHeap(heapMemoryUsage.getCommitted())
                .setInitHeap(heapMemoryUsage.getInit())
                .setUsedHeap(heapMemoryUsage.getUsed())
                .setMaxHeap(heapMemoryUsage.getMax())
                .setInitNonHeap(nonHeapMemoryUsage.getInit())
                .setCommittedNonHeap(nonHeapMemoryUsage.getCommitted())
                .setUsedNonHeap(nonHeapMemoryUsage.getUsed())
                .setMaxNonHeap(nonHeapMemoryUsage.getMax())
                .setGc(GCInfo.newBuilder().setJstatS0(Double.valueOf(gcInfo.get(CommonConstants.S0)))
                        .setJstatS1(Double.valueOf(gcInfo.get(CommonConstants.S1)))
                        .setJstatE(Double.valueOf(gcInfo.get(CommonConstants.E)))
                        .setJstatO(Double.valueOf(gcInfo.get(CommonConstants.O)))
                        .setJstatP(Double.valueOf(gcInfo.get(CommonConstants.P)))
                        .setJstatYGC(Double.valueOf(gcInfo.get(CommonConstants.YGC)))
                        .setJstatYGCT(Double.valueOf(gcInfo.get(CommonConstants.YGCT)))
                        .setJstatFGC(Double.valueOf(gcInfo.get(CommonConstants.FGC)))
                        .setJstatFGCT(Double.valueOf(gcInfo.get(CommonConstants.FGCT)))
                        .setJstatGCT(Double.valueOf(gcInfo.get(CommonConstants.GCT)))).build();

        LOGGER.info("cost:{}", System.currentTimeMillis() - startTime);
        // ObjectMapper mapper = new ObjectMapper();
        // mapper.writeValue(new
        // File("D:\\Users\\zhangshuo\\Desktop\\perBean.json"), perfBean);
        //
        // mapper.defaultPrettyPrintingWriter().writeValue(new
        // File("D:\\Users\\zhangshuo\\Desktop\\perBean.json"), performBean);
        return performBean;

    }
    //TODO refactor with JMX Proxy
    private MemoryUsage getMemoryUsage(MBeanServerConnection mBeanSConnection,String attribute) throws Exception{
        MemoryUsage heapMemoryUsage = null;

            ObjectName  heapObjName = new ObjectName(CommonConstants.MEMORY_OBJECT_NAME);
            heapObjName = new ObjectName(CommonConstants.MEMORY_OBJECT_NAME);
            heapMemoryUsage = MemoryUsage.from((CompositeDataSupport) mBeanSConnection.getAttribute(heapObjName,
                    attribute));
        return heapMemoryUsage;
    }

    private OperatingSystemMXBean getOSInfo(MBeanServerConnection mBeanSConnection) throws Exception{
    ObjectName osObjectName=null;
    OperatingSystemMXBean osMBeanProxy = null;
        osObjectName = new ObjectName(CommonConstants.OPERATIONSYSYTEM_OBJECT_NAME);
        osMBeanProxy = JMX.newMBeanProxy(mBeanSConnection, osObjectName, OperatingSystemMXBean.class);
    return osMBeanProxy;

    }

    private Map<String, String> getJstatFields() throws Exception {
        Map<String, String> jstatFields = new HashMap<String, String>();
            jstatFields = getGCInfo();
            // TODO log error
        return jstatFields;
    }

    private  Map<String, String> getGCInfo() throws Exception{
        // linux
        // String[] cmd = new String[] { CommonConstants.BASH_CMD,
        // CommonConstants.C_CMD, CommonConstants.JSTAT_COMAND };
        String cmd = "jstat -gcutil 6764";
        Runtime run = Runtime.getRuntime();
        BufferedInputStream in = null;
        BufferedReader inBr = null;
        Process p = run.exec(cmd);
        in = new BufferedInputStream(p.getInputStream());
        inBr = new BufferedReader(new InputStreamReader(in));
        String lineStr = null;
        String[] fieldsName = null;
        String[] fieldsValue = null;
        while ((lineStr = inBr.readLine()) != null) {
            lineStr = lineStr.trim();
            if (lineStr.startsWith("S")) {
                fieldsName = new String(lineStr.getBytes()).replaceAll("\\s+", "|").split("\\|");
            } else {
                fieldsValue = new String(lineStr.getBytes()).replaceAll("\\s+", "|").split("\\|");
            }
        }
        if (p.waitFor() != 0) {
            if (p.exitValue() == 1)
                System.err.println("fail ");
        }
        Map<String, String> fields = null;
        if (fieldsName.length == fieldsValue.length) {

            fields = new HashMap<String, String>();

            for (int i = 0; i < fieldsName.length; i++) {
                fields.put(fieldsName[i], fieldsValue[i]);
            }
        }
        inBr.close();
        in.close();
        return fields;
    }

    private boolean isNotNull(MBeanServerConnection mBeanSConnection,MemoryUsage heapMemoryUsage,MemoryUsage nonHeapMemoryUsage,OperatingSystemMXBean osInfo,Map<String,String> gcInfo){

       return  (null != heapMemoryUsage)&&(null != nonHeapMemoryUsage) && (null != mBeanSConnection) && (null != osInfo) && (null!=gcInfo);

        }
}

每个私有方法我抛出异常而不是立即尝试捕获。最后，我在主要方法上捕获了所有异常。

我应该什么时候尝试捕获或抛出？请有人帮忙！我是对的吗？

Answer 1

虽然问题似乎很广泛，但您需要了解Java异常框架+一些设计模式

1。）如果您在服务中公开一些公共方法，最好捕获异常

Log Exception -> Return proper error code/message

2.）抛出异常意味着每个调用该方法的人都必须自己处理异常。

3.如果方法的内部实现有任何变化，那么你最终可能会抛出一个不同的异常。

4。）同时抛出superclass Exception，再次失去了精确度的焦点。

我应该在哪里捕捉异常????主要的公共方法？或私人方法？

1 个答案: