网络编程

1.1 概述

地球村：地理位置不同，有其他区域的朋友

信件：

计算机网络：

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

网络编程的目的：

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

想要达到这个效果需要什么：

1. 如何准确的定位网络上的一台主机	192.168.16.124：端口，定位到这个计算机上的某个资源
2. 找到了这个主机，如何传输数据？

JavaWeb：网页编程 B/S

网络编程： TCP/IP C/S

1.2 网络通信的要素

如何实现网络的通信？

通信双方的地址：

ip
端口号
192.168.16,124:5900

规则：网络通信的协议

TCP/IP参考模型：

小结：

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

1.3 IP

ip地址：InetAddress

唯一定位一台网络上计算机
127.0.0.1：本机localhost
ip地址的分类
- ipv4/ipv6
  - IPV4 127.0.0.1,4个字节组成，0~255, 42亿； 30亿都在北美，亚洲4亿。2011年就用尽；
  - IPV6 128位 8个无符号整数
    
    举例：2001:0bb2:aaaa:0015:0000:0000:1aaa:1312
- 公网（互联网）-私网（局域网）
  - ABCD类地址
  - 192.168.xx.xx，专门给组织内部使用的
域名：记忆IP问题
- IP: www.baidu.com

了解就好

import java.net.InetAddress;
import java.net.UnknownHostException;

public class TestInetAddress {
    public static void main(String[] args) {
        try{
            // 查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);
            InetAddress inetAddress2 = InetAddress.getByName("localhost");
            System.out.println(inetAddress2);
            InetAddress inetAddress3 = InetAddress.getLocalHost();
            System.out.println(inetAddress3);
            // 查询网址ip地址
            InetAddress inetAddress4 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress4);
            // 常用方法
            // System.out.println(inetAddress4.getAddress());
            System.out.println(inetAddress4.getCanonicalHostName()); // 规范的名字
            System.out.println(inetAddress4.getHostAddress()); // ip
            System.out.println(inetAddress4.getHostName()); // 域名或者自己电脑的名字
        }catch (UnknownHostException e){
            e.printStackTrace();
        }
    }
}

1.4 端口

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

不同的进程有不同的端口号！用来区分软件
被规定 0~65535
TCP,UDP : 65535*2 tcp：80，udp：80吗？单个协议下，端口号不能冲突

端口分类

公有端口 0~1023
- HTTP : 80
- HTTPS : 443
- FTP : 21
- Telent ： 23
程序注册端口：1024~49151,分配用户或者程序
- Tomcat ：8080
- MySql ：3306
- Oracle ：1521

动态、私有：49152~65535

netstat -ano // 查看所有的端口
netstat -ano|findstr "5900" // 查看指定的端口
tasklist|findstr "8696" // 查看指定端口的进程
Ctrl + shift + Esc

import java.net.InetSocketAddress;

public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress socketAddress2 = new InetSocketAddress("localhost",8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress2);

        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName()); // 地址
        System.out.println(socketAddress.getPort()); // 端口
    }
}

1.5 通信协议

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

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

问题：非常的复杂？

大事化小：分层

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

重要：

TCP : 用户传输协议
UDP ：用户数据报协议

出名的协议：

TCP : 用户传输协议
IP : 网络互连协议

TCP UDP 对比

TCP ：打电话

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

三次握手，最少需要三次，保证稳定连接

A：你好啊，我是A

B：你好啊，我是B

A：今天天气不错

代码的方式就是A向B发送一个syn请求，要跟B建立链接，这个时候B回复一个ack 表名B收到这个请求了。然后B又送A发送一个syn建立一个序列号，然后A收到这个序列号给B回复自己的序列号。这样两遍的序列号都保持一致了。就表名链接建立成功了

四次挥手

A：我要断开了！

B：好的，请稍等

B：好了，你可以断开了

A：我断开了

