Socket问题求救

Question

小弟新学scoket有些不明白的地方请教大虾们，以下是协议的部分内容
本接口协议采用Socket通讯的TCP长连接方式。服务器端为 管理平台，客户端为jinjzk。
消息头格式
描述
      为了统一数据包格式，本接口采用统一的消息头结构，即所有消息公共包头。
2.1.2 消息头定义
字段名 字节数 类型 描述
total_length 4 Integer 消息总长度(含消息头及消息体)
command_id 4 Integer 命令标识 （见小节2.1.3） 
sequence_id 16 String 时间戳YYMMDDhhmmss+4位消息流水号（0001-9999），（一对请求和应答消息的流水号必须相同）
2.1.3 消息命令标识定义请求名称 请求标识 消息方向 说明
login 0x00000001 jinjzk管理平台 登录请求
login_resp 0x80000001 jinjzk管理平台 登录请求的应答
close 0x00000005 jinjzk管理平台 退出请求
close_resp 0x80000005 jinjzk管理平台 退出请求的应答2.2 消息体描述
     本接口消息传递共有以下几部分内容。
1、客户端登陆；
2、客户端关闭连接；2.3.1 客户端登陆消息定义（Login）
字段名 字节数 类型 描述
Corp_ID 10 string ID
Login_Name 16 string 客户端登陆用户名
Login_Pwd 16 string 客户端登陆密码
Reserve 8 string 保留
不知道这样的程序该如何下手，请大家不吝赐教

Answer 1

请求名称 请求标识 消息方向 说明 
login 0x00000001 jinjzk->管理平台 登录请求 
login_resp 0x80000001 jinjzk<-管理平台 登录请求的应答 
close 0x00000005 jinjzk管理平台-> 退出请求 
close_resp 0x80000005 jinjzk管理平台<- 退出请求的应答这里把箭头漏掉了

Answer 2

package TestSocket;import java.io.Serializable;public final class Header implements Serializable {
private static final long serialVersionUID = 5182816937539658584L;
private int totalLength;
private int commandID;
private String sequenceID;

public Header(int length, int command, String sequence) {
this.totalLength = length;
this.commandID = command;
this.sequenceID = sequence;
} public int getCommandID() {
return this.commandID;
} public void setCommandID(int commandID) {
this.commandID = commandID;
} public String getSequenceID() {
return this.sequenceID;
} public void setSequenceID(String sequenceID) {
this.sequenceID = sequenceID;
} public int getTotalLength() {
return this.totalLength;
} public void setTotalLength(int totalLength) {
this.totalLength = totalLength;
}
}

Answer 3

package TestSocket;import java.io.Serializable;public final class Body implements Serializable {
private static final long serialVersionUID = 1L;
private Object[] objects = null; public Body(Object[] objs) {
this.objects = objs;
}

public Object[] getObjects() {
return this.objects;
}

public void setObjects(Object[] objects) {
this.objects = objects;
}
}

Answer 4

package TestSocket;import java.io.Serializable;public final class Message implements Serializable {
private static final long serialVersionUID = 1L;
private Header header = null;
private Body body = null; public Message(Header header, Body body) {
this.header = header;
this.body = body;
}

public final Body getBody() {
return this.body;
} public final void setBody(Body body) {
this.body = body;
} public final Header getHeader() {
return this.header;
} public final void setHeader(Header header) {
this.header = header;
}
}

Answer 5

package TestSocket;public final class LoginInfo {
private String corpID;
private String loginID;
private String loginPW;
private String reserve;

public LoginInfo() {
this.corpID = "";
this.loginID = "";
this.loginPW = "";
this.reserve = "        "; //8 spaces
}

public String getCorpID() {
return this.corpID;
}

public void setCorpID(String corpID) {
this.corpID = this.getFormatString(corpID, 10);
}

public String getLoginID() {
return this.loginID;
}

public void setLoginID(String loginID) {
this.loginID = this.getFormatString(loginID, 16);
}

public String getLoginPW() {
return this.loginPW;
}

public void setLoginPW(String loginPW) {
this.loginPW =  this.getFormatString(loginPW, 16);
}

public String getReserve() {
return this.reserve;
}

public void setReserve(String reserve) {
this.reserve = this.getFormatString(reserve, 8);
}

private String getFormatString(String source, int size) {
char[] chars = new char[size];
int strLength = source.length();

for(int i = 0; i < size; i++) {
if(i < strLength) {
chars[i] = source.charAt(i);
} else {
chars[i] = 32;
}
}

return new String(chars);
}
}

