网络编程（狂神说）

原创
AWhiteElephant
2022-03-11
Java
451
0

网络编程（狂神说）

1.1、概述

信件：

打电话：---连接---接了---通话 TCP

发短信：---发送了就完事了---接收 UDP

计算机网络：

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

网络编程的目的：

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

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

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

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

javaweb：网页编程 B/S

网络编程：TCP/IP C/S

1.2、网络通信的要素

如何实现网络上的通信？

通信双方地址：

（192.168.1.1）：局域网。。

  • ip：
  • 端口号

规则：网络通信的协议：

TCP/IP参考模型：

HTTP：超文本传输协议

FTP:文件上传协议

小结：

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

  • 如何准确的定位到网络上的一台或者多台主机
  • 找到主机之后如何进行通信

2、网络编程中的要素

  • IP和端口号 IP
  • 网络通信协议 UDP，TCP

3、万物皆对象

1.3、IP

ip地址：inetAddress

  • 唯一定位一台网络上计算机
  • 127.0.0.1：本机loaclhost
  • Ip地址的分类
    • Ipv4/Ipv6
      • IPv4 127.00.1,四个字节组成，0-255，42亿~；30亿都在北美，亚洲四亿，2011年就用尽；
      • IPV6：128位，8个无符号整数！
    • 公网（互联网）-私网（局域网）
      • ABCD类地址
      • 192.168.xx.xx专门给组织内部使用的
  • 域名：记忆IP问题！
    • IP：
 package Second11_16;
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 
 public class TestInetAddres {
 public static void main(String[] args) {
     try {
         //查询网站IP地址
         InetAddress allByName = InetAddress.getByName("localhost");
         System.out.println(allByName);
 
         //常用方法：
         System.out.println(allByName.getHostAddress());//IP
         System.out.println(allByName.getHostName());//名字
         System.out.println(allByName.getCanonicalHostName());//规范的名字
     } catch (UnknownHostException e) {
         e.printStackTrace();
     }
 
 }
 }

1.4、端口(port)

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

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

  • 被规定0-65535

  • TCP,UDP：65536*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

       1、netstat -ano #查看所有的端口
 2、netstat -ano|findstr "9640" # 查看指定的窗口 其中|是指先干后面的再在前面中找
 3、tasklist|findstr "8696" #查看指定端口的进程

     package Second11_16;

 import java.net.InetSocketAddress;

 public class TestInetSocketAddres {
 public static void main(String[] args) {
     InetSocketAddress inetSocketAddress1 = new InetSocketAddress("127.0.0.1", 8080);
     InetSocketAddress inetSocketAddress2 = new InetSocketAddress("localhost", 8080);
     System.out.println(inetSocketAddress1);
     System.out.println(inetSocketAddress2);

     System.out.println(inetSocketAddress2.getAddress());
     System.out.println(inetSocketAddress2.getHostName());//地址
     System.out.println(inetSocketAddress2.getPort());//端口
 }
 }

1.5、通信协议

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

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

问题：非常的复杂

大事化小：分层！

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

重要：

  • TCP:用户传输协议
  • UDP:用户数据报协议

出名的协议：

  • TCP：
  • IP：网络互联协议

ps:应用层：QQ、微信；传输层：通信；网络层：分包；数据链路层：具体的传输：如光纤，海底电缆。。。。。。；

TCP UDP对比：

TCP：打电话

  • 连接，稳定

  • 三次握手、四次挥手

     最少需要三次，才能保证稳定连接！
 A；你愁啥？
 B：瞅你咋地？
 A：干一场！


 A：我要走了
 B：你真的要走了吗？
 B：你真的真的要走了吗？
 A：我真的要走了！

  • 客户端、服务端

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

UDP：发短信

  • 不连接，不稳定
  • 客户端、服务端：没有明确的界限
  • 不管有没有准备好，都可以发给你。。。
  • 导弹攻击
  • DDOS：洪水攻击！（饱和攻击）

1.6、TCP

有关socket的知识分享：https://www.cnblogs.com/dolphinx/p/3460545.html

SeverSocket:

为了使客户能成功地连接到服务器，服务器必须建立一个ServerSocket 对象，该对象通过将客户端地套接字对象和服务器端地一个套接字对象连接起来，从而达到连接的目的。

客户端:(socket对象)socket(IP地址，端口)

服务器:(ServerSocket对象)serversocket(端口 )用ServerSocket.accept（）来建立一个和客户端的Socket对象相连接的Socket对象。

服务器端的输出流/输入流的目的地和客户端的输入流/输出流的源刚好相同。

进程堵塞

提升作用域

文件上传

