使用Java代码获取服务器性能信息及局域网内主机名

时间:2022-04-20 21:06:51

最近做个项目,就是要取得cpu占有率等等的系统信息,一开始以为要用动态链接库了,但后来发现可以像下面这样做,不去调用jni,这样省去了很多看新技术的时间o(∩_∩)o...
在Java中,可以获得总的物理内存、剩余的物理内存、已使用的物理内存等信息,下面例子可以取得这些信息,并且获得在Windows下的内存使用率。
     首先编写一个MonitorInfoBean类,用来装载监控的一些信息,包括物理内存、剩余的物理内存、已使用的物理内存、内存使用率等字段,该类的代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
package com.amgkaka.performance;
 
/** */ /**
 * 监视信息的JavaBean类.
 * @author amg
 * @version 1.0 
 * Creation date: 2008-4-25 - 上午10:37:00
 */
public  class MonitorInfoBean {
  /** */ /** 可使用内存. */
  private  long totalMemory;
   
  /** */ /** 剩余内存. */
  private  long freeMemory;
   
  /** */ /** 最大可使用内存. */
  private  long maxMemory;
   
  /** */ /** 操作系统. */
  private String osName;
   
  /** */ /** 总的物理内存. */
  private  long totalMemorySize;
   
  /** */ /** 剩余的物理内存. */
  private  long freePhysicalMemorySize;
   
  /** */ /** 已使用的物理内存. */
  private  long usedMemory;
   
  /** */ /** 线程总数. */
  private  int totalThread;
   
  /** */ /** cpu使用率. */
  private  double cpuRatio;
 
  public  long getFreeMemory() {
    return freeMemory;
  }
 
  public  void setFreeMemory( long freeMemory) {
    this .freeMemory = freeMemory;
  }
 
  public  long getFreePhysicalMemorySize() {
    return freePhysicalMemorySize;
  }
 
  public  void setFreePhysicalMemorySize( long freePhysicalMemorySize) {
    this .freePhysicalMemorySize = freePhysicalMemorySize;
  }
 
  public  long getMaxMemory() {
    return maxMemory;
  }
 
  public  void setMaxMemory( long maxMemory) {
    this .maxMemory = maxMemory;
  }
 
  public String getOsName() {
    return osName;
  }
 
  public  void setOsName(String osName) {
    this .osName = osName;
  }
 
  public  long getTotalMemory() {
    return totalMemory;
  }
 
  public  void setTotalMemory( long totalMemory) {
    this .totalMemory = totalMemory;
  }
 
  public  long getTotalMemorySize() {
    return totalMemorySize;
  }
 
  public  void setTotalMemorySize( long totalMemorySize) {
    this .totalMemorySize = totalMemorySize;
  }
 
  public  int getTotalThread() {
    return totalThread;
  }
 
  public  void setTotalThread( int totalThread) {
    this .totalThread = totalThread;
  }
 
  public  long getUsedMemory() {
    return usedMemory;
  }
 
  public  void setUsedMemory( long usedMemory) {
    this .usedMemory = usedMemory;
  }
 
  public  double getCpuRatio() {
    return cpuRatio;
  }
 
  public  void setCpuRatio( double cpuRatio) {
    this .cpuRatio = cpuRatio;
  }
}

 
接着编写一个获得当前的监控信息的接口,该类的代码如下所示:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.amgkaka.performance;
 
/** */ /**
 * 获取系统信息的业务逻辑类接口.
 * @author amg * @version 1.0 
 * Creation date: 2008-3-11 - 上午10:06:06
 */
public  interface IMonitorService {
  /** */ /**
   * 获得当前的监控对象.
   * @return 返回构造好的监控对象
   * @throws Exception
   * @author amgkaka
   * Creation date: 2008-4-25 - 上午10:45:08
   */
  public MonitorInfoBean getMonitorInfoBean() throws Exception;
 
}

  该类的实现类MonitorServiceImpl如下所示:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
package com.amgkaka.performance;
 
import java.io.InputStreamReader;
import java.io.LineNumberReader;
 
import sun.management.ManagementFactory;
 
import com.sun.management.OperatingSystemMXBean;
 
/** */ /**
 * 获取系统信息的业务逻辑实现类.
 * @author amg * @version 1.0 Creation date: 2008-3-11 - 上午10:06:06
 */
