Java教程

Java学习-第一部分-第三阶段-第一节:网络编程

本文主要是介绍Java学习-第一部分-第三阶段-第一节:网络编程,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

网络编程

笔记目录:(https://www.cnblogs.com/wenjie2000/p/16378441.html)

网络基础

网络通信

  1. 概念:两台设备之间通过网络实现数据传输
  2. 网络通信:将数据通过网络从一台设备传输到另一台设备
  3. java.net包下提供了一系列的类或接口,供程序员使用,完成网络通信

网络

  1. 概念:两台或多台设备通过一定物理设备连接起来构成了网络

  2. 根据网络的覆盖范围不同,对网络进行分类:

    局域网:覆盖范围最小,仅仅覆盖一个教室或一个机房
    城域网:覆盖范围较大,可以覆盖一个城市
    广域网:覆盖范围最大,可以覆盖全国,甚至全球,万维网是广域网的代表

ip地址

  1. 概念:用于唯一标识网络中的每台计算机

  2. 查看ip地址: ipconfig

  3. ip地址的表示形式:点分十进制XX.XX.XX.XX

  4. 每一个十进制数的范围:0~255

  5. ip地址的组成=网络地址+主机地址,比如:192.168.16.69

  6. IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议,其地址数量号称可以为全世界的每一粒沙子编上一个地址[1]。

  7. 由于IPv4最大的问题在于网络地址资源有限,严重制约了互联网的应用和发展。IPv6的使用,不仅能解决网络地址资源数量的问题,而且也解决了多种接入设备连入互联的障碍

ipv4地址分类

image

image

域名

  1. www.baidu.com
  2. 好处:为了方便记忆,解决记ip的困难
  3. 概念:将ip地址映射成域名(这里怎么映射上,HTTP协议)

端口号

  1. 概念:用于标识计算机上某个特定的网络程序

  2. 表示形式:以整数形式,范围0~65535【0--216

  3. 0~1024已经被占用,比如ssh 22, ftp 21, smtp 25 http 80(在网络开发中,不要使用0-1024的端口名花有主.)

  4. 常见的网络程序端口号:
    tomcat :8080
    mysql:3306

    oracle:1521

    salserver:1433

网络通讯协议

网络通信协议(tcp/ip)

TCP/IP (Transmission ControlProtocol/Internet Protocol)的简写.中文译名为传输控制协议/因特网互联协议,又叫网络通讯协议,这个协议是lnternet最基本的协议、Internet国际互联网络的基础,简单地说,就是由网络层的IP协议和传输层的TCP协议组成的。[示意图]

image

网络通讯协议

image

TCP和UDP

TCP协议:传输控制协议

  1. 使用TCP协议前,须先建立TCP连接,形成传输数据通道
  2. 传输前,采用"三次握手"方式,是可靠的
  3. TCP协议进行通信的两个应用进程:客户端、服务端
  4. 在连接中可进行大数据量的传输
  5. 传输完毕,需释放已建立的连接,效率低
  6. 举例:打电话

UDP协议:用户数据协议

  1. 将数据、源、目的封装成数据包,不需要建立连接
  2. 每个数据报的大小限制在64K内,不适合传输大量数据
  3. 因无需连接,故是不可靠的
  4. 发送数据结束时无需释放资源(因为不是面向连接的),速度快
  5. 举例:厕所通知,发短信,QQ给某人发消息 (直接发信息,不管是否能收到)

InetAddress

  1. 获取本机InetAddress对象getLocalHost
  2. 根据指定主机名/域名获取ip地址对象getByName
  3. 获取lnetAddress对象的主机名getHostName
  4. 获取InetAddress对象的地址getHostAddress
public static void main(String[] args) throws UnknownHostException {
    InetAddress localHost = InetAddress.getLocalHost();
    System.out.println(localHost);//DESKTOP-VUTHVJ2/192.168.1.173

    //2.根据指定主机名或ip获取InetAddress对象
    InetAddress host1 = InetAddress.getByName("DESKTOP-VUTHVJ2");
    System.out.println("host1=" + host1); //DESKTOP-VUTHVJ2/192.168.1.173

    //3.根据域名返回InetAddress对象,比如 www.baidu.com对应
    InetAddress host2 = InetAddress.getByName("www.baidu.com");
    System.out.println(host2);//www.baidu.com/39.156.66.14

    //4,通过InetAddress对象,获取对应的地址
    String hostAddress = host2.getHostAddress();
    System.out.println(hostAddress);//39.156.66.14

    //5.通过InetAddress对象,获取对应的主机名/或者的域名
    String hostName = host2.getHostName();
    System.out.println(hostName);//www.baidu.com
}

Socket

基本介绍

  1. 套接字(Socket)开发网络应用程序被广泛采用,以至于成为事实上的标准。
  2. 通信的两端都要有Socket,是两台机器间通信的端点
  3. 网络通信其实就是Socket|间的通信。
  4. Socket允许程序把网络连接当成一个流,数据在两个Socket间通过IO传输。
  5. 一般主动发起通信的应用程序属客户端,等待通信请求的为服务端

示意图

image

TCP网络通信编程

基本介绍

  1. 基于客户端服务端的网络通信
  2. 底层使用的是TCP/IP协议
  3. 应用场景举例:客户端发送数据,服务端接受并显示控制台
  4. 基于Socket的TCP编程

image

应用案例1(使用字节流)

  1. 编写一个服务器端,和一个客户端

  2. 服务器端在9999端口监听

  3. 客户端连接到服务器端,,发送"hello, server",然后退出

  4. 服务器端接收到客户端发送的信息,输出,并退出

    image

    服务器代码

    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class SocketTCP01Server {
        public static void main(String[] args) throws IOException {
            //思路
            //1.在本机的9999端口监听,等待连接
            //细节:要求在本机没有其它服务在监听9999
            ServerSocket serverSocket = new ServerSocket(9999);
            System.out.println("服务端,在9999端口监听,等待连接..");
            //2.当没有客户端连接9999端口时,程序会阻塞,等待连接
            //如果有客户端连接,则会返回Socket对象,程序继续
            //细节:这个ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
            Socket socket = serverSocket.accept();
            System.out.println("服务器端socket ="+socket.getClass());
            //
            //3.通过socket.getInputStream()读取
            InputStream inputStream = socket.getInputStream();
            //4.IO读取
            byte[] bytes = new byte[8];
            int readLen=0;
            while ((readLen=inputStream.read(bytes))!=-1){
                System.out.print(new String(bytes,0,readLen));
            }
            //5.关闭流和socket
            inputStream.close();
            socket.close();
            serverSocket.close();
            //客户端写入到数据通道的数据,显示
        }
    }
    

    客户端代码

    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    public class SocketTCP01Client {
        public static void main(String[] args) throws IOException {
            //思路
            //1。连接服务端(ip,端口)
            //解读:连接本机的9999端口,如果连接成功,返回Socket对象
            Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
            System.out.println("客户端socket返回=" + socket.getClass());
            //2.连接上后,生成Socket,通过socket.getOutputStream()
            //得到和socket对象关联的输出流对象
            OutputStream outputStream = socket.getOutputStream();
            //3.通过输出流,写入数据到数据通道
            outputStream.write("hello,world".getBytes());
            //关闭流对象
            outputStream.close();
            socket.close();
            System.out.println("客户端退出");
        }
    }
    

应用案例2(使用字节流)

  1. 编写一个服务嚣端,和一个客户端

  2. 服务器端在9999端口监听

  3. 客户端连接到服务器端,发送"hello, server",并接收服务器端回发的"hello,client",再退出

  4. 服务器端接收到客户端发送的信息,输出,并发送"hello, client",再退出

    示意图

    image

    服务器代码

    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class SocketTCP01Server {
        public static void main(String[] args) throws IOException {
            //思路
            //1.在本机的9999端口监听,等待连接
            //细节:要求在本机没有其它服务在监听9999
            ServerSocket serverSocket = new ServerSocket(9999);
            System.out.println("服务端,在9999端口监听,等待连接..");
            //2.当没有客户端连接9999端口时,程序会阻塞,等待连接
            //如果有客户端连接,则会返回Socket对象,程序继续
            //细节:这个ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
            Socket socket = serverSocket.accept();
            System.out.println("服务器端socket ="+socket.getClass());
            //
            //3.通过socket.getInputStream()读取
            InputStream inputStream = socket.getInputStream();
            //4.IO读取
            byte[] bytes = new byte[8];
            int readLen=0;
            while ((readLen=inputStream.read(bytes))!=-1){
                System.out.print(new String(bytes,0,readLen));
            }
            
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("hello, client".getBytes());
            //设置结束标记
            socket.shutdownOutput();
    
            //5.关闭流和socket
            inputStream.close();
            outputStream.close();
            socket.close();
            serverSocket.close();
            //客户端写入到数据通道的数据,显示
        }
    }
    

    客户端代码

    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    public class SocketTCP01Client {
        public static void main(String[] args) throws IOException {
            //思路
            //1。连接服务端(ip,端口)
            //解读:连接本机的9999端口,如果连接成功,返回Socket对象
            Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
            System.out.println("客户端socket返回=" + socket.getClass());
            //2.连接上后,生成Socket,通过socket.getOutputStream()
            //得到和socket对象关联的输出流对象
            OutputStream outputStream = socket.getOutputStream();
            //3.通过输出流,写入数据到数据通道
            outputStream.write("hello,server".getBytes());
            //设置结束标记
            socket.shutdownOutput();
    
            InputStream inputStream = socket.getInputStream();
            int readLen=0;
            byte[] bytes = new byte[8];
            while ((readLen=inputStream.read(bytes))!=-1){
                System.out.print(new String(bytes,0,readLen));
            }
            //关闭流对象
            inputStream.close();
            outputStream.close();
            socket.close();
            System.out.println("客户端退出");
    
        }
    }
    

应用案例3(使用字符流)

  1. 编写一个服务端,和一个客户端

  2. 服务端在9999端口监听

  3. 客户端连接到服务端,发送"hello, server",并接收服务端回发的"hello,client",再退出

  4. 服务端接收到客户端发送的信息,输出,并发送"hello, client",再退出

    示意图

    image

    服务器端代码

    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class SocketTCP01Server {
        public static void main(String[] args) throws IOException {
            //思路
            //1.在本机的9999端口监听,等待连接
            //细节:要求在本机没有其它服务在监听9999
            ServerSocket serverSocket = new ServerSocket(9999);
            System.out.println("服务端,在9999端口监听,等待连接..");
            //2.当没有客户端连接9999端口时,程序会阻塞,等待连接
            //如果有客户端连接,则会返回Socket对象,程序继续
            //细节:这个ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
            Socket socket = serverSocket.accept();
            System.out.println("服务器端socket ="+socket.getClass());
            //
            //3.通过socket.getInputStream()读取
            InputStream inputStream = socket.getInputStream();
            //4.IO读取,使用字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String s = bufferedReader.readLine();
            System.out.println(s);
    
            //获取socket关联的输出流
            OutputStream outputStream = socket.getOutputStream();
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
            bufferedWriter.write("hello, client 字符流");
            bufferedWriter.newLine();//表示恢复内容结束
            bufferedWriter.flush();
    
    
            //5.关闭流和socket
            bufferedReader.close();
            bufferedWriter.close();
            socket.close();
            serverSocket.close();
            //客户端写入到数据通道的数据,显示
        }
    }
    

    客户端代码

    import java.io.*;
    import java.net.InetAddress;
    import java.net.Socket;
    
    public class SocketTCP01Client {
        public static void main(String[] args) throws IOException {
            //思路
            //1。连接服务端(ip,端口)
            //解读:连接本机的9999端口,如果连接成功,返回Socket对象
            Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
            System.out.println("客户端socket返回=" + socket.getClass());
            //2.连接上后,生成Socket,通过socket.getOutputStream()
            //得到和socket对象关联的输出流对象
            OutputStream outputStream = socket.getOutputStream();
            //3.通过输出流,写入数据到数据通道,使用字符流
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
            bufferedWriter.write("hello,server 字符流");
            bufferedWriter.newLine();//插入一个换行符,表示写入的内容结束,注意,要求对方使用readLine()!!否者读不到结束
            bufferedWriter.flush();//如果使用的字符流,需要手动刷新,否则数据不会写入数据通道
    
            //4。获取和socket关联的输入流。读取数据(字符),并显示
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String s = bufferedReader.readLine();
            System.out.println(s);
    
            //关闭流对象
            bufferedReader.close();//关闭外层流
            bufferedWriter.close();
            socket.close();
            System.out.println("客户端退出");
    
        }
    }
    

应用案例4

  1. 编写一个服务端,和一个客户端

  2. 服务器端在8888端口监听

  3. 客户端连接到服务端,发送一张图片d:\qie.png

  4. 服务器端接收到客户端发送的图片,保存到src下,发送"收到图片”再退出

  5. 客户端接收到服务端发送的“收到图片”,再退出

    服务器端代码

    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class SocketTCP01Server {
        public static void main(String[] args) throws IOException {
    
            ServerSocket serverSocket = new ServerSocket(8888);
            System.out.println("服务端,在8888端口监听,等待连接..");
            Socket socket = serverSocket.accept();
            System.out.println("服务器端socket =" + socket.getClass());
            InputStream inputStream = socket.getInputStream();
    
            FileOutputStream fileOutputStream = new FileOutputStream("src\\(1).png");
            byte[] bytes = new byte[1024];
            int readLen;
            while ((readLen = inputStream.read(bytes)) != -1) {
                 fileOutputStream.write(bytes,0,readLen);
            }
            System.out.println("收到");
    
            OutputStream outputStream = socket.getOutputStream();
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
            outputStreamWriter.write("收到图片");
            outputStreamWriter.flush();
            socket.shutdownOutput();
    
            outputStreamWriter.close();
            fileOutputStream.close();
            inputStream.close();
            socket.close();
            serverSocket.close();
    
            System.out.println("服务器端结束");
        }
    }
    

    客户端代码

    import java.io.*;
    import java.net.InetAddress;
    import java.net.Socket;
    //代码还可以继续优化
    public class SocketTCP01Client {
        public static void main(String[] args) throws IOException {
            Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
            System.out.println("客户端socket返回=" + socket.getClass());
    
            FileInputStream fileInputStream = new FileInputStream("D:\\(1).png");
            byte[] bytes = new byte[1024];
            int len;
            OutputStream outputStream = socket.getOutputStream();
            while ((len = fileInputStream.read(bytes)) != -1) {
                outputStream.write(bytes,0,len);
            }
            socket.shutdownOutput();
    
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            System.out.println(bufferedReader.readLine());
    
            bufferedReader.close();
            outputStream.close();
            fileInputStream.close();
            socket.close();
    
            System.out.println("客户端退出");
        }
    }
    

编程题

  1. 编写客户端程序和服务器端程序

  2. 客户端可以输入一个音乐文件名,比如高山流水,服务端收到音乐名后,可以给客户端返回这个音乐文件,如果服务器没有这个文件,返回一个默认的音乐即可.

  3. 客户端收到文件后,保存到本地d:\\

  4. 提示:该程序可以使用StreamUtils.java
    本质:其实就是指定下载文件的应用.结合文件上传来做。

    服务器端 代码

    import java.io.*;
    import java.net.*;
    
    //服务器端
    public class B {
        public static void main(String[] args) throws IOException {
            ServerSocket serverSocket = new ServerSocket(9000);
            Socket socket = serverSocket.accept();
            InputStream inputStream = socket.getInputStream();
    
            byte[] bytes = new byte[1024];
            int bytesLen;
            String s="";
            while ((bytesLen=inputStream.read(bytes))!=-1){
                s+=new String(bytes,0,bytesLen);
            }
    
            File file = new File("src\\",s);
            System.out.println("文件名:" +file.getPath());
            BufferedInputStream bufferedInputStream;
            if (file.exists()) {
                System.out.println("找到文件");
                bufferedInputStream= new BufferedInputStream(new FileInputStream(file));
            }else {
                System.out.println("未找到该文件");
                bufferedInputStream= new BufferedInputStream(new FileInputStream("src\\22.mp4"));
            }
    
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            while ((bytesLen=bufferedInputStream.read(bytes))!=-1){
                byteArrayOutputStream.write(bytes,0,bytesLen);
            }
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(socket.getOutputStream());
            bytes = byteArrayOutputStream.toByteArray();
            bufferedOutputStream.write(bytes);
            bufferedOutputStream.flush();
            socket.shutdownOutput();
    
            bufferedOutputStream.close();
            bufferedInputStream.close();
            socket.close();
            serverSocket.close();
        }
    }
    

    客户端 代码

    import java.io.*;
    import java.net.InetAddress;
    import java.net.Socket;
    import java.util.Scanner;
    
    
    //客户端
    public class A {
        public static void main(String[] args) throws IOException {
            Socket socket = new Socket(InetAddress.getLocalHost(), 9000);
            OutputStream outputStream = socket.getOutputStream();
    
            System.out.println("请输入文件名:");
            Scanner scanner = new Scanner(System.in);
            String s = scanner.next();
            outputStream.write(s.getBytes());
            socket.shutdownOutput();
            System.out.println("等待中");
    
            BufferedInputStream bufferedInputStream = new BufferedInputStream(socket.getInputStream());
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] bytes = new byte[1024];
            int bytesLen;
            while ((bytesLen=bufferedInputStream.read(bytes))!=-1){
                byteArrayOutputStream.write(bytes,0,bytesLen);
            }
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("d:\\"+s));
            bufferedOutputStream.write(byteArrayOutputStream.toByteArray());
    
            bufferedOutputStream.close();
            byteArrayOutputStream.close();
            bufferedInputStream.close();
            outputStream.close();
            socket.close();
        }
    }
    

