java基础完结——网络编程（2）

谁借莪１个温暖的怀抱￠ 2022-12-10 11:25 220阅读 0赞

1、基于TCP协议的网络编程

TCP(Transmission Control Protocol，传输控制协议)被称作一种端对端协议。是一种面向连接的、可靠的、基于字节流的传输层的通信协议，可以连续传输大量的数据。类似于打电话的效果。

这是因为它为当一台计算机需要与另一台远程计算机连接时，TCP协议会采用“三次握手”方式让它们建立一个连接，用于发送和接收数据的虚拟链路。数据传输完毕TCP协议会采用“四次挥手”方式断开连接。

TCP协议负责收集这些信息包，并将其按适当的次序放好传送，在接收端收到后再将其正确的还原。TCP协议保证了数据包在传送中准确无误。TCP协议使用重发机制，当一个通信实体发送一个消息给另一个通信实体后，需要收到另一个通信实体确认信息，如果没有收到另一个通信实体确认信息，则会再次重复刚才发送的消息。

1.1、基于TCP协议的网络通信程序结构

Java语言的基于套接字TCP编程分为服务端编程和客户端编程，其通信模型如图所示：

在这里插入图片描述

服务器程序的工作过程包含以下五个基本的步骤：

  1. 使用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
  2. 调用 accept()方法：监听连接请求，如果客户端请求连接，则接受连接，创建与该客户端的通信套接字对象。否则该方法将一直处于等待状态。
  3. 调用 该Socket对象的 getOutputStream() 和 getInputStream ()：获取输出流和输入流，开始网络数据的发送和接收。
  4. 关闭Socket对象：某客户端访问结束，关闭与之通信的套接字。
  5. 关闭ServerSocket：如果不再接收任何客户端的连接的话，调用close()进行关闭。

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

  1. 创建 Socket：根据指定服务端的 IP 地址或端口号构造 Socket 类对象，创建的同时会自动向服务器方发起连接。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
  2. 打开连接到Socket 的输入/出流：使用 getInputStream()方法获得输入流，使用 getOutputStream()方法获得输出流，进行数据传输。
  3. 进行读/写操作：通过输入流读取服务器发送的信息，通过输出流将信息发送给服务器。
  4. 关闭 Socket：断开客户端到服务器的连接

注意：客户端和服务器端在获取输入流和输出流时要对应，否则容易死锁。例如：客户端先获取字节输出流（即先写），那么服务器端就先获取字节输入流（即先读）；反过来客户端先获取字节输入流（即先读），那么服务器端就先获取字节输出流（即先写）。

1.2、案例：一个客户端与服务器单次通信

需求：客户端连接服务器，连接成功后给服务发送“lalala”，服务器收到消息后，给客户端返回“欢迎登录”

服务器端程序示例代码：

  1. package com.bdit.tcp.one;
  3. import java.io.InputStream;
  4. import java.io.OutputStream;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  8. public class Server {
  11.     public static void main(String[] args)throws Exception {
  13.         //1、准备一个ServerSocket对象，并绑定8888端口
  14.         ServerSocket server =  new ServerSocket(8888);
  15.         System.out.println("等待连接....");
  17.         //2、在8888端口监听客户端的连接，该方法是个阻塞的方法，如果没有客户端连接，将一直等待
  18.         Socket socket = server.accept();
  19.         System.out.println("一个客户端连接成功！！");
  21.         //3、获取输入流，用来接收该客户端发送给服务器的数据
  22.         InputStream input = socket.getInputStream();
  23.         //接收数据
  24.         byte[] data = new byte[1024];
  25.         StringBuilder s = new StringBuilder();
  26.         int len;
  27.         while ((len = input.read(data)) != -1) {
  29.             s.append(new String(data, 0, len));
  30.         }
  31.         System.out.println("客户端发送的消息是：" + s);
  33.         //4、获取输出流，用来发送数据给该客户端
  34.         OutputStream out = socket.getOutputStream();
  35.         //发送数据
  36.         out.write("欢迎登录".getBytes());
  37.         out.flush();
  39.         //5、关闭socket，不再与该客户端通信
  40.         //socket关闭，意味着InputStream和OutputStream也关闭了
  41.         socket.close();
  43.         //6、如果不再接收任何客户端通信，可以关闭ServerSocket
  44.         server.close();
  45.     }
  46. }

