网络编程笔记整理

网络编程

附上所看视频教程->网络编程实战讲解

1.1、概述

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

网络编程的目的：
无线电台…传播交流信息、数据交换、通信

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

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

javaweb：网页编程 B/S
网络编程：TCP/IP C/S

1.2、网络通信的要素

如何实现网络的通信？
通信双方地址：

• ip
• 端口号
• 192.168.xxx.xxx:端口

规则：网络通信的协议

TCP/IP参考模型：

图片链接所属博客->OSI 七层模型和TCP/IP模型及对应协议（详解）

小结：

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

IP

ip地址：InetAddress

• 唯一定位一台网络上的计算机
• 127.0.0.1：本机localhost
  相当于自己呼叫自己，没网也能呼叫成功
  
• ip地址的分类
  - ipv4 / ipv6
  ipv4 127.0.0.1，四个字节组成
  ipv6 128位，八个无符号整数
  - 公网（互联网）-私网（局域网）
  ABCD类地址
  192.168.xx.xx，专门给组织内部使用的
  - 域名：记忆IP问题
  IP：www.id.com

package com.niko.lesson01;

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

/**
 * @auther Daisy
 * @date 2020/6/24 - 20:20
 * 测试IP
 */
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" #查看指定端口的进程->PID->端口port
 #ctrl + shift + esc #打开任务管理器快捷键

C:\Windows\System32\drivers\etc\host	#hosts文件所在位置

package com.niko.lesson01;

import java.net.InetSocketAddress;

/**
 * @auther Daisy
 * @date 2020/6/24 - 20:38
 */
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：你瞅啥
B：瞅你咋地
A：干一架


A：我要走了
B：你真的要走了吗
B：你真的真的走了吗
A：我真的要走了

• 客户端、服务端
• 传输完成，释放连接，效率低

UDP类似于发短信

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

到网上查了以后发现，QQ 以 UDP 协议为主，以 TCP 协议为辅

QQ既有UDP也有TCP！
不管UDP还是TCP，最终登陆成功之后，QQ都会有一个TCP连接来保持在线状态。
这个TCP连接的远程端口一般是80，采用UDP方式登陆的时候，端口是8000。

UDP协议是无连接方式的协议，它的效率高，速度快，占资源少，
但是其传输机制为不可靠传送，必须依靠辅助的算法来完成传输控制。

QQ采用的通信协议以UDP为主，辅以TCP协议。

由于QQ的服务器设计容量是海量级的应用，一台服务器要同时容纳十几万的并发连接，

因此服务器端只有采用UDP协议与客户端进行通讯才能保证这种超大规模的服务。

QQ客户端之间的消息传送也采用了UDP模式，因为国内的网络环境非常复杂，
而且很多用户采用的方式是通过代理服务器共享一条线路上网的方式，

在这些复杂的情况下，客户端之间能彼此建立起来TCP连接的概率较小，严重影响传送信息的效率。

而UDP包能够穿透大部分的代理服务器，因此QQ选择了UDP作为客户之间的主要通信协议。

采用UDP协议，通过服务器中转方式。

因此，现在的IP侦探在你仅仅跟对方发送聊天消息的时候是无法获取到IP的。

大家都知道，UDP 协议是不可靠协议，它只管发送，不管对方是否收到的，但它的传输很高效。

但是，作为聊天软件，怎么可以采用这样的不可靠方式来传输消息呢？

于是，腾讯采用了上层协议来保证可靠传输：
如果客户端使用UDP协议发出消息后，服务器收到该包，需要使用UDP协议发回一个应答包。

如此来保证消息可以无遗漏传输。

之所以会发生在客户端明明看到“消息发送失败”但对方又收到了这个消息的情况，
就是因为客户端发出的消息服务器已经收到并转发成功，

但客户端由于网络原因没有收到服务器的应答包引起的。

1.6、TCP

客户端

1. 连接服务器Socket
2. 发送消息

package com.niko.lesson02;

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

/**
 * @auther Daisy
 * @date 2020/6/25 - 10:14
 * 客户端
 */
public class TcpClientDemo01 {
    public static void main(String[] args) {

        InetAddress serverIP = null;
        Socket socket = null;
        OutputStream os = null;
        try {
            //1、要知道服务器的地址
            serverIP = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2、创建一个socket连接
            socket = new Socket(serverIP,port);
            //3、发送消息 IO流
            os = socket.getOutputStream();
            os.write("你好，欢迎学习".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();
                }
            }
        }
    }
}

