Question

我需要实时从Java程序向C＃程序发送字符串消息。互联网上有很多例子，但是U找不到任何有用的东西（可能是）Java客户端（套接字代码）和c＃server（套接字代码）。谢谢。

Answer 1

好的，我已经在我的一个项目中做过这个，所以这里是：
免责声明：一些代码（实际上只有一点点）基于nakov聊天服务器另请注意，我对UTF-8中发送和接收的所有消息进行解码和编码。

Java代码：

类：服务器

import java.net.*;
import java.io.*;
import javax.swing.*; 

public class Server
{

    private static void createAndShowGUI() {
        //Create and set up the window
    }


public static final int LISTENING_PORT = 2002; 

public static void main(String[] args)
{
    // Open server socket for listening
    ServerSocket serverSocket = null;
    try 
    {
       serverSocket = new ServerSocket(LISTENING_PORT);
       javax.swing.SwingUtilities.invokeLater(new Runnable() {
           public void run() {
               createAndShowGUI();
           }
       });
       //System.out.println("Server started on port " + LISTENING_PORT);
    }
    catch (IOException se) 
    {
       System.err.println("Can not start listening on port " + LISTENING_PORT);
       se.printStackTrace();
       System.exit(-1);
    }

    // Start ServerDispatcher thread
    ServerDispatcher serverDispatcher = new ServerDispatcher();


    // Accept and handle client connections
    while (true) 
    {   
       try  
       {
           Socket socket = serverSocket.accept();
           ClientInfo clientInfo = new ClientInfo();
           clientInfo.mSocket = socket;
           ClientListener clientListener =
               new ClientListener(clientInfo, serverDispatcher);
           ClientSender clientSender =
               new ClientSender(clientInfo, serverDispatcher);
           clientInfo.mClientListener = clientListener;
           clientInfo.mClientSender = clientSender;
           clientListener.start();
           clientSender.start();
           serverDispatcher.addClient(clientInfo);
       }
       catch (IOException ioe) 
       {
           ioe.printStackTrace();
       }
    }
}

}

类消息调度程序：

    import java.io.UnsupportedEncodingException;
        import java.net.*;
    import java.util.*;

    public class ServerDispatcher 
        {
        private Vector mMessageQueue = new Vector();
        private Vector<ClientInfo> mClients = new Vector<ClientInfo>();


    public synchronized void addClient(ClientInfo aClientInfo) {
        mClients.add(aClientInfo);
    }

    public synchronized void deleteClient(ClientInfo aClientInfo) {
        int clientIndex = mClients.indexOf(aClientInfo);
        if (clientIndex != -1)
            mClients.removeElementAt(clientIndex);
    }


    private synchronized void sendMessageToAllClients(String aMessage)
    {
        for (int i = 0; i < mClients.size(); i++) {
            ClientInfo infy = (ClientInfo) mClients.get(i);
            infy.mClientSender.sendMessage(aMessage);
                              } 
    }   




    public void sendMessage(ClientInfo aClientInfo, String aMessage) {
        aClientInfo.mClientSender.sendMessage(aMessage);

    }


}

类：ClientInfo

/**
 *
 * ClientInfo class contains information about a client, connected to the server.
 */

import java.awt.List;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Vector;

public class ClientInfo
{

    public int userID=-1;
    public Socket mSocket = null;
    public ClientListener mClientListener = null;
    public ClientSender mClientSender = null;
}

类ClientListner：

/**
 * ClientListener class is purposed to listen for client messages and
 * to forward them to ServerDispatcher.
 */

import java.io.*;
import java.net.*;

public class ClientListener extends Thread {
    private ServerDispatcher mServerDispatcher;
    private ClientInfo mClientInfo;
    private BufferedReader mIn;
    private String message;
    private String decoded = null;

    public ClientListener(ClientInfo aClientInfo,
            ServerDispatcher aServerDispatcher) throws IOException {
        mClientInfo = aClientInfo;
        mServerDispatcher = aServerDispatcher;
        Socket socket = aClientInfo.mSocket;
        mIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    }