客户端程序示例代码：

  1. package com.bdit.tcp.one;
  3. import java.io.InputStream;
  4. import java.io.OutputStream;
  5. import java.net.Socket;
  7. public class Client {
  10.     public static void main(String[] args) throws Exception {
  12.         // 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
  13.         Socket socket = new Socket("127.0.0.1", 8888);
  15.         // 2、获取输出流，用来发送数据给服务器
  16.         OutputStream out = socket.getOutputStream();
  17.         // 发送数据
  18.         out.write("lalala".getBytes());
  19.         //会在流末尾写入一个“流的末尾”标记，对方才能读到-1，否则对方的读取方法会一致阻塞
  20.         socket.shutdownOutput();
  22.         //3、获取输入流，用来接收服务器发送给该客户端的数据
  23.         InputStream input = socket.getInputStream();
  24.         // 接收数据
  25.         byte[] data = new byte[1024];
  26.         StringBuilder s = new StringBuilder();
  27.         int len;
  28.         while ((len = input.read(data)) != -1) {
  30.             s.append(new String(data, 0, len));
  31.         }
  32.         System.out.println("服务器返回的消息是：" + s);
  34.         //4、关闭socket，不再与服务器通信，即断开与服务器的连接
  35.         //socket关闭，意味着InputStream和OutputStream也关闭了
  36.         socket.close();
  37.     }
  38. }

1.3、案例：多个客户端与服务器之间的多次通信

通常情况下，服务器不应该只接受一个客户端请求，而应该不断地接受来自客户端的所有请求，所以Java程序通常会通过循环，不断地调用ServerSocket的accept()方法。

如果服务器端要“同时”处理多个客户端的请求，因此服务器端需要为每一个客户端单独分配一个线程来处理，否则无法实现“同时”。

案例需求：多个客户端连接服务器，并进行多次通信

●每一个客户端连接成功后，从键盘输入英文单词或中国成语，并发送给服务器

● 服务器收到客户端的消息后，把词语“反转”后返回给客户端

● 客户端接收服务器返回的“词语”，打印显示

● 当客户端输入“stop”时断开与服务器的连接

● 多个客户端可以同时给服务器发送“词语”，服务器可以“同时”处理多个客户端的请求

在这里插入图片描述

思考分析：服务器端要“同时”处理多个客户端的请求，那么必须使用多线程，每一个客户端的通信需要单独的线程来处理。

客户端程序示例代码：

  1. package com.bdit.tcp.echo;
  3. import java.io.BufferedReader;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  6. import java.io.OutputStream;
  7. import java.io.PrintStream;
  8. import java.net.Socket;
  9. import java.util.Scanner;
  11. public class Client {
  14.     public static void main(String[] args) throws Exception {
  16.         // 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
  17.         Socket socket = new Socket("127.0.0.1", 8888);
  19.         // 2、获取输出流，用来发送数据给服务器
  20.         OutputStream out = socket.getOutputStream();
  21.         PrintStream ps = new PrintStream(out);
  23.         // 3、获取输入流，用来接收服务器发送给该客户端的数据
  24.         InputStream input = socket.getInputStream();
  25.         BufferedReader br = new BufferedReader(new InputStreamReader(input));
  27.         Scanner scanner = new Scanner(System.in);
  28.         while(true){
  30.             System.out.println("输入发送给服务器的单词或成语：");
  31.             String message = scanner.nextLine();
  32.             if(message.equals("stop")){
  34.                 socket.shutdownOutput();
  35.                 break;
  36.             }
  38.             // 4、 发送数据
  39.             ps.println(message);
  40.             // 接收数据
  41.             String feedback  = br.readLine();
  42.             System.out.println("从服务器收到的反馈是：" + feedback);
  43.         }
  45.         //5、关闭socket，断开与服务器的连接
  46.         scanner.close();
  47.         socket.close();
  48.     }
  49. }

服务器端程序示例代码：

  1. package com.bdit.tcp.echo;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  6. public class Server {
  9.     public static void main(String[] args)throws Exception {
  11.         // 1、准备一个ServerSocket
  12.         ServerSocket server = new ServerSocket(8888);
  13.         System.out.println("等待连接...");
  15.         int count = 0;
  16.         while(true){
  18.             // 2、监听一个客户端的连接
  19.             Socket socket = server.accept();
  20.             System.out.println("第" + ++count + "个客户端连接成功！！");
  22.             ClientHandlerThread ct = new ClientHandlerThread(socket);
  23.             ct.start();
  24.         }
  26.         //这里没有关闭server，永远监听
  27.     }
  28. }

