zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-08-18 20:38:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

6.x

Browse Source
This commit is contained in:
Looly
2022-04-28 01:30:17 +08:00
parent e0ac5e9961
commit d78219c60c
248 changed files with 621 additions and 3407 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
hutool-extra/pom.xml
View File

@@ -9,7 +9,7 @@
<parent>
<groupId>cn.hutool</groupId>
<artifactId>hutool-parent</artifactId>
<version>5.8.0.M5</version>
<version>6.0.0.M1</version>
</parent>
<artifactId>hutool-extra</artifactId>
@@ -41,6 +41,11 @@
<artifactId>hutool-core</artifactId>
<version>${project.parent.version}</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-swing</artifactId>
<version>${project.parent.version}</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-setting</artifactId>
@@ -472,5 +477,12 @@
<scope>compile</scope>
<optional>true</optional>
</dependency>
<!-- 跨平台的系统及硬件信息库 -->
<dependency>
<groupId>com.github.oshi</groupId>
<artifactId>oshi-core</artifactId>
<version>6.1.6</version>
<scope>provided</scope>
</dependency>
</dependencies>
</project>

74
hutool-extra/src/main/java/cn/hutool/extra/aop/ProxyUtil.java Normal file
View File

@@ -0,0 +1,74 @@
package cn.hutool.extra.aop;
import cn.hutool.extra.aop.aspects.Aspect;
import cn.hutool.extra.aop.proxy.ProxyFactory;
import cn.hutool.core.util.ClassUtil;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
/**
* 代理工具类
* @author Looly
*
*/
public final class ProxyUtil {
/**
* 使用切面代理对象
*
* @param <T> 切面对象类型
* @param target 目标对象
* @param aspectClass 切面对象类
* @return 代理对象
*/
public static <T> T proxy(T target, Class<? extends Aspect> aspectClass){
return ProxyFactory.createProxy(target, aspectClass);
}
/**
* 使用切面代理对象
*
* @param <T> 被代理对象类型
* @param target 被代理对象
* @param aspect 切面对象
* @return 代理对象
*/
public static <T> T proxy(T target, Aspect aspect){
return ProxyFactory.createProxy(target, aspect);
}
/**
* 创建动态代理对象<br>
* 动态代理对象的创建原理是：<br>
* 假设创建的代理对象名为 $Proxy0<br>
* 1、根据传入的interfaces动态生成一个类，实现interfaces中的接口<br>
* 2、通过传入的classloder将刚生成的类加载到jvm中。即将$Proxy0类load<br>
* 3、调用$Proxy0的$Proxy0(InvocationHandler)构造函数 创建$Proxy0的对象，并且用interfaces参数遍历其所有接口的方法，这些实现方法的实现本质上是通过反射调用被代理对象的方法<br>
* 4、将$Proxy0的实例返回给客户端。 <br>
* 5、当调用代理类的相应方法时，相当于调用 {@link InvocationHandler#invoke(Object, java.lang.reflect.Method, Object[])} 方法
*
*
* @param <T> 被代理对象类型
* @param classloader 被代理类对应的ClassLoader
* @param invocationHandler {@link InvocationHandler} ，被代理类通过实现此接口提供动态代理功能
* @param interfaces 代理类中需要实现的被代理类的接口方法
* @return 代理类
*/
@SuppressWarnings("unchecked")
public static <T> T newProxyInstance(ClassLoader classloader, InvocationHandler invocationHandler, Class<?>... interfaces) {
return (T) Proxy.newProxyInstance(classloader, interfaces, invocationHandler);
}
/**
* 创建动态代理对象
*
* @param <T> 被代理对象类型
* @param invocationHandler {@link InvocationHandler} ，被代理类通过实现此接口提供动态代理功能
* @param interfaces 代理类中需要实现的被代理类的接口方法
* @return 代理类
*/
public static <T> T newProxyInstance(InvocationHandler invocationHandler, Class<?>... interfaces) {
return newProxyInstance(ClassUtil.getClassLoader(), invocationHandler, interfaces);
}
}

47
hutool-extra/src/main/java/cn/hutool/extra/aop/aspects/Aspect.java Normal file
View File

@@ -0,0 +1,47 @@
package cn.hutool.extra.aop.aspects;
import java.lang.reflect.Method;
/**
* 切面接口
*
* @author looly
* @author ted.L
* @since 4.18
*/
public interface Aspect {
/**
* 目标方法执行前的操作
*
* @param target 目标对象
* @param method 目标方法
* @param args 参数
* @return 是否继续执行接下来的操作
*/
boolean before(Object target, Method method, Object[] args);
/**
* 目标方法执行后的操作<br>
* 如果 target.method 抛出异常且 {@link Aspect#afterException} 返回true,则不会执行此操作<br>
* 如果 {@link Aspect#afterException} 返回false,则无论target.method是否抛出异常，均会执行此操作<br>
*
* @param target 目标对象
* @param method 目标方法
* @param args 参数
* @param returnVal 目标方法执行返回值
* @return 是否允许返回值（接下来的操作）
*/
boolean after(Object target, Method method, Object[] args, Object returnVal);
/**
* 目标方法抛出异常时的操作
*
* @param target 目标对象
* @param method 目标方法
* @param args 参数
* @param e 异常
* @return 是否允许抛出异常
*/
boolean afterException(Object target, Method method, Object[] args, Throwable e);
}

33
hutool-extra/src/main/java/cn/hutool/extra/aop/aspects/SimpleAspect.java Normal file
View File

@@ -0,0 +1,33 @@
package cn.hutool.extra.aop.aspects;
import java.io.Serializable;
import java.lang.reflect.Method;
/**
* 简单切面类，不做任何操作<br>
* 可以继承此类实现自己需要的方法即可
*
* @author Looly, ted.L
*/
public class SimpleAspect implements Aspect, Serializable {
private static final long serialVersionUID = 1L;
@Override
public boolean before(Object target, Method method, Object[] args) {
//继承此类后实现此方法
return true;
}
@Override
public boolean after(Object target, Method method, Object[] args, Object returnVal) {
//继承此类后实现此方法
return true;
}
@Override
public boolean afterException(Object target, Method method, Object[] args, Throwable e) {
//继承此类后实现此方法
return true;
}
}

33
hutool-extra/src/main/java/cn/hutool/extra/aop/aspects/TimeIntervalAspect.java Normal file
View File

@@ -0,0 +1,33 @@
package cn.hutool.extra.aop.aspects;
import cn.hutool.core.date.TimeInterval;
import cn.hutool.core.lang.Console;
import java.lang.reflect.Method;
/**
* 通过日志打印方法的执行时间的切面
*
* @author Looly
*/
public class TimeIntervalAspect extends SimpleAspect {
private static final long serialVersionUID = 1L;
private final TimeInterval interval = new TimeInterval();
@Override
public boolean before(Object target, Method method, Object[] args) {
interval.start();
return true;
}
@Override
public boolean after(Object target, Method method, Object[] args, Object returnVal) {
Console.log("Method [{}.{}] execute spend [{}]ms return value [{}]",
target.getClass().getName(), //
method.getName(), //
interval.intervalMs(), //
returnVal);
return true;
}
}

7
hutool-extra/src/main/java/cn/hutool/extra/aop/aspects/package-info.java Normal file
View File

@@ -0,0 +1,7 @@
/**
* 切面实现，提供一些基本的切面实现
*
* @author looly
*
*/
package cn.hutool.extra.aop.aspects;

60
hutool-extra/src/main/java/cn/hutool/extra/aop/interceptor/CglibInterceptor.java Normal file
View File

