java 网络编程

一、网络编程

1.1概述

地球村：将整个地球看成一个村子

信件：

计算机网络：计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
网络编程的目的：
- 数据交换
- 通讯
想要达到这个效果需要的东西
- 如何准确定位网络上的一台主机：通过IP+端口号，定位到某个计算机上的某个资源。
- 找到这个主机，如何进行数据传输
javaWeb:网页编程（B/S）
网络编程（C/S）

1.2网络通信的两个要素

如何实现网络的通信
- 通信双方地址
  - IP
  - 端口号
  - 如192.168.0.101：5900
- 通信的规则：网络通信的协议
  - http、ftp、smtp、tcp、udp等
网络编程主要涉及TCP和UDP协议
小结：
- 网络编程中有两个主要的问题
  - 如何准确的定位到网络上的一台或者多台主机
  - 找到主机后如何进行通信
- 网络编程中的要素
  - IP和端口号
  - 网络通信协议（TCP、UDP）
- 万物皆对象，上面的东西在java中全是以对象的形式出现

1.3、IP

ip地址：InetAddress类

唯一定位一台网络上的计算机
127.0.0.1：本机localhost
ip地址的分类
- ipv4/ipv6
  - IPV4：如127.0.0.1，4个字节，每个0~255，共有42亿多个地址，30多亿都在北美，亚洲仅4亿，2019年全部用完。
  - IPV6：128位，每个间隔为16位(16进制表示)，共8个间隔
```
2001:0DB8:0000:0023:0008:0800:200C:417A
//前置0可省略
2001:DB8:0:23:8:800:200C:417A
//中间有多个0可压缩为::   
FF01:0:0:0:0:0:0:1101 → FF01::1101
```
- 公网（互联网）/私网（局域网）
  - ABCD类地址：
  - A类地址第1字节为网络地址，其它3个字节为主机地址。另外第1个字节的最高位固定为0。
    　　A类地址范围：1.0.0.0到127.255.255.255。
    　　A类地址中的私有地址和保留地址：
    　　10.0.0.0到10.255.255.255是私有地址（所谓的私有地址就是在互联网上不使用，而被用在局域网络中的地址）。
    　　127.0.0.0到127.255.255.255是保留地址，用做循环测试用的。
    　　0.0.0.0到0.255.255.255也是保留地址，用做表示所有的IP地址。
    A类地址默认子网掩码为255.0.0.0
    
    B类地址第1字节和第2字节为网络地址，其它2个字节为主机地址。另外第1个字节的前两位固定为10。
    　　B类地址范围：128.0.0.1到191.255.255.255。
    　　B类地址的私有地址和保留地址
    　　172.16.0.0到172.31.255.255是私有地址
    　　169.254.0.0到169.254.255.255是保留地址。如果你的IP地址是自动获取IP地址，而你在网络上又没有找到可用的DHCP服务器，这时你将会从169.254.0.0到169.254.255.255中临时获得一个IP地址。
    　　B类地址默认子网掩码为255.255.0.0
    
    C类地址第1字节、第2字节和第3个字节为网络地址，第4个字节为主机地址。另外第1个字节的前三位固定为110。
    　　C类地址范围：192.0.0.1到223.255.255.255。
    　　C类地址中的私有地址：192.168.0.0到192.168.255.255是私有地址。
    　　C类地址默认子网掩码为255.255.255.0
    
    D类地址不分网络地址和主机地址，它的第1个字节的前四位固定为1110。
    　　⑵ D类地址范围：224.0.0.0到239.255.255.255
    　　D类地址用于多点播送。
    　　D类IP地址第一个字节以“lll0”开始，它是一个专门保留的地址。它并不指向特定的网络，目前这一类地址被用在多点广播（Multicast）中。多点广播地址用来一次寻址一组计算机，它标识共享同一协议的一组计算机。
    　　D类地址又分为三种类型：即专用地址、公用地址和私用地址；其中专用地址（224.0.0.0-224.0.0.255）用于网络协议组的广播，公用地址（224.0.1.0-238.255.255.255）用于其它组播，私用地址（239.0.0.0-239.255.255.255）用于测试。
    　　在IPv6协议中，第一个字节必须是0xFF。
    
    E类地址也不分网络地址和主机地址，它的第1个字节的前五位固定为11110。
    　　E类地址范围：240.0.0.1到255.255.255.254
    　　E类IP地址以“llll0”开始，为将来使用保留。
    　　全零（“0．0．0．0”）地址对应于当前主机。全“1”的IP地址（“255．255．255．255”）是当前子网的广播地址。
    　　E类IP地址的第一段数字范围为240～254，E类地址保留，仅作为搜索、Internet的实验和开发之用。
