从java向android应用程序发送实时数据

我需要将数据从java应用程序实时发送到android应用程序。 数据不是很大（0和9之间的整数），但传输次数很高，大约每秒5次传输

我希望有一个出版商-订阅者模型。 Java应用程序将把数据推送到android应用程序，而不是android应用程序持续ping Java应用程序获取数据

传输必须是实时的，并且将通过局域网进行

尝试使用GCM，但不是实时的。 Pubnub是另一个，但不确定它的实时性

---

如何继续？

如果您正在局域网中将数据从java传输到android应用程序，那么您可以使用TCp/UDP在java和android应用程序之间进行实时数据传输。 在我的一个项目中，我也遇到了同样的情况，但我想在pc中将字符串从android应用程序传输到java应用程序。在LAN中，我使用TCP。java应用程序正在侦听tcp连接，当android应用程序向java应用程序发送连接请求时，数据也被传输

---

您可以使用此方案解决您的问题

我建议您使用以下方法：

制作一个服务于应用程序的服务器脚本，您可以使用PHP。这是首选方法，但您可以坚持使用java服务器

让您的服务器在指定的端口上侦听（如果您选择java），或者如果您使用HTTP版本，则只启动web服务器

你的应用程序是谁应该开始交流，而不是反过来

如果您想使用HTTP服务器，必须学习JSON或任何AJAX技术

如果您坚持使用java服务器，您可能希望实现如下内容：

public class Client {
    public void retrieveData() {
        ResponseObject response = null;
        try {
            Socket socket = new Socket("host", 9999);
            ObjectOutputStream oos = new ObjectOutputStream( socket.getOutputStream() );
            oos.writeObject(criterio);
            oos.close();
            ObjectInputStream ois = new ObjectInputStream( socket.getInputStream() );
            Response response = (Response) ois.readObject();
            socket.close();
        } catch (IOException e) {
            System.out.println("Error: "+e.getMessage());
        }
        System.out.println("Response was: "response.toString());
    }
}

public class Server {
    public void startServer() {
        ServerSocket serverSocket = new ServerSocket(9999);
        ExecutorService service = Executors.newFixedThreadPool(MAX_THREADS);

        while (true) {
            try {
                servicio.submit(new Receiver(serverSocket.accept()));
            } catch (IOException e) {
                System.out.println("Error: "+e.getMessage());
            }
        }

        serverSocket.close();
    }

    public class Receiver implements Callable<Object> {
        Socket socket;

        Receiver(Socket socket) {
            this.socket = socket;
        }

        public Object call() {
            ObjectInputStream ois = new ObjectInputStream( socket.getInputStream() );
            Object clientData = ois.readObject();
            ois.close();

            ObjectOutputStream oos = new ObjectOutputStream( socket.getOutputStream() );
            oos.writeObject(...); /* Your response goes here */
            oos.close();

            socket.close();
            return null;
        }
    }
}

您的服务器等待连接，例如在端口9999上

应用程序通过

ObjectOutputStream

发送同步包，让服务器知道客户端需要信息

服务器通过相同的

套接字

发回信息

客户机根据需要重复多次

客户端可能如下所示：

public class Client {
    public void retrieveData() {
        ResponseObject response = null;
        try {
            Socket socket = new Socket("host", 9999);
            ObjectOutputStream oos = new ObjectOutputStream( socket.getOutputStream() );
            oos.writeObject(criterio);
            oos.close();
            ObjectInputStream ois = new ObjectInputStream( socket.getInputStream() );
            Response response = (Response) ois.readObject();
            socket.close();
        } catch (IOException e) {
            System.out.println("Error: "+e.getMessage());
        }
        System.out.println("Response was: "response.toString());
    }
}

public class Server {
    public void startServer() {
        ServerSocket serverSocket = new ServerSocket(9999);
        ExecutorService service = Executors.newFixedThreadPool(MAX_THREADS);

        while (true) {
            try {
                servicio.submit(new Receiver(serverSocket.accept()));
            } catch (IOException e) {
                System.out.println("Error: "+e.getMessage());
            }
        }

        serverSocket.close();
    }

    public class Receiver implements Callable<Object> {
        Socket socket;

        Receiver(Socket socket) {
            this.socket = socket;
        }

        public Object call() {
            ObjectInputStream ois = new ObjectInputStream( socket.getInputStream() );
            Object clientData = ois.readObject();
            ois.close();

            ObjectOutputStream oos = new ObjectOutputStream( socket.getOutputStream() );
            oos.writeObject(...); /* Your response goes here */
            oos.close();

            socket.close();
            return null;
        }
    }
}

还有这样的服务器：

