java socket編程問題（發送和接收數據）

Question

客戶端有一個sendpoints（）方法，它被其他一些我沒有包含的類調用。 無論如何，調用sendpoints（）並將整數發送到服務器，服務器接收它們並將其發送回所有連接到服務器的客戶端（廣播）。

問題是，當服務器卡在我爲接收整數創建的線程（我認爲服務器沒有從輸入流中讀取）時，客戶端不停地發送整數。

我試着改變流，我試着將整數放在一個對象中，然後用ObjectOutputStream發送它，但這些都不起作用。 我需要幫助（pointStruct是保存我創造了一些整數值的類）

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



public class Server { 


    private ArrayList dataclient; 
    private ArrayList messageclient; 

    private ServerSocket dataserver; 
    private ServerSocket messageserver; 

    public static void main(String[] args) { 
     Server s1 = new Server(); 
     s1.start(); 

    } 

    // Start running server 
    public void start() { 
     try { 
      dataserver = new ServerSocket(4999); 
      messageserver = new ServerSocket(5000); 
      Socket dataconn; 
      Socket messageconn; 

      dataclient = new ArrayList(); 
      messageclient = new ArrayList(); 
      dataconn= null; 
      messageconn= null; 
      System.out.println("[server]start"); 

      //start accepting connections 
      while (true) { 
       try { 
       dataconn = dataserver.accept(); 
       System.out.println("[server]accepted dataconn"); 

       messageconn = messageserver.accept(); 
       System.out.println("[server]accepted messageconn"); 

       //add clients to arraylist 

       dataclient.add(dataconn.getOutputStream()); 

       messageclient.add(messageconn.getOutputStream()); 

       } 
       catch (Exception ex) { 
        ex.printStackTrace(); 
       } 

       //creating receiver threads 
       Thread t1 = new Thread(new DataReceiver(dataconn)); 
       Thread t2 = new Thread(new MessageReceiver(messageconn)); 
       System.out.println("[server]Thread successfully created"); 
       t1.start(); 
       t2.start(); 
       System.out.println("[server]Thread successfully started"); 
      } 
     } 
     catch(Exception ex) { 
      ex.printStackTrace(); 
     } 
    } 

    //receive data from clients 
    public class DataReceiver implements Runnable { 

     BufferedReader br; 
     InputStream is; 

     int x,y; 
     int x2,y2; 
     int t; 
     int red; 
     int green; 
     int blue; 
     int size; 
     int dummy; 

     DataReceiver(Socket s){ 
      try { 
       is=s.getInputStream(); 
       //br = new BufferedReader(isr); 
      } 
      catch(Exception ex) { 
       ex.printStackTrace(); 
      } 
     } 
     public void run() { 
     while(true) { 
      try{ 

       Iterator it = dataclient.iterator(); 
       dummy=is.read(); 
       if(dummy==9999) { 
       System.out.println("[server]executing data thread"); 
       x=is.read(); 
       System.out.println("[server]read a line"+x); 
       y=is.read(); 
       System.out.println("[server]read a line"+y); 

       //x2=isr.read(); 
       //y2=isr.read(); 
       t=is.read(); 
       red=is.read(); 
       green=is.read(); 
       blue=is.read(); 
       size=is.read(); 

       dummy=0; 
       //broadcast data 

       while (it.hasNext()) { 
        OutputStream os = (OutputStream)it.next(); 
        os.write(9999); 
        os.write(x); 
        os.write(y); 
        os.write(t); 
        os.write(255); 
        os.write(0); 
        os.write(0); 
        os.write(size); 
       } 
       System.out.println("[server]data broadcasted"); 
       } 
      } 
      catch(Exception ex) { 
       ex.printStackTrace(); 
      } 


    } 
    } 
    } 

    //------------------------receive message from clients------------------------ 
    public class MessageReceiver implements Runnable { 

     MessageReceiver(Socket s) { 

     } 

     public void run() { 


     } 

    } 
} 




public class networkHandler{ 
    PrintWriter writer; 
    BufferedReader reader; 
    PrintWriter pwriter; 
    BufferedReader preader; 
    Socket sock; 
    Socket pointsock; 
    InputStream is; 
    JTextArea incoming; 
    pointHandler ph; 

    public networkHandler(pointHandler _ph) { 
     init(); 
     ph=_ph; 
     setUpNetworking(); 
     Thread readerThread = new Thread(new IncomingReader()); 
     readerThread.start(); 
     Thread pointerThread = new Thread(new ReceivingPoints()); 
     pointerThread.start(); 
    } 

