【Java高级编程】网络编程

ゝ一纸荒年。 2023-10-12 23:27 120阅读 0赞

在这里插入图片描述
【Java核心技术】Java基本语法
【Java核心技术】Java面向对象编程
【Java核心技术】Java异常处理
【Java高级编程】Java多线程
【Java高级编程】Java常用类
【Java高级编程】Java枚举类&注解
【Java高级编程】Java集合
【Java高级编程】Java泛型
【Java高级编程】JavaIO流
【Java高级编程】Java网络编程
【Java高级编程】Java反射机制
【Java高级编程】Java8的新特性

网络编程

      • 1、InetAddress类的使用
        • 1.1、实现网络通信需要解决的两个问题
        • 1.2、网络通信的两个要素
        • 1.3、通信要素一：IP和端口号
        • 1.4、通信要素二：网络通信协议
        • 1.5、TCP和UDP的区别
        • 1.6、TCP三次握手和四次挥手
      • 2、TCP网络编程
      • 3、UDP网络编程
      • 4、URL编程
        • 4.1、URL(Uniform Resource Locator)的理解
        • 4.2、URL的5个基本结构
        • 4.3、如何实例化
        • 4.4、常用方法
        • 4.5、可以读取、下载对应的url资源

1、InetAddress类的使用

1.1、实现网络通信需要解决的两个问题
  • 如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
  • 找到主机后如何可靠高效地进行数据传输
1.2、网络通信的两个要素
  • 对应问题一：IP和端口号
  • 对应问题二：提供网络通信协议：TCP/IP参考模型（应用层、传输层、网络层、物理+数据链路层）
1.3、通信要素一：IP和端口号

  • IP的理解

    • IP：唯一的标识Internet上的计算机（通信实体）
    • 在Java中使用InetAddress类代表IP
    • IP分类：IPv4和IPv6；万维网和局域网

    • 域名：www.baidu.com、www.mi.com

      • 域名解析：域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务器（DNS）负责将域名转化成IP地址，这样才能和主机建立连接。
    • 本地回路地址：127.0.0.1 对应着：localhost

  • InetAddress类：此类的一个对象就代表着一个具体的IP地址

    • 实例化：

      • getByName(String host)
      • getLocalHost()

    • 常用方法：

      • getHostName()
      • getHostAddress()

  • 端口号：正在计算机上运行的进程

    • 要求：不同的进程不同的端口号
    • 范围：被规定为一个16位的整数 0~65535
  • 端口号与IP地址的组合得出一个网络套接字：Socket
1.4、通信要素二：网络通信协议






























OSI参考模型 TCP/IP参考模型 TCP/IP参考模型各层对应协议
应用层、表示层、会话层 应用层 HTTP、FTP、Telnet、DNS…
传输层 传输层 TCP、UDP…
网络层 网络层 IP、ICMP、ARP…
数据链路层、物理层 物理+数据链路层 Link
1.5、TCP和UDP的区别

  • TCP协议：

    • 使用TCP协议前，须先建立TCP连接，形成传输数据通道
    • 传输前，采用“三次握手”方式，点对点通信，是可靠的
    • TCP协议进行通信的两个应用进程：客户端、服务端
    • 在连接中可进行大数据量的传输
    • 传输完毕，需要释放已建立的连接，效率低

  • UDP协议：

    • 将数据、源、目的封装成数据包，不需要建立连接
    • 每个数据报的大小限制在64K内
    • 发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
    • 可以广播发送
    • 发送数据结束时无需释放资源，开销小，速度快
1.6、TCP三次握手和四次挥手
  • 三次握手

客户端服务端seq=x,SYN=1客户端发送syn报文，并置发送序号为xACK=x+1,seq=y,SYN=1服务端发送syn+ACK报文并置发送序号为y，再确定序号为x+1ACK=y+1,seq=z客户端发送ACK报文，并置发送序号为z再确定序号为Y+1客户端服务端

  • 四次挥手

主动方被动方Fin=1,Ack=z,seq=x主动方发送Fin+Ack报文，并置发送序号为XACK=x+1,seq=z被动方发送ACK报文，并置发送序号为Z，再确定序号为X+1Fin=1,ack=x,seq=y被动方发送Fin+Ack报文，并置发送序号为Y，再确定序号为XACK=Y,seq=x主动方发送ack报文，并置发送序号为X，再确认序号为Y主动方被动方

