2014-03-12 36 views
2

在Client類中有一個while循環,我要求用戶進行一些計算。當我嘗試進行多個計算時,會出現此問題。它從服務器類中進行計算。保持Socket服務器的多種用途?

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

public class Client { 

private static final int PORT = 1234; 

public static void main(String[] arg) { 
    try { 

     Scanner userInputScanner = new Scanner(System.in); 

     Calculator c = new Calculator(0,0,"+"); 
     CalculatorProtocol s = new CalculatorProtocol(); 
     String testString = null; 
     String answer = null; 

     Socket socketConnection = new Socket(InetAddress.getLocalHost(),PORT); 
     ObjectOutputStream clientOutputStream = new 
       ObjectOutputStream(socketConnection.getOutputStream()); 
      ObjectInputStream clientInputStream = new 
       ObjectInputStream(socketConnection.getInputStream()); 

     do{ 

     System.out.println("Give the 1st integer:"); 
     testString = userInputScanner.next(); 
     while (!s.isInteger(testString)) { 
      System.out.println("Wrong input data." + "Give the 1st integer:"); 
      testString = userInputScanner.next(); 
     } 
     c.setFirstNumber(Integer.parseInt(testString));    

     System.out.println("Give the 2nd integer:"); 
     testString = userInputScanner.next(); 

     while (!s.isInteger(testString)) { 
      System.out.println("Wrong input data." + "Give the 2nd integer:"); 
      testString = userInputScanner.next(); 
     }     
     c.setSecondNumber(Integer.parseInt(testString)); 
     userInputScanner.nextLine(); // Gia na mi ginei lathos 

     System.out.println("Give the operator (+,-,*,/):"); 
     testString = userInputScanner.nextLine(); 
     while(!s.isOperator(testString)) { 
      System.out.println("Wrong input data."       
        + "Give the operator(+,-,*,/):"); 
      testString = userInputScanner.next(); 
     } 
     c.setOperation(testString); 

     System.out.println("First integer:" +c.getFirstNumber()); 
     System.out.println("Second integer:" +c.getSecondNumber()); 
     System.out.println("Operator:"+c.getOperation());     

     clientOutputStream.writeObject(c); 

     c = (Calculator)clientInputStream.readObject(); 


     System.out.println("Result="+c.getResult()); 

     System.out.println("Want more?");   
     answer = userInputScanner.nextLine(); 
     }while(s.wantMore(answer)); 

     clientOutputStream.close(); 
     clientInputStream.close(); 



    }catch (Exception e) {System.out.println(e); } 
     } 
} 

服務器類

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

public class Server { 

    private static final int PORT = 1234; 

    public static void main(String[] arg) { 

    Calculator c = null; 
    CalculatorProtocol s = new CalculatorProtocol(); 
    String answer = null; 



     try { 
       ServerSocket socketConnection = new ServerSocket(PORT); 

       System.out.println("Server Waiting"); 


       while(true) { 
        Socket pipe = socketConnection.accept(); 
        ObjectInputStream serverInputStream = new  
            ObjectInputStream(pipe.getInputStream()); 

         ObjectOutputStream serverOutputStream = new 
            ObjectOutputStream(pipe.getOutputStream()); 
         c = (Calculator)serverInputStream.readObject(); 
        while (true) { 


         c.setResult(s.Calculate(c.getFirstNumber(), c.getSecondNumber() 
           , c.getOperation())); 
         serverOutputStream.writeObject(c); 

        } 



       } 




      } catch(Exception e) {System.out.println(e); 
    } 


    } 
} 

類用於協議

public class CalculatorProtocol { 


private int a , b ; 
private String d; 




public static boolean isInteger(String str) { 
    if (str == null) { 
     return false; 
    } 
    int length = str.length(); 
    if (length == 0) { 
     return false; 
    } 
    int i = 0; 
    if (str.charAt(0) == '-') { 
     if (length == 1) { 
      return false; 
     } 
     i = 1; 
    } 
    for (; i < length; i++) { 
     char c = str.charAt(i); 
     if (c <= '/' || c >= ':') { 
      return false; 
     } 
    } 
    return true; 
} 

public boolean isOperator(String op){ 
    if(!(op.equals("+") || op.equals("-") || op.equals("*") || op.equals("/"))) 
     return false; 
    else 
     d = op; 
     return true; 
} 

public int Calculate(int n1 , int n2 , String o) { 

    a = n1; 
    b = n2; 
    d = o; 

    int result = 0; 

    if (d.equals("+")) 
     result = a + b; 
    else if (d.equals("-")) 
     result = a - b; 
    else if (d.equals("*")) 
     result = a * b; 
    else 
     result = a/b; 

    return result; 
} 

public boolean wantMore(String m){ 
    if (m.equals("Yes")) 
     return true; 
    else 
     return false; 
} 



} 



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

public class Calculator implements Serializable { 

private int num1,num2,result; 
private String calc; 

計算器類計算器對象。

Calculator (int a, int b, String p) { 
    num1 = a; 
    num2 = b; 
    calc = p; 
    result = 0; 

} 

public int getFirstNumber() { 
    return num1 ; 
} 

public int getSecondNumber() { 
    return num2 ; 
} 

public void setFirstNumber(int num) { 
    num1 = num; 
} 

public void setSecondNumber(int num) { 
     num2 = num; 
    } 

public String getOperation() { 
    return calc ; 
} 

public void setOperation(String op) { 
    calc = op; 
} 

public void setResult(int d) { 
    result = d; 
} 

public int getResult() { 
    return result; 
} 
} 

回答

0

沒有篩選出所有發佈的代碼,我會診斷你的問題。您似乎想要添加多個客戶端來進行計算。它卡在這裏。

while(true) { 
    Socket pipe = socketConnection.accept(); 
    ObjectInputStream serverInputStream = new ObjectInputStream(pipe.getInputStream()); 

    ObjectOutputStream serverOutputStream = new ObjectOutputStream(pipe.getOutputStream()); 
    c = (Calculator)serverInputStream.readObject(); //this is only done once 
    while (true) { // you need logic to break out of this loop. 
     c.setResult(s.Calculate(c.getFirstNumber(), c.getSecondNumber(), c.getOperation())); 
     serverOutputStream.writeObject(c); //this is done multiple times 
    } 

假設你只想在一次處理一個客戶,你想要做的是採取計算從客戶端,直到它不再願意送他們。然後假設你會拿一個物體,然後寫一個物體並沖洗並重復,你需要做的改變如下。

ObjectInputStream serverInputStream = new ObjectInputStream(pipe.getInputStream()); 
    ObjectOutputStream serverOutputStream = new ObjectOutputStream(pipe.getOutputStream()); 
    while (true) { 
     c = (Calculator)serverInputStream.readObject(); 
     c.setResult(s.Calculate(c.getFirstNumber(), c.getSecondNumber(),c.getOperation())); 
     serverOutputStream.writeObject(c); 
    } 

您需要添加一些邏輯來打破基於客戶端離開,雖然還是會循環永遠是循環的。

0

在等待客戶端輸入的循環中,服務器一遍又一遍地寫入c。

經過下一次計算,客戶端沒有得到c的更新版本。要獲取更新對象的新副本,您需要撥打serverOutputStream.reset()

ObjectStreams爲已寫入的每個對象添加引用。您需要調用重置,這會刪除先前寫入的對象的所有引用。使您能夠發送已編輯的副本。

主要問題是您如何從服務器發送循環中的對象。你不斷地將它永久地連續發送到一個永恆的真實循環中。