多线程的socket对象传输（DTO）示例

刚温习了一下DTO，自己做的一个多线程的socket数据传输示例！

AtomsServer.java
[code]
package exam.lingling;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AtomsServer
{
private int port = 8833;

private ServerSocket serverSocket;

private ExecutorService executorService;

private final int POOL_SIZE = 10;

public AtomsServer()
{
try
{
serverSocket = new ServerSocket(port);
executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
System.out.println("The server has started!");
} catch (IOException e)
{
System.out.println(e.getMessage());
}
}

public void serviceStart()
{
while (true)
{
Socket socket = null;
try
{
socket = serverSocket.accept();
executorService.execute(new ServerHandle(socket));

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

public static void main(String[] args)
{
new AtomsServer().serviceStart();
}
}

[/code]

ServerHandle.java
[code]

package exam.lingling;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;

public class ServerHandle implements Runnable
{
private Socket socket;

public ServerHandle(Socket socket)
{
this.socket = socket;
}

private ObjectInputStream getAtomsReceive(Socket socket) throws IOException
{
return new ObjectInputStream(socket.getInputStream());
}

public void run()
{
try
{
ObjectInputStream ois = this.getAtomsReceive(socket);
Object o = ois.readObject();
while (o != null)
{
AtomsData atomsdata = (AtomsData) o;
System.out.println("The version of operation is " + atomsdata.getVersion() + " .");
}
} catch (IOException e)
{
e.printStackTrace();
System.out.println(e.getMessage());
} catch (ClassNotFoundException e)
{
e.printStackTrace();
} finally
{
try
{
if (socket != null)
socket.close();
} catch (Exception e)
{
e.printStackTrace();
}
}
}
}

[/code]

AtomsClient.java

[code]

package exam.lingling;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AtomsClient
{
public static void main(String args[]) throws InterruptedException
{
ExecutorService exec = Executors.newFixedThreadPool(2);
for (int index = 0; index < 10; index++)
{
Runnable run = new Runnable()
{
private Socket socket = null;

private int port = 8833;

AtomsData atomsdata;

ObjectOutputStream oos = null;

public void run()
{
while (true)
{
try
{
socket = new Socket("localhost", port);
atomsdata = new AtomsData();
atomsdata.setVersion((new Double((long) (Math.random() * 1000))).toString());
oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(atomsdata);
} catch (IOException e)
{
e.printStackTrace();
} finally
{
try
{
oos.close();
} catch (Exception e)
{
e.printStackTrace();
}
}
}
}
};
exec.execute(run);
}
exec.shutdown();
}
}

[/code]

AtomsData.java
[code]

package exam.lingling;

import java.io.Serializable;

public class AtomsData implements Serializable
{
private static final long serialVersionUID = 1L;

private String version;

private int[] atomsArray;

AtomsData()
{
}

AtomsData(String version, int[] atomsArray)
{
this.version = version;
this.atomsArray = atomsArray;
}

public int[] getAtomsArray()
{
return atomsArray;
}

public void setAtomsArray(int[] atomsArray)
{
this.atomsArray = atomsArray;
}

public String getVersion()
{
return version;
}

public void setVersion(String version)
{
this.version = version;
}

public String toString()
{
return "AtomsData info:" + this.version;
}
}

[/code]