2、TCP网络编程

  1. /**
  2.  * 客户端发送信息给服务端，服务端将数据显示在控制台上
  3.  */
  4. public class TCPTest1 {
  5.     // 客户端
  6.     @Test
  7.     public void client() {
  8.         Socket socket = null;
  9.         OutputStream os = null;
  10.         try {
  11.             // 1、创建Socket对象，指明服务器端的IP和端口号
  12.             InetAddress inet = InetAddress.getByName("127.0.0.1");
  13.             socket = new Socket(inet, 8899);
  14.             // 2、获取一个输出流，用于输出数据
  15.             os = socket.getOutputStream();
  16.             // 3、写出数据的操作
  17.             os.write("你好，我是客户端mm".getBytes());
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         } finally {
  21.             // 4、资源的关闭
  22.             if (os != null) {
  23.                 try {
  24.                     os.close();
  25.                 } catch (IOException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.             }
  30.             if (socket != null) {
  31.                 try {
  32.                     socket.close();
  33.                 } catch (IOException e) {
  34.                     e.printStackTrace();
  35.                 }
  36.             }
  37.         }
  38.     }
  39.     //服务端
  40.     @Test
  41.     public void server () {
  42.         ServerSocket ss = null;
  43.         Socket socket = null;
  44.         InputStream is = null;
  45.         ByteArrayOutputStream baos = null;
  46.         try {
  47.             // 1、创建服务器端的ServerSocket，指明自己的端口号
  48.             ss = new ServerSocket(8899);
  49.             // 2、调用accept()表示接收来自客户端的socket
  50.             socket = ss.accept();
  51.             // 3、获取输入流
  52.             is = socket.getInputStream();
  53.             // 4、读取输入流中的数据
  54.             baos = new ByteArrayOutputStream();
  55.             byte[] buffer = new byte[5];
  56.             int len;
  57.             while ((len = is.read(buffer)) != -1) {
  58.                 baos.write(buffer, 0, len);
  59.             }
  61.             System.out.println(socket.getInetAddress().getHostAddress() + "：" + baos.toString());
  62.         } catch (IOException e) {
  63.             e.printStackTrace();
  64.         } finally {
  65.             // 5、关闭资源
  66.             if (baos != null) {
  67.                 try {
  68.                     baos.close();
  69.                 } catch (IOException e) {
  70.                     e.printStackTrace();
  71.                 }
  72.             }
  73.             if (is != null) {
  74.                 try {
  75.                     is.close();
  76.                 } catch (IOException e) {
  77.                     e.printStackTrace();
  78.                 }
  79.             }
  80.             if (socket != null) {
  81.                 try {
  82.                     socket.close();
  83.                 } catch (IOException e) {
  84.                     e.printStackTrace();
  85.                 }
  86.             }
  87.             if (ss != null) {
  88.                 try {
  89.                     ss.close();
  90.                 } catch (IOException e) {
  91.                     e.printStackTrace();
  92.                 }
  93.             }
  94.         }
  95.     }
  96. }
  98. /**
  99.  * 客户端发送文件给服务端，服务端将文件保存在本地
  100.  */
  101. public class TCPTest2 {
  102.     // 客户端
  103.     @Test
  104.     public void client () {
  105.         Socket socket = null;
  106.         OutputStream os = null;
  107.         FileInputStream fis = null;
  108.         try {
  109.             socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
  110.             os = socket.getOutputStream();
  111.             fis = new FileInputStream(new File("beauty.jpg"));
  112.             byte[] buffer = new byte[1024];
  113.             int len;
  114.             while ((len = fis.read(buffer)) != -1) {
  115.                 os.write(buffer, 0, len);
  116.             }
  117.         } catch (IOException e) {
  118.             e.printStackTrace();
  119.         } finally {
  120.             if (fis != null) {
  121.                 try {
  122.                     fis.close();
  123.                 } catch (IOException e) {
  124.                     e.printStackTrace();
  125.                 }
  126.             }
  127.             if (os != null) {
  128.                 try {
  129.                     os.close();
  130.                 } catch (IOException e) {
  131.                     e.printStackTrace();
  132.                 }
  133.             }
  134.             if (socket != null) {
  135.                 try {
  136.                     socket.close();
  137.                 } catch (IOException e) {
  138.                     e.printStackTrace();
  139.                 }
  140.             }
  141.         }
  142.     }
  144.     //服务端
  145.     @Test
  146.     public void server () {
  147.         ServerSocket ss = null;
  148.         Socket socket = null;
  149.         InputStream is = null;
  150.         FileOutputStream fos = null;
  151.         try {
  152.             ss = new ServerSocket(9090);
  153.             socket = ss.accept();
  154.             is = socket.getInputStream();
  155.             fos = new FileOutputStream(new File("beauty1.jpg"));
  157.             byte[] buffer = new byte[1024];
  158.             int len;
  159.             while ((len = is.read(buffer)) != -1) {
  160.                 fos.write(buffer, 0, len);
  161.             }
  162.         } catch (IOException e) {
  163.             e.printStackTrace();
  164.         } finally {
  165.             if (fos != null) {
  166.                 try {
  167.                     fos.close();
  168.                 } catch (IOException e) {
  169.                     e.printStackTrace();
  170.                 }
  171.             }
  172.             if (is != null) {
  173.                 try {
  174.                     is.close();
  175.                 } catch (IOException e) {
  176.                     e.printStackTrace();
  177.                 }
  178.             }
  179.             if (socket != null) {
  180.                 try {
  181.                     socket.close();
  182.                 } catch (IOException e) {
  183.                     e.printStackTrace();
  184.                 }
  185.             }
  186.             if (ss != null) {
  187.                 try {
  188.                     ss.close();
  189.                 } catch (IOException e) {
  190.                     e.printStackTrace();
  191.                 }
  192.             }
  193.         }
  194.     }
  195. }
  197. /**
  198.  * 从客户端发送文件给服务器，服务端保存到本地。并返回“发送成功”给客户端
  199.  * 并关闭相关的连接
  200.  */
  201. public class TCPTest3 {
  202.     // 客户端
  203.     @Test
  204.     public void client ()
  205.     {
  206.         Socket socket = null;
  207.         OutputStream os = null;
  208.         FileInputStream fis = null;
  209.         InputStream is = null;
  210.         ByteArrayOutputStream baos = null;
  211.         try {
  212.             socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
  213.             os = socket.getOutputStream();
  214.             fis = new FileInputStream(new File("beauty.jpg"));
  216.             byte[] buffer = new byte[1024];
  217.             int len;
  218.             while ((len = fis.read(buffer)) != -1) {
  219.                 os.write(buffer, 0, len);
  220.             }
  221.             // 关闭数据的输出
  222.             socket.shutdownOutput();
  224.             // 接收来自于服务器端的数据，并显示到控制台上
  225.             is = socket.getInputStream();
  226.             baos = new ByteArrayOutputStream();
  227.             byte[] buffer1 = new byte[20];
  228.             int len1;
  229.             while ((len1 = is.read(buffer1)) != -1) {
  230.                 baos.write(buffer1, 0, len1);
  231.             }
  233.             System.out.println(baos.toString());
  234.         } catch (IOException e) {
  235.             e.printStackTrace();
  236.         } finally {
  237.             if (baos != null) {
  238.                 try {
  239.                     baos.close();
  240.                 } catch (IOException e) {
  241.                     e.printStackTrace();
  242.                 }
  243.             }
  244.             if (is != null) {
  245.                 try {
  246.                     is.close();
  247.                 } catch (IOException e) {
  248.                     e.printStackTrace();
  249.                 }
  250.             }
  251.             if (fis != null) {
  252.                 try {
  253.                     fis.close();
  254.                 } catch (IOException e) {
  255.                     e.printStackTrace();
  256.                 }
  257.             }
  258.             if (os != null) {
  259.                 try {
  260.                     os.close();
  261.                 } catch (IOException e) {
  262.                     e.printStackTrace();
  263.                 }
  264.             }
  265.             if (socket != null) {
  266.                 try {
  267.                     socket.close();
  268.                 } catch (IOException e) {
  269.                     e.printStackTrace();
  270.                 }
  271.             }
  273.         }
  274.     }
  276.     // 服务端
  277.     @Test
  278.     public void server () {
  279.         ServerSocket ss = null;
  280.         Socket socket = null;
  281.         InputStream is = null;
  282.         FileOutputStream fos = null;
  283.         OutputStream os = null;
  284.         try {
  285.             ss = new ServerSocket(9090);
  286.             socket = ss.accept();
  287.             is = socket.getInputStream();
  288.             fos = new FileOutputStream(new File("beauty2.jpg"));
  290.             byte[] buffer = new byte[1024];
  291.             int len;
  292.             while ((len = is.read(buffer)) != -1) {
  293.                 fos.write(buffer, 0, len);
  294.             }
  296.             System.out.println("图片传输完成");
  298.             // 服务器端给予客户单反馈
  299.             os = socket.getOutputStream();
  300.             os.write("你好，美女，照片我已收到，非常漂亮！".getBytes());
  301.         } catch (IOException e) {
  302.             e.printStackTrace();
  303.         } finally {
  304.             if (os != null) {
  305.                 try {
  306.                     os.close();
  307.                 } catch (IOException e) {
  308.                     e.printStackTrace();
  309.                 }
  310.             }
  311.             if (fos != null) {
  312.                 try {
  313.                     fos.close();
  314.                 } catch (IOException e) {
  315.                     e.printStackTrace();
  316.                 }
  317.             }
  318.             if (is != null) {
  319.                 try {
  320.                     is.close();
  321.                 } catch (IOException e) {
  322.                     e.printStackTrace();
  323.                 }
  324.             }
  325.             if (socket != null) {
  326.                 try {
  327.                     socket.close();
  328.                 } catch (IOException e) {
  329.                     e.printStackTrace();
  330.                 }
  331.             }
  332.             if (ss != null) {
  333.                 try {
  334.                     ss.close();
  335.                 } catch (IOException e) {
  336.                     e.printStackTrace();
  337.                 }
  338.             }
  339.         }
  340.     }
  341. }

3、UDP网络编程

  1. public class UDPTest {
  2.     // 发送端
  3.     @Test
  4.     public void sender () {
  5.         DatagramSocket socket = null;
  6.         try {
  7.             socket = new DatagramSocket();
  9.             String str = "我是UDP方式发送的导弹";
  10.             byte[] data = str.getBytes();
  11.             InetAddress inet = InetAddress.getLocalHost();
  12.             DatagramPacket packet = new DatagramPacket(data, 0, data.length, inet, 9090);
  14.             socket.send(packet);
  15.         } catch (IOException e) {
  16.             e.printStackTrace();
  17.         } finally {
  18.             if (socket != null) {
  19.                 socket.close();
  20.             }
  21.         }
  22.     }
  23.     // 接收端
  24.     @Test
  25.     public void receiver () {
  26.         DatagramSocket socket = null;
  27.         try {
  28.             socket = new DatagramSocket(9090);
  30.             byte[] buffer = new byte[100];
  31.             DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
  33.             socket.receive(packet);
  35.             System.out.println(new String(packet.getData(), 0, packet.getLength()));
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         } finally {
  39.             socket.close();
  40.         }
  41.     }
  42. }

4、URL编程

4.1、URL(Uniform Resource Locator)的理解
  • 统一资源定位符，对应着互联网的某一资源地址
4.2、URL的5个基本结构
  • 协议
  • 主机名
  • 端口号
  • 资源地址
  • 参数列表
4.3、如何实例化
  • URL url = new URL("http://localhost:8080/examples/beauty.jpg?username=Tom")
4.4、常用方法
  • public String getProtocol()：获取该URL的协议名
  • public String getHost()：获取该URL的主机名
  • public String getPort()：获取该URL的端口号
  • public String getPath()：获取该URL的文件路径
  • public String getFile()：获取该URL的文件名
  • public String getQuery()：获取该URL的查询名
4.5、可以读取、下载对应的url资源
  1. public static void main(String[] args) {
  2.     HttpURLConnection urlConnection = null;
  3.     InputStream is = null;
  4.     FileOutputStream fos = null;
  5.     try {
  6.         URL url = new URL("http://localhost:8080/examples/beauty.jpg");
  7.         urlConnection = (HttpURLConnection) url.openConnection();
  8.         urlConnection.connect();
  10.         is = urlConnection.getInputStream();
  11.         fos = new FileOutputStream("day10\\beauty3.jpg");
  13.         byte[] buffer = new byte[1024];
  14.         int len;
  15.         while ((len = is.read(buffer)) != -1) {
  16.             fos.write(buffer, 0, len);
  17.         }
  19.         System.out.println("下载完成");
  20.     } catch (IOException e) {
  21.         e.printStackTrace();
  22.     } finally {
  23.         if (fos != null) {
  24.             try {
  25.                 fos.close();
  26.             } catch (IOException e) {
  27.                 e.printStackTrace();
  28.             }
  29.         }
  30.         if (is != null) {
  31.             try {
  32.                 is.close();
  33.             } catch (IOException e) {
  34.                 e.printStackTrace();
  35.             }
  36.         }
  37.         if (urlConnection != null) {
  38.             urlConnection.disconnect();
  39.         }
  40.     }
  41. }

发表评论

表情：
评论列表 （有 0 条评论，120人围观）

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

相关阅读

    相关 java7高级编程_java高级编程

    一、课程描述及课程目标 (一)课程描述 Java高级编程是一门面向计算机专业的专业任选课，其具有实践性强、应用广泛、功能强大等特点，对于学生职业发展和提高社会信息化水平，具

    电玩女神电玩女神/ 0 赞/ 281 阅读

    相关 《网络编程》高级 I/O

    本节是套接字的高级 I/O 。为套接字设置超时闹钟，使用更加方便的数据传输函数。套接字的 I/O 操作上设置超时有三种方法： 1. 调用 alarm 函数，在它指定超时到期

    我就是我我就是我/ 0 赞/ 197 阅读