服务器端处理客户端请求的线程类示例代码：

  1. package com.bdit.tcp.echo;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintStream;
  7. import java.net.Socket;
  9. public class ClientHandlerThread extends Thread{
  11.     private Socket socket;
  13.     public ClientHandlerThread(Socket socket) {
  15.         super();
  16.         this.socket = socket;
  17.     }
  19.     public void run(){
  22.         try{
  24.             //（1）获取输入流，用来接收该客户端发送给服务器的数据
  25.             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  26.             //（2）获取输出流，用来发送数据给该客户端
  27.             PrintStream ps = new PrintStream(socket.getOutputStream());
  28.             String str;
  29.             // （3）接收数据
  30.             while ((str = br.readLine()) != null) {
  32.                 //（4）反转
  33.                 StringBuilder word = new StringBuilder(str);
  34.                 word.reverse();
  36.                 //（5）返回给客户端
  37.                 ps.println(word);
  38.             }
  39.         }catch(Exception  e){
  41.             e.printStackTrace();
  42.         }finally{
  44.             try {
  46.                 //（6）断开连接
  47.                 socket.close();
  48.             } catch (IOException e) {
  50.                 e.printStackTrace();
  51.             }
  52.         }
  53.     }
  54. }

1.4、案例：多个客户端上传文件

需求：每一个客户端启动后都可以给服务器上传一个文件，服务器接收到文件后保存到一个upload目录中。可以同时接收多个客户端的文件上传。

思考分析：

（1）服务器端要“同时”处理多个客户端的请求，那么必须使用多线程，每一个客户端的通信需要单独的线程来处理。

（2）服务器保存上传文件的目录只有一个upload，而每个客户端给服务器发送的文件可能重名，所以需要保证文件名的唯一。我们可以使用“时间戳”作为文件名，而后缀名不变

（3）客户端需要给服务器上传文件名（含后缀名）以及文件内容。而文件名是字符串，文件内容不一定是纯文本的，因此选择DataOutputStream和DataInputStream。

客户端的示例代码：

  1. package com.bdit.tcp.fileupload;
  3. import java.io.BufferedReader;
  4. import java.io.DataOutputStream;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.InputStream;
  8. import java.io.InputStreamReader;
  9. import java.io.OutputStream;
  10. import java.net.Socket;
  11. import java.util.Scanner;
  13. public class Client {
  15.     public static void main(String[] args) throws Exception {
  17.         // (1)连接服务器
  18.         Socket socket = new Socket("192.168.34.53", 8888);
  20.         Scanner input = new Scanner(System.in);
  22.         //(2)从键盘输入文件的路径和名称
  23.         System.out.print("请选择要上传的文件：");
  24.         String path = input.nextLine();
  25.         File file = new File(path);
  27.         OutputStream out = socket.getOutputStream();
  28.         DataOutputStream dos = new DataOutputStream(out);//用它的目的是为了既可以单独传一个字符串，又可以写字节内容
  30.         //先发送文件名（含后缀名）
  31.         dos.writeUTF(file.getName());//单独发一个字符串
  33.         //还需要一个IO流，从文件读取内容，给服务器发过去
  34.         FileInputStream fis = new FileInputStream(file);
  36.         //（3）把文件内容给服务器传过去，类似与复制文件
  37.         byte[] data = new byte[1024];
  38.         while(true){
  40.             int len = fis.read(data);
  41.             if(len==-1){
  43.                 break;
  44.             }
  45.             dos.write(data, 0, len);
  46.         }
  47.         socket.shutdownOutput();
  49.         //(4)接收服务器返回的结果
  50.         InputStream is = socket.getInputStream();
  51.         InputStreamReader isr = new InputStreamReader(is);//把字节流转成字符流
  52.         BufferedReader br = new BufferedReader(isr);
  53.         String result = br.readLine();
  54.         System.out.println(result);
  56.         //(5)关闭
  57.         fis.close();
  58.         input.close();
  59.         socket.close();
  60.     }
  61. }

服务器端的示例代码：

  1. package com.bdit.tcp.fileupload;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  6. public class Server {
  8.     public static void main(String[] args) throws Exception{
  10.         //服务器在8888端口号监听数据
  11.         @SuppressWarnings("resource")
  12.         ServerSocket server = new ServerSocket(8888);
  14.         while(true){
  16.             //(2)等待连接 
  17.             //这句代码执行一次，意味着一个客户端连接
  18.             Socket accept = server.accept();
  20.             FileUploadThread ft = new FileUploadThread(accept);
  21.             ft.start();
  22.         }
  23.     }
  24. }

