• Java网络编程

    目录

    网络编程

    概述

    计算机网络：

    计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

    计算机网络主要是由一些通用的、可编程的硬件互连而成的，而这些硬件并非专门用来实现某一特定目的（例如，传送数据或视频信号）。这些可编程的硬件能够用来传送多种不同类型的数据，并能支持广泛的和日益增长的应用。

    网络编程的目的：

    传播交流信息，数据交换，通信

    网络编程的需求：

    1. 如何准确的定位网络上的一台主机
    2. 如何传输数据

    JavaWeb：网页编程 B/S

    网络编程：TCP/IP C/S

    网络通信的要素

    如何实现网络的通信

    通信双方地址：

    • ip
    • 端口号

    规则：网络通信的协议

    TCP/IP参考模型：

    小结：

    1. 网络编程中有两个主要的问题
      • 如何准确的定位到网络上的一台或者多台主机
      • 找到主机之后如何进行通信
    2. 网络编程中的要素
      • IP和端口号
      • 网络通信协议 TCP、UDP
    3. 万物皆对象

    IP地址

    ip地址：InetAddress

    • 唯一定位一台网络上计算机
    • 127.0.0.1：本机localhost
    • ip地址的分类
      • ipv4/ipv6
        • ipv4 127.0.0.1 4个字节组成 0~255 全球一共42亿个ip地址 30亿在北美 4亿在亚洲 2011年就已经用尽
        • ipv6 128位，8个无符号整数
      • 公网（互联网）---私网（局域网）
        • ABCD类地址
        • 192.168.xx.xx，专门给组织内部使用的
    • 域名：记忆Ip问题

    演示

    1. package net;
    2.  
    3. import java.net.InetAddress;
    4. import java.net.UnknownHostException;
    5.  
    6. //测试IP
    7. public class TestInetAddress {
    8.     public static void main(String[] args) {
    9.         try {
    10.             //查询本机地址方式一
    11.             InetAddress inetAddress1 = InetAddress.getByName("172.0.0.1");
    12.             System.out.println(inetAddress1);
    13.  
    14.             //查询本机地址方式二
    15.             InetAddress inetAddress2 = InetAddress.getByName("localhost");
    16.             System.out.println(inetAddress2);
    17.  
    18.             //查询本机地址方式三
    19.             InetAddress inetAddress3 = InetAddress.getLocalHost();
    20.             System.out.println(inetAddress3);
    21.  
    22.             //查询网站ip地址
    23.             InetAddress inetAddress4 = InetAddress.getByName("www.baidu.com");
    24.             System.out.println(inetAddress4);
    25.         } catch (UnknownHostException e) {
    26.             throw new RuntimeException(e);
    27.         }
    28.     }
    29. }

    端口

    端口表示计算机上的一个程序的进程

    • 不同的进程有不同的端口号！用来区分软件！
    • 被规定0~65535
    • TCP，UDP：65535*2 单个协议下，端口号不能冲突
    • 端口分类
      • 公有端口 0~1023
        • HTTP：80
        • HTTPS：443
        • FTP：21
        • Telnet：23
      • 程序注册端口：1024~49151，分配用户或者程序
        • Tomcat：8080
        • MySQL：3306
        • Oracle：1521
      • 动态、私有：49152~65535

    演示

    1. package net;
    2.  
    3. import java.net.InetSocketAddress;
    4.  
    5. public class TestInetSocketAddress {
    6.     public static void main(String[] args) {
    7.  
    8.         InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
    9.         System.out.println(inetSocketAddress);
    10.  
    11.         InetSocketAddress inetSocketAddress1 = new InetSocketAddress("localhost", 8080);
    12.         System.out.println(inetSocketAddress1);
    13.  
    14.         System.out.println("===========================");
    15.  
    16.         System.out.println(inetSocketAddress.getAddress());
    17.         System.out.println(inetSocketAddress.getHostName());    //地址
    18.         System.out.println(inetSocketAddress.getPort());        //端口
    19.     }
    20. }

    通信协议

    协议：约定，就好比我们现在说的普通话。

    网络通信协议：速率，传输码率，代码结构，传输控制

    TCP：传输控制协议

    UDP：用户数据报协议

    IP：网络互联协议

    TCP和UDP对比

    TCP：打电话

    • 连接，稳定
    • 三次握手，四次挥手

    • 客户端，服务端
    • 传输完成，释放网络，效率低

    UDP：发短信

    • 不连接，不稳定
    • 客户端，服务端;没有明确的界限
    • 不管有没有准备好，都可以发给你
    • 类似导弹，直接轰炸，不提醒
    • DDOS：洪水攻击（饱和攻击）

    TCP

    演示：TCP实现聊天

    TcpClientDemo01.java

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

    TcpServerDemo01.java

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

    演示：TCP文件上传实现

    TcpClientDemo02.java

    1. package net;
    2.  
    3. import java.io.*;
    4. import java.net.InetAddress;
    5. import java.net.Socket;
    6.  
    7. public class TcpClientDemo02 {
    8.     public static void main(String[] args) throws Exception{
    9.         //1.创建一个socket连接
    10.         Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
    11.  
    12.         //2.创建一个输出流
    13.         OutputStream os = socket.getOutputStream();
    14.  
    15.         //3.读取文件
    16.         FileInputStream fis = new FileInputStream(new File("吴彦祖.gif"));
    17.  
    18.         //4.写出文件
    19.         byte[] buffer = new byte[1024];
    20.         int len;
    21.         while((len=fis.read(buffer))!=-1){
    22.             os.write(buffer,0,len);
    23.         }
    24.  
    25.         //5.通知服务器，已经结束传输了
    26.         socket.shutdownOutput();
    27.  
    28.         //6.确定服务器接受完毕，才能够断开连接
    29.         InputStream is = socket.getInputStream();
    30.         //String byte[]
    31.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    32.  
    33.         byte[] buffer2 = new byte[1024];
    34.         int len2;
    35.         while((len2=is.read(buffer2))!=-1){
    36.             baos.write(buffer2,0,len2);
    37.         }
    38.  
    39.         System.out.println(baos.toString());
    40.  
    41.         //7.关闭资源
    42.         baos.close();
    43.         is.close();
    44.         fis.close();
    45.         os.close();
    46.         socket.close();
    47.     }
    48. }

    TcpServerDemo02.java

    1. import java.io.File;
    2. import java.io.FileOutputStream;
    3. import java.io.InputStream;
    4. import java.io.OutputStream;
    5. import java.net.ServerSocket;
    6. import java.net.Socket;
    7.  
    8. public class TcpServerDemo02 {
    9.     public static void main(String[] args) throws Exception{
    10.         //1.创建服务
    11.         ServerSocket serverSocket = new ServerSocket(9000);
    12.  
    13.         //2.监听客户端的连接
    14.         Socket socket = serverSocket.accept();//阻塞式监听，会一直等待客户端连接
    15.  
    16.         //3.获取输入流
    17.         InputStream is = socket.getInputStream();
    18.  
    19.         //4.文件输出
    20.         FileOutputStream fos = new FileOutputStream(new File("receive.gif"));
    21.         byte[] buffer = new byte[1024];
    22.         int len;
    23.         while((len=is.read(buffer))!=-1){
    24.             fos.write(buffer,0,len);
    25.         }
    26.  
    27.         //5.通知客户端我已经接受完毕了
    28.         OutputStream os = socket.getOutputStream();
    29.         os.write("已接受完毕，可以断开！".getBytes());
    30.  
    31.         //6.关闭资源
    32.         fos.close();
    33.         is.close();
    34.         socket.close();
    35.         serverSocket.close();
    36.  
    37.  
    38.     }
    39. }

    UDP

    协议简介

    UDP（UserDatagramProtocol）是一个简单的面向消息的传输层协议，尽管UDP提供标头和有效负载的完整性验证（通过校验和），但它不保证向上层协议提供消息传递，并且UDP层在发送后不会保留UDP 消息的状态。因此，UDP有时被称为不可靠的数据报协议。如果需要传输可靠性，则必须在用户应用程序中实现。

    • UDP是基于IP的简单协议，不可靠的协议。
    • UDP的优点：简单，轻量化。
    • UDP的缺点：没有流控制，没有应答确认机制，不能解决丢包、重发、错序问题。

    综上所述，UDP使用场景为流媒体应用、语音交流、视频会议所使用的传输层协议，还有许多基于互联网的电话服务使用的VOIP（基于IP的语音）也是基于UDP运行的，实时视频和音频流协议旨在处理偶尔丢失的数据包，因此，如果重新传输丢失的数据包，则只会发生质量略有下降，而不是出现较大的延迟。

    DatagramSocket 类

    DatagramSocket 类用于表示发送和接收数据报包的套接字。数据报包套接字是包投递服务的发送或接收点。每个在数据报包套接字上发送或接收的包都是单独编址和路由的。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。

    DatagramPacket 类

    java.net 包中的 DatagramPacket 类用来表示数据报包，数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。

    演示：UDP消息发送

    UdpClientDemo01.java

    1. package net;
    2.  
    3. import java.net.DatagramPacket;
    4. import java.net.DatagramSocket;
    5. import java.net.InetAddress;
    6.  
    7. //不需要连接服务器
    8. public class UdpClientDemo01 {
    9.     public static void main(String[] args) throws Exception{
    10.         //1.建立一个Socket
    11.         DatagramSocket socket = new DatagramSocket();
    12.  
    13.         //2.新建一个包
    14.         String msg = "你好啊，服务器";
    15.  
    16.         //发送给谁
    17.         InetAddress localhost = InetAddress.getByName("localhost");
    18.         int port =9090;
    19.  
    20.         //数据，数据的长度起始，要发送谁
    21.         DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);
    22.  
    23.         //3.发送包
    24.         socket.send(packet);
    25.  
    26.         //4.关闭流
    27.         socket.close();
    28.     }
    29. }

    UdpServerDemo01.java

    1. package net;
    2.  
    3. import java.net.DatagramPacket;
    4. import java.net.DatagramSocket;
    5.  
    6. //还是要等待客户端的连接
    7. public class UdpServerDemo01 {
    8.     public static void main(String[] args) throws Exception{
    9.         //开放端口
    10.         DatagramSocket socket = new DatagramSocket(9090);
    11.  
    12.         //接受数据包
    13.         byte[] buffer = new byte[1024];
    14.         DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);//接收
    15.  
    16.         socket.receive(packet);//阻塞接收
    17.  
    18.         System.out.println(packet.getAddress().getHostAddress());
    19.         System.out.println(new String(packet.getData(),0,packet.getLength()));
    20.  
    21.         //关闭连接
    22.         socket.close();
    23.  
    24.     }
    25. }

    演示：UDP聊天实现

    UdpSenderDemo01.java

    1. package net;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.InputStreamReader;
    5. import java.net.DatagramPacket;
    6. import java.net.DatagramSocket;
    7. import java.net.InetSocketAddress;
    8.  
    9. public class UdpSenderDemo01 {
    10.     public static void main(String[] args) throws Exception{
    11.         DatagramSocket socket = new DatagramSocket(8888);
    12.  
    13.         //准备数据： 控制台读取System.in
    14.         //表示缓冲区的。之前的StringBuffer，缓冲区中的内容可以更改，可以提高效率。
    15. 		//如果想接收任意长度的数据，而且避免乱码的产生，就可以使用BufferedReader。[下图BufferedReader注解]
    16.         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    17.  
    18.         while (true){
    19.             String data = reader.readLine();
    20.             byte[] datas = data.getBytes();
    21.             DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));
    22.  
    23.             socket.send(packet);
    24.             if(data.equals("bye")){
    25.                 break;
    26.             }
    27.         }
    28.  
    29.         socket.close();
    30.     }
    31. }

    UdpReceiveDemo01.java

    1. package net;
    2.  
    3. import java.net.DatagramPacket;
    4. import java.net.DatagramSocket;
    5.  
    6. public class UdpReceiveDemo01 {
    7.     public static void main(String[] args) throws Exception{
    8.         DatagramSocket socket = new DatagramSocket(6666);
    9.  
    10.  
    11.         while (true){
    12.             //准备接受包裹
    13.             byte[] container = new byte[1024];
    14.             DatagramPacket packet = new DatagramPacket(container,0,container.length);
    15.             socket.receive(packet);//阻塞式接受包裹
    16.  
    17.             //断开连接
    18.             byte[] data = packet.getData();
    19.             String receiveData = new String(data, 0, data.length);
    20.  
    21.             System.out.println(receiveData.trim());
    22.  
    23.             if(receiveData.equals("bye")){
    24.                 break;
    25.             }
    26.         }
    27.     }
    28. }

    UDP多线程聊天

    TalkSend.java

    1. package net;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.IOException;
    5. import java.io.InputStreamReader;
    6. import java.net.DatagramPacket;
    7. import java.net.DatagramSocket;
    8. import java.net.InetSocketAddress;
    9. import java.net.SocketException;
    10.  
    11. public class TalkSend implements Runnable{
    12.  
    13.     DatagramSocket socket = null;
    14.     BufferedReader reader = null;
    15.  
    16.     private int fromPort;
    17.     private  String toIp;
    18.     private int toPort;
    19.  
    20.     public TalkSend(int fromPort, String toIp, int toPort) {
    21.         this.fromPort = fromPort;
    22.         this.toIp = toIp;
    23.         this.toPort = toPort;
    24.  
    25.         try {
    26.              socket = new DatagramSocket(fromPort);
    27.              reader = new BufferedReader(new InputStreamReader(System.in));
    28.         } catch (SocketException e) {
    29.             throw new RuntimeException(e);
    30.         }
    31.     }
    32.  
    33.     @Override
    34.     public void run() {
    35.         while (true)
    36.             try {
    37.             String data = reader.readLine();
    38.             byte[] datas = data.getBytes();
    39.             DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIp,this.toPort));
    40.  
    41.             socket.send(packet);
    42.             if(data.equals("bye")){
    43.                 break;
    44.             }
    45.               } catch (IOException e) {
    46.                 throw new RuntimeException(e);
    47.         }
    48.         socket.close();
    49.     }
    50. }

    TalkReceive.java

    1. package net;
    2.  
    3. import java.io.IOException;
    4. import java.net.DatagramPacket;
    5. import java.net.DatagramSocket;
    6. import java.net.SocketException;
    7.  
    8. public class TalkReceive implements Runnable{
    9.  
    10.     DatagramSocket socket = null;
    11.     private int port;
    12.     private String msgFrom;
    13.  
    14.     public TalkReceive(int port,String msgFrom) {
    15.         this.port = port;
    16.         this.msgFrom = msgFrom;
    17.  
    18.         try {
    19.             socket = new DatagramSocket(port);
    20.         } catch (SocketException e) {
    21.             throw new RuntimeException(e);
    22.         }
    23.     }
    24.  
    25.     @Override
    26.     public void run() {
    27.         while (true){
    28.             try{
    29.                 //准备接受包裹
    30.                 byte[] container = new byte[1024];
    31.                 DatagramPacket packet = new DatagramPacket(container,0,container.length);
    32.                 socket.receive(packet);//阻塞式接受包裹
    33.  
    34.                 //断开连接 bye
    35.                 byte[] data = packet.getData();
    36.                 String receiveData = new String(data, 0, data.length);
    37.  
    38.                 System.out.println(msgFrom+":"+receiveData.trim());
    39.  
    40.                 if(receiveData.equals("bye")){
    41.                     break;
    42.                 }
    43.             }catch (IOException e){
    44.                 e.printStackTrace();
    45.             }
    46.         }
    47.         socket.close();
    48.  
    49.     }
    50. }

    TalkStudent.java

    1. package net;
    2.  
    3. public class TalkStudent {
    4.     public static void main(String[] args) {
    5.         //开启两个线程
    6.         //学生发送消息的目的地址是IP，目的端口9999，学生接受消息的端口8888，接受的是老师这个人
    7.         new Thread(new TalkSend(7777,"localhost",9999)).start();
    8.         new Thread(new TalkReceive(8888,"老师")).start();
    9.     }
    10. }

    TalkTeacher.java

    1. package net;
    2.  
    3. public class TalkTeacher {
    4.     public static void main(String[] args) {
    5.         //老师发送消息的目的地址是IP，目的端口8888，老师接受消息的端口9999，接受的是学生这个人
    6.         new Thread(new TalkSend(5555,"localhost",8888)).start();
    7.         new Thread(new TalkReceive(9999,"学生")).start();
    8.     }
    9. }

    URL

    URL:统一资源定位符

    URL是对互联网上得到的资源的位置和访问方法的一种简洁表示，是互联网上标准资源的地址。URL它具有全球唯一性，正确的URL应该是可以通过浏览器打开此网页的，但如果您访问外网，会提示网页无法打开，这并不能说明这个URL是错误的。只不过在国内不能访问而已。

    URL由三部分组成：资源类型、存放资源的主机域名、资源文件名。

    演示：URL的get用法

    1. package net;
    2.  
    3. import java.net.URL;
    4.  
    5. public class UrlDemo1 {
    6.     public static void main(String[] args) throws Exception{
    7.         URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=chenxin&password=123456");
    8.         System.out.println(url.getProtocol());      //协议
    9.         System.out.println(url.getHost());          //主机ip
    10.         System.out.println(url.getPort());          //端口
    11.         System.out.println(url.getPath());          //路径
    12.         System.out.println(url.getQuery());         //参数
    13.     }
    14. }

    URL的down用法

    1. package net;
    2.  
    3. import java.io.FileOutputStream;
    4. import java.io.InputStream;
    5. import java.net.HttpURLConnection;
    6. import java.net.URL;
    7. import java.net.URLConnection;
    8.  
    9. public class UrlDown {
    10.     public static void main(String[] args) throws Exception{
    11.         //1.下载地址
    12.         URL url = new URL("https://gimg2.baidu.com/image_search/src=http%316%2F06%2F13%2F146578167579371187.PNG");
    13.  
    14.         //2.连接到这个资源 HTTP
    15.         HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
    16.  
    17.         InputStream inputStream = urlConnection.getInputStream();
    18.  
    19.         FileOutputStream fos = new FileOutputStream("吴彦祖.gif");
    20.  
    21.         byte[] buffer = new byte[1024];
    22.         int len;
    23.         while ((len=inputStream.read(buffer))!=-1){
    24.             fos.write(buffer,0,len);    //写出这个程序
    25.         }
    26.         fos.close();
    27.         inputStream.close();
    28.         urlConnection.disconnect();//断开连接
    29.     }
    30. }

  • 相关阅读:
    Mybatis-Plus
    OPC DCOM快速配置
    java毕业生设计中小型连锁超市配送中心配送管理计算机源码+系统+mysql+调试部署+lw
    00后会不会改变软件测试行业现状？
    Unity/C# 舍入的五种写法
    二分查找练习
    SpringBoot+Vue项目疫苗预约管理系统
    操作系统——死锁
    商品秒杀系统思路
    基于JAVA+SpringBoot+Mybatis+MYSQL的课程在线学习系统
  • 原文地址：https://blog.csdn.net/guanshengg/article/details/126315509