【Java】网络套接字

Starshime2024-12-21 18:29

网络通信原理--套接字

基于TCP的网络编程

功能：模拟网站的登录，客户端录入账号密码，然后服务器端进行验证。

功能分解1：单向通信

功能：客户端发送一句话到服务器：

客户端：

  1. public class TestClient {//客户端
  3. //这是一个main方法，是程序的入口：
  4. public static void main(String[] args) throws IOException {
  5. //1.创建套接字：指定服务器的ip和端口号：
  6. Socket s = new Socket("192.168.199.217",8888);
  7. //2.对于程序员来说，向外发送数据 感受 --》利用输出流：
  8. OutputStream os = s.getOutputStream();
  9. DataOutputStream dos = new DataOutputStream(os);
  10. //利用这个OutputStream就可以向外发送数据了，但是没有直接发送String的方法
  11. //所以我们又在OutputStream外面套了一个处理流：DataOutputStream
  12. dos.writeUTF("你好");
  14. //3.关闭流 + 关闭网络资源：
  15. dos.close();
  16. os.close();
  17. s.close();
  18. }
  19. }

服务器：

  1. public class TestServer {//服务器
  3. //这是一个main方法，是程序的入口：
  4. public static void main(String[] args) throws IOException {
  5. //1.创建套接字： 指定服务器的端口号
  6. ServerSocket ss = new ServerSocket(8888);
  7. //2.等着客户端发来的信息：
  8. Socket s = ss.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
  9. //accept()返回值为一个Socket，这个Socket其实就是客户端的Socket
  10. //接到这个Socket以后，客户端和服务器才真正产生了连接，才真正可以通信了
  11. //3.感受到的操作流：
  12. InputStream is = s.getInputStream();
  13. DataInputStream dis = new DataInputStream(is);
  15. //4.读取客户端发来的数据：
  16. String str = dis.readUTF();
  17. System.out.println("客户端发来的数据为："+str);
  19. //5.关闭流+关闭网络资源：
  20. dis.close();
  21. is.close();
  22. s.close();
  23. ss.close();
  24. }
  25. }

测试：

（1）先开启客户端还是先开启服务器：先开服务器，再开启客户端

侧面验证：先开客户端：出错：

功能分解2：双向通信

服务器端：

  1. package com.star.test02;
  3. import java.io.*;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  7. /**
  8. * @author : Starshine
  9. */
  10. public class TestServer {//服务器
  12. //这是一个main方法，是程序的入口：
  13. public static void main(String[] args) throws IOException {
  14. //1.创建套接字： 指定服务器的端口号
  15. ServerSocket ss = new ServerSocket(8888);
  16. //2.等着客户端发来的信息：
  17. Socket s = ss.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
  18. //accept()返回值为一个Socket，这个Socket其实就是客户端的Socket
  19. //接到这个Socket以后，客户端和服务器才真正产生了连接，才真正可以通信了
  20. //3.感受到的操作流：
  21. InputStream is = s.getInputStream();
  22. DataInputStream dis = new DataInputStream(is);
  24. //4.读取客户端发来的数据：
  25. String str = dis.readUTF();
  26. System.out.println("客户端发来的数据为："+str);
  28. //向客户端输出一句话：---》操作流---》输出流
  29. OutputStream os = s.getOutputStream();
  30. DataOutputStream dos = new DataOutputStream(os);
  31. dos.writeUTF("你好，我是服务器端，我接受到你的请求了");
  34. //5.关闭流+关闭网络资源：
  35. dos.close();
  36. os.close();
  37. dis.close();
  38. is.close();
  39. s.close();
  40. ss.close();
  41. }
  42. }

