【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. }
相关推荐
charlie11451419111 分钟前
如何使用Qt创建一个浮在MainWindow上的滑动小Panel
开发语言·c++·qt·界面设计
Dcs15 分钟前
VSCode等多款主流 IDE 爆出安全漏洞！插件“伪装认证”可执行恶意命令！
java
神仙别闹19 分钟前
基于Python实现LSTM对股票走势的预测
开发语言·python·lstm
保持学习ing21 分钟前
day1--项目搭建and内容管理模块
java·数据库·后端·docker·虚拟机
京东云开发者32 分钟前
Java的SPI机制详解
java
超级小忍1 小时前
服务端向客户端主动推送数据的几种方法（Spring Boot 环境）
java·spring boot·后端
程序无bug1 小时前
Spring IoC注解式开发无敌详细（细节丰富）
java·后端
小莫分享1 小时前
Java Lombok 入门
java
程序无bug1 小时前
Spring 对于事务上的应用的详细说明
java·后端
食亨技术团队1 小时前
被忽略的 SAAS 生命线：操作日志有多重要
java·后端
热门推荐
01Java学习第十五部分——MyBatis02集群聊天服务器---MySQL数据库的建立03Coze扣子平台完整体验和实践（附国内和国际版对比）04基于odoo17的设计模式详解---装饰模式05使用Ruby接入实时行情API教程06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07【无标题】08Everything文件检索工具 几秒检索几百G的文件09DeepSeek各版本说明与优缺点分析10基于odoo17的设计模式详解---单例模式