A向B发送一个fin 表名我要断开了。B收到这个fin然后通过ack回复。然后处理继续发送的消息。等这个消息发完了。然后向A发送一个fin表名我处理好了，你可以关了。然后a发送一个消息告诉B我也处理好了
客户端、服务器
传输完成，释放连接，效率低

UDP ：发短信

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

1.6 TCP

客户端：

连接服务器 Socket

发送消息

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

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

        try {
            // 1. 要知道服务器的地址，端口号
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            // 2. 创建一个socket 连接
            socket = new Socket(serverIP,port);
            // 3. 发送消息 IO流
            os = socket.getOutputStream();
            os.write("Java".getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

服务器：

建立服务的端口 ServerSovke
等待用户的链接 accept

接收用户的消息

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) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            // 1. 得有一个地址
            serverSocket = new ServerSocket(9999);

            while (true){
                // 2. 等待客户端连接过来
                socket = serverSocket.accept();
                // 3. 读取客户端的消息
                is = socket.getInputStream();
                // 管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len=is.read(buffer))!=-1){
                    baos.write(buffer,0,len);
                }
                System.out.println(baos.toString());
            }
            /*
            超过线程池，会出现乱码情况
            byte[] buffer = new byte[1024];
            int len;
            while ((len=is.read(buffer))!=-1){
                String msg = new String(buffer,0,len);
                System.out.println(msg);
            }
             */
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (baos!=null){
                try{
                    baos.close();
                } catch (IOException e){
                    e.printStackTrace();
                }
            }
            if (is!=null){
                try {
                    is.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();
                }
            }
        }
    }
}

先运行服务端，在运行客户端运行结果：

文件上传

客户端

为了方便使用throws Exception 正常要使用try catch

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

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("test.jpg"));
        // 4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }
        // 通知服务器，我已经结束了
        socket.shutdownOutput(); // 我已经传输完了

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

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

服务端

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception{
        // 1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        // 2.监听客户端的连接
        Socket socket = serverSocket.accept(); // 阻塞式监听，会一直等待客户端连接
        // 3.获取输入流
        InputStream is = socket.getInputStream();
        // 4.文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
        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.关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

运行结果：

Tomcat

服务端

自定义 S
Tomcat服务器 S ：Java后台开发

客户端

自定义 C
浏览器 B

1.7 UDP

发短信：不用连接，需要指导对方的地址

发送消息

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

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

接收端

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()));

        // 关闭连接
        socket.close();
    }
}

运行结果：

循环发送消息

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

public class UpdSenderDemo01 {
    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("localhost",6666));

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

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

public class UpdReceiverDemo01 {
    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); // 阻塞式接收包裹
            // 断开连接 bye
            byte[] data = packet.getData();
            String receiveData = new String(data,0,data.length);
            System.out.println(receiveData);

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

运行结果：

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

发送端

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 formPort;
    private String toIP;
    private int toPort;

    public TalkSend(int formPort, String toIP, int toPort) {
        this.formPort = formPort;
        this.toIP = toIP;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(formPort);
            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 (Exception e){
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

接收端

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

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

学生端

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

老师端

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

运行结果：

URL

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

import java.net.MalformedURLException;
import java.net.URL;

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=wg&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()); // 参数
    }
}

运行结果：

网上下载文件示例

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class UrlDown {
    public static void main(String[] args) throws Exception{
        // 1.下载地址
        URL url = new URL("http://1812.img.pp.sohu.com.cn/images/blog/2009/11/18/18/8/125b6560a6ag214.jpg");
        // 2.连接到这个资源    HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("f.jpg");

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

视频链接

posted @ 2021-05-28 16:09 闲着的大叔阅读(89) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

闲着的大叔

网络编程

网络编程

1.1 概述

计算机网络：

网络编程的目的：

想要达到这个效果需要什么：

1.2 网络通信的要素

通信双方的地址：

规则：网络通信的协议

1.3 IP

1.4 端口

1.5 通信协议

1.6 TCP

文件上传

Tomcat

1.7 UDP

循环发送消息

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

URL

公告