Java中的Wifi信息

如何在Java中获取附近wifi路由器的MAC地址、SSID和信号强度？最好是系统独立的，如果不是Windows。

要获取Mac地址，需要查询ARP缓存。这不是琐碎的和依赖于系统的

---

更多信息：

我真的不认为有任何独立于系统的方法可以从Java中了解这一点

---

在Windows上，您应该能够使用s来实现这一点，但您很可能需要一些JNI来访问它们。

我知道这是一个非常老的问题，但您可以在Windows中使用netsh命令，使用java提取wifi信息。这是我写的一篇关于这个的博客

Java不允许我们直接获取这些低级信息。因此，我在java内部运行命令行和netsh命令，以提取这些信息。下面是我为此实现的类。请注意，这仅适用于windows

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Rajind
 */
public class Extractor {

    public static String NOT_SET = "NOT_SET";

    public static boolean isEnabled(){
        try {
            String state;
            ProcessBuilder builder = new ProcessBuilder(
                    "cmd.exe", "/c", "netsh interface show interface \"Wi-Fi\"");
            builder.redirectErrorStream(true);
            Process p = builder.start();
            BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            while ((line = r.readLine())!=null) {
                //line = r.readLine();
                if (line.contains("Administrative state")){
                    state = line.split("\\s+")[3];
                    //System.out.println(state);
                    state = state.toLowerCase();
                    if(state.equals("enabled")){
                        return true;
                    }else{
                        return false;
                    }
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(Extractor.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }

    public static boolean isConnected(){
        try {
            String state;
            ProcessBuilder builder = new ProcessBuilder(
                    "cmd.exe", "/c", "netsh interface show interface \"Wi-Fi\"");
            builder.redirectErrorStream(true);
            Process p = builder.start();
            BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            while ((line = r.readLine())!=null) {
                //line = r.readLine();
                if (line.contains("Connect state")){
                    state = line.split("\\s+")[3];
//                    System.out.println(state);
                    state = state.toLowerCase();
                    if(state.equals("connected")){
                        return true;
                    }else{
                        return false;
                    }
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(Extractor.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }

    public static String getConnectedSSID(){
        String ssid = NOT_SET;
        try {
            ProcessBuilder builder = new ProcessBuilder(
                    "cmd.exe", "/c", "netsh wlan show interfaces");
            builder.redirectErrorStream(true);
            Process p = builder.start();
            BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            while ((line = r.readLine())!=null) {
                //line = r.readLine();
                if (line.contains("SSID")){
                    ssid = line.split("\\s+")[3];
//                    System.out.println(ssid);
                    return ssid;
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(Extractor.class.getName()).log(Level.SEVERE, null, ex);
        }
        return ssid;
    }

    public static String[] getListOfSSIDs(){
        String [] ssid_List;
        String ssid;
        ArrayList<String> arr = new ArrayList<>();
        try {
            ProcessBuilder builder = new ProcessBuilder(
                    "cmd.exe", "/c", "netsh wlan show networks");
            builder.redirectErrorStream(true);
            Process p = builder.start();
            BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            while ((line = r.readLine())!=null) {
                //line = r.readLine();
                if (line.contains("SSID")){
                    ssid = line.split("\\s+")[3];
                    //System.out.println(ssid);
                    arr.add(ssid);
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(Extractor.class.getName()).log(Level.SEVERE, null, ex);
        }
        ssid_List = new String[arr.size()];
        arr.toArray(ssid_List);
        return ssid_List;
    }

    public static String getIP(){
        String ip = NOT_SET; 
        try {
            ProcessBuilder builder = new ProcessBuilder(
                    "cmd.exe", "/c", "netsh interface ip show addresses \"Wi-Fi\"");
            builder.redirectErrorStream(true);
            Process p = builder.start();
            BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            while ((line = r.readLine())!=null) {
                //line = r.readLine();
                if (line.contains("IP Address")){
                    ip = line.split("\\s+")[3];
                    //System.out.println(ip);
                    return ip;
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(Extractor.class.getName()).log(Level.SEVERE, null, ex);
        }
        return ip;
    }

    public static String getSubnetMask(){
        String sb = NOT_SET; 
        try {
            ProcessBuilder builder = new ProcessBuilder(
                    "cmd.exe", "/c", "netsh interface ip show addresses \"Wi-Fi\"");
            builder.redirectErrorStream(true);
            Process p = builder.start();
            BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            while ((line = r.readLine())!=null) {
                //line = r.readLine();
                if (line.contains("Subnet Prefix")){
                    sb = line.split("\\s+")[5];
                    sb = sb.substring(0, sb.length() - 1);
                    //System.out.println(sb);
                    return sb;
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(Extractor.class.getName()).log(Level.SEVERE, null, ex);
        }
        return sb;
    }

    public static String getBroadcast(){
        String subnetMask = getSubnetMask();
        String ip = getIP();

        String []arrSubnetMask = subnetMask.split("\\.");
        String []arrIP = ip.split("\\.");
        int []networkAddress = new int[4];
        int [] broadcastAddress = new int[4];

        String broadcast = "";

        for(int i=0; i< 4; i++){
            networkAddress[i] =  Integer.parseInt(arrIP[i]) & Integer.parseInt(arrSubnetMask[i]);
            //System.out.println(networkAddress[i]);
        }

        for(int i=0; i< 4; i++){
            //broadcastAddress[i] =  networkAddress[i] | (~Integer.parseInt(arrSubnetMask[i]) & 0xff);
            //System.out.println(broadcastAddress[i]);
            broadcast = broadcast + "." + (networkAddress[i] | (~Integer.parseInt(arrSubnetMask[i]) & 0xff));
        }

//        System.out.println(broadcast.substring(1));

        //mask AND ip you get network address
        //Invert Mask OR Network Address you get broadcast

        return broadcast.substring(1);
    }
}

导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStreamReader；
导入java.util.ArrayList；
导入java.util.logging.Level；
导入java.util.logging.Logger；
/**
*
*@作者拉金德
*/
公共类提取器{
公共静态字符串NOT_SET=“NOT_SET”；
公共静态布尔值isEnabled（）{
试一试{
字符串状态；
ProcessBuilder=新的ProcessBuilder(
“cmd.exe”、“/c”、“netsh界面显示界面\“Wi-Fi\”）；
builder.redirectErrorStream（true）；
进程p=builder.start（）；
BufferedReader r=新的BufferedReader（新的InputStreamReader（p.getInputStream（））；
弦线；
而（（line=r.readLine（））！=null）{
//line=r.readLine（）；
if（第行包含（“管理状态”））{
state=line.split（“\\s+”）[3]；
//System.out.println（状态）；
state=state.toLowerCase（）；
if（state.equals（“enabled”））{
返回true；
}否则{
返回false；
}
}
}
}捕获（IOEX异常）{
Logger.getLogger（Extractor.class.getName（））.log（Level.SEVERE，null，ex）；
}
返回false；
}
公共静态布尔值未连接（）{
试一试{
字符串状态；
ProcessBuilder=新的ProcessBuilder(
“cmd.exe”、“/c”、“netsh界面显示界面\“Wi-Fi\”）；
builder.redirectErrorStream（true）；
进程p=builder.start（）；
BufferedReader r=新的BufferedReader（新的InputStreamReader（p.getInputStream（））；
弦线；
而（（line=r.readLine（））！=null）{
//line=r.readLine（）；
if（行包含（“连接状态”））{
state=line.split（“\\s+”）[3]；
//System.out.println（状态）；
state=state.toLowerCase（）；
if（state.equals（“connected”））{
返回true；
}否则{
返回false；
}
}
}
}捕获（IOEX异常）{
Logger.getLogger（Extractor.class.getName（））.log（Level.SEVERE，null，ex）；
}
返回false；
}
公共静态字符串getConnectedSSID（）{
字符串ssid=未设置；
试一试{
ProcessBuilder=新的ProcessBuilder(
“cmd.exe”、“/c”、“netsh wlan显示接口”）；
builder.redirectErrorStream（true）；
进程p=builder.start（）；
BufferedReader r=新的BufferedReader（新的InputStreamReader（p.getInputStream（））；
弦线；
而（（line=r.readLine（））！=null）{
//line=r.readLine（）；
if（第行包含（“SSID”））{
ssid=line.split（\\s+）[3]；
//系统输出打印项次（ssid）；
返回ssid；
}
}
}捕获（IOEX异常）{
Logger.getLogger（Extractor.class.getName（））.log（Level.SEVERE，null，ex）；
}
返回ssid；
}
公共静态字符串[]getListOfSSIDs（）{
字符串[]ssid_列表；
字符串ssid；
ArrayList arr=新的ArrayList（）；
试一试{
ProcessBuilder=新的ProcessBuilder(
“cmd.exe”、“/c”、“netsh wlan show networks”）；
builder.redirectErrorStream（true）；
进程p=builder.start（）；
BufferedReader r=新的BufferedReader（新的InputStreamReader（p.getInputStream（））；
弦线；
而（（line=r.readLine（））！=null）{
//line=r.readLine（）；
if（第行包含（“SSID”））{
ssid=line.split（\\s+）[3]；
//系统输出打印项次（ssid）；
arr.add（ssid）；
}
}
}捕获（IOEX异常）{
Logger.getLogger（Extractor.class.getName（））.log（Level.SEVERE，null，ex）；
}
ssid_List=新字符串[arr.size（）]；
到达目的地（ssid_列表）；
返回ssid_列表；
}
公共静态字符串getIP（）{
字符串ip=未设置；
试一试{
ProcessBuilder=新的ProcessBuilder(
“cmd.exe”、“/c”、“netsh接口ip显示地址\“Wi-Fi\”）；
builder.redirectErrorStream（true）；
进程p=builder.start（）；
BufferedReader r=新的BufferedReader（新的InputStreamReader（p.getInputStream（））；
弦线；
而（（line=r.readLine（））！=null）{
//line=r.readLine（）；
如果（第行包含（“IP地址”））{
ip=line.split（\\s+）[3]；
//System.out.p