public class Client {
    public void retrieveData() {
        ResponseObject response = null;
        try {
            Socket socket = new Socket("host", 9999);
            ObjectOutputStream oos = new ObjectOutputStream( socket.getOutputStream() );
            oos.writeObject(criterio);
            oos.close();
            ObjectInputStream ois = new ObjectInputStream( socket.getInputStream() );
            Response response = (Response) ois.readObject();
            socket.close();
        } catch (IOException e) {
            System.out.println("Error: "+e.getMessage());
        }
        System.out.println("Response was: "response.toString());
    }
}

public class Server {
    public void startServer() {
        ServerSocket serverSocket = new ServerSocket(9999);
        ExecutorService service = Executors.newFixedThreadPool(MAX_THREADS);

        while (true) {
            try {
                servicio.submit(new Receiver(serverSocket.accept()));
            } catch (IOException e) {
                System.out.println("Error: "+e.getMessage());
            }
        }

        serverSocket.close();
    }

    public class Receiver implements Callable<Object> {
        Socket socket;

        Receiver(Socket socket) {
            this.socket = socket;
        }

        public Object call() {
            ObjectInputStream ois = new ObjectInputStream( socket.getInputStream() );
            Object clientData = ois.readObject();
            ois.close();

            ObjectOutputStream oos = new ObjectOutputStream( socket.getOutputStream() );
            oos.writeObject(...); /* Your response goes here */
            oos.close();

            socket.close();
            return null;
        }
    }
}

公共类服务器{
public void startServer（）{
ServerSocket ServerSocket=新的ServerSocket（9999）；
ExecutorService=Executors.newFixedThreadPool（最大线程数）；
while（true）{
试一试{
submit（新接收方（serverSocket.accept（））；
}捕获（IOE异常）{
System.out.println（“错误：+e.getMessage（））；
}
}
serverSocket.close（）；
}
公共类接收器实现可调用{
插座；
接收器（插座）{
this.socket=socket；
}
公共对象调用（）{
ObjectInputStream ois=新的ObjectInputStream（socket.getInputStream（））；
Object clientData=ois.readObject（）；
ois.close（）；
ObjectOutputStream oos=新的ObjectOutputStream（socket.getOutputStream（））；
oos.writeObject（…）；/*您的响应如下*/
oos.close（）；
socket.close（）；
返回null；
}
}
}

查看MQTT。我用它从ActiveMQ转到Android。我的Android应用程序使用连接到ActiveMQ并订阅主题的MQTT库

以下是一些链接：

---

我相信我使用的客户端库来自这里：

PubNub是实时的。。。而且，让Java服务器与Android设备对话非常容易（事实上，PubNub拥有用于50多个不同平台的客户端SDK！）

同样的代码将在Android和普通Java上运行：

import com.pubnub.api.*;
import org.json.*;

Pubnub pubnub = new Pubnub("demo", "demo");

Callback callback = new Callback() {
  public void successCallback(String channel, Object response) {
      Log.d("PUBNUB",response.toString());
  }
  public void errorCallback(String channel, PubnubError error) {
      Log.d("PUBNUB",error.toString());
  }
};

try {
  pubnub.subscribe("demo", callback);
    } catch (PubnubException e) {
  Log.d("PUBNUB",e.toString());
}

pubnub.publish("demo", "Hello World !!" , callback);

完整的演练可在以下位置获得：

如果您对此有其他问题，请随时联系support@pubnub.com，他们会很乐意进一步帮助你

---

geremy

如果我没有错，客户端需要从服务器请求数据！！我希望服务器将数据推送到客户端。这就是为什么需要发送

同步

信号，让服务器知道客户端需要数据，打开连接并通过该连接将数据推送到客户端。服务器不应打开与客户端的连接。但是如果您坚持，那么您必须在客户端上使用

Server

类，在服务器上使用

client

类，并在客户端上保留一个打开的端口。android可能不支持JMS。看看ActiveMQ，你有什么想法吗？你想推的原因是什么？“实时”有点宽泛。准确的实时性要求是什么？你有没有想过普通的旧套接字？它就像一个java应用程序不断地向android客户端应用程序发送数据。java应用程序生成的数据需要及时到达android应用程序，以便采取一些行动。允许的最大延迟为1秒或2秒。我不希望android应用程序向java应用程序请求数据，这就是为什么我希望java应用程序将数据推送到android而不是android拉数据。支持多个客户端的套接字服务器如何？我最近构建了一个类似的项目，尽管我的服务器应用程序是用C#编写的。查看

java.net.*

库。我使用了

InetSocketAddress

、

Socket

和

SocketAddress

。是的，sockets工作正常，但实际上它没有发布者-订阅者模型。