Java读取系统硬件信息

集合了网上的Java读取系统硬件信息的可用代码,Windows上使用脚本去读取,linux上使用命令或者脚本读取,但linux中存在权限问题!

import java.io.BufferedReader;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.swing.LookAndFeel;

import org.apache.log4j.Logger;

public class HardWareUtils {
private static Logger logger = Logger.getLogger(HardWareUtils.class);
private static String OSName =System.getProperty(“os.name”).toLowerCase();
public static List listResult = new ArrayList();
public HardWareUtils() {
logger.info(“——当前系统版本—–:”+OSName);
}
/**
* 获取当前操作系统名称
*/
public static String getOSName() {
return OSName;
}

// 主板序列号 windows
private static String getMainBordId_windows() {
    String result = "";
    try {
        File file = File.createTempFile("realhowto", ".vbs");
        file.deleteOnExit();
        FileWriter fw = new java.io.FileWriter(file);

        String vbs = "Set objWMIService = GetObject(\"winmgmts:\\\\.\\root\\cimv2\")\n"
                + "Set colItems = objWMIService.ExecQuery _ \n" + "   (\"Select * from Win32_BaseBoard\") \n"
                + "For Each objItem in colItems \n" + "    Wscript.Echo objItem.SerialNumber \n"
                + "    exit for  ' do the first cpu only! \n" + "Next \n";

        fw.write(vbs);
        fw.close();
        Process p = Runtime.getRuntime().exec("cscript //NoLogo " + file.getPath());
        BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line;
        while ((line = input.readLine()) != null) {
            result += line;
        }
        input.close();
    } catch (Exception e) {
        logger.error("获取主板信息错误", e);
    }
    return result.trim();
}

// 主板序列号 linux
private static String getMainBordId_linux() {

    String result = "";
    String maniBord_cmd = "dmidecode | grep 'Serial Number' | awk '{print $3}' | tail -1";
    Process p;
    try {
        p = Runtime.getRuntime().exec(new String[] { "sh", "-c", maniBord_cmd });// 管道
        BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            result += line;
            break;
        }
        br.close();
    } catch (IOException e) {
        logger.error("获取主板信息错误", e);
    }
    return result;
}

/**
 * 获取mac地址 (如果Linux下有eth0这个网卡)
 */
private static String getMAC_linux() {
    String mac = null;
    BufferedReader bufferedReader = null;
    Process process = null;
    try {
        // linux下的命令,一般取eth0作为本地主网卡
        process = Runtime.getRuntime().exec("ifconfig eth0");
        // 显示信息中包含有mac地址信息
        bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line = null;
        int index = -1;
        while ((line = bufferedReader.readLine()) != null) {
            // 寻找标示字符串[hwaddr]
            index = line.toLowerCase().indexOf("hwaddr");
            if (index >= 0) {// 找到了
                // 取出mac地址并去除2边空格
                mac = line.substring(index + "hwaddr".length() + 1).trim();
                break;
            }
        }
    } catch (IOException e) {
        logger.error("获取mac信息错误", e);
    } finally {
        try {
            if (bufferedReader != null) {
                bufferedReader.close();
            }
        } catch (IOException e1) {
            logger.error("获取mac信息错误", e1);
        }
        bufferedReader = null;
        process = null;
    }
    return mac;
}

/**
* 获取Linux的mac
*/
private static String getMAC_linuxs() {

    String mac = null;
    BufferedReader bufferedReader = null;
    Process process = null;
    try {
        // linux下的命令,一般取eth0作为本地主网卡
        process = Runtime.getRuntime().exec("ifconfig");
        // 显示信息中包含有mac地址信息
        bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line = null;
        int index = -1;
         while ((line = bufferedReader.readLine()) != null) 
         {
             Pattern pat = Pattern.compile("\\b\\w+:\\w+:\\w+:\\w+:\\w+:\\w+\\b");
             Matcher mat= pat.matcher(line);
             if(mat.find())
             {
                 mac=mat.group(0);
             }
         }

    } catch (IOException e) {
        logger.error("获取mac信息错误", e);
    } finally {
        try {
            if (bufferedReader != null) {
                bufferedReader.close();
            }
        } catch (IOException e1) {
            logger.error("获取mac信息错误", e1);
        }
        bufferedReader = null;
        process = null;
    }
    return mac;
}

