Socket通信

发表于   |   分类于

Socket是进程通讯的一种方式，即调用这个网络库的一些API函数实现分布在不同主机的相关进程之间的数据交
换。

Socket通信模型

Socket

Socket通信实现步骤

  1. 创建ServerSocket和Socket
  2. 打开连接到Socket的输入/输出流
  3. 按照协议对Socket进行读/写操作
  4. 关闭输入输出流、关闭Socket

基于TCP的Socket通信

服务器端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
/*
 * 基于TCP协议的Socket通信
 * 服务器端
 */
public class Server {
	public static void main(String[] args) {
		try {
			//1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
			ServerSocket serverSocket = new ServerSocket(1945);
			//2.调用accept()方法开始监听，等待客户端的连接
			System.out.println("***服务器即将启动，等待客户端的连接***");
			Socket socket = serverSocket.accept();
			//3.获取输入流，并读取客户端信息
			InputStream is = socket.getInputStream();//字节输入流
			InputStreamReader isr = new InputStreamReader(is);//将字节流转换为字符流
			BufferedReader br = new BufferedReader(isr);//为输入流添加缓冲
			String info = null;
			//循环读取客户端信息
			while((info = br.readLine())!=null){
				System.out.println("我是服务器，客户端说：" + info);
			}
			socket.shutdownInput();//关闭输入流
			//4.获取输出流，响应客户端的请求
			OutputStream os = socket.getOutputStream();
			PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
			pw.write("欢迎您");
			pw.flush();//调用flush()方法将缓存输出
			//5.关闭相关资源
			pw.close();
			os.close();
			br.close();
			isr.close();
			is.close();
			socket.close();
			serverSocket.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
/*
 * 客户端
 */
public class Client {
	public static void main(String[] args) {
		try {
			//1.创建客户端Socket，指定服务器地址和端口
			Socket socket = new Socket("localhost", 1945);//在本地运行客户端和服务端，可不写ip地址
			//2.获取输出流，向服务器端发送信息
			OutputStream os = socket.getOutputStream();//字节输出流
			PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
			pw.write("用户名：admin；密码：123");
			pw.flush();
			socket.shutdownOutput();//关闭输出流
			//3.获取输入流，并读取服务端的相应信息
			InputStream is = socket.getInputStream();
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String info = null;
			//循环读取客户端信息
			while((info = br.readLine())!=null){
				System.out.println("我是客户端，服务器说：" + info);
			}
			//4.关闭相关资源
			br.close();
			is.close();
			pw.close();
			os.close();
			socket.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

输出结果

先运行服务器端，后运行客户端

1
2
***服务器即将启动，等待客户端的连接***
我是服务器，客户端说：用户名：admin；密码：123

1
我是客户端，服务器说：欢迎您

多线程服务器

应用多线程来实现服务器和多客户端之间的通信

基本步骤

  1. 服务器创建ServerSocket，循环调用accept()等待客户端连接
  2. 客户端创建一个socket并请求和服务器端连接
  3. 服务器接收客户端请求，创建socket与该客户建立专线连接
  4. 建立连接的两个socket在一个单独的线程上对话
  5. 服务器端继续等待新的连接

服务器线程处理类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
/*
 * 服务器线程处理类
 */
public class ServerThread extends Thread{
	Socket socket = null;
	public ServerThread(Socket socket){
		this.socket = socket;
	}
	
	//线程执行的操作，响应客户端的需求
	public void run() {
		InputStream is = null;
		InputStreamReader isr = null;
		BufferedReader br = null;
		OutputStream os = null;
		PrintWriter pw = null;
		try {
			//获取输入流，并读取客户端信息
			is = socket.getInputStream();//字节输入流
			isr = new InputStreamReader(is);//将字节流转换为字符流
			br = new BufferedReader(isr);//为输入流添加缓冲
			String info = null;
			//循环读取客户端信息
			while ((info = br.readLine()) != null) {
				System.out.println("我是服务器，客户端说：" + info);
			}
			socket.shutdownInput();//关闭输入流
			//获取输出流，响应客户端的请求
			os = socket.getOutputStream();
			pw = new PrintWriter(os);//将输出流包装为打印流
			pw.write("欢迎您");
			pw.flush();//调用flush()方法将缓存输出
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (pw != null)
					pw.close();
				if (os != null)
					os.close();
				if (br != null)
					br.close();
				if (isr != null)
					isr.close();
				if (is != null)
					is.close();
				if (socket != null)
					socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

服务器端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
/*
 * 基于TCP协议的Socket通信
 * 服务器端
 */
public class Server {
	public static void main(String[] args) {
		try {
			//创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
			ServerSocket serverSocket = new ServerSocket(1945);
			Socket socket = null;
			//记录客户端的数量
			int count = 0;
			System.out.println("***服务器即将启动，等待客户端的连接***");
			//循环监听等待客户端的连接
			while(true){
				//调用accept()方法开始监听，等待客户端的连接
				socket = serverSocket.accept();
				//创建一个新的线程
				ServerThread serverThread = new ServerThread(socket);
				//启动线程
				serverThread.start();
				count++;//统计客户端的数量
				System.out.println("客户端的数量："+ count);
				InetAddress address=socket.getInetAddress();
				System.out.println("当前客户端的IP："+address.getHostAddress());
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

客户端

为测试多线程添加一个客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
/*
 * 客户端
 */
public class Client2 {
	public static void main(String[] args) {
		try {
			//1.创建客户端Socket，指定服务器地址和端口
			Socket socket = new Socket("localhost", 1945);//在本地运行客户端和服务端，可不写ip地址
			//2.获取输出流，向服务器端发送信息
			OutputStream os = socket.getOutputStream();//字节输出流
			PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
			pw.write("用户名：abc；密码：456");
			pw.flush();
			socket.shutdownOutput();//关闭输出流
			//3.获取输入流，并读取服务端的相应信息
			InputStream is = socket.getInputStream();
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String info = null;
			//循环读取客户端信息
			while((info = br.readLine())!=null){
				System.out.println("我是客户端，服务器说：" + info);
			}
			//4.关闭相关资源
			br.close();
			is.close();
			pw.close();
			os.close();
			socket.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

输出结果

先运行服务器端，后运行客户端
localhost默认IP为127.0.0.1

1
2
3
4
5
6
7
***服务器即将启动，等待客户端的连接***
客户端的数量：1
当前客户端的IP：127.0.0.1
我是服务器，客户端说：用户名：admin；密码：123
客户端的数量：2
当前客户端的IP：127.0.0.1
我是服务器，客户端说：用户名：abc；密码：456

1
我是客户端，服务器说：欢迎您

基于UDP的Socket通信

UDP

UDP协议（用户数据协议）是无连接、不可靠的、无序的。
UDP协议以数据报作为数据传输的载体。
进行数据传输时，首先需要将要传输的数据定义成数据报（Datagram），在数据报中指明数据所要达到的
Socket（主机地址和端口号），然后再将数据报发送出去。

相关操作类

DatagramPacket:表示数据报包
DatagramSocket:进行端到端通信的类

服务器端实现步骤

  1. 创建DatagramSocket，指定端口号
  2. 创建DatagramPacket，接收客户端发送的数据
  3. 接收客户端发送的数据信息
  4. 读取数据
  5. 服务器端继续等待新的连接

客户端实现步骤

  1. 定义发送信息
  2. 创建DatagramPacket，包含将要发送的信息
  3. 创建DatagramSocket，实现数据发送
  4. 发送数据

服务器端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/*
 * 服务器端，实现基于UDP的用户登陆
 */
public class UDPServer {
	public static void main(String[] args) throws IOException {
		/*
		 * 接收客户端发送的数据
		 */
		//1.创建服务器端DatagramSocket，指定端口
		DatagramSocket socket=new DatagramSocket(8800);
		//2.创建数据报，用于接收客户端发送的数据
		byte[] data =new byte[1024];//创建字节数组，指定接收的数据包的大小
		DatagramPacket packet=new DatagramPacket(data, data.length);
		//3.接收客户端发送的数据
		System.out.println("****服务器端已经启动，等待客户端发送数据");
		socket.receive(packet);//此方法在接收到数据报之前会一直阻塞
		//4.读取数据
		String info=new String(data, 0, packet.getLength());
		System.out.println("我是服务器，客户端说："+info);
		
		/*
		 * 向客户端响应数据
		 */
		//1.定义客户端的地址、端口号、数据
		InetAddress address=packet.getAddress();
		int port=packet.getPort();
		byte[] data2="欢迎您!".getBytes();
		//2.创建数据报，包含响应的数据信息
		DatagramPacket packet2=new DatagramPacket(data2, data2.length, address, port);
		//3.响应客户端
		socket.send(packet2);
		//4.关闭资源
		socket.close();
	}
}

客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
/*
 * 客户端
 */
public class UDPClient {
	public static void main(String[] args) throws IOException {
		/*
		 * 向服务器端发送数据
		 */
		//1.定义服务器的地址、端口号、数据
		InetAddress address=InetAddress.getByName("localhost");
		int port=8800;
		byte[] data="用户名：admin;密码：123".getBytes();
		//2.创建数据报，包含发送的数据信息
		DatagramPacket packet=new DatagramPacket(data, data.length, address, port);
		//3.创建DatagramSocket对象
		DatagramSocket socket=new DatagramSocket();
		//4.向服务器端发送数据报
		socket.send(packet);
		
		/*
		 * 接收服务器端响应的数据
		 */
		//1.创建数据报，用于接收服务器端响应的数据
		byte[] data2=new byte[1024];
		DatagramPacket packet2=new DatagramPacket(data2, data2.length);
		//2.接收服务器响应的数据
		socket.receive(packet2);
		//3.读取数据
		String reply=new String(data2, 0, packet2.getLength());
		System.out.println("我是客户端，服务器说："+reply);
		//4.关闭资源
		socket.close();
	}
}

输出结果

1
2
****服务器端已经启动，等待客户端发送数据
我是服务器，客户端说：用户名：admin;密码：123
1
我是客户端，服务器说：欢迎您!