1 InetAddress

  • 一些常用的方法
  1.         //1. 获取本机的InetAddress 对象
  2.         InetAddress localHost = InetAddress.getLocalHost();
  3.         System.out.println(localHost);
  5.         //2. 根据指定主机名 获取 InetAddress对象
  6.         InetAddress host1 = InetAddress.getByName("PCOS-2020YWLYDD");
  7.         System.out.println("host1=" + host1);
  9.         //3. 根据域名返回 InetAddress对象, 比如 www.baidu.com 对应
  10.         InetAddress host2 = InetAddress.getByName("www.baidu.com");
  11.         System.out.println("host2=" + host2);
  13.         //4. 通过 InetAddress 对象，获取对应的地址
  14.         String hostAddress = host2.getHostAddress();
  15.         System.out.println("host2 对应的ip = " + hostAddress);
  17.         //5. 通过 InetAddress 对象，获取对应的主机名/或者的域名
  18.         String hostName = host2.getHostName();
  19.         System.out.println("host2对应的主机名/域名=" + hostName); // www.baidu.com

2 Socket

2.1 TCP

  • java中TCP的工作流程
    TCP是连接的协议，需要先建立连接再发送数据

Tcp.png

2.1.1 利用TCP传输数据

  • 服务器端
  1. import java.io.*;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  5. public class SocketTCPServer {
  6.     public static void main(String[] args) throws IOException {
  7.         //思路
  8.         //1. 在本机 的9999端口监听, 等待连接
  9.         //   细节: 要求在本机没有其它服务在监听9999
  10.         //   细节：这个 ServerSocket 可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发]
  11.         ServerSocket serverSocket = new ServerSocket(9999);
  12.         System.out.println("服务端，在9999端口监听，等待连接..");
  13.         //2. 当没有客户端连接9999端口时，程序会 阻塞, 等待连接
  14.         //   如果有客户端连接，则会返回Socket对象，程序继续
  16.         Socket socket = serverSocket.accept();
  18.         System.out.println("服务端 socket =" + socket.getLocalSocketAddress());
  19.         //
  20.         //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
  21.         InputStream inputStream = socket.getInputStream();
  22.         //4. IO读取, 使用字符流
  23.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
  24.         String s = bufferedReader.readLine();
  25.         System.out.println(s);//输出
  27.         //5. 获取socket相关联的输出流
  28.         OutputStream outputStream = socket.getOutputStream();
  29.         //    使用字符输出流的方式回复信息
  30.         BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
  31.         bufferedWriter.write("hello client 字符流");
  32.         bufferedWriter.newLine();// 插入一个换行符，表示回复内容的结束
  33.         bufferedWriter.flush();//注意需要手动的flush
  36.         //6.关闭流和socket
  37.         bufferedWriter.close();
  38.         bufferedReader.close();
  39.         socket.close();
  40.         serverSocket.close();//关闭
  42.     }
  43. }
  • 客户端
  1. import java.io.*;
  2. import java.net.InetAddress;
  3. import java.net.Socket;
  5. public class SocketTCPClient {
  6.     public static void main(String[] args) throws IOException {
  7.         //思路
  8.         //1. 连接服务端 (ip , 端口）
  9.         //解读: 连接本机的 9999端口, 如果连接成功，返回Socket对象
  10.         Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
  11.         System.out.println("客户端 socket=" + socket.getLocalSocketAddress());
  12.         //2. 连接上后，生成Socket, 通过socket.getOutputStream()
  13.         //   得到 和 socket对象关联的输出流对象
  14.         OutputStream outputStream = socket.getOutputStream();
  15.         //3. 通过输出流，写入数据到 数据通道, 使用字符流
  16.         BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
  17.         bufferedWriter.write("hello, server 字符流");
  18.         bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束, 注意，要求对方使用readLine()!!!!
  19.         bufferedWriter.flush();// 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
  22.         //4. 获取和socket关联的输入流. 读取数据(字符)，并显示
  23.         InputStream inputStream = socket.getInputStream();
  24.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
  25.         String s = bufferedReader.readLine();
  26.         System.out.println(s);
  28.         //5. 关闭流对象和socket, 必须关闭
  29.         bufferedReader.close();//关闭外层流
  30.         bufferedWriter.close();
  31.         socket.close();
  32.         System.out.println("客户端退出.....");
  33.     }
  34. }