/**
 * 获取widnows网卡的mac地址.
 */
private static String getMAC_windows() {
    InetAddress ip = null;
    NetworkInterface ni = null;
    List<String> macList = new ArrayList<String>();
    try {
        Enumeration<NetworkInterface> netInterfaces = (Enumeration<NetworkInterface>) NetworkInterface
                .getNetworkInterfaces();
        while (netInterfaces.hasMoreElements()) {
            ni = (NetworkInterface) netInterfaces.nextElement();
            // ----------特定情况,可以考虑用ni.getName判断
            // 遍历所有ip
            Enumeration<InetAddress> ips = ni.getInetAddresses();
            while (ips.hasMoreElements()) {
                ip = (InetAddress) ips.nextElement();
                if (!ip.isLoopbackAddress() // 非127.0.0.1
                        && ip.getHostAddress().matches("(\\d{1,3}\\.){3}\\d{1,3}")) {
                    macList.add(getMacFromBytes(ni.getHardwareAddress()));
                }
            }
        }
    } catch (Exception e) {
        logger.error("获取mac错误", e);
    }
    if (macList.size() > 0) {
        return macList.get(0);
    } else {
        return "";
    }

}

private static String getMacFromBytes(byte[] bytes) {
    StringBuffer mac = new StringBuffer();
    byte currentByte;
    boolean first = false;
    for (byte b : bytes) {
        if (first) {
            mac.append("-");
        }
        currentByte = (byte) ((b & 240) >> 4);
        mac.append(Integer.toHexString(currentByte));
        currentByte = (byte) (b & 15);
        mac.append(Integer.toHexString(currentByte));
        first = true;
    }
    return mac.toString().toUpperCase();
}

/**
 * 获取CPU序列号 Windows
 * 
 * @return
 */
private static String getCPUID_Windows() {
    String result = "";
    try {
        File file = File.createTempFile("tmp", ".vbs");
        file.deleteOnExit();
        FileWriter fw = new java.io.FileWriter(file);
        String vbs = "Set objWMIService = GetObject(\"winmgmts:\\\\.\\root\\cimv2\")\n"
                + "Set colItems = objWMIService.ExecQuery _ \n" + "   (\"Select * from Win32_Processor\") \n"
                + "For Each objItem in colItems \n" + "    Wscript.Echo objItem.ProcessorId \n"
                + "    exit for  ' do the first cpu only! \n" + "Next \n";

        fw.write(vbs);
        fw.close();
        Process p = Runtime.getRuntime().exec("cscript //NoLogo " + file.getPath());
        BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line;
        while ((line = input.readLine()) != null) {
            result += line;
        }
        input.close();
        file.delete();
    } catch (Exception e) {
        logger.error("获取windows cpu信息错误", e);
    }
    return result.trim();
}

/**
 * 获取CPU序列号 linux
 * 
 * @return
 */
private static String getCPUID_linux() throws InterruptedException {
    String result = "";
    String CPU_ID_CMD = "dmidecode";
    BufferedReader bufferedReader = null;
    Process p = null;
    try {
        p = Runtime.getRuntime().exec(new String[] { "sh", "-c", CPU_ID_CMD });// 管道
        bufferedReader = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line = null;
        int index = -1;
        while ((line = bufferedReader.readLine()) != null) {
            // 寻找标示字符串[hwaddr]
            index = line.toLowerCase().indexOf("uuid");
            if (index >= 0) {// 找到了
                // 取出mac地址并去除2边空格
                result = line.substring(index + "uuid".length() + 1).trim();
                break;
            }
        }

    } catch (IOException e) {
        logger.error("获取liunx cpu信息错误", e);
    }
    return result.trim();
}
/**
 * 获取硬盘序列号(该方法获取的是 盘符的逻辑序列号,并不是硬盘本身的序列号)硬盘驱动器分区 如C,D
 * 硬盘序列号还在研究中
 * @param drive 盘符
 * @return
 */