服务器端处理每一个客户端上传文件的线程类代码：

  1. package com.bdit.tcp.fileupload;
  3. import java.io.DataInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.OutputStream;
  9. import java.io.PrintStream;
  10. import java.net.Socket;
  11. import java.text.SimpleDateFormat;
  12. import java.util.Date;
  14. public class FileUploadThread extends Thread{
  16.     private Socket socket;
  17.     private String dir = "upload/";
  19.     public FileUploadThread(Socket socket) {
  21.         super();
  22.         this.socket = socket;
  23.     }
  25.     public void run(){
  27.         FileOutputStream fos = null;
  28.         try {
  30.             InputStream is = socket.getInputStream();
  31.             DataInputStream dis = new DataInputStream(is);
  33.             //读取文件名（含后缀名）
  34.             String filename = dis.readUTF();
  35.             //截取后缀名
  36.             String ext = filename.substring(filename.lastIndexOf("."));
  37.             //生成时间戳
  38.             SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
  39.             filename = sf.format(new Date());
  40.             //用新文件路径构建文件输出流
  41.             fos = new FileOutputStream(dir + filename + ext);
  42.             //接收文件内容
  43.             byte[] data = new byte[1024];
  44.             while(true){
  46.                 int len = is.read(data);
  47.                 if(len==-1){
  49.                     break;
  50.                 }
  51.                 fos.write(data, 0, len);
  52.             }
  54.             //返回结果
  55.             OutputStream out = socket.getOutputStream();
  56.             PrintStream ps = new PrintStream(out);
  57.             ps.println(filename + ext + "：已上传完毕");
  58.         } catch (FileNotFoundException e) {
  60.             e.printStackTrace();
  61.         } catch (IOException e) {
  63.             e.printStackTrace();
  64.         }finally{
  66.             try {
  68.                 fos.close();
  69.                 socket.close();
  70.             } catch (IOException e) {
  72.                 e.printStackTrace();
  73.             }
  74.         }
  75.     }
  76. }

1.5、案例：多个客户端群聊

需求：模拟聊天室群聊

客户端要先登录，登录成功之后才能发送和接收消息

思考分析：

● 服务器端，需要为每个客户端开启一个线程通信，这样才能实现多个客户端“同时”与服务器通信

● 客户端，需要把收消息功能与发消息功能分开两个线程，这样才能“同时收发”，即可以发消息，也可以接收其他客户端的聊天消息

● 服务器端要分别处理客户端的“登录”、“退出”、“聊天”的消息，所以这里设计了Code常量类，用状态值区分“登录”、“退出”、“聊天”

● 这里设计Message类，包含code属性，区别是“登录”、“退出”、“聊天”，username属性表示用户名，表明消息是谁发的，content属性，存储消息内容，如果是登录，就用来存储密码。

● 这里消息是Message对象，因此在客户端与服务器之间传输的是对象，所以选择ObjectOutputStream和ObjectInputStream。

● 这里的Message类与Code类是服务器端和客户端“共享”的，要保持一致。特别注意包名和序列化版本ID。

Message类与Code类的示例代码：

  1. package com.bdit.tcp.chat.bean;
  3. public class Code {
  5.     public static final int LOGIN = 1;
  6.     public static final int CHAT = 2;
  7.     public static final int LOGOUT = 3;
  9.     public static final int SUCCESS = 1;
  10.     public static final int FAIL = 2;
  11. }
  13. package com.bdit.tcp.chat.bean;
  15. import java.io.Serializable;
  17. public class Message implements Serializable{
  19.     private static final long serialVersionUID = 1L;
  20.     private int code;
  21.     private String username;
  22.     private String content;
  23.     public Message(int code, String username, String content) {
  25.         super();
  26.         this.code = code;
  27.         this.username = username;
  28.         this.content = content;
  29.     }
  31.     public Message() {
  33.         super();
  34.     }
  36.     public int getCode() {
  38.         return code;
  39.     }
  40.     public void setCode(int code) {
  42.         this.code = code;
  43.     }
  44.     public String getUsername() {
  46.         return username;
  47.     }
  48.     public void setUsername(String username) {
  50.         this.username = username;
  51.     }
  52.     public String getContent() {
  54.         return content;
  55.     }
  56.     public void setContent(String content) {
  58.         this.content = content;
  59.     }
  60. }

服务器端用户管理类代码：

  1. package com.bdit.tcp.chat.server;
  3. import java.util.HashMap;
  5. public class UserManager {
  7.     public static HashMap<String,String> allUsers = new HashMap<String,String>();
  8.     static{
  10.         allUsers.put("gangge", "123");
  11.         allUsers.put("xiaobai", "456");
  12.         allUsers.put("gujie", "789");
  13.     }
  15.     public static boolean login(String username, String password){
  17.         if(allUsers.get(username)!=null && allUsers.get(username).equals(password)){
  19.             return true;
  20.         }else{
  22.             return false;
  23.         }
  24.     }
  25. }

服务器端示例代码：

  1. package com.bdit.tcp.chat.server;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  6. public class Server {
  8.     public static void main(String[] args)throws Exception {
  10.         @SuppressWarnings("resource")
  11.         ServerSocket server = new ServerSocket(9999);
  13.         while(true){
  15.             Socket socket = server.accept();
  17.             ClientHandlerThread ct = new ClientHandlerThread(socket);
  18.             ct.start();
  19.         }
  20.     }
  21. }