客户端：

  1. package com.star.test02;
  3. import java.io.*;
  4. import java.net.Socket;
  6. /**
  7. * @author : Starshine
  8. */
  9. public class TestClient {//客户端
  11. //这是一个main方法，是程序的入口：
  12. public static void main(String[] args) throws IOException {
  13. //1.创建套接字：指定服务器的ip和端口号：
  14. Socket s = new Socket("192.168.199.217",8888);
  15. //2.对于程序员来说，向外发送数据 感受 --》利用输出流：
  16. OutputStream os = s.getOutputStream();
  17. DataOutputStream dos = new DataOutputStream(os);
  18. //利用这个OutputStream就可以向外发送数据了，但是没有直接发送String的方法
  19. //所以我们又在OutputStream外面套了一个处理流：DataOutputStream
  20. dos.writeUTF("你好");
  22. //接收服务器端的回话--》利用输入流：
  23. InputStream is = s.getInputStream();
  24. DataInputStream dis = new DataInputStream(is);
  25. String str = dis.readUTF();
  26. System.out.println("服务器端对我说："+str);
  28. //3.关闭流 + 关闭网络资源：
  29. dis.close();
  30. is.close();
  31. dos.close();
  32. os.close();
  33. s.close();
  34. }
  35. }

注意：关闭防火墙

功能分解3：对象流传送

封装的User类：

  1. package com.star.test03;
  3. import java.io.Serializable;
  5. /**
  6. * @author : Starshine
  7. */
  8. public class User implements Serializable {
  9. private static final long serialVersionUID = 9050691344308365540L;
  10. private String name;
  11. private String pwd;
  13. public String getName() {
  14. return name;
  15. }
  17. public void setName(String name) {
  18. this.name = name;
  19. }
  21. public String getPwd() {
  22. return pwd;
  23. }
  25. public void setPwd(String pwd) {
  26. this.pwd = pwd;
  27. }
  29. public User(String name, String pwd) {
  30. this.name = name;
  31. this.pwd = pwd;
  32. }
  33. }

客户端：

  1. package com.star.test03;
  3. import java.io.*;
  4. import java.net.Socket;
  5. import java.util.Scanner;
  7. /**
  8. * @author : Starshine
  9. */
  10. public class TestClient {//客户端
  12. //这是一个main方法，是程序的入口：
  13. public static void main(String[] args) throws IOException {
  14. //1.创建套接字：指定服务器的ip和端口号：
  15. Socket s = new Socket("192.168.199.217",8888);
  17. //录入用户的账号和密码：
  18. Scanner sc = new Scanner(System.in);
  19. System.out.println("请录入您的账号：");
  20. String name = sc.next();
  21. System.out.println("请录入您的密码：");
  22. String pwd = sc.next();
  23. //将账号和密码封装为一个User的对象：
  24. User user = new User(name,pwd);
  27. //2.对于程序员来说，向外发送数据 感受 --》利用输出流：
  28. OutputStream os = s.getOutputStream();
  29. ObjectOutputStream oos = new ObjectOutputStream(os);
  30. oos.writeObject(user);
  33. //接收服务器端的回话--》利用输入流：
  34. InputStream is = s.getInputStream();
  35. DataInputStream dis = new DataInputStream(is);
  36. boolean b = dis.readBoolean();
  37. if(b){
  38. System.out.println("恭喜，登录成功");
  39. }else{
  40. System.out.println("对不起，登录失败");
  41. }
  43. //3.关闭流 + 关闭网络资源：
  44. dis.close();
  45. is.close();
  46. oos.close();
  47. os.close();
  48. s.close();
  49. }
  50. }

服务器：

  1. package com.star.test03;
  3. import java.io.*;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  7. /**
  8. * @author : Starshine
  9. */
  10. public class TestServer {//服务器
  12. //这是一个main方法，是程序的入口：
  13. public static void main(String[] args) throws IOException, ClassNotFoundException {
  14. //1.创建套接字： 指定服务器的端口号
  15. ServerSocket ss = new ServerSocket(8888);
  16. //2.等着客户端发来的信息：
  17. Socket s = ss.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
  18. //accept()返回值为一个Socket，这个Socket其实就是客户端的Socket
  19. //接到这个Socket以后，客户端和服务器才真正产生了连接，才真正可以通信了
  20. //3.感受到的操作流：
  21. InputStream is = s.getInputStream();
  22. ObjectInputStream ois = new ObjectInputStream(is);
  24. //4.读取客户端发来的数据：
  25. User user = (User)(ois.readObject());
  27. //对对象进行验证：
  28. boolean flag = false;
  29. if(user.getName().equals("娜娜")&&user.getPwd().equals("123123")){
  30. flag = true;
  31. }
  33. //向客户端输出结果：---》操作流---》输出流
  34. OutputStream os = s.getOutputStream();
  35. DataOutputStream dos = new DataOutputStream(os);
  36. dos.writeBoolean(flag);
  39. //5.关闭流+关闭网络资源：
  40. dos.close();
  41. os.close();
  42. ois.close();
  43. is.close();
  44. s.close();
  45. ss.close();
  46. }
  47. }
