Javasocket客户端与服务端同步通信实例
发布时间：2010/7/17 15:29:45 来源：城市学习网 编辑：ziteng
导读:工作中没涉及有关JAVA SOCKET编程的实际经历，但理论大概了解。想正明一下自已的对JAVA SOCKET理解写个通信TEST,通过TEST验证了基本与理论相近。
1.开发工具：eclips3.2
2.工程基本结构：
2.1 工程名：SocketTest
2.2 包test1.service含类功能说明：
2.2.1 KKMultiServerThread 服务端多线程处理类.
2.2.2 KnockKnockProtocol 双方通信协义处理类。
2.2.3 KnockKnockProtocolFace 双方通信协义处理接口。
2.2.4 MyService 服务端监听处理主方法类。
2.2.5 MyClient 客户端主方法类。
2.3 包test1.error含类功能说明：
2.3.1 ResponseError 服务端处理客户端响应异常类。
3.工程基本结构具体说明及原码。
2.1 工程名：SocketTest
2.2 包test1.service含类功能说明：
2.2.1 KKMultiServerThread 服务端多线程处理类.
package test1.service;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import test1.error.ResponseError;
/**
* @功能：服务端处理客户端请求返回响应（多线程）
*/
public class KKMultiServerThread extends Thread {
private Socket clentSocket = null;
private KnockKnockProtocol kkpf = null;
private PrintWriter pw = null;
private BufferedReader bir = null;
public KKMultiServerThread() {
super("KKMultiServerThread");
}
public KKMultiServerThread(Socket clentSocket) {
super("KKMultiServerThread");
this.clentSocket = clentSocket;
}
public KKMultiServerThread(Socket clentSocket, KnockKnockProtocolFace kkpf) {
super("KKMultiServerThread");
this.clentSocket = clentSocket;
this.kkpf = (KnockKnockProtocol) kkpf;
}
public Socket getClentSocket() {
return clentSocket;
}
public void setClentSocket(Socket clentSocket) {
this.clentSocket = clentSocket;
}
public KnockKnockProtocol getKkpf() {
return kkpf;
}
public void setKkpf(KnockKnockProtocol kkpf) {
this.kkpf = kkpf;
}
// 运行线程
public void run() {
try {
pw = new PrintWriter(clentSocket.getOutputStream());
bir = new BufferedReader(new InputStreamReader(clentSocket
.getInputStream()));
String request = bir.readLine();
System.out.println("客户端请求： " + request);
InetAddress ia = clentSocket.getInetAddress();
System.out.println("客户端ip:"+ia.getHostAddress());
String response = kkpf.processInput(request);
// 向客户端发送
System.out.println("返回客户端响应：" + response);
kkpf.sendResponse(pw, response);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ResponseError e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
System.out.println("关闭客户与服务端的连接");
this.pw.close();
this.bir.close();
this.clentSocket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
} [NextPage] 2.2.2 KnockKnockProtocol 双方通信协义处理类。
package test1.service;
import java.io.PrintWriter;
import test1.error.ResponseError;
/**
* @功能：协义处理类
*/
public class KnockKnockProtocol implements KnockKnockProtocolFace {
private String response = null;
//获得客户端协义
public String processInput(String request) throws ResponseError {
if (request.equalsIgnoreCase(KnockKnockProtocolFace.QUERY_USER)) {
response = this.processQUERY_USER(request);
} else {
response = KnockKnockProtocolFace.NOT_EXIST_REQUEST_PROTOCOL_ERROR;
}
return this.response;
}
//处理QUERY_USER协义
public String processQUERY_USER(String request) throws ResponseError {
this.response = this.QUERY_USER_SUCCEED_INFO;
return this.response;
}
// 发送服务端请求
public void sendResponse(PrintWriter pw, String response) throws ResponseError {
pw.println(response);
pw.flush();
}
}
2.2.3 KnockKnockProtocolFace 双方通信协义处理接口。
package test1.service;
import java.io.PrintWriter;
import test1.error.ResponseError;
/**
* @功能：协义处理类接口
*/
public interface KnockKnockProtocolFace { //此属性没有从数据库或属性文件中读取。
public static final String EXIT = "EXIT";
public static final String QUERY_USER = "QUERY_USER";
public static final String ERROR = "ERROR";
public static final String QUERY_USER_ERROR_INFO = "QUERY_USER_ERROR";
public static final String QUERY_USER_SUCCEED_INFO = "QUERY_USER_SUCCEED";
public static final String NOT_EXIST_REQUEST_PROTOCOL_ERROR = "NOT_EXIST_REQUEST_PROTOCOL_ERROR";
public String processInput(String request) throws ResponseError;
public String processQUERY_USER(String request) throws ResponseError;
public void sendResponse(PrintWriter pw,String response) throws ResponseError;
}
2.2.4 MyService 服务端监听处理主方法类。
package test1.service;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**
*/
public class MyService {
private ServerSocket ss = null;
private KKMultiServerThread kkst = null;
private int PORT = 65534;
private long MILLIS = 0l;
private Socket s = null;
// 服务
public static void main(String[] args) {
new MyService().startMainService();
}
// 开启服务
private void startMainService() {
try {
// 设置服务端提供服端口
ss = new ServerSocket(this.PORT);
KnockKnockProtocol kkpl = new KnockKnockProtocol();
kkst = new KKMultiServerThread();
// /s = ss.accept();
int count = 0;
// 读取客户端信息
while (true) {
System.out.println("等待读取客户端信息");
//s = ss.accept();
KKMultiServerThread st = new KKMultiServerThread(ss.accept(),
new KnockKnockProtocol());
st.start();
st.sleep(0);
}
// 关闭客户端连接
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
System.out.println("服务端关闭客户端连接");
if (s != null)
s.close();
if (ss != null)
ss.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}[NextPage] 2.2.5 MyClient 客户端主方法类。
package test1.service;
import java.io.IOException;
import java.net.*;
import java.io.*;
/**
* @功能：客户监听
*/
public class MyClient {
private Socket s = null;
private BufferedReader br = null;
private BufferedReader brClent = null;
private PrintWriter pw = null;
// 客户端实实读取
public static void main(String[] args) {
// TODO Auto-generated method stub
for (int i = 0; i < args.length; i++) {
new MyClient().startClientService(args[i]);
}
}
// 开启客户端
private void startClientService(String command) {
try {
// for (int i = 0; i < 10; i++) {
s = new Socket(InetAddress.getLocalHost(), 65534);
System.out.println("建立与服务端的连接1" + s);
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
pw = new PrintWriter(s.getOutputStream());
// pw.println("QUERY_USER");
pw.println(command);
pw.flush();
// 如果得到服务端响应 新关闭与服务端的连接
boolean flag = true;
while (flag) {
if (br.ready()) {
System.out.println("res: " + br.readLine());
break;
}
}
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
// 关闭与服务端的连接
System.out.println("关闭与服务端的连接");
try {
if (br != null)
br.close();
if (pw != null)
pw.close();
if (s != null)
s.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
2.3 包test1.error含类功能说明：
2.3.1 ResponseError 服务端处理客户端响应异常类。
package test1.error;
public class ResponseError extends Exception {
public ResponseError(String msg) {
super(msg);
}
}
总结：
1.使用JAVA SOCKET 能够实现强健的网络程序。JAVA SOCKET 帮我们实现了许多网络通信底层技术。
2.以上代码并不作为实际应用，很多地方没有实现开闭原则，但是就测试程序而言足够。