服务器端：

 package lesson03;
 
 import java.io.*;
 import java.net.ServerSocket;
 import java.net.Socket;
 
 public class TCPserver02 {
 public static void main(String[] args) throws IOException {
 
     //建立连接，创建服务
     ServerSocket serverSocket= new ServerSocket(9900);
     // 监听客户端的连接
     Socket socket = serverSocket.accept();
 
 
     //创立输入流和文件输出流
     InputStream is = socket.getInputStream();
     // 文件输出
     FileOutputStream fos = new FileOutputStream(new File("JTest3.png"));
 
     //创立缓冲区和写
     byte[] buff=new byte[1024];
     int len;
     while((len=is.read(buff))!=-1){
         fos.write(buff,0,len);
     }
 
     //与客户端说我已经收到了
     OutputStream os =socket.getOutputStream();
     os.write("我已接收".getBytes());
 
     //关闭资源
     os.close();
     fos.close();
     is.close();
     socket.close();
     serverSocket.close();
 }
 }
 
 /*
 1、接收要read，所以要用inputStream
 2、要把文件写给大家看，所以要fileoutputstream
  */

客户端：

 package lesson03;
 
 import java.io.*;
 import java.net.InetAddress;
 import java.net.Socket;
 import java.net.UnknownHostException;
 
 public class TCPclient02 {
 public static void main(String[] args) throws IOException {
 
     //建立连接
     Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9900);
 
     //建立输出流和文件输入流
     OutputStream os =socket.getOutputStream();
     FileInputStream fis = new FileInputStream(new File("JavaKuangStudy/network programming/src/ImageData/Test.png"));
 
     //缓冲区之后
     //需要转换格式
     //写出文件
     byte[] buff = new byte[1024];//划定空间
     int len;
     while((len= fis.read(buff))!=-1){
         os.write(buff,0,len);
     }
 
     //确定服务器接收完毕才能断开连接。
     //发送成功后关闭输出流
     //通知服务器我已经输出结束了
     socket.shutdownOutput();
 
     //接收来自服务端的消息，用数组流来输出
     InputStream is = socket.getInputStream();
     ByteArrayOutputStream bos = new ByteArrayOutputStream();
     int len1;
     byte[] buff1 = new byte[1024];//初始内存空间大小
     while((len1=is.read(buff1))!=-1){
         bos.write(buff1,0,len1);
     }
     System.out.println(bos.toString());
 
     //关闭资源
     bos.close();
     is.close();
     fis.close();
     os.close();
     socket.close();
 }
 }
 /*
 1、抛出异常
 2、套接字的get输入输出流
 3、通知服务器，我已经输出结束了：socket.shutdownOutput();
 4、while（（len=is.read(buff)）!=-1）{
     bos.write(buff,0,len);
 5、while和0-长度
 }
  */

Tomcat

调试：consolehandler:GBK

服务端

  • 自定义（S）
  • Tomcat服务器(S)：Java后台开发用别人的服务器！

客户端

  • 自定义（C）
  • 浏览器(B)

1.7、UDP

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

发送消息

发送端

 package Udp01;
 
 import java.net.*;
 //不需要连接服务器
 public class UdpTest02 {
 public static void main(String[] args) throws Exception {
     //建立一个socket
     DatagramSocket socket=new DatagramSocket();
 
     //建个包
     InetAddress inetAddress=InetAddress.getByName("localhost");
     byte[] Str= "你好".getBytes();
     int port=9999;
 
     //数据，数据的长度起始，要发送给谁
     DatagramPacket datagramPacket=new DatagramPacket(Str,0,Str.length,inetAddress,port);
 
     //发送包
     socket.send(datagramPacket);
 
     //关闭流
     socket.close();
 }
 }

接收端：

 package Udp01;
 
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.SocketException;
 
 //还是要等待客户端的链接
 public class UdpTest01 {
 public static void main(String[] args) throws Exception {
     //开放端口
     DatagramSocket socket=new DatagramSocket(9999);
 while (true) {
 
     //接收数据包
     byte[] Strin = new byte[1024];
 
     DatagramPacket datagramPacket = new DatagramPacket(Strin, 0, Strin.length);
 
     //阻塞接收
     socket.receive(datagramPacket);
 
     System.out.println(new String(datagramPacket.getData(), 0, datagramPacket.getLength()));
 
     //关闭链接
     socket.close();
 }
 }
 }

咨询

循环发送消息

发送方：

package UDP.Udp02;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class UdpSin {
public static void main(String[] args) throws Exception {
    DatagramSocket datagramSocket=new DatagramSocket(8888);

    while (true){
        //准备数据，控制台读取System.in
        BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));

        //读取控制台输入的一行并把它转化为字符
        String Buf=buf.readLine();

    InetAddress inetAddress=InetAddress.getByName("localhost");
    DatagramPacket datagramPacket=new DatagramPacket(Buf.getBytes(),0,Buf.length(),inetAddress,9999 );

    datagramSocket.send(datagramPacket);

    if(Buf.equals("bye"))
        break;
    }
    datagramSocket.close();
}
}
/*
1、BuffReader读取控制台字符时用readLine来读取一行
 */