    /**
     * Until interrupted, reads messages from the client socket, forwards them
     * to the server dispatcher and notifies the server dispatcher.
     */
    public void run() {
        message = "";
        while (!isInterrupted()) {
            try {
                message = mIn.readLine();
                if (message == null)
                    break;
                try {
                    decoded = URLDecoder.decode(message, "UTF-8");
                } catch (UnsupportedEncodingException e)
                    e.printStackTrace();
                }
                mServerDispatcher.sendMessage(mClientInfo, decoded);

            } 

            catch (IOException e) {
                break;
            }

        }

        // Communication is broken. Interrupt both listener and sender threads
        mClientInfo.mClientSender.interrupt();
        mServerDispatcher.deleteClient(mClientInfo);
    }

}

<强>类别：ClientSender

/**
 * Sends messages to the client. Messages are stored in a message queue. When
 * the queue is empty, ClientSender falls in sleep until a new message is
 * arrived in the queue. When the queue is not empty, ClientSender sends the
 * messages from the queue to the client socket.
 */

import java.io.*;
import java.net.*;
import java.util.*;

public class ClientSender extends Thread
{
    private Vector mMessageQueue = new Vector();

    private ServerDispatcher mServerDispatcher;
    private ClientInfo mClientInfo;
    private PrintWriter mOut;

    public ClientSender(ClientInfo aClientInfo, ServerDispatcher aServerDispatcher)
    throws IOException
    {
        mClientInfo = aClientInfo;
        mServerDispatcher = aServerDispatcher;
        Socket socket = aClientInfo.mSocket;
        mOut = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
    }

    /**
     * Adds given message to the message queue and notifies this thread
     * (actually getNextMessageFromQueue method) that a message is arrived.
     * sendMessage is called by other threads (ServeDispatcher).
     */
    public synchronized void sendMessage(String aMessage)
    {
        mMessageQueue.add(aMessage);
        notify();
    }

    /**
     * @return and deletes the next message from the message queue. If the queue
     * is empty, falls in sleep until notified for message arrival by sendMessage
     * method.
     */
    private synchronized String getNextMessageFromQueue() throws InterruptedException
    {
        while (mMessageQueue.size()==0)
           wait();
        String message = (String) mMessageQueue.get(0);
        mMessageQueue.removeElementAt(0);
        return message;
    }

    /**
     * Sends given message to the client's socket.
     */
    private void sendMessageToClient(String aMessage)
    {
         String encoded;
        try {
            encoded = URLEncoder.encode(aMessage,"UTF-8");
            mOut.println(encoded);
            mOut.flush();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

    }

    /**
     * Until interrupted, reads messages from the message queue
     * and sends them to the client's socket.
     */
    public void run()
    {
        try {
           while (!isInterrupted()) {
               String message = getNextMessageFromQueue();


               sendMessageToClient(message);
           }
        } catch (Exception e) {
           // Commuication problem
       break;
        }

        // Communication is broken. Interrupt both listener and sender threads
        mClientInfo.mClientListener.interrupt();
        mServerDispatcher.deleteClient(mClientInfo);
    }

}

好的这是java代码，现在是c＃代码

c＃代码：

使用的Varibales：

    private StreamWriter swSender;
    private StreamReader srReceiver;
    private TcpClient tcpServer;
    private Thread thrMessaging;
    private IPAddress ipAddr;
    private bool Connected;

功能：Intelize connection：

private void InitializeConnection()
{
    // Parse the IP address

    string ipAdress = "XXX.XXX.XXX.XXX";
    ipAddr = IPAddress.Parse(ipAdress);


    // Start a new TCP connections to the chat server
    tcpServer = new TcpClient();
    try
    {
        tcpServer.Connect(ipAddr, 2002);
        swSender = new StreamWriter(tcpServer.GetStream());


        // Start the thread for receiving messages and further communication
        thrMessaging = new Thread(new ThreadStart(ReceiveMessages));
        thrMessaging.Start();
        Connected=true;
    }
        catch (Exception e2)
        {
            MessageBox.Show(e2.ToString());
        }
    }



}

