网络通信要素

IP与端口号

IP

1.IP：唯一的标识Internet上的计算机（通信实体）
2.在java中使用InetAddress类代表IP
3.IP分类：IPV4 和 IPV6；万维网和局域网
4.域名：www.baidu.com www.mi.com www.sina.com www.jd.com www.vip.com
5.本地回路地址：127.0.0.1 对应着：localhost
6.实例化InetAddress：getByName(String host) / getLocalHost()
两个常用方法：getHostName() / getHostAddress()

  1. public static void main(String[] args) {
  2.         try {
  3.             InetAddress inet1 = InetAddress.getByName("192.168.10.14");
  5.             System.out.println(inet1);///192.168.10.14
  7.             InetAddress inet2 = InetAddress.getByName("www.atguigu.com");
  8.             System.out.println(inet2);//www.atguigu.com/221.15.64.230
  10.             InetAddress inet3 = InetAddress.getByName("127.0.0.1");
  11.             System.out.println(inet3);///127.0.0.1
  13.             InetAddress inet4 = InetAddress.getLocalHost();
  14.             System.out.println(inet4);//LAPTOP-IFCERJD6/10.213.26.75
  15.             //getHostName()
  16.             System.out.println(inet2.getHostName());//www.atguigu.com
  17.             //getHostAddress
  18.             System.out.println(inet2.getHostAddress());//221.15.64.230
  20.         } catch (UnknownHostException e) {
  21.             e.printStackTrace();
  22.         }

端口号

正在计算机上运行的进程
1.要求：不同的进程有不同的端口号
2.范围：被规定为一个 16 位的整数 0~65535
3.端口号与IP地址的组合得出一个网络套接字：Socket
屏幕截图 2022-04-16 141551.jpg

网络通信协议

屏幕截图 2022-04-15 213302.jpg

屏幕截图 2022-04-16 170944.jpg

TCP实例

TCP网络传输文档

  1. //客户端
  2.     @Test
  3.     public void client() {
  4.         Socket socket = null;
  5.         OutputStream os = null;
  6.         try {
  7.             //1.创建Socket对象，指明服务器端的ip和端口号
  8.             InetAddress inet = InetAddress.getByName("127.0.0.1");
  9.             socket = new Socket(inet,8899);
  11.             //2.获取一个输出流，用于输出数据
  12.             os = socket.getOutputStream();
  13.             //3.写出数据的操作
  14.             os.write("你好，我是客户端".getBytes(StandardCharsets.UTF_8));
  15.         } catch (IOException e) {
  16.             e.printStackTrace();
  17.         } finally {
  18.             //4.资源的关闭
  19.             if (os != null){
  20.                 try {
  21.                     os.close();
  22.                 } catch (IOException e) {
  23.                     e.printStackTrace();
  24.                 }
  25.             }
  26.             if (socket != null){
  27.                 try {
  28.                     socket.close();
  29.                 } catch (IOException e) {
  30.                     e.printStackTrace();
  31.                 }
  32.             }
  33.         }
  34.     }
  36.     //服务端
  37.     @Test
  38.     public void server() {
  40.         ServerSocket ss = null;
  41.         Socket socket = null;
  42.         InputStream is = null;
  43.         ByteArrayOutputStream baos = null;
  44.         try {
  45.             //1.创建服务器端的ServerSocket，指明自己的端口号
  46.             ss = new ServerSocket(8899);
  47.             //2.调用accept()表示接收来自客户端的socket
  48.             socket = ss.accept();
  49.             //3.获取输入流
  50.             is = socket.getInputStream();
  52.             //不建议，可能乱码
  53.         /*byte[] buffer = new byte[20];
  54.         int len;
  55.         while((len = is.read(buffer)) != -1){
  56.             String str = new String(buffer,0,len);
  57.             System.out.println(str);
  58.         }*/
  59.             //4.读取输入流的数据
  60.             baos = new ByteArrayOutputStream();
  61.             byte[] buffer = new byte[5];
  62.             int len;
  63.             while ((len = is.read(buffer)) != -1){
  64.                 baos.write(buffer,0,len);
  66.             }
  67.         } catch (IOException e) {
  68.             e.printStackTrace();
  69.         } finally {
  70.             //5.资源关闭
  71.             if (baos != null){
  72.                 try {
  73.                     baos.close();
  74.                 } catch (IOException e) {
  75.                     e.printStackTrace();
  76.                 }
  77.             }
  78.             if (is != null){
  79.                 try {
  80.                     is.close();
  81.                 } catch (IOException e) {
  82.                     e.printStackTrace();
  83.                 }
  84.             }
  85.             if (socket != null){
  86.                 try {
  87.                     socket.close();
  88.                 } catch (IOException e) {
  89.                     e.printStackTrace();
  90.                 }
  91.             }
  92.             if (ss != null){
  93.                 try {
  94.                     ss.close();
  95.                 } catch (IOException e) {
  96.                     e.printStackTrace();
  97.                 }
  98.             }
  99.         }
  101.         System.out.println(baos.toString());
  103.     }

TCP网络传输图片

  1. @Test
  2.     public void client(){
  4.         Socket socket = null;
  5.         OutputStream os = null;
  6.         FileInputStream fis = null;
  7.         try {
  8.             socket = new Socket(InetAddress.getByName("127.0.0.1"),900);
  10.             os = socket.getOutputStream();
  12.             fis = new FileInputStream(new File("记.jpg"));
  14.             byte[] buffer = new byte[1024];
  15.             int len;
  16.             while((len = fis.read(buffer)) != -1){
  17.                 os.write(buffer,0,len);
  18.             }
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         } finally {
  22.             if (fis != null){
  23.                 try {
  24.                     fis.close();
  25.                 } catch (IOException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.             }
  29.             if (os != null){
  30.                 try {
  31.                     os.close();
  32.                 } catch (IOException e) {
  33.                     e.printStackTrace();
  34.                 }
  35.             }
  36.             if (socket != null){
  37.                 try {
  38.                     socket.close();
  39.                 } catch (IOException e) {
  40.                     e.printStackTrace();
  41.                 }
  42.             }
  43.         }
  44.     }
  46.     @Test
  47.     public void server() {
  49.         ServerSocket ss = null;
  50.         Socket socket = null;
  51.         InputStream is = null;
  52.         FileOutputStream fos = null;
  53.         try {
  54.             ss = new ServerSocket(900);
  56.             socket = ss.accept();
  58.             is = socket.getInputStream();
  60.             fos = new FileOutputStream(new File("记3.jpg"));
  62.             byte[] buffer = new byte[1024];
  63.             int len;
  64.             while((len = is.read(buffer)) != -1){
  65.                 fos.write(buffer,0,len);
  66.             }
  67.         } catch (IOException e) {
  68.             e.printStackTrace();
  69.         } finally {
  70.             if (fos != null){
  71.                 try {
  72.                     fos.close();
  73.                 } catch (IOException e) {
  74.                     e.printStackTrace();
  75.                 }
  76.             }
  77.             if (is != null){
  78.                 try {
  79.                     is.close();
  80.                 } catch (IOException e) {
  81.                     e.printStackTrace();
  82.                 }
  83.             }
  84.             if (socket != null){
  85.                 try {
  86.                     socket.close();
  87.                 } catch (IOException e) {
  88.                     e.printStackTrace();
  89.                 }
  90.             }
  91.             if (ss != null){
  92.                 try {
  93.                     ss.close();
  94.                 } catch (IOException e) {
  95.                     e.printStackTrace();
  96.                 }
  97.             }
  98.         }
  99.     }

服务器对客户端的反馈

  1. @Test
  2.     public void client(){
  4.         Socket socket = null;
  5.         OutputStream os = null;
  6.         FileInputStream fis = null;
  7.         try {
  8.             socket = new Socket(InetAddress.getByName("127.0.0.1"),900);
  10.             os = socket.getOutputStream();
  12.             fis = new FileInputStream(new File("记.jpg"));
  14.             byte[] buffer = new byte[1024];
  15.             int len;
  16.             while((len = fis.read(buffer)) != -1){
  17.                 os.write(buffer,0,len);
  18.             }
  20.             //关闭数据的输出
  21.             socket.shutdownOutput();
  23.             //接收来自于客户端的数据，并显示在控制台
  24.             InputStream is = socket.getInputStream();
  25.             ByteArrayOutputStream baos = new ByteArrayOutputStream();
  26.             byte[] buffer1 = new byte[20];
  27.             int len1;
  28.             while ((len1 = is.read(buffer1)) != -1){
  29.                 baos.write(buffer,0,len1);
  30.             }
  32.             System.out.println(baos.toString());
  34.         } catch (IOException e) {
  35.             e.printStackTrace();
  36.         } finally {
  37.             if (fis != null){
  38.                 try {
  39.                     fis.close();
  40.                 } catch (IOException e) {
  41.                     e.printStackTrace();
  42.                 }
  43.             }
  44.             if (os != null){
  45.                 try {
  46.                     os.close();
  47.                 } catch (IOException e) {
  48.                     e.printStackTrace();
  49.                 }
  50.             }
  51.             if (socket != null){
  52.                 try {
  53.                     socket.close();
  54.                 } catch (IOException e) {
  55.                     e.printStackTrace();
  56.                 }
  57.             }
  58.             if (os != null){
  59.                 try {
  60.                     os.close();
  61.                 } catch (IOException e) {
  62.                     e.printStackTrace();
  63.                 }
  64.             }
  65.         }
  66.     }
  68.     @Test
  69.     public void server() {
  71.         ServerSocket ss = null;
  72.         Socket socket = null;
  73.         InputStream is = null;
  74.         FileOutputStream fos = null;
  75.         try {
  76.             ss = new ServerSocket(900);
  78.             socket = ss.accept();
  80.             is = socket.getInputStream();
  82.             fos = new FileOutputStream(new File("记3.jpg"));
  84.             byte[] buffer = new byte[1024];
  85.             int len;
  86.             while((len = is.read(buffer)) != -1){
  87.                 fos.write(buffer,0,len);
  88.             }
  90.             //服务器给与客户端反馈
  91.             OutputStream os = socket.getOutputStream();
  92.             os.write("你好，照片已经收到".getBytes());
  95.         } catch (IOException e) {
  96.             e.printStackTrace();
  97.         } finally {
  98.             if (fos != null){
  99.                 try {
  100.                     fos.close();
  101.                 } catch (IOException e) {
  102.                     e.printStackTrace();
  103.                 }
  104.             }
  105.             if (is != null){
  106.                 try {
  107.                     is.close();
  108.                 } catch (IOException e) {
  109.                     e.printStackTrace();
  110.                 }
  111.             }
  112.             if (socket != null){
  113.                 try {
  114.                     socket.close();
  115.                 } catch (IOException e) {
  116.                     e.printStackTrace();
  117.                 }
  118.             }
  119.             if (ss != null){
  120.                 try {
  121.                     ss.close();
  122.                 } catch (IOException e) {
  123.                     e.printStackTrace();
  124.                 }
  125.             }
  126.         }
  127.     }

UDP实例

  1. @Test
  2.     public void sender() {
  4.         DatagramSocket socket = null;
  5.         try {
  6.             socket = new DatagramSocket();
  8.             String str = "我是UDP方式发送的导弹";
  9.             byte[] data = str.getBytes(StandardCharsets.UTF_8);
  10.             InetAddress inet = InetAddress.getLocalHost();
  11.             DatagramPacket paket = new DatagramPacket(data,0,data.length,inet,9090);
  13.             socket.send(paket);
  14.         } catch (IOException e) {
  15.             e.printStackTrace();
  16.         } finally {
  17.             if (socket != null){
  18.                 socket.close();
  19.             }
  20.         }
  21.     }
  23.     @Test
  24.     public void receiver() {
  26.         DatagramSocket socket = null;
  27.         try {
  28.             socket = new DatagramSocket(9090);
  30.             byte[] buffer = new byte[100];
  32.             DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
  34.             socket.receive(packet);
  36.             System.out.println(new String(packet.getData(),0,packet.getLength()));
  37.         } catch (IOException e) {
  38.             e.printStackTrace();
  39.         } finally {
  40.             if (socket != null){
  41.                 socket.close();
  42.             }
  43.         }
  44.     }

URL网络编程

1.URL：统一资源定位符，对应着互联网的某一资源地址（俗称：种子）
2.格式：
http://localhost:8080/examples/hello.txt?username=Jone
协议 主机名 端口号 资源地址 参数列表
屏幕截图 2022-04-17 154626.jpg

URL的常用方法

屏幕截图 2022-04-17 155507.jpg

  1. public static void main(String[] args) {
  3.         try {
  4.             URL url = new URL("http://localhost:8080/example/hello.txt");
  5.             System.out.println(url.getProtocol());
  6.             System.out.println(url.getHost());
  7.             System.out.println(url.getPort());
  8.             System.out.println(url.getPath());
  9.             System.out.println(url.getFile());
  10.             System.out.println(url.getQuery());
  13.         } catch (MalformedURLException e) {
  14.             e.printStackTrace();
  15.         }
  16.     }

URL资源下载

  1. public static void main(String[] args){
  3.         HttpURLConnection urlConnection = null;
  4.         InputStream is = null;
  5.         FileOutputStream fos = null;
  6.         try {
  7.             URL url = new URL("http://localhost:8080/example/hello.txt");
  9.             urlConnection = (HttpURLConnection) url.openConnection();
  11.             urlConnection.connect();
  13.             is = urlConnection.getInputStream();
  14.             fos = new FileOutputStream("hello6.txt");
  16.             byte[] buffer = new byte[1024];
  17.             int len;
  18.             while((len = is.read(buffer)) != -1){
  19.                 fos.write(buffer,0,len);
  20.             }
  21.         } catch (IOException e) {
  22.             e.printStackTrace();
  23.         } finally {
  25.             if (is != null){
  26.                 try {
  27.                     is.close();
  28.                 } catch (IOException e) {
  29.                     e.printStackTrace();
  30.                 }
  31.             }
  32.             if (fos != null){
  33.                 try {
  34.                     fos.close();
  35.                 } catch (IOException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.             if (urlConnection != null){
  40.                 urlConnection.disconnect();
  41.             }
  42.         }
  43.     }