    public void init() { 
     incoming = new JTextArea(20,20); 
    } 
    private void setUpNetworking() { 
     try { 

      // setup message port 
      System.out.println("networking establish started"); 
      sock = new Socket("127.0.0.1",5000); 
      System.out.println("[NH]port 5000 established"); 

      // setup point port 
      pointsock = new Socket("127.0.0.1",4999); 
      System.out.println("[NH]port 4999 established"); 

      //message i/o stream 
      InputStreamReader streamReader = new InputStreamReader(sock.getInputStream()); 
      reader = new BufferedReader(streamReader); 
      writer = new PrintWriter(sock.getOutputStream()); 


      //point i/o stream 
      InputStreamReader pstreamReader = new InputStreamReader(pointsock.getInputStream()); 
      System.out.println("networking establishing: Stream"); 
      preader= new BufferedReader(pstreamReader); 
      pwriter= new PrintWriter(pointsock.getOutputStream()); 
      System.out.println("networking establishing: Stream"); 
     } 
     catch(IOException ex) { 
      ex.printStackTrace(); 
     } 
     System.out.println("networking established"); 
    } 

    //send message to the server 
    public void writeStream(String input){ 
     try { 
      writer.println(input); 

      writer.flush();  
     } 
     catch(Exception ex) { 
      ex.printStackTrace(); 
     } 
    } 
    public JTextArea getServerMessage() { 
     return incoming; 
    } 

    //receiving message from server 
    public class IncomingReader implements Runnable { 

     @Override 
     public void run() { 
      String message; 
      try { 
       while ((message = reader.readLine())!=null){ 
        System.out.println("[NH] read from server:"+message); 
        incoming.append(message+"\n"); 
       } 
      } 
      catch(Exception ex) { 
       ex.printStackTrace(); 
      } 

     } 

    } 

    //receiving points from server 
    public class ReceivingPoints implements Runnable { 

     int x,y; 
     int x2,y2; 
     int red; 
     int green; 
     int blue; 
     int t; 
     int size; 
     int dummy; 
     pointStruct ps; 
     Color cr; 
     Point p; 

     synchronized public void run() { 
      try { 
       is = pointsock.getInputStream(); 
       p= new Point(); 
      } 
      catch(Exception ex) { 
       ex.printStackTrace(); 
      } 

      while(true) { 
       try { 
       dummy=is.read(); 
       if(dummy==9999) { 

       x=is.read(); 
       y=is.read(); 

       //x2=preader.read(); 
       //y2=preader.read(); 

       t=is.read(); 
       red=is.read(); 
       green=is.read(); 
       blue =is.read(); 
       size=is.read(); 






       //create dummy pointStruct 
       ps = new pointStruct(); 
       cr = new Color(red,green,blue); 

       p.x=x; 
       p.y=y; 
       ps.setP1(p); 
       p.x=x2; 
       p.y=y2; 
       //ps.setP2(p); 
       ps.setT((char)t); 
       ps.setS(size); 
       ps.setC(cr); 

       ph.save(ps); 
       dummy=0; 
       } 

       } 
       catch(Exception ex) { 
       ex.printStackTrace(); 
       } 

      System.out.println("[NH]receiving done"); 
      } 
    }} 


    public void sendPoints(pointStruct ps) {   
     OutputStream os; 
     try{ 
      os=pointsock.getOutputStream(); 
      os.write(9999); 
      os.write(ps.getP1().x); 
      os.write(ps.getP1().y); 
      //pwriter.print(ps.getP2().x); 
      //pwriter.print(ps.getP2().y); 

      os.write(ps.getT()); 
      os.write(ps.getC().getRed()); 
      os.write(ps.getC().getGreen()); 
      os.write(ps.getC().getBlue()); 
      os.write(ps.getS()); 
     } 
     catch(Exception ex) { 
      ex.printStackTrace(); 
     } 
     System.out.println("[NH]points sent to server"); 
    }  
} 

Answer 1

您不正確讀取數據流，InputStream.read()返回從流的字節，而是轉換爲int。從0到255

InputStream.read()返回值被讀取是成功的，並且-1如果沒有更多的讀數可以做（流的末尾）。

例如，InputStream.read() != 9999總是。因此，這ReceivingPoints.run()塊不火：

while (true) { 
    try { 
     dummy = is.read(); 
     if (dummy == 9999) {} 
    } catch(Exception ex) { 
     ex.printStackTrace(); 
    } 
} 

您正在尋找DataInputStream，它具有讀寫等基本類型的不僅僅是字節的方法。