循序渐进Java Socket网络编程（多客户端、信息共享、文件传输）

目录[-]

• 一、TCP/IP协议

• 二、TCP与UDP

• 三、Socket是什么

• 四、Java中的Socket

• 五、基本的Client/Server程序

• 六、多客户端连接服务器

• 七、信息共享

• 八、文件传输

• 推荐阅读：

前言：在最近一个即将结束的项目中使用到了Socket编程，用于调用另一系统进行处理并返回数据。故把Socket的基础知识总结梳理一遍。

一、TCP/IP协议

　　既然是网络编程，涉及几个系统之间的交互，那么首先要考虑的是如何准确的定位到网络上的一台或几台主机，另一个是如何进行可靠高效的数据传输。这里就要使用到TCP/IP协议。

　　TCP/IP协议（传输控制协议）由网络层的IP协议和传输层的TCP协议组成。IP层负责网络主机的定位，数据传输的路由，由IP地址可以唯一的确定Internet上的一台主机。TCP层负责面向应用的可靠的或非可靠的数据传输机制，这是网络编程的主要对象。

二、TCP与UDP

　　TCP是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。

　　UDP是一种面向无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。

TCP与UDP区别：

TCP特点：

　　1、TCP是面向连接的协议，通过三次握手建立连接，通讯完成时要拆除连接，由于TCP是面向连接协议，所以只能用于点对点的通讯。而且建立连接也需要消耗时间和开销。

　　2、TCP传输数据无大小限制，进行大数据传输。

　　3、TCP是一个可靠的协议，它能保证接收方能够完整正确地接收到发送方发送的全部数据。

UDP特点：

　　1、UDP是面向无连接的通讯协议，UDP数据包括目的端口号和源端口号信息，由于通讯不需要连接，所以可以实现广播发送。

　　2、UDP传输数据时有大小限制，每个被传输的数据报必须限定在64KB之内。

　　3、UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方。

TCP与UDP应用：

　　1、TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。但是可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，因此TCP传输的效率不如UDP高。

　　2，UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。例如视频会议系统，并不要求音频视频数据绝对的正确，只要保证连贯性就可以了，这种情况下显然使用UDP会更合理一些。

三、Socket是什么

　　Socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket，一个Socket由一个IP地址和一个端口号唯一确定。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。 Socket是TCP/IP协议的一个十分流行的编程界面，但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。

　　Socket通讯过程：服务端监听某个端口是否有连接请求，客户端向服务端发送连接请求，服务端收到连接请求向客户端发出接收消息，这样一个连接就建立起来了。客户端和服务端都可以相互发送消息与对方进行通讯。

　　Socket的基本工作过程包含以下四个步骤：

　　1、创建Socket；

　　2、打开连接到Socket的输入输出流；

　　3、按照一定的协议对Socket进行读写操作；

　　4、关闭Socket。

四、Java中的Socket

　　在java.net包下有两个类：Socket和ServerSocket。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。

列出几个常用的构造方法：

?

1 2 3 4 5 6 7 8 9

Socket(InetAddress address,int port);//创建一个流套接字并将其连接到指定 IP 地址的指定端口号 Socket(String host,int port);//创建一个流套接字并将其连接到指定主机上的指定端口号 Socket(InetAddress address,int port, InetAddress localAddr,int localPort);//创建一个套接字并将其连接到指定远程地址上的指定远程端口 Socket(String host,int port, InetAddress localAddr,int localPort);//创建一个套接字并将其连接到指定远程主机上的指定远程端口 Socket(SocketImpl impl);//使用用户指定的 SocketImpl 创建一个未连接 Socket ServerSocket(int port);//创建绑定到特定端口的服务器套接字 ServerSocket(int port,int backlog);//利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号 ServerSocket(int port,int backlog, InetAddress bindAddr);//使用指定的端口、侦听 backlog 和要绑定到的本地 IP地址创建服务器

　　构造方法的参数中，address、host和port分别是双向连接中另一方的IP地址、主机名和端 口号，stream指明socket是流socket还是数据报socket，localPort表示本地主机的端口号，localAddr和bindAddr是本地机器的地址（ServerSocket的主机地址），impl是socket的父类，既可以用来创建serverSocket又可以用来创建Socket。count则表示服务端所能支持的最大连接数。

注意：必须小心选择端口号。每一个端口提供一种特定的服务，只有给出正确的端口，才 能获得相应的服务。0~1023的端口号为系统所保留，例如http服务的端口号为80,telnet服务的端口号为21,ftp服务的端口号为23, 所以我们在选择端口号时，最好选择一个大于1023的数以防止发生冲突。