服务器

1. 建立服务的端口ServerSocket
2. 等待用户的连接accept
3. 接收用户的消息

package com.niko.lesson02;

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

/**
 * @auther Daisy
 * @date 2020/6/25 - 10:15
 * 服务端
 */
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 {
            //关闭资源
            try {
                if(baos!=null){
                    baos.close();
                }
                if(is!=null){
                    is.close();
                }
                if(socket!=null){
                    socket.close();
                }
                if(serverSocket!=null){
                    serverSocket.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

文件上传

服务端

package com.niko.lesson02;

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

/**
 * @auther Daisy
 * @date 2020/6/25 - 10:47
 */
public class TcpServerDemo02 {
    public static void main(String[] args) throws IOException {
        //创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2、监听客户端的连接
        Socket socket = serverSocket.accept();//阻塞式监听，会一直等待客户端连接
        //3、获取输入流
        InputStream is = socket.getInputStream();
        //4、文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.png"));

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

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

客户端

package com.niko.lesson02;

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

/**
 * @auther Daisy
 * @date 2020/6/25 - 10:40
 */
public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception{
        //创建一个socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);

        //2、创建一个输出流
        OutputStream os = socket.getOutputStream();

        //3、读取文件
        FileInputStream fis = new FileInputStream(new File("dairy.png"));

        //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();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int len2;
        byte[] buffer2 = new byte[2014];
        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();
    }
}

Tomcat

服务端

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

客户端

• 自定义 C
• 浏览器 B

UDP

发短信：不用连接，需要知道对方的地址
发送消息
发送端

package com.niko.lesson03;

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

/**
 * @auther Daisy
 * @date 2020/6/25 - 11:31
 * 不需要连接服务器
 */
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();
    }
}

接收端

package com.niko.lesson03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.nio.Buffer;

/**
 * @auther Daisy
 * @date 2020/6/25 - 11:36
 * 还是要等待客户端的连接
 */
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();


    }
}

咨询

循环发送消息

package com.niko.chat;

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

/**
 * @auther Daisy
 * @date 2020/6/25 - 11:43
 */
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("localhost",6666));
            socket.send(packet);
            if(data.equals("bye")){
                break;
            }
        }


        socket.close();
    }
}

循环接收消息

package com.niko.chat;

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

/**
 * @auther Daisy
 * @date 2020/6/25 - 11:44
 */
public class UdpReceiveDemo01 {
    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();
    }
}

在线咨询

两个人都可以是发送方，也都可以是接收方

发送方

package com.niko.chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.*;

/**
 * @auther Daisy
 * @date 2020/6/25 - 15:14
 */
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.trim().equals("bye")){
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }


        socket.close();
    }
}

接收方

package com.niko.chat;

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

/**
 * @auther Daisy
 * @date 2020/6/25 - 15:22
 */
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;
        //ctrl+alt+t代码提示，看起来是可以自动写if，try/catch语句的快捷键
        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.trim().equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

开线程
老师端

package com.niko.chat;

/**
 * @auther Daisy
 * @date 2020/6/25 - 15:31
 */
public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

学生端

package com.niko.chat;

/**
 * @auther Daisy
 * @date 2020/6/25 - 15:29
 */
public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

1.8、URL

https://www.baidu.com/

统一资源定位符：定位互联网上的某一个资源
DNS域名解析 www.baidu.com xxx.x…x…x

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

package com.niko.lesson04;

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

/**
 * @auther Daisy
 * @date 2020/6/25 - 15:55
 */
public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld.index.jsp?username=jkk&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.niko.lesson04;

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

/**
 * @auther Daisy
 * @date 2020/6/25 - 16:58
 * http://localhost:8080/niko/SecurityFile.txt
 *
 * 告白网易云地址
 * https://m801.music.126.net/20200625174444/6d1978619444770e5f0a99dc44595ea6/jdyyaac/015b/5509/5459/61554bda73bc6e98b899c3ff41f97ae7.m4a
 */
public class URLDown {
    public static void main(String[] args) throws Exception {
        //1、下载地址
        URL url = new URL("https://m801.music.126.net/20200625174444/6d1978619444770e5f0a99dc44595ea6/jdyyaac/015b/5509/5459/61554bda73bc6e98b899c3ff41f97ae7.m4a");

        //2、连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("gaobai.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();//断开连接
    }
}

附全部代码
收拾收拾得把输入输出流和多线程重新学学
找时间再了解一下socket