Demo08-网络编程

网络编程 1.1 概述

早期：包（packet）

对方的信息

对方的地址

自己的地址

打电话–连接–接通–通话-- TCP连接

发短信–发送成功–接收-- UDP连接

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

网络编程的目的：

无线电台…传播交流信息…数据交换。通信

注意：Javaweb：网页编程

网络编程：TCP/IP

1.2网络通信的要素

如何实现网络的通信？

通信双方的地址：

IP端口号IP +端口就能定位到具体的一台计算机的具体应用规则：网络通信的协议：

TCP/IP参考模型：OSI七层网络模型，TCP/IP四层概念模型，对应网络协议

1.3 IP

IP地址：InetAddress

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

127.0.0.1：本机localhost

ip地址的分类

IP地址分类：IPV4/IPV6

IPV4 --127.0.0.1 ,4个字节组成。(一个字节长度0-255)2011年用尽IPV6–128位。8位无符号整数！eg. 2001:0bb2：aaaa:0015:0000:0000:1bbb:1234!

公网(互联网)-私网（局域网）

ABCD类地址

192.168.xx.xx,专门给组织内部使用的。

域名：为了解决记忆IP问题！

IP 1.4 端口

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

不同的进程有不同的端口号，用来区分软件。

端口被规定为0-65536

分为TCP端口,和UDP端口: 65536 *2 ;

tcp:80, udp:80可以吗？单个协议下，端口号不能冲突

端口的分类：

公有端口 0-1023

http：80
https：443
FTP： 21
TELENT： 23

程序注册端口：1024-49151 （分配给用户或者程序

Tomact：8080

Mysql : 3306

Oracle: 1521
动态、私有端口：49152-65536

netstat -ano #查看所有的端口
netstat -ano|findstr "5900" #查看指定的端口
tasklist|findstr "8696" #查看指定端口的进程
Ctrl + shift + ESC #快捷键打开任务管理器

1.5 通信协议

协议：即一种约定（类似于普通话）

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

TCP/IP协议簇：实际上是一组协议

注：1. TCP：用户传输协议

2.UDP：用户数据报协议

TCP UDP对比：

TCP相当于打电话：

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

最少需要三次，保证稳定连接客户端，服务端传输完成，释放连接，效率低

UDP：发短信

不连接，不稳定客户端、服务端：没有明确的界限不管有没有准备好，都可以发送DDOS:洪水攻击！（饱和攻击） 1.6 TCP

客户端：

连接服务器Socket

发送消息

package com.li.lesson01;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.nio.charset.StandardCharsets;


public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream outputStream  = null;
        try {
            //1.要知道服务器的地址
            InetAddress severIP = InetAddress.getByName("127.0.0.1");
            //端口号
            int port = 9999;
            //2.创建一个socket连接
            socket = new Socket(severIP,port);
            //3.发送消息 IO流
            outputStream = socket.getOutputStream();
            outputStream.write("这是一个小测试".getBytes(StandardCharsets.UTF_8));

        } catch (IOException 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();
                }
            }
        }

    }
}

服务器：

建立服务的端口ServerSocket

等待用户的链接 accept

接受用户的消息

package com.li.lesson01;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;


public class TcpServerDemo01 {

    public static void main(String[] args) {
        ByteArrayOutputStream baos = null;
        InputStream inputStream  =null;
        Socket socket = null;
        ServerSocket serverSocket  = null;
        try {
            //1.服务器需要有一个地址
            serverSocket = new ServerSocket(9999);
            while(true) {
                //2.等待客户端连接进来
                socket = serverSocket.accept();
                //3.读取客户端的消息
                inputStream = socket.getInputStream();

                

                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len =inputStream.read(buffer)) != -1) {
                    baos.write(buffer, 0, len);
                }
                System.out.println(baos.toString());
            }

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            if (baos!=null){
                try {
                    baos.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();
                }
            }
        }
    }

}

文件上传

服务器端

package com.li.lesson01;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServerDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建服务器端口
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        Socket socket = serverSocket.accept();//阻塞式监听，会一直等待客户端连接
        //3.获取输入流
        InputStream is = socket.getInputStream();

        //4.文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpeg"));
        byte[] buffer = new byte[1024];
        int len;
        while((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }


        //通知客户端接收完毕
        OutputStream os = socket.getOutputStream();
        os.write("我接收完毕，可以断开连接了".getBytes());

        //5.关闭所有连接
        os.close();
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

客户端

package com.li.lesson01;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

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

        //通知服务器我传输结束了
        socket.shutdownOutput(); //传输完了

        //确定服务器接收完，才能够断开连接
        InputStream is = socket.getInputStream();
        //String<==>byte[]
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2=is.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }
        System.out.println(baos.toString()); //转为字符串

        //5.关闭资源
        baos.close();
        is.close();
        fis.close();
        os.close();
        socket.close();
    }
}