几个重要的Socke方法：

?

1 2 3

public InputStream getInputStream();//方法获得网络连接输入，同时返回一个IutputStream对象实例 public OutputStream getOutputStream();//方法连接的另一端将得到输入，同时返回一个OutputStream对象实例 public Socket accept();//用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。

"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。

注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。

五、基本的Client/Server程序

以下是一个基本的客户端/服务器端程序代码。主要实现了服务器端一直监听某个端口，等待客户端连接请求。客户端根据IP地址和端口号连接服务器端，从键盘上输入一行信息，发送到服务器端，然后接收服务器端返回的信息，最后结束会话。这个程序一次只能接受一个客户连接。

ps：这个小例子写好后，服务端一直接收不到消息，调试了好长时间，才发现误使用了PrintWriter的print()方法，而BufferedReader的readLine()方法一直没有遇到换行，所以一直等待读取。我晕死~~@_@

客户端程序：

view source

print?

01	package sock;

02

03	import java.io.BufferedReader;

04	import java.io.InputStreamReader;

05	import java.io.PrintWriter;

06	import java.net.Socket;

07

08	public class SocketClient {

09	public static void main(String[] args) {

10

try {

11	/** 创建Socket*/

12	// 创建一个流套接字并将其连接到指定 IP 地址的指定端口号(本处是本机)

13	Socket socket =new Socket("127.0.0.1",2013);

14

// 60s超时

15	socket.setSoTimeout(60000);

16

17	/** 发送客户端准备传输的信息 */

18	// 由Socket对象得到输出流，并构造PrintWriter对象

19	PrintWriter printWriter =new PrintWriter(socket.getOutputStream(),true);

20	// 将输入读入的字符串输出到Server

21	BufferedReader sysBuff =new BufferedReader(new InputStreamReader(System.in));

22	printWriter.println(sysBuff.readLine());

23	// 刷新输出流，使Server马上收到该字符串

24	printWriter.flush();

25

26	/** 用于获取服务端传输来的信息 */

27	// 由Socket对象得到输入流，并构造相应的BufferedReader对象

28	BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));

29	// 输入读入一字符串

30	String result = bufferedReader.readLine();

31	System.out.println("Server say : " + result);

32

33	/** 关闭Socket*/

34	printWriter.close();

35	bufferedReader.close();

36	socket.close();

37	}catch (Exception e) {

38	System.out.println("Exception:" + e);

39

}

40

}

41

}

服务器端程序：

view source

print?

01	package sock;

02	import java.io.BufferedReader;

03	import java.io.InputStreamReader;

04	import java.io.PrintWriter;

05	import java.net.ServerSocket;

06	import java.net.Socket;

07

08	public class SocketServer {

09	public static void main(String[] args) {

10

try {

11	/** 创建ServerSocket*/

12	// 创建一个ServerSocket在端口2013监听客户请求

13	ServerSocket serverSocket =new ServerSocket(2013);

14	while (true) {

15	// 侦听并接受到此Socket的连接,请求到来则产生一个Socket对象，并继续执行

16	Socket socket = serverSocket.accept();

17

18	/** 获取客户端传来的信息 */

19	// 由Socket对象得到输入流，并构造相应的BufferedReader对象

20	BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));

21	// 获取从客户端读入的字符串

22	String result = bufferedReader.readLine();

23	System.out.println("Client say : " + result);

24

25	/** 发送服务端准备传输的 */

26	// 由Socket对象得到输出流，并构造PrintWriter对象

27	PrintWriter printWriter =new PrintWriter(socket.getOutputStream());

28	printWriter.print("hello Client, I am Server!");

29	printWriter.flush();

30

31	/** 关闭Socket*/

32	printWriter.close();

33	bufferedReader.close();

34	socket.close();

35

}

36	}catch (Exception e) {

37	System.out.println("Exception:" + e);

38

}finally{

39	//          serverSocket.close();

40

}

41

}

42

}

六、多客户端连接服务器

上面的服务器端程序一次只能连接一个客户端，这在实际应用中显然是不可能的。通常的网络环境是多个客户端连接到某个主机进行通讯，所以我们要对上面的程序进行改造。

设计思路：服务器端主程序监听某一个端口，客户端发起连接请求，服务器端主程序接收请求，同时构造一个线程类，用于接管会话。当一个Socket会话产生后，这个会话就会交给线程进行处理，主程序继续进行监听。

