【Java】网络编程TCP 实现聊天

网络编程TCP实现聊天的前提还需要掌握IO流,话不多说,直接上代码!!!

客户端:

  1. package com.kuang.lesson02;
  2. import java.io.IOException;
  3. import java.io.OutputStream;
  4. import java.net.InetAddress;
  5. import java.net.Socket;
  6. //客户端
  7. public class TcpClientDemo01 {
  8. public static void main(String[] args) {
  9. Socket socket = null;
  10. OutputStream os = null;
  11. try {
  12. //1、要知道服务器的地址、端口号
  13. InetAddress serverIP = InetAddress.getByName("127.0.0.1");
  14. int port = 9999;
  15. //2、创建一个socket连接
  16. socket = new Socket(serverIP, port);
  17. //3、发送消息IO流
  18. os = socket.getOutputStream();
  19. os.write("你好,Java".getBytes());
  20. } catch (Exception e) {
  21. e.printStackTrace();
  22. } finally {
  23. if (os != null) {
  24. try {
  25. os.close();
  26. } catch (IOException e) {
  27. e.printStackTrace();
  28. }
  29. }
  30. if (socket != null) {
  31. try {
  32. socket.close();
  33. } catch (IOException e) {
  34. e.printStackTrace();
  35. }
  36. }
  37. }
  38. }
  39. }

服务端:

  1. package com.kuang.lesson02;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  7. //服务端
  8. public class TcpServerDemo01 {
  9. public static void main(String[] args) {
  10. ServerSocket serverSocket = null;
  11. Socket socket = null;
  12. InputStream is = null;
  13. ByteArrayOutputStream baos = null;
  14. try {
  15. //1、我得有一个地址
  16. serverSocket = new ServerSocket(9999);
  17. while (true) {
  18. //2、等待客户端连接过来
  19. socket = serverSocket.accept();
  20. //3、读取客户端的消息
  21. is = socket.getInputStream();
  22. //管道流
  23. baos = new ByteArrayOutputStream();
  24. byte[] buffer = new byte[1024];
  25. int len;
  26. while ((len = is.read(buffer)) != -1) {
  27. baos.write(buffer, 0, len);
  28. }
  29. System.out.println(baos.toString());
  30. }
  31. } catch (Exception e) {
  32. e.printStackTrace();
  33. } finally {
  34. //关闭资源
  35. if (baos != null) {
  36. try {
  37. baos.close();
  38. } catch (IOException e) {
  39. e.printStackTrace();
  40. }
  41. }
  42. if (is != null) {
  43. try {
  44. is.close();
  45. } catch (IOException e) {
  46. e.printStackTrace();
  47. }
  48. }
  49. if (socket != null) {
  50. try {
  51. socket.close();
  52. } catch (IOException e) {
  53. e.printStackTrace();
  54. }
  55. }
  56. if (serverSocket != null) {
  57. try {
  58. serverSocket.close();
  59. } catch (IOException e) {
  60. e.printStackTrace();
  61. }
  62. }
  63. }
  64. }
  65. }

运行结果:

1、首先运行服务端,等待接收消息,可以发现服务端一直在运行
在这里插入图片描述

2、接着运行客户端,发送消息,可以发现客户端运行结束
在这里插入图片描述

3、返回服务端查看,可以发现服务端已经接收到了客户端发送来的消息
在这里插入图片描述

4、由于是循环操作,所以只要客户端发送消息来,服务端就能接收到,可以实现多次发送消息。

发表评论

表情:
评论列表 (有 0 条评论,82人围观)

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

相关阅读