Answer 6

package TestSocket;import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.Date;public final class MessageFactory {
public static final int LoginRequest = 0x00000001;
public static final int LoginResponse = 0x80000001;
public static final int CloseRequest = 0x00000005;
public static final int CloseResponse = 0x80000005; private static final String DATEFORMAT = "yyMMddhhmmss";
private static final String NUMBERFORMAT = "0000";
private static final Object sequenceLock = new Object();
private static int sequence = 0; private MessageFactory() {
} public static Message createResponseMessage(int request, Object object, String sequenceId) {
switch (request) {
case MessageFactory.LoginResponse:
case MessageFactory.CloseResponse:
return new Message(new Header(24, request, sequenceId), null);
default:
return null;
}
}

public static Message createRequestMessage(int request, Object object) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(MessageFactory.DATEFORMAT);
DecimalFormat decimalFormat = new DecimalFormat(MessageFactory.NUMBERFORMAT); synchronized (sequenceLock) {
MessageFactory.sequence++;
String sequenceId = simpleDateFormat.format(new Date()) + decimalFormat.format(MessageFactory.sequence);
switch (request) {
case MessageFactory.LoginRequest:
if(object instanceof LoginInfo) {
LoginInfo loginInfo = (LoginInfo)object;
Object[] params = new Object[4];
params[0] = loginInfo.getCorpID();
params[1] = loginInfo.getLoginID();
params[2] = loginInfo.getLoginPW();
params[3] = loginInfo.getReserve();
return new Message(new Header(74, request, sequenceId), new Body(params));
}
return null;
case MessageFactory.CloseRequest:
return new Message(new Header(24, request, sequenceId), null);
default:
return null;
}
}
}
}

Answer 7