接收方：

package UDP.Udp02;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpSin01 {
public static void main(String[] args) throws Exception{
    //建立链接
    DatagramSocket datagramSocket = new DatagramSocket(9999);
    byte[] bufin = new byte[1024];
    while (true) {

        //准备接收包裹
        DatagramPacket datagramPacket = new DatagramPacket(bufin, 0, bufin.length);

        datagramSocket.receive(datagramPacket);//阻塞时接收包裹

        byte[] data=datagramPacket.getData();
        String msg=new String(data,0,data.length);
        System.out.println(msg);

        if(msg.equals("bye")){
            break;
        }

        datagramSocket.close();
    }
}
}
/*
1、创建对象 while之外
2、接收包裹.getData
 */

在线咨询：两个人都可以发送

发送端线程：

package UDP.Run;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;

public class Sent implements Runnable{
    DatagramSocket datagramSocket;
    DatagramPacket datagramPacket;
    private int fromPort;
    private String toIP;
    private int Toport;
    BufferedReader bufferedReader;
    String buf;

public Sent(int fromPort, String toIP, int Toport) {
    this.fromPort = fromPort;
    this.toIP = toIP;
    this.Toport = Toport;
    try {
        this.datagramSocket = new DatagramSocket(fromPort);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
public void run() {
    while(true){
        try {
            bufferedReader=new BufferedReader(new InputStreamReader(System.in));
            buf=bufferedReader.readLine();
            byte[] buff=buf.getBytes();
            datagramPacket= new DatagramPacket(buff,0,buff.length,new InetSocketAddress(this.toIP,this.Toport));

            datagramSocket.send(datagramPacket);

            if (buf.equals("bye")){
                break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    datagramSocket.close();
}
}
/*今日忘记
1、IP:String
2、DatagramSocket(端口)
2、BuffReader（输入流）；
3、发送要把String变成数组
 */

接收端线程：

package UDP.Run;

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

public class Receive implements Runnable{
    DatagramSocket datagramSocket;
DatagramPacket datagramPacket;
private String FromID;
    private int Port;

public Receive(String fromID, int port) {
    this.FromID = fromID;
    this.Port = port;

    try {
        datagramSocket=new DatagramSocket(port);
    } catch (SocketException e) {
        e.printStackTrace();
    }
}

@Override
public void run() {
    while (true) {
        try {
            byte[] buff = new byte[1024];
           datagramPacket = new DatagramPacket(buff, 0, buff.length);
            datagramSocket.receive(datagramPacket);

            byte[] data=datagramPacket.getData();
            String msg=new String(data,0,data.length);

            System.out.println(FromID + ":" +msg);

            if (datagramPacket.equals("bye")) {
                break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    datagramSocket.close();
}
}
//重新定义数组

学生端：

package UDP.Run;

import UDP.Run.Receive;
import UDP.Run.Sent;

public class Student {
public static void main(String[] args) {
    new Thread(new Sent(7754,"localhost",9999)).start();
    new Thread(new Receive("老师：",7787)).start();
}

}
//线程要启动

老师端：

package UDP.Run;

import UDP.Run.Receive;
import UDP.Run.Sent;

public class Teacher {
public static void main(String[] args) {
    new Thread(new Sent(7755,"localhost",7787)).start();
    new Thread(new Receive("学生：",9999)).start();
}
}

1.8、URL

https://www.baidu.com/

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

DNS域名解析 WWW.baidu

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

public class Url {
public static void main(String[] args) throws IOException {
    URL url=new URL("https://m801.music.126.net/20201123231609/7a60a829f966abbdfc75ee0756ed0ff9/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/4916388353/e2fe/8be5/e1e6/c7614d21f4afc33120723d86e09d330d.m4a");
    HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

    InputStream in=urlConnection.getInputStream();
    FileOutputStream Fout=new FileOutputStream("d.m4a");

    byte[] buff=new byte[1024];
    int len;
    while ((len=in.read(buff))!=-1){
        Fout.write(buff,0,len);
    }

    Fout.close();
    in.close();
    urlConnection.disconnect();
}


}
end
  • 作者：AWhiteElephant（联系作者）
  • 发表时间：2022-03-11 20:59
  • 版权声明：自由转载-非商用-非衍生-保持署名（创意共享3.0许可证）
  • 转载声明：如果是转载栈主转载的文章，请附上原文链接
    •

    评论