Tomact

服务端

自定义 STomcat服务器（已经定义好的服务器）S ：Java后台开发用已经定义好的服务器

客户端

自定义C浏览器B 1.7 UDP 发送消息

类似于发短信：不用连接，需要知道对方的地址

发送端

package com.li.lesson02;
import java.net.*;

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1.新建一个Socket
        DatagramSocket socket = new DatagramSocket();

        //2.建个包 DatagramPacket
        String msg="你好，服务器！";
        InetAddress address = InetAddress.getByName("localhost");
        int port=9090;
        //数据，数据的长度起始，要发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, address, port);

        //3.发送包
        socket.send(packet);
        //4.关闭流
        socket.close();
    }
}

接收端

package com.li.lesson02;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
//需要等待客户端的连接
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())); //byte[]->String
        //关闭连接
        socket.close();
    }
}

聊天实现

循环发送消息

发送方

package com.li.chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class UdpSenderDemo01 {
    public static void main(String[] args) throws  Exception{
        DatagramSocket socket = new DatagramSocket(8888);
        //准备数据：控制台读取System.in
        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("127.0.0.1", 6666));

            socket.send(packet);

            if(data.equals("bye")) break; //bye退出循环接收
        }

        socket.close();


    }
}

接收方

package com.li.chat;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

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

        while (true) {

            //准备接收数据
            byte[] bytes = new byte[1024];
            DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
            socket.receive(packet); //阻塞式接收包裹

            //断开连接：如果接收到 bye就退出循环
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);
            System.out.println(receiveData);

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

        socket.close();

    }
}

多线程在线咨询

发送线程

package com.li.chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class TalkSend  implements Runnable {
    DatagramSocket socket = null;
    BufferedReader reader = null;
    private int fromPort;
    private String toIP;
    private int toPort;
    //建立连接
    public TalkSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        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; //bye退出循环接收
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

接收线程

package com.li.chat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable {
    
    DatagramSocket socket = null;
    private int port;//知道自己的端口号
    private String msgFrom;

    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); //阻塞式接收包裹

                //断开连接：如果接收到 bye就退出循环
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);
                System.out.println(msgFrom+": " +receiveData);

                if (receiveData.equals("bye")) {
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        socket.close();

    }
}

不同端口

package com.li.chat;

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

package com.li.chat;

public class TalkTeacher {

    public static void main(String[] args) {
        // 开启两个线程
        new Thread(new TalkSend(5555, "localhost", 8888)).start();
        new Thread(new TalkReceive(9999, "学生")).start();
    }
}

在线咨询：两个人都可以是发送方，也都可以是接收方

1.8URL

https://www.baidu.com/

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

DNS:域名解析将www.baidu.com 解析为xxx.x…x…x

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

package com.li.lesson03;

import java.net.MalformedURLException;
import java.net.URL;
import java.time.Year;

//http://localhost:8080/lizi/secret.txt
public class URLDemo01 {
    public static void main(String[] args)throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=lizi&password=123");
        System.out.println(url.getProtocol());  //协议名
        System.out.println(url.getHost());  //主机IP
        System.out.println(url.getPort());   //端口号
        System.out.println(url.getPath());   //文件
        System.out.println(url.getFile());   //文件全路径
        System.out.println(url.getQuery());   //参数

    }
}

下载资源

package com.li.lesson03;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class UrlDown {
    public static void main(String[] args) throws IOException {
        //1.下载地址（可以写自己想下的资源链接）
        URL url = new URL("https://m701.music.126.net/20220305130937/292d051724c7fdd34cb5cfec432afdaa/jdyyaac/0f5c/015a/065e/8605fc5b996069d98547143dcbfc978f.m4a");
        //2.连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("8605fc5b996069d98547143dcbfc978f.m4a");
        byte[] buffer = new byte[1024];
        int len;
        while ((len=inputStream.read(buffer))!=-1){
            fos.write(buffer,0,len); //写出这个数据到文件
        }

        fos.close();
        inputStream.close();
        urlConnection.disconnect(); //断开连接
    }
}

的资源链接）
URL url = new URL(“https://m701.music.126.net/20220305130937/292d051724c7fdd34cb5cfec432afdaa/jdyyaac/0f5c/015a/065e/8605fc5b996069d98547143dcbfc978f.m4a”);
//2.连接到这个资源 HTTP
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

    InputStream inputStream = urlConnection.getInputStream();

    FileOutputStream fos = new FileOutputStream("8605fc5b996069d98547143dcbfc978f.m4a");
    byte[] buffer = new byte[1024];
    int len;
    while ((len=inputStream.read(buffer))!=-1){
        fos.write(buffer,0,len); //写出这个数据到文件
    }

    fos.close();
    inputStream.close();
    urlConnection.disconnect(); //断开连接
}

}

Demo08-网络编程

Java相关栏目本月热门文章