package TestSocket;import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;public final class SocketClient {
private Socket socket = null;
private ObjectInputStream socketIn = null;
private ObjectOutputStream socketOut = null;
private boolean isConnected;

public SocketClient() {
this.isConnected = false;
}

public synchronized boolean connectToServer(String serverHost, int serverPort) {
if(!this.isConnected) {
try {
this.socket = new Socket(serverHost, serverPort);
this.socketOut = new ObjectOutputStream(this.socket.getOutputStream());
this.socketIn = new ObjectInputStream(this.socket.getInputStream());
this.isConnected = true;
} catch (Exception e) {
this.isConnected = false;
e.printStackTrace();
try {
if (this.socketOut != null) {
this.socketOut.close();
}
if (this.socketIn != null) {
this.socketIn.close();
}
if (this.socket != null) {
this.socket.close();
}
} catch (Exception ee) {
ee.printStackTrace();
} finally {
this.socket = null;
this.socketIn = null;
this.socketOut = null;
}
}
}
return this.isConnected;
}

public synchronized void disconnectServer() {
if (this.isConnected) {
try {
this.socketOut.close();
this.socketIn.close();
this.socket.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
this.socket = null;
this.socketIn = null;
this.socketOut = null;
this.isConnected = false;
}
}
}

public synchronized boolean sendMessage(Message message) {
boolean retVal = false;

if(this.isConnected) {
try {
this.socketOut.writeObject(message);
this.socketOut.flush();
retVal = true;
} catch (Exception e) {
e.printStackTrace();
}
}
return retVal;
}

public synchronized Message receiveMessage() {
Message retVal = null;

if(this.isConnected) {
try {
Object readingObject = this.socketIn.readObject();
if (readingObject != null) {
if (readingObject instanceof Message) {
retVal = (Message)readingObject;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}

return retVal;
}

protected void finalize() {
this.disconnectServer();
}
}

Answer 8

package TestSocket;import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public final class SocketServer extends Thread {
private static final int THREAD_POOL_SIZE_PER_CPU = 10;
private static SocketServer instance = null; private ServerSocket serverSocket;
private ExecutorService executorService;
private Object runningLock = new Object();
private boolean isStop = false; private SocketServer(int port) throws Exception {
this.serverSocket = new ServerSocket(port);
this.executorService = Executors.newFixedThreadPool(Runtime
.getRuntime().availableProcessors()
* THREAD_POOL_SIZE_PER_CPU);
} public static synchronized SocketServer getInstance(int port)
throws Exception {
if (SocketServer.instance == null) {
SocketServer.instance = new SocketServer(port);
}
return SocketServer.instance;
} public void run() {
Socket clientSocket = null;
boolean isStopped = false;
while (!isStopped) {
try {
clientSocket = this.serverSocket.accept();
this.executorService.execute(new SocketConnectionHandler(
clientSocket));
synchronized (this.runningLock) {
isStopped = this.isStop;
}
SocketServer.sleep(0);
} catch (Exception e) {
e.printStackTrace();
try {
if (clientSocket != null) {
clientSocket.close();
}
} catch (Exception ee) {
ee.printStackTrace();
}
}
}
}

public void stopIt() {
synchronized (this.runningLock) {
this.isStop = true;
}
}

protected void finalize() {
this.stopIt();
}


}

Answer 9

package TestSocket;import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;public final class SocketConnectionHandler implements Runnable {
private Socket clientSocket;

public SocketConnectionHandler(Socket socket) {
this.clientSocket = socket;
}

public void run() {
ObjectInputStream socketIn = null;
ObjectOutputStream socketOut = null;
try {
socketIn = new ObjectInputStream(this.clientSocket.getInputStream());
socketOut = new ObjectOutputStream(this.clientSocket
.getOutputStream());
Object readingObject;
Message inMessage;
Message outMessage;
Header header;
Body body;
while ((readingObject = socketIn.readObject()) != null) {
if (readingObject instanceof Message) {
inMessage = (Message)readingObject;
header = inMessage.getHeader();
System.out.println("CommandID=" + Integer.toHexString(header.getCommandID()));
System.out.println("SequenceID=" + header.getSequenceID());
body = inMessage.getBody();
switch(header.getCommandID()) {
case MessageFactory.LoginRequest:
LoginInfo loginInfo = new LoginInfo();
if(body != null) {
Object[] objs = body.getObjects();
if(objs.length == 4) {
if(objs[0] instanceof String) {
loginInfo.setCorpID((String)objs[0]);
}
if(objs[1] instanceof String) {
loginInfo.setLoginID((String)objs[1]);
}
if(objs[2] instanceof String) {
loginInfo.setLoginPW((String)objs[2]);
}
if(objs[3] instanceof String) {
loginInfo.setReserve((String)objs[3]);
}
}
}
System.out.println("CorpID=\"" + loginInfo.getCorpID() + "\"");
System.out.println("LoginID=\"" + loginInfo.getLoginID() + "\"");
System.out.println("LoginPW=\"" + loginInfo.getLoginPW() + "\"");
System.out.println("Reserve=\"" + loginInfo.getReserve() + "\"");
outMessage = MessageFactory.createResponseMessage(MessageFactory.LoginResponse, null, header.getSequenceID());
socketOut.writeObject(outMessage);
socketOut.flush();
break;
case MessageFactory.CloseRequest:
//do something...
outMessage = MessageFactory.createResponseMessage(MessageFactory.CloseResponse, null, header.getSequenceID());
socketOut.writeObject(outMessage);
socketOut.flush();
break;
}
}
}
} catch (Exception e) {
return;
} finally {
try {
if (socketIn != null) {
socketIn.close();
}
if (socketOut != null) {
socketOut.close();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (this.clientSocket != null) {
this.clientSocket.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}

Answer 10

package TestSocket;public final class SocketClientTester { public static void main(String[] args) {
LoginInfo loginInfo = new LoginInfo();
loginInfo.setCorpID("1234567890");
loginInfo.setLoginID("1234567890123456");
loginInfo.setLoginPW("1234567890123456");
Message message = MessageFactory.createRequestMessage(MessageFactory.LoginRequest, loginInfo);
System.out.println(message.getHeader().getSequenceID());
SocketClient socketClient = new SocketClient();
if(socketClient.connectToServer("127.0.0.1", 10888)) {
if(socketClient.sendMessage(message)) {
System.out.println("sending ok");
Message inMessage = socketClient.receiveMessage();
if(inMessage != null) {
System.out.println("CommandID=" + Integer.toHexString(inMessage.getHeader().getCommandID()));
System.out.println("SequenceID=" + inMessage.getHeader().getSequenceID());
}
} else {
System.out.println("sending faild");
}
socketClient.disconnectServer();
}
}}

Answer 11

package TestSocket;public final class SocketServerTester { public static void main(String[] args) {
try {
SocketServer socketServer = SocketServer.getInstance(10888);
socketServer.start();
} catch (Exception e) {
e.printStackTrace();
}
}}