功能分解4：加入完整的处理异常方式

服务器端：

  1. package com.star.test03;
  3. import java.io.*;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  7. /**
  8. * @author : Starshine
  9. */
  10. public class TestServer {//服务器
  12. //这是一个main方法，是程序的入口：
  13. public static void main(String[] args) {
  14. //1.创建套接字： 指定服务器的端口号
  15. ServerSocket ss = null;
  16. Socket s = null;
  17. InputStream is = null;
  18. ObjectInputStream ois = null;
  19. OutputStream os = null;
  20. DataOutputStream dos = null;
  21. try {
  22. ss = new ServerSocket(8888);
  23. //2.等着客户端发来的信息：
  24. s = ss.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。
  25. //accept()返回值为一个Socket，这个Socket其实就是客户端的Socket
  26. //接到这个Socket以后，客户端和服务器才真正产生了连接，才真正可以通信了
  27. //3.感受到的操作流：
  28. is = s.getInputStream();
  29. ois = new ObjectInputStream(is);
  31. //4.读取客户端发来的数据：
  32. User user = (User)(ois.readObject());
  34. //对对象进行验证：
  35. boolean flag = false;
  36. if(user.getName().equals("娜娜")&&user.getPwd().equals("123123")){
  37. flag = true;
  38. }
  40. //向客户端输出结果：---》操作流---》输出流
  41. os = s.getOutputStream();
  42. dos = new DataOutputStream(os);
  43. dos.writeBoolean(flag);
  44. } catch (IOException | ClassNotFoundException e) {
  45. e.printStackTrace();
  46. } finally {
  47. //5.关闭流+关闭网络资源：
  48. try {
  49. if(dos!=null){
  50. dos.close();
  51. }
  52. } catch (IOException e) {
  53. e.printStackTrace();
  54. }
  55. try {
  56. if(os!=null){
  57. os.close();
  58. }
  59. } catch (IOException e) {
  60. e.printStackTrace();
  61. }
  62. try {
  63. if(ois!=null){
  64. ois.close();
  65. }
  66. } catch (IOException e) {
  67. e.printStackTrace();
  68. }
  69. try {
  70. if(is!=null){
  71. is.close();
  72. }
  73. } catch (IOException e) {
  74. e.printStackTrace();
  75. }
  76. try {
  77. if(s!=null){
  78. s.close();
  79. }
  80. } catch (IOException e) {
  81. e.printStackTrace();
  82. }
  83. try {
  84. if(ss!=null){
  85. ss.close();
  86. }
  87. } catch (IOException e) {
  88. e.printStackTrace();
  89. }
  90. }
  95. }
  96. }

