[网络协议]day27：网络编程

网络编程概述

网络通信要素概述

IP 和端口号
网络通信协议

 一、网络编程中有两个主要的问题：
    1、如何准确地定位网络上一台或多台主机：定位主机上特定的应用
    2、找到主机后如何可靠高效的进行数据传输

 二、网络编程中的两个要素：
    1、对应问题一：IP 和端口号
    2、对应问题二、提供网络通信协议：TCP/IP 参考模型（应用层、传输层、网络层、物理+数据链路层）

通信要素1：IP和端口号

同一台主机上的两个不同的进程不能使用相同的端口号。

InetAdress 类

通信要素一：IP和端口号
 1、IP：唯一的标识 Internet 上的计算机（通信实体）
 2、在java中使用 InetAddress 类代表IP
 3、IP的分类：IPv4和IPv6；万维网和局域网
 4、域名：www.baidu.com   www.mi.com    DNS域名解析
 5、本地贿赂地址：127.0.0.1     对应着：localhost
 6、如何实例化 InetAddress : 两个方法
    getByName(String host)
    getLocalHost()
    两个常用方法：getHostName() / getHostAddress()
 7、端口号：标识正在计算机上运行的进程（程序）
    要求：不同的进程有不同的端口号
    范围：被规定为一个 16 位的整数 0~65535。
 8、端口号与IP地址的组合得出了一个网络套接字：Socket