private static String getHardDiskSN_Windows(String drive) {
    String result = "";
    try {
        File file = File.createTempFile("realhowto", ".vbs");
        file.deleteOnExit();
        FileWriter fw = new java.io.FileWriter(file);

        String vbs = "Set objFSO = CreateObject(\"Scripting.FileSystemObject\")\n"
                + "Set colDrives = objFSO.Drives\n"
                + "Set objDrive = colDrives.item(\""
                + drive
                + "\")\n"
                + "Wscript.Echo objDrive.SerialNumber"; // see note
        fw.write(vbs);
        fw.close();
        String path = file.getPath().replace("%20", " ");
        Process p = Runtime.getRuntime().exec(
                "cscript //NoLogo " + path);
        BufferedReader input = new BufferedReader(new InputStreamReader(
                p.getInputStream()));
        String line;
        while ((line = input.readLine()) != null) {
            result += line;
        }
        input.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result.trim();
}
private static String getBiosSN_Windows() {
    String result = "";
    try {
        Runtime rt = Runtime.getRuntime();
        Process p = rt.exec("cmd.exe /c wmic bios get serialnumber");
        InputStream in = p.getInputStream();
        BufferedReader input = new BufferedReader(new InputStreamReader(
                p.getInputStream()));
        String line;
        while ((line = input.readLine()) != null) {
            result += line;
        }
        input.close();
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException();
    }
    return result.split("SerialNumber")[1].trim().toString();
}
/***************************linux下 通过执行shell读取 *********************************/
/**
 * Java执行shell脚本入口
 * @param shellName 脚本文件名
 * @throws Exception
 */
public static void service(String shellName) throws Exception{
    String shellDir = "";
    String shellPath = "";
    try {
        //获取脚本所在的目录
        String configFilePath = Thread.currentThread().getContextClassLoader().getResource("jdbc.properties").getPath();
        File f = new File(configFilePath);
        shellDir = f.getParent().split("java")[0];
        logger.info("shell dir = " + shellDir);

        //拼接完整的脚本目录
        shellPath = shellDir + "java/solution/Shell/" + shellName;
        logger.info("shell path = " + shellPath);

        //执行脚本
        callScript(shellPath);

    } catch (Exception e) {
        logger.error("ShellExcutor异常" + e.getMessage(), e);
        throw e;
    }
}

/**
 * 脚本文件具体执行及脚本执行过程探测
 * @param script 脚本文件绝对路径
 * @throws Exception
 */
private static void callScript(String script) throws Exception{
    try {
        String cmd = "sh " + script;
        try {
            //解决脚本没有执行权限
            ProcessBuilder builder = new ProcessBuilder("/bin/chmod", "755",script);
            Process chmodprocess = builder.start();
            int w=chmodprocess.waitFor();
            if(w!=0)
            {
                logger.error("------callScript 开启脚本权限不成功!");
                BufferedReader erro_br = new BufferedReader(new InputStreamReader(chmodprocess.getErrorStream()));;
                 String erroResult = "";
                 String l="";
                 while((l = erro_br.readLine()) != null){
                     erroResult+=l+"\n";
                  }
                 if(erroResult.length()>0)
                     logger.error("-----callScript erro"+erroResult);
                 erro_br.close();
            }
            chmodprocess.destroy();
        } catch (Exception e) {
            // TODO: handle exception
        }

// //启动独立线程等待process执行完成
// CommandWaitForThread commandThread = new CommandWaitForThread(cmd);
// commandThread.start();
//
// while (!commandThread.isFinish()) {
// logger.info(“shell ” + script + ” 还未执行完毕,10s后重新探测”);
// Thread.sleep(10000);
// }
//
// //检查脚本执行结果状态码
// if(commandThread.getExitValue() != 0){
// throw new Exception(“shell ” + script + “执行失败,exitValue = ” + commandThread.getExitValue());
// }
// logger.info(“shell ” + script + “执行成功,exitValue = ” + commandThread.getExitValue());
logger.info(“——callScript cmd job : ” + cmd);
Scanner input = null;
Process process = null;
try {
//整个命令作为sh的参数进行执行,以便执行重定向和管道命令,否则管道命令会被当成参数执行,得到错误结果
//process = Runtime.getRuntime().exec(new String[] { “/bin/sh”, “-c”, cmd });
process = Runtime.getRuntime().exec(cmd);
try {
//等待命令执行完成
//process.waitFor(10, TimeUnit.SECONDS);
int waitfor = process.waitFor();
if(waitfor!=0)
{
logger.error(“——callScript 执行命令不成功!”);
BufferedReader erro_br = new BufferedReader(new InputStreamReader(process.getErrorStream()));;
String erroResult = “”;
String l=””;
while((l = erro_br.readLine()) != null){
erroResult+=l+”\n”;
}
if(erroResult.length()>0)
logger.error(“—–callScript erro”+erroResult);
erro_br.close();
}

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = br.readLine()) != null) {
                listResult.add(line);
            }

            br.close();
        } finally {
            if (input != null) {
                input.close();
            }
            if (process != null) {
                process.destroy();
            }
        }
    }
    catch (Exception e){
        throw new Exception("执行脚本发生异常,脚本路径" + script, e);
    }
}
/**
 * 脚本函数执行线程
 */