客户端：

  1. package com.star.test03;
  3. import java.io.*;
  4. import java.net.Socket;
  5. import java.util.Scanner;
  7. /**
  8. * @author : Starshine
  9. */
  10. public class TestClient {//客户端
  12. //这是一个main方法，是程序的入口：
  13. public static void main(String[] args){
  14. //1.创建套接字：指定服务器的ip和端口号：
  15. Socket s = null;
  16. OutputStream os = null;
  17. ObjectOutputStream oos = null;
  18. InputStream is = null;
  19. DataInputStream dis = null;
  20. try {
  21. s = new Socket("192.168.199.217",8888);
  22. //录入用户的账号和密码：
  23. Scanner sc = new Scanner(System.in);
  24. System.out.println("请录入您的账号：");
  25. String name = sc.next();
  26. System.out.println("请录入您的密码：");
  27. String pwd = sc.next();
  28. //将账号和密码封装为一个User的对象：
  29. User user = new User(name,pwd);
  30. //2.对于程序员来说，向外发送数据 感受 --》利用输出流：
  31. os = s.getOutputStream();
  32. oos = new ObjectOutputStream(os);
  33. oos.writeObject(user);
  34. //接收服务器端的回话--》利用输入流：
  35. is = s.getInputStream();
  36. dis = new DataInputStream(is);
  37. boolean b = dis.readBoolean();
  38. if(b){
  39. System.out.println("恭喜，登录成功");
  40. }else{
  41. System.out.println("对不起，登录失败");
  42. }
  43. } catch (IOException e) {
  44. e.printStackTrace();
  45. } finally{
  46. //3.关闭流 + 关闭网络资源：
  47. try {
  48. if(dis!=null){
  49. dis.close();
  50. }
  51. } catch (IOException e) {
  52. e.printStackTrace();
  53. }
  54. try {
  55. if(is!=null){
  56. is.close();
  57. }
  58. } catch (IOException e) {
  59. e.printStackTrace();
  60. }
  61. try {
  62. if(oos!=null){
  63. oos.close();
  64. }
  65. } catch (IOException e) {
  66. e.printStackTrace();
  67. }
  68. try {
  69. if(os!=null){
  70. os.close();
  71. }
  72. } catch (IOException e) {
  73. e.printStackTrace();
  74. }
  75. try {
  76. if(s!=null){
  77. s.close();
  78. }
  79. } catch (IOException e) {
  80. e.printStackTrace();
  81. }
  82. }
  87. }
  88. }
功能分解5：多线程接收用户请求

遗留问题：服务器针对一个请求服务，之后服务器就关闭了（程序自然结束了）

现在需要解决：服务器必须一直在监听 ，一直开着，等待客户端的请求

在当前代码中，客户端不用动了

更改服务器代码：

  1. package com.star.test03;

  3. import java.io.*;

  4. import java.net.Socket;

  6. /**

  7. * @author : Starshine

  8. */

  9. public class ServerThread extends Thread {//线程：专门处理客户端的请求

  10. InputStream is = null;

  11. ObjectInputStream ois = null;

  12. OutputStream os = null;

  13. DataOutputStream dos = null;

  14. Socket s = null;

  15. public ServerThread(Socket s){

  16. this.s = s;

  17. }

  18. @Override

  19. public void run() {

  20. try{

  21. //2.等着客户端发来的信息：

  23. is = s.getInputStream();

  24. ois = new ObjectInputStream(is);

  26. //4.读取客户端发来的数据：

  27. User user = (User)(ois.readObject());

  29. //对对象进行验证：

  30. boolean flag = false;

  31. if(user.getName().equals("娜娜")&&user.getPwd().equals("123123")){

  32. flag = true;

  33. }

  35. //向客户端输出结果：---》操作流---》输出流

  36. os = s.getOutputStream();

  37. dos = new DataOutputStream(os);

  38. dos.writeBoolean(flag);

  39. }catch (IOException | ClassNotFoundException e) {

  40. e.printStackTrace();

  41. }finally {

  42. try {

  43. if(dos!=null){

  44. dos.close();

  45. }

  46. } catch (IOException e) {

  47. e.printStackTrace();

  48. }

  49. try {

  50. if(os!=null){

  51. os.close();

  52. }

  53. } catch (IOException e) {

  54. e.printStackTrace();

  55. }

  56. try {

  57. if(ois!=null){

  58. ois.close();

  59. }

  60. } catch (IOException e) {

  61. e.printStackTrace();

  62. }

  63. try {

  64. if(is!=null){

  65. is.close();

  66. }

  67. } catch (IOException e) {

  68. e.printStackTrace();

  69. }

  70. }

  71. }

  72. }

  74. package com.star.test03;

  76. import java.io.*;

  77. import java.net.ServerSocket;

  78. import java.net.Socket;

  80. /**

  81. * @author : Starshine

  82. */

  83. public class TestServer {//服务器

  85. //这是一个main方法，是程序的入口：

  86. public static void main(String[] args) {

  87. System.out.println("服务器启动了");

  88. //1.创建套接字： 指定服务器的端口号

  89. ServerSocket ss = null;

  90. Socket s = null;

  91. int count = 0;//定义一个计数器，用来计数 客户端的请求

  92. try {

  93. ss = new ServerSocket(8888);

  94. while(true){//加入死循环，服务器一直监听客户端是否发送数据

  95. s = ss.accept();//阻塞方法:等待接收客户端的数据，什么时候接收到数据，什么时候程序继续向下执行。

  96. //每次过来的客户端的请求 靠 线程处理：

  97. new ServerThread(s).start();

  98. count++;

  99. //输入请求的客户端的信息：

  100. System.out.println("当前是第"+count+"个用户访问我们的服务器,对应的用户是："+s.getInetAddress());

  101. }

  102. } catch (IOException e) {

  103. e.printStackTrace();

  104. }

  105. }

  106. }