@@ -0,0 +1,60 @@
package cn.hutool.extra.aop.interceptor;
import cn.hutool.extra.aop.aspects.Aspect;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* Cglib实现的动态代理切面
*
* @author looly, ted.L
*/
public class CglibInterceptor implements MethodInterceptor, Serializable {
private static final long serialVersionUID = 1L;
private final Object target;
private final Aspect aspect;
/**
* 构造
*
* @param target 被代理对象
* @param aspect 切面实现
*/
public CglibInterceptor(Object target, Aspect aspect) {
this.target = target;
this.aspect = aspect;
}
public Object getTarget() {
return this.target;
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
final Object target = this.target;
Object result = null;
// 开始前回调
if (aspect.before(target, method, args)) {
try {
// result = proxy.invokeSuper(obj, args);
result = proxy.invoke(target, args);
} catch (InvocationTargetException e) {
// 异常回调（只捕获业务代码导致的异常，而非反射导致的异常）
if (aspect.afterException(target, method, args, e.getTargetException())) {
throw e;
}
}
}
// 结束执行回调
if (aspect.after(target, method, args, result)) {
return result;
}
return null;
}
}

67
hutool-extra/src/main/java/cn/hutool/extra/aop/interceptor/JdkInterceptor.java Normal file
View File

@@ -0,0 +1,67 @@
package cn.hutool.extra.aop.interceptor;
import cn.hutool.extra.aop.aspects.Aspect;
import cn.hutool.core.util.ClassUtil;
import cn.hutool.core.util.ReflectUtil;
import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* JDK实现的动态代理切面
*
* @author Looly
* @author ted.L
*/
public class JdkInterceptor implements InvocationHandler, Serializable {
private static final long serialVersionUID = 1L;
private final Object target;
private final Aspect aspect;
/**
* 构造
*
* @param target 被代理对象
* @param aspect 切面实现
*/
public JdkInterceptor(Object target, Aspect aspect) {
this.target = target;
this.aspect = aspect;
}
public Object getTarget() {
return this.target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
final Object target = this.target;
final Aspect aspect = this.aspect;
Object result = null;
// 开始前回调
if (aspect.before(target, method, args)) {
ReflectUtil.setAccessible(method);
try {
result = method.invoke(ClassUtil.isStatic(method) ? null : target, args);
} catch (InvocationTargetException e) {
// 异常回调（只捕获业务代码导致的异常，而非反射导致的异常）
if (aspect.afterException(target, method, args, e.getTargetException())) {
throw e;
}
}
// 结束执行回调
if (aspect.after(target, method, args, result)) {
return result;
}
}
return null;
}
}

65
hutool-extra/src/main/java/cn/hutool/extra/aop/interceptor/SpringCglibInterceptor.java Normal file
View File

@@ -0,0 +1,65 @@
package cn.hutool.extra.aop.interceptor;
import cn.hutool.extra.aop.aspects.Aspect;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* Spring-cglib实现的动态代理切面
*
* @author looly
*/
public class SpringCglibInterceptor implements MethodInterceptor, Serializable {
private static final long serialVersionUID = 1L;
private final Object target;
private final Aspect aspect;
/**
* 构造
*
* @param target 被代理对象
* @param aspect 切面实现
*/
public SpringCglibInterceptor(Object target, Aspect aspect) {
this.target = target;
this.aspect = aspect;
}
/**
* 获得目标对象
*
* @return 目标对象
*/
public Object getTarget() {
return this.target;
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
final Object target = this.target;
Object result = null;
// 开始前回调
if (aspect.before(target, method, args)) {
try {
// result = proxy.invokeSuper(obj, args);
result = proxy.invoke(target, args);
} catch (InvocationTargetException e) {
// 异常回调（只捕获业务代码导致的异常，而非反射导致的异常）
if (aspect.afterException(target, method, args, e.getTargetException())) {
throw e;
}
}
}
// 结束执行回调
if (aspect.after(target, method, args, result)) {
return result;
}
return null;
}
}

7
hutool-extra/src/main/java/cn/hutool/extra/aop/interceptor/package-info.java Normal file
View File

@@ -0,0 +1,7 @@
/**
* 代理拦截器实现
*
* @author looly
*
*/
package cn.hutool.extra.aop.interceptor;

7
hutool-extra/src/main/java/cn/hutool/extra/aop/package-info.java Normal file
View File

@@ -0,0 +1,7 @@
/**
* JDK动态代理封装，提供非IOC下的切面支持
*
* @author looly
*
*/
package cn.hutool.extra.aop;

24
hutool-extra/src/main/java/cn/hutool/extra/aop/proxy/CglibProxyFactory.java Normal file
View File

@@ -0,0 +1,24 @@
package cn.hutool.extra.aop.proxy;
import cn.hutool.extra.aop.aspects.Aspect;
import cn.hutool.extra.aop.interceptor.CglibInterceptor;
import net.sf.cglib.proxy.Enhancer;
/**
* 基于Cglib的切面代理工厂
*
* @author looly
*/
public class CglibProxyFactory extends ProxyFactory {
private static final long serialVersionUID = 1L;
@Override
@SuppressWarnings("unchecked")
public <T> T proxy(T target, Aspect aspect) {
final Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(new CglibInterceptor(target, aspect));
return (T) enhancer.create();
}
}

22
hutool-extra/src/main/java/cn/hutool/extra/aop/proxy/JdkProxyFactory.java Normal file
View File

@@ -0,0 +1,22 @@
package cn.hutool.extra.aop.proxy;
import cn.hutool.extra.aop.ProxyUtil;
import cn.hutool.extra.aop.aspects.Aspect;
import cn.hutool.extra.aop.interceptor.JdkInterceptor;
/**
* JDK实现的切面代理
*
* @author looly
*/
public class JdkProxyFactory extends ProxyFactory {
private static final long serialVersionUID = 1L;
@Override
public <T> T proxy(T target, Aspect aspect) {
return ProxyUtil.newProxyInstance(//
target.getClass().getClassLoader(), //
new JdkInterceptor(target, aspect), //
target.getClass().getInterfaces());
}
}

73
hutool-extra/src/main/java/cn/hutool/extra/aop/proxy/ProxyFactory.java Normal file
View File

@@ -0,0 +1,73 @@
package cn.hutool.extra.aop.proxy;
import cn.hutool.extra.aop.aspects.Aspect;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.ServiceLoaderUtil;
import java.io.Serializable;
/**
* 代理工厂<br>
* 根据用户引入代理库的不同，产生不同的代理对象
*
* @author looly
*/
public abstract class ProxyFactory implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 创建代理
*
* @param <T> 代理对象类型
* @param target 被代理对象
* @param aspectClass 切面实现类，自动实例化
* @return 代理对象
* @since 5.3.1
*/
public <T> T proxy(T target, Class<? extends Aspect> aspectClass) {
return proxy(target, ReflectUtil.newInstanceIfPossible(aspectClass));
}
/**
* 创建代理
*
* @param <T> 代理对象类型
* @param target 被代理对象
* @param aspect 切面实现
* @return 代理对象
*/
public abstract <T> T proxy(T target, Aspect aspect);
/**
* 根据用户引入Cglib与否自动创建代理对象
*
* @param <T> 切面对象类型
* @param target 目标对象
* @param aspectClass 切面对象类
* @return 代理对象
*/
public static <T> T createProxy(T target, Class<? extends Aspect> aspectClass) {
return createProxy(target, ReflectUtil.newInstance(aspectClass));
}
/**
* 根据用户引入Cglib与否自动创建代理对象
*
* @param <T> 切面对象类型
* @param target 被代理对象
* @param aspect 切面实现
* @return 代理对象
*/
public static <T> T createProxy(T target, Aspect aspect) {
return create().proxy(target, aspect);
}
/**
* 根据用户引入Cglib与否创建代理工厂
*
* @return 代理工厂
*/
public static ProxyFactory create() {
return ServiceLoaderUtil.loadFirstAvailable(ProxyFactory.class);
}
}

