网络编程

网络编程

1.1、概述

地球村：你在上海，你一个美国的朋友！

信件：

计算机网络：

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

 

网络编程的目的：

无线电台…传播交流信息，数据交换。通信

 

想要达到这个效果需要什么：

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

  2. 找到了这个主机，如何传输数据呢？

javaweb：网页编程 B/S

网络编程：TCP/IP C/S

1.2、网络通信的要素

人工智能：智能机车：工厂，人少！

 

如何实现网络的通信？

通过双方的地址：

  • ip

  • 端口号

  • 192.168.16.124：5900

规则：网络通信的协议

TCP/IP参考模型：

ping 网址 例：ping www.baidu.com 即可获得他的地址

小结：

1.网络编程中有两个主要的问题

  • 如何准确的定位到网络上的一台或者多太主机

  • 找到主机之后进行通信

2.网络编程中的要素

  • IP 和 端口号 IP

  • 网络通信协议 udp , tcp

3.万物皆对象

1.3、IP

ip地址：InetAddress

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

  • 127.0.0.1 : 本机 localhost

  • ip地址的分类

    • ipv4 / ipv6

    • IPV4 127.0.0.1 ,4个字节组成。0 ~ 255，42亿 ；30亿在北美，亚洲4亿。2011年就用尽了；

    • IPV6 ：128位。8个无符号整数！

     2022:0bb2:zzzz:0036:0000:oooo:64dd:1314   //这个是乱写的看格式就可以了

    • 公网（互联网）-私网（局域网）

      • ABCD类地址

      • 192.168.xx.xx，专门给组织内部使用的

  • 域名：记忆IP问题！

 package com.kuang.lesson01;
 ​
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 ​
 public class TestInetAddress {
     public static void main(String[] args) {
         try {
             //查询本机地址
             InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
             System.out.println(inetAddress);
             InetAddress inetAddress2 = InetAddress.getByName("localhost");
             System.out.println(inetAddress2);
             InetAddress inetAddress3 = InetAddress.getLocalHost();
             System.out.println(inetAddress3);
 ​
             //查询网站ip地址
             InetAddress inetAddress1 = InetAddress.getByName("www.baidu.com");
             System.out.println(inetAddress1);
 ​
             //常用方法
             //System.out.println(inetAddress1.getAddress());
             System.out.println(inetAddress1.getHostAddress());//ip
             System.out.println(inetAddress1.getCanonicalHostName());//Canonical ：规范的
             System.out.println(inetAddress1.getHostName());//域名，或者自己电脑的名字
 ​
         } catch (UnknownHostException e) {
             e.printStackTrace();
         }
     }
 }

1.4、端口

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

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

  • 被规定 0~65535

  • TCP/UDP : 65535*2 tcp：80，udp：80吗，单个协议下，端口号不能冲突

  • 端口分类

    • 公有端口 0~1023

      • HTTP : 80

      • HTTPS : 443

      • FTP : 21

      • Telent：23

    • 程序注册端口：1024~49151，分配给用户或者程序的

      • Tomcat：8080

      • MySQL：3306

      • Oracle：1521

    • 动态、私有：49152~65535

     netstat -ano  #查看所有的端口号
 netstat -ano|findstr "5900" #查看指定的端口
 tasklist|findstr "1637" #查看指定端口的进程
  •  package com.kuang.lesson01;
 ​
 import java.net.InetSocketAddress;
 ​
 public class TestSocketAddress {
     public static void main(String[] args) {
         InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
         InetSocketAddress socketAddress2 = new InetSocketAddress("localhost", 8080);
         System.out.println(socketAddress);
         System.out.println(socketAddress2);
 ​
         System.out.println(socketAddress.getAddress());
         System.out.println(socketAddress.getHostName());//地址
         System.out.println(socketAddress.getPort());//端口
 ​
     }
 }
 ​

1.5、通信协议

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

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

问题：非常的复杂？

大事化小：分层！

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

重要：

  • TCP : 用户传输协议

  • UDP：用户数据报协议

出名的协议：

  • TCP :

  • IP：网络互联协议

 

TCP udp 对比

TCP：打电话

  • 连接，稳定

  • 三次握手 四次挥手

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

  • 客户端、服务端

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

UDP：发短信

  • 不连接，不稳定

  • 客户端、服务端：没有明确的界限

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

  • 导弹

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

1.6、TCP

客户端

1.连接服务器 Socket

2.发送消息

 package com.kuang.lesson02;
 ​
 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.InetAddress;
 import java.net.Socket;
 ​
 ​
 //客户端
 public class TcpClientDemo01 {
     public static void main(String[] args) {
         Socket socket =null;
         OutputStream os = null;
         try {
             //1.要知道服务器的地址，端口号
             InetAddress serverIP = InetAddress.getByName("127.0.0.1");
             int port = 9999;
             //2.创建一个socket连接
             socket = new Socket(serverIP,port);
 ​
             //3.发送消息 IO流
             os = socket.getOutputStream();
             os.write("你好，欢迎学习狂神说Java".getBytes());
 ​
         } catch (Exception 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();
                 }
             }
         }
     }
 }

服务端

  1. 建立服务的端口

  2. 等待用户的连接

  3. 接收用户的消息

 package com.kuang.lesson02;
 ​
 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 socket = null;
         InputStream is = null;
         ByteArrayOutputStream baos = null;
         try {
             //1.我得有一个地址
             serverSocket = new ServerSocket(9999);
             while (true) {//加了while就可以一直进行监听
                 //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());
 ​
             }
             /*
             byte[] buffer = new byte[1024];
             int len;
             while((len=is.read(buffer))!=-1){
                 String msg = new String(buffer,0,len);
                 System.out.println(msg);
             }
              */
 ​
         } 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();
                 }
             }
         }
     }
 }

