InetAddress类

  • 此类表示Internet协议(IP)地址

    InetAddress API如下：

  1. IP地址的代表类是谁？
    1. InetAddress类
  2. 如何获取本机IP对象
    1. public static InetAddress getLocalHost();
  3. 如何判断与该IP地址对象是否互通
    1. public boolean isReachable(int timeout);

测试代码：

  1. package com.h;
  2. import java.io.IOException;
  3. import java.net.InetAddress;
  4. import java.net.UnknownHostException;
  6. /*
  7.  *   网络编程
  8.  * */
  9. public class InetAddressDemo01 {
  10.     public static void main(String[] args) throws IOException {
  11.         //1、 获取本机地址对象
  12.         InetAddress address = InetAddress.getLocalHost();
  13.         //2、获取本地主机名与地址
  14.         System.out.println(address.getHostName());
  15.         System.out.println(address.getHostAddress());
  17.         //3、获取域名ip地址，前提是电脑联网或者有dns缓存
  18.         InetAddress address1 = InetAddress.getByName("www.baidu.com");
  19.         System.out.println(address1.getHostAddress());
  20.         System.out.println(address1.getHostName());
  22.         //4、获取公网IP对象
  23.         InetAddress address2 = InetAddress.getByName("110.242.68.3");
  24.         System.out.println(address2.getHostName());
  25.         System.out.println(address2.getHostAddress());
  27.         //5、判断是否能通：ping 5s之前测试是否可通
  28.         System.out.println(address2.isReachable(5000)); //返回true
  29.     }
  30. }

端口：

端口号：范围0~65535
端口号的作用

  • 唯一标识正在计算机设备上运行的进程(程序)

一个设备中，能否出现2个应用程序的端口号一样，为什么？

  • 不可以，如果一样会出现端口冲突错误

传输层的2个常见协议

  • TCP：传输控制协议
  • UDP：用户数据报协议

TCP协议特点

  • 使用TCP协议，必须双方先建立连接，它是一种面向连接的可靠通信协议
  • 传输前，采用“三次握手”方式建立连接，所以是可靠的
  • 在连接中可进行大数据量的传输
  • 连接，发送数据都需要确认，且传输完毕后，还需释放已建立的连接，通信效率较低

TCP协议通信场景

  • 对信息安全要求较高的场景，例如：文件下载、金融等数据通信

三次握手
客户端 ——> 服务器：客户端向服务器发出连接请求，等待服务器确认
服务器 ——> 客户端：服务器向客户端返回一个响应，告诉客户端收到了请求
客户端 ——> 服务器：客户端向服务器再次发出确认信息，连接建立
TCP四次挥手断开连接
客户端 ——> 服务器：客户端向服务器发出取消连接请求
…………..
UDP协议

  • UDP是一种无连接、不可靠传输的协议
  • 语音通话，视频会话等。

TCP必须先建立连接才能通信，UDP不需要建立连接

UDP

DatagramPacket:数据包对象(韭菜盘子)

  • 构造器：public DatagramPacket(byte[] buf, int length, InetAddress address, int port)；
    • 创建发送端数据包对象；
    • buf:要发送的内容,字节数组;
    • length:要发送内容的字节长度;
    • address:接收端的IP地址对象；
    • port:接收端口号

DatagramSocket：发送端和接收端对象(人)

  • 构造器：public DatagramSocket()；创建发送端的Socket对象,系统会随机分配一个端口号
  • 构造器2：public DatagramSocket(int port)：创建接收端的Socket对象并指定端口号
  • send(DatagramPacket dp)；发送数据包
  • receive(DatagramPacket p)；接收数据包