import java.net.InetAddress;
import java.net.UnknownHostException;
public class InetAddressTest {
    public static void main(String[] args) {
        try {

            InetAddress int1 = InetAddress.getByName("192.168.163.138");//  /192.168.163.138    不需要进行域名解析
            System.out.println(int1);

            InetAddress int2 = InetAddress.getByName("www.baidu.com");//    www.baidu.com/183.232.231.172   域名解析
            System.out.println(int2);

            //获取本机地址
            InetAddress localHost1 = InetAddress.getByName("127.0.0.1");
            System.out.println(localHost1);//    /127.0.0.1

            InetAddress localHost2 = InetAddress.getLocalHost();
            System.out.println();//   DESKTOP-L1HEFJK/192.168.**.*    获取本机地址

            //getHostName()
            //getHostAddress()
            InetAddress jd = InetAddress.getByName("www.jd.com");
            System.out.println(jd.getHostName());//www.jd.com   获取域名
            System.out.println(jd.getHostAddress());//39.175.102.3  获取主机地址


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

通信要素2：网络协议

Socket

TCP网络编程

例子1：客户端发送信息给服务端，服务端将数据信息显示在控制台上

import org.junit.jupiter.api.Test;

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

/**
 实现TCP的网络编程
 例子1：客户端发送信息给服务端，服务端将数据信息显示在控制台上
 */
public class TCPTest1 {
    //客户端
    @Test
    public void client(){

        Socket socket = null;
        OutputStream os = null;
        try {
            //1、创建 Socket 对象，指明服务器端的 IP 和端口号
            InetAddress inet = InetAddress.getByName("127.0.0.1");//对方的IP,当前为本地地址，
            socket = new Socket(inet,8899);//对方的端口号和IP地址

            //2、获取一个输出流，用于输出数据
            os = socket.getOutputStream();
            //写出数据的操作
            os.write("你好，这是客户端".getBytes());


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //资源的关闭
            try {
                if (os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
    //服务端
    @Test
    public void server() {

        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //创建服务器短的Socket ServerSocket，指明自己的端口号
            ss = new ServerSocket(8899);
            //2、调用 accept() 表示接收来自于客户端的 socket
            socket = ss.accept();
            //3、获取输入流
            is = socket.getInputStream();

            //读取输入流当中的数据
            //不建议，会出现乱码
//        byte[] buffer = new byte[20];
//        int len;
//        while ((len = is.read(buffer)) != -1){
//            String str = new String(buffer,0,len);
//            System.out.println(str);
//        }
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[5];
            int len;
            while((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len);
            }
            System.out.println(baos.toString());

            System.out.println("收到了来自于："+socket.getInetAddress().getHostAddress()+"的数据");//获取对方的IP地址

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

}

例题2：客户端发送文件给服务端，服务端将文件保存在本地。

import org.junit.jupiter.api.Test;

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

/**
 例题2.客户端发送文件给服务端，服务端将文件保存在本地。

 */
public class TCPTest2 {
    @Test
    public void client() {
        OutputStream os = null;
        FileInputStream fis = null;
        try {
            //创建 Socket
            Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
            //获取一个输出流和一个输入流
            os = socket.getOutputStream();
            fis = new FileInputStream("1.jpg");//若找不到指定文件，服务端仍收到文件，但不能打开
            //具体读写出操作
            byte[] buffer = new byte[1024];
            int len;
            while((len=fis.read(buffer))!=-1){
                os.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流资源
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void server() {
        ServerSocket ss = null;
        Socket accept = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            //创建 ServerSocket
            ss = new ServerSocket(9090);
            //获取可客户端的Socket
            accept = ss.accept();
            //获取客户端的输入流
            is = accept.getInputStream();
            //保存数据到本地，新建一个输出流
            fos = new FileOutputStream("2.jpg");
            //具体的读写操作
            byte[] buffer = new byte[5];
            int len;
            while((len=is.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流资源
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (accept != null) {
                try {
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

例题3：从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。并关闭相应的连接。

import org.junit.jupiter.api.Test;

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

/**
 例题3.从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。并关闭相应的连接。
 可从例题2的条件下添加功能
 */
public class TCPTest3 {
    @Test
    public void client() {
        OutputStream os = null;
        FileInputStream fis = null;
        ByteArrayOutputStream baos=null;
        try {
            //创建 Socket
            Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
            //获取一个输出流和一个输入流
            os = socket.getOutputStream();
            fis = new FileInputStream("1.jpg");//若找不到指定文件，服务端仍收到文件，但不能打开

            //具体读写出操作
            byte[] buffer = new byte[1024];
            int len;
            while((len=fis.read(buffer))!=-1){
                os.write(buffer,0,len);
            }

            
//*********************************************************
			socket.shutdownOutput();//表示图片数据已传输完成
			
            //接受来自于服务器端的数据，并显示在控制台上
            InputStream is = socket.getInputStream();
            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());
//***********************************************************
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流资源
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //*********************************************************
    @Test
    public void server() {
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        OutputStream os=null;
        try {
            //创建 ServerSocket
            ss = new ServerSocket(9090);
            //获取可客户端的Socket
            socket = ss.accept();
            //获取客户端的输入流
            is = socket.getInputStream();
            //保存数据到本地，新建一个输出流
            fos = new FileOutputStream("2.jpg");
            //具体的读写操作
            byte[] buffer = new byte[5];
            int len;
            while((len=is.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
//*********************************************************
//            System.out.println("图片传输完成");//若没有在客户端中告知图片传输完成，会出现阻塞，并卡在此代码之前
            //服务器端给客户端反馈
            os = socket.getOutputStream();
            os.write("文件已接收".getBytes());
//*********************************************************
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流资源
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

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

/**
 1.服务端读取图片并发送给客户端，客户端保存图片到本地,客户端给服务器发送信息表示已收到，服务器接收并在控制台输出
 此时的异常依然使用 try-catch-finally处理，此处便于观察流程使用 throws
 */
public class TCPTest4 {
    @Test
    public void client() throws IOException {
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9988);
        InputStream is = socket.getInputStream();
        FileOutputStream fos = new FileOutputStream("3.jpg");
        byte[] buffer = new byte[20];
        int len;
        while((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }

        OutputStream os = socket.getOutputStream();
        os.write("文件已收到".getBytes());

        socket.close();
        is.close();
        fos.close();
        os.close();

    }
    //********************************************************
    @Test
    public void server() throws IOException {
        ServerSocket ss = new ServerSocket(9988);
        Socket socket = ss.accept();
        FileInputStream fis= new FileInputStream("1.jpg");
        OutputStream os = socket.getOutputStream();
        byte[] buffer = new byte[20];
        int len;
        while((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }
        socket.shutdownOutput();

        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[20];
        int len2;
        while((len2=is.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }
        System.out.println(baos.toString());
        ss.close();
        socket.close();
        fis.close();
        os.close();
        is.close();
        baos.close();
    }
}

import org.junit.jupiter.api.Test;

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

/**
 2.客户端给服务端发送文本，服务端会将文本转成大写在返回给客户端。
 */
public class TCPTest5 {
    @Test
    public void client() throws IOException {
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9990);
        OutputStream os = socket.getOutputStream();
        os.write("abcdefghijklmm".getBytes());
        socket.shutdownOutput();//要进行下面的操作，需将输出终止

        InputStream is = socket.getInputStream();
        byte[] buffer = new byte[20];
        int len;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        while ((len=is.read(buffer))!=-1){
            baos.write(buffer,0,len);
        }
        System.out.println(baos.toString());
        socket.close();
        os.close();
        is.close();
        baos.close();
    }
    @Test
    public void server() throws IOException {
        ServerSocket ss = new ServerSocket(9990);
        Socket socket = ss.accept();
        InputStream is = socket.getInputStream();
        byte[] buffer = new byte[20];
        int len;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        while ((len=is.read(buffer))!=-1){
            baos.write(buffer,0,len);
        }
        String str = baos.toString().toUpperCase();

        OutputStream os = socket.getOutputStream();
        os.write(str.getBytes());

        ss.close();
        socket.close();
        is.close();
        baos.close();
        os.close();
    }
}

UDP网络编程

UDP 是一种不可靠链接

UDP协议：数据报限定为64kb，效率高但不可靠。
TCP协议：进行大量数据传输，效率低但可靠。

DatagramSocket 类的常用方法

DatagramPacket类的常用方法

import org.junit.jupiter.api.Test;

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

/**
 UDP 协议的网络编程
 */
public class UDPTest {
    //发送端
    @Test
    public void sender() throws IOException {
        DatagramSocket socket = new DatagramSocket();
        String str = "UDP 方式发送数据！";
        byte[] data = str.getBytes();
        InetAddress inet = InetAddress.getLocalHost();
        DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);//丰庄数据报,UDP的数据都封装在Packet

        socket.send(packet);

        socket.close();
    }
    //接收端
    @Test
    public void receiver() throws IOException {
        DatagramSocket socket = new DatagramSocket(9090);//指明端口号
        byte[] buffer = new byte[100];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
        socket.receive(packet);

        System.out.println(new String(packet.getData(),0,packet.getLength()));

        socket.close();
    }
}

URL编程

URL类

URL：统一资源定位符

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

/**
 URL 网咯编程
 1、URL：统一资源定位符，对应着互联网上的某一资源地址
 URL的基本结构由5部分组成：
    <传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表
    https://localhost:8080/资源地址
    协议  主机名   端口号   具体资源地址
 */
public class URLTest {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://localhost:8080//workspace//InetAddressTest//1.jpg");//参数为资源地址

            //?public String getProtocol( ) 获取该URL的协议名
            System.out.println(url.getProtocol());
            //?public String getHost( ) 获取该URL的主机名
            System.out.println(url.getHost());
            //?public String getPort( ) 获取该URL的端口号
            System.out.println(url.getPort());
            //?public String getPath( ) 获取该URL的文件路径
            System.out.println(url.getPath());
            //?public String getFile( ) 获取该URL的文件名
            System.out.println(url.getFile());
            //?public String getQuery( ) 获取该URL的查询名
            System.out.println(url.getQuery());

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

针对HTTP协议的URLConnection类

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

/**
 * @Discription:
 */
public class URLTest2 {
    public static void main(String[] args) {
        HttpURLConnection urlConnection = null;//获取到服务器的链接
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            URL url = new URL("https://scpic.chinaz.net/files/pic/pic9/202009/apic27858.jpg");
            urlConnection = (HttpURLConnection) url.openConnection();

            urlConnection.connect();//获取连接，访问服务器
            is = urlConnection.getInputStream();
            fos = new FileOutputStream("5.jpg");

            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }



        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (urlConnection != null) {
                urlConnection.disconnect();//断开连接
            }

        }

    }
}

URI、URL和URN的区别

小 结