文件上传

服务器端

 package com.kuang.lesson02;
 ​
 import java.io.*;
 import java.net.InetAddress;
 import java.net.Socket;
 ​
 public class TcpClientDemo02 {
     public static void main(String[] args) throws Exception {//这里抛出了异常没有try，不推荐这样不然以后你就需要写更多的异常
         //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("tx.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 baos = new ByteArrayOutputStream();
 ​
         byte[] buffer2 = new byte[2048];
         int len2;
         while ((len=inputStream.read(buffer2))!=-1){
             baos.write(buffer2,0,len);
         }
         System.out.println(baos.toString());
 ​
         //5.关闭资源
         baos.close();
         inputStream.close();
         fis.close();
         os.close();
         socket.close();
     }
 }

客户端

 package com.kuang.lesson02;
 ​
 import java.io.*;
 import java.net.ServerSocket;
 import java.net.Socket;
 ​
 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"));
         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());
 ​
 ​
         //关闭资源
         fos.close();
         is.close();
         socket.close();
         serverSocket.close();
     }
 }

Tomcat

服务端

  • 自定义 S

  • Tomcat 服务器 S

客户端

  • 自定义 C

  • 浏览器 B

1.7、UDP

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

发送消息

发送端

 package com.kuang.lesson03;
 ​
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 import java.net.SocketException;
 ​
 //不需要连接服务器
 public class UdpClientDemo01 {
     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(), 0, msg.getBytes().length, localhost, port);
 ​
         //3.发送包
         socket.send(packet);
         //4.关闭流
         socket.close();
     }
 }

接收端

 package com.kuang.lesson03;
 ​
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.SocketException;
 ​
 //还是要等待客户端的链接！
 public class UdpServerDemo01 {
     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();
     }
 }

 

咨询

循环发送消息

 package com.kuang.chat;
 ​
 import java.io.BufferedReader;
 import java.io.InputStreamReader;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetSocketAddress;
 ​
 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));
         String data = reader.readLine();
         byte[] bytes = data.getBytes();
 ​
         DatagramPacket packet = new DatagramPacket(bytes,0,bytes.length,new InetSocketAddress("localhost",6666));
         socket.send(packet);
         socket.close();
     }
 }

循环接收消息

 package com.kuang.chat;
 ​
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 ​
 public class UdpReciveDemo01 {
     public static void main(String[] args) throws Exception {
         DatagramSocket socket = new DatagramSocket();
 ​
         while (true) {
             //准备接收包裹
             byte[] bytes = new byte[1024];
             DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
             socket.receive(packet);
 ​
             //断开连接  bye
             byte[] data = packet.getData();
             String receiveDate = new String(data, 0, data.length);
             System.out.println(receiveDate);
             if (receiveDate.equals("bye")) {
                 break;
             }
         }
         socket.close();
     }
 }

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

发送方：

 package com.kuang.chat;
 ​
 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;
 ​
 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 (SocketException e) {
             e.printStackTrace();
         }
     }
 ​
 ​
     @Override
     public void run() {
 ​
         //准备数据：控制台读取 System.in
         while (true) {
             try {
                 String data = reader.readLine();
                 byte[] bytes = data.getBytes();
 ​
                 DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, new InetSocketAddress(this.toIp, this.toPort));
                 socket.send(packet);
                 if (data.equals("bye")){
                     break;
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         socket.close();
     }
 }

接收方：

 package com.kuang.chat;
 ​
 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) {
             try {
 ​
                 //准备接收包裹
                 byte[] bytes = new byte[1024];
                 DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
                 socket.receive(packet);//阻塞式接收包裹
 ​
                 //断开连接  bye
                 byte[] data = packet.getData();
                 String receiveDate = new String(data, 0, data.length);
                 System.out.println(msgFrom+":"+receiveDate);
                 if (receiveDate.equals("bye")) {
                     break;
                 }
             }catch (Exception e){
                 e.printStackTrace();
             }
         }
         socket.close();
     }
 }

模拟出学生与老师对话

 package com.kuang.chat;
 ​
 public class TalkStudent {
     public static void main(String[] args) {
         //开启两个线程
         new Thread(new TalkSend(7777,"localhost",9999)).start();
         new Thread(new TalkReceive(8888,"老师")).start();
     }
 }
 package com.kuang.chat;
 ​
 public class TalkTeacher {
     public static void main(String[] args) {
         new Thread(new TalkSend(5555,"localhost",8888)).start();
         new Thread(new TalkReceive(9999,"学生")).start();
     }
 }

同时打开两个既可以模拟对话！

1.8、URL

https://www.baidu.com/

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

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

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

网络上下载图片…

 package com.kuang.lesson04;
 ​
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.net.HttpURLConnection;
 import java.net.URL;
 ​
 public class UrlDown {
     public static void main(String[] args) throws Exception {
         //1.下载地址
         URL url = new URL("");//路径
 ​
         //2.连接到这个资源 HTTP
         HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
 ​
         InputStream inputStream = urlConnection.getInputStream();
 ​
         FileOutputStream fos = new FileOutputStream("文件名");//可以自定义
         byte[] buffer = new byte[1024];
         int len;
         while ((len=inputStream.read(buffer))!=-1){
             fos.write(buffer,0,len);//写出这个数据
         }
         fos.close();
         inputStream.close();
         urlConnection.disconnect();//断开连接
     }
 }
posted @ 2022-01-24 21:43  nakano_may  阅读(62)  评论(0)  编辑  收藏  举报