一发一收

  3. 发送端
  4. package com.h.UDP;
  6. import java.net.*;
  7. import java.nio.charset.StandardCharsets;
  9. /*
  10. *   发送端
  11. * */
  12. public class ClientDemo1 {
  13.     public static void main(String[] args) throws Exception {
  14.         //1、创建发送端对象:发送端自带默认端口号。不填7777就是默认端口填7777是指定端口
  15.         DatagramSocket socket = new DatagramSocket(7777);
  17.         //2、创建一个数据包对象封装数据(韭菜盘子)
  18.         //参数
  19.         //参数一：封装要发送的数据(韭菜) byte[]
  20.         //参数二：数据大小 int length
  21.         //参数三：服务端IP地址 对方的ip
  22.         //参数四：服务端的端口 对方的端口
  24.         byte[] buff = "我是韭菜".getBytes();
  26.         //这个8888端口是将数据包发送给服务端的socket端口必须一样
  27.         DatagramPacket packet = new DatagramPacket(buff,4,
  28.                 InetAddress.getLocalHost() ,8888);
  31.         //3、发送数据出去
  32.         socket.send(packet);
  34.         socket.close();
  35.     }
  36. }
  39. 接收端
  40. package com.h.UDP;
  42. import java.net.DatagramPacket;
  43. import java.net.DatagramSocket;
  44. import java.net.SocketException;
  46. /*
  47. *   接收端 服务端
  48. * */
  49. public class ServerDemo2 {
  50.     public static void main(String[] args) throws Exception {
  51.         System.out.println("===服务端启动===");
  52.         //1、创建接收端对象：注册端口(人) 这里的Socket8888端口必须和数据包里面的端口一致
  53.         DatagramSocket socket = new DatagramSocket(8888);
  55.         //2、创建一个数据包对象接数据
  56.         byte[] buff = new byte[1024 * 64];
  57.         DatagramPacket packet = new DatagramPacket(buff,buff.length);
  59.         //3、接收数据
  60.         socket.receive(packet);
  61.         //4、取出数据
  62.         //读多少倒多少
  63.         int len = packet.getLength();
  64.         String str = new String(buff,0,len);
  65.         //获取发送端的ip
  66.         String address = packet.getSocketAddress().toString();
  67.         //这个端口是对方默认端口
  68.         int port = packet.getPort();
  69.         System.out.println(str+" "+port+" "+address);
  71.         socket.close();
  72.     }
  73. }

广播：
当前主机与所在网络中所有主机通信，广播消息是可以发给当前所在网络中的所有服务器
广播ip：255.255.255.255

  1. package com.h.udp;
  3. import java.net.*;
  5. /*
  6. *   发送端
  7. * */
  8. public class ClientDemo1 {
  9.     public static void main(String[] args) throws Exception {
  10.         //1、创建发送端对象:发送端自带默认端口号。
  11.         DatagramSocket socket = new DatagramSocket();
  13.         //2、创建一个数据包对象封装数据(韭菜盘子)
  14.         //参数
  15.         //参数一：封装要发送的数据(韭菜) byte[]
  16.         //参数二：数据大小 int length
  17.         //参数三：服务端IP地址 对方的ip
  18.         //参数四：服务端的端口 对方的端口
  20.         byte[] buff = "我是韭菜".getBytes();
  22.         //这个8888端口是将数据包发送给服务端的socket端口必须一样
  23.         //广播IP 255.255.255.255
  24.         DatagramPacket packet = new DatagramPacket(buff,4,
  25.                 InetAddress.getByName("255.255.255.255") ,8888);
  28.         //3、发送数据出去
  29.         socket.send(packet);
  31.         socket.close();
  33.     }
  34. }
  36. //接收端
  37. package com.h.udp;
  39. import java.net.DatagramPacket;
  40. import java.net.DatagramSocket;
  42. /*
  43. *   接收端 服务端
  44. * */
  45. public class ServerDemo2 {
  46.     public static void main(String[] args) throws Exception {
  47.         System.out.println("===服务端启动===");
  48.         //1、创建接收端对象：注册端口(人) 这里的Socket8888端口必须和数据包里面的端口一致
  49.         DatagramSocket socket = new DatagramSocket(8888);
  51.         //2、创建一个数据包对象接数据
  52.         byte[] buff = new byte[1024 * 64];
  53.         DatagramPacket packet = new DatagramPacket(buff,buff.length);
  55.         //3、接收数据
  56.         socket.receive(packet);
  57.         //4、取出数据
  58.         //读多少倒多少
  59.         int len = packet.getLength();
  60.         String str = new String(buff,0,len);
  61.         //获取发送端的ip
  62.         String address = packet.getSocketAddress().toString();
  63.         //这个端口是对方默认端口
  64.         int port = packet.getPort();
  65.         System.out.println(str+" "+port+" "+address);
  67.         socket.close();
  68.     }
  69. }

组播：

  • 使用组播地址：224.0.0.0 ~ 239.255.255.255
  • 具体操作
    • 发送端的数据包的目的地是组播IP(例如：224.0.1.1，端口9999)
    • 接收端必须绑定该组播IP(224.0.1.1),端口要对应发送端的端口9999，这样即可接收消息
    • DatagramSocket的子类MulticastSocket可以在接收端绑定组播IP