下面的实现程序流程是：客户端和服务器建立连接，客户端发送消息，服务端根据消息进行处理并返回消息，若客户端申请关闭，则服务器关闭此连接，双方通讯结束。

客户端程序：

view source

print?

01	package sock;

02

03	import java.io.BufferedReader;

04	import java.io.InputStreamReader;

05	import java.io.PrintWriter;

06	import java.net.Socket;

07

08	public class SocketClient {

09	public static void main(String[] args) {

10

try {

11	Socket socket =new Socket("127.0.0.1",2013);

12	socket.setSoTimeout(60000);

13

14	PrintWriter printWriter =new PrintWriter(socket.getOutputStream(),true);

15	BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));

16

17	String result ="";

18	while(result.indexOf("bye") == -1){

19	BufferedReader sysBuff =new BufferedReader(new InputStreamReader(System.in));

20	printWriter.println(sysBuff.readLine());

21	printWriter.flush();

22

23	result = bufferedReader.readLine();

24	System.out.println("Server say : " + result);

25

}

26

27	printWriter.close();

28	bufferedReader.close();

29	socket.close();

30	}catch (Exception e) {

31	System.out.println("Exception:" + e);

32

}

33

}

34

}

服务器端程序：

view source

print?

01	package sock;

02	import java.io.*;

03	import java.net.*;

04

05	public class Server extends ServerSocket {

06	private static final int SERVER_PORT =2013;

07

08	public Server()throws IOException {

09	super(SERVER_PORT);

10

11

try {

12	while (true) {

13	Socket socket = accept();

14	new CreateServerThread(socket);//当有请求时，启一个线程处理

15

}

16	}catch (IOException e) {

17	}finally {

18

close();

19

}

20

}

21

22

//线程类

23	class CreateServerThread extends Thread {

24	private Socket client;

25	private BufferedReader bufferedReader;

26	private PrintWriter printWriter;

27

28	public CreateServerThread(Socket s)throws IOException {

29	client = s;

30

31	bufferedReader =new BufferedReader(new InputStreamReader(client.getInputStream()));

32

33	printWriter =new PrintWriter(client.getOutputStream(),true);

34	System.out.println("Client(" + getName() +") come in...");

35

36

start();

37

}

38

39	public void run() {

40

try {

41	String line = bufferedReader.readLine();

42

43	while (!line.equals("bye")) {

44	printWriter.println("continue, Client(" + getName() +")!");

45	line = bufferedReader.readLine();

46	System.out.println("Client(" + getName() +") say: " + line);

47

}

48	printWriter.println("bye, Client(" + getName() +")!");

49

50	System.out.println("Client(" + getName() +") exit!");

51	printWriter.close();

52	bufferedReader.close();

53	client.close();

54	}catch (IOException e) {

55

}

56

}

57

}

58

59	public static void main(String[] args)throws IOException {

60	new Server();

61

}

62

}

七、信息共享

以上虽然实现了多个客户端和服务器连接，但是仍然是消息在一个客户端和服务器之间相互传播。现在我们要实现信息共享，即服务器可以向多个客户端发送广播消息，客户端也可以向其他客户端发送消息。类似于聊天室的那种功能，实现信息能在多个客户端之间共享。

设计思路：客户端循环可以不停输入向服务器发送消息，并且启一个线程，专门用来监听服务器端发来的消息并打印输出。服务器端启动时，启动一个监听何时需要向客户端发送消息的线程。每次接受客户端连接请求，都启一个线程进行处理，并且将客户端信息存放到公共集合中。当客户端发送消息时，服务器端将消息顺序存入队列中，当需要输出时，从队列中取出广播到各客户端处。客户端输入showuser命令可以查看在线用户列表，输入bye向服务器端申请退出连接。

PS：以下代码在测试时发现了一个中文乱码小问题，当文件设置UTF-8编码时，无论怎样在代码中设置输入流编码都不起作用，输入中文仍然会乱码。把文件设置为GBK编码后，不用在代码中设置输入流编码都能正常显示传输中文。

客户端代码：

view source

print?

01	package sock;

02

03	import java.io.BufferedReader;

04	import java.io.InputStreamReader;

05	import java.io.PrintWriter;

06	import java.net.Socket;

07