25
hutool-extra/src/main/java/cn/hutool/extra/aop/proxy/SpringCglibProxyFactory.java Normal file
View File

@@ -0,0 +1,25 @@
package cn.hutool.extra.aop.proxy;
import cn.hutool.extra.aop.aspects.Aspect;
import cn.hutool.extra.aop.interceptor.SpringCglibInterceptor;
import org.springframework.cglib.proxy.Enhancer;
/**
* 基于Spring-cglib的切面代理工厂
*
* @author looly
*
*/
public class SpringCglibProxyFactory extends ProxyFactory{
private static final long serialVersionUID = 1L;
@Override
@SuppressWarnings("unchecked")
public <T> T proxy(T target, Aspect aspect) {
final Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(new SpringCglibInterceptor(target, aspect));
return (T) enhancer.create();
}
}

7
hutool-extra/src/main/java/cn/hutool/extra/aop/proxy/package-info.java Normal file
View File

@@ -0,0 +1,7 @@
/**
* 代理实现
*
* @author looly
*
*/
package cn.hutool.extra.aop.proxy;

4
hutool-extra/src/main/java/cn/hutool/extra/qrcode/QrCodeUtil.java
View File

@@ -1,8 +1,8 @@
package cn.hutool.extra.qrcode;
import cn.hutool.core.codec.Base64;
import cn.hutool.core.img.Img;
import cn.hutool.core.img.ImgUtil;
import cn.hutool.swing.img.Img;
import cn.hutool.swing.img.ImgUtil;
import cn.hutool.core.util.CharsetUtil;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.Binarizer;

2
hutool-extra/src/main/java/cn/hutool/extra/qrcode/QrConfig.java
View File

@@ -1,6 +1,6 @@
package cn.hutool.extra.qrcode;
import cn.hutool.core.img.ImgUtil;
import cn.hutool.swing.img.ImgUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.CharsetUtil;
import com.google.zxing.BarcodeFormat;

69
hutool-extra/src/main/java/cn/hutool/extra/system/HostInfo.java Normal file
View File