服务器端处理消息的线程类代码：

  1. package com.bdit.tcp.chat.server;
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.net.Socket;
  7. import java.util.ArrayList;
  8. import java.util.Collections;
  9. import java.util.HashSet;
  10. import java.util.Set;
  12. import com.bdit.tcp.chat.bean.Code;
  13. import com.bdit.tcp.chat.bean.Message;
  15. public class ClientHandlerThread extends Thread{
  17.     public static Set<ObjectOutputStream> online = Collections.synchronizedSet(new HashSet<ObjectOutputStream>());
  19.     private Socket socket;
  20.     private String username;
  21.     private ObjectInputStream ois;
  22.     private ObjectOutputStream oos;
  24.     public ClientHandlerThread(Socket socket) {
  26.         super();
  27.         this.socket = socket;
  28.     }
  30.     public void run(){
  32.         Message message = null;
  33.         try{
  35.             ois = new ObjectInputStream(socket.getInputStream());
  36.             oos = new ObjectOutputStream(socket.getOutputStream());
  38.             //接收数据
  39.             while (true) {
  41.                 message = (Message) ois.readObject();
  43.                 if(message.getCode() == Code.LOGIN){
  45.                     //如果是登录，则验证用户名密码
  46.                     username = message.getUsername();
  47.                     String password = message.getContent();
  48.                     if(UserManager.login(username, password)){
  50.                         message.setCode(Code.SUCCESS);
  51.                         oos.writeObject(message);
  53.                         //并将该用户添加到在线人员名单中
  54.                         online.add(oos);
  56.                         message.setCode(Code.CHAT);
  57.                         message.setContent("上线了");
  58.                         //通知其他人，xx上线了
  59.                         sendToOther(message);
  60.                     }else{
  62.                         message.setCode(Code.FAIL);
  63.                         oos.writeObject(message);
  64.                     }
  65.                 }else if(message.getCode() == Code.CHAT){
  67.                     //如果是聊天信息，把消息转发给其他在线客户端
  68.                     sendToOther(message);
  69.                 }else if(message.getCode() == Code.LOGOUT){
  71.                     //通知其他人，xx下线了
  72.                     message.setContent("下线了");
  73.                     sendToOther(message);
  74.                     break;
  75.                 }
  76.             }
  77.         }catch(Exception  e){
  79.             //通知其他人，xx掉线了
  80.             if(message!=null && username!=null){
  82.                 message.setCode(Code.LOGOUT);
  83.                 message.setContent("掉线了");
  84.                 sendToOther(message);
  85.             }
  86.         }finally{
  88.             //从在线人员中移除并断开当前客户端
  89.             try {
  91.                 online.remove(oos);
  92.                 socket.close();
  93.             } catch (IOException e) {
  95.                 e.printStackTrace();
  96.             }
  97.         }
  98.     }
  100.     private void sendToOther(Message message) {
  102.         ArrayList<ObjectOutputStream> offline = new ArrayList<ObjectOutputStream>();
  103.         for (ObjectOutputStream on : online) {
  105.             if(!on.equals(oos)){
  107.                 try {
  109.                     on.writeObject(message);
  110.                 } catch (IOException e) {
  112.                     offline.add(on);
  113.                 }
  114.             }
  115.         }
  117.         for (ObjectOutputStream off : offline) {
  119.             online.remove(off);
  120.         }
  121.     }
  122. }

客户端示例代码：

  1. package com.bdit.tcp.chat.client;
  3. import java.io.ObjectInputStream;
  4. import java.io.ObjectOutputStream;
  5. import java.net.Socket;
  6. import java.util.Scanner;
  8. import com.bdit.tcp.chat.bean.Code;
  9. import com.bdit.tcp.chat.bean.Message;
  11. public class Client {
  13.     public static void main(String[] args) throws Exception{
  15.         Socket socket = new Socket("192.168.1.107", 9999);
  17.         ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
  18.         ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
  20.         //先登录
  21.         Scanner scanner = new Scanner(System.in);
  22.         String username;
  23.         while(true){
  25.             //输入登录信息
  26.             System.out.println("用户名：");
  27.             username = scanner.nextLine();
  28.             System.out.println("密码：");
  29.             String password = scanner.nextLine();
  31.             Message msg = new Message(Code.LOGIN, username, password);
  32.             //发送登录数据
  33.             oos.writeObject(msg);
  34.             // 接收登录结果
  35.             msg = (Message) ois.readObject();
  36.             if(msg.getCode() == Code.SUCCESS){
  38.                 System.out.println("登录成功！");
  39.                 break;
  40.             }else if(msg.getCode() == Code.FAIL){
  42.                 System.out.println("用户名或密码错误，登录失败，重新输入");
  43.             }
  44.         }
  46.         //启动收消息和发消息线程
  47.         SendThread s = new SendThread(oos,username);
  48.         ReceiveThread r = new ReceiveThread(ois);
  49.         s.start();
  50.         r.start();
  52.         s.join();//不发了，就结束
  53.         r.setFlag(false);
  54.         r.join();
  56.         scanner.close();
  57.         socket.close();
  58.     }
  59. }

