网络编程粗解

1.概述

packet：信息，地址

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

网络编程的目的：

传播交流信息，数据交换。通信

想达到这个效果需要啥：

1. 如何准确的定位网络上的一台主机，端口，定位到这个计算机上的某个资源。


2. 找到主机，如何传输数据？

javaweb：网页编程 b/s

网络编程：TCP/IP c/s

2.网络通信的要素

人工智能：智能汽车，工厂

如何实现网络的通信？

1. 通信双方的地址：
   
   
   
   • ip
   
   
   • 端口号
   
   
   
   


2. 规则（网络通信的协议）
   
   
   
   • TCP/IP 参考模型：OSI七层参考模型，TCP/IP四层概念模型
   
   
   
   

两个主要问题：

1. 如何准确的定位到网络上的一台或多台主机


2. 找到主机如何通信

网络编程的要素：

1. IP和端口号


2. 网络通信协议

java万物皆对象

3.IP

ip地址：inetAddress

• 唯一定位一台网络上的计算机


• 127.0.0.1 本机，localhost


• ip地址的分类
  
  
  
  • ipv4/ipv6
  
  
  • 公网(互联网)/私网(局域网)
    
    
    
    • 192.168.xx.xx专门给组织机构用到
    
    
    
    
  
  
  
  


• 域名：记忆ip问题
  
  
  
  • IP
  
  
  
  

package com.thj.lession1;
import java.net.InetAddress;
import java.net.UnknownHostException;
// 测试ip
public class TestInetAddress {
public static void main(String[] args) {
try {
// 查询本机地址
InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
// 查询网站ip
InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
InetAddress inetAddress3 = InetAddress.getLocalHost();
System.out.println(inetAddress1);
System.out.println(inetAddress2);
System.out.println(inetAddress3);
// 常用方法
// System.out.println(inetAddress1.getAddress());
System.out.println(inetAddress1.getHostName());
System.out.println(inetAddress1.getHostAddress());
System.out.println(inetAddress1.getCanonicalHostName());
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}


4.端口

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

• 不同的进程有不同的端口号！用来区分软件！

  
  



• 被规定0~65535

  
  



• TCP，UDP：65535*2 单个协议下，端口号不能冲突

  
  



• 端口分类：

  
  
  
  
  • 共有端口 0~1023
    
    
    
    • HTTP：80
    
    
    • HTTPS：443
    
    
    • FTP：21
    
    
    • SSH：22
    
    
    • Telent：23
    
    
    
    
  
  
  • 程序注册端口：1024~49151，分配给用户或者程序
    
    
    
    • Tomcat：8080
    
    
    • MYSQL：3306
    
    
    • Oracle：1521
    
    
    
    
  
  
  • 动态，私有：49152~65535，最好别使用
  
  

  netstat -ano # 查看所有端口
netatat -ano|findstr "" # 查看某一端口
tasklist|findstr "" # 查看指定端口的进程
ctrl + alt + esc


  package com.thj.lession1;
import java.net.InetSocketAddress;
//
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());
}
}

  

5.通信协议

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

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

问题：非常的复杂？

大事化小：分层！

TCP/IP协议簇，实际上是一组协议

重要：

• TCP：用户传输协议


• UDP：用户数据报协议

出名的协议：

• TCP：


• IP：网络互联协议

TCP UDP 对比

TCP：打电话

• 连接，稳定

  
  



• 三次握手，四次挥手

  最少需要三次，保证稳定连接！
A:你瞅啥？
B：瞅你咋地？
A:干一场！
A:我要断开了
B：我知道你要断开了
B:你真的要断开了吗？
A:我真的要断开了

  




• 客户端，服务端

  
  



• 传输完成，释放连接，效率低

  
  

UDP：发短信

• 不连接，不稳定


• 客户端，服务的没有明确的概念


• 不管有没有准备好，都可以发给你


• DDOS：洪水攻击！（饱和攻击）

6.TCP

客户端

1. 连接服务器Socket


2. 发送消息

服务器

1. 建立服务的端口 SeverSocket


2. 等待用户的连接 accept


3. 接受用户的消息

服务器：

