带有服务器到客户端消息传递的Android应用程序

我现在正在创建一个Android应用程序，它允许客户端到服务器的消息传递，但我正在寻找一种同时允许服务器到客户端消息传递的方法，这样客户端和服务器都可以来回发送消息。任何关于我如何做到这一点的建议都将不胜感激。我知道我需要编辑我的ChatServer类，如下所示

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.LinkedList;
import java.util.List;

public class ChatServer {

private static final String USAGE = "Usage: java ChatServer";

/** Default port number on which this server to be run. */
private static final int PORT_NUMBER = 8008;

/**
 * List of print writers associated with current clients, one for each.
 */
private List<PrintWriter> clients;

/** Creates a new server. */
public ChatServer() {
    clients = new LinkedList<PrintWriter>();
}

/** Starts the server. */
public void start() {
    System.out.println("AndroidChatApplication server started on port "
            + PORT_NUMBER + "!");
    try {
        ServerSocket s = new ServerSocket(PORT_NUMBER);
        for (;;) {
            Socket incoming = s.accept();
            new ClientHandler(incoming).start();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("AndroidChatApplication server stopped.");
}

/** Adds a new client identified by the given print writer. */
private void addClient(PrintWriter out) {
    synchronized (clients) {
        clients.add(out);
    }
}

/** Adds the client with given print writer. */
private void removeClient(PrintWriter out) {
    synchronized (clients) {
        clients.remove(out);
    }
}

/** Broadcasts the given text to all clients. */
private void broadcast(String msg) {
    for (PrintWriter out : clients) {
        out.println(msg);
        out.flush();
    }
}

public static void main(String[] args) {
    if (args.length > 0) {
        System.out.println(USAGE);
        System.exit(-1);
    }
    new ChatServer().start();
}

/**
 * A thread to serve a client. This class receive messages from a client and
 * broadcasts them to all clients including the message sender.
 */
private class ClientHandler extends Thread {

    /** Socket to read client messages. */
    private Socket incoming;

    /** Creates a hander to serve the client on the given socket. */
    public ClientHandler(Socket incoming) {
        this.incoming = incoming;
    }

    /** Starts receiving and broadcasting messages. */
    public void run() {
        PrintWriter out = null;
        try {
            out = new PrintWriter(new OutputStreamWriter(
                    incoming.getOutputStream()));

            // inform the server of this new client
            ChatServer.this.addClient(out);

            out.print("Welcome to AndroidChatApplication! ");
            out.println("Enter BYE to exit.");
            out.flush();

            BufferedReader in = new BufferedReader(new InputStreamReader(
                    incoming.getInputStream()));
            for (;;) {
                String msg = in.readLine();
                if (msg == null) {
                    break;
                } else {
                    if (msg.trim().equals("BYE"))
                        break;
                    System.out.println("Received: " + msg);
                    // broadcast the receive message
                    ChatServer.this.broadcast(msg);
                }
            }
            incoming.close();
            ChatServer.this.removeClient(out);
        } catch (Exception e) {
            if (out != null) {
                ChatServer.this.removeClient(out);
            }
            e.printStackTrace();
        }
    }
 }
}

导入java.io.BufferedReader；
导入java.io.InputStreamReader；
导入java.io.OutputStreamWriter；
导入java.io.PrintWriter；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.util.LinkedList；
导入java.util.List；
公共类聊天服务器{
私有静态最终字符串用法=“用法：JavaChatServer”；
/**运行此服务器的默认端口号*/
专用静态最终int端口号=8008；
/**
*与当前客户端关联的打印写入程序列表，每个客户端一个。
*/
私人名单客户；
/**创建一个新服务器*/
公共聊天服务器（）{
clients=newlinkedlist（）；
}
/**启动服务器*/
公开作废开始（）{
System.out.println（“AndroidChatApplication服务器已在端口上启动”
+端口号+“！”；
试一试{
ServerSocket s=新的ServerSocket（端口号）；
对于（；；）{
套接字传入=s.accept（）；
新的ClientHandler（传入）.start（）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
System.out.println（“AndroidChatApplication服务器已停止”）；
}
/**添加由给定打印编写器标识的新客户端*/
专用void addClient（打印输出）{
已同步（客户端）{
客户。添加（输出）；
}
}
/**添加具有给定打印编写器的客户端*/
私有void removeClient（打印输出）{
已同步（客户端）{
客户。移除（移出）；
}
}
/**将给定文本广播到所有客户端*/
专用无效广播（字符串消息）{
用于（打印输出：客户端）{
out.println（msg）；
out.flush（）；
}
}
公共静态void main（字符串[]args）{
如果（args.length>0）{
System.out.println（用法）；
系统退出（-1）；
}
新建聊天服务器（）.start（）；
}
/**
*为客户机服务的线程。此类从客户机接收消息并
*将它们广播到包括消息发送者在内的所有客户端。
*/
私有类ClientHandler扩展线程{
/**用于读取客户端消息的套接字*/
专用插座输入；
/**创建一个hander，在给定套接字上为客户端提供服务*/
公用ClientHandler（套接字传入）{
this.incoming=传入；
}
/**开始接收和广播消息*/
公开募捐{
PrintWriter out=null；
试一试{
out=新的PrintWriter（新的OutputStreamWriter(
incoming.getOutputStream（））；
//将此新客户端通知服务器
ChatServer.this.addClient（out）；
打印（“欢迎使用AndroidChatApplication！”）；
out.println（“输入再见退出”）；
out.flush（）；
BufferedReader in=新的BufferedReader（新的InputStreamReader(
incoming.getInputStream（））；
对于（；；）{
字符串msg=in.readLine（）；
如果（msg==null）{
打破
}否则{
如果（msg.trim（）.equals（“BYE”））
打破
System.out.println（“接收：+msg”）；
//广播接收信息
ChatServer.this.broadcast（msg）；
}
}
incoming.close（）；
ChatServer.this.removeClient（out）；
}捕获（例外e）{
if（out！=null）{
ChatServer.this.removeClient（out）；
}
e、 printStackTrace（）；
}
}
}
}

您只需使用谷歌推送通知服务，查看和好友以了解更多详细信息。这里有一些关于如何使用它的信息