基于UDP的网络编程

TCP:

客户端：Socket

程序感受到的 使用流 ：输出流

服务器端： ServerSocket --->Socket 程序感受到的 使用流 ：输入流

（客户端和服务器端地位不平等。）

UDP:

发送方：DatagramSocket 发送：数据包 DatagramPacket

接收方：DatagramSocket 接收：数据包 DatagramPacket

（发送方和接收方的地址是平等的。）

UDP案例： 完成网站的咨询聊天

功能分解1：单向通信

发送方：

  1. package com.star.test04;
  3. import java.io.IOException;
  4. import java.net.*;
  6. /**
  7. * @author : Starshine
  8. */
  9. public class TestSend {//发送方：
  11. //这是一个main方法，是程序的入口：
  12. public static void main(String[] args) throws IOException {
  13. System.out.println("学生上线。。。");
  14. //1.准备套接字： 指定发送方的端口号
  15. DatagramSocket ds = new DatagramSocket(8888);
  16. //2.准备数据包
  17. String str = "你好";
  18. byte[] bytes = str.getBytes();
  19. /*
  20. 需要四个参数：
  21. 1.指的是传送数据转为字节数组
  22. 2.字节数组的长度
  23. 3.封装接收方的ip
  24. 4.指定接收方的端口号
  25. */
  26. DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
  27. //发送：
  28. ds.send(dp);
  30. //关闭资源
  31. ds.close();
  32. }
  33. }

接收方：

  1. package com.star.test04;
  3. import java.io.IOException;
  4. import java.net.DatagramPacket;
  5. import java.net.DatagramSocket;
  6. import java.net.SocketException;
  8. /**
  9. * @author : Starshine
  10. */
  11. public class TestReceive {//接收方
  13. //这是一个main方法，是程序的入口：
  14. public static void main(String[] args) throws IOException {
  15. System.out.println("老师上线了。。");
  16. //1.创建套接字：指定接收方的端口
  17. DatagramSocket ds = new DatagramSocket(9999);
  18. //2.有一个空的数据包，打算用来接收 对方传过来的数据包：
  19. byte[] b = new byte[1024];
  20. DatagramPacket dp = new DatagramPacket(b,b.length);
  21. //3.接收对方的数据包，然后放入我们的dp数据包中填充
  22. ds.receive(dp);//接收完以后 dp里面就填充好内容了
  24. //4.取出数据：
  25. byte[] data = dp.getData();
  26. String s = new String(data,0,dp.getLength());//dp.getLength()数组包中的有效长度
  27. System.out.println("学生对我说："+s);
  29. //5.关闭资源：
  30. ds.close();
  33. }
  34. }
功能分解2：双向通信