08	public class SocketClient extends Socket{

09

10	private static final String SERVER_IP ="127.0.0.1";

11	private static final int SERVER_PORT =2013;

12

13	private Socket client;

14	private PrintWriter out;

15	private BufferedReader in;

16

17

/**

18	* 与服务器连接，并输入发送消息

19

*/

20	public SocketClient()throws Exception{

21	super(SERVER_IP, SERVER_PORT);

22	client =this;

23	out =new PrintWriter(this.getOutputStream(),true);

24	in =new BufferedReader(new InputStreamReader(this.getInputStream()));

25	new readLineThread();

26

27	while(true){

28	in =new BufferedReader(new InputStreamReader(System.in));

29	String input = in.readLine();

30	out.println(input);

31

}

32

}

33

34

/**

35	* 用于监听服务器端向客户端发送消息线程类

36

*/

37	class readLineThread extends Thread{

38

39	private BufferedReader buff;

40	public readLineThread(){

41

try {

42	buff =new BufferedReader(new InputStreamReader(client.getInputStream()));

43

start();

44	}catch (Exception e) {

45

}

46

}

47

48

@Override

49	public void run() {

50

try {

51	while(true){

52	String result = buff.readLine();

53	if("byeClient".equals(result)){//客户端申请退出，服务端返回确认退出

54

break;

55	}else{//输出服务端发送消息

56	System.out.println(result);

57

}

58

}

59	in.close();

60	out.close();

61	client.close();

62	}catch (Exception e) {

63

}

64

}

65

}

66

67	public static void main(String[] args) {

68

try {

69	new SocketClient();//启动客户端

70	}catch (Exception e) {

71

}

72

}

73

}

服务器端代码：

view source

print?

001	package sock;

002	import java.io.BufferedReader;

003	import java.io.IOException;

004	import java.io.InputStreamReader;

005	import java.io.PrintWriter;

006	import java.net.ServerSocket;

007	import java.net.Socket;

008	import java.util.ArrayList;

009	import java.util.LinkedList;

010	import java.util.List;

011

012

013	public class Server extends ServerSocket{

014

015	private static final int SERVER_PORT =2013;

016

017	private static boolean isPrint =false;//是否输出消息标志

018	private static List user_list =new ArrayList();//登录用户集合

019	private static List<ServerThread> thread_list =new ArrayList<ServerThread>();//服务器已启用线程集合

020	private static LinkedList<String> message_list =new LinkedList<String>();//存放消息队列

021

022

/**

023	* 创建服务端Socket,创建向客户端发送消息线程,监听客户端请求并处理

024

*/

025	public Server()throws IOException{

026	super(SERVER_PORT);//创建ServerSocket

027	new PrintOutThread();//创建向客户端发送消息线程

028

029

try {

030	while(true){//监听客户端请求，启个线程处理

031	Socket socket = accept();

032	new ServerThread(socket);

033

}

034	}catch (Exception e) {

035

}finally{

036

close();

037

}

038

}

039

040

/**

041	* 监听是否有输出消息请求线程类,向客户端发送消息

042

*/

043	class PrintOutThread extends Thread{

044

045	public PrintOutThread(){

046

start();

047

}

048

049

@Override

050	public void run() {

051	while(true){

052	if(isPrint){//将缓存在队列中的消息按顺序发送到各客户端，并从队列中清除。

053	String message = message_list.getFirst();

054	for (ServerThread thread : thread_list) {

055	thread.sendMessage(message);

056

}

057	message_list.removeFirst();

058	isPrint = message_list.size() >0 ?true :false;

059

}

060

}

061

}

062

}

063

064

/**

065

* 服务器线程类

066

*/

067	class ServerThread extends Thread{

068	private Socket client;

069	private PrintWriter out;

070	private BufferedReader in;

071	private String name;

072

073	public ServerThread(Socket s)throws IOException{

074	client = s;

075	out =new PrintWriter(client.getOutputStream(),true);

076	in =new BufferedReader(new InputStreamReader(client.getInputStream()));

077	in.readLine();

078	out.println("成功连上聊天室,请输入你的名字：");

079

start();

080

}

081

082

@Override

083	public void run() {

084

try {

085	int flag =0;

086	String line = in.readLine();

087	while(!"bye".equals(line)){

088	//查看在线用户列表

089	if ("showuser".equals(line)) {

090	out.println(this.listOnlineUsers());

091	line = in.readLine();

092

}

093	//第一次进入，保存名字

094	if(flag++ ==0){

095	name = line;

096	user_list.add(name);

097	thread_list.add(this);

098	out.println(name +"你好,可以开始聊天了...");

099	this.pushMessage("Client<" + name +">进入聊天室...");

100

}else{

101	this.pushMessage("Client<" + name +"> say : " + line);

102

}

103	line = in.readLine();

104

}

105	out.println("byeClient");

106	}catch (Exception e) {

107	e.printStackTrace();

108	}finally{//用户退出聊天室

109

try {

110	client.close();

111	}catch (IOException e) {

112	e.printStackTrace();

113

}

114	thread_list.remove(this);

115	user_list.remove(name);

116	pushMessage("Client<" + name +">退出了聊天室");

117

}

118

}

119

120	//放入消息队列末尾，准备发送给客户端

121	private void pushMessage(String msg){

122	message_list.addLast(msg);

123	isPrint =true;

124

}

125

126	//向客户端发送一条消息

127	private void sendMessage(String msg){

128	out.println(msg);

129

}

130

131	//统计在线用户列表

132	private String listOnlineUsers() {

133	String s ="--- 在线用户列表 ---\015\012";

134	for (int i =0; i < user_list.size(); i++) {

135	s +="[" + user_list.get(i) +"]\015\012";

136

}

137	s +="--------------------";

138

return s;

139

}

140

}

141

142	public static void main(String[] args)throws IOException {

143	new Server();//启动服务端

144

}

145

}