netstat 指令

  1. netstat -an可以查看当前主机网络情况,包括端口监听情况和网络连接情况(netstat -anb 可以看到哪个程序在使用这些端口)

  2. netstat -an | more可以分页显示

  3. 要求在dos控制台下执行

说明:
(1) Listening表示某个端口在监听
(2)如果有一个外部程序(客户端)连接到该端口,就会显示一条连接信息.

(3)可以输入ctrl +c退出指令

TCP网络通讯不为人知的秘密

  1. 当客户端连接到服务端后,实际上客户端也是通过一个端口和服务端进行通讯的,这
    个端口是TCP/IP来分配的,是不确定的。
  2. 程序验证

UDP编程

基本介绍

  1. 类 DatagramSocket和 DatagramPacket实现了基于UDP协议网络程序。

  2. UDP数据报通过数据报套接字DatagramSocket发送和接收,系统不保证UDP数据报一定能够安全送到目的地,也不能确定什么时候可以抵达。

  3. DatagramPacket 对象封装了UDP数据报,在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。

  4. UDP协议中每个数据报都给出了完整的地址信息,因此无须建立发送方和接收方的连接

基本流程

  1. 核心的两个类/对象DatagramSocket与DatagramPacket
  2. 建立发送端,接收端
  3. 建立数据包
  4. 调用DatagramSocket的发送、接收方法5.关闭DatagramSocket

