通过 Socket 实现 TCP 编程入门

这里我们通过一个用户登录的例子来学习基于 TCP 协议的 Socket 通信。

 

Socket 通信模型

 

 

Socket通信步骤

 

ServerSocket 构造器和成员方法

1、ServerSocket 构造方法

 

2、ServerSocket 成员方法

 

Socket 构造器和成员方法

1、Socket 构造器

 

2、Socket 成员方法

 

一个服务端和支持多个客户端的对话demo

1、server.java

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

 

2、ServerThread.java

1. package com.liuyanzhao;
3. import java.io.*;
4. import java.net.Socket;
6. /**
7.  * 服务器线程处理类
8.  * @author 言曌
9.  * @date 2017/12/4 下午8:32
10.  */
12. public class ServerThread extends Thread {
13.     //本线程相关的Socket
14.     Socket socket = null;
16.     public ServerThread(Socket socket) {
17.         this.socket = socket;
18.     }
20.     //线程执行操作，响应客户端的请求
21.     public void run() {
22.         InputStream inputStream = null;//字符输入流
23.         InputStreamReader inputStreamReader = null;
24.         BufferedReader bufferedReader = null;
25.         OutputStream outputStream = null;
26.         PrintWriter printWriter = null;
28.         try {
29.             //获取输入流，并读取客户端信息
30.             inputStream = socket.getInputStream();
31.             inputStreamReader = new InputStreamReader(inputStream);//将字节流转换成字符流
32.             bufferedReader = new BufferedReader(inputStreamReader);//为字符流添加缓存
33.             String info = null;
34.             while((info = bufferedReader.readLine()) != null) {
35.                 System.out.println("我是服务器，客户端说："+info);
36.             }
37.             socket.shutdownInput();//关闭输入流
38.             //获取输出流，响应客户端的请求
39.             outputStream = socket.getOutputStream();
40.             printWriter = new PrintWriter(outputStream);
41.             printWriter.write("欢迎您！");
42.             printWriter.flush();//刷新缓存
45.         } catch (IOException e) {
46.             e.printStackTrace();
47.         } finally {
48.             //关闭资源
49.             try {
50.                 if(bufferedReader != null) {
51.                     bufferedReader.close();
53.                 }
54.                 if(outputStream != null) {
55.                     outputStream.close();
56.                 }
57.                 if(inputStreamReader != null) {
58.                     inputStreamReader.close();
59.                 }
60.                 if(inputStream != null) {
61.                     inputStream.close();
63.                 }
64.                 if(socket != null) {
65.                     socket.close();
66.                 }
67.             } catch (IOException e) {
68.                 e.printStackTrace();
69.             }
70.         }
72.     }
74. }

 

3、Client.java

1. package com.liuyanzhao;
3. import java.io.*;
4. import java.net.Socket;
6. /**
7.  * 客户端
8.  * @author 言曌
9.  * @date 2017/12/4 下午7:37
10.  */
12. public class Client {
14.     public static void main(String args[]) {
15.         try {
16.             //1、创建客户端Socket，指定服务器地址和端口
17.             Socket socket = new Socket("localhost",8888);
18.             //2、获取输出流，向服务器端发送信息
19.             OutputStream outputStream = socket.getOutputStream();//字节输出流
20.             PrintWriter printWriter = new PrintWriter(outputStream);//将输出流包装为打印流
21.             printWriter.write("用户名：Tom;密码：123456");
22.             printWriter.flush();//刷新缓存，输出信息
23.             socket.shutdownOutput();//关闭输出流
24.             //3、获取输入流，并读取服务器的响应信息
25.             InputStream inputStream = socket.getInputStream();
26.             BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
27.             String info = null;
28.             while((info = bufferedReader.readLine()) != null) {
29.                 System.out.println("我是客户端，服务器说："+info);
30.             }
31.             //4、 关闭资源
32.             printWriter.close();
33.             bufferedReader.close();
34.             inputStream.close();
35.             outputStream.close();
36.             socket.close();
38.         } catch (IOException e) {
39.             e.printStackTrace();
40.         }
42.     }
43. }

 

上面的程序支持一个服务端和多个客户端对话。

运行效果

1、先运行 Server 类

 

2、再运行 Client 类

服务端界面

 

客户端界面

 

3、再运行一次 Client 类，再启动一个客户端

服务端界面

 

客户端界面如上

 

 

本文参考：慕课网

本文地址：https://liuyanzhao.com/6907.html