发送方：

  1. package com.star.test04;
  3. import java.io.IOException;
  4. import java.net.*;
  5. import java.util.Scanner;
  7. /**
  8. * @author : Starshine
  9. */
  10. public class TestSend {//发送方：
  12. //这是一个main方法，是程序的入口：
  13. public static void main(String[] args) throws IOException {
  14. System.out.println("学生上线。。。");
  15. //1.准备套接字： 指定发送方的端口号
  16. DatagramSocket ds = new DatagramSocket(8888);
  17. //2.准备数据包
  18. Scanner sc = new Scanner(System.in);
  19. System.out.print("学生：");
  20. String str = sc.next();
  21. byte[] bytes = str.getBytes();
  22. /*
  23. 需要四个参数：
  24. 1.指的是传送数据转为Z字节数组
  25. 2.字节数组的长度
  26. 3.封装接收方的ip
  27. 4.指定接收方的端口号
  28. */
  29. DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
  30. //发送：
  31. ds.send(dp);
  33. //接收老师发送回来的信息：
  34. byte[] b = new byte[1024];
  35. DatagramPacket dp2 = new DatagramPacket(b,b.length);
  36. ds.receive(dp2);//接收完以后 dp2里面就填充好内容了
  38. //取出数据：
  39. byte[] data = dp2.getData();
  40. String s = new String(data,0,dp2.getLength());//dp.getLength()数组包中的有效长度
  41. System.out.println("老师对我说："+s);
  43. //关闭资源
  44. ds.close();
  45. }
  46. }

接收方：

  1. package com.star.test04;
  3. import java.io.IOException;
  4. import java.net.DatagramPacket;
  5. import java.net.DatagramSocket;
  6. import java.net.InetAddress;
  7. import java.net.SocketException;
  8. import java.util.Scanner;
  10. /**
  11. * @author : Starshine
  12. */
  13. public class TestReceive {//接收方
  15. //这是一个main方法，是程序的入口：
  16. public static void main(String[] args) throws IOException {
  17. System.out.println("老师上线了。。");
  18. //1.创建套接字：指定接收方的端口
  19. DatagramSocket ds = new DatagramSocket(9999);
  20. //2.有一个空的数据包，打算用来接收 对方传过来的数据包：
  21. byte[] b = new byte[1024];
  22. DatagramPacket dp = new DatagramPacket(b,b.length);
  23. //3.接收对方的数据包，然后放入我们的dp数据包中填充
  24. ds.receive(dp);//接收完以后 dp里面就填充好内容了
  26. //4.取出数据：
  27. byte[] data = dp.getData();
  28. String s = new String(data,0,dp.getLength());//dp.getLength()数组包中的有效长度
  29. System.out.println("学生对我说："+s);
  31. //老师进行回复：
  32. Scanner sc = new Scanner(System.in);
  33. System.out.print("老师：");
  34. String str = sc.next();
  35. byte[] bytes = str.getBytes();
  36. //封装数据，并且指定学生的ip和端口号
  37. DatagramPacket dp2 = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),8888);
  38. //发送：
  39. ds.send(dp2);
  40. //5.关闭资源：
  41. ds.close();
  44. }
  45. }
功能分解3：加入完整的处理异常方式

发送方：

  1. package com.star.test04;
  3. import java.io.IOException;
  4. import java.net.*;
  5. import java.util.Scanner;
  7. /**
  8. * @author : Starshine
  9. */
  10. public class TestSend {//发送方：
  12. //这是一个main方法，是程序的入口：
  13. public static void main(String[] args) {
  14. System.out.println("学生上线。。。");
  15. //1.准备套接字： 指定发送方的端口号
  16. DatagramSocket ds = null;
  17. try {
  18. ds = new DatagramSocket(8888);
  19. //2.准备数据包
  20. Scanner sc = new Scanner(System.in);
  21. System.out.print("学生：");
  22. String str = sc.next();
  23. byte[] bytes = str.getBytes();
  24. /*
  25. 需要四个参数：
  26. 1.指的是传送数据转为Z字节数组
  27. 2.字节数组的长度
  28. 3.封装接收方的ip
  29. 4.指定接收方的端口号
  30. */
  31. DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
  32. //发送：
  33. ds.send(dp);
  35. //接收老师发送回来的信息：
  36. byte[] b = new byte[1024];
  37. DatagramPacket dp2 = new DatagramPacket(b,b.length);
  38. ds.receive(dp2);//接收完以后 dp2里面就填充好内容了
  40. //取出数据：
  41. byte[] data = dp2.getData();
  42. String s = new String(data,0,dp2.getLength());//dp.getLength()数组包中的有效长度
  43. System.out.println("老师对我说："+s);
  44. } catch (SocketException e) {
  45. e.printStackTrace();
  46. } catch (UnknownHostException e) {
  47. e.printStackTrace();
  48. } catch (IOException e) {
  49. e.printStackTrace();
  50. } finally {
  51. //关闭资源
  52. ds.close();
  53. }
  57. }
  58. }

