概述

计算机网络

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

网络编程

网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。

JavaWeb：网页编程 B/S

网络编程：TCP/IP C/S

网路通信的要素

如何实现网络的通信？

通信双方地址：

IP
端口号
192.168.123.1:8080

规则：网络通信的协议

OSI 七层模型和TCP/IP参考模型：

Java 网络编程

小结

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

IP

IP地址：InetAddress

唯一定位一台网络上计算机
127.0.0.1：本机localhost
IP地址的分类
- ipv4/ipv6
  - IPV4 127.0.0.1，4个字节组成。0~255，42亿。
  - IPV6 2001:0DB8:0000:0023:0008:0800:200C:417A，128位。8个无符号整数。
- 公网（互联网）- 私网（局域网）
  - 192.168.xxx.xxx 局域网
  - IP地址分类
域名：记忆IP问题

例子：

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

运行结果：

www.baidu.com/163.177.151.110
DESKTOP-QOS6ALD/192.168.123.7
[B@2f7a2457
163.177.151.110
163.177.151.110
www.baidu.com

端口

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

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

端口分类

公有端口0~1023
- HTTP：80
- HTTPS：443
- FTP：21
- Telnet：23
程序注册端口：2014~49151，分配用户或者程序
- Tomcat：8080
- MySQL：3306
- Oracle：1521

动态、私有：49152~65535

netstat -ano#查看所有端口
netstat -ano|findstr "5900"#查看指定端口
tasklist|findstr "8696" #查看指定端口的进程

public class TestInetSocketAddress {
       
    public static void main(String[] args){
       
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress inetSocketAddress2 = new InetSocketAddress("localhost", 8080);
        System.out.println(inetSocketAddress);
        System.out.println(inetSocketAddress2);
        System.out.println(inetSocketAddress.getAddress());
        System.out.println(inetSocketAddress.getHostName());
        System.out.println(inetSocketAddress.getPort());
        System.out.println(inetSocketAddress.getHostString());
    }
}

通信协议

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

TCP/IP协议簇

重要：

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

TCP 和 UDP 对比

TCP：打电话

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

三次握手过程理解

第一次握手：建立连接时，客户端发送syn包（syn=j）到服务器，并进入SYN_SENT状态，等待服务器确认；SYN：同步序列编号（Synchronize Sequence Numbers）。

第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；

第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1），此包发送完毕，客户端和服务器进入ESTABLISHED（TCP连接成功）状态，完成三次握手。

四次挥手过程理解

1）客户端进程发出连接释放报文，并且停止发送数据。释放数据报文首部，FIN=1，其序列号为seq=u（等于前面已经传送过来的数据的最后一个字节的序号加1），此时，客户端进入FIN-WAIT-1（终止等待1）状态。 TCP规定，FIN报文段即使不携带数据，也要消耗一个序号。
2）服务器收到连接释放报文，发出确认报文，ACK=1，ack=u+1，并且带上自己的序列号seq=v，此时，服务端就进入了CLOSE-WAIT（关闭等待）状态。TCP服务器通知高层的应用进程，客户端向服务器的方向就释放了，这时候处于半关闭状态，即客户端已经没有数据要发送了，但是服务器若发送数据，客户端依然要接受。这个状态还要持续一段时间，也就是整个CLOSE-WAIT状态持续的时间。
3）客户端收到服务器的确认请求后，此时，客户端就进入FIN-WAIT-2（终止等待2）状态，等待服务器发送连接释放报文（在这之前还需要接受服务器发送的最后的数据）。
4）服务器将最后的数据发送完毕后，就向客户端发送连接释放报文，FIN=1，ack=u+1，由于在半关闭状态，服务器很可能又发送了一些数据，假定此时的序列号为seq=w，此时，服务器就进入了LAST-ACK（最后确认）状态，等待客户端的确认。
5）客户端收到服务器的连接释放报文后，必须发出确认，ACK=1，ack=w+1，而自己的序列号是seq=u+1，此时，客户端就进入了TIME-WAIT（时间等待）状态。注意此时TCP连接还没有释放，必须经过2∗∗MSL（最长报文段寿命）的时间后，当客户端撤销相应的TCB后，才进入CLOSED状态。
6）服务器只要收到了客户端发出的确认，立即进入CLOSED状态。同样，撤销TCB后，就结束了这次的TCP连接。可以看到，服务器结束TCP连接的时间要比客户端早一些。
客户端、服务端
传输完成，释放连接，效率低

UDP：发短信

不连接，不稳定
客户端、服务端：没有明确的界限
不管有没有准备好，都可以发给你

TCP

客户端

连接服务器Socket

发送信息

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;

/** * ClassName:TcpClientDemo1 * Package:com.company.network * Description: * 客户端 * * @date:2021/3/18 22:44 * @author:yt */

public class TcpClientDemo1 {
     
    public static void main(String[] args) {
     
        Socket socket = null;
        OutputStream os = null;
        try {
     
            //1.要知道服务器地址
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2.创建Socket连接
            socket = new Socket(inetAddress, port);
            //3.发送消息IO流
            os = socket.getOutputStream();
            os.write("你好！".getBytes(StandardCharsets.UTF_8));
        } catch (UnknownHostException e) {
     
            e.printStackTrace();
        } catch (IOException 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();
                }
            }
        }
    }
}

服务器

建立服务端口ServerSocket
等待用户连接 accept