private static class CommandWaitForThread extends Thread {

    private String cmd;
    private boolean finish = false;
    private int exitValue = -1;

    public CommandWaitForThread(String cmd) {
        this.cmd = cmd;
    }

    public void run(){
        try {
            //执行脚本并等待脚本执行完成
            Process process = Runtime.getRuntime().exec(cmd);

            //写出脚本执行中的过程信息
            BufferedReader infoInput = new BufferedReader(new InputStreamReader(process.getInputStream()));
            BufferedReader errorInput = new BufferedReader(new InputStreamReader(process.getErrorStream()));
            String line = "";
            while ((line = infoInput.readLine()) != null) {
                logger.info(line);
            }
            while ((line = errorInput.readLine()) != null) {
                logger.error(line);
            }
            infoInput.close();
            errorInput.close();

            //阻塞执行线程直至脚本执行完成后返回
            this.exitValue = process.waitFor();
        } catch (Throwable e) {
            logger.error("CommandWaitForThread accure exception,shell " + cmd, e);
            exitValue = 110;
        } finally {
            finish = true;
        }
    }

    public boolean isFinish() {
        return finish;
    }

    public void setFinish(boolean finish) {
        this.finish = finish;
    }

    public int getExitValue() {
        return exitValue;
    }
}

/**

  • 通过硬件名获取硬件信息
    */
    private static String getInfoByName(String name) {
    String infoString=””;
    try {
    if(listResult.size()==0)
    service(“HardWareInfo.sh”);
    for(String line:listResult)
    {
    if(line.contains(name))
    {
    String[] r= line.replace(name+”:”, “”).trim().split(“:”);
    if(r.length>1)
    {
    if(r.length==2)
    return r[1];
    else {
    //针对这种情况 00:16:3e:0a:6d:70
    String rString=””;
    for (int i = 0; i <r.length; i++) {
    rString+=”:”+r[i];
    }
    return rString.split(“:”,2)[1];
    }
    } else return r[0]; }}} catch (Exception e) { // TODO: handle exception logger.error("------getInfoByName "+name+":"+e.getMessage(),e); throw new RuntimeException(); } return infoString; }
    /linux下 通过命令读取 / private static String executeLinuxCmd(String cmd) throws IOException {
    logger.info(“——executeLinuxCmd got cmd job : ” + cmd);
    Scanner input = null;
    String result = “”;
    Process process = null;
    try {
    //整个命令作为sh的参数进行执行,以便执行重定向和管道命令,否则管道命令会被当成参数执行,得到错误结果
    process = Runtime.getRuntime().exec(new String[] { “/bin/sh”, “-c”, cmd });
    try {
    //等待命令执行完成
    //process.waitFor(10, TimeUnit.SECONDS);
    int waitfor = process.waitFor();
    if(waitfor!=0)
    logger.error(“——executeLinuxCmd 执行命令不成功!”);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    // InputStream is = process.getInputStream();
    // input = new Scanner(is);
    // while (input.hasNextLine()) {
    // result += input.nextLine() + “\n”;
    // }
    BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream()));
    String line;
    while ((line = br.readLine()) != null) {
    result += line;
    break;
    }
    br = new BufferedReader(new InputStreamReader(process.getErrorStream()));;
    String erroResult = “”;
    while((line = br.readLine()) != null){
    erroResult+=line+”\n”;
    }
    if(erroResult.length()>0)
    logger.error(“—–executeLinuxCmd erro”+erroResult);
    br.close();
    //result = cmd + “\n” + result; //加上命令本身,打印出来
    } finally {
    if (input != null) {
    input.close();
    }
    if (process != null) {
    process.destroy();
    }
    }
    return result; } /**
    • @param cmd 命令语句
    /整合/
    /**
    • 获取CPU序列号
      • @return
        */
        public static String getCPUID() {
        logger.info(“——当前系统版本—–:”+OSName);
        try {
        if (OSName!=null&&OSName.indexOf(“linux”)>-1) { //return getCPUID_linux2(); return getInfoByName("cpuid"); } else {
        return getCPUID_Windows();
        }
        } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        throw new RuntimeException();
        }
    }
    /**
    • 获取主板序列号
      • @return
        */
        public static String getMainBordId() {
        try {
        if (OSName!=null&&OSName.indexOf(“linux”)>-1) { //return getMainBordId_linux2(); return getInfoByName("mainborid"); } else {
        return getMainBordId_windows();
        }
        } catch (Exception e) {
        // TODO Auto-generated catch block
        logger.error(“——getMainBordId——:”+e.getMessage());
        throw new RuntimeException();
        }
    }
    /**
    • linux 硬盘序列号
    • @return
      */
      public static String getHardDiskSN() {
      try {
      if (OSName!=null&&OSName.indexOf(“linux”)>-1) { //return getHardDiskSN_Linux(); return getInfoByName("harddisksn"); } else { return getHardDiskSN_Windows("C"); } } catch (Exception e) { // TODO Auto-generated catch block logger.error("------getHardDiskSN------:"+e.getMessage()); throw new RuntimeException(); }
    }
    /**
    • 获取bios列号
    • @return
      */
      public static String getBiosSN() {
      try {
      if (OSName!=null&&OSName.indexOf(“linux”)>-1) { //return getBiosVersion_Linux(); return getInfoByName("biossn"); } else { return getBiosSN_Windows();
      }
      } catch (Exception e) {
      logger.error(“——getBiosSN——:”+e.getMessage());
      throw new RuntimeException();
      }
      }
    //硬盘驱动???? /**
    • 获取widnows网卡的mac地址.
      */
      public static String getMAC() {
      try {
      if (OSName!=null&&OSName.indexOf(“linux”)>-1) { //return getMAC_linuxs(); return getInfoByName("mac"); } else { return getMAC_windows();
      }
      } catch (Exception e) {
      logger.error(“——getMAC——:”+e.getMessage());
      throw new RuntimeException();
      }
      }

}

转载自:https://blog.csdn.net/u011323200/article/details/104313700

Java获取当前系统类型

Java获取当前系统类型完整版

系统枚举类:

public enum EPlatform {
    Any("any"),
    Linux("Linux"),
    Mac_OS("Mac OS"),
    Mac_OS_X("Mac OS X"),
    Windows("Windows"),
    OS2("OS/2"),
    Solaris("Solaris"),
    SunOS("SunOS"),
    MPEiX("MPE/iX"),
    HP_UX("HP-UX"),
    AIX("AIX"),
    OS390("OS/390"),
    FreeBSD("FreeBSD"),
    Irix("Irix"),
    Digital_Unix("Digital Unix"),
    NetWare_411("NetWare"),
    OSF1("OSF1"),
    OpenVMS("OpenVMS"),
    Others("Others");

    private EPlatform(String desc) {
        this.description = desc;
    }

    public String toString() {
        return description;
    }

    private String description;
}

获取系统类型类:

public class OSinfo {

    private static String OS = System.getProperty("os.name").toLowerCase();

    private static OSinfo _instance = new OSinfo();

    private EPlatform platform;

    private OSinfo(){}

    public static boolean isLinux(){
        return OS.indexOf("linux")>=0;
    }

    public static boolean isMacOS(){
        return OS.indexOf("mac")>=0&&OS.indexOf("os")>0&&OS.indexOf("x")<0;
    }

    public static boolean isMacOSX(){
        return OS.indexOf("mac")>=0&&OS.indexOf("os")>0&&OS.indexOf("x")>0;
    }

    public static boolean isWindows(){
        return OS.indexOf("windows")>=0;
    }

    public static boolean isOS2(){
        return OS.indexOf("os/2")>=0;
    }

    public static boolean isSolaris(){
        return OS.indexOf("solaris")>=0;
    }

    public static boolean isSunOS(){
        return OS.indexOf("sunos")>=0;
    }

    public static boolean isMPEiX(){
        return OS.indexOf("mpe/ix")>=0;
    }

    public static boolean isHPUX(){
        return OS.indexOf("hp-ux")>=0;
    }

    public static boolean isAix(){
        return OS.indexOf("aix")>=0;
    }

    public static boolean isOS390(){
        return OS.indexOf("os/390")>=0;
    }

    public static boolean isFreeBSD(){
        return OS.indexOf("freebsd")>=0;
    }

    public static boolean isIrix(){
        return OS.indexOf("irix")>=0;
    }

    public static boolean isDigitalUnix(){
        return OS.indexOf("digital")>=0&&OS.indexOf("unix")>0;
    }

    public static boolean isNetWare(){
        return OS.indexOf("netware")>=0;
    }

    public static boolean isOSF1(){
        return OS.indexOf("osf1")>=0;
    }

    public static boolean isOpenVMS(){
        return OS.indexOf("openvms")>=0;
    }

    /**
     * 获取操作系统名字
     * @return 操作系统名
     */
    public static EPlatform getOSname(){
        if(isAix()){
            _instance.platform = EPlatform.AIX;
        }else if (isDigitalUnix()) {
            _instance.platform = EPlatform.Digital_Unix;
        }else if (isFreeBSD()) {
            _instance.platform = EPlatform.FreeBSD;
        }else if (isHPUX()) {
            _instance.platform = EPlatform.HP_UX;
        }else if (isIrix()) {
            _instance.platform = EPlatform.Irix;
        }else if (isLinux()) {
            _instance.platform = EPlatform.Linux;
        }else if (isMacOS()) {
            _instance.platform = EPlatform.Mac_OS;
        }else if (isMacOSX()) {
            _instance.platform = EPlatform.Mac_OS_X;
        }else if (isMPEiX()) {
            _instance.platform = EPlatform.MPEiX;
        }else if (isNetWare()) {
            _instance.platform = EPlatform.NetWare_411;
        }else if (isOpenVMS()) {
            _instance.platform = EPlatform.OpenVMS;
        }else if (isOS2()) {
            _instance.platform = EPlatform.OS2;
        }else if (isOS390()) {
            _instance.platform = EPlatform.OS390;
        }else if (isOSF1()) {
            _instance.platform = EPlatform.OSF1;
        }else if (isSolaris()) {
            _instance.platform = EPlatform.Solaris;
        }else if (isSunOS()) {
            _instance.platform = EPlatform.SunOS;
        }else if (isWindows()) {
            _instance.platform = EPlatform.Windows;
        }else{
            _instance.platform = EPlatform.Others;
        }
        return _instance.platform;
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(OSinfo.getOSname());// 获取系统类型
        System.out.println(OSinfo.isWindows());// 判断是否为windows系统 
    }

}

测试结果:

在这里插入图片描述

转载自:https://blog.csdn.net/fangchao2011/article/details/88785637

如何写周报

写周报之前需要认清

周报意味着总结
  • 写清楚过去一周做了什么,尤其是
  • 过去一周,在核心业务上做了什么
  • 周报的重点在于描述,描述你深处的环境,而描述需要:思考
周报意味着思考
  • 你需要有一个完整的思考:业务,技术,团队
  • 时间线上的思考:过去,现在,将来
  • 问题线上的思考:问题,快速/简单解决,完整解决
  • 优先级上的思考:有限的资源如何应对无限的事情?时间差
你的思考范围
  • 业务的思考

公司/团队整体面对的业务:应该是什么样的,现在是什么样的,差距在哪里

合作方/业务方/使用方是什么样的,他们提出了什么样的要求,面临什么样的问题

竞对是什么样的,与我们相比有什么优势,如何快速追平

兄弟部门是什么样的,他们到了什么阶段,遇到了什么问题

  • 技术的思考

我们的系统是否具有充分的健壮性和扩展性

瓶颈在哪里,性能瓶颈还是功能瓶颈

排查问题是否足够迅速,覆盖场景是否足够全面

系统的各个层面的治理是否充分

  • 团队的思考

团队现在遇到的问题或者困境是什么,如何解决

团队是否积极向上,是否具备自我良性循环的机制?

  • 完整的思考

考虑方方面面

a. 覆盖:业务,技术,团队

b. 覆盖:正向,逆向

不光要考虑做一件事情会怎么样,还要考虑不做会怎么样

c. 覆盖:公司决策,团队分解,个人执行

开始写周报

汇报周期
  • 一般来说是一周,不然为什么要叫周报?
现阶段工作的核心指标
  • 紧跟OKR,是OKR的延伸或者分解

是否可以超出OKR的范围?

当然可以!但是,这往往说明OKR需要调整,最终要回归到OKR

  • 跟OKR一样,核心工作是大事,不是鸡毛蒜皮的小事
  • 用数字衡量!有时间约束!有场景范围!缺一不可
核心指标本周完成进度
  • 在核心指标上的进度
  • 有里程碑,有衡量方法之后的进度,不能是拍脑袋。拍脑袋的进度写在“本周完成工作事项”里面
  • 谨慎填写,可以没有核心进度
本周完成工作事项
  • 可以写的随意一些,日常的工作都可以写上来
  • 大部分时间,主要在写这个
下周工作计划
  • 很重要,这才是周报的精髓:自我的承诺
  • 核心进度没有,惭愧不惭愧?本周完成工作没几项,丢人不丢人?请务必向前看,做好下周的计划
  • 自我承诺要尽量完成,所以不要承诺很简单的事情,因为没有意义;也不要承诺和很难的事情,因为完成不了
遇到的问题
  • 个人遇到的问题,困惑;如果有解决方案,那么同时也列出来;如果没有,也不妨写出来
  • 团队遇到的问题,同样的,最好有解决方案

几个关键字

完整
  • 完整性是一切的基石
  • 换一种说法是:保持开阔的视野和头脑
量化
  • 分解和量化,是必要的步骤
思考
  • 思考是一切的核心
  • 行动步骤是思考出来的,不是别人指挥和命令的
承诺
  • 计划和承诺是实现的方式