接收方：

  1. package com.star.test04;
  3. import java.io.IOException;
  4. import java.net.*;
  5. import java.util.Scanner;
  7. /**
  8. * @author : Starshine
  9. */
  10. public class TestReceive {//接收方
  12. //这是一个main方法，是程序的入口：
  13. public static void main(String[] args){
  14. System.out.println("老师上线了。。");
  15. //1.创建套接字：指定接收方的端口
  16. DatagramSocket ds = null;
  17. try {
  18. ds = new DatagramSocket(9999);
  19. //2.有一个空的数据包，打算用来接收 对方传过来的数据包：
  20. byte[] b = new byte[1024];
  21. DatagramPacket dp = new DatagramPacket(b,b.length);
  22. //3.接收对方的数据包，然后放入我们的dp数据包中填充
  23. ds.receive(dp);//接收完以后 dp里面就填充好内容了
  25. //4.取出数据：
  26. byte[] data = dp.getData();
  27. String s = new String(data,0,dp.getLength());//dp.getLength()数组包中的有效长度
  28. System.out.println("学生对我说："+s);
  30. //老师进行回复：
  31. Scanner sc = new Scanner(System.in);
  32. System.out.print("老师：");
  33. String str = sc.next();
  34. byte[] bytes = str.getBytes();
  35. //封装数据，并且指定学生的ip和端口号
  36. DatagramPacket dp2 = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),8888);
  37. //发送：
  38. ds.send(dp2);
  39. } catch (SocketException e) {
  40. e.printStackTrace();
  41. } catch (UnknownHostException e) {
  42. e.printStackTrace();
  43. } catch (IOException e) {
  44. e.printStackTrace();
  45. } finally {
  46. //5.关闭资源：
  47. ds.close();
  48. }
  53. }
  54. }
功能分解4：正常通信

发送方：

  1. package com.star.test04;
  3. import java.io.IOException;
  4. import java.net.*;
  5. import java.util.Scanner;
  7. /**
  8. * @author : Starshine
  9. */
  10. public class TestSend {//发送方：
  12. //这是一个main方法，是程序的入口：
  13. public static void main(String[] args) {
  14. System.out.println("学生上线。。。");
  15. //1.准备套接字： 指定发送方的端口号
  16. DatagramSocket ds = null;
  17. try {
  18. ds = new DatagramSocket(8888);
  19. while(true){
  20. //2.准备数据包
  21. Scanner sc = new Scanner(System.in);
  22. System.out.print("学生：");
  23. String str = sc.next();
  25. byte[] bytes = str.getBytes();
  26. /*
  27. 需要四个参数：
  28. 1.指的是传送数据转为Z字节数组
  29. 2.字节数组的长度
  30. 3.封装接收方的ip
  31. 4.指定接收方的端口号
  32. */
  33. DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
  34. //发送：
  35. ds.send(dp);
  36. if(str.equals("byebye")){
  37. System.out.println("学生下线。。");
  38. break;
  39. }
  40. //接收老师发送回来的信息：
  41. byte[] b = new byte[1024];
  42. DatagramPacket dp2 = new DatagramPacket(b,b.length);
  43. ds.receive(dp2);//接收完以后 dp2里面就填充好内容了
  45. //取出数据：
  46. byte[] data = dp2.getData();
  47. String s = new String(data,0,dp2.getLength());//dp.getLength()数组包中的有效长度
  48. System.out.println("老师对我说："+s);
  49. }
  50. } catch (SocketException e) {
  51. e.printStackTrace();
  52. } catch (UnknownHostException e) {
  53. e.printStackTrace();
  54. } catch (IOException e) {
  55. e.printStackTrace();
  56. } finally {
  57. //关闭资源
  58. ds.close();
  59. }
  63. }
  64. }