域名：记忆IP问题！
- IP：www.baidu.com

代码：

package com.xiaoxiao.IPClass;

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

public class IPClassTest {
    public static void main(String[] args) throws UnknownHostException {
        //InetAdress类
        //查询本机地址
        System.out.println(InetAddress.getByName("localhost"));
        System.out.println(InetAddress.getByName("127.0.0.1"));
        System.out.println(InetAddress.getLocalHost());//如果有多个网卡，需要禁用
        //查询网络地址
        System.out.println(InetAddress.getByName("www.baidu.com"));
        //
        InetAddress localHost = InetAddress.getByName("www.baidu.com");
        //返回一个地址的数组
        byte[] address = localHost.getAddress();
        for (byte b : address) {
            ////比如-1，原码为1000 0001，反码为1111 1110，补码为1111 1111 与0xff(1111 1111)做与运算，则结果为int 0000 0000 1111 1111即255
            System.out.println(b& 0xff);
        }
        System.out.println(localHost.getCanonicalHostName());//获取规范的IP地址
        System.out.println(localHost.getHostAddress());//获取IP地址
        System.out.println(localHost.getHostName());//获取域名或者自己电脑的名字
    }
}

1.4、端口

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

不同的进程有不同的端口号！用来区分软件!
被规定为0~65535
TCP,UDP:62535*2(每个最大都是62535)，如tcp：80，udp：80,但是单个协议下端口号不能冲突
端口分类
- 公有端口0~1023
  - http:80
  - https:443
  - ftp:21
  - telent:23
- 程序注册端口：1024~49151，分配给用户或者程序
  - tomcat：8080
  - Mysql：3306
  - oracle：1521
- 动态、私有端口：49152~65535
- 常见dos命令
```
netsata -ano #查看所有端口
netsata -ano|findstr "xxx"  #查看指定的端口
tasklist|findstr "xxx"  #查看指定端口的进程
Ctrl+shift+ESC		#打开任务管理器
```

代码：

package com.xiaoxiao.IPClass;

import java.net.InetSocketAddress;

public class IPSocketDemo {
    public static void main(String[] args) {
        InetSocketAddress inetSocketAddress = new InetSocketAddress("www.baidu.com", 8080);
        System.out.println(inetSocketAddress.getAddress());
        System.out.println(inetSocketAddress.getHostName());
        System.out.println(inetSocketAddress.getPort());//端口
        System.out.println(inetSocketAddress.getHostString());
        InetSocketAddress inetSocketAddress2= new InetSocketAddress("127.0.0.1", 8080);
        System.out.println(inetSocketAddress2.getAddress());
        System.out.println(inetSocketAddress2.getHostName());//hosts
        System.out.println(inetSocketAddress2.getPort());//端口
        System.out.println(inetSocketAddress2.getHostString());

    }
}

1.5、通信协议

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

网络通信协议：包括的内容很多，非常的复杂，采用分层的结构来进行细分（大事化小）
TCP/IP协议簇：包括很多协议
- TCP：传输控制协议
- UDP：用户数据报协议
- IP：网络互连协议
TCP和UDP对比
- TCP：类比于打电话
  - 需要建立连接，稳定
  - “三次握手”，“四次挥手”
    - ```
    //三次握手
    A:我要和你建立连接了
    B:我知道你要和我建立连接了
    A:建立连接
    
    
    //四次挥手 
    A:我要断开连接了
    B:我知道你要断开连接了
    B:你真的要断开连接了么？
    A:断开连接
```
- 采用客户端/服务端的方式
- 传输完成，释放连接
- UDP：类比于发短信
  - 不建立连接，不稳定
  - 客户端/服务端，但是没有明确界限
  - 不管有没有准备好，都可以发给你
  - DDOS：洪水攻击（不断的发垃圾信息，导致堵塞）[饱和攻击]

