Javascript 如何将数据从节点发送到另一台服务器

我正试图找到一种方法，将节点用作客户端，将数据发送到安卓应用程序上侦听的服务器。android应用程序将首先向节点服务器发送一个post请求，其中包含它的公共IP地址和它将侦听的端口（套接字）。一旦有了新的内容，节点服务器就会通过注册的套接字将一包JSON数据发送到特定的应用程序上

这在Node中可能吗？如果不可能，我如何在Javascript中实现它，或者实现这一点的最佳方法是什么

这是安卓应用服务器

public class AndroidAppLocalServer {
    Activity activity;
    ServerSocket serverSocket;
    String message = "";
    static final int socketServerPORT = 8080;

    public AndroidAppLocalServer(Activity activity) {
        this.activity = activity;
        Thread socketServerThread = new Thread(new SocketServerThread());
        socketServerThread.start();
    }

    public int getPort() {
        return socketServerPORT;
    }

    public void onDestroy() {
        if (serverSocket != null) {
            try {
                serverSocket.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    private class SocketServerThread extends Thread {

        int count = 0;

        @Override
        public void run() {
            try {
                // create ServerSocket using specified port
                serverSocket = new ServerSocket(socketServerPORT);

                while (true) {
                    // block the call until connection is created and return
                    // Socket object
                    Socket socket = serverSocket.accept();
                    count++;
                    message += "#" + count + " from "
                            + socket.getInetAddress() + ":"
                            + socket.getPort() + "\n";

                    activity.runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Log.v("MyApp", message);
                        }
                    });

                    SocketServerReplyThread socketServerReplyThread = new SocketServerReplyThread(socket, count);
                    socketServerReplyThread.run();

                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    private class SocketServerReplyThread extends Thread {

        private Socket hostThreadSocket;
        int cnt;

        SocketServerReplyThread(Socket socket, int c) {
            hostThreadSocket = socket;
            cnt = c;
        }

        @Override
        public void run() {
            OutputStream outputStream;
            String msgReply = "Hello from AndroidAppLocalServer, you are #" + cnt;

            try {
                outputStream = hostThreadSocket.getOutputStream();
                PrintStream printStream = new PrintStream(outputStream);
                printStream.print(msgReply);
                printStream.close();

                message += "replayed: " + msgReply + "\n";

                activity.runOnUiThread(new Runnable() {

                    @Override
                    public void run() {
                        Log.v("MyApp", message);
                    }
                });

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                message += "Something wrong! " + e.toString() + "\n";
            }

            activity.runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    Log.v("MyApp", message);
                }
            });
        }

    }

    public String getIpAddress() {
        String ip = "";
        try {
            Enumeration<NetworkInterface> enumNetworkInterfaces = NetworkInterface.getNetworkInterfaces();
            while (enumNetworkInterfaces.hasMoreElements()) {
                NetworkInterface networkInterface = enumNetworkInterfaces.nextElement();
                Enumeration<InetAddress> enumInetAddress = networkInterface.getInetAddresses();
                while (enumInetAddress.hasMoreElements()) {
                    InetAddress inetAddress = enumInetAddress.nextElement();

                    if (inetAddress.isSiteLocalAddress()) {
                        ip += "AndroidAppLocalServer running at : " + inetAddress.getHostAddress();
                    }
                }
            }

        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            ip += "Something Wrong! " + e.toString() + "\n";
        }
        return ip;
    }
}

公共类AndroidAppLocalServer{
活动；
服务器套接字服务器套接字；
字符串消息=”；
静态最终int socketServerPORT=8080；
公共AndroidAppLocalServer（活动）{
这个。活动=活动；
Thread socketServerThread=新线程（新的socketServerThread（））；
socketServerThread.start（）；
}
公共int getPort（）{
返回socketServerPORT；
}
公共空间{
if（serverSocket！=null）{
试一试{
serverSocket.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
私有类SocketServerThread扩展线程{
整数计数=0；
@凌驾
公开募捐{
试一试{
//使用指定的端口创建ServerSocket
serverSocket=新的serverSocket（socketServerPORT）；
while（true）{
//阻止呼叫，直到建立连接并返回
//套接字对象
Socket=serverSocket.accept（）；
计数++；
消息+=“#”+计数+“来自”
+socket.getInetAddress（）+“：”
+socket.getPort（）+“\n”；
activity.runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
Log.v（“MyApp”，消息）；
}
});
SocketServerReplyThread SocketServerReplyThread=新的SocketServerReplyThread（套接字，计数）；
socketServerReplyThread.run（）；
}
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
私有类SocketServerReplyThread扩展线程{
私有套接字hostThreadSocket；
int-cnt；
SocketServerReplyThread（Socket-Socket，int-c）{
hostThreadSocket=套接字；
cnt=c；
}
@凌驾
公开募捐{
输出流输出流；
String msgReply=“来自AndroidAppLocalServer的您好，您是#”+cnt；
试一试{
outputStream=hostThreadSocket.getOutputStream（）；
PrintStream PrintStream=新的PrintStream（outputStream）；
printStream.print（msgReply）；
printStream.close（）；
消息+=“重播：”+msgReply+“\n”；
activity.runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
Log.v（“MyApp”，消息）；
}
});
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
消息+=“有问题！”+e.toString（）+“\n”；
}
activity.runOnUiThread（新的Runnable（）{
@凌驾
公开募捐{
Log.v（“MyApp”，消息）；
}
});
}
}
公共字符串getIpAddress（）{
字符串ip=“”；
试一试{
枚举枚举enumNetworkInterfaces=NetworkInterface.getNetworkInterfaces（）；
while（enumNetworkInterfaces.hasMoreElements（））{
NetworkInterface NetworkInterface=enumNetworkInterfaces.nextElement（）；
枚举Enumeration enumInetAddress=networkInterface.getInetAddresses（）；
while（enumInetAddress.hasMoreElements（））{
InetAddress InetAddress=enumInetAddress.nextElement（）；
if（inetAddress.isSiteLocalAddress（））{
ip+=“AndroidAppLocalServer运行于：”+inetAddress.getHostAddress（）；
}
}
}
}捕获（SocketException e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
ip++=“有问题！”+e.toString（）+“\n”；
}
返回ip；
}
}

是的，您可以在Node.js中执行此操作，前提是应用程序运行在实际上可以公开访问的手机上。由于您在Android应用程序中使用的是普通TCP套接字，因此可以首先通过使用

netcat

或

telnet

（例如

netcat 8080

）等工具手动连接套接字进行验证

如果这样做有效，您可以在Node.js中使用类执行相同的操作

const net=require（'net'）；
const client=new net.Socket（）；
client.connect（8080，，（）=>{
//连接成功时的回调
client.write（“发送到应用程序的数据”）；
});
client.on（'数据'，（数据）=>{
//回调，当应用程序回复数据时
});
client.on（'关闭'，（数据）=>{
//套接字关闭时的回调
});

---

但是，根据您实际尝试实现的目标，您可能希望了解Android应用程序通常如何实现推送通知。

是的，您可以在Node.js中实现这一点，前提是该应用程序运行在可公开访问的手机上。因为你使用的是pla

const net = require('net');
const client = new net.Socket();
client.connect(8080, '<PUBLIC-IP>', () => {
    // callback, when connection successfull
    client.write('Data sent to the App');
});
client.on('data', (data) => {
    // callback, when app replies with data
});
client.on('close', (data) => {
    // callback, when socket is closed
});