接收方：

  1. package com.star.test04;
  3. import java.io.IOException;
  4. import java.net.*;
  5. import java.util.Scanner;
  7. /**
  8. * @author : Starshine
  9. */
  10. public class TestReceive {//接收方
  12. //这是一个main方法，是程序的入口：
  13. public static void main(String[] args){
  14. System.out.println("老师上线了。。");
  15. //1.创建套接字：指定接收方的端口
  16. DatagramSocket ds = null;
  17. try {
  18. ds = new DatagramSocket(9999);
  19. while(true){
  20. //2.有一个空的数据包，打算用来接收 对方传过来的数据包：
  21. byte[] b = new byte[1024];
  22. DatagramPacket dp = new DatagramPacket(b,b.length);
  23. //3.接收对方的数据包，然后放入我们的dp数据包中填充
  24. ds.receive(dp);//接收完以后 dp里面就填充好内容了
  26. //4.取出数据：
  27. byte[] data = dp.getData();
  28. String s = new String(data,0,dp.getLength());//dp.getLength()数组包中的有效长度
  29. System.out.println("学生对我说："+s);
  30. if(s.equals("byebye")){
  31. System.out.println("学生已经下线了，老师也下线。。。");
  32. break;
  33. }
  35. //老师进行回复：
  36. Scanner sc = new Scanner(System.in);
  37. System.out.print("老师：");
  38. String str = sc.next();
  39. byte[] bytes = str.getBytes();
  40. //封装数据，并且指定学生的ip和端口号
  41. DatagramPacket dp2 = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),8888);
  42. //发送：
  43. ds.send(dp2);
  44. }
  45. } catch (SocketException e) {
  46. e.printStackTrace();
  47. } catch (UnknownHostException e) {
  48. e.printStackTrace();
  49. } catch (IOException e) {
  50. e.printStackTrace();
  51. } finally {
  52. //5.关闭资源：
  53. ds.close();
  54. }
  59. }
  60. }
相关推荐
Python×CATIA工业智造3 小时前
Frida RPC高级应用：动态模拟执行Android so文件实战指南
开发语言·python·pycharm
pianmian13 小时前
类（JavaBean类）和对象
java
我叫小白菜4 小时前
【Java_EE】单例模式、阻塞队列、线程池、定时器
java·开发语言
狐凄4 小时前
Python实例题：基于 Python 的简单聊天机器人
开发语言·python
Albert Edison4 小时前
【最新版】IntelliJ IDEA 2025 创建 SpringBoot 项目
java·spring boot·intellij-idea
超级小忍5 小时前
JVM 中的垃圾回收算法及垃圾回收器详解
java·jvm
weixin_446122465 小时前
JAVA内存区域划分
java·开发语言·redis
悦悦子a啊5 小时前
Python之--基本知识
开发语言·前端·python
勤奋的小王同学~5 小时前
（javaEE初阶）计算机是如何组成的：CPU基本工作流程 CPU介绍 CPU执行指令的流程 寄存器 程序 进程 进程控制块 线程 线程的执行
java·java-ee
TT哇5 小时前
JavaEE==网站开发
java·redis·java-ee
热门推荐
01GPU 进阶笔记（二）：华为昇腾 910B GPU02Word粘贴时出现“运行时错误53,文件未找到：MathPage.WLL“的解决方案03Coze扣子平台完整体验和实践（附国内和国际版对比）04MIUI显示/隐藏5G开关的方法，信号弱时开启手机Wifi通话方法05扣子空间的使用教程与大模型技术思考06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07集群聊天服务器---MySQL数据库的建立08Coze实战第13讲：飞书多维表格读取+豆包生图模型，轻松批量生成短剧封面09DeepSeek各版本说明与优缺点分析10使用Ruby接入实时行情API教程