功能：ReciveMessages

private void ReceiveMessages()
        {
            // Receive the response from the server
            srReceiver = new StreamReader(tcpServer.GetStream());
            while (Connected)
            {
                String con = srReceiver.ReadLine();
                string StringMessage = HttpUtility.UrlDecode(con, System.Text.Encoding.UTF8);

                processMessage(StringMessage);



            }
        }

功能：proceesMessage：

private void processMessage(String p)
        {
        // do something with the message
        }

功能sendMessage：

 private void SendMessage(String p)
        {
            if (p != "")
            {
                p = HttpUtility.UrlEncode(p, System.Text.Encoding.UTF8);
                swSender.WriteLine(p);
                swSender.Flush();

            }

        }

这就是你需要在java服务器和c＃客户端之间进行通信所需的一切。如果您有任何问题，请不要犹豫，将它们发布在这里。

Answer 2

选择用于编码/发送字符串的协议。例如：

<length of string (4 bytes)><string data (length bytes)>

编写一些Java代码来发送一个字符串，该字符串遵循您在＃1中选择的任何协议。因此，使用上面的示例，您可以执行以下操作：

public static void writeString(String string, OutputStream out) throws IOEXception {
    if (string == null || "".equals(string)) {
        //nothing to do
        return;
    }
    int length = string.length();

    //synchronize so that two threads don't try to write to the same stream at the same time
    synchronized(out) {
        out.write((length >> 24) & 0xFF);
        out.write((length >> 16) & 0xFF);
        out.write((length >> 8) & 0xFF);
        out.write(length & 0xFF);
        out.write(string.getBytes());
        out.flush();
    }
}

在C＃中写一些等效代码来解码正在发送的字符串。它看起来很像你的Java代码，除了读取而不是写入。

Answer 3

我想我找到了一个好的，有效的解决方案。使用UDP套接字：

Java代码

public void runJavaSocket() {
    System.out.println("Java Sockets Program has started."); int i=0;

    try {
        DatagramSocket socket = new DatagramSocket();
        System.out.println("Sending the udp socket...");
        // Send the Message "HI"
        socket.send(toDatagram("HI",InetAddress.getByName("127.0.0.1"),3800));
        while (true) {
            System.out.println("Sending hi " + i);
            Thread.currentThread();
            Thread.sleep(1000);
            socket.send(toDatagram("HI " +
                String.valueOf(i),InetAddress.getByName("127.0.0.1"),3800));
            i++;
       }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public DatagramPacket toDatagram(
    String s, InetAddress destIA, int destPort) {
    // Deprecated in Java 1.1, but it works:
    byte[] buf = new byte[s.length() + 1];
    s.getBytes(0, s.length(), buf, 0);
    // The correct Java 1.1 approach, but it's
    // Broken (it truncates the String):
    // byte[] buf = s.getBytes();
    return new DatagramPacket(buf, buf.length, destIA, destPort);
}

C＃代码

string returnData;
byte[] receiveBytes;
//ConsoleKeyInfo cki = new ConsoleKeyInfo();

using (UdpClient udpClient = 
    new UdpClient(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 3800)))
{
    IPEndPoint remoteIpEndPoint =
        new IPEndPoint(IPAddress.Parse("127.0.0.1"), 3800);
    while (true)
    {
        receiveBytes = udpClient.Receive(ref remoteIpEndPoint);
        returnData = Encoding.ASCII.GetString(receiveBytes);
        Console.WriteLine(returnData);
    }
}

Answer 4

我只会使用SOAP协议。您可以在C＃端使用WCF，在Java端使用JMS（Java messging）。这两种技术都是基于SOAP构建的，因此它们可以读取彼此的消息。他们都使用WSDL。

套接字：从Java发送字符串到C＃？

4 个答案:

Java代码：

c＃代码：