zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-07-21 15:09:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

change line sep

Browse Source
This commit is contained in:
Looly
2021-01-20 17:10:45 +08:00
parent 720d24566b
commit 4e38adb32d
1450 changed files with 183940 additions and 183940 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
hutool-system/src/main/java/cn/hutool/system/HostInfo.java
View File

@@ -1,69 +1,69 @@
package cn.hutool.system;
import cn.hutool.core.net.NetUtil;
import java.io.Serializable;
import java.net.InetAddress;
/**
* 代表当前主机的信息。
*/
public class HostInfo implements Serializable {
private static final long serialVersionUID = 1L;
private final String HOST_NAME;
private final String HOST_ADDRESS;
public HostInfo() {
final InetAddress localhost = NetUtil.getLocalhost();
if(null != localhost){
HOST_NAME = localhost.getHostName();
HOST_ADDRESS = localhost.getHostAddress();
} else{
HOST_NAME = null;
HOST_ADDRESS = null;
}
}
/**
* 取得当前主机的名称。
*
* <p>
* 例如：<code>"webserver1"</code>
* </p>
*
* @return 主机名
*/
public final String getName() {
return HOST_NAME;
}
/**
* 取得当前主机的地址。
*
* <p>
* 例如：<code>"192.168.0.1"</code>
* </p>
*
* @return 主机地址
*/
public final String getAddress() {
return HOST_ADDRESS;
}
/**
* 将当前主机的信息转换成字符串。
*
* @return 主机信息的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "Host Name: ", getName());
SystemUtil.append(builder, "Host Address: ", getAddress());
return builder.toString();
}
}
package cn.hutool.system;
import cn.hutool.core.net.NetUtil;
import java.io.Serializable;
import java.net.InetAddress;
/**
* 代表当前主机的信息。
*/
public class HostInfo implements Serializable {
private static final long serialVersionUID = 1L;
private final String HOST_NAME;
private final String HOST_ADDRESS;
public HostInfo() {
final InetAddress localhost = NetUtil.getLocalhost();
if(null != localhost){
HOST_NAME = localhost.getHostName();
HOST_ADDRESS = localhost.getHostAddress();
} else{
HOST_NAME = null;
HOST_ADDRESS = null;
}
}
/**
* 取得当前主机的名称。
*
* <p>
* 例如：<code>"webserver1"</code>
* </p>
*
* @return 主机名
*/
public final String getName() {
return HOST_NAME;
}
/**
* 取得当前主机的地址。
*
* <p>
* 例如：<code>"192.168.0.1"</code>
* </p>
*
* @return 主机地址
*/
public final String getAddress() {
return HOST_ADDRESS;
}
/**
* 将当前主机的信息转换成字符串。
*
* @return 主机信息的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "Host Name: ", getName());
SystemUtil.append(builder, "Host Address: ", getAddress());
return builder.toString();
}
}

722
hutool-system/src/main/java/cn/hutool/system/JavaInfo.java
View File

@@ -1,361 +1,361 @@
package cn.hutool.system;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ReUtil;
import java.io.Serializable;
/**
* 代表Java Implementation的信息。
*/
public class JavaInfo implements Serializable {
private static final long serialVersionUID = 1L;
private final String JAVA_VERSION = SystemUtil.get("java.version", false);
private final float JAVA_VERSION_FLOAT = getJavaVersionAsFloat();
private final int JAVA_VERSION_INT = getJavaVersionAsInt();
private final String JAVA_VENDOR = SystemUtil.get("java.vendor", false);
private final String JAVA_VENDOR_URL = SystemUtil.get("java.vendor.url", false);
// 1.1--1.3能否识别?
private final boolean IS_JAVA_1_1 = getJavaVersionMatches("1.1");
private final boolean IS_JAVA_1_2 = getJavaVersionMatches("1.2");
private final boolean IS_JAVA_1_3 = getJavaVersionMatches("1.3");
private final boolean IS_JAVA_1_4 = getJavaVersionMatches("1.4");
private final boolean IS_JAVA_1_5 = getJavaVersionMatches("1.5");
private final boolean IS_JAVA_1_6 = getJavaVersionMatches("1.6");
private final boolean IS_JAVA_1_7 = getJavaVersionMatches("1.7");
private final boolean IS_JAVA_1_8 = getJavaVersionMatches("1.8");
private final boolean IS_JAVA_9 = getJavaVersionMatches("9");
private final boolean IS_JAVA_10 = getJavaVersionMatches("10");
private final boolean IS_JAVA_11 = getJavaVersionMatches("11");
private final boolean IS_JAVA_12 = getJavaVersionMatches("12");
/**
* 取得当前Java impl.的版本（取自系统属性：<code>java.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"1.4.2"</code>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
* @since Java 1.1
*/
public final String getVersion() {
return JAVA_VERSION;
}
/**
* 取得当前Java impl.的版本（取自系统属性：<code>java.version</code>）。
*
* <p>
* 例如：
*
* <ul>
* <li>JDK 1.2：<code>1.2f</code>。</li>
* <li>JDK 1.3.1：<code>1.31f</code></li>
* </ul>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>0</code>。
*/
public final float getVersionFloat() {
return JAVA_VERSION_FLOAT;
}
/**
* 取得当前Java impl.的版本（取自系统属性：<code>java.version</code>），java10及其之后的版本返回值为4位。
*
* <p>
* 例如：
*
* <ul>
* <li>JDK 1.2：<code>120</code>。</li>
* <li>JDK 1.3.1：<code>131</code></li>
* <li>JDK 11.0.2：<code>1102</code></li>
* </ul>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>0</code>。
* @since Java 1.1
*/
public final int getVersionInt() {
return JAVA_VERSION_INT;
}
/**
* 取得当前Java impl.的版本的<code>float</code>值。
*
* @return Java版本的<code>float</code>值或<code>0</code>
*/
private float getJavaVersionAsFloat() {
if (JAVA_VERSION == null) {
return 0f;
}
String str = JAVA_VERSION;
str = ReUtil.get("^[0-9]{1,2}(\\.[0-9]{1,2})?", str, 0);
return Float.parseFloat(str);
}
/**
* 取得当前Java impl.的版本的<code>int</code>值。
*
* @return Java版本的<code>int</code>值或<code>0</code>
*/
private int getJavaVersionAsInt() {
if (JAVA_VERSION == null) {
return 0;
}
String javaVersion = ReUtil.get("^[0-9]{1,2}(\\.[0-9]{1,2}){0,2}", JAVA_VERSION, 0);
String[] split = javaVersion.split("\\.");
String result = ArrayUtil.join(split, "");
//保证java10及其之后的版本返回的值为4位
if (split[0].length() > 1) {
result = (result + "0000").substring(0, 4);
}
return Integer.parseInt(result);
}
/**
* 取得当前Java impl.的厂商（取自系统属性：<code>java.vendor</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Sun Microsystems Inc."</code>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
* @since Java 1.1
*/
public final String getVendor() {
return JAVA_VENDOR;
}
/**
* 取得当前Java impl.的厂商网站的URL（取自系统属性：<code>java.vendor.url</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"http://java.sun.com/"</code>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
* @since Java 1.1
*/
public final String getVendorURL() {
return JAVA_VENDOR_URL;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.1，则返回<code>true</code>
*/
public final boolean isJava1_1() {
return IS_JAVA_1_1;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.2，则返回<code>true</code>
*/
public final boolean isJava1_2() {
return IS_JAVA_1_2;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.3，则返回<code>true</code>
*/
public final boolean isJava1_3() {
return IS_JAVA_1_3;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.4，则返回<code>true</code>
*/
public final boolean isJava1_4() {
return IS_JAVA_1_4;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.5，则返回<code>true</code>
*/
public final boolean isJava1_5() {
return IS_JAVA_1_5;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.6，则返回<code>true</code>
*/
public final boolean isJava1_6() {
return IS_JAVA_1_6;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.7，则返回<code>true</code>
*/
public final boolean isJava1_7() {
return IS_JAVA_1_7;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.8，则返回<code>true</code>
*/
public final boolean isJava1_8() {
return IS_JAVA_1_8;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为9，则返回<code>true</code>
*/
public final boolean isJava9() {
return IS_JAVA_9;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为10，则返回<code>true</code>
*/
public final boolean isJava10() {
return IS_JAVA_10;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为11，则返回<code>true</code>
*/
public final boolean isJava11() {
return IS_JAVA_11;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为12，则返回<code>true</code>
*/
public final boolean isJava12() {
return IS_JAVA_12;
}
/**
* 匹配当前Java的版本。
*
* @param versionPrefix Java版本前缀
* @return 如果版本匹配，则返回<code>true</code>
*/
private boolean getJavaVersionMatches(String versionPrefix) {
if (JAVA_VERSION == null) {
return false;
}
return JAVA_VERSION.startsWith(versionPrefix);
}
/**
* 判定当前Java的版本是否大于等于指定的版本号。
*
* <p>
* 例如：
*
*
* <ul>
* <li>测试JDK 1.2：<code>isJavaVersionAtLeast(1.2f)</code></li>
* <li>测试JDK 1.2.1：<code>isJavaVersionAtLeast(1.31f)</code></li>
* </ul>
*
* @param requiredVersion 需要的版本
* @return 如果当前Java版本大于或等于指定的版本，则返回<code>true</code>
*/
public final boolean isJavaVersionAtLeast(float requiredVersion) {
return getVersionFloat() >= requiredVersion;
}
/**
* 判定当前Java的版本是否大于等于指定的版本号。
*
* <p>
* 例如：
*
*
* <ul>
* <li>测试JDK 1.2：<code>isJavaVersionAtLeast(120)</code></li>
* <li>测试JDK 1.2.1：<code>isJavaVersionAtLeast(131)</code></li>
* </ul>
*
* @param requiredVersion 需要的版本
* @return 如果当前Java版本大于或等于指定的版本，则返回<code>true</code>
*/
public final boolean isJavaVersionAtLeast(int requiredVersion) {
return getVersionInt() >= requiredVersion;
}
/**
* 将Java Implementation的信息转换成字符串。
*
* @return JVM impl.的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "Java Version: ", getVersion());
SystemUtil.append(builder, "Java Vendor: ", getVendor());
SystemUtil.append(builder, "Java Vendor URL: ", getVendorURL());
return builder.toString();
}
}
package cn.hutool.system;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ReUtil;
import java.io.Serializable;
/**
* 代表Java Implementation的信息。
*/
public class JavaInfo implements Serializable {
private static final long serialVersionUID = 1L;
private final String JAVA_VERSION = SystemUtil.get("java.version", false);
private final float JAVA_VERSION_FLOAT = getJavaVersionAsFloat();
private final int JAVA_VERSION_INT = getJavaVersionAsInt();
private final String JAVA_VENDOR = SystemUtil.get("java.vendor", false);
private final String JAVA_VENDOR_URL = SystemUtil.get("java.vendor.url", false);
// 1.1--1.3能否识别?
private final boolean IS_JAVA_1_1 = getJavaVersionMatches("1.1");
private final boolean IS_JAVA_1_2 = getJavaVersionMatches("1.2");
private final boolean IS_JAVA_1_3 = getJavaVersionMatches("1.3");
private final boolean IS_JAVA_1_4 = getJavaVersionMatches("1.4");
private final boolean IS_JAVA_1_5 = getJavaVersionMatches("1.5");
private final boolean IS_JAVA_1_6 = getJavaVersionMatches("1.6");
private final boolean IS_JAVA_1_7 = getJavaVersionMatches("1.7");
private final boolean IS_JAVA_1_8 = getJavaVersionMatches("1.8");
private final boolean IS_JAVA_9 = getJavaVersionMatches("9");
private final boolean IS_JAVA_10 = getJavaVersionMatches("10");
private final boolean IS_JAVA_11 = getJavaVersionMatches("11");
private final boolean IS_JAVA_12 = getJavaVersionMatches("12");
/**
* 取得当前Java impl.的版本（取自系统属性：<code>java.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"1.4.2"</code>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
* @since Java 1.1
*/
public final String getVersion() {
return JAVA_VERSION;
}
/**
* 取得当前Java impl.的版本（取自系统属性：<code>java.version</code>）。
*
* <p>
* 例如：
*
* <ul>
* <li>JDK 1.2：<code>1.2f</code>。</li>
* <li>JDK 1.3.1：<code>1.31f</code></li>
* </ul>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>0</code>。
*/
public final float getVersionFloat() {
return JAVA_VERSION_FLOAT;
}
/**
* 取得当前Java impl.的版本（取自系统属性：<code>java.version</code>），java10及其之后的版本返回值为4位。
*
* <p>
* 例如：
*
* <ul>
* <li>JDK 1.2：<code>120</code>。</li>
* <li>JDK 1.3.1：<code>131</code></li>
* <li>JDK 11.0.2：<code>1102</code></li>
* </ul>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>0</code>。
* @since Java 1.1
*/
public final int getVersionInt() {
return JAVA_VERSION_INT;
}
/**
* 取得当前Java impl.的版本的<code>float</code>值。
*
* @return Java版本的<code>float</code>值或<code>0</code>
*/
private float getJavaVersionAsFloat() {
if (JAVA_VERSION == null) {
return 0f;
}
String str = JAVA_VERSION;
str = ReUtil.get("^[0-9]{1,2}(\\.[0-9]{1,2})?", str, 0);
return Float.parseFloat(str);
}
/**
* 取得当前Java impl.的版本的<code>int</code>值。
*
* @return Java版本的<code>int</code>值或<code>0</code>
*/
private int getJavaVersionAsInt() {
if (JAVA_VERSION == null) {
return 0;
}
String javaVersion = ReUtil.get("^[0-9]{1,2}(\\.[0-9]{1,2}){0,2}", JAVA_VERSION, 0);
String[] split = javaVersion.split("\\.");
String result = ArrayUtil.join(split, "");
//保证java10及其之后的版本返回的值为4位
if (split[0].length() > 1) {
result = (result + "0000").substring(0, 4);
}
return Integer.parseInt(result);
}
/**
* 取得当前Java impl.的厂商（取自系统属性：<code>java.vendor</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Sun Microsystems Inc."</code>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
* @since Java 1.1
*/
public final String getVendor() {
return JAVA_VENDOR;
}
/**
* 取得当前Java impl.的厂商网站的URL（取自系统属性：<code>java.vendor.url</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"http://java.sun.com/"</code>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
* @since Java 1.1
*/
public final String getVendorURL() {
return JAVA_VENDOR_URL;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.1，则返回<code>true</code>
*/
public final boolean isJava1_1() {
return IS_JAVA_1_1;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.2，则返回<code>true</code>
*/
public final boolean isJava1_2() {
return IS_JAVA_1_2;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.3，则返回<code>true</code>
*/
public final boolean isJava1_3() {
return IS_JAVA_1_3;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.4，则返回<code>true</code>
*/
public final boolean isJava1_4() {
return IS_JAVA_1_4;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.5，则返回<code>true</code>
*/
public final boolean isJava1_5() {
return IS_JAVA_1_5;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.6，则返回<code>true</code>
*/
public final boolean isJava1_6() {
return IS_JAVA_1_6;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.7，则返回<code>true</code>
*/
public final boolean isJava1_7() {
return IS_JAVA_1_7;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为1.8，则返回<code>true</code>
*/
public final boolean isJava1_8() {
return IS_JAVA_1_8;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为9，则返回<code>true</code>
*/
public final boolean isJava9() {
return IS_JAVA_9;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为10，则返回<code>true</code>
*/
public final boolean isJava10() {
return IS_JAVA_10;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为11，则返回<code>true</code>
*/
public final boolean isJava11() {
return IS_JAVA_11;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性<code>java.version</code>（因为Java安全限制），则总是返回 <code>false</code>
*
* @return 如果当前Java版本为12，则返回<code>true</code>
*/
public final boolean isJava12() {
return IS_JAVA_12;
}
/**
* 匹配当前Java的版本。
*
* @param versionPrefix Java版本前缀
* @return 如果版本匹配，则返回<code>true</code>
*/
private boolean getJavaVersionMatches(String versionPrefix) {
if (JAVA_VERSION == null) {
return false;
}
return JAVA_VERSION.startsWith(versionPrefix);
}
/**
* 判定当前Java的版本是否大于等于指定的版本号。
*
* <p>
* 例如：
*
*
* <ul>
* <li>测试JDK 1.2：<code>isJavaVersionAtLeast(1.2f)</code></li>
* <li>测试JDK 1.2.1：<code>isJavaVersionAtLeast(1.31f)</code></li>
* </ul>
*
* @param requiredVersion 需要的版本
* @return 如果当前Java版本大于或等于指定的版本，则返回<code>true</code>
*/
public final boolean isJavaVersionAtLeast(float requiredVersion) {
return getVersionFloat() >= requiredVersion;
}
/**
* 判定当前Java的版本是否大于等于指定的版本号。
*
* <p>
* 例如：
*
*
* <ul>
* <li>测试JDK 1.2：<code>isJavaVersionAtLeast(120)</code></li>
* <li>测试JDK 1.2.1：<code>isJavaVersionAtLeast(131)</code></li>
* </ul>
*
* @param requiredVersion 需要的版本
* @return 如果当前Java版本大于或等于指定的版本，则返回<code>true</code>
*/
public final boolean isJavaVersionAtLeast(int requiredVersion) {
return getVersionInt() >= requiredVersion;
}
/**
* 将Java Implementation的信息转换成字符串。
*
* @return JVM impl.的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "Java Version: ", getVersion());
SystemUtil.append(builder, "Java Vendor: ", getVendor());
SystemUtil.append(builder, "Java Vendor URL: ", getVendorURL());
return builder.toString();
}
}

450
hutool-system/src/main/java/cn/hutool/system/JavaRuntimeInfo.java
View File

@@ -1,225 +1,225 @@
package cn.hutool.system;
import java.io.Serializable;
import cn.hutool.core.util.StrUtil;
/**
* 代表当前运行的JRE的信息。
*/
public class JavaRuntimeInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String JAVA_RUNTIME_NAME = SystemUtil.get("java.runtime.name", false);
private final String JAVA_RUNTIME_VERSION = SystemUtil.get("java.runtime.version", false);
private final String JAVA_HOME = SystemUtil.get("java.home", false);
private final String JAVA_EXT_DIRS = SystemUtil.get("java.ext.dirs", false);
private final String JAVA_ENDORSED_DIRS = SystemUtil.get("java.endorsed.dirs", false);
private final String JAVA_CLASS_PATH = SystemUtil.get("java.class.path", false);
private final String JAVA_CLASS_VERSION = SystemUtil.get("java.class.version", false);
private final String JAVA_LIBRARY_PATH = SystemUtil.get("java.library.path", false);
private final String SUN_BOOT_CLASS_PATH = SystemUtil.get("sun.boot.class.path", false);
private final String SUN_ARCH_DATA_MODEL = SystemUtil.get("sun.arch.data.model", false);
public final String getSunBoothClassPath() {
return SUN_BOOT_CLASS_PATH;
}
/**
* JVM is 32M <code>or</code> 64M
*
* @return 32 <code>or</code> 64
*/
public final String getSunArchDataModel() {
return SUN_ARCH_DATA_MODEL;
}
/**
* 取得当前JRE的名称（取自系统属性：<code>java.runtime.name</code>）。
*
* <p>
* 例如Sun JDK 1.4.2： <code>"Java(TM) 2 Runtime Environment, Standard Edition"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.3
*/
public final String getName() {
return JAVA_RUNTIME_NAME;
}
/**
* 取得当前JRE的版本（取自系统属性：<code>java.runtime.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"1.4.2-b28"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.3
*/
public final String getVersion() {
return JAVA_RUNTIME_VERSION;
}
/**
* 取得当前JRE的安装目录（取自系统属性：<code>java.home</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"/opt/jdk1.4.2/jre"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getHomeDir() {
return JAVA_HOME;
}
/**
* 取得当前JRE的扩展目录列表（取自系统属性：<code>java.ext.dirs</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"/opt/jdk1.4.2/jre/lib/ext:..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.3
*/
public final String getExtDirs() {
return JAVA_EXT_DIRS;
}
/**
* 取得当前JRE的endorsed目录列表（取自系统属性：<code>java.endorsed.dirs</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"/opt/jdk1.4.2/jre/lib/endorsed:..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.4
*/
public final String getEndorsedDirs() {
return JAVA_ENDORSED_DIRS;
}
/**
* 取得当前JRE的系统classpath（取自系统属性：<code>java.class.path</code>）。
*
* <p>
* 例如：<code>"/home/admin/myclasses:/home/admin/..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getClassPath() {
return JAVA_CLASS_PATH;
}
/**
* 取得当前JRE的系统classpath（取自系统属性：<code>java.class.path</code>）。
*
* <p>
* 例如：<code>"/home/admin/myclasses:/home/admin/..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String[] getClassPathArray() {
return StrUtil.split(getClassPath(), SystemUtil.get("path.separator", false));
}
/**
* 取得当前JRE的class文件格式的版本（取自系统属性：<code>java.class.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"48.0"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getClassVersion() {
return JAVA_CLASS_VERSION;
}
/**
* 取得当前JRE的library搜索路径（取自系统属性：<code>java.library.path</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"/opt/jdk1.4.2/bin:..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getLibraryPath() {
return JAVA_LIBRARY_PATH;
}
/**
* 取得当前JRE的library搜索路径（取自系统属性：<code>java.library.path</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"/opt/jdk1.4.2/bin:..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*
*/
public final String[] getLibraryPathArray() {
return StrUtil.split(getLibraryPath(), SystemUtil.get("path.separator", false));
}
/**
* 取得当前JRE的URL协议packages列表（取自系统属性：<code>java.library.path</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"sun.net.www.protocol|..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*
*/
public final String getProtocolPackages() {
return SystemUtil.get("java.protocol.handler.pkgs", true);
}
/**
* 将当前运行的JRE信息转换成字符串。
*
* @return JRE信息的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "Java Runtime Name: ", getName());
SystemUtil.append(builder, "Java Runtime Version: ", getVersion());
SystemUtil.append(builder, "Java Home Dir: ", getHomeDir());
SystemUtil.append(builder, "Java Extension Dirs: ", getExtDirs());
SystemUtil.append(builder, "Java Endorsed Dirs: ", getEndorsedDirs());
SystemUtil.append(builder, "Java Class Path: ", getClassPath());
SystemUtil.append(builder, "Java Class Version: ", getClassVersion());
SystemUtil.append(builder, "Java Library Path: ", getLibraryPath());
SystemUtil.append(builder, "Java Protocol Packages: ", getProtocolPackages());
return builder.toString();
}
}
package cn.hutool.system;
import java.io.Serializable;
import cn.hutool.core.util.StrUtil;
/**
* 代表当前运行的JRE的信息。
*/
public class JavaRuntimeInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String JAVA_RUNTIME_NAME = SystemUtil.get("java.runtime.name", false);
private final String JAVA_RUNTIME_VERSION = SystemUtil.get("java.runtime.version", false);
private final String JAVA_HOME = SystemUtil.get("java.home", false);
private final String JAVA_EXT_DIRS = SystemUtil.get("java.ext.dirs", false);
private final String JAVA_ENDORSED_DIRS = SystemUtil.get("java.endorsed.dirs", false);
private final String JAVA_CLASS_PATH = SystemUtil.get("java.class.path", false);
private final String JAVA_CLASS_VERSION = SystemUtil.get("java.class.version", false);
private final String JAVA_LIBRARY_PATH = SystemUtil.get("java.library.path", false);
private final String SUN_BOOT_CLASS_PATH = SystemUtil.get("sun.boot.class.path", false);
private final String SUN_ARCH_DATA_MODEL = SystemUtil.get("sun.arch.data.model", false);
public final String getSunBoothClassPath() {
return SUN_BOOT_CLASS_PATH;
}
/**
* JVM is 32M <code>or</code> 64M
*
* @return 32 <code>or</code> 64
*/
public final String getSunArchDataModel() {
return SUN_ARCH_DATA_MODEL;
}
/**
* 取得当前JRE的名称（取自系统属性：<code>java.runtime.name</code>）。
*
* <p>
* 例如Sun JDK 1.4.2： <code>"Java(TM) 2 Runtime Environment, Standard Edition"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.3
*/
public final String getName() {
return JAVA_RUNTIME_NAME;
}
/**
* 取得当前JRE的版本（取自系统属性：<code>java.runtime.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"1.4.2-b28"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.3
*/
public final String getVersion() {
return JAVA_RUNTIME_VERSION;
}
/**
* 取得当前JRE的安装目录（取自系统属性：<code>java.home</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"/opt/jdk1.4.2/jre"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getHomeDir() {
return JAVA_HOME;
}
/**
* 取得当前JRE的扩展目录列表（取自系统属性：<code>java.ext.dirs</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"/opt/jdk1.4.2/jre/lib/ext:..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.3
*/
public final String getExtDirs() {
return JAVA_EXT_DIRS;
}
/**
* 取得当前JRE的endorsed目录列表（取自系统属性：<code>java.endorsed.dirs</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"/opt/jdk1.4.2/jre/lib/endorsed:..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.4
*/
public final String getEndorsedDirs() {
return JAVA_ENDORSED_DIRS;
}
/**
* 取得当前JRE的系统classpath（取自系统属性：<code>java.class.path</code>）。
*
* <p>
* 例如：<code>"/home/admin/myclasses:/home/admin/..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getClassPath() {
return JAVA_CLASS_PATH;
}
/**
* 取得当前JRE的系统classpath（取自系统属性：<code>java.class.path</code>）。
*
* <p>
* 例如：<code>"/home/admin/myclasses:/home/admin/..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String[] getClassPathArray() {
return StrUtil.split(getClassPath(), SystemUtil.get("path.separator", false));
}
/**
* 取得当前JRE的class文件格式的版本（取自系统属性：<code>java.class.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"48.0"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getClassVersion() {
return JAVA_CLASS_VERSION;
}
/**
* 取得当前JRE的library搜索路径（取自系统属性：<code>java.library.path</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"/opt/jdk1.4.2/bin:..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getLibraryPath() {
return JAVA_LIBRARY_PATH;
}
/**
* 取得当前JRE的library搜索路径（取自系统属性：<code>java.library.path</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"/opt/jdk1.4.2/bin:..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*
*/
public final String[] getLibraryPathArray() {
return StrUtil.split(getLibraryPath(), SystemUtil.get("path.separator", false));
}
/**
* 取得当前JRE的URL协议packages列表（取自系统属性：<code>java.library.path</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"sun.net.www.protocol|..."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*
*/
public final String getProtocolPackages() {
return SystemUtil.get("java.protocol.handler.pkgs", true);
}
/**
* 将当前运行的JRE信息转换成字符串。
*
* @return JRE信息的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "Java Runtime Name: ", getName());
SystemUtil.append(builder, "Java Runtime Version: ", getVersion());
SystemUtil.append(builder, "Java Home Dir: ", getHomeDir());
SystemUtil.append(builder, "Java Extension Dirs: ", getExtDirs());
SystemUtil.append(builder, "Java Endorsed Dirs: ", getEndorsedDirs());
SystemUtil.append(builder, "Java Class Path: ", getClassPath());
SystemUtil.append(builder, "Java Class Version: ", getClassVersion());
SystemUtil.append(builder, "Java Library Path: ", getLibraryPath());
SystemUtil.append(builder, "Java Protocol Packages: ", getProtocolPackages());
return builder.toString();
}
}

148
hutool-system/src/main/java/cn/hutool/system/JavaSpecInfo.java
View File

@@ -1,74 +1,74 @@
package cn.hutool.system;
import java.io.Serializable;
/**
* 代表Java Specification的信息。
*/
public class JavaSpecInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String JAVA_SPECIFICATION_NAME = SystemUtil.get("java.specification.name", false);
private final String JAVA_SPECIFICATION_VERSION = SystemUtil.get("java.specification.version", false);
private final String JAVA_SPECIFICATION_VENDOR = SystemUtil.get("java.specification.vendor", false);
/**
* 取得当前Java Spec.的名称（取自系统属性：<code>java.specification.name</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Java Platform API Specification"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getName() {
return JAVA_SPECIFICATION_NAME;
}
/**
* 取得当前Java Spec.的版本（取自系统属性：<code>java.specification.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"1.4"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.3
*/
public final String getVersion() {
return JAVA_SPECIFICATION_VERSION;
}
/**
* 取得当前Java Spec.的厂商（取自系统属性：<code>java.specification.vendor</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Sun Microsystems Inc."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getVendor() {
return JAVA_SPECIFICATION_VENDOR;
}
/**
* 将Java Specification的信息转换成字符串。
*
* @return JVM spec.的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "Java Spec. Name: ", getName());
SystemUtil.append(builder, "Java Spec. Version: ", getVersion());
SystemUtil.append(builder, "Java Spec. Vendor: ", getVendor());
return builder.toString();
}
}
package cn.hutool.system;
import java.io.Serializable;
/**
* 代表Java Specification的信息。
*/
public class JavaSpecInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String JAVA_SPECIFICATION_NAME = SystemUtil.get("java.specification.name", false);
private final String JAVA_SPECIFICATION_VERSION = SystemUtil.get("java.specification.version", false);
private final String JAVA_SPECIFICATION_VENDOR = SystemUtil.get("java.specification.vendor", false);
/**
* 取得当前Java Spec.的名称（取自系统属性：<code>java.specification.name</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Java Platform API Specification"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getName() {
return JAVA_SPECIFICATION_NAME;
}
/**
* 取得当前Java Spec.的版本（取自系统属性：<code>java.specification.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"1.4"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.3
*/
public final String getVersion() {
return JAVA_SPECIFICATION_VERSION;
}
/**
* 取得当前Java Spec.的厂商（取自系统属性：<code>java.specification.vendor</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Sun Microsystems Inc."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getVendor() {
return JAVA_SPECIFICATION_VENDOR;
}
/**
* 将Java Specification的信息转换成字符串。
*
* @return JVM spec.的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "Java Spec. Name: ", getName());
SystemUtil.append(builder, "Java Spec. Version: ", getVersion());
SystemUtil.append(builder, "Java Spec. Vendor: ", getVendor());
return builder.toString();
}
}

178
hutool-system/src/main/java/cn/hutool/system/JvmInfo.java
View File

@@ -1,89 +1,89 @@
package cn.hutool.system;
import java.io.Serializable;
/**
* 代表Java Virtual Machine Implementation的信息。
*/
public class JvmInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String JAVA_VM_NAME = SystemUtil.get("java.vm.name", false);
private final String JAVA_VM_VERSION = SystemUtil.get("java.vm.version", false);
private final String JAVA_VM_VENDOR = SystemUtil.get("java.vm.vendor", false);
private final String JAVA_VM_INFO = SystemUtil.get("java.vm.info", false);
/**
* 取得当前JVM impl.的名称（取自系统属性：<code>java.vm.name</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Java HotSpot(TM) Client VM"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getName() {
return JAVA_VM_NAME;
}
/**
* 取得当前JVM impl.的版本（取自系统属性：<code>java.vm.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"1.4.2-b28"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getVersion() {
return JAVA_VM_VERSION;
}
/**
* 取得当前JVM impl.的厂商（取自系统属性：<code>java.vm.vendor</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Sun Microsystems Inc."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getVendor() {
return JAVA_VM_VENDOR;
}
/**
* 取得当前JVM impl.的信息（取自系统属性：<code>java.vm.info</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"mixed mode"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getInfo() {
return JAVA_VM_INFO;
}
/**
* 将Java Virutal Machine Implementation的信息转换成字符串。
*
* @return JVM impl.的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "JavaVM Name: ", getName());
SystemUtil.append(builder, "JavaVM Version: ", getVersion());
SystemUtil.append(builder, "JavaVM Vendor: ", getVendor());
SystemUtil.append(builder, "JavaVM Info: ", getInfo());
return builder.toString();
}
}
package cn.hutool.system;
import java.io.Serializable;
/**
* 代表Java Virtual Machine Implementation的信息。
*/
public class JvmInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String JAVA_VM_NAME = SystemUtil.get("java.vm.name", false);
private final String JAVA_VM_VERSION = SystemUtil.get("java.vm.version", false);
private final String JAVA_VM_VENDOR = SystemUtil.get("java.vm.vendor", false);
private final String JAVA_VM_INFO = SystemUtil.get("java.vm.info", false);
/**
* 取得当前JVM impl.的名称（取自系统属性：<code>java.vm.name</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Java HotSpot(TM) Client VM"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getName() {
return JAVA_VM_NAME;
}
/**
* 取得当前JVM impl.的版本（取自系统属性：<code>java.vm.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"1.4.2-b28"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getVersion() {
return JAVA_VM_VERSION;
}
/**
* 取得当前JVM impl.的厂商（取自系统属性：<code>java.vm.vendor</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Sun Microsystems Inc."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getVendor() {
return JAVA_VM_VENDOR;
}
/**
* 取得当前JVM impl.的信息（取自系统属性：<code>java.vm.info</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"mixed mode"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getInfo() {
return JAVA_VM_INFO;
}
/**
* 将Java Virutal Machine Implementation的信息转换成字符串。
*
* @return JVM impl.的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "JavaVM Name: ", getName());
SystemUtil.append(builder, "JavaVM Version: ", getVersion());
SystemUtil.append(builder, "JavaVM Vendor: ", getVendor());
SystemUtil.append(builder, "JavaVM Info: ", getInfo());
return builder.toString();
}
}

146
hutool-system/src/main/java/cn/hutool/system/JvmSpecInfo.java
View File

@@ -1,73 +1,73 @@
package cn.hutool.system;
import java.io.Serializable;
/**
* 代表Java Virutal Machine Specification的信息。
*/
public class JvmSpecInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String JAVA_VM_SPECIFICATION_NAME = SystemUtil.get("java.vm.specification.name", false);
private final String JAVA_VM_SPECIFICATION_VERSION = SystemUtil.get("java.vm.specification.version", false);
private final String JAVA_VM_SPECIFICATION_VENDOR = SystemUtil.get("java.vm.specification.vendor", false);
/**
* 取得当前JVM spec.的名称（取自系统属性：<code>java.vm.specification.name</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Java Virtual Machine Specification"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getName() {
return JAVA_VM_SPECIFICATION_NAME;
}
/**
* 取得当前JVM spec.的版本（取自系统属性：<code>java.vm.specification.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"1.0"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getVersion() {
return JAVA_VM_SPECIFICATION_VERSION;
}
/**
* 取得当前JVM spec.的厂商（取自系统属性：<code>java.vm.specification.vendor</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Sun Microsystems Inc."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getVendor() {
return JAVA_VM_SPECIFICATION_VENDOR;
}
/**
* 将Java Virutal Machine Specification的信息转换成字符串。
*
* @return JVM spec.的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "JavaVM Spec. Name: ", getName());
SystemUtil.append(builder, "JavaVM Spec. Version: ", getVersion());
SystemUtil.append(builder, "JavaVM Spec. Vendor: ", getVendor());
return builder.toString();
}
}
package cn.hutool.system;
import java.io.Serializable;
/**
* 代表Java Virutal Machine Specification的信息。
*/
public class JvmSpecInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String JAVA_VM_SPECIFICATION_NAME = SystemUtil.get("java.vm.specification.name", false);
private final String JAVA_VM_SPECIFICATION_VERSION = SystemUtil.get("java.vm.specification.version", false);
private final String JAVA_VM_SPECIFICATION_VENDOR = SystemUtil.get("java.vm.specification.vendor", false);
/**
* 取得当前JVM spec.的名称（取自系统属性：<code>java.vm.specification.name</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Java Virtual Machine Specification"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getName() {
return JAVA_VM_SPECIFICATION_NAME;
}
/**
* 取得当前JVM spec.的版本（取自系统属性：<code>java.vm.specification.version</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"1.0"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getVersion() {
return JAVA_VM_SPECIFICATION_VERSION;
}
/**
* 取得当前JVM spec.的厂商（取自系统属性：<code>java.vm.specification.vendor</code>）。
*
* <p>
* 例如Sun JDK 1.4.2：<code>"Sun Microsystems Inc."</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getVendor() {
return JAVA_VM_SPECIFICATION_VENDOR;
}
/**
* 将Java Virutal Machine Specification的信息转换成字符串。
*
* @return JVM spec.的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "JavaVM Spec. Name: ", getName());
SystemUtil.append(builder, "JavaVM Spec. Version: ", getVersion());
SystemUtil.append(builder, "JavaVM Spec. Vendor: ", getVendor());
return builder.toString();
}
}

882
hutool-system/src/main/java/cn/hutool/system/OsInfo.java
View File

@@ -1,441 +1,441 @@
package cn.hutool.system;
import java.io.Serializable;
/**
* 代表当前OS的信息。
*/
public class OsInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String OS_VERSION = SystemUtil.get("os.version", false);
private final String OS_ARCH = SystemUtil.get("os.arch", false);
private final String OS_NAME = SystemUtil.get("os.name", false);
private final boolean IS_OS_AIX = getOSMatches("AIX");
private final boolean IS_OS_HP_UX = getOSMatches("HP-UX");
private final boolean IS_OS_IRIX = getOSMatches("Irix");
private final boolean IS_OS_LINUX = getOSMatches("Linux") || getOSMatches("LINUX");
private final boolean IS_OS_MAC = getOSMatches("Mac");
private final boolean IS_OS_MAC_OSX = getOSMatches("Mac OS X");
private final boolean IS_OS_OS2 = getOSMatches("OS/2");
private final boolean IS_OS_SOLARIS = getOSMatches("Solaris");
private final boolean IS_OS_SUN_OS = getOSMatches("SunOS");
private final boolean IS_OS_WINDOWS = getOSMatches("Windows");
private final boolean IS_OS_WINDOWS_2000 = getOSMatches("Windows", "5.0");
private final boolean IS_OS_WINDOWS_95 = getOSMatches("Windows 9", "4.0");
private final boolean IS_OS_WINDOWS_98 = getOSMatches("Windows 9", "4.1");
private final boolean IS_OS_WINDOWS_ME = getOSMatches("Windows", "4.9");
private final boolean IS_OS_WINDOWS_NT = getOSMatches("Windows NT");
private final boolean IS_OS_WINDOWS_XP = getOSMatches("Windows", "5.1");
private final boolean IS_OS_WINDOWS_7 = getOSMatches("Windows", "6.1");
private final boolean IS_OS_WINDOWS_8 = getOSMatches("Windows", "6.2");
private final boolean IS_OS_WINDOWS_8_1 = getOSMatches("Windows", "6.3");
private final boolean IS_OS_WINDOWS_10 = getOSMatches("Windows", "10.0");
// 由于改变file.encoding属性并不会改变系统字符编码，为了保持一致，通过LocaleUtil取系统默认编码。
private final String FILE_SEPARATOR = SystemUtil.get("file.separator", false);
private final String LINE_SEPARATOR = SystemUtil.get("line.separator", false);
private final String PATH_SEPARATOR = SystemUtil.get("path.separator", false);
/**
* 取得当前OS的架构（取自系统属性：<code>os.arch</code>）。
*
* <p>
* 例如：<code>"x86"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getArch() {
return OS_ARCH;
}
/**
* 取得当前OS的名称（取自系统属性：<code>os.name</code>）。
*
* <p>
* 例如：<code>"Windows XP"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getName() {
return OS_NAME;
}
/**
* 取得当前OS的版本（取自系统属性：<code>os.version</code>）。
*
* <p>
* 例如：<code>"5.1"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getVersion() {
return OS_VERSION;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为AIX，则返回<code>true</code>
*/
public final boolean isAix() {
return IS_OS_AIX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为HP-UX，则返回<code>true</code>
*/
public final boolean isHpUx() {
return IS_OS_HP_UX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为IRIX，则返回<code>true</code>
*/
public final boolean isIrix() {
return IS_OS_IRIX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Linux，则返回<code>true</code>
*/
public final boolean isLinux() {
return IS_OS_LINUX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Mac，则返回<code>true</code>
*/
public final boolean isMac() {
return IS_OS_MAC;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为MacOS X，则返回<code>true</code>
*/
public final boolean isMacOsX() {
return IS_OS_MAC_OSX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为OS2，则返回<code>true</code>
*/
public final boolean isOs2() {
return IS_OS_OS2;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Solaris，则返回<code>true</code>
*/
public final boolean isSolaris() {
return IS_OS_SOLARIS;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Sun OS，则返回<code>true</code>
*/
public final boolean isSunOS() {
return IS_OS_SUN_OS;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows，则返回<code>true</code>
*/
public final boolean isWindows() {
return IS_OS_WINDOWS;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 2000，则返回<code>true</code>
*/
public final boolean isWindows2000() {
return IS_OS_WINDOWS_2000;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 95，则返回<code>true</code>
*/
public final boolean isWindows95() {
return IS_OS_WINDOWS_95;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 98，则返回<code>true</code>
*/
public final boolean isWindows98() {
return IS_OS_WINDOWS_98;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows ME，则返回<code>true</code>
*/
public final boolean isWindowsME() {
return IS_OS_WINDOWS_ME;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows NT，则返回<code>true</code>
*/
public final boolean isWindowsNT() {
return IS_OS_WINDOWS_NT;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows XP，则返回<code>true</code>
*/
public final boolean isWindowsXP() {
return IS_OS_WINDOWS_XP;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 7，则返回<code>true</code>
*/
public final boolean isWindows7() {
return IS_OS_WINDOWS_7;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 8，则返回<code>true</code>
*/
public final boolean isWindoows8() {
return IS_OS_WINDOWS_8;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 8.1，则返回<code>true</code>
*/
public final boolean isWindows8_1() {
return IS_OS_WINDOWS_8_1;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 10，则返回<code>true</code>
*/
public final boolean isWindows10() {
return IS_OS_WINDOWS_10;
}
/**
* 匹配OS名称。
*
* @param osNamePrefix OS名称前缀
*
* @return 如果匹配，则返回<code>true</code>
*/
private boolean getOSMatches(String osNamePrefix) {
if (OS_NAME == null) {
return false;
}
return OS_NAME.startsWith(osNamePrefix);
}
/**
* 匹配OS名称。
*
* @param osNamePrefix OS名称前缀
* @param osVersionPrefix OS版本前缀
*
* @return 如果匹配，则返回<code>true</code>
*/
private boolean getOSMatches(String osNamePrefix, String osVersionPrefix) {
if ((OS_NAME == null) || (OS_VERSION == null)) {
return false;
}
return OS_NAME.startsWith(osNamePrefix) && OS_VERSION.startsWith(osVersionPrefix);
}
/**
* 取得OS的文件路径的分隔符（取自系统属性：<code>file.separator</code>）。
*
* <p>
* 例如：Unix为<code>"/"</code>，Windows为<code>"\\"</code>。
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getFileSeparator() {
return FILE_SEPARATOR;
}
/**
* 取得OS的文本文件换行符（取自系统属性：<code>line.separator</code>）。
*
* <p>
* 例如：Unix为<code>"\n"</code>，Windows为<code>"\r\n"</code>。
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getLineSeparator() {
return LINE_SEPARATOR;
}
/**
* 取得OS的搜索路径分隔符（取自系统属性：<code>path.separator</code>）。
*
* <p>
* 例如：Unix为<code>":"</code>，Windows为<code>";"</code>。
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getPathSeparator() {
return PATH_SEPARATOR;
}
/**
* 将OS的信息转换成字符串。
*
* @return OS的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "OS Arch: ", getArch());
SystemUtil.append(builder, "OS Name: ", getName());
SystemUtil.append(builder, "OS Version: ", getVersion());
SystemUtil.append(builder, "File Separator: ", getFileSeparator());
SystemUtil.append(builder, "Line Separator: ", getLineSeparator());
SystemUtil.append(builder, "Path Separator: ", getPathSeparator());
return builder.toString();
}
}
package cn.hutool.system;
import java.io.Serializable;
/**
* 代表当前OS的信息。
*/
public class OsInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String OS_VERSION = SystemUtil.get("os.version", false);
private final String OS_ARCH = SystemUtil.get("os.arch", false);
private final String OS_NAME = SystemUtil.get("os.name", false);
private final boolean IS_OS_AIX = getOSMatches("AIX");
private final boolean IS_OS_HP_UX = getOSMatches("HP-UX");
private final boolean IS_OS_IRIX = getOSMatches("Irix");
private final boolean IS_OS_LINUX = getOSMatches("Linux") || getOSMatches("LINUX");
private final boolean IS_OS_MAC = getOSMatches("Mac");
private final boolean IS_OS_MAC_OSX = getOSMatches("Mac OS X");
private final boolean IS_OS_OS2 = getOSMatches("OS/2");
private final boolean IS_OS_SOLARIS = getOSMatches("Solaris");
private final boolean IS_OS_SUN_OS = getOSMatches("SunOS");
private final boolean IS_OS_WINDOWS = getOSMatches("Windows");
private final boolean IS_OS_WINDOWS_2000 = getOSMatches("Windows", "5.0");
private final boolean IS_OS_WINDOWS_95 = getOSMatches("Windows 9", "4.0");
private final boolean IS_OS_WINDOWS_98 = getOSMatches("Windows 9", "4.1");
private final boolean IS_OS_WINDOWS_ME = getOSMatches("Windows", "4.9");
private final boolean IS_OS_WINDOWS_NT = getOSMatches("Windows NT");
private final boolean IS_OS_WINDOWS_XP = getOSMatches("Windows", "5.1");
private final boolean IS_OS_WINDOWS_7 = getOSMatches("Windows", "6.1");
private final boolean IS_OS_WINDOWS_8 = getOSMatches("Windows", "6.2");
private final boolean IS_OS_WINDOWS_8_1 = getOSMatches("Windows", "6.3");
private final boolean IS_OS_WINDOWS_10 = getOSMatches("Windows", "10.0");
// 由于改变file.encoding属性并不会改变系统字符编码，为了保持一致，通过LocaleUtil取系统默认编码。
private final String FILE_SEPARATOR = SystemUtil.get("file.separator", false);
private final String LINE_SEPARATOR = SystemUtil.get("line.separator", false);
private final String PATH_SEPARATOR = SystemUtil.get("path.separator", false);
/**
* 取得当前OS的架构（取自系统属性：<code>os.arch</code>）。
*
* <p>
* 例如：<code>"x86"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getArch() {
return OS_ARCH;
}
/**
* 取得当前OS的名称（取自系统属性：<code>os.name</code>）。
*
* <p>
* 例如：<code>"Windows XP"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getName() {
return OS_NAME;
}
/**
* 取得当前OS的版本（取自系统属性：<code>os.version</code>）。
*
* <p>
* 例如：<code>"5.1"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getVersion() {
return OS_VERSION;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为AIX，则返回<code>true</code>
*/
public final boolean isAix() {
return IS_OS_AIX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为HP-UX，则返回<code>true</code>
*/
public final boolean isHpUx() {
return IS_OS_HP_UX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为IRIX，则返回<code>true</code>
*/
public final boolean isIrix() {
return IS_OS_IRIX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Linux，则返回<code>true</code>
*/
public final boolean isLinux() {
return IS_OS_LINUX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Mac，则返回<code>true</code>
*/
public final boolean isMac() {
return IS_OS_MAC;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为MacOS X，则返回<code>true</code>
*/
public final boolean isMacOsX() {
return IS_OS_MAC_OSX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为OS2，则返回<code>true</code>
*/
public final boolean isOs2() {
return IS_OS_OS2;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Solaris，则返回<code>true</code>
*/
public final boolean isSolaris() {
return IS_OS_SOLARIS;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Sun OS，则返回<code>true</code>
*/
public final boolean isSunOS() {
return IS_OS_SUN_OS;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows，则返回<code>true</code>
*/
public final boolean isWindows() {
return IS_OS_WINDOWS;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 2000，则返回<code>true</code>
*/
public final boolean isWindows2000() {
return IS_OS_WINDOWS_2000;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 95，则返回<code>true</code>
*/
public final boolean isWindows95() {
return IS_OS_WINDOWS_95;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 98，则返回<code>true</code>
*/
public final boolean isWindows98() {
return IS_OS_WINDOWS_98;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows ME，则返回<code>true</code>
*/
public final boolean isWindowsME() {
return IS_OS_WINDOWS_ME;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows NT，则返回<code>true</code>
*/
public final boolean isWindowsNT() {
return IS_OS_WINDOWS_NT;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows XP，则返回<code>true</code>
*/
public final boolean isWindowsXP() {
return IS_OS_WINDOWS_XP;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 7，则返回<code>true</code>
*/
public final boolean isWindows7() {
return IS_OS_WINDOWS_7;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 8，则返回<code>true</code>
*/
public final boolean isWindoows8() {
return IS_OS_WINDOWS_8;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 8.1，则返回<code>true</code>
*/
public final boolean isWindows8_1() {
return IS_OS_WINDOWS_8_1;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性<code>os.name</code>（因为Java安全限制），则总是返回<code>false</code>
* </p>
*
* @return 如果当前OS类型为Windows 10，则返回<code>true</code>
*/
public final boolean isWindows10() {
return IS_OS_WINDOWS_10;
}
/**
* 匹配OS名称。
*
* @param osNamePrefix OS名称前缀
*
* @return 如果匹配，则返回<code>true</code>
*/
private boolean getOSMatches(String osNamePrefix) {
if (OS_NAME == null) {
return false;
}
return OS_NAME.startsWith(osNamePrefix);
}
/**
* 匹配OS名称。
*
* @param osNamePrefix OS名称前缀
* @param osVersionPrefix OS版本前缀
*
* @return 如果匹配，则返回<code>true</code>
*/
private boolean getOSMatches(String osNamePrefix, String osVersionPrefix) {
if ((OS_NAME == null) || (OS_VERSION == null)) {
return false;
}
return OS_NAME.startsWith(osNamePrefix) && OS_VERSION.startsWith(osVersionPrefix);
}
/**
* 取得OS的文件路径的分隔符（取自系统属性：<code>file.separator</code>）。
*
* <p>
* 例如：Unix为<code>"/"</code>，Windows为<code>"\\"</code>。
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getFileSeparator() {
return FILE_SEPARATOR;
}
/**
* 取得OS的文本文件换行符（取自系统属性：<code>line.separator</code>）。
*
* <p>
* 例如：Unix为<code>"\n"</code>，Windows为<code>"\r\n"</code>。
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getLineSeparator() {
return LINE_SEPARATOR;
}
/**
* 取得OS的搜索路径分隔符（取自系统属性：<code>path.separator</code>）。
*
* <p>
* 例如：Unix为<code>":"</code>，Windows为<code>";"</code>。
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getPathSeparator() {
return PATH_SEPARATOR;
}
/**
* 将OS的信息转换成字符串。
*
* @return OS的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "OS Arch: ", getArch());
SystemUtil.append(builder, "OS Name: ", getName());
SystemUtil.append(builder, "OS Version: ", getVersion());
SystemUtil.append(builder, "File Separator: ", getFileSeparator());
SystemUtil.append(builder, "Line Separator: ", getLineSeparator());
SystemUtil.append(builder, "Path Separator: ", getPathSeparator());
return builder.toString();
}
}

146
hutool-system/src/main/java/cn/hutool/system/RuntimeInfo.java
View File

@@ -1,73 +1,73 @@
package cn.hutool.system;
import cn.hutool.core.io.FileUtil;
import java.io.Serializable;
/**
* 运行时信息，包括内存总大小、已用大小、可用大小等
*
* @author looly
*/
public class RuntimeInfo implements Serializable {
private static final long serialVersionUID = 1L;
private final Runtime currentRuntime = Runtime.getRuntime();
/**
* 获得运行时对象
*
* @return {@link Runtime}
*/
public final Runtime getRuntime() {
return currentRuntime;
}
/**
* 获得JVM最大内存
*
* @return 最大内存
*/
public final long getMaxMemory() {
return currentRuntime.maxMemory();
}
/**
* 获得JVM已分配内存
*
* @return 已分配内存
*/
public final long getTotalMemory() {
return currentRuntime.totalMemory();
}
/**
* 获得JVM已分配内存中的剩余空间
*
* @return 已分配内存中的剩余空间
*/
public final long getFreeMemory() {
return currentRuntime.freeMemory();
}
/**
* 获得JVM最大可用内存
*
* @return 最大可用内存
*/
public final long getUsableMemory() {
return currentRuntime.maxMemory() - currentRuntime.totalMemory() + currentRuntime.freeMemory();
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "Max Memory: ", FileUtil.readableFileSize(getMaxMemory()));
SystemUtil.append(builder, "Total Memory: ", FileUtil.readableFileSize(getTotalMemory()));
SystemUtil.append(builder, "Free Memory: ", FileUtil.readableFileSize(getFreeMemory()));
SystemUtil.append(builder, "Usable Memory: ", FileUtil.readableFileSize(getUsableMemory()));
return builder.toString();
}
}
package cn.hutool.system;
import cn.hutool.core.io.FileUtil;
import java.io.Serializable;
/**
* 运行时信息，包括内存总大小、已用大小、可用大小等
*
* @author looly
*/
public class RuntimeInfo implements Serializable {
private static final long serialVersionUID = 1L;
private final Runtime currentRuntime = Runtime.getRuntime();
/**
* 获得运行时对象
*
* @return {@link Runtime}
*/
public final Runtime getRuntime() {
return currentRuntime;
}
/**
* 获得JVM最大内存
*
* @return 最大内存
*/
public final long getMaxMemory() {
return currentRuntime.maxMemory();
}
/**
* 获得JVM已分配内存
*
* @return 已分配内存
*/
public final long getTotalMemory() {
return currentRuntime.totalMemory();
}
/**
* 获得JVM已分配内存中的剩余空间
*
* @return 已分配内存中的剩余空间
*/
public final long getFreeMemory() {
return currentRuntime.freeMemory();
}
/**
* 获得JVM最大可用内存
*
* @return 最大可用内存
*/
public final long getUsableMemory() {
return currentRuntime.maxMemory() - currentRuntime.totalMemory() + currentRuntime.freeMemory();
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "Max Memory: ", FileUtil.readableFileSize(getMaxMemory()));
SystemUtil.append(builder, "Total Memory: ", FileUtil.readableFileSize(getTotalMemory()));
SystemUtil.append(builder, "Free Memory: ", FileUtil.readableFileSize(getFreeMemory()));
SystemUtil.append(builder, "Usable Memory: ", FileUtil.readableFileSize(getUsableMemory()));
return builder.toString();
}
}

272
hutool-system/src/main/java/cn/hutool/system/SystemPropsKeys.java
View File

@@ -1,136 +1,136 @@
package cn.hutool.system;
/**
* 系统属性名称常量池
*
* <p>
* 封装了包括Java运行时环境信息、Java虚拟机信息、Java类信息、OS信息、用户信息等<br>
*
*
* @author Looly
* @since 4.6.7
*/
public interface SystemPropsKeys {
// ----- Java运行时环境信息 -----/
/**
* Java 运行时环境规范名称
*/
String SPECIFICATION_NAME = "java.specification.name";
/**
* Java 运行时环境版本
*/
String VERSION = "java.version";
/**
* Java 运行时环境规范版本
*/
String SPECIFICATION_VERSION = "java.specification.version";
/**
* Java 运行时环境供应商
*/
String VENDOR = "java.vendor";
/**
* Java 运行时环境规范供应商
*/
String SPECIFICATION_VENDOR = "java.specification.vendor";
/**
* Java 供应商的 URL
*/
String VENDOR_URL = "java.vendor.url";
/**
* Java 安装目录
*/
String HOME = "java.home";
/**
* 加载库时搜索的路径列表
*/
String LIBRARY_PATH = "java.library.path";
/**
* 默认的临时文件路径
*/
String TMPDIR = "java.io.tmpdir";
/**
* 要使用的 JIT 编译器的名称
*/
String COMPILER = "java.compiler";
/**
* 一个或多个扩展目录的路径
*/
String EXT_DIRS = "java.ext.dirs";
// ----- Java虚拟机信息 -----/
/**
* Java 虚拟机实现名称
*/
String VM_NAME = "java.vm.name";
/**
* Java 虚拟机规范名称
*/
String VM_SPECIFICATION_NAME = "java.vm.specification.name";
/**
* Java 虚拟机实现版本
*/
String VM_VERSION = "java.vm.version";
/**
* Java 虚拟机规范版本
*/
String VM_SPECIFICATION_VERSION = "java.vm.specification.version";
/**
* Java 虚拟机实现供应商
*/
String VM_VENDOR = "java.vm.vendor";
/**
* Java 虚拟机规范供应商
*/
String VM_SPECIFICATION_VENDOR = "java.vm.specification.vendor";
// ----- Java类信息 -----/
/**
* Java 类格式版本号
*/
String CLASS_VERSION = "java.class.version";
/**
* Java 类路径
*/
String CLASS_PATH = "java.class.path";
// ----- OS信息 -----/
/**
* 操作系统的名称
*/
String OS_NAME = "os.name";
/**
* 操作系统的架构
*/
String OS_ARCH = "os.arch";
/**
* 操作系统的版本
*/
String OS_VERSION = "os.version";
/**
* 文件分隔符（在 UNIX 系统中是“/”）
*/
String FILE_SEPARATOR = "file.separator";
/**
* 路径分隔符（在 UNIX 系统中是“:”）
*/
String PATH_SEPARATOR = "path.separator";
/**
* 行分隔符（在 UNIX 系统中是“\n”）
*/
String LINE_SEPARATOR = "line.separator";
// ----- 用户信息 -----/
/**
* 用户的账户名称
*/
String USER_NAME = "user.name";
/**
* 用户的主目录
*/
String USER_HOME = "user.home";
/**
* 用户的当前工作目录
*/
String USER_DIR = "user.dir";
}
package cn.hutool.system;
/**
* 系统属性名称常量池
*
* <p>
* 封装了包括Java运行时环境信息、Java虚拟机信息、Java类信息、OS信息、用户信息等<br>
*
*
* @author Looly
* @since 4.6.7
*/
public interface SystemPropsKeys {
// ----- Java运行时环境信息 -----/
/**
* Java 运行时环境规范名称
*/
String SPECIFICATION_NAME = "java.specification.name";
/**
* Java 运行时环境版本
*/
String VERSION = "java.version";
/**
* Java 运行时环境规范版本
*/
String SPECIFICATION_VERSION = "java.specification.version";
/**
* Java 运行时环境供应商
*/
String VENDOR = "java.vendor";
/**
* Java 运行时环境规范供应商
*/
String SPECIFICATION_VENDOR = "java.specification.vendor";
/**
* Java 供应商的 URL
*/
String VENDOR_URL = "java.vendor.url";
/**
* Java 安装目录
*/
String HOME = "java.home";
/**
* 加载库时搜索的路径列表
*/
String LIBRARY_PATH = "java.library.path";
/**
* 默认的临时文件路径
*/
String TMPDIR = "java.io.tmpdir";
/**
* 要使用的 JIT 编译器的名称
*/
String COMPILER = "java.compiler";
/**
* 一个或多个扩展目录的路径
*/
String EXT_DIRS = "java.ext.dirs";
// ----- Java虚拟机信息 -----/
/**
* Java 虚拟机实现名称
*/
String VM_NAME = "java.vm.name";
/**
* Java 虚拟机规范名称
*/
String VM_SPECIFICATION_NAME = "java.vm.specification.name";
/**
* Java 虚拟机实现版本
*/
String VM_VERSION = "java.vm.version";
/**
* Java 虚拟机规范版本
*/
String VM_SPECIFICATION_VERSION = "java.vm.specification.version";
/**
* Java 虚拟机实现供应商
*/
String VM_VENDOR = "java.vm.vendor";
/**
* Java 虚拟机规范供应商
*/
String VM_SPECIFICATION_VENDOR = "java.vm.specification.vendor";
// ----- Java类信息 -----/
/**
* Java 类格式版本号
*/
String CLASS_VERSION = "java.class.version";
/**
* Java 类路径
*/
String CLASS_PATH = "java.class.path";
// ----- OS信息 -----/
/**
* 操作系统的名称
*/
String OS_NAME = "os.name";
/**
* 操作系统的架构
*/
String OS_ARCH = "os.arch";
/**
* 操作系统的版本
*/
String OS_VERSION = "os.version";
/**
* 文件分隔符（在 UNIX 系统中是“/”）
*/
String FILE_SEPARATOR = "file.separator";
/**
* 路径分隔符（在 UNIX 系统中是“:”）
*/
String PATH_SEPARATOR = "path.separator";
/**
* 行分隔符（在 UNIX 系统中是“\n”）
*/
String LINE_SEPARATOR = "line.separator";
// ----- 用户信息 -----/
/**
* 用户的账户名称
*/
String USER_NAME = "user.name";
/**
* 用户的主目录
*/
String USER_HOME = "user.home";
/**
* 用户的当前工作目录
*/
String USER_DIR = "user.dir";
}

1068
hutool-system/src/main/java/cn/hutool/system/SystemUtil.java
View File

File diff suppressed because it is too large Load Diff

250
hutool-system/src/main/java/cn/hutool/system/UserInfo.java
View File

@@ -1,125 +1,125 @@
package cn.hutool.system;
import java.io.Serializable;
/**
* 代表当前用户的信息。
*/
public class UserInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String USER_NAME = SystemUtil.get("user.name", false);
private final String USER_HOME = SystemUtil.get("user.home", false);
private final String USER_DIR = SystemUtil.get("user.dir", false);
private final String USER_LANGUAGE = SystemUtil.get("user.language", false);
private final String USER_COUNTRY = ((SystemUtil.get("user.country", false) == null) ? SystemUtil.get("user.region", false) : SystemUtil.get("user.country", false));
private final String JAVA_IO_TMPDIR = SystemUtil.get("java.io.tmpdir", false);
/**
* 取得当前登录用户的名字（取自系统属性：<code>user.name</code>）。
*
* <p>
* 例如：<code>"admin"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getName() {
return USER_NAME;
}
/**
* 取得当前登录用户的home目录（取自系统属性：<code>user.home</code>）。
*
* <p>
* 例如：<code>"/home/admin"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getHomeDir() {
return USER_HOME;
}
/**
* 取得当前目录（取自系统属性：<code>user.dir</code>）。
*
* <p>
* 例如：<code>"/home/admin/working"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getCurrentDir() {
return USER_DIR;
}
/**
* 取得临时目录（取自系统属性：<code>java.io.tmpdir</code>）。
*
* <p>
* 例如：<code>"/tmp"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*
*/
public final String getTempDir() {
return JAVA_IO_TMPDIR;
}
/**
* 取得当前登录用户的语言设置（取自系统属性：<code>user.language</code>）。
*
* <p>
* 例如：<code>"zh"</code>、<code>"en"</code>等
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getLanguage() {
return USER_LANGUAGE;
}
/**
* 取得当前登录用户的国家或区域设置（取自系统属性：JDK1.4 <code>user.country</code>或JDK1.2 <code>user.region</code>）。
*
* <p>
* 例如：<code>"CN"</code>、<code>"US"</code>等
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getCountry() {
return USER_COUNTRY;
}
/**
* 将当前用户的信息转换成字符串。
*
* @return 用户信息的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "User Name: ", getName());
SystemUtil.append(builder, "User Home Dir: ", getHomeDir());
SystemUtil.append(builder, "User Current Dir: ", getCurrentDir());
SystemUtil.append(builder, "User Temp Dir: ", getTempDir());
SystemUtil.append(builder, "User Language: ", getLanguage());
SystemUtil.append(builder, "User Country: ", getCountry());
return builder.toString();
}
}
package cn.hutool.system;
import java.io.Serializable;
/**
* 代表当前用户的信息。
*/
public class UserInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String USER_NAME = SystemUtil.get("user.name", false);
private final String USER_HOME = SystemUtil.get("user.home", false);
private final String USER_DIR = SystemUtil.get("user.dir", false);
private final String USER_LANGUAGE = SystemUtil.get("user.language", false);
private final String USER_COUNTRY = ((SystemUtil.get("user.country", false) == null) ? SystemUtil.get("user.region", false) : SystemUtil.get("user.country", false));
private final String JAVA_IO_TMPDIR = SystemUtil.get("java.io.tmpdir", false);
/**
* 取得当前登录用户的名字（取自系统属性：<code>user.name</code>）。
*
* <p>
* 例如：<code>"admin"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getName() {
return USER_NAME;
}
/**
* 取得当前登录用户的home目录（取自系统属性：<code>user.home</code>）。
*
* <p>
* 例如：<code>"/home/admin"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getHomeDir() {
return USER_HOME;
}
/**
* 取得当前目录（取自系统属性：<code>user.dir</code>）。
*
* <p>
* 例如：<code>"/home/admin/working"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
* @since Java 1.1
*/
public final String getCurrentDir() {
return USER_DIR;
}
/**
* 取得临时目录（取自系统属性：<code>java.io.tmpdir</code>）。
*
* <p>
* 例如：<code>"/tmp"</code>
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*
*/
public final String getTempDir() {
return JAVA_IO_TMPDIR;
}
/**
* 取得当前登录用户的语言设置（取自系统属性：<code>user.language</code>）。
*
* <p>
* 例如：<code>"zh"</code>、<code>"en"</code>等
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getLanguage() {
return USER_LANGUAGE;
}
/**
* 取得当前登录用户的国家或区域设置（取自系统属性：JDK1.4 <code>user.country</code>或JDK1.2 <code>user.region</code>）。
*
* <p>
* 例如：<code>"CN"</code>、<code>"US"</code>等
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回<code>null</code>。
*
*/
public final String getCountry() {
return USER_COUNTRY;
}
/**
* 将当前用户的信息转换成字符串。
*
* @return 用户信息的字符串表示
*/
@Override
public final String toString() {
StringBuilder builder = new StringBuilder();
SystemUtil.append(builder, "User Name: ", getName());
SystemUtil.append(builder, "User Home Dir: ", getHomeDir());
SystemUtil.append(builder, "User Current Dir: ", getCurrentDir());
SystemUtil.append(builder, "User Temp Dir: ", getTempDir());
SystemUtil.append(builder, "User Language: ", getLanguage());
SystemUtil.append(builder, "User Country: ", getCountry());
return builder.toString();
}
}

258
hutool-system/src/main/java/cn/hutool/system/oshi/CpuInfo.java
View File

@@ -1,130 +1,130 @@
package cn.hutool.system.oshi;
import java.text.DecimalFormat;
/**
* <p>CPU相关信息</p>
*
* @author Dai Yuanchuan
**/
public class CpuInfo {
/**
* cpu核心数
*/
private Integer cpuNum;
/**
* CPU总的使用率
*/
private double toTal;
/**
* CPU系统使用率
*/
private double sys;
/**
* CPU用户使用率
*/
private double used;
/**
* CPU当前等待率
*/
private double wait;
/**
* CPU当前空闲率
*/
private double free;
/**
* CPU型号信息
*/
private String cpuModel;
public CpuInfo() {
}
public CpuInfo(Integer cpuNum, double toTal, double sys, double used, double wait, double free, String cpuModel) {
this.cpuNum = cpuNum;
this.toTal = toTal;
this.sys = sys;
this.used = used;
this.wait = wait;
this.free = free;
this.cpuModel = cpuModel;
}
public Integer getCpuNum() {
return cpuNum;
}
public void setCpuNum(Integer cpuNum) {
this.cpuNum = cpuNum;
}
public double getToTal() {
return toTal;
}
public void setToTal(double toTal) {
this.toTal = toTal;
}
public double getSys() {
return sys;
}
public void setSys(double sys) {
this.sys = sys;
}
public double getUsed() {
return used;
}
public void setUsed(double used) {
this.used = used;
}
public double getWait() {
return wait;
}
public void setWait(double wait) {
this.wait = wait;
}
public double getFree() {
return free;
}
public void setFree(double free) {
this.free = free;
}
public String getCpuModel() {
return cpuModel;
}
public void setCpuModel(String cpuModel) {
this.cpuModel = cpuModel;
}
@Override
public String toString() {
DecimalFormat format = new DecimalFormat("#.00");
return "CpuInfo{" +
"cpu核心数=" + cpuNum +
", CPU总的使用率=" + toTal +
", CPU系统使用率=" + sys +
", CPU用户使用率=" + used +
", CPU当前等待率=" + wait +
", CPU当前空闲率=" + free +
", CPU利用率=" + Double.parseDouble(format.format((100 - getFree()))) +
", CPU型号信息='" + cpuModel + '\'' +
'}';
}
package cn.hutool.system.oshi;
import java.text.DecimalFormat;
/**
* <p>CPU相关信息</p>
*
* @author Dai Yuanchuan
**/
public class CpuInfo {
/**
* cpu核心数
*/
private Integer cpuNum;
/**
* CPU总的使用率
*/
private double toTal;
/**
* CPU系统使用率
*/
private double sys;
/**
* CPU用户使用率
*/
private double used;
/**
* CPU当前等待率
*/
private double wait;
/**
* CPU当前空闲率
*/
private double free;
/**
* CPU型号信息
*/
private String cpuModel;
public CpuInfo() {
}
public CpuInfo(Integer cpuNum, double toTal, double sys, double used, double wait, double free, String cpuModel) {
this.cpuNum = cpuNum;
this.toTal = toTal;
this.sys = sys;
this.used = used;
this.wait = wait;
this.free = free;
this.cpuModel = cpuModel;
}
public Integer getCpuNum() {
return cpuNum;
}
public void setCpuNum(Integer cpuNum) {
this.cpuNum = cpuNum;
}
public double getToTal() {
return toTal;
}
public void setToTal(double toTal) {
this.toTal = toTal;
}
public double getSys() {
return sys;
}
public void setSys(double sys) {
this.sys = sys;
}
public double getUsed() {
return used;
}
public void setUsed(double used) {
this.used = used;
}
public double getWait() {
return wait;
}
public void setWait(double wait) {
this.wait = wait;
}
public double getFree() {
return free;
}
public void setFree(double free) {
this.free = free;
}
public String getCpuModel() {
return cpuModel;
}
public void setCpuModel(String cpuModel) {
this.cpuModel = cpuModel;
}
@Override
public String toString() {
DecimalFormat format = new DecimalFormat("#.00");
return "CpuInfo{" +
"cpu核心数=" + cpuNum +
", CPU总的使用率=" + toTal +
", CPU系统使用率=" + sys +
", CPU用户使用率=" + used +
", CPU当前等待率=" + wait +
", CPU当前空闲率=" + free +
", CPU利用率=" + Double.parseDouble(format.format((100 - getFree()))) +
", CPU型号信息='" + cpuModel + '\'' +
'}';
}
}

350
hutool-system/src/main/java/cn/hutool/system/oshi/OshiUtil.java
View File

@@ -1,175 +1,175 @@
package cn.hutool.system.oshi;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.ComputerSystem;
import oshi.hardware.GlobalMemory;
import oshi.hardware.HWDiskStore;
import oshi.hardware.HardwareAbstractionLayer;
import oshi.hardware.NetworkIF;
import oshi.hardware.Sensors;
import oshi.software.os.OperatingSystem;
import oshi.util.Util;
import java.text.DecimalFormat;
import java.util.List;
/**
* Oshi库封装的工具类，通过此工具类，可获取系统、硬件相关信息
*
* <pre>
* 1、系统信息
* 2、硬件信息
* </pre>
*
* 相关内容见：https://github.com/oshi/oshi
*
* @author Looly
* @since 4.6.4
*/
public class OshiUtil {
private static final SystemInfo systemInfo;
/** 硬件信息 */
private static final HardwareAbstractionLayer hardware;
/** 系统信息 */
private static final OperatingSystem os;
static {
systemInfo = new SystemInfo();
hardware = systemInfo.getHardware();
os = systemInfo.getOperatingSystem();
}
/**
* 获取操作系统相关信息，包括系统版本、文件系统、进程等
*
* @return 操作系统相关信息
*/
public static OperatingSystem getOs() {
return os;
}
/**
* 获取硬件相关信息，包括内存、硬盘、网络设备、显示器、USB、声卡等
*
* @return 硬件相关信息
*/
public static HardwareAbstractionLayer getHardware() {
return hardware;
}
/**
* 获取BIOS中计算机相关信息，比如序列号、固件版本等
*
* @return 获取BIOS中计算机相关信息
*/
public static ComputerSystem getSystem() {
return hardware.getComputerSystem();
}
/**
* 获取内存相关信息，比如总内存、可用内存等
*
* @return 内存相关信息
*/
public static GlobalMemory getMemory() {
return hardware.getMemory();
}
/**
* 获取CPU（处理器）相关信息，比如CPU负载等
*
* @return CPU（处理器）相关信息
*/
public static CentralProcessor getProcessor() {
return hardware.getProcessor();
}
/**
* 获取传感器相关信息，例如CPU温度、风扇转速等，传感器可能有多个
*
* @return 传感器相关信息
*/
public static Sensors getSensors() {
return hardware.getSensors();
}
/**
* 获取磁盘相关信息，可能有多个磁盘（包括可移动磁盘等）
*
* @return 磁盘相关信息
* @since 5.3.6
*/
public static List<HWDiskStore> getDiskStores() {
return hardware.getDiskStores();
}
/**
* 获取网络相关信息，可能多块网卡
* @return 网络相关信息
* @since 5.3.6
*/
public static List<NetworkIF> getNetworkIFs(){
return hardware.getNetworkIFs();
}
// ------------------------------------------------------------------ cpu
/**
* 获取系统CPU 系统使用率、用户使用率、利用率等等 相关信息
*
* @return 系统 CPU 使用率 等信息
*/
public static CpuInfo getCpuInfo() {
return getCpuInfo(1000);
}
/**
* 获取系统CPU 系统使用率、用户使用率、利用率等等 相关信息
*
* @param waitingTime 设置等待时间
* @return 系统 CPU 使用率 等信息
*/
public static CpuInfo getCpuInfo(long waitingTime) {
return getCpuInfo(OshiUtil.getProcessor(), waitingTime);
}
/**
* 获取系统CPU 系统使用率、用户使用率、利用率等等 相关信息
*
* @param processor {@link CentralProcessor}
* @param waitingTime 设置等待时间
* @return 系统 CPU 使用率 等信息
*/
private static CpuInfo getCpuInfo(CentralProcessor processor, long waitingTime) {
CpuInfo cpuInfo = new CpuInfo();
// CPU信息
long[] prevTicks = processor.getSystemCpuLoadTicks();
// 这里必须要设置延迟
Util.sleep(waitingTime);
long[] ticks = processor.getSystemCpuLoadTicks();
long nice = ticks[CentralProcessor.TickType.NICE.getIndex()] - prevTicks[CentralProcessor.TickType.NICE.getIndex()];
long irq = ticks[CentralProcessor.TickType.IRQ.getIndex()] - prevTicks[CentralProcessor.TickType.IRQ.getIndex()];
long softIrq = ticks[CentralProcessor.TickType.SOFTIRQ.getIndex()] - prevTicks[CentralProcessor.TickType.SOFTIRQ.getIndex()];
long steal = ticks[CentralProcessor.TickType.STEAL.getIndex()] - prevTicks[CentralProcessor.TickType.STEAL.getIndex()];
long cSys = ticks[CentralProcessor.TickType.SYSTEM.getIndex()] - prevTicks[CentralProcessor.TickType.SYSTEM.getIndex()];
long user = ticks[CentralProcessor.TickType.USER.getIndex()] - prevTicks[CentralProcessor.TickType.USER.getIndex()];
long ioWait = ticks[CentralProcessor.TickType.IOWAIT.getIndex()] - prevTicks[CentralProcessor.TickType.IOWAIT.getIndex()];
long idle = ticks[CentralProcessor.TickType.IDLE.getIndex()] - prevTicks[CentralProcessor.TickType.IDLE.getIndex()];
long totalCpu = Math.max(user + nice + cSys + idle + ioWait + irq + softIrq + steal, 0);
final DecimalFormat format = new DecimalFormat("#.00");
cpuInfo.setCpuNum(processor.getLogicalProcessorCount());
cpuInfo.setToTal(totalCpu);
cpuInfo.setSys(Double.parseDouble(format.format(cSys <= 0 ? 0 : (100d * cSys / totalCpu))));
cpuInfo.setUsed(Double.parseDouble(format.format(user <= 0 ? 0 : (100d * user / totalCpu))));
if (totalCpu == 0) {
cpuInfo.setWait(0);
} else {
cpuInfo.setWait(Double.parseDouble(format.format(100d * ioWait / totalCpu)));
}
cpuInfo.setFree(Double.parseDouble(format.format(idle <= 0 ? 0 : (100d * idle / totalCpu))));
cpuInfo.setCpuModel(processor.toString());
return cpuInfo;
}
}
package cn.hutool.system.oshi;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.ComputerSystem;
import oshi.hardware.GlobalMemory;
import oshi.hardware.HWDiskStore;
import oshi.hardware.HardwareAbstractionLayer;
import oshi.hardware.NetworkIF;
import oshi.hardware.Sensors;
import oshi.software.os.OperatingSystem;
import oshi.util.Util;
import java.text.DecimalFormat;
import java.util.List;
/**
* Oshi库封装的工具类，通过此工具类，可获取系统、硬件相关信息
*
* <pre>
* 1、系统信息
* 2、硬件信息
* </pre>
*
* 相关内容见：https://github.com/oshi/oshi
*
* @author Looly
* @since 4.6.4
*/
public class OshiUtil {
private static final SystemInfo systemInfo;
/** 硬件信息 */
private static final HardwareAbstractionLayer hardware;
/** 系统信息 */
private static final OperatingSystem os;
static {
systemInfo = new SystemInfo();
hardware = systemInfo.getHardware();
os = systemInfo.getOperatingSystem();
}
/**
* 获取操作系统相关信息，包括系统版本、文件系统、进程等
*
* @return 操作系统相关信息
*/
public static OperatingSystem getOs() {
return os;
}
/**
* 获取硬件相关信息，包括内存、硬盘、网络设备、显示器、USB、声卡等
*
* @return 硬件相关信息
*/
public static HardwareAbstractionLayer getHardware() {
return hardware;
}
/**
* 获取BIOS中计算机相关信息，比如序列号、固件版本等
*
* @return 获取BIOS中计算机相关信息
*/
public static ComputerSystem getSystem() {
return hardware.getComputerSystem();
}
/**
* 获取内存相关信息，比如总内存、可用内存等
*
* @return 内存相关信息
*/
public static GlobalMemory getMemory() {
return hardware.getMemory();
}
/**
* 获取CPU（处理器）相关信息，比如CPU负载等
*
* @return CPU（处理器）相关信息
*/
public static CentralProcessor getProcessor() {
return hardware.getProcessor();
}
/**
* 获取传感器相关信息，例如CPU温度、风扇转速等，传感器可能有多个
*
* @return 传感器相关信息
*/
public static Sensors getSensors() {
return hardware.getSensors();
}
/**
* 获取磁盘相关信息，可能有多个磁盘（包括可移动磁盘等）
*
* @return 磁盘相关信息
* @since 5.3.6
*/
public static List<HWDiskStore> getDiskStores() {
return hardware.getDiskStores();
}
/**
* 获取网络相关信息，可能多块网卡
* @return 网络相关信息
* @since 5.3.6
*/
public static List<NetworkIF> getNetworkIFs(){
return hardware.getNetworkIFs();
}
// ------------------------------------------------------------------ cpu
/**
* 获取系统CPU 系统使用率、用户使用率、利用率等等 相关信息
*
* @return 系统 CPU 使用率 等信息
*/
public static CpuInfo getCpuInfo() {
return getCpuInfo(1000);
}
/**
* 获取系统CPU 系统使用率、用户使用率、利用率等等 相关信息
*
* @param waitingTime 设置等待时间
* @return 系统 CPU 使用率 等信息
*/
public static CpuInfo getCpuInfo(long waitingTime) {
return getCpuInfo(OshiUtil.getProcessor(), waitingTime);
}
/**
* 获取系统CPU 系统使用率、用户使用率、利用率等等 相关信息
*
* @param processor {@link CentralProcessor}
* @param waitingTime 设置等待时间
* @return 系统 CPU 使用率 等信息
*/
private static CpuInfo getCpuInfo(CentralProcessor processor, long waitingTime) {
CpuInfo cpuInfo = new CpuInfo();
// CPU信息
long[] prevTicks = processor.getSystemCpuLoadTicks();
// 这里必须要设置延迟
Util.sleep(waitingTime);
long[] ticks = processor.getSystemCpuLoadTicks();
long nice = ticks[CentralProcessor.TickType.NICE.getIndex()] - prevTicks[CentralProcessor.TickType.NICE.getIndex()];
long irq = ticks[CentralProcessor.TickType.IRQ.getIndex()] - prevTicks[CentralProcessor.TickType.IRQ.getIndex()];
long softIrq = ticks[CentralProcessor.TickType.SOFTIRQ.getIndex()] - prevTicks[CentralProcessor.TickType.SOFTIRQ.getIndex()];
long steal = ticks[CentralProcessor.TickType.STEAL.getIndex()] - prevTicks[CentralProcessor.TickType.STEAL.getIndex()];
long cSys = ticks[CentralProcessor.TickType.SYSTEM.getIndex()] - prevTicks[CentralProcessor.TickType.SYSTEM.getIndex()];
long user = ticks[CentralProcessor.TickType.USER.getIndex()] - prevTicks[CentralProcessor.TickType.USER.getIndex()];
long ioWait = ticks[CentralProcessor.TickType.IOWAIT.getIndex()] - prevTicks[CentralProcessor.TickType.IOWAIT.getIndex()];
long idle = ticks[CentralProcessor.TickType.IDLE.getIndex()] - prevTicks[CentralProcessor.TickType.IDLE.getIndex()];
long totalCpu = Math.max(user + nice + cSys + idle + ioWait + irq + softIrq + steal, 0);
final DecimalFormat format = new DecimalFormat("#.00");
cpuInfo.setCpuNum(processor.getLogicalProcessorCount());
cpuInfo.setToTal(totalCpu);
cpuInfo.setSys(Double.parseDouble(format.format(cSys <= 0 ? 0 : (100d * cSys / totalCpu))));
cpuInfo.setUsed(Double.parseDouble(format.format(user <= 0 ? 0 : (100d * user / totalCpu))));
if (totalCpu == 0) {
cpuInfo.setWait(0);
} else {
cpuInfo.setWait(Double.parseDouble(format.format(100d * ioWait / totalCpu)));
}
cpuInfo.setFree(Double.parseDouble(format.format(idle <= 0 ? 0 : (100d * idle / totalCpu))));
cpuInfo.setCpuModel(processor.toString());
return cpuInfo;
}
}

14
hutool-system/src/main/java/cn/hutool/system/oshi/package-info.java
View File

@@ -1,8 +1,8 @@
/**
* Oshi库封装<br>
* https://github.com/oshi/oshi
*
* @author Looly
* @since 4.6.4
*/
/**
* Oshi库封装<br>
* https://github.com/oshi/oshi
*
* @author Looly
* @since 4.6.4
*/
package cn.hutool.system.oshi;

12
hutool-system/src/main/java/cn/hutool/system/package-info.java
View File

@@ -1,7 +1,7 @@
/**
* System模块主要获取系统、JVM、内存、CPU等信息，以便动态监测系统状态
*
* @author looly
*
*/
/**
* System模块主要获取系统、JVM、内存、CPU等信息，以便动态监测系统状态
*
* @author looly
*
*/
package cn.hutool.system;

42
hutool-system/src/test/java/cn/hutool/system/OshiTest.java
View File

@@ -1,21 +1,21 @@
package cn.hutool.system;
import cn.hutool.system.oshi.CpuInfo;
import cn.hutool.system.oshi.OshiUtil;
import org.junit.Assert;
import org.junit.Test;
public class OshiTest {
@Test
public void getMemeryTest() {
long total = OshiUtil.getMemory().getTotal();
Assert.assertTrue(total > 0);
}
@Test
public void getCupInfo() {
CpuInfo cpuInfo = OshiUtil.getCpuInfo();
Assert.assertNotNull(cpuInfo);
}
}
package cn.hutool.system;
import cn.hutool.system.oshi.CpuInfo;
import cn.hutool.system.oshi.OshiUtil;
import org.junit.Assert;
import org.junit.Test;
public class OshiTest {
@Test
public void getMemeryTest() {
long total = OshiUtil.getMemory().getTotal();
Assert.assertTrue(total > 0);
}
@Test
public void getCupInfo() {
CpuInfo cpuInfo = OshiUtil.getCpuInfo();
Assert.assertNotNull(cpuInfo);
}
}

78
hutool-system/src/test/java/cn/hutool/system/SystemUtilTest.java
View File

@@ -1,39 +1,39 @@
package cn.hutool.system;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
public class SystemUtilTest {
@Test
@Ignore
public void dumpTest() {
SystemUtil.dumpSystemInfo();
}
@Test
public void getCurrentPidTest() {
long pid = SystemUtil.getCurrentPID();
Assert.assertTrue(pid > 0);
}
@Test
public void getJavaInfoTest() {
JavaInfo javaInfo = SystemUtil.getJavaInfo();
Assert.assertNotNull(javaInfo);
}
@Test
public void getOsInfoTest() {
OsInfo osInfo = SystemUtil.getOsInfo();
Assert.assertNotNull(osInfo);
}
@Test
public void getHostInfo() {
HostInfo hostInfo = SystemUtil.getHostInfo();
Assert.assertNotNull(hostInfo);
}
}
package cn.hutool.system;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
public class SystemUtilTest {
@Test
@Ignore
public void dumpTest() {
SystemUtil.dumpSystemInfo();
}
@Test
public void getCurrentPidTest() {
long pid = SystemUtil.getCurrentPID();
Assert.assertTrue(pid > 0);
}
@Test
public void getJavaInfoTest() {
JavaInfo javaInfo = SystemUtil.getJavaInfo();
Assert.assertNotNull(javaInfo);
}
@Test
public void getOsInfoTest() {
OsInfo osInfo = SystemUtil.getOsInfo();
Assert.assertNotNull(osInfo);
}
@Test
public void getHostInfo() {
HostInfo hostInfo = SystemUtil.getHostInfo();
Assert.assertNotNull(hostInfo);
}
}