Socket连接中ObjectOutputStream.writeObject()的问题

Question

首先描述下我现在的程序
有一个已经实现了Serializable接口的自己的类X 同时也就是我在Socket连接中需要传输的类
C/S模型 Socket连接已经建立 连接没有任何问题
客户端线程里(run()方法) 需要循环特定次数 循环里面的内容是 对已存在的我的对象（X类）进行属性重新赋值 然后通过已建立的ObjectOutputStream的writeObject()方法发送此对象
目前看来 服务器部分工作正常 现在的问题是 客户端可以发送第一次该对象 到第二次 会抛出java.net.SocketException: Software caused connection abort: socket write error
我有用reset()方法重置对象输出流 没用 
我甚至尝试建立一个新的对象 第二次发送这个新的对象 仍然是这个异常 第一次工作良好 第二次发送新对象也会抛出同样异常 难道我的输出流变成一次性的了？
我想我把我的问题描述清楚了吧
求教各位高人 我的问题出在哪里了？以下是涉及到的代码 如果你们有兴趣的话 可以看看 - -
客户端类
------------------------------------------------
private void sendVote(Vote e) throws IOException {
clientOutput.writeObject(e);//clientOutput是ObjectOutputStream对象
clientOutput.reset();
}
------------------------------------------------
public void run() {
initialize();
try {
while (true) {
myObject = Object.start(1);//重新给myObject属性赋值的方法 该方法包含返回一个新的我的类的对象
sendVote(myVote);          //也就是说 每次myObject里装的都是新对象
System.out.println(read());
}
}
------------------------------------------------
异常全文：
java.net.SocketException: Software caused connection abort: socket write error
at java.net.SocketOutputStream.socketWrite0(Native Method)
at java.net.SocketOutputStream.socketWrite(Unknown Source)
at java.net.SocketOutputStream.write(Unknown Source)
at java.io.ObjectOutputStream$BlockDataOutputStream.drain(Unknown Source)
at java.io.ObjectOutputStream$BlockDataOutputStream.setBlockDataMode(Unknown Source)
at java.io.ObjectOutputStream.writeNonProxyDesc(Unknown Source)
at java.io.ObjectOutputStream.writeClassDesc(Unknown Source)
at java.io.ObjectOutputStream.writeOrdinaryObject(Unknown Source)
at java.io.ObjectOutputStream.writeObject0(Unknown Source)
at java.io.ObjectOutputStream.writeFatalException(Unknown Source)
at java.io.ObjectOutputStream.writeObject(Unknown Source)
at cs165.Client.sendVote(Client.java:45)
at cs165.Client.run(Client.java:62)
at cs165.Client.main(Client.java:98)
-------------------------------------------------

Answer 1

我从网上找个例子:
import java.io.*;
import java.net.*;
import java.util.*;
public class SimpleServer {
  public void send(Object object)throws IOException{
    ServerSocket serverSocket = new ServerSocket(8000);
    while(true){
      Socket socket=serverSocket.accept();
      OutputStream out=socket.getOutputStream();
      ObjectOutputStream oos=new ObjectOutputStream(out);
      oos.writeObject(object);
      oos.writeObject(object);
      oos.close();
      socket.close();
    }
  }
  public static void main(String args[])throws IOException {
    Object object=null;
    if(args.length>0 && args[0].equals("Date"))
      object=new Date();
    else if(args.length>0 && args[0].equals("Customer1"))
      object=new Customer1("Tom","1234");
    else if(args.length>0 && args[0].equals("Customer2")){
      Customer2 customer=new Customer2("Tom");
      Order2 order1=new Order2("number1",customer);
      Order2 order2=new Order2("number2",customer);
      customer.addOrder(order1);
      customer.addOrder(order2);
      object=customer;
    }else if(args.length>0 && args[0].equals("Customer3")){
      object=new Customer3("Tom","1234");
    }else if(args.length>0 && args[0].equals("Customer4")){
      Customer4 customer=new Customer4("Tom");
      Order4 order1=new Order4("number1",customer);
      Order4 order2=new Order4("number2",customer);
      customer.addOrder(order1);
      customer.addOrder(order2);
      object=customer;
    }else if(args.length>0 && args[0].equals("Customer5")){
      object=new Customer5("Tom",25);
    }else{
      object="Hello";
    }
    System.out.println("待发送的对象信息："+object);
    new SimpleServer().send(object);
  }
}

Answer 2

服务器类import java.net.*;
import java.util.concurrent.*;
import java.io.*;public class Server { private Vote vote;
private ServerSocket serverSocket;
private ObjectInputStream serverInput;
private PrintWriter serverOutput;
private Socket socket;
private ExecutorService executorService;
private final int POOL_SIZE = 10; public Server() throws IOException{
serverSocket = new ServerSocket(8821);
executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
.availableProcessors()
* POOL_SIZE);
System.out.println("Server initialized successfully!");
} public void start() {
while (true) {
Socket socket = null;
try {
socket = serverSocket.accept();
executorService.execute(new Handler(socket));
} catch (Exception e) {
e.printStackTrace();
}
}
} public Vote read() {
vote = new Vote("", "", "");
try {
while ((vote = (Vote) serverInput.readObject()) != null) {
return vote;
}
} catch (Exception e) {
System.out
.println("Error happens during reading in the server side!");
e.printStackTrace();
}
return vote;
} public int write(String s) {
try {
serverOutput.write(s);
return 1;
} catch (Exception e) {
System.out
.println("Error happens during writing in the server side!");
e.printStackTrace();
return 0;
}
} public void dispose() {
try {
serverOutput.close();
serverInput.close();
socket.close();
serverSocket.close();
} catch (IOException e) {
System.out.println("Fail to dispose Server!");
e.printStackTrace();
}
} public static void main(String[] args) throws IOException{
Server server = new Server();
server.start();

}
}Handler类 服务器类是壳 这个类负责处理客户端的多线程请求
import java.io.*;
import java.net.*;public class Handler implements Runnable {
private Socket socket;
private Vote vote;
BufferedReader bReader;
ObjectInputStream oReader;
PrintWriter writer;
private Vote voteReceived;
private String msg; public Handler(Socket socket) {
this.socket = socket;
} private PrintWriter getWriter(Socket socket) throws IOException {
OutputStream socketOut = socket.getOutputStream();
return new PrintWriter(socketOut, true);
} private BufferedReader getReader(Socket socket) throws IOException {
InputStream socketIn = socket.getInputStream();
return new BufferedReader(new InputStreamReader(socketIn));
} private ObjectInputStream getObjectInputStream(Socket socket)
throws IOException {
InputStream socketIn = socket.getInputStream();
return new ObjectInputStream(socketIn);
} public String echo(String msg) {
return "echo:" + msg;
} private String read() {
try {
msg = null;
while ((msg = bReader.readLine()) != null) {
return msg;
}
} catch (Exception e) {
System.out
.println("Error happens during reading in the server side!");
e.printStackTrace();
}
return msg;
} private Vote readVote() {
try {
voteReceived = null;
while ((voteReceived = (Vote) oReader.readObject()) != null) {
return voteReceived;
}
} catch (Exception e) {
System.out
.println("Error happens during reading in the server side!");
e.printStackTrace();
}
return voteReceived;
} private int write(String s) {
try {
writer.println(s);
return 1;
} catch (Exception e) {
System.out
.println("Error happens during writing in the server side!");
e.printStackTrace();
return 0;
}
} public void run() {
try {
System.out.println("New connection accepted "
+ socket.getInetAddress() + ":" + socket.getPort());
bReader = getReader(socket);
writer = getWriter(socket);
oReader = getObjectInputStream(socket);
vote = readVote();
write("I received a vote for: " + vote.getVotefor());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (socket != null) {
socket.close();
bReader.close();
writer.close();
oReader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}}客户端类
import java.io.*;
import java.net.*;public class Client implements Runnable { private String serverAddress;
private int port;
private ObjectOutputStream clientOutput;
private BufferedReader clientInput;
private PrintWriter msgWriter;
private Socket clientSocket;
private String information;
private Vote myVote = new Vote();
private String msg; public void initialize() {
try {
FileReader fr = new FileReader("./src/cs165/ServerAddress.txt");
BufferedReader br = new BufferedReader(fr);
serverAddress = br.readLine();
port = Integer.parseInt(br.readLine());
br.close();
fr.close();
clientSocket = new Socket(serverAddress, port);
clientOutput = new ObjectOutputStream(clientSocket
.getOutputStream());
clientInput = new BufferedReader(new InputStreamReader(clientSocket
.getInputStream()));
msgWriter = new PrintWriter(clientSocket.getOutputStream(), true);
} catch (Exception e) {
// TODO Auto-generated catch block
System.out.println("Error happens during initializing the client");
e.printStackTrace();
}
} private void sendMessage(String s) throws IOException {
msgWriter.println(s);
System.out.println("Message sent.");
} private void sendVote(Vote e) throws IOException {
clientOutput.writeObject(e);
clientOutput.reset();
} private String read() throws IOException {
information = null;
while ((information = clientInput.readLine()) != null) {
return information;
}
return "Error";
} public void run() {
initialize();
try {
while (true) {
myVote = myVote.start(1);
sendVote(myVote);
System.out.println(read());
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if (clientSocket != null) {
try {
clientSocket.close();
msgWriter.close();
clientInput.close();
clientOutput.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} } public void dispose() {
try {
clientInput.close();
clientOutput.close();
clientSocket.close();
} catch (IOException e) {
System.out.println("Fail to dispose the client!");
e.printStackTrace();
} } public static void main(String[] args) {
Client client = new Client();
client.run();
}
}