客户端发消息线程类代码：

  1. package com.bdit.tcp.chat.client;
  3. import java.io.IOException;
  4. import java.io.ObjectOutputStream;
  5. import java.util.Scanner;
  7. import com.bdit.tcp.chat.bean.Code;
  8. import com.bdit.tcp.chat.bean.Message;
  10. public class SendThread extends Thread{
  12.     private ObjectOutputStream oos;
  13.     private String username;
  15.     public SendThread(ObjectOutputStream oos,String username) {
  17.         super();
  18.         this.oos = oos;
  19.         this.username = username;
  20.     }
  22.     public void run(){
  24.         try {
  26.             Scanner scanner = new Scanner(System.in);
  27.             while(true){
  29.                 System.out.println("请输入消息内容：");
  30.                 String content = scanner.nextLine();
  31.                 Message msg;
  32.                 if("bye".equals(content)){
  34.                     msg = new Message(Code.LOGOUT, username, content);
  35.                     oos.writeObject(msg);
  36.                     scanner.close();
  37.                     break;
  38.                 }else{
  40.                     msg = new Message(Code.CHAT, username, content);
  41.                     oos.writeObject(msg);
  42.                 }
  43.             }
  44.         } catch (IOException e) {
  46.             e.printStackTrace();
  47.         }
  48.     }
  49. }

客户端收消息线程类代码：

  1. package com.bdit.tcp.chat.client;
  3. import java.io.ObjectInputStream;
  5. import com.bdit.tcp.chat.bean.Message;
  7. public class ReceiveThread extends Thread{
  9.     private ObjectInputStream ois;
  10.     private volatile boolean flag = true;
  12.     public ReceiveThread(ObjectInputStream ois) {
  14.         super();
  15.         this.ois = ois;
  16.     }
  17.     public void run(){
  19.         try {
  21.             while(flag){
  23.                 Message msg = (Message) ois.readObject();
  24.                 System.out.println(msg.getUsername() + ":" + msg.getContent());
  25.             }
  26.         } catch (Exception e) {
  28.             System.out.println("请重新登录");
  29.         }
  30.     }
  31.     public void setFlag(boolean flag) {
  33.         this.flag = flag;
  34.     }
  36. }

以上案例的网络通信程序是基于阻塞式API的，所以服务器必须为每个客户端都提供一条独立线程进行处理，当服务器需要同时处理大量客户端时，这种做法会导致性能下降。如果要开发高性能网络服务器，那么需要使用Java提供的NIO API，可以让服务器使用一个或有限几个线程来同时处理连接到服务器上的所有客户端。

2、基于UDP协议的网络编程

UDP(User Datagram Protocol，用户数据报协议)：是一个无连接的传输层协议、提供面向事务的简单不可靠的信息传送服务，类似于短信。

UDP协议是一种面向非连接的协议，面向非连接指的是在正式通信前不必与对方先建立连接，不管对方状态就直接发送，至于对方是否可以接收到这些数据内容，UDP协议无法控制，因此说，UDP协议是一种不可靠的协议。无连接的好处就是快，省内存空间和流量，因为维护连接需要创建大量的数据结构。UDP会尽最大努力交付数据，但不保证可靠交付，没有TCP的确认机制、重传机制，如果因为网络原因没有传送到对端，UDP也不会给应用层返回错误信息。

UDP协议是面向数据报文的信息传送服务。UDP在发送端没有缓冲区，对于应用层交付下来的报文在添加了首部之后就直接交付于ip层，不会进行合并，也不会进行拆分，而是一次交付一个完整的报文。比如我们要发送100个字节的报文，我们调用一次send()方法就会发送100字节，接收方也需要用receive()方法一次性接收100字节，不能使用循环每次获取10个字节，获取十次这样的做法。

UDP协议没有拥塞控制，所以当网络出现的拥塞不会导致主机发送数据的速率降低。虽然UDP的接收端有缓冲区，但是这个缓冲区只负责接收，并不会保证UDP报文的到达顺序是否和发送的顺序一致。因为网络传输的时候，由于网络拥塞的存在是很大的可能导致先发的报文比后发的报文晚到达。如果此时缓冲区满了，后面到达的报文将直接被丢弃。这个对实时应用来说很重要，比如：视频通话、直播等应用。