package com.thj.lession2;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
// 服务器
public class TcpServerDemo01 {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket accept = null;
InputStream is = null;
ByteArrayOutputStream baos = null;
// 我得有个地址
try {
serverSocket = new ServerSocket(9999);
// 等待客户端连接过来
accept = serverSocket.accept();
// 读取客户端的消息
is = accept.getInputStream();
/*
*/
// byte[] buffer = new byte[1024];
// int len;
// while((len=is.read(buffer)) !=-1){
// String s = new String(buffer,0,len);
// System.out.println(s);
// }
// 管道流
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());
baos.close();
is.close();
accept.close();
serverSocket.close();
} 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(accept != null){
try {
accept.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(serverSocket != null){
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}


客户端：

package com.thj.lession2;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
// 客户端
public class TcpClientDemo01 {
public static void main(String[] args) {
Socket socket = null;
OutputStream os = null;
// 1.要知道服务器的地址
try {
InetAddress serverIP = InetAddress.getByName("127.0.0.1");
// 2.端口号
int port = 9999;
// 3.创建一个socket连接
socket = new Socket(serverIP,port);
// 4.发送信息 IO流
os = socket.getOutputStream();
os.write("你好".getBytes(StandardCharsets.UTF_8));
} catch (Exception e) {
e.printStackTrace();
}finally {
if(socket != null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(os != null){
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}


文件上传：

服务器端：

package com.thj.lession2;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
public class TcpServerDemo02 {
public static void main(String[] args) throws Exception {
// 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 outputStream = socket.getOutputStream();
outputStream.write("接收完毕，可以断开".getBytes(StandardCharsets.UTF_8));
// 关闭资源
outputStream.close();
fos.close();
is.close();
socket.close();
serverSocket.close();
}
}


客户端：

package com.thj.lession2;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
public class TcpClientDemo02 {
public static void main(String[] args) throws Exception{
// 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("QQ图片20201108113935.jpg"));
// 4.写出文件
byte[] buffer = new byte[1024];
int len;
while((len = fis.read(buffer))!=-1){
os.write(buffer,0,len);
}
// 通知服务器，已经结束
socket.shutdownOutput();// 我传输完了
// 确认接收完毕
InputStream inputStream = socket.getInputStream();
// String byte[]
ByteArrayOutputStream byteArrayInputStream = new ByteArrayOutputStream();
byte[] buffer2 = new byte[2014];
int len2;
while((len2=inputStream.read(buffer2))!=-1){
byteArrayInputStream.write(buffer2,0,len2);
}
// 5.关闭资源
byteArrayInputStream.close();
inputStream.close();
fis.close();
os.close();
socket.close();
}
}


Tomcat

服务端

• 自定义 S


• Tomcat服务器S：java后台开发

客户端

• 自定义C


• 浏览器B

7.UDP

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

发送信息

发送端：

package com.thj.lession3;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
// 不需要连接服务器
public class UdpClientDemo01 {
public static void main(String[] args) throws Exception {
// 1.建立一个socket
DatagramSocket socket = new DatagramSocket();
// 2.建立包
// 3.发给谁
InetAddress localhost = InetAddress.getByName("localhost");
int port = 9090;
String msg = "hello,server";
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();
}
}


接收端：

ckage com.thj.lession3;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
// 还要等待客户端的连接
public class UdpServerDemo01 {
public static void main(String[] args) throws Exception {
// 开放端口
DatagramSocket socket = new DatagramSocket(9090);
// 接收数据包
byte[] buffer = new byte[1024];
DatagramPacket datagramPacket = new DatagramPacket(buffer, 0, buffer.length);// 接收
socket.receive(datagramPacket); // 阻塞接收
System.out.println(new String(datagramPacket.getData(),0,datagramPacket.getLength()));
// 关闭连接
socket.close();
}
}


咨询

package com.thj.chat;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
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(StandardCharsets.UTF_8);
DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));
socket.send(packet);
if(data.equals("bye")){
break;
}
}
socket.close();
}
}


package com.thj.chat;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
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);
// 断开连接
String receivedata = new String(packet.getData(), 0, packet.getLength());
System.out.println(receivedata);
if(receivedata.equals("bye")){
break;
}
socket.receive(packet); // 阻塞式接收包裹
}
socket.close();
}
}


在线咨询：两个人互为发送，接收方

1. 发送的线程

package com.thj.lession3;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
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){
String data = null;
try {
data = reader.readLine();
byte[] datas = data.getBytes(StandardCharsets.UTF_8);
DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIP,this.toPort));
socket.send(packet);
if(data.equals("bye")) {
break;
}
} catch (Exception e) {
e.printStackTrace();
}
}
socket.close();
}
}


2. 接收的线程

package com.thj.lession3;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
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;
try {
socket = new DatagramSocket(port);
} catch (SocketException e) {
e.printStackTrace();
}
}
@Override
public void run() {
while (true){
// 准备接收包裹
byte[] cOntainer= new byte[1024];
DatagramPacket packet = new DatagramPacket(container,0,container.length);
try {
socket.receive(packet); // 阻塞式接收包裹
} catch (IOException e) {
e.printStackTrace();
}
// 断开连接
String receivedata = new String(packet.getData(), 0, packet.getLength());
System.out.println(msgFrom+"："+receivedata);
if(receivedata.equals("bye")){
break;
}
}
socket.close();
}
}


3. 启动线程1

package com.thj.chat;
import com.thj.lession3.TalkReceive;
import com.thj.lession3.TalkSend;
public class TalkStudent {
public static void main(String[] args) {
Thread t2 = new Thread(new TalkSend(7777,"localhost",9999));
Thread t1 = new Thread(new TalkReceive(8888,"老师"));
t1.start();
t2.start();
}
}


4. 启动线程2

package com.thj.chat;
import com.thj.lession3.TalkReceive;
import com.thj.lession3.TalkSend;
public class TalkTeacher {
public static void main(String[] args) {
new Thread(new TalkSend(9090,"localhost",8888)).start();
new Thread(new TalkReceive(9999,"学生")).start();
// 静态代理
}
}


8.URL

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

DNS 域名解析

https://www.baidu.com

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


package com.thj.lession4;
import java.net.MalformedURLException;
import java.net.URL;
public class URLDemo01 {
public static void main(String[] args) throws MalformedURLException {
URL url = new URL("http://localhost:8080/helloworld/index.jsp");
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.thj.lession4;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
public class URLDown {
public static void main(String[] args) throws Exception {
// 1.下载地址
URL url = new URL("https://m801.music.126.net/20220411172939/620cae4e506ca0ad6ec1ccd94ee67e72/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/13856315686/d4d9/42b9/075c/062ef57b71d8160c74e351d4036a5af8.m4a");
// 2.连接到这个资源 HTTP
HttpURLConnection urlCOnnection= (HttpURLConnection) url.openConnection();
InputStream inputStream = urlConnection.getInputStream();
FileOutputStream fos = new FileOutputStream("1.m4a");
byte[] buffer = new byte[1024];
int len;
while ((len=inputStream.read(buffer))!=-1){
fos.write(buffer,0,len); // 写出这个数据，到len就行
}
fos.close();
inputStream.close();
urlConnection.disconnect(); // 断开连接
}
}