1.6、java TCP通信小实例

客户端：
- 连接服务器Socket
- 通过获取输出流发送消息

package com.xiaoxiao.TCPTest;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;

//模拟客户端服务器通信
public class SocketClientDemo01 {
    public static void main(String[] args) {
        OutputStream outputStream=null;
        Socket socket=null;
        //1.要知道服务器的IP和端口号
        InetSocketAddress inetSocketAddress=new InetSocketAddress("127.0.0.1",9999);
        String hostAddress = inetSocketAddress.getAddress().getHostAddress();
        int port = inetSocketAddress.getPort();
        //2.创建一个socket连接
        try {
            //此套接字用于发送数据
            socket=new Socket(hostAddress,port);
            //3.发送消息用IO流
            outputStream = socket.getOutputStream();
            outputStream.write("陌上花开，人已不在!\r\n".getBytes());
            outputStream.write("十年生死两茫茫!".getBytes());
        } 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.xiaoxiao.TCPTest;

import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;

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

//模拟服务端TCP通信
public class SocketServerDemo01 {

    public static void main(String[] args) {
        ServerSocket serverSocket=null;
        Socket accept=null;
        InputStream inputStream=null;
        ByteOutputStream byteOutputStream=null;
        //1.得有一个端口
        try {
            //服务器套接字，可帧听客户端的套接字
            serverSocket=new ServerSocket(9999);
            while(true) {
                //2.获取从客户端发送过来的套接字
                accept = serverSocket.accept();
                //3.获取输入流
                inputStream = accept.getInputStream();
                //使用一个管道流进行包装，防止乱码
                byteOutputStream = new ByteOutputStream();
                byte[] buffers = new byte[1024];
                int len;
                while ((len = inputStream.read(buffers)) != -1) {
                    byteOutputStream.write(buffers, 0, len);
                }
                System.out.println(byteOutputStream.toString());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (byteOutputStream!=null){
                byteOutputStream.close();
            }
            if (inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (accept!=null){
                try {
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.7、java-TCP实现文件上传

服务端代码：

package com.xiaoxiao.TCPTest;

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

//实现图片的上传和下载 服务端
public class SocketServerDemo02 {
    public static void main(String[] args) throws IOException {
        //创建服务器套接字
        ServerSocket serverSocket=new ServerSocket(8888);
        //启动帧听，等待客户端的连接
        Socket socket = serverSocket.accept();
        InputStream is = socket.getInputStream();
        FileOutputStream fos=new FileOutputStream("new.jpg");
        byte[] buffers=new byte[1024];
        int len;
        while((len=is.read(buffers))!=-1){
            fos.write(buffers,0,len);
        }
        //返回一个信息，告知客户端收到了
        OutputStream os = socket.getOutputStream();
        os.write("服务器收到客户端的数据了".getBytes());
        os.close();
        fos.close();
        is.close();
        serverSocket.close();
    }
}

客户端

package com.xiaoxiao.TCPTest;
import java.io.*;
import java.net.Socket;
//实现图片的上传和下载 客户端
public class SocekClientDemo02 {
    public static void main(String[] args) throws IOException {
        //创建一个套接字对象，用来传输数据
        Socket socket=new Socket("127.0.0.1",8888);
        //获取套接字的输出流，通过这个流向服务端写入数据
        OutputStream os = socket.getOutputStream();
        //通过输入流将图片写入
        FileInputStream fis=new FileInputStream("src/a3.jpg");
        byte[] buffers=new byte[1024];
        int len;
        //读到最后一个字节之前将数据写入到buffers
        while((len=fis.read(buffers))!=-1){
            //写入socket的输出流
            os.write(buffers,0,len);
        }
        //告诉服务端，输出流关闭,没有这个会死锁，两个进程同时
        socket.shutdownOutput();
        InputStream is = socket.getInputStream();
        //字节数组管理流包装，防止乱码
        ByteArrayOutputStream baos=new ByteArrayOutputStream();
        byte[] buffer=new byte[1024];
        int len2;
        while((len2=is.read(buffer))!=-1){
            baos.write(buffer,0,len2);
        }
        System.out.println(baos);
        baos.close();
        is.close();
        fis.close();
        os.close();
        socket.close();
    }
}

1.8、java UDP消息发送

UDP无准确的客户端和服务端的区分，一方只负责发，不管接收端接收到没有

客户端：

package com.xiaoxiao.UDPTest;

import java.io.IOException;
import java.net.*;
//UDP通信没有客户端和服务端的明确界限，两个主机均可作为客户端或服务端
public class Client {
    public static void main(String[] args) throws IOException {
        //1.创建一个数据报套接字
        DatagramSocket socket = new DatagramSocket();
        InetAddress address=InetAddress.getByName("localhost");
        int port =9090;

        //2.创建一个数据报包
        DatagramPacket packet=new DatagramPacket("hello，server".getBytes(),0,"hello，server".getBytes().length,address,port);

        //3.发送
        socket.send(packet);
        socket.close();
    }
}

服务端：

package com.xiaoxiao.UDPTest;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class Server {
    public static void main(String[] args) throws IOException {
        //1.创建一个接收的套接字
        DatagramSocket socket=new DatagramSocket(9090);
        byte[] buffers=new byte[1024];
        DatagramPacket packet=new DatagramPacket(buffers,0,buffers.length);
        socket.receive(packet);
        System.out.println(new String(packet.getData(),0,packet.getLength()));
        System.out.println(packet.getAddress());
        System.out.println(packet.getPort());
        socket.close();
    }
}

1.9、java UDP实现单向聊天

接收端：

package com.xiaoxiao.charByUDP;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class Receiver {
    public static void main(String[] args) throws Exception {
        //创建一个套接字
        DatagramSocket receiverSocket = new DatagramSocket(8888);
        while (true) {
            //创建一个缓冲区用于接收
            byte[] buffer = new byte[1024];
            //创建一个数据报
            DatagramPacket receiverPacket = new DatagramPacket(buffer, 0, buffer.length);
            receiverSocket.receive(receiverPacket);//此处一直帧听
            String s = new String(receiverPacket.getData(), 0, receiverPacket.getLength(),"UTF8");
            System.out.println(s);
            //接收到bye退出
            if (s.equals("bye")) {
                break;
            }
        }
        receiverSocket.close();
    }
}

发送端：

package com.xiaoxiao.charByUDP;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;
public class Sender {
    //发送方
    public static void main(String[] args) throws Exception {
        //发送方创建一个socket
        DatagramSocket senderSocket = new DatagramSocket(9999);
        BufferedReader reader = null;
        while (true) {
            //通过字符缓冲流进行包装，可以提高效率
            //从控制台获取输入信息
            reader = new BufferedReader(new InputStreamReader(System.in));
            //设置两边字符编码相同，否则会乱码
            String s = new String(reader.readLine().getBytes(),"UTF8");
            //创建发送的数据报
            DatagramPacket senderPacket = new DatagramPacket(s.getBytes(), 0, s.getBytes().length, new InetSocketAddress("localhost", 8888));
            //发送
            senderSocket.send(senderPacket);
            if (s.equals("bye")) {
                break;
            }
        }
        reader.close();
        senderSocket.close();
    }
}

1.10、java UDP实现多线程双向聊天

sender端：

package com.xiaoxiao.chatWithEachOther;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
public class TalkSender implements Runnable {
    DatagramSocket sender = null;
    BufferedReader bufferedReader=null;
    private int toPort;
    private int fromPort;
    private String toIP;
    public TalkSender(int toPort, int fromPort, String toIP) throws SocketException {
        //初使化
        this.toIP = toIP;
        this.fromPort = fromPort;
        this.toPort = toPort;
        //从哪个端口发送
        sender = new DatagramSocket(fromPort);
        bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    }
    @Override
    public void run() {
        //不断的读
        while (true) {
            try {
                //默认字符
                String s = new String(bufferedReader.readLine().getBytes("UTF8"));
                //这时要注意，不能是s.length(),和字节数组的长度是不一样的，会造成乱码
                DatagramPacket packet = new DatagramPacket(s.getBytes(),0,s.getBytes().length,new InetSocketAddress(toIP,toPort));
                sender.send(packet);
                if (s.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        sender.close();
    }
}

Receiver端：

package com.xiaoxiao.chatWithEachOther;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class TalkReceiver implements Runnable{
    private int port;
    private String name;
    DatagramSocket socket=null;
    public TalkReceiver(int port,String name) {
        this.name=name;
        this.port=port;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while(true){
            byte[] buffer=new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
            try {
                socket.receive(packet);
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                String s = new String(packet.getData(), 0, packet.getLength(),"UTF8");
                System.out.println(name+":"+s);
                if (s.equals("bye")){
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

实现Student：

package com.xiaoxiao.chatWithEachOther;
import com.xiaoxiao.chatWithEachOther.TalkReceiver;
import com.xiaoxiao.chatWithEachOther.TalkSender;
import java.net.SocketException;
public class TalkStudent {
    public static void main(String[] args) {
        //学生接收线程
        new Thread(new TalkReceiver(9999,"老师")).start();
        //学生发送线程
        try {
            new Thread(new TalkSender(8888,5555,"localhost")).start();
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
}

实现Teacher：

package com.xiaoxiao.chatWithEachOther;
import com.xiaoxiao.chatWithEachOther.TalkReceiver;
import com.xiaoxiao.chatWithEachOther.TalkSender;
import java.net.SocketException;
public class TalkTeacher {
    public static void main(String[] args) {
        //老师接收线程
        new Thread(new TalkReceiver(8888,"学生")).start();
        //老师发送线程
        try {
            new Thread(new TalkSender(9999,6666,"localhost")).start();
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
}

1.11、URL

https://www.baidu.com/

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

DNS域名解析：就是将www.baidu.com解析成IP的

//URL组成：
协议：//ip地址：端口/项目名称/资源

实例一：

package com.xiaoxiao.URL;

import java.net.URL;

//统一资源定位符
public class URLDemo {
    public static void main(String[] args) throws Exception {
        URL url = new URL("http://localhost:8080/test/mytest.txt");
        System.out.println(url.getAuthority());//返回主机名+端口号
        System.out.println(url.getContent());
        System.out.println(url.getFile());//和路径差不多
        System.out.println(url.getPath());
        System.out.println(url.getDefaultPort());
        System.out.println(url.getHost());
        System.out.println(url.getPort());
        System.out.println(url.getProtocol());
        System.out.println(url.getQuery());//参数
        System.out.println(url.getRef());
        System.out.println(url.getUserInfo());
        System.out.println(url.getClass());
    }
}

实例二：通过url下载网络资源

//通过URL爬取网络歌曲
package com.xiaoxiao.URL;

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

public class URLDEmo02 {
    public static void main(String[] args) throws Exception {
        //创建一个url
        URL url = new URL("https://m701.music.126.net/20220522003909/b2e8d67e1ad71caf7c45227a9e441d23/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/14550490581/8fba/1680/7886/e3c12c9268d5987126d4e92727a1d71f.m4a");
        //打开连接URLConnection为抽象类，HttpURLConnection是他的子类
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        //获取连接的输入流
        InputStream is = urlConnection.getInputStream();

        FileOutputStream fos=new FileOutputStream("src/com/xiaoxiao/URL/test.m4a");
        byte[] buffer=new byte[1024];
        int len;
        while((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        fos.close();
        is.close();
        urlConnection.disconnect();

    }
}

java网络编程