2.1.1 利用TCP传输文件

  • 服务器端
  1. import java.io.*;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  5. public class TCPFileUploadServer {
  6.     public static void main(String[] args) throws Exception {
  8.         //1. 服务端在本机监听8888端口
  9.         ServerSocket serverSocket = new ServerSocket(8888);
  10.         System.out.println("服务端在8888端口监听....");
  11.         //2. 等待连接
  12.         Socket socket = serverSocket.accept();
  15.         //3. 读取客户端发送的数据
  16.         //   通过Socket得到输入流
  17.         BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
  18.         byte[] bytes = StreamUtils.streamToByteArray(bis);
  19.         //4. 将得到 bytes 数组，写入到指定的路径，就得到一个文件了
  20.         String destFilePath = "f\\b.png";
  21.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
  22.         bos.write(bytes);
  23.         bos.close();
  25.         // 向客户端回复 "收到图片"
  26.         // 通过socket 获取到输出流(字符)
  27.         BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  28.         writer.write("收到图片");
  29.         writer.flush();//把内容刷新到数据通道
  30.         socket.shutdownOutput();//设置写入结束标记
  32.         //关闭其他资源
  33.         writer.close();
  34.         bis.close();
  35.         socket.close();
  36.         serverSocket.close();
  37.     }
  38. }
  • 客户端
  1. import java.io.*;
  2. import java.net.InetAddress;
  3. import java.net.Socket;
  5. public class TCPFileUploadClient {
  6.     public static void main(String[] args) throws Exception {
  8.         //客户端连接服务端 8888，得到Socket对象
  9.         Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
  10.         //创建读取磁盘文件的输入流
  12.         String filePath = "f:\\a.png";
  13.         BufferedInputStream bis  = new BufferedInputStream(new FileInputStream(filePath));
  15.         //bytes 就是filePath对应的字节数组
  16.         byte[] bytes = StreamUtils.streamToByteArray(bis);
  18.         //通过socket获取到输出流, 将bytes数据发送给服务端
  19.         BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
  20.         bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
  21.         bis.close();
  22.         socket.shutdownOutput();//设置写入数据的结束标记
  24.         //=====接收从服务端回复的消息=====
  26.         InputStream inputStream = socket.getInputStream();
  27.         //使用StreamUtils 的方法，直接将 inputStream 读取到的内容 转成字符串
  28.         String s = StreamUtils.streamToString(inputStream);
  29.         System.out.println(s);
  32.         //关闭相关的流
  33.         inputStream.close();
  34.         bos.close();
  35.         socket.close();
  37.     }
  40. }

2.2 UDP

  • UDP是无连接协议
  • 发送数据时先创建套接字绑定本机一个端口，向目的IP和端口发送数据，不需要去管是否有主机在这个端口接收数据

UDP.png

  • A端
  1. import java.io.IOException;
  2. import java.net.DatagramPacket;
  3. import java.net.DatagramSocket;
  4. import java.net.InetAddress;
  5. import java.net.SocketException;
  7. public class UDPReceiverA {
  8.     public static void main(String[] args) throws IOException {
  9.         //1. 创建一个 DatagramSocket 对象，准备在9999接收数据
  10.         DatagramSocket socket = new DatagramSocket(9999);
  11.         //2. 构建一个 DatagramPacket 对象，准备接收数据
  12.         byte[] buf = new byte[1024];
  13.         DatagramPacket packet = new DatagramPacket(buf, buf.length);
  14.         //3. 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
  15.         //   填充到 packet对象
  16.         //   如果没有数据包发送到 本机的9999端口, 就会阻塞等待.
  17.         System.out.println("接收端A 等待接收数据..");
  18.         socket.receive(packet);
  20.         //4. 可以把packet 进行拆包，取出数据，并显示.
  21.         int length = packet.getLength();//实际接收到的数据字节长度
  22.         byte[] data = packet.getData();//接收到数据
  23.         String s = new String(data, 0, length);
  24.         System.out.println(s);
  27.         //===回复信息给B端
  28.         //将需要发送的数据，封装到 DatagramPacket对象
  29.         data = "库里FMVP".getBytes();
  30.         //说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
  31.         packet =
  32.                 new DatagramPacket(data, data.length, InetAddress.getByName("127.0.0.1"), 9998);
  34.         socket.send(packet);//发送
  36.         //5. 关闭资源
  37.         socket.close();
  38.         System.out.println("A端退出...");
  40.     }
  41. }
  • B端
  1. import java.io.IOException;
  2. import java.net.*;
  4. public class UDPSenderB {
  5.     public static void main(String[] args) throws IOException {
  7.         //1.创建 DatagramSocket 对象，准备在9998端口 接收数据
  8.         DatagramSocket socket = new DatagramSocket(9998);
  10.         //2. 将需要发送的数据，封装到 DatagramPacket对象
  11.         byte[] data = "hello 勇士总冠军~".getBytes(); //
  13.         //说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
  14.         DatagramPacket packet =
  15.                 new DatagramPacket(data, data.length, InetAddress.getByName("127.0.0.1"), 9999);
  17.         socket.send(packet);
  19.         //3.=== 接收从A端回复的信息
  20.         //(1)   构建一个 DatagramPacket 对象，准备接收数据
  21.         //   在前面讲解UDP 协议时，老师说过一个数据包最大 64k
  22.         byte[] buf = new byte[1024];
  23.         packet = new DatagramPacket(buf, buf.length);
  24.         //(2)    调用 接收方法, 将通过网络传输的 DatagramPacket 对象
  25.         //   填充到 packet对象
  26.         //老师提示: 当有数据包发送到 本机的9998端口时，就会接收到数据
  27.         //   如果没有数据包发送到 本机的9998端口, 就会阻塞等待.
  28.         socket.receive(packet);
  30.         //(3)  可以把packet 进行拆包，取出数据，并显示.
  31.         int length = packet.getLength();//实际接收到的数据字节长度
  32.         data = packet.getData();//接收到数据
  33.         String s = new String(data, 0, length);
  34.         System.out.println(s);
  36.         //关闭资源
  37.         socket.close();
  38.         System.out.println("B端退出");
  39.     }
  40. }

常见的网络程序端口号
tomcat:8080
mysql:3306
oracle:1521
sqlserver:1433