循序渐进Socket网络编程（多客户端、信息共享、文件传输）
前言：在最近一个即将结束的项目中使用到了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类及其子类完成的。
列出几个常用的构造方法：
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方法：
public InputStream getInputStream(); //方法获得网络连接输入，同时返回一个IutputStream对象实例
public OutputStream getOutputStream(); //方法连接的另一端将得到输入，同时返回一个OutputStream对象实例
public Socket accept(); //用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。
"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。
注意： 其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。
四、基本的Client/Server程序
以下是一个基本的客户端/服务器端程序代码。主要实现了服务器端一直监听某个端口，等待客户端连接请求。客户端根据IP地址和端口号连接服务器端，从键盘上输入一行信息，发送到服务器端，然后接收服务器端返回的信息，最后结束会话。这个程序一次只能接受一个客户连接。
ps：这个小例子写好后，服务端一直接收不到消息，调试了好长时间，才发现误使用了PrintWriter的print()方法，而BufferedReader的readLine()方法一直没有遇到换行，所以一直等待读取。我晕死~~@_@
客户端程序：
package com.socket;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class SocketClient {
public static void main(String[] args) {
try {
/** 创建Socket*/
// 创建一个流套接字并将其连接到指定 IP 地址的指定端口号(本处是本机)
Socket socket = new Socket( "127.0.0.1" , 2013 );
// 60s超时
socket.setSoTimeout( 60000 );
/** 发送客户端准备传输的信息 */
// 由Socket对象得到输出流，并构造PrintWriter对象
PrintWriter printWriter = new PrintWriter(socket.getOutputStream(), true );
// 将输入读入的字符串输出到Server
BufferedReader sysBuff = new BufferedReader( new InputStreamReader(System.in));
printWriter.println(sysBuff.readLine());
// 刷新输出流，使Server马上收到该字符串
printWriter.flush();
/** 用于获取服务端传输来的信息 */
// 由Socket对象得到输入流，并构造相应的BufferedReader对象
BufferedReader bufferedReader = new BufferedReader( new InputStreamReader(socket.getInputStream()));
// 输入读入一字符串
String result = bufferedReader.readLine();
System.out.println( "Server say : " + result);
/** 关闭Socket*/
printWriter.close();
bufferedReader.close();
socket.close();
} catch (Exception e) {
System.out.println( "Exception:" + e);
}
}
}
服务器端程序：
package com.socket;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketServer {
public static void main(String[] args) {
try {
/** 创建ServerSocket*/
// 创建一个ServerSocket在端口2013监听客户请求
ServerSocket serverSocket = new ServerSocket( 2013 );
while ( true ) {
// 侦听并接受到此Socket的连接,请求到来则产生一个Socket对象，并继续执行
Socket socket = serverSocket.accept();
/** 获取客户端传来的信息 */
// 由Socket对象得到输入流，并构造相应的BufferedReader对象
BufferedReader bufferedReader = new BufferedReader( new InputStreamReader(socket.getInputStream()));
// 获取从客户端读入的字符串
String result = bufferedReader.readLine();
System.out.println( "Client say : " + result);
/** 发送服务端准备传输的 */
// 由Socket对象得到输出流，并构造PrintWriter对象
PrintWriter printWriter = new PrintWriter(socket.getOutputStream());
printWriter.print( "hello Client, I am Server!" );
printWriter.flush();
/** 关闭Socket*/
printWriter.close();
bufferedReader.close();
socket.close();
}
} catch (Exception e) {
System.out.println( "Exception:" + e);
} finally {
// serverSocket.close();
}
}
}
五、多客户端连接服务器
上面的服务器端程序一次只能连接一个客户端，这在实际应用中显然是不可能的。通常的网络环境是多个客户端连接到某个主机进行通讯，所以我们要对上面的程序进行改造。
设计思路：服务器端主程序监听某一个端口，客户端发起连接请求，服务器端主程序接收请求，同时构造一个线程类，用于接管会话。当一个Socket会话产生后，这个会话就会交给线程进行处理，主程序继续进行监听。
下面的实现程序流程是：客户端和服务器建立连接，客户端发送消息，服务端根据消息进行处理并返回消息，若客户端申请关闭，则服务器关闭此连接，双方通讯结束。
客户端程序：
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class SocketClient {
public static void main(String[] args) {
try {
Socket socket = new Socket( "127.0.0.1" , 2013 );
socket.setSoTimeout( 60000 );
PrintWriter printWriter = new PrintWriter(socket.getOutputStream(), true );
BufferedReader bufferedReader = new BufferedReader( new InputStreamReader(socket.getInputStream()));
String result = "" ;
while (result.indexOf( "bye" ) == - 1 ){
BufferedReader sysBuff = new BufferedReader( new InputStreamReader(System.in));
printWriter.println(sysBuff.readLine());
printWriter.flush();
result = bufferedReader.readLine();
System.out.println( "Server say : " + result);
}
printWriter.close();
bufferedReader.close();
socket.close();
} catch (Exception e) {
System.out.println( "Exception:" + e);
}
}
}
服务器端程序：
import java.io.*;
import java.net.*;
public class Server extends ServerSocket {
private static final int SERVER_PORT = 2013 ;
public Server() throws IOException {
super (SERVER_PORT);
try {
while ( true ) {
Socket socket = accept();
new CreateServerThread(socket); //当有请求时，启一个线程处理
}
} catch (IOException e) {
} finally {
close();
}
}
//线程类
class CreateServerThread extends Thread {
private Socket client;
private BufferedReader bufferedReader;
private PrintWriter printWriter;
public CreateServerThread(Socket s) throws IOException {
client = s;
bufferedReader = new BufferedReader( new InputStreamReader(client.getInputStream()));
printWriter = new PrintWriter(client.getOutputStream(), true );
System.out.println( "Client(" + getName() + ") come in..." );
start();
}
public void run() {
try {
String line = bufferedReader.readLine();
while (!line.equals( "bye" )) {
printWriter.println( "continue, Client(" + getName() + ")!" );
line = bufferedReader.readLine();
System.out.println( "Client(" + getName() + ") say: " + line);
}
printWriter.println( "bye, Client(" + getName() + ")!" );
System.out.println( "Client(" + getName() + ") exit!" );
printWriter.close();
bufferedReader.close();
client.close();
} catch (IOException e) {
}
}
}
public static void main(String[] args) throws IOException {
new Server();
}
}
六、信息共享
以上虽然实现了多个客户端和服务器连接，但是仍然是消息在一个客户端和服务器之间相互传播。现在我们要实现信息共享，即服务器可以向多个客户端发送广播消息，客户端也可以向其他客户端发送消息。类似于聊天室的那种功能，实现信息能在多个客户端之间共享。
设计思路：客户端循环可以不停输入向服务器发送消息，并且启一个线程，专门用来监听服务器端发来的消息并打印输出。服务器端启动时，启动一个监听何时需要向客户端发送消息的线程。每次接受客户端连接请求，都启一个线程进行处理，并且将客户端信息存放到公共集合中。当客户端发送消息时，服务器端将消息顺序存入队列中，当需要输出时，从队列中取出广播到各客户端处。客户端输入showuser命令可以查看在线用户列表，输入bye向服务器端申请退出连接。
PS：以下代码在测试时发现了一个中文乱码小问题，当文件设置UTF-8编码时，无论怎样在代码中设置输入流编码都不起作用，输入中文仍然会乱码。把文件设置为GBK编码后，不用在代码中设置输入流编码都能正常显示传输中文。
客户端代码：
import java.io.*;
import java.net.*;
public class Server extends ServerSocket {
private static final int SERVER_PORT = 2013 ;
public Server() throws IOException {
super (SERVER_PORT);
try {
while ( true ) {
Socket socket = accept();
new CreateServerThread(socket); //当有请求时，启一个线程处理
}
} catch (IOException e) {
} finally {
close();
}
}
//线程类
class CreateServerThread extends Thread {
private Socket client;
private BufferedReader bufferedReader;
private PrintWriter printWriter;
public CreateServerThread(Socket s) throws IOException {
client = s;
bufferedReader = new BufferedReader( new InputStreamReader(client.getInputStream()));
printWriter = new PrintWriter(client.getOutputStream(), true );
System.out.println( "Client(" + getName() + ") come in..." );
start();
}
public void run() {
try {
String line = bufferedReader.readLine();
while (!line.equals( "bye" )) {
printWriter.println( "continue, Client(" + getName() + ")!" );
line = bufferedReader.readLine();
System.out.println( "Client(" + getName() + ") say: " + line);
}
printWriter.println( "bye, Client(" + getName() + ")!" );
System.out.println( "Client(" + getName() + ") exit!" );
printWriter.close();
bufferedReader.close();
client.close();
} catch (IOException e) {
}
}
}
public static void main(String[] args) throws IOException {
new Server();
}
}
服务器端代码：
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Server extends ServerSocket{
private static final int SERVER_PORT = 2013 ;
private static boolean isPrint = false ; //是否输出消息标志
private static List user_list = new ArrayList(); //登录用户集合
private static List thread_list = new ArrayList(); //服务器已启用线程集合
private static LinkedList message_list = new LinkedList(); //存放消息队列
/**
* 创建服务端Socket,创建向客户端发送消息线程,监听客户端请求并处理
*/
public Server() throws IOException{
super (SERVER_PORT); //创建ServerSocket
new PrintOutThread(); //创建向客户端发送消息线程
try {
while ( true ){ //监听客户端请求，启个线程处理
Socket socket = accept();
new ServerThread(socket);
}
} catch (Exception e) {
} finally {
close();
}
}
/**
* 监听是否有输出消息请求线程类,向客户端发送消息
*/
class PrintOutThread extends Thread{
public PrintOutThread(){
start();
}
@Override
public void run() {
while ( true ){
if (isPrint){ //将缓存在队列中的消息按顺序发送到各客户端，并从队列中清除。
String message = message_list.getFirst();
for (ServerThread thread : thread_list) {
thread.sendMessage(message);
}
message_list.removeFirst();
isPrint = message_list.size() > 0 ? true : false ;
}
}
}
}
/**
* 服务器线程类
*/
class ServerThread extends Thread{
private Socket client;
private PrintWriter out;
private BufferedReader in;
private String name;
public ServerThread(Socket s) throws IOException{
client = s;
out = new PrintWriter(client.getOutputStream(), true );
in = new BufferedReader( new InputStreamReader(client.getInputStream()));
in.readLine();
out.println( "成功连上聊天室,请输入你的名字：" );
start();
}
@Override
public void run() {
try {
int flag = 0 ;
String line = in.readLine();
while (! "bye" .equals(line)){
//查看在线用户列表
if ( "showuser" .equals(line)) {
out.println( this .listOnlineUsers());
line = in.readLine();
}
//第一次进入，保存名字
if (flag++ == 0 ){
name = line;
user_list.add(name);
thread_list.add( this );
out.println(name + "你好,可以开始聊天了..." );
this .pushMessage( "Client<" + name + ">进入聊天室..." );
} else {
this .pushMessage( "Client<" + name + "> say : " + line);
}
line = in.readLine();
}
out.println( "byeClient" );
} catch (Exception e) {
e.printStackTrace();
} finally { //用户退出聊天室
try {
client.close();
} catch (IOException e) {
e.printStackTrace();
}
thread_list.remove( this );
user_list.remove(name);
pushMessage( "Client<" + name + ">退出了聊天室" );
}
}
//放入消息队列末尾，准备发送给客户端
private void pushMessage(String msg){
message_list.addLast(msg);
isPrint = true ;
}
//向客户端发送一条消息
private void sendMessage(String msg){
out.println(msg);
}
//统计在线用户列表
private String listOnlineUsers() {
String s = "--- 在线用户列表 ---\015\012" ;
for ( int i = 0 ; i < user_list.size(); i++) {
s += "[" + user_list.get(i) + "]\015\012" ;
}
s += "--------------------" ;
return s;
}
}
public static void main(String[] args) throws IOException {
new Server(); //启动服务端
}
}
七、文件传输
客户端向服务器端传送文件，服务端可获取文件名用于保存，获取文件大小计算传输进度，比较简单，直接贴代码。
客户端代码：
import java.io.File;
import java.io.FileInputStream;
import java.net.Socket;
/**
* 客户端
*/
public class Client extends Socket{
private static final String SERVER_IP = "127.0.0.1" ;
private static final int SERVER_PORT = 2013 ;
private Socket client;
private FileInputStream fis;
private DataOutputStream dos;
public Client(){
try {
try {
client = new Socket(SERVER_IP, SERVER_PORT);
//向服务端传送文件
File file = new File( "c:/test.doc" );
fis = new FileInputStream(file);
dos = new DataOutputStream(client.getOutputStream());
//文件名和长度
dos.writeUTF(file.getName());
dos.flush();
dos.writeLong(file.length());
dos.flush();
//传输文件
byte [] sendBytes = new byte [ 1024 ];
int length = 0 ;
while ((length = fis.read(sendBytes, 0 , sendBytes.length)) > 0 ){
dos.write(sendBytes, 0 , length);
dos.flush();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (fis != null )
fis.close();
if (dos != null )
dos.close();
client.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
new Client();
}
}
服务器端代码：
import java.io.File;
import java.io.FileOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服务器
*/
public class Server extends ServerSocket{
private static final int PORT = 2013 ;
private ServerSocket server;
private Socket client;
private DataInputStream dis;
private FileOutputStream fos;
public Server() throws Exception{
try {
try {
server = new ServerSocket(PORT);
while ( true ){
client = server.accept();
dis = new DataInputStream(client.getInputStream());
//文件名和长度
String fileName = dis.readUTF();
long fileLength = dis.readLong();
fos = new FileOutputStream( new File( "d:/" + fileName));
byte [] sendBytes = new byte [ 1024 ];
int transLen = 0 ;
System.out.println( "----开始接收文件<" + fileName + ">,文件大小为<" + fileLength + ">----" );
while ( true ){
int read = 0 ;
read = dis.read(sendBytes);
if (read == - 1 )
break ;
transLen += read;
System.out.println( "接收文件进度" + 100 * transLen/fileLength + "%..." );
fos.write(sendBytes, 0 , read);
fos.flush();
}
System.out.println( "----接收文件<" + fileName + ">成功-------" );
client.close();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (dis != null )
dis.close();
if (fos != null )
fos.close();
server.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
new Server();
}
}
分类: 1. JavaSE
作者： Leo_wl
出处： http://www.cnblogs.com/Leo_wl/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
版权信息查看更多关于循序渐进Socket网络编程（多客户端、信息共享、文件传输）的详细内容...