组播是可以选择性的发送给指定ip的服务器

  1. //发送端
  2. package com.h.udp_multicast;
  3. import java.net.*;
  4. public class Cline {
  5.     public static void main(String[] args) {
  6.         try {
  7.             //创建发送器
  8.             DatagramSocket d = new DatagramSocket();
  9.             byte[] buffer = "组播".getBytes();
  11.             //创建数据包
  12.             //组播ip为224.0.0.0 ~ 239.255.255.255
  13.             DatagramPacket dp = new DatagramPacket(buffer,buffer.length, InetAddress.getByName("224.0.1.1"),8888);
  15.             d.send(dp);
  17.             d.close();
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  22. }
  24. //接收端
  26. package com.h.udp_multicast;
  28. import java.net.*;
  30. /*
  31. *   接收端 服务端
  32. * */
  33. public class Server {
  34.     public static void main(String[] args) throws Exception {
  35.         System.out.println("===服务端启动===");
  37.         //组播主要是需要MulticastSocket这个对象
  38.         //创建接收端对象 注册端口
  39.         MulticastSocket socket = new MulticastSocket(8888);
  41.         //当前接收端加入到一个组播组里面去：绑定对应的组播ip
  42. //        socket.joinGroup(InetAddress.getByName("224.0.1.1")); 过时的写法
  43.         //使用新的写法 
  44.         socket.joinGroup(new InetSocketAddress(InetAddress.getByName("224.0.1.1"),8888),
  45.                 NetworkInterface.getByInetAddress(InetAddress.getLocalHost()));
  48.         //2、创建一个数据包对象接数据
  49.         byte[] buff = new byte[1024 * 64];
  50.         DatagramPacket packet = new DatagramPacket(buff,buff.length);
  52.         //3、接收数据
  53.         socket.receive(packet);
  54.         //4、取出数据
  55.         //读多少倒多少
  56.         int len = packet.getLength();
  57.         String str = new String(buff,0,len);
  58.         //获取发送端的ip
  59.         String address = packet.getSocketAddress().toString();
  60.         //这个端口是对方默认端口
  61.         int port = packet.getPort();
  62.         System.out.println(str+" "+port+" "+address);
  64.         socket.close();
  65.     }
  66. }

多发多收

  1. package com.h.udp2;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. import java.net.InetAddress;
  6. import java.util.Scanner;
  8. /*
  9.  *   发送端 多发多收
  10.  * */
  11. public class ClientDemo1 {
  12.     public static void main(String[] args) throws Exception {
  13.         //1、创建发送端对象:发送端自带默认端口号。
  14.         DatagramSocket socket = new DatagramSocket();
  16.         //2、创建一个数据包对象封装数据(韭菜盘子)
  17.         //参数
  18.         //参数一：封装要发送的数据(韭菜) byte[]
  19.         //参数二：数据大小 int length
  20.         //参数三：服务端IP地址 对方的ip
  21.         //参数四：服务端的端口 对方的端口
  23.         Scanner sc = new Scanner(System.in);
  24.         while (true) {
  26.             System.out.println("请说：");
  27.             String  s = sc.nextLine();
  28.             if(s.equals("exit")){
  29.                 System.out.println("离线成功");
  30.                 socket.close();
  31.                 break;
  32.             }
  34.             byte[] buff = s.getBytes();
  35.             //这个8888端口是将数据包发送给服务端的socket端口必须一样
  36.             DatagramPacket packet = new DatagramPacket(buff, buff.length,
  37.                     InetAddress.getLocalHost(), 8888);
  40.             //3、发送数据出去
  41.             socket.send(packet);
  42.         }
  43.     }
  44. }
  47. 接收端
  48. package com.h.udp2;
  50. import java.net.DatagramPacket;
  51. import java.net.DatagramSocket;
  52. import java.util.Scanner;
  54. /*
  55.  *   接收端 服务端 多发多收
  56.  * */
  57. public class ServerDemo2 {
  58.     public static void main(String[] args) throws Exception {
  59.         System.out.println("===服务端启动===");
  60.         //1、创建接收端对象：注册端口(人) 这里的Socket8888端口必须和数据包里面的端口一致
  61.         DatagramSocket socket = new DatagramSocket(8888);
  63.         byte[] buff = new byte[1024 * 64];
  64.         DatagramPacket packet = new DatagramPacket(buff, buff.length);
  66.         while (true) {
  68.             socket.receive(packet);
  69.             //收到多收数据
  70.             int len = packet.getLength();
  71.             System.out.println("收到了来自："+packet.getPort()+
  72.                     packet.getSocketAddress()+"的数据"+
  73.                     new String(buff,0,len));
  74.         }
  75.     }
  76. }

基础版互相聊天:使用线程来来完成

  1. package com.h.udp2;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. import java.net.InetAddress;
  6. import java.net.SocketException;
  7. import java.util.Scanner;
  9. /*
  10.  *   发送端 多发多收
  11.  * */
  12. public class ClientDemo1 {
  13.     public static void main(String[] args) throws Exception {
  14.         //1、创建发送端对象:发送端自带默认端口号。
  16.         //2、创建一个数据包对象封装数据(韭菜盘子)
  17.         //参数
  18.         //参数一：封装要发送的数据(韭菜) byte[]
  19.         //参数二：数据大小 int length
  20.         //参数三：服务端IP地址 对方的ip
  21.         //参数四：服务端的端口 对方的端口
  24.         new Thread() {
  25.             @Override
  26.             public void run() {
  27.                 Scanner sc = new Scanner(System.in);
  28.                 DatagramSocket socket = null;
  29.                 try {
  30.                     socket = new DatagramSocket();
  31.                     while (true) {
  32.                         System.out.println("请说：");
  33.                         String s = sc.nextLine();
  34.                         if (s.equals("exit")) {
  35.                             System.out.println("离线成功");
  36.                             socket.close();
  37.                             break;
  38.                         }
  39.                         byte[] buff = s.getBytes();
  40.                         //这个8888端口是将数据包发送给服务端的socket端口必须一样
  41.                         DatagramPacket packet = new DatagramPacket(buff, buff.length,
  42.                                 InetAddress.getLocalHost(), 7777);
  43.                         //3、发送数据出去
  44.                         socket.send(packet);
  46.                     }
  47.                 } catch (Exception e) {
  48.                     e.printStackTrace();
  49.                 }
  50.             }
  51.         }.start();
  53.         new Thread(){
  54.             @Override
  55.             public void run() {
  56.                 System.out.println("===服务端启动===");
  57.                 //1、创建接收端对象：注册端口(人) 这里的Socket8888端口必须和数据包里面的端口一致
  58.                 DatagramSocket socket = null;
  59.                 try {
  60.                     socket = new DatagramSocket(8888);
  63.                     byte[] buff = new byte[1024 * 64];
  64.                     DatagramPacket packet = new DatagramPacket(buff, buff.length);
  66.                     while (true) {
  68.                         //等待接收的数据
  69.                         socket.receive(packet);
  70.                         //收到多收数据
  71.                         int len = packet.getLength();
  73.                         System.out.println("收到了来自："+packet.getPort()+
  74.                                 packet.getSocketAddress()+"的数据"+
  75.                                 new String(buff,0,len));
  76.                     }
  77.                 } catch (Exception e) {
  78.                     e.printStackTrace();
  79.                 }
  80.             }
  81.         }.start();
  84.     }
  85. }
  87. 第二个端
  88. package com.h.udp2;
  90. import java.net.DatagramPacket;
  91. import java.net.DatagramSocket;
  92. import java.net.InetAddress;
  93. import java.net.SocketException;
  94. import java.util.Scanner;
  96. /*
  97.  *   接收端 服务端 多发多收
  98.  * */
  99. public class ServerDemo2 {
  100.     public static void main(String[] args) throws Exception {
  102.         new Thread() {
  103.             @Override
  104.             public void run() {
  105.                 Scanner sc = new Scanner(System.in);
  106.                 DatagramSocket socket = null;
  107.                 try {
  108.                     socket = new DatagramSocket();
  109.                     while (true) {
  110.                         System.out.println("请说：");
  111.                         String s = sc.nextLine();
  112.                         if (s.equals("exit")) {
  113.                             System.out.println("离线成功");
  114.                             socket.close();
  115.                             break;
  116.                         }
  117.                         byte[] buff = s.getBytes();
  118.                         //这个8888端口是将数据包发送给服务端的socket端口必须一样
  119.                         DatagramPacket packet = new DatagramPacket(buff, buff.length,
  120.                                 InetAddress.getLocalHost(), 8888);
  121.                         //3、发送数据出去
  122.                         socket.send(packet);
  124.                     }
  125.                 } catch (Exception e) {
  126.                     e.printStackTrace();
  127.                 }
  128.             }
  129.         }.start();
  131.         new Thread(){
  132.             @Override
  133.             public void run() {
  134.                 System.out.println("===服务端启动===");
  135.                 //1、创建接收端对象：注册端口(人) 这里的Socket8888端口必须和数据包里面的端口一致
  136.                 DatagramSocket socket = null;
  137.                 try {
  138.                     socket = new DatagramSocket(7777);
  141.                 byte[] buff = new byte[1024 * 64];
  142.                 DatagramPacket packet = new DatagramPacket(buff, buff.length);
  144.                 while (true) {
  146.                     //等待接收的数据
  147.                     socket.receive(packet);
  148.                     //收到多收数据
  149.                     int len = packet.getLength();
  151.                     System.out.println("收到了来自："+packet.getPort()+
  152.                             packet.getSocketAddress()+"的数据"+
  153.                             new String(buff,0,len));
  154.                 }
  155.                 } catch (Exception e) {
  156.                     e.printStackTrace();
  157.                 }
  158.             }
  159.         }.start();
  160.     }
  161. }

UDP广播，组播

TCP:

三次握手，
客户端和服务端通信之间，双方会建立一个连接管道，Socket
TCP是通过流来进行实现消息的传递
image.png
Socket :
构造器：public Socket(String host,int port);创建一个发送端的Socket对象与服务端连接，参数为服务端程序的ip地址和端口
成员方法：

  • OutputStream getOutputStream()；获取字节输出流对象
  • InputStream getInputStream()；获取输入流对象

    客户端发送信息

    需求：客户端实现步骤
  1. 创建客户端的Socket对象，请求与服务端的连接
  2. 使用socket对象调用getOutputStream()方法得到一个字节输出流
  3. 使用字节输出流完成数据的发送
  4. 释放资源：关闭资源

现在服务端为什么不可以接收多个客户端

  • TCP服务端是单线程一次只能处理一个客户端所以不能实现一个服务端接收多个客户端

TCP代码实现
一发一收：

  1. //服务端
  2. package com.h.tcp;
  4. import java.io.BufferedReader;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.io.PrintStream;
  8. import java.net.ServerSocket;
  9. import java.net.Socket;
  11. /*
  12.  *   服务端
  13.  * */
  14. public class TcpServer {
  16.     public static void main(String[] args) {
  17.         System.out.println("服务端启动");
  18.         try (
  19.                 ServerSocket ss = new ServerSocket(7777);
  21.         ) {
  23.             //阻塞等待客户端连接
  24.             Socket socket = ss.accept();
  26.             //如果阻塞在IO后面的话就会出现编译错误，因为阻塞是在等客户端的流
  27.             InputStream in = socket.getInputStream();
  29.             //使用高级字符流来获取文本信息   使用了转换流
  30.             BufferedReader br = new BufferedReader(new InputStreamReader(in));
  32.             String str ;
  33.             //对方挂了server也挂 实现了一发一收
  34.             if ((str = br.readLine())!=null) {
  35.                 System.out.println(socket.getRemoteSocketAddress()+"说了:"+str);
  36.             }
  38.         } catch (Exception e) {
  39.             e.printStackTrace();
  40.         }
  41.     }
  42. }
  45. //接收端
  46. package com.h.tcp;
  48. import java.io.FileOutputStream;
  49. import java.io.OutputStream;
  50. import java.io.PrintStream;
  51. import java.net.InetAddress;
  52. import java.net.Socket;
  53. import java.net.UnknownHostException;
  55. /*
  56. * 客户端
  57. * */
  58. public class Tcpclient {
  59.     public static void main(String[] args)   {
  60.         try{
  63.         //参数一、服务端ip地址
  64.         //参数二、服务端端口号
  66.         // 10.50.128.211
  67.         Socket socket = new Socket("10.50.128.211",7777);
  69.         //从socket中得到一个字节输出流，负责发送消息
  70.         //把低级的字节流包装成打印流
  71.         PrintStream ps = new PrintStream(out);
  73. //        //发送消息
  74.         ps.println("你好TCP服务器，我是客户端");
  75.         ps.flush();
  77.         //关闭资源
  78.         socket.close();
  79.         }catch (Exception e){
  81.         }
  82.     }
  83. }

TCP多发多收

  1.  package com.h.tcp2;
  3. import java.io.BufferedReader;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  9. /*
  10.  *   服务端
  11.  * */
  12. public class TcpServer {
  14.     public static void main(String[] args) {
  15.         System.out.println("服务端启动");
  16.         try (
  17.                 ServerSocket ss = new ServerSocket(7777);
  19.         ) {
  21.             //阻塞等待客户端连接
  22.             Socket socket = ss.accept();
  24.             //如果阻塞在IO后面的话就会出现编译错误，因为阻塞是在等客户端的流
  25.             InputStream in = socket.getInputStream();
  27.             //使用高级字符流来获取文本信息   使用了转换流
  28.             BufferedReader br = new BufferedReader(new InputStreamReader(in));
  30.             String str;
  31.             //每次接收到了客户端后就会一直在这等消息
  32.             while ((str = br.readLine()) != null) {
  33.                 System.out.println(socket.getRemoteSocketAddress() + "说了:" + str);
  34.             }
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  41. }
  44. package com.h.tcp2;
  46. import java.io.OutputStream;
  47. import java.io.PrintStream;
  48. import java.net.Socket;
  49. import java.util.Scanner;
  51. /*
  52.     多发多收
  53.  * 客户端
  54.  * */
  55. public class Tcpclient {
  56.     public static void main(String[] args) {
  57.         try {
  58.             //创建用户输入类
  59.             Scanner sc = new Scanner(System.in);
  61.             //参数一、服务端ip地址
  62.             //参数二、服务端端口号
  64.             // 10.50.128.211
  65.             Socket socket = new Socket("10.50.128.214", 7777);
  68.             //从socket中得到一个字节输出流，负责发送消息
  69.             OutputStream out = socket.getOutputStream();
  71.             //把低级的字节流包装成打印流 这里只是把低级的流进行了包装后再发过去
  72.             PrintStream ps = new PrintStream(out);
  73.             while (true) {
  74.                 //发送消息
  75.                 System.out.println("请输入你要发送的内容");
  76.                 String s = sc.nextLine();
  77.                 //发送内容
  78.                 ps.println(s);
  80.                 ps.flush();
  81.             }
  82.         } catch (Exception e) {
  84.         }
  85.     }
  86. }

完成一个服务端同时处理多个客户端消息

  • 使用线程实现了一个服务端接收多个客户端
  • Socket.accept()这里阻塞直到获取一个客户端后代码才会继续向下执行
  • 获取到了客户端后接下来就会在read()方法哪里等待可以客户端输入内容过来，会一直在获取客户端内容
  • 所以用while来创建多个来接收多个客户端的，一个线程处理一个客户端
  • 这样一来就实现了一个服务端接收多个客户端信息

代码：

  1. //服务端
  2. System.out.println("=====服务端启动=====");
  3.   try { 
  4.     ServerSocket ss = new ServerSocket(7777);
  5.     while (true) {
  6.          //每次都会接收到客户端电的Socket管道，交给一个独立线程,会在这里阻塞
  7.          Socket socket = ss.accept();
  8.          //开始创建独立线程处理socket
  9.          new ThreadT(socket).start();
  10.   }
  11.  //线程
  12. public class ThreadT extends Thread{
  13.     private Socket socket;
  14.     public ThreadT(Socket socket){
  15.         this.socket = socket;
  16.     }
  17.     public void run() {
  18.         try {
  19.             InputStream inputStream = socket.getInputStream();
  20.             BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
  21.             String str ;
  22.             while ((str = br.readLine())!=null){
  23.                 System.out.println(socket.getRemoteSocketAddress()+"说："+str);
  24.             }
  25.         } catch (Exception e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  29. }
  30. //客户端
  31.       package com.h.tcp2;
  33. import java.io.OutputStream;
  34. import java.io.PrintStream;
  35. import java.net.Socket;
  36. import java.util.Scanner;
  38. /*
  39.     多发多收
  40.  * 客户端
  41.  * */
  42. public class Tcpclient {
  43.     public static void main(String[] args) {
  44.         try {
  45.             //创建用户输入类
  46.             Scanner sc = new Scanner(System.in);
  48.             //参数一、服务端ip地址
  49.             //参数二、服务端端口号
  51.             // 10.50.128.211
  52.             Socket socket = new Socket("10.50.128.214", 7777);
  54.             //从socket中得到一个字节输出流，负责发送消息
  55.             OutputStream out = socket.getOutputStream();
  57.             //把低级的字节流包装成打印流 这里只是把低级的流进行了包装后再发过去
  58.             PrintStream ps = new PrintStream(out);
  59.             while (true) {
  60.                 //发送消息
  61.                 System.out.println("请输入你要发送的内容");
  62.                 String s = sc.nextLine();
  64.                 if (s.equals("exit")) {
  65.                     break;
  66.                 }
  67.                 //发送内容
  68.                 ps.println(s);
  70.                 ps.flush();
  71.             }
  72.         } catch (Exception e) {
  74.         }
  75.     }
  76. }

使用线程池实现：

  • 服务端可以复用线程处理多个客户端，可以避免系统瘫痪 ```java //客户端 package com.h.tcp_many_majorization;

import com.h.tcp_many.ThreadT;

import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.*;

/

  • 使用线程池进行优化

  • */ public class TcpServerDuo优化 { //使用静态变量记住一个线程池对象 private static ExecutorService tpe = new ThreadPoolExecutor(3, 5, 6,

    1.     TimeUnit.SECONDS, new ArrayBlockingQueue<>(2),
    2.     Executors.defaultThreadFactory(),
    3.     new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {

    1. System.out.println("=====服务端启动=====");
    2. try {
    4.     //注册端口
    5.     ServerSocket ss = new ServerSocket(7777);
    7.     while (true) {
    8.         //每次都会接收到客户端电的Socket管道，交给一个独立线程,会在这里阻塞
    9.         Socket socket = ss.accept();
    10.         System.out.println(socket.getRemoteSocketAddress() + "上线了");
    12.         //创建线程类
    13.         ServerRunnable s = new ServerRunnable(socket);
    14.         tpe.execute(s);
    15.     }
    16. } catch (Exception e) {
    17.     e.printStackTrace();
    18. }

    } } //线程 package com.h.tcp_many_majorization;

import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.net.Socket;

public class ServerRunnable implements Runnable{

  1. private Socket socket;
  2. public ServerRunnable(Socket socket){
  3.     this.socket = socket;
  4. }
  6. @Override
  7. public void run() {
  8.     try {
  10.         InputStream inputStream = socket.getInputStream();
  12.         BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
  14.         String str ;
  16.         while ((str = br.readLine())!=null){
  17.             System.out.println(socket.getRemoteSocketAddress()+"说："+str);
  18.         }
  21.     } catch (Exception e) {
  22.         System.out.println(socket.getRemoteSocketAddress()+"这个吊毛已经离线了");
  23.     }
  24. }

} //接收端跟上面一样

  1. <a name="QpktB"></a>
  2. ### TCP即时通信
  3. 即时通信是什么含义，要实现怎么样的设计
  5. - 发送消息个服务端，服务端在转发给所有客户端
  6. - 即时通信，是指一个客户端的消息发出去，其他客户端可以接收到
  7. - 即时通信需要进行端口转发的设计思想
  8. - 服务端需要把在线的Socket管道存储起来
  9. - 一旦收到一个消息要推送给其他管道
  11. 代码实现：
  12. ```java
  13. package com.h.tcpim;
  15. import com.h.tcp_many_majorization.ServerRunnable;
  17. import java.io.*;
  18. import java.net.ServerSocket;
  19. import java.net.Socket;
  20. import java.util.ArrayList;
  21. import java.util.List;
  22. import java.util.concurrent.*;
  24. /*
  25.  *
  26.  * 端口转发 即时通信
  27.  *  */
  28. public class TcpServerIM {
  29.     //定义一个静态的List集合存储当前全部在线的Socket管道
  30.     public static List<Socket> list = new ArrayList<>();
  33.     //使用静态变量记住一个线程池对象
  34.     private static ExecutorService tpe = new ThreadPoolExecutor(3, 5, 6,
  35.             TimeUnit.SECONDS, new ArrayBlockingQueue<>(2),
  36.             Executors.defaultThreadFactory(),
  37.             new ThreadPoolExecutor.AbortPolicy());
  39.     public static void main(String[] args) {
  40.         System.out.println("=====服务端启动=====");
  41.         try {
  43.             //注册端口
  44.             ServerSocket ss = new ServerSocket(7777);
  46.             while (true) {
  48.                 //每次都会接收到客户端电的Socket管道，交给一个独立线程,会在这里阻塞
  49.                 Socket socket = ss.accept();
  50.                 //每次有一个客户端上线就把他加入到这个集合中去
  51.                 list.add(socket);
  53.                 System.out.println(socket.getRemoteSocketAddress() + "上线了");
  55.                 //创建线程类
  56.                 ThreadIM s = new ThreadIM(socket);
  57.                 tpe.execute(s);
  58.             }
  59.         } catch (Exception e) {
  60.             e.printStackTrace();
  61.         }
  64.     }
  65. }
  66. class ThreadIM extends Thread{
  67.     private  Socket socket;
  69.     public ThreadIM(Socket socket){
  70.         this.socket = socket;
  71.     }
  73.     @Override
  74.     public void run() {
  75.         try {
  77.             InputStream inputStream = socket.getInputStream();
  79.             BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
  81.             String str ;
  83.             while ((str = br.readLine())!=null){
  84.                 System.out.println(socket.getRemoteSocketAddress()+"说："+str);
  86.                 //服务端收到消息后 转发出去 进行端口转发发送给全部的Socket管道
  87.                 sendMsgToAll(str);
  88.             }
  91.         } catch (Exception e) {
  92.             System.out.println(socket.getRemoteSocketAddress()+"这个吊毛已经离线了");
  93.             //当客户端挂掉后 就会从集合中删除这个socket 这样程序就不会报错
  94.             TcpServerIM.list.remove(socket);
  95.         }
  96.     }
  98.     private void sendMsgToAll(String str) throws Exception {
  100.         //list里面有所有的上线了的客户端，所以我们就把这些客户端遍历出来把消息通过流在发出去
  101.         for (Socket socket: TcpServerIM.list ) {
  102.             PrintStream pr = new PrintStream(socket.getOutputStream());
  103.             pr.println(str);
  104.             pr.flush();
  107.         }
  110.     }
  112. }
  114. package com.h.tcpim;
  116. import java.io.*;
  117. import java.net.Socket;
  118. import java.net.SocketAddress;
  119. import java.util.HashMap;
  120. import java.util.Random;
  121. import java.util.Scanner;
  122. import java.util.Set;
  124. /*
  125.     多发多收
  126.  * 客户端
  127.  * */
  128. public class TcpClient {
  130.     public static void main(String[] args) throws Exception {
  132.         //创建用户输入类
  133.         Scanner sc = new Scanner(System.in);
  135.         //参数一、服务端ip地址
  136.         //参数二、服务端端口号
  138.         // 10.50.128.211
  139.         Socket socket = new Socket("10.50.128.214", 7777);
  140.         //创建一个独立的线程专门负责这个客户端的读消息，服务器随时会转发消息过来
  141.         new ClientReaderThread(socket).start();
  143.         //从socket中得到一个字节输出流，负责发送消息
  144.         OutputStream out = socket.getOutputStream();
  146.         //把低级的字节流包装成打印流 这里只是把低级的流进行了包装后再发过去
  147.         PrintStream ps = new PrintStream(out);
  148.         while (true) {
  149.             //发送消息
  150.             System.out.println("请输入你要发送的内容");
  151.             String s = sc.nextLine();
  153.             if (s.equals("exit")) {
  154.                 break;
  155.             }
  156.             //发送内容
  157.             ps.println(s);
  159.             ps.flush();
  160.         }
  161.     }
  162. }
  164. class ClientReaderThread extends Thread {
  165.     private Socket socket;
  167.     public ClientReaderThread(Socket socket) {
  168.         this.socket = socket;
  169.     }
  172.     @Override
  173.     public void run() {
  175.         try {
  177.             InputStream inputStream = socket.getInputStream();
  179.             BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
  181.             String str;
  184.             while ((str = br.readLine()) != null) {
  185.                 System.out.println(getName() + "发送消息：" + str);
  186.             }
  188.         } catch (Exception e) {
  189.             System.out.println("服务端把你踢出去了");
  191.         }
  192.     }
  193. }

总结

UDP使用的是DatagramSocket类DatagramPacket
客户端

  • DatagramSocket socket = new DatagramSocket();
  • DatagramPacket packet = new DatagramPacket(buff, buff.length, InetAddress.getLocalHost(), 7777);
  • 使用socket.send();

服务端

  • DatagramSocket socket = new DatagramSocket(7777);//注册端口
  • DatagramPacket packet = new DatagramPacket(buff,buff.length);
  • socket.receive();

TCP使用
客户端

  • Socket socket = new Socket(“10.50.128.214”, 7777);
  • socket.getOutputStream();

服务端

  • ServerSocket ss = new Socket(777);//注册端口
  • ss.accept();
  • ss.getInputStream();
  1. 使用代码下载音乐
  3. package com.hhm.下载音乐;
  5. import java.io.File;
  6. import java.io.FileOutputStream;
  7. import java.io.InputStream;
  8. import java.net.HttpURLConnection;
  9. import java.net.MalformedURLException;
  10. import java.net.URL;
  12. public class 下载音乐 {
  13.     public static void main(String[] args) {
  14.         try {
  15.             //下载地址
  16.             URL url = new URL("https://m801.music.126.net/20211214174656/0047165544898dca518d32057e866e50/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/11858827254/839c/479d/c797/5b2e139670c187c5391ef2e22d698d2d.m4a");
  17.             //连接到这个资源
  18.             HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
  20.             InputStream inputStream = urlConnection.getInputStream();
  22.             //下载下来的名字自己改
  23.             FileOutputStream fos = new FileOutputStream("f.m4a");
  25.             byte[] bytes = new byte[1024];
  26.             int len ;
  27.             while ((len = inputStream.read(bytes)) != -1){
  28.                 fos.write(bytes,0,len);//写出这个数据
  29.             }
  31.             fos.close();
  32.             inputStream.close();
  33.             urlConnection.disconnect();//断开连接
  34.         } catch (Exception e) {
  35.             e.printStackTrace();
  36.         }
  38.     }
  39. }