接受用户的消息

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
/** * ClassName:TcpServerDemo1 * Package:com.company.network * Description: * 服务器 * * @date:2021/3/18 22:45 * @author:yt */
public class TcpServerDemo1 {

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

文件上传

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
/** * ClassName:TcpClientDemo2 * Package:com.company.network * Description: * 客户端 * @date:2021/3/18 23:48 * @author:yt */
public class TcpClientDemo2 {

public static void main(String[] args) throws IOException {

//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("Thread1.jpg"));
//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();
while ((len = is.read(buffer)) != -1) {

baos.write(buffer, 0, len);
}
System.out.println(baos.toString());
//5.关闭资源
baos.close();
is.close();
fis.close();
os.close();
socket.close();
}
}

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
/** * ClassName:TcpServerDemo2 * Package:com.company.network * Description: * 服务器 * @date:2021/3/18 23:57 * @author:yt */
public class TcpServerDemo2 {

public static void main(String[] args) throws IOException {

//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(StandardCharsets.UTF_8));
//关闭资源
os.close();
fos.close();
is.close();
socket.close();
serverSocket.close();
}
}

UDP

发送数据，不用连接，需要对方的地址！

发送消息

客户端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
/** * ClassName:UdpClientDemo1 * Package:com.company.network * Description: * 客户端，不需要连接服务器 * @date:2021/3/19 10:58 * @author:yt */
public class UdpClientDemo1 {

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(StandardCharsets.UTF_8),0,msg.getBytes(StandardCharsets.UTF_8).length,localhost,port);
//3.发送包
socket.send(packet);
//4.关闭资源
socket.close();
}
}

接收端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
/** * ClassName:UdpServerDemo1 * Package:com.company.network * Description: * 服务器，还是要等待客户端连接 * @date:2021/3/19 10:59 * @author:yt */
public class UdpServerDemo1 {

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.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.Scanner;
/** * ClassName:UdpSenderDemo1 * Package:com.company.network.chat * Description: * 发送端 * * @date:2021/3/19 23:58 * @author:yt */
public class UdpSenderDemo1 {

public static void main(String[] args) throws Exception {

DatagramSocket socket = new DatagramSocket(8888);
//准备数据：控制台读取 System.in
Scanner sc = new Scanner(System.in);
while (true) {

String data = sc.nextLine();
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();
sc.close();
}
}

接收端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
/** * ClassName:UdpReceiveDemo1 * Package:com.company.network.chat * Description: * 接收端 * @date:2021/3/19 23:59 * @author:yt */
public class UdpReceiveDemo1 {

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, packet.getLength());
System.out.println(receiveData);
if(receiveData.equals("bye")){

break;
}
}
socket.close();
}
}

咨询

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

发送端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.Scanner;
/** * ClassName:TalkSend * Package:com.company.network.chat * Description: * * @date:2021/3/20 0:43 * @author:yt */
public class TalkSend implements Runnable {

DatagramSocket socket = null;
Scanner sc = 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);
sc = new Scanner(System.in);
} catch (Exception e) {

e.printStackTrace();
}
}
@Override
public void run() {

//准备数据：控制台读取 System.in
while (true) {

String data = sc.nextLine();
byte[] datas = data.getBytes();
DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(this.toIP, this.toPort));
try {

socket.send(packet);
} catch (IOException e) {

e.printStackTrace();
}
if (data.equals("bye")) {

break;
}
}
socket.close();
sc.close();
}
}

接收端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
/** * ClassName:TalkReceive * Package:com.company.network.chat * Description: * * @date:2021/3/20 0:51 * @author:yt */
public class TalkReceive implements Runnable {

DatagramSocket socket = null;
private int port;
private String msgForm;
public TalkReceive(int port, String msgForm) {

this.port = port;
this.msgForm = msgForm;
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, packet.getLength());
System.out.println(msgForm+"： "+receiveData);
if (receiveData.equals("bye")) {

break;
}
} catch (IOException 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

https://www.baidu.com/

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

DNS域名解析：www.baidu.com xxx.xxx.xxx.xxx

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

例子：

public class URLDemo1 {

public static void main(String[] args) throws MalformedURLException {

URL url = new URL("http://localhost:9090/ROOT/index.jsp");
//协议
System.out.println(url.getProtocol());
//主机ip
System.out.println(url.getHost());
//端口
System.out.println(url.getPort());
//路径
System.out.println(url.getPath());
//文件
System.out.println(url.getFile());
//参数
System.out.println(url.getQuery());
}
}

下载网络资源

例子：

public class URLDown {

public static void main(String[] args) throws Exception {

//1.下载地址
URL url = new URL("http://localhost:9090/yt/yt.txt");
//2.连接到这个资源 HTTP
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
InputStream is = urlConnection.getInputStream();
FileOutputStream fos = new FileOutputStream("yt.txt");
byte[] buffer = new byte[1024];
int len;
while ((len=is.read(buffer))!=-1){

fos.write(buffer,0,len);
}
fos.close();
is.close();
urlConnection.disconnect();
}
}

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/114426.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...

Java 网络编程

概述

计算机网络

网络编程

网路通信的要素

IP

端口

通信协议

TCP

文件上传

UDP

发送消息

循环发送消息

咨询

URL

下载网络资源

相关推荐

ps怎么导出图片形式_ps导出图片变色

sourceinsight4.0序列号_source insight 4

【vizard】用python写3D游戏

springboot rabbitmq 之死信队列（延迟消费消息）「建议收藏」

navicat激活码 最新[在线序列号]

matplotlib绘图实例：pyplot、pylab模块及作图参数「建议收藏」

发表回复

navicat激活码最新[在线序列号]