因此UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境，数据报大小限制在64K以下。

2.1、基于UDP协议的网络编程

基于UDP协议的网络编程仍然需要在通信实例的两端各建立一个Socket，但这两个Socket之间并没有虚拟链路，这两个Socket只是发送、接收数据报的对象，Java提供了DatagramSocket对象作为基于UDP协议的Socket，使用DatagramPacket代表DatagramSocket发送、接收的数据报。

DatagramSocket 类的常用方法：

  1. public DatagramSocket(int port)创建数据报套接字并将其绑定到本地主机上的指定端口。套接字将被绑定到通配符地址，IP 地址由内核来选择。
  2. public DatagramSocket(int port,InetAddress laddr)创建数据报套接字，将其绑定到指定的本地地址。本地端口必须在 0 到 65535 之间（包括两者）。如果 IP 地址为 0.0.0.0，套接字将被绑定到通配符地址，IP 地址由内核选择。
  3. public void close()关闭此数据报套接字。
  4. public void send(DatagramPacket p)从此套接字发送数据报包。DatagramPacket 包含的信息指示：将要发送的数据、其长度、远程主机的 IP 地址和远程主机的端口号。
  5. public void receive(DatagramPacket p)从此套接字接收数据报包。当此方法返回时，DatagramPacket 的缓冲区填充了接收的数据。数据报包也包含发送方的 IP 地址和发送方机器上的端口号。
    此方法在接收到数据报前一直阻塞。数据报包对象的 length 字段包含所接收信息的长度。如果信息比包的长度长，该信息将被截短。

DatagramPacket类的常用方法：

  1. public DatagramPacket(byte[] buf,int length)构造 DatagramPacket，用来接收长度为
    length 的数据包。 length 参数必须小于等于 buf.length。
  2. public DatagramPacket(byte[] buf,int length,InetAddress address,int
    port)构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。length 参数必须小于等于 buf.length。
  3. public int getLength()返回将要发送或接收到的数据的长度。

1、“发送端”

步骤流程：

  1. 建立发送端的DatagramSocket，需要指定本端的端口号

  2. 建立数据包DatagramPacket

    ●数据

    ●接收端的IP地址

    ●接收端的端口号

  3. 调用DatagramSocket的发送方法
  4. 关闭DatagramSocket

示例代码：

  1. package com.bdit.udp;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. import java.net.InetAddress;
  6. import java.util.ArrayList;
  8. public class Send {
  11.     public static void main(String[] args)throws Exception {
  13. //    1、建立发送端的DatagramSocket
  14.         DatagramSocket ds = new DatagramSocket();
  16.         //要发送的数据
  17.         ArrayList<String> all = new ArrayList<String>();
  18.         all.add("一二三四");
  19.         all.add("五六七八");
  20.         all.add("好好学习");
  21.         all.add("天天向上");
  23.         //接收方的IP地址
  24.         InetAddress ip = InetAddress.getByName("127.0.0.1");
  25.         //接收方的监听端口号
  26.         int port = 9999;
  27.         //发送多个数据报
  28.         for (int i = 0; i < all.size(); i++) {
  30. //       2、建立数据包DatagramPacket
  31.             byte[] data = all.get(i).getBytes();
  32.             DatagramPacket dp = new DatagramPacket(data, data.length, ip, port);
  33. //       3、调用Socket的发送方法
  34.             ds.send(dp);
  35.         }
  37. //    4、关闭Socket
  38.         ds.close();
  39.     }
  40. }

2、“接收端”

步骤流程：

  1. 建立接收端的DatagramSocket，需要指定本端的IP地址和端口号

  2. 建立数据包DatagramPacket

    需要指定装数据的数组

  3. 调用Socket的接收方法
  4. 拆封数据
  5. 关闭Socket

示例代码：

  1. package com.bdit.udp;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  6. public class Receive {
  9.     public static void main(String[] args) throws Exception {
  11. //    1、建立接收端的DatagramSocket，需要指定本端的监听端口号
  12.         DatagramSocket ds = new DatagramSocket(9999);
  14.         //一直监听数据
  15.         while(true){
  17.             //    2、建立数据包DatagramPacket
  18.             byte[] buffer = new byte[1024*64];
  19.             DatagramPacket dp = new DatagramPacket(buffer , buffer.length);
  21.             //    3、调用Socket的接收方法
  22.             ds.receive(dp);
  24.             //4、拆封数据
  25.             String str = new String(buffer,0,dp.getLength());
  26.             System.out.println(str);
  27.         }
  28.     }
  29. }