八、文件传输

客户端向服务器端传送文件，服务端可获取文件名用于保存，获取文件大小计算传输进度，比较简单，直接贴代码。

客户端代码：

view source

print?

01	package sock;

02

03	import java.io.DataOutputStream;

04	import java.io.File;

05	import java.io.FileInputStream;

06	import java.net.Socket;

07

08

/**

09

* 客户端

10

*/

11	public class Client extends Socket{

12

13	private static final String SERVER_IP ="127.0.0.1";

14	private static final int SERVER_PORT =2013;

15

16	private Socket client;

17	private FileInputStream fis;

18	private DataOutputStream dos;

19

20	public Client(){

21

try {

22

try {

23	client =new Socket(SERVER_IP, SERVER_PORT);

24	//向服务端传送文件

25	File file =new File("c:/test.doc");

26	fis =new FileInputStream(file);

27	dos =new DataOutputStream(client.getOutputStream());

28

29

//文件名和长度

30	dos.writeUTF(file.getName());

31	dos.flush();

32	dos.writeLong(file.length());

33	dos.flush();

34

35

//传输文件

36	byte[] sendBytes =new byte[1024];

37	int length =0;

38	while((length = fis.read(sendBytes,0, sendBytes.length)) >0){

39	dos.write(sendBytes,0, length);

40	dos.flush();

41

}

42	}catch (Exception e) {

43	e.printStackTrace();

44

}finally{

45	if(fis !=null)

46	fis.close();

47	if(dos !=null)

48	dos.close();

49	client.close();

50

}

51	}catch (Exception e) {

52	e.printStackTrace();

53

}

54

}

55

56	public static void main(String[] args)throws Exception {

57	new Client();

58

}

59

}

服务器端代码：

view source

print?

01	package sock;

02	import java.io.DataInputStream;

03	import java.io.File;

04	import java.io.FileOutputStream;

05	import java.net.ServerSocket;

06	import java.net.Socket;

07

08

/**

09

* 服务器

10

*/

11	public class Server extends ServerSocket{

12

13	private static final int PORT =2013;

14

15	private ServerSocket server;

16	private Socket client;

17	private DataInputStream dis;

18	private FileOutputStream fos;

19

20	public Server()throws Exception{

21

try {

22

try {

23	server =new ServerSocket(PORT);

24

25	while(true){

26	client = server.accept();

27

28	dis =new DataInputStream(client.getInputStream());

29

//文件名和长度

30	String fileName = dis.readUTF();

31	long fileLength = dis.readLong();

32	fos =new FileOutputStream(new File("d:/" + fileName));

33

34	byte[] sendBytes =new byte[1024];

35	int transLen =0;

36	System.out.println("----开始接收文件<" + fileName +">,文件大小为<" + fileLength +">----");

37	while(true){

38	int read =0;

39	read = dis.read(sendBytes);

40	if(read == -1)

41

break;

42	transLen += read;

43	System.out.println("接收文件进度" +100 * transLen/fileLength +"%...");

44	fos.write(sendBytes,0, read);

45	fos.flush();

46

}

47	System.out.println("----接收文件<" + fileName +">成功-------");

48	client.close();

49

}

50	}catch (Exception e) {

51	e.printStackTrace();

52	}finally {

53	if(dis !=null)

54	dis.close();

55	if(fos !=null)

56	fos.close();

57	server.close();

58

}

59	}catch (Exception e) {

60	e.printStackTrace();

61

}

62

}

63

64	public static void main(String[] args)throws Exception {

65	new Server();

66

}

67

}