image

应用案例

  1. 编写一个接收端A,和一个发送端B
  2. 接收端A在9999端口等待接收数据(receive)
  3. 发送端B向接收端A发送数据"hello,明天吃火锅~"
  4. 接收端A接收到发送端B发送的数据,回复"好的,明天见",再退出
  5. 发送端接收回复的数据,再退出

A端口 代码

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

public class A {
    public static void main(String[] args) throws IOException {
        //1。创建一个DatagramSocket对象,准备在9999接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2。构建一个DatagramPacket 对象,准备接收数据
        //在前面讲解UDP协议时,一个数据包最大64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        //3.调用接收方法,将通过网络传输的DatagramPacket对象
        // 填充到 packet对象
        //提示:当有数据包发送到本机的9999端口时,就会接收到数据
        // 如果没有数据包发送到本机的9999端口,就会阻塞等待。
        System.out.println("接收端A等待接收数据..");
        socket.receive(packet);

        //4。可以把packet进行拆包,取出数据,并显示。
        int length = packet.getLength();//实际接收到的数据字节长度
        byte[] data = packet.getData();//接收到数据
        String s = new String(data, 0, length);
        System.out.println(s);

        data="好的,明天见".getBytes();
        DatagramPacket packet1 = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.1.173"), 9998);
        socket.send(packet1);

        socket.close();

        System.out.println("A退出");
    }
}

B端口代码

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

public class B {
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket对象,准备在9998端口接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        //2.将需要发送的数据,封装到DatagramPacket对象
        byte[] data="hello,明天吃火锅~".getBytes();
        //说明:封装的DatagramPacket对象 data 内容字节数组,data.length ,主机(IP),端口
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.1.173"), 9999);
        socket.send(packet);

        System.out.println("接收端B等待回复数据..");
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        socket.receive(packet);

        //4。可以把packet进行拆包,取出数据,并显示。
        int length = packet.getLength();//实际接收到的数据字节长度
        data = packet.getData();//接收到数据
        String s = new String(data, 0, length);
        System.out.println(s);

        //关闭资源
        socket.close();
        System.out.println("B退出");

    }
}
这篇关于Java学习-第一部分-第三阶段-第一节:网络编程的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!