1.1 概述

1.2 网络通信的要素

1.3 IP

1.4 端口

1.5 通信协议

1.6 TCP

（1）消息发送

（2）文件上传

1.7 UDP

（1）发短信

（2）聊天（循环发送-循环接收）

（3）多线程实现双向聊天

1.8 URL

1.1 概述

计算机网络：

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

网络编程的目的：

无线电台——传播交流信息，数据交换、通信

主要因素：

1. 如果准确的定位网络上的一台主机？

端口，定位到这个计算机上的某个资源。

2. 找到这个主机，如何传输数据？

javaweb：网页编程、

网络编程：TCP/IP C/S

1.2 网络通信的要素

如何实现网络的通信？

通信双方地址：

IP 端口号 192.168.xxx.xxx

规则：网络通信的协议

TCP/IP参考模型：

小结：

1. 网络编程中的两个主要的问题？

如何准确的定位到网络上的一台或多台主机。域名/IP地址

找到主机之后如何进行通信。

2. 网络编程中的要素？

IP和端口号 IP

网络通信写协议 UDP、TCP

1.3 IP

1. IP地址：InetAddress

唯一定位一台网络上计算机

127.0.0.1：本机localhost

2. IP地址的分类：

（1） IPV4/IPV6 ：

IPV4 == 127.0.0.1 ，4个字节组成 0~255

IPV6 == fe80::915d:470e:d522:4339:1006:f431:g342 ， 128位，8个无符号整数。

（2）公网（互联网）-私网（局域网）

public class TestIntentAddress {
    public static void main(String[] args) {
        try {
            //查找本机地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);
            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);
            InetAddress inetAddress4 = InetAddress.getLocalHost();
            System.out.println(inetAddress4);

            //查询网站IP地址
            InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress2);

            //常用的方法
            System.out.println(inetAddress2.getAddress());
            System.out.println(inetAddress2.getHostAddress());//ip
            System.out.println(inetAddress2.getCanonicalHostName());//规范的名字
            System.out.println(inetAddress2.getHostName());//域名，或者自己电脑的名字

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

1.4 端口

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

不同进程有不同的端口号，用来区分软件被规定 0~65535

TCP,UDP :65535 *2 TCP:80 UDP:80 单个协议下，端口号不能冲突。

2. 端口分类：

（1）公有端口 0~1023

http：80端口

https（安全）： 443

ftp： 21

Telent ： 23

（2）程序注册端口：1024~49151 分配用户或程序

Tomcat ： 8080

MySQL ： 3306

Oracle ： 1521

（3）动态、私有：49152~65535

Linux查看任务管理器的方法：

方法一：ctrl + shift + esc

方法二：↓↓↓

netstat -ano    #查看所有端口
netstat -ano|findstr "5900"    #查看指定端口
tasklist|findstr "8696"     #查看指定端口进程

public class TestIntetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress inetSocketAddress1 = new InetSocketAddress("localhost",8080);

        System.out.println(inetSocketAddress);
        System.out.println(inetSocketAddress1);

        System.out.println(inetSocketAddress.getAddress());
        System.out.println(inetSocketAddress.getHostName());  //地址
        System.out.println(inetSocketAddress.getPort());    //窗口
    }
}

1.5 通信协议

网络通信协议：

速率、传输码率、代码结构、传输控制...

TCO/IP协议簇：

（1）TCP ：用户传输协议

（2）UDP ：用户数据报协议

（3）IP：网络互联协议

TCP UDP 对比：

（1）TCP：打电话

连接，稳定

“三次握手” “四次挥手”：最少需要三次，保证稳定连接

客户端服务端

传输完成，释放连接，效率低

（2）UDP：发短信

不连接，不稳定

客户端服务端：没有明确的界限

不管有没有准备好，随时发送

1.6 TCP

（1）消息发送

客户端：

1. 连接服务器 Socket