2.2、使用MulticastSocket实现多点广播

Datagram只允许数据报发送给指定的目标地址，而MulticastSocket可以将数据报以广播方式发送到数量不等的多个客户端。

IP协议为多点广播提供了这批特殊的IP地址，这些IP地址的范围是224.0.0.0至239.255.255.255。

在这里插入图片描述

MulticastSocket常用的方法：

● MulticastSocket(int port) ：创建多播套接字并将其绑定到特定端口。创建一个MulticastSocket对象后，还需要将该MulticastSocket加入到指定的多点广播地址，如果结束也需要脱离多点广播地址。

● void joinGroup(InetAddress mcastaddr) ：加入多播组。

● void leaveGroup(InetAddress mcastaddr) ：离开多播组。

● void setLoopbackMode(boolean disable) ：启用/禁用多播数据报的本地回送。true 表示禁用 LoopbackMode。

案例：群聊

  1. package com.bdit.udp.multi;
  3. import java.io.IOException;
  4. import java.net.DatagramPacket;
  5. import java.net.InetAddress;
  6. import java.net.MulticastSocket;
  7. import java.util.Scanner;
  9. public class Chat {
  11.     private volatile static boolean exit = false;
  12.     private static Scanner input = new Scanner(System.in);
  13.     private static String username;
  15.     public static void main(String[] args) throws IOException {
  17.         MulticastSocket socket = new MulticastSocket(9999);
  18.         InetAddress ip = InetAddress.getByName("230.0.0.1");
  19.         socket.joinGroup(ip);
  20.         socket.setLoopbackMode(false);
  22.         System.out.print("请输入用户名：");
  23.         username = input.nextLine();
  25.         SendThread s = new SendThread(socket,ip);
  26.         ReceiveThread r = new ReceiveThread(socket);
  28.         s.start();
  29.         r.start();
  31.         try {
  33.             s.join();
  34.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  39.         socket.close();
  40.         input.close();
  41.     }
  42.     static class SendThread extends Thread{
  44.         private MulticastSocket socket;
  45.         private InetAddress ip;
  47.         public SendThread(MulticastSocket socket,InetAddress ip) {
  49.             super();
  50.             this.socket = socket;
  51.             this.ip = ip;
  52.         }
  53.         public void run(){
  55.             try {
  57.                 while (!exit) {
  59.                     System.out.print("输入广播消息：");
  60.                     String message = input.nextLine();
  61.                     if ("bye".equals(message)) {
  63.                         exit = true;
  64.                         break;
  65.                     }
  67.                     byte[] data = (username+":"+message).getBytes();
  68.                     DatagramPacket dp = new DatagramPacket(data, data.length, ip, 9999);
  70.                     socket.send(dp);
  71.                 }
  72.             } catch (IOException e) {
  74.                 e.printStackTrace();
  75.             }
  76.         }
  78.     }
  79.     static class ReceiveThread extends Thread{
  81.         private MulticastSocket socket;
  83.         public ReceiveThread(MulticastSocket socket) {
  85.             super();
  86.             this.socket = socket;
  87.         }
  89.         public void run(){
  91.             try {
  93.                 while (!exit) {
  95.                     byte[] data = new byte[1024];
  96.                     DatagramPacket dp = new DatagramPacket(data, data.length);
  97.                     socket.receive(dp);
  98.                     String str = new String(data, 0, dp.getLength());
  99.                     System.out.println(str);
  100.                 }
  101.             } catch (IOException e) {
  103.                 exit = false;
  104.             }
  105.         }
  107.     }
  108. }

发表评论

表情：
评论列表 （有 0 条评论，220人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java基础：网络编程

    1. 网络编程概述 自从互联网诞生以来，现在基本上所有的程序都是网络程序，很少有单机版的程序了。 计算机网络就是把各个计算机连接到一起，让网络中的计算机可以互相通信。网

    偏执的太偏执、偏执的太偏执、/ 0 赞/ 521 阅读

    相关 Java基础：网络编程

    1. 网络编程概述 自从互联网诞生以来，现在基本上所有的程序都是网络程序，很少有单机版的程序了。 计算机网络就是把各个计算机连接到一起，让网络中的计算机可以互相通信。网

    ╰半夏微凉°╰半夏微凉°/ 0 赞/ 364 阅读

    相关 JAVA网络编程基础

    Java为网络支持提供了java.net包，我们来看一下这个这个包里几个主要的类。 ![70][]![70 1][] ①InetAddress 对网络协议稍微有点了解的同

    末蓝、末蓝、/ 0 赞/ 415 阅读