@@ -0,0 +1,69 @@
package cn.hutool.extra.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"}
* </p>
*
* @return 主机名
*/
public final String getName() {
return HOST_NAME;
}
/**
* 取得当前主机的地址。
*
* <p>
* 例如：{@code "192.168.0.1"}
* </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();
}
}

361
hutool-extra/src/main/java/cn/hutool/extra/system/JavaInfo.java Normal file
View File

@@ -0,0 +1,361 @@
package cn.hutool.extra.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}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "1.4.2"}
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
* @since Java 1.1
*/
public final String getVersion() {
return JAVA_VERSION;
}
/**
* 取得当前Java impl.的版本（取自系统属性：{@code java.version}）。
*
* <p>
* 例如：
*
* <ul>
* <li>JDK 1.2：{@code 1.2f}。</li>
* <li>JDK 1.3.1：{@code 1.31f}</li>
* </ul>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code 0}。
*/
public final float getVersionFloat() {
return JAVA_VERSION_FLOAT;
}
/**
* 取得当前Java impl.的版本（取自系统属性：{@code java.version}），java10及其之后的版本返回值为4位。
*
* <p>
* 例如：
*
* <ul>
* <li>JDK 1.2：{@code 120}。</li>
* <li>JDK 1.3.1：{@code 131}</li>
* <li>JDK 11.0.2：{@code 1102}</li>
* </ul>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code 0}。
* @since Java 1.1
*/
public final int getVersionInt() {
return JAVA_VERSION_INT;
}
/**
* 取得当前Java impl.的版本的{@code float}值。
*
* @return Java版本的<code>float</code>值或{@code 0}
*/
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}值。
*
* @return Java版本的<code>int</code>值或{@code 0}
*/
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}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "Sun Microsystems Inc."}
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
* @since Java 1.1
*/
public final String getVendor() {
return JAVA_VENDOR;
}
/**
* 取得当前Java impl.的厂商网站的URL（取自系统属性：{@code java.vendor.url}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "<a href="http://java.sun.com/">http://java.sun.com/</a>"}
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
* @since Java 1.1
*/
public final String getVendorURL() {
return JAVA_VENDOR_URL;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为1.1，则返回{@code true}
*/
public final boolean isJava1_1() {
return IS_JAVA_1_1;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为1.2，则返回{@code true}
*/
public final boolean isJava1_2() {
return IS_JAVA_1_2;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为1.3，则返回{@code true}
*/
public final boolean isJava1_3() {
return IS_JAVA_1_3;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为1.4，则返回{@code true}
*/
public final boolean isJava1_4() {
return IS_JAVA_1_4;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为1.5，则返回{@code true}
*/
public final boolean isJava1_5() {
return IS_JAVA_1_5;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为1.6，则返回{@code true}
*/
public final boolean isJava1_6() {
return IS_JAVA_1_6;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为1.7，则返回{@code true}
*/
public final boolean isJava1_7() {
return IS_JAVA_1_7;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为1.8，则返回{@code true}
*/
public final boolean isJava1_8() {
return IS_JAVA_1_8;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为9，则返回{@code true}
*/
public final boolean isJava9() {
return IS_JAVA_9;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为10，则返回{@code true}
*/
public final boolean isJava10() {
return IS_JAVA_10;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为11，则返回{@code true}
*/
public final boolean isJava11() {
return IS_JAVA_11;
}
/**
* 判断当前Java的版本。
*
* <p>
* 如果不能取得系统属性{@code java.version}（因为Java安全限制），则总是返回 {@code false}
*
* @return 如果当前Java版本为12，则返回{@code true}
*/
public final boolean isJava12() {
return IS_JAVA_12;
}
/**
* 匹配当前Java的版本。
*
* @param versionPrefix Java版本前缀
* @return 如果版本匹配，则返回{@code true}
*/
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)}</li>
* <li>测试JDK 1.2.1：{@code isJavaVersionAtLeast(1.31f)}</li>
* </ul>
*
* @param requiredVersion 需要的版本
* @return 如果当前Java版本大于或等于指定的版本，则返回{@code true}
*/
public final boolean isJavaVersionAtLeast(float requiredVersion) {
return getVersionFloat() >= requiredVersion;
}
/**
* 判定当前Java的版本是否大于等于指定的版本号。
*
* <p>
* 例如：
*
*
* <ul>
* <li>测试JDK 1.2：{@code isJavaVersionAtLeast(120)}</li>
* <li>测试JDK 1.2.1：{@code isJavaVersionAtLeast(131)}</li>
* </ul>
*
* @param requiredVersion 需要的版本
* @return 如果当前Java版本大于或等于指定的版本，则返回{@code true}
*/
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();
}
}

225
hutool-extra/src/main/java/cn/hutool/extra/system/JavaRuntimeInfo.java Normal file
View File

@@ -0,0 +1,225 @@
package cn.hutool.extra.system;
import cn.hutool.core.util.StrUtil;
import java.io.Serializable;
/**
* 代表当前运行的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} 64M
*
* @return 32 {@code or} 64
*/
public final String getSunArchDataModel() {
return SUN_ARCH_DATA_MODEL;
}
/**
* 取得当前JRE的名称（取自系统属性：{@code java.runtime.name}）。
*
* <p>
* 例如Sun JDK 1.4.2： {@code "Java(TM) 2 Runtime Environment, Standard Edition"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.3
*/
public final String getName() {
return JAVA_RUNTIME_NAME;
}
/**
* 取得当前JRE的版本（取自系统属性：{@code java.runtime.version}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "1.4.2-b28"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.3
*/
public final String getVersion() {
return JAVA_RUNTIME_VERSION;
}
/**
* 取得当前JRE的安装目录（取自系统属性：{@code java.home}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "/opt/jdk1.4.2/jre"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getHomeDir() {
return JAVA_HOME;
}
/**
* 取得当前JRE的扩展目录列表（取自系统属性：{@code java.ext.dirs}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "/opt/jdk1.4.2/jre/lib/ext:..."}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.3
*/
public final String getExtDirs() {
return JAVA_EXT_DIRS;
}
/**
* 取得当前JRE的endorsed目录列表（取自系统属性：{@code java.endorsed.dirs}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "/opt/jdk1.4.2/jre/lib/endorsed:..."}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.4
*/
public final String getEndorsedDirs() {
return JAVA_ENDORSED_DIRS;
}
/**
* 取得当前JRE的系统classpath（取自系统属性：{@code java.class.path}）。
*
* <p>
* 例如：{@code "/home/admin/myclasses:/home/admin/..."}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getClassPath() {
return JAVA_CLASS_PATH;
}
/**
* 取得当前JRE的系统classpath（取自系统属性：{@code java.class.path}）。
*
* <p>
* 例如：{@code "/home/admin/myclasses:/home/admin/..."}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String[] getClassPathArray() {
return StrUtil.splitToArray(getClassPath(), SystemUtil.get("path.separator", false));
}
/**
* 取得当前JRE的class文件格式的版本（取自系统属性：{@code java.class.version}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "48.0"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getClassVersion() {
return JAVA_CLASS_VERSION;
}
/**
* 取得当前JRE的library搜索路径（取自系统属性：{@code java.library.path}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "/opt/jdk1.4.2/bin:..."}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
public final String getLibraryPath() {
return JAVA_LIBRARY_PATH;
}
/**
* 取得当前JRE的library搜索路径（取自系统属性：{@code java.library.path}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "/opt/jdk1.4.2/bin:..."}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*
*/
public final String[] getLibraryPathArray() {
return StrUtil.splitToArray(getLibraryPath(), SystemUtil.get("path.separator", false));
}
/**
* 取得当前JRE的URL协议packages列表（取自系统属性：{@code java.library.path}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "sun.net.www.protocol|..."}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*
*/
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();
}
}

74
hutool-extra/src/main/java/cn/hutool/extra/system/JavaSpecInfo.java Normal file
View File

@@ -0,0 +1,74 @@
package cn.hutool.extra.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}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "Java Platform API Specification"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
public final String getName() {
return JAVA_SPECIFICATION_NAME;
}
/**
* 取得当前Java Spec.的版本（取自系统属性：{@code java.specification.version}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "1.4"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.3
*/
public final String getVersion() {
return JAVA_SPECIFICATION_VERSION;
}
/**
* 取得当前Java Spec.的厂商（取自系统属性：{@code java.specification.vendor}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "Sun Microsystems Inc."}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
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();
}
}

89
hutool-extra/src/main/java/cn/hutool/extra/system/JvmInfo.java Normal file
View File

@@ -0,0 +1,89 @@
package cn.hutool.extra.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}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "Java HotSpot(TM) Client VM"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
public final String getName() {
return JAVA_VM_NAME;
}
/**
* 取得当前JVM impl.的版本（取自系统属性：{@code java.vm.version}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "1.4.2-b28"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
public final String getVersion() {
return JAVA_VM_VERSION;
}
/**
* 取得当前JVM impl.的厂商（取自系统属性：{@code java.vm.vendor}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "Sun Microsystems Inc."}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
public final String getVendor() {
return JAVA_VM_VENDOR;
}
/**
* 取得当前JVM impl.的信息（取自系统属性：{@code java.vm.info}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "mixed mode"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
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();
}
}

73
hutool-extra/src/main/java/cn/hutool/extra/system/JvmSpecInfo.java Normal file
View File

@@ -0,0 +1,73 @@
package cn.hutool.extra.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}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "Java Virtual Machine Specification"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
public final String getName() {
return JAVA_VM_SPECIFICATION_NAME;
}
/**
* 取得当前JVM spec.的版本（取自系统属性：{@code java.vm.specification.version}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "1.0"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
public final String getVersion() {
return JAVA_VM_SPECIFICATION_VERSION;
}
/**
* 取得当前JVM spec.的厂商（取自系统属性：{@code java.vm.specification.vendor}）。
*
* <p>
* 例如Sun JDK 1.4.2：{@code "Sun Microsystems Inc."}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
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();
}
}

441
hutool-extra/src/main/java/cn/hutool/extra/system/OsInfo.java Normal file
View File

@@ -0,0 +1,441 @@
package cn.hutool.extra.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}）。
*
* <p>
* 例如：{@code "x86"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getArch() {
return OS_ARCH;
}
/**
* 取得当前OS的名称（取自系统属性：{@code os.name}）。
*
* <p>
* 例如：{@code "Windows XP"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getName() {
return OS_NAME;
}
/**
* 取得当前OS的版本（取自系统属性：{@code os.version}）。
*
* <p>
* 例如：{@code "5.1"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getVersion() {
return OS_VERSION;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为AIX，则返回{@code true}
*/
public final boolean isAix() {
return IS_OS_AIX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为HP-UX，则返回{@code true}
*/
public final boolean isHpUx() {
return IS_OS_HP_UX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为IRIX，则返回{@code true}
*/
public final boolean isIrix() {
return IS_OS_IRIX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Linux，则返回{@code true}
*/
public final boolean isLinux() {
return IS_OS_LINUX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Mac，则返回{@code true}
*/
public final boolean isMac() {
return IS_OS_MAC;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为MacOS X，则返回{@code true}
*/
public final boolean isMacOsX() {
return IS_OS_MAC_OSX;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为OS2，则返回{@code true}
*/
public final boolean isOs2() {
return IS_OS_OS2;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Solaris，则返回{@code true}
*/
public final boolean isSolaris() {
return IS_OS_SOLARIS;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Sun OS，则返回{@code true}
*/
public final boolean isSunOS() {
return IS_OS_SUN_OS;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows，则返回{@code true}
*/
public final boolean isWindows() {
return IS_OS_WINDOWS;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows 2000，则返回{@code true}
*/
public final boolean isWindows2000() {
return IS_OS_WINDOWS_2000;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows 95，则返回{@code true}
*/
public final boolean isWindows95() {
return IS_OS_WINDOWS_95;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows 98，则返回{@code true}
*/
public final boolean isWindows98() {
return IS_OS_WINDOWS_98;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows ME，则返回{@code true}
*/
public final boolean isWindowsME() {
return IS_OS_WINDOWS_ME;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows NT，则返回{@code true}
*/
public final boolean isWindowsNT() {
return IS_OS_WINDOWS_NT;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows XP，则返回{@code true}
*/
public final boolean isWindowsXP() {
return IS_OS_WINDOWS_XP;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows 7，则返回{@code true}
*/
public final boolean isWindows7() {
return IS_OS_WINDOWS_7;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows 8，则返回{@code true}
*/
public final boolean isWindows8() {
return IS_OS_WINDOWS_8;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows 8.1，则返回{@code true}
*/
public final boolean isWindows8_1() {
return IS_OS_WINDOWS_8_1;
}
/**
* 判断当前OS的类型。
*
* <p>
* 如果不能取得系统属性{@code os.name}（因为Java安全限制），则总是返回{@code false}
* </p>
*
* @return 如果当前OS类型为Windows 10，则返回{@code true}
*/
public final boolean isWindows10() {
return IS_OS_WINDOWS_10;
}
/**
* 匹配OS名称。
*
* @param osNamePrefix OS名称前缀
*
* @return 如果匹配，则返回{@code true}
*/
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}
*/
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}）。
*
* <p>
* 例如：Unix为{@code "/"}，Windows为{@code "\\"}。
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getFileSeparator() {
return FILE_SEPARATOR;
}
/**
* 取得OS的文本文件换行符（取自系统属性：{@code line.separator}）。
*
* <p>
* 例如：Unix为{@code "\n"}，Windows为{@code "\r\n"}。
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getLineSeparator() {
return LINE_SEPARATOR;
}
/**
* 取得OS的搜索路径分隔符（取自系统属性：{@code path.separator}）。
*
* <p>
* 例如：Unix为{@code ":"}，Windows为{@code ";"}。
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @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();
}
}

73
hutool-extra/src/main/java/cn/hutool/extra/system/RuntimeInfo.java Normal file
View File

@@ -0,0 +1,73 @@
package cn.hutool.extra.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();
}
}

136
hutool-extra/src/main/java/cn/hutool/extra/system/SystemPropsKeys.java Normal file
View File

@@ -0,0 +1,136 @@
package cn.hutool.extra.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";
}

421
hutool-extra/src/main/java/cn/hutool/extra/system/SystemUtil.java Normal file
View File

@@ -0,0 +1,421 @@
package cn.hutool.extra.system;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.Singleton;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.SystemPropsUtil;
import java.io.PrintWriter;
import java.lang.management.ClassLoadingMXBean;
import java.lang.management.CompilationMXBean;
import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryManagerMXBean;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.OperatingSystemMXBean;
import java.lang.management.RuntimeMXBean;
import java.lang.management.ThreadMXBean;
import java.util.List;
/**
* Java的System类封装工具类。<br>
* 参考：<a href="http://blog.csdn.net/zhongweijian/article/details/7619383">http://blog.csdn.net/zhongweijian/article/details/7619383</a>
*
* @author Looly
*/
public class SystemUtil extends SystemPropsUtil {
// ----- Java运行时环境信息 -----/
/**
* Java 运行时环境规范名称的KEY
*/
public final static String SPECIFICATION_NAME = SystemPropsKeys.SPECIFICATION_NAME;
/**
* Java 运行时环境版本的KEY
*/
public final static String VERSION = SystemPropsKeys.VERSION;
/**
* Java 运行时环境规范版本的KEY
*/
public final static String SPECIFICATION_VERSION = SystemPropsKeys.SPECIFICATION_VERSION;
/**
* Java 运行时环境供应商的KEY
*/
public final static String VENDOR = SystemPropsKeys.VENDOR;
/**
* Java 运行时环境规范供应商的KEY
*/
public final static String SPECIFICATION_VENDOR = SystemPropsKeys.SPECIFICATION_VENDOR;
/**
* Java 供应商的 URL的KEY
*/
public final static String VENDOR_URL = SystemPropsKeys.VENDOR_URL;
/**
* Java 安装目录的KEY
*/
public final static String HOME = SystemPropsKeys.HOME;
/**
* 加载库时搜索的路径列表的KEY
*/
public final static String LIBRARY_PATH = SystemPropsKeys.LIBRARY_PATH;
/**
* 默认的临时文件路径的KEY
*/
public final static String TMPDIR = SystemPropsKeys.TMPDIR;
/**
* 要使用的 JIT 编译器的名称的KEY
*/
public final static String COMPILER = SystemPropsKeys.COMPILER;
/**
* 一个或多个扩展目录的路径的KEY
*/
public final static String EXT_DIRS = SystemPropsKeys.EXT_DIRS;
// ----- Java虚拟机信息 -----/
/**
* Java 虚拟机实现名称的KEY
*/
public final static String VM_NAME = SystemPropsKeys.VM_NAME;
/**
* Java 虚拟机规范名称的KEY
*/
public final static String VM_SPECIFICATION_NAME = SystemPropsKeys.VM_SPECIFICATION_NAME;
/**
* Java 虚拟机实现版本的KEY
*/
public final static String VM_VERSION = SystemPropsKeys.VM_VERSION;
/**
* Java 虚拟机规范版本的KEY
*/
public final static String VM_SPECIFICATION_VERSION = SystemPropsKeys.VM_SPECIFICATION_VERSION;
/**
* Java 虚拟机实现供应商的KEY
*/
public final static String VM_VENDOR = SystemPropsKeys.VM_VENDOR;
/**
* Java 虚拟机规范供应商的KEY
*/
public final static String VM_SPECIFICATION_VENDOR = SystemPropsKeys.VM_SPECIFICATION_VENDOR;
// ----- Java类信息 -----/
/**
* Java 类格式版本号的KEY
*/
public final static String CLASS_VERSION = SystemPropsKeys.CLASS_VERSION;
/**
* Java 类路径的KEY
*/
public final static String CLASS_PATH = SystemPropsKeys.CLASS_PATH;
// ----- OS信息 -----/
/**
* 操作系统的名称的KEY
*/
public final static String OS_NAME = SystemPropsKeys.OS_NAME;
/**
* 操作系统的架构的KEY
*/
public final static String OS_ARCH = SystemPropsKeys.OS_ARCH;
/**
* 操作系统的版本的KEY
*/
public final static String OS_VERSION = SystemPropsKeys.OS_VERSION;
/**
* 文件分隔符（在 UNIX 系统中是“/”）的KEY
*/
public final static String FILE_SEPARATOR = SystemPropsKeys.FILE_SEPARATOR;
/**
* 路径分隔符（在 UNIX 系统中是“:”）的KEY
*/
public final static String PATH_SEPARATOR = SystemPropsKeys.PATH_SEPARATOR;
/**
* 行分隔符（在 UNIX 系统中是“\n”）的KEY
*/
public final static String LINE_SEPARATOR = SystemPropsKeys.LINE_SEPARATOR;
// ----- 用户信息 -----/
/**
* 用户的账户名称的KEY
*/
public final static String USER_NAME = SystemPropsKeys.USER_NAME;
/**
* 用户的主目录的KEY
*/
public final static String USER_HOME = SystemPropsKeys.USER_HOME;
/**
* 用户的当前工作目录的KEY
*/
public final static String USER_DIR = SystemPropsKeys.USER_DIR;
/**
* 获取当前进程 PID
*
* @return 当前进程 ID
*/
public static long getCurrentPID() {
return Long.parseLong(getRuntimeMXBean().getName().split("@")[0]);
}
/**
* 返回Java虚拟机类加载系统相关属性
*
* @return {@link ClassLoadingMXBean}
* @since 4.1.4
*/
public static ClassLoadingMXBean getClassLoadingMXBean() {
return ManagementFactory.getClassLoadingMXBean();
}
/**
* 返回Java虚拟机内存系统相关属性
*
* @return {@link MemoryMXBean}
* @since 4.1.4
*/
public static MemoryMXBean getMemoryMXBean() {
return ManagementFactory.getMemoryMXBean();
}
/**
* 返回Java虚拟机线程系统相关属性
*
* @return {@link ThreadMXBean}
* @since 4.1.4
*/
public static ThreadMXBean getThreadMXBean() {
return ManagementFactory.getThreadMXBean();
}
/**
* 返回Java虚拟机运行时系统相关属性
*
* @return {@link RuntimeMXBean}
* @since 4.1.4
*/
public static RuntimeMXBean getRuntimeMXBean() {
return ManagementFactory.getRuntimeMXBean();
}
/**
* 返回Java虚拟机编译系统相关属性<br>
* 如果没有编译系统，则返回{@code null}
*
* @return a {@link CompilationMXBean} ，如果没有编译系统，则返回{@code null}
* @since 4.1.4
*/
public static CompilationMXBean getCompilationMXBean() {
return ManagementFactory.getCompilationMXBean();
}
/**
* 返回Java虚拟机运行下的操作系统相关信息属性
*
* @return {@link OperatingSystemMXBean}
* @since 4.1.4
*/
public static OperatingSystemMXBean getOperatingSystemMXBean() {
return ManagementFactory.getOperatingSystemMXBean();
}
/**
* 获取Java虚拟机中的{@link MemoryPoolMXBean}列表<br>
* The Java virtual machine can have one or more memory pools. It may add or remove memory pools during execution.
*
* @return a list of <tt>MemoryPoolMXBean</tt> objects.
*/
public static List<MemoryPoolMXBean> getMemoryPoolMXBeans() {
return ManagementFactory.getMemoryPoolMXBeans();
}
/**
* 获取Java虚拟机中的{@link MemoryManagerMXBean}列表<br>
* The Java virtual machine can have one or more memory managers. It may add or remove memory managers during execution.
*
* @return a list of <tt>MemoryManagerMXBean</tt> objects.
*/
public static List<MemoryManagerMXBean> getMemoryManagerMXBeans() {
return ManagementFactory.getMemoryManagerMXBeans();
}
/**
* 获取Java虚拟机中的{@link GarbageCollectorMXBean}列表
*
* @return {@link GarbageCollectorMXBean}列表
*/
public static List<GarbageCollectorMXBean> getGarbageCollectorMXBeans() {
return ManagementFactory.getGarbageCollectorMXBeans();
}
/**
* 取得Java Virtual Machine Specification的信息。
*
* @return {@link JvmSpecInfo}对象
*/
public static JvmSpecInfo getJvmSpecInfo() {
return Singleton.get(JvmSpecInfo.class);
}
/**
* 取得Java Virtual Machine Implementation的信息。
*
* @return {@link JvmInfo}对象
*/
public static JvmInfo getJvmInfo() {
return Singleton.get(JvmInfo.class);
}
/**
* 取得Java Specification的信息。
*
* @return {@link JavaSpecInfo}对象
*/
public static JavaSpecInfo getJavaSpecInfo() {
return Singleton.get(JavaSpecInfo.class);
}
/**
* 取得Java Implementation的信息。
*
* @return {@link JavaInfo}对象
*/
public static JavaInfo getJavaInfo() {
return Singleton.get(JavaInfo.class);
}
/**
* 取得当前运行的JRE的信息。
*
* @return {@link JavaRuntimeInfo}对象
*/
public static JavaRuntimeInfo getJavaRuntimeInfo() {
return Singleton.get(JavaRuntimeInfo.class);
}
/**
* 取得OS的信息。
*
* @return {@code OsInfo}对象
*/
public static OsInfo getOsInfo() {
return Singleton.get(OsInfo.class);
}
/**
* 取得User的信息。
*
* @return {@code UserInfo}对象
*/
public static UserInfo getUserInfo() {
return Singleton.get(UserInfo.class);
}
/**
* 取得Host的信息。
*
* @return {@link HostInfo}对象
*/
public static HostInfo getHostInfo() {
return Singleton.get(HostInfo.class);
}
/**
* 取得Runtime的信息。
*
* @return {@link RuntimeInfo}对象
*/
public static RuntimeInfo getRuntimeInfo() {
return Singleton.get(RuntimeInfo.class);
}
/**
* 获取JVM中内存总大小
*
* @return 内存总大小
* @since 4.5.4
*/
public static long getTotalMemory() {
return Runtime.getRuntime().totalMemory();
}
/**
* 获取JVM中内存剩余大小
*
* @return 内存剩余大小
* @since 4.5.4
*/
public static long getFreeMemory() {
return Runtime.getRuntime().freeMemory();
}
/**
* 获取JVM可用的内存总大小
*
* @return JVM可用的内存总大小
* @since 4.5.4
*/
public static long getMaxMemory() {
return Runtime.getRuntime().maxMemory();
}
/**
* 获取总线程数
*
* @return 总线程数
*/
public static int getTotalThreadCount() {
ThreadGroup parentThread = Thread.currentThread().getThreadGroup();
while (null != parentThread.getParent()) {
parentThread = parentThread.getParent();
}
return parentThread.activeCount();
}
// ------------------------------------------------------------------ Dump
/**
* 将系统信息输出到{@link System#out}中。
*/
public static void dumpSystemInfo() {
dumpSystemInfo(new PrintWriter(System.out));
}
/**
* 将系统信息输出到指定{@link PrintWriter}中。
*
* @param out {@link PrintWriter}输出流
*/
public static void dumpSystemInfo(PrintWriter out) {
out.println("--------------");
out.println(getJvmSpecInfo());
out.println("--------------");
out.println(getJvmInfo());
out.println("--------------");
out.println(getJavaSpecInfo());
out.println("--------------");
out.println(getJavaInfo());
out.println("--------------");
out.println(getJavaRuntimeInfo());
out.println("--------------");
out.println(getOsInfo());
out.println("--------------");
out.println(getUserInfo());
out.println("--------------");
out.println(getHostInfo());
out.println("--------------");
out.println(getRuntimeInfo());
out.println("--------------");
out.flush();
}
/**
* 输出到{@link StringBuilder}。
*
* @param builder {@link StringBuilder}对象
* @param caption 标题
* @param value 值
*/
protected static void append(StringBuilder builder, String caption, Object value) {
builder.append(caption).append(StrUtil.nullToDefault(Convert.toStr(value), "[n/a]")).append("\n");
}
}

156
hutool-extra/src/main/java/cn/hutool/extra/system/UserInfo.java Normal file
View File

@@ -0,0 +1,156 @@
package cn.hutool.extra.system;
import cn.hutool.core.util.StrUtil;
import java.io.File;
import java.io.Serializable;
/**
* 代表当前用户的信息。
*/
public class UserInfo implements Serializable{
private static final long serialVersionUID = 1L;
private final String USER_NAME;
private final String USER_HOME;
private final String USER_DIR;
private final String JAVA_IO_TMPDIR;
private final String USER_LANGUAGE;
private final String USER_COUNTRY;
public UserInfo(){
USER_NAME = fixPath(SystemUtil.get("user.name", false));
USER_HOME = fixPath(SystemUtil.get("user.home", false));
USER_DIR = fixPath(SystemUtil.get("user.dir", false));
JAVA_IO_TMPDIR = fixPath(SystemUtil.get("java.io.tmpdir", false));
USER_LANGUAGE = SystemUtil.get("user.language", false);
// JDK1.4 {@code user.country}，JDK1.2 {@code user.region}
String userCountry = SystemUtil.get("user.country", false);
if(null == userCountry){
userCountry = SystemUtil.get("user.country", false);
}
USER_COUNTRY = userCountry;
}
/**
* 取得当前登录用户的名字（取自系统属性：{@code user.name}）。
*
* <p>
* 例如：{@code "admin"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getName() {
return USER_NAME;
}
/**
* 取得当前登录用户的home目录（取自系统属性：{@code user.home}）。
*
* <p>
* 例如：{@code "/home/admin/"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getHomeDir() {
return USER_HOME;
}
/**
* 取得当前目录（取自系统属性：{@code user.dir}）。
*
* <p>
* 例如：{@code "/home/admin/working/"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getCurrentDir() {
return USER_DIR;
}
/**
* 取得临时目录（取自系统属性：{@code java.io.tmpdir}）。
*
* <p>
* 例如：{@code "/tmp/"}
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*
*/
public final String getTempDir() {
return JAVA_IO_TMPDIR;
}
/**
* 取得当前登录用户的语言设置（取自系统属性：{@code user.language}）。
*
* <p>
* 例如：{@code "zh"}、{@code "en"}等
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
public final String getLanguage() {
return USER_LANGUAGE;
}
/**
* 取得当前登录用户的国家或区域设置（取自系统属性：JDK1.4 {@code user.country}或JDK1.2 {@code user.region}）。
*
* <p>
* 例如：{@code "CN"}、{@code "US"}等
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
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();
}
/**
* 修正路径，包括：
*
* <ul>
* <li>1. 末尾补充 /</li>
* </ul>
* @param path 路径
* @return 修正后的路径
* @since 5.6.4
*/
private static String fixPath(String path){
return StrUtil.addSuffixIfNot(path, File.separator);
}
}

217
hutool-extra/src/main/java/cn/hutool/extra/system/oshi/CpuInfo.java Normal file
View File

@@ -0,0 +1,217 @@
package cn.hutool.extra.system.oshi;
import cn.hutool.core.util.NumberUtil;
import oshi.hardware.CentralProcessor;
import java.text.DecimalFormat;
/**
* <p>CPU相关信息</p>
*
* @author Dai Yuanchuan
**/
public class CpuInfo {
private static final DecimalFormat LOAD_FORMAT = new DecimalFormat("#.00");
/**
* CPU核心数
*/
private Integer cpuNum;
/**
* CPU总的使用率
*/
private double toTal;
/**
* CPU系统使用率
*/
private double sys;
/**
* CPU用户使用率
*/
private double user;
/**
* CPU当前等待率
*/
private double wait;
/**
* CPU当前空闲率
*/
private double free;
/**
* CPU型号信息
*/
private String cpuModel;
/**
* CPU型号信息
*/
private CpuTicks ticks;
/**
* 空构造
*/
public CpuInfo() {
}
/**
* 构造，等待时间为用于计算在一定时长内的CPU负载情况，如传入1000表示最近1秒的负载情况
*
* @param processor {@link CentralProcessor}
* @param waitingTime 设置等待时间，单位毫秒
*/
public CpuInfo(CentralProcessor processor, long waitingTime) {
init(processor, waitingTime);
}
/**
* 构造
*
* @param cpuNum CPU核心数
* @param toTal CPU总的使用率
* @param sys CPU系统使用率
* @param user CPU用户使用率
* @param wait CPU当前等待率
* @param free CPU当前空闲率
* @param cpuModel CPU型号信息
*/
public CpuInfo(Integer cpuNum, double toTal, double sys, double user, double wait, double free, String cpuModel) {
this.cpuNum = cpuNum;
this.toTal = toTal;
this.sys = sys;
this.user = user;
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 getUser() {
return user;
}
public void setUser(double user) {
this.user = user;
}
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;
}
public CpuTicks getTicks() {
return ticks;
}
public void setTicks(CpuTicks ticks) {
this.ticks = ticks;
}
/**
* 获取用户+系统的总的CPU使用率
*
* @return 总CPU使用率
*/
public double getUsed() {
return NumberUtil.sub(100, this.free);
}
@Override
public String toString() {
return "CpuInfo{" +
"CPU核心数=" + cpuNum +
", CPU总的使用率=" + toTal +
", CPU系统使用率=" + sys +
", CPU用户使用率=" + user +
", CPU当前等待率=" + wait +
", CPU当前空闲率=" + free +
", CPU利用率=" + getUsed() +
", CPU型号信息='" + cpuModel + '\'' +
'}';
}
/**
* 获取指定等待时间内系统CPU 系统使用率、用户使用率、利用率等等 相关信息
*
* @param processor {@link CentralProcessor}
* @param waitingTime 设置等待时间，单位毫秒
* @since 5.7.12
*/
private void init(CentralProcessor processor, long waitingTime) {
final CpuTicks ticks = new CpuTicks(processor, waitingTime);
this.ticks = ticks;
this.cpuNum = processor.getLogicalProcessorCount();
this.cpuModel = processor.toString();
final long totalCpu = ticks.totalCpu();
this.toTal = totalCpu;
this.sys = formatDouble(ticks.cSys, totalCpu);
this.user = formatDouble(ticks.user, totalCpu);
this.wait = formatDouble(ticks.ioWait, totalCpu);
this.free = formatDouble(ticks.idle, totalCpu);
}
/**
* 获取每个CPU核心的tick，计算方式为 100 * tick / totalCpu
*
* @param tick tick
* @param totalCpu CPU总数
* @return 平均每个CPU核心的tick
* @since 5.7.12
*/
private static double formatDouble(long tick, long totalCpu) {
if (0 == totalCpu) {
return 0D;
}
return Double.parseDouble(LOAD_FORMAT.format(tick <= 0 ? 0 : (100d * tick / totalCpu)));
}
}

145
hutool-extra/src/main/java/cn/hutool/extra/system/oshi/CpuTicks.java Normal file
View File

@@ -0,0 +1,145 @@
package cn.hutool.extra.system.oshi;
import oshi.hardware.CentralProcessor;
import oshi.util.Util;
/**
* CPU负载时间信息
*
* @author looly
* @since 5.7.12
*/
public class CpuTicks {
long idle;
long nice;
long irq;
long softIrq;
long steal;
long cSys;
long user;
long ioWait;
/**
* 构造，等待时间为用于计算在一定时长内的CPU负载情况，如传入1000表示最近1秒的负载情况
*
* @param processor {@link CentralProcessor}
* @param waitingTime 设置等待时间，单位毫秒
*/
public CpuTicks(CentralProcessor processor, long waitingTime) {
// CPU信息
final long[] prevTicks = processor.getSystemCpuLoadTicks();
// 这里必须要设置延迟
Util.sleep(waitingTime);
final long[] ticks = processor.getSystemCpuLoadTicks();
this.idle = tick(prevTicks, ticks, CentralProcessor.TickType.IDLE);
this.nice = tick(prevTicks, ticks, CentralProcessor.TickType.NICE);
this.irq = tick(prevTicks, ticks, CentralProcessor.TickType.IRQ);
this.softIrq = tick(prevTicks, ticks, CentralProcessor.TickType.SOFTIRQ);
this.steal = tick(prevTicks, ticks, CentralProcessor.TickType.STEAL);
this.cSys = tick(prevTicks, ticks, CentralProcessor.TickType.SYSTEM);
this.user = tick(prevTicks, ticks, CentralProcessor.TickType.USER);
this.ioWait = tick(prevTicks, ticks, CentralProcessor.TickType.IOWAIT);
}
public long getIdle() {
return idle;
}
public void setIdle(long idle) {
this.idle = idle;
}
public long getNice() {
return nice;
}
public void setNice(long nice) {
this.nice = nice;
}
public long getIrq() {
return irq;
}
public void setIrq(long irq) {
this.irq = irq;
}
public long getSoftIrq() {
return softIrq;
}
public void setSoftIrq(long softIrq) {
this.softIrq = softIrq;
}
public long getSteal() {
return steal;
}
public void setSteal(long steal) {
this.steal = steal;
}
public long getcSys() {
return cSys;
}
public void setcSys(long cSys) {
this.cSys = cSys;
}
public long getUser() {
return user;
}
public void setUser(long user) {
this.user = user;
}
public long getIoWait() {
return ioWait;
}
public void setIoWait(long ioWait) {
this.ioWait = ioWait;
}
/**
* 获取CPU总的使用率
*
* @return CPU总使用率
*/
public long totalCpu() {
return Math.max(user + nice + cSys + idle + ioWait + irq + softIrq + steal, 0);
}
@Override
public String toString() {
return "CpuTicks{" +
"idle=" + idle +
", nice=" + nice +
", irq=" + irq +
", softIrq=" + softIrq +
", steal=" + steal +
", cSys=" + cSys +
", user=" + user +
", ioWait=" + ioWait +
'}';
}
/**
* 获取一段时间内的CPU负载标记差
*
* @param prevTicks 开始的ticks
* @param ticks 结束的ticks
* @param tickType tick类型
* @return 标记差
* @since 5.7.12
*/
private static long tick(long[] prevTicks, long[] ticks, CentralProcessor.TickType tickType) {
return ticks[tickType.getIndex()] - prevTicks[tickType.getIndex()];
}
}

152
hutool-extra/src/main/java/cn/hutool/extra/system/oshi/OshiUtil.java Normal file
View File

@@ -0,0 +1,152 @@
package cn.hutool.extra.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.OSProcess;
import oshi.software.os.OperatingSystem;
import java.util.List;
/**
* Oshi库封装的工具类，通过此工具类，可获取系统、硬件相关信息
*
* <pre>
* 1、系统信息
* 2、硬件信息
* </pre>
* <p>
* 相关内容见：<a href="https://github.com/oshi/oshi">https://github.com/oshi/oshi</a>
*
* @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;
}
/**
* 获取当前进程信息{@link OSProcess}
*
* @return 进程信息 {@link OSProcess}
* @since 5.7.12
*/
public static OSProcess getCurrentProcess() {
return os.getProcess(os.getProcessId());
}
/**
* 获取硬件相关信息，包括内存、硬盘、网络设备、显示器、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 系统使用率、用户使用率、利用率等等 相关信息<br>
* 默认间隔1秒
*
* @return 系统 CPU 使用率 等信息
*/
public static CpuInfo getCpuInfo() {
return getCpuInfo(1000);
}
/**
* 获取系统CPU 系统使用率、用户使用率、利用率等等 相关信息
*
* @param waitingTime 设置等待时间，单位毫秒
* @return 系统 CPU 使用率 等信息
*/
public static CpuInfo getCpuInfo(long waitingTime) {
return new CpuInfo(OshiUtil.getProcessor(), waitingTime);
}
}

8
hutool-extra/src/main/java/cn/hutool/extra/system/oshi/package-info.java Normal file
View File

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

7
hutool-extra/src/main/java/cn/hutool/extra/system/package-info.java Normal file
View File

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

3
hutool-extra/src/main/resources/META-INF/services/cn.hutool.extra.aop.proxy.ProxyFactory Normal file
View File

@@ -0,0 +1,3 @@
cn.hutool.extra.aop.proxy.CglibProxyFactory
cn.hutool.extra.aop.proxy.SpringCglibProxyFactory
cn.hutool.extra.aop.proxy.JdkProxyFactory

87
hutool-extra/src/test/java/cn/hutool/extra/aop/AopTest.java Normal file
View File

@@ -0,0 +1,87 @@
package cn.hutool.extra.aop;
import cn.hutool.core.lang.Console;
import cn.hutool.extra.aop.aspects.TimeIntervalAspect;
import lombok.Data;
import org.junit.Assert;
import org.junit.Test;
/**
* AOP模块单元测试
*
* @author Looly
*/
public class AopTest {
@Test
public void aopTest() {
Animal cat = ProxyUtil.proxy(new Cat(), TimeIntervalAspect.class);
String result = cat.eat();
Assert.assertEquals("猫吃鱼", result);
cat.seize();
}
@Test
public void aopByAutoCglibTest() {
Dog dog = ProxyUtil.proxy(new Dog(), TimeIntervalAspect.class);
String result = dog.eat();
Assert.assertEquals("狗吃肉", result);
dog.seize();
}
interface Animal {
String eat();
void seize();
}
/**
* 有接口
*
* @author looly
*/
static class Cat implements Animal {
@Override
public String eat() {
return "猫吃鱼";
}
@Override
public void seize() {
Console.log("抓了条鱼");
}
}
/**
* 无接口
*
* @author looly
*/
static class Dog {
public String eat() {
return "狗吃肉";
}
public void seize() {
Console.log("抓了只鸡");
}
}
@Test
public void testCGLIBProxy() {
TagObj target = new TagObj();
//目标类设置标记
target.setTag("tag");
TagObj proxy = ProxyUtil.proxy(target, TimeIntervalAspect.class);
//代理类获取标记tag (断言错误)
Assert.assertEquals("tag", proxy.getTag());
}
@Data
public static class TagObj{
private String tag;
}
}

2
hutool-extra/src/test/java/cn/hutool/extra/qrcode/QrCodeUtilTest.java
View File

@@ -1,7 +1,7 @@
package cn.hutool.extra.qrcode;
import cn.hutool.core.codec.Base64;
import cn.hutool.core.img.ImgUtil;
import cn.hutool.swing.img.ImgUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.lang.Console;
import com.google.zxing.BarcodeFormat;

16
hutool-extra/src/test/java/cn/hutool/extra/system/OshiPrintTest.java Normal file
View File

@@ -0,0 +1,16 @@
package cn.hutool.extra.system;
import cn.hutool.core.lang.Console;
import cn.hutool.extra.system.oshi.OshiUtil;
import org.junit.Ignore;
import org.junit.Test;
@Ignore
public class OshiPrintTest {
@Test
@Ignore
public void printCpuInfo(){
Console.log(OshiUtil.getCpuInfo());
}
}

41
hutool-extra/src/test/java/cn/hutool/extra/system/OshiTest.java Normal file
View File

@@ -0,0 +1,41 @@
package cn.hutool.extra.system;
import cn.hutool.core.lang.Console;
import cn.hutool.extra.system.oshi.CpuInfo;
import cn.hutool.extra.system.oshi.OshiUtil;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import oshi.software.os.OSProcess;
/**
* 测试参考：<a href="https://github.com/oshi/oshi/blob/master/oshi-core/src/test/java/oshi/SystemInfoTest.java">https://github.com/oshi/oshi/blob/master/oshi-core/src/test/java/oshi/SystemInfoTest.java</a>
*/
public class OshiTest {
@Test
public void getMemoryTest() {
long total = OshiUtil.getMemory().getTotal();
Assert.assertTrue(total > 0);
}
@Test
public void getCupInfo() {
CpuInfo cpuInfo = OshiUtil.getCpuInfo();
Assert.assertNotNull(cpuInfo);
}
@Test
public void getCurrentProcessTest() {
final OSProcess currentProcess = OshiUtil.getCurrentProcess();
Assert.assertEquals("java", currentProcess.getName());
}
@Test
@Ignore
public void getUsedTest() {
while (true) {
Console.log(OshiUtil.getCpuInfo().getUsed());
}
}
}

53
hutool-extra/src/test/java/cn/hutool/extra/system/SystemUtilTest.java Normal file
View File

@@ -0,0 +1,53 @@
package cn.hutool.extra.system;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import java.io.File;
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 getJavaRuntimeInfoTest() {
JavaRuntimeInfo info = SystemUtil.getJavaRuntimeInfo();
Assert.assertNotNull(info);
}
@Test
public void getOsInfoTest() {
OsInfo osInfo = SystemUtil.getOsInfo();
Assert.assertNotNull(osInfo);
}
@Test
public void getHostInfo() {
HostInfo hostInfo = SystemUtil.getHostInfo();
Assert.assertNotNull(hostInfo);
}
@Test
public void getUserInfoTest(){
// https://gitee.com/dromara/hutool/issues/I3NM39
final UserInfo userInfo = SystemUtil.getUserInfo();
Assert.assertTrue(userInfo.getTempDir().endsWith(File.separator));
}
}