2. 发送消息

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream outputStream = null;

        try {
            //1.要知道服务器的地址
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2.创建一个socket连接
            socket =  new Socket(serverIP, port);
            //3.发送消息
            outputStream = socket.getOutputStream();
            outputStream.write("你好！".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

服务器端：

1. 简历服务器端口 ServerSocket

2. 等待用户的连接 accept

3. 接收用户的消息

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket =null;
        InputStream inputStream =null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        Socket socket =null;
        try {
            //1.要先有一个地址
            serverSocket = new ServerSocket(9999);
            while (true) {
                //2.等客户端连接过来
                socket = serverSocket.accept();
                //3.读取客户端的消息
                inputStream = socket.getInputStream();
                //管道流
                byteArrayOutputStream = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len = inputStream.read(buffer)) != -1) {
                    byteArrayOutputStream.write(buffer, 0, len);
                }
                System.out.println(byteArrayOutputStream.toString());
            }
        }
             catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            if (byteArrayOutputStream!=null){
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

（2）文件上传

原文件：bj.jpg

上传的新文件：receive.jpg

客户端：

public class TcpClientDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建一个socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);
        //2.创建一个输出流
        OutputStream outputStream = socket.getOutputStream();
        //3.读取文件
        FileInputStream fileInputStream = new FileInputStream(new File("bj.jpg"));
        //4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fileInputStream.read(buffer))!=-1){
            outputStream.write(buffer,0,len);
        }

        //通知服务器，已接收结束
        socket.shutdownOutput();//传输完毕
        //确定服务器接收完毕，才能断开连接
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer1 = new byte[1024];
        int len1;
        while ((len1=inputStream.read(buffer1))!=-1){
            byteArrayOutputStream.write(buffer1,0,len1);
        }
        System.out.println(byteArrayOutputStream.toString());

        //5.关闭资源
        byteArrayOutputStream.close();
        fileInputStream.close();
        outputStream.close();
        socket.close();
    }
}

服务器端：

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception{
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);

        //2.监听客户端的连接
        Socket socket = serverSocket.accept();  //阻断式监听，会一直等待客户端连接
        //3.获取输入流
        InputStream inputStream = socket.getInputStream();
        //4.文件输出
        FileOutputStream receive = new FileOutputStream(new File("receive.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while((len = inputStream.read(buffer))!=-1){
            receive.write(buffer,0,len);
        }
        //通知客户端，接收完毕
        OutputStream outputStream1 = socket.getOutputStream();
        outputStream1.write("接收完毕".getBytes());
        //5.关闭资源
        receive.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

1.7 UDP

（1）发短信

不用连接，但是需要知道对方地址。

发送端：

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception{
        //1.建立一个socket
        DatagramSocket socket = new DatagramSocket();
        //2.建立一个包
        String msg = "你好！";
        //发送对象
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;

        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length,localhost,port);//（数据，数据的起始长度，发送对象）
        //3.发送包
        socket.send(packet);
        //4.关闭流
        socket.close();

    }
}

接收端：

public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception{
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        socket.receive(packet);//阻塞接收

        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0, packet.getLength()));
        //关闭连接
        socket.close();
    }
}

（2）聊天（循环发送-循环接收）

发送端：

public class UdpSenderDemo1 {
    public static void main(String[] args) throws Exception{
        DatagramSocket socket = new DatagramSocket(4444);

        //准备数据：控制台读取
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true){
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));

            socket.send(packet);

            if (data.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

接收端：

public class UdpReceiveDemo1 {
    public static void main(String[] args)throws Exception {
        DatagramSocket socket = new DatagramSocket(6666);
        while (true){
            //准备接收包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet);
            //断开连接
            byte[] data = packet.getData();
            String receiveData = new String(data,0,packet.getLength());

            System.out.println(receiveData);

            if (receiveData.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

（3）多线程实现双向聊天

TalkSend.java:

public class TalkSend implements Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = null;

    private String toIP;
    private int toPort;
    private int fromPort;

    public TalkSend(int fromPort,String toIP, int toPort) {
        this.toIP = toIP;
        this.toPort = toPort;
        this.fromPort = fromPort;
        try {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true){
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIP,this.toPort));

                socket.send(packet);
                if (data.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

TalkReceive.java:

public class TalkReceive implements Runnable{
    DatagramSocket socket = null;
    private String msgFrom;
    private int port;

    public TalkReceive(int port,String msgFrom){
        this.port = port;
        this.msgFrom = msgFrom;

        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while (true){
            try {
                //准备接收包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                socket.receive(packet);
                //断开连接
                byte[] data = packet.getData();
                String receiveData = new String(data,0,data.length);

                System.out.println(msgFrom + ":" + receiveData);

                if (receiveData.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();

    }
}

TalkStudent.java:

public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();

    }
}

TalkTeacher.java:

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

1.8 URL

统一资源定位符：定位资源的，定位互联网上的某个资源。

DNS 域名解析（域名==> IP） : 将www.baidu.com 解析为 xxxx.xxx.xxx

协议：// ip地址：端口 / 项目名 / 资源

public class UrlDown {
    public static void main(String[] args) throws Exception{
        //1.下载地址
        URL url = new URL("https://m801.music.126.net/20221209142041/01f6ad2e737beb12088aa17e256a535b/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/22676704157/3d2d/6f33/86f2/4f89bbb672141094a59a423b68bd6a98.m4a");
        //2.连接到这个资源  HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fileOutputStream = new FileOutputStream("a98.m4a");

        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer))!=-1){
            fileOutputStream.write(buffer,0,len);//写出这个数据
        }
        fileOutputStream.close();
        inputStream.close();
        urlConnection.disconnect();//断开连接
    }
}