public  class MonitorServiceImpl implements IMonitorService {
  //可以设置长些,防止读到运行此次系统检查时的cpu占用率,就不准了 
  private  static  final  int CPUTIME = 5000 ;
 
  private  static  final  int PERCENT = 100 ;
 
  private  static  final  int FAULTLENGTH = 10 ;
 
  /** */ /**
   * 获得当前的监控对象.
   * @return 返回构造好的监控对象
   * @throws Exception
   * @author amg   * Creation date: 2008-4-25 - 上午10:45:08
   */
  public MonitorInfoBean getMonitorInfoBean() throws Exception {
    int kb = 1024 ;
     
    // 可使用内存 
    long totalMemory = Runtime.getRuntime().totalMemory() / kb;
    // 剩余内存 
    long freeMemory = Runtime.getRuntime().freeMemory() / kb;
    // 最大可使用内存 
    long maxMemory = Runtime.getRuntime().maxMemory() / kb;
 
    OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory
        .getOperatingSystemMXBean();
 
    // 操作系统 
    String osName = System.getProperty("os.name" );
    // 总的物理内存 
    long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;
    // 剩余的物理内存 
    long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;
    // 已使用的物理内存 
    long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb
        .getFreePhysicalMemorySize())
        / kb;
 
    // 获得线程总数 
    ThreadGroup parentThread;
    for (parentThread = Thread.currentThread().getThreadGroup(); parentThread
        .getParent() != null ; parentThread = parentThread.getParent())
      ;
    int totalThread = parentThread.activeCount();
 
    double cpuRatio = 0 ;
    if (osName.toLowerCase().startsWith( "windows" )) {
      cpuRatio = this .getCpuRatioForWindows();
    }
     
    // 构造返回对象 
    MonitorInfoBean infoBean = new MonitorInfoBean();
    infoBean.setFreeMemory(freeMemory);
    infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize);
    infoBean.setMaxMemory(maxMemory);
    infoBean.setOsName(osName);
    infoBean.setTotalMemory(totalMemory);
    infoBean.setTotalMemorySize(totalMemorySize);
    infoBean.setTotalThread(totalThread);
    infoBean.setUsedMemory(usedMemory);
    infoBean.setCpuRatio(cpuRatio);
    return infoBean;
  }
 
  /** */ /**
   * 获得CPU使用率.
   * @return 返回cpu使用率
   * @author amg   * Creation date: 2008-4-25 - 下午06:05:11
   */
  private  double getCpuRatioForWindows() {
    try {
      String procCmd = System.getenv("windir" )
          + "\\system32\\wbem\\wmic.exe process get Caption,CommandLine,"
          + "KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount" ;
      // 取进程信息 
      long [] c0 = readCpu(Runtime.getRuntime().exec(procCmd));
      Thread.sleep(CPUTIME);
      long [] c1 = readCpu(Runtime.getRuntime().exec(procCmd));
      if (c0 != null && c1 != null ) {
        long idletime = c1[ 0 ] - c0[ 0 ];
        long busytime = c1[ 1 ] - c0[ 1 ];
        return Double.valueOf(
            PERCENT * (busytime) / (busytime + idletime))
            .doubleValue();
      } else {
        return  0.0 ;
      }
    } catch (Exception ex) {
      ex.printStackTrace();
      return  0.0 ;
    }
  }
 
  /** */ /**
   * 读取CPU信息.
   * @param proc
   * @return
   * @author amg   * Creation date: 2008-4-25 - 下午06:10:14
   */
  private  long [] readCpu( final Process proc) {
    long [] retn = new  long [ 2 ];
    try {
      proc.getOutputStream().close();
      InputStreamReader ir = new InputStreamReader(proc.getInputStream());
      LineNumberReader input = new LineNumberReader(ir);
      String line = input.readLine();
      if (line == null || line.length() < FAULTLENGTH) {
        return  null ;
      }
      int capidx = line.indexOf( "Caption" );
      int cmdidx = line.indexOf( "CommandLine" );
      int rocidx = line.indexOf( "ReadOperationCount" );
      int umtidx = line.indexOf( "UserModeTime" );
      int kmtidx = line.indexOf( "KernelModeTime" );
      int wocidx = line.indexOf( "WriteOperationCount" );
      long idletime = 0 ;
      long kneltime = 0 ;
      long usertime = 0 ;
      while ((line = input.readLine()) != null ) {
        if (line.length() < wocidx) {
          continue ;
        }
        // 字段出现顺序:Caption,CommandLine,KernelModeTime,ReadOperationCount, 
        // ThreadCount,UserModeTime,WriteOperation 
        String caption = Bytes.substring(line, capidx, cmdidx - 1 )
            .trim();
        String cmd = Bytes.substring(line, cmdidx, kmtidx - 1 ).trim();
        if (cmd.indexOf( "wmic.exe" ) >= 0 ) {
          continue ;
        }
        // log.info("line="+line); 
        if (caption.equals( "System Idle Process" )
            || caption.equals("System" )) {
          idletime += Long.valueOf(
              Bytes.substring(line, kmtidx, rocidx - 1 ).trim())
              .longValue();
          idletime += Long.valueOf(
              Bytes.substring(line, umtidx, wocidx - 1 ).trim())
              .longValue();
          continue ;
        }
 
        kneltime += Long.valueOf(
            Bytes.substring(line, kmtidx, rocidx - 1 ).trim())
            .longValue();
        usertime += Long.valueOf(
            Bytes.substring(line, umtidx, wocidx - 1 ).trim())
            .longValue();
      }
      retn[0 ] = idletime;
      retn[1 ] = kneltime + usertime;
      return retn;
    } catch (Exception ex) {
      ex.printStackTrace();
    } finally {
      try {
        proc.getInputStream().close();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    return  null ;
  }
   
  /** */ /**
   * 测试方法.
   * @param args
   * @throws Exception
   * @author amg   * Creation date: 2008-4-30 - 下午04:47:29
   */
  public  static  void main(String[] args) throws Exception {
    IMonitorService service = new MonitorServiceImpl();
    MonitorInfoBean monitorInfo = service.getMonitorInfoBean();
    System.out.println("cpu占有率=" + monitorInfo.getCpuRatio());
     
    System.out.println("可使用内存=" + monitorInfo.getTotalMemory());
    System.out.println("剩余内存=" + monitorInfo.getFreeMemory());
    System.out.println("最大可使用内存=" + monitorInfo.getMaxMemory());
     
    System.out.println("操作系统=" + monitorInfo.getOsName());
    System.out.println("总的物理内存=" + monitorInfo.getTotalMemorySize() + "kb" );
    System.out.println("剩余的物理内存=" + monitorInfo.getFreeMemory() + "kb" );
    System.out.println("已使用的物理内存=" + monitorInfo.getUsedMemory() + "kb" );
    System.out.println("线程总数=" + monitorInfo.getTotalThread() + "kb" );
  }
}

 
该实现类中需要用到一个自己编写byte的工具类,该类的代码如下所示:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.amgkaka.performance;
 
/** */ /**
 * byte操作类.
 * @author amg * @version 1.0 
 * Creation date: 2008-4-30 - 下午04:57:23
 */
public  class Bytes {
  /** */ /**
   * 由于String.subString对汉字处理存在问题(把一个汉字视为一个字节),因此在
   * 包含汉字的字符串时存在隐患,现调整如下:
   * @param src 要截取的字符串
   * @param start_idx 开始坐标(包括该坐标)
   * @param end_idx  截止坐标(包括该坐标)
   * @return
   */
  public  static String substring(String src, int start_idx, int end_idx){
    byte [] b = src.getBytes();
    String tgt = "" ;
    for ( int i=start_idx; i<=end_idx; i++){
      tgt +=(char )b[i];
    }
    return tgt;
  }
}

 
运行下MonitorBeanImpl类,读者将会看到当前的内存、cpu利用率等信息。

PS:得到局域网内所有主机名的方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.InetAddress;
import java.net.UnknownHostException;
public class A {
 
 static public void main(String[] args) {
 try {
   //通过主机名称得到IP地址
  InetAddress address = InetAddress.getByName("192.168.9.148");
  System.out.println("192.168.9.148"+": "+address.getHostAddress());
//  通过IP得到主机名称
  String ips="192.168.9.",ip;
  InetAddress addip;
    for(int i=148;i<255;i++){
    ip=ips+i; 
    addip=InetAddress.getByName(ip);
     System.out.println(ip+": "+addip.getHostName());
   
    }
  
   
   
  }
  catch(UnknownHostException uhe) {
  System.err.println("Unable to find: "+"192.168.9.148");
  }
 }
 }