学习java 第八天-CSDN博客

本文链接：https://blog.csdn.net/nmwxhy/article/details/123803173

网络编程

打电话：TCP 发短信：UDP

网络通信的要素

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

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

找到主机之后如何进行编程

2、网络编程中的要素

ip 和端口号

网络通信协议 UDP TCP

3、万物皆对象

IP

ip地址：InetAddress（无构造器）

唯一定位一台网路上的计算机

127.0.0.1 ：本机localhost

ip地址分类

ipv4/ipv6

ipv4 127.0.0.1 ，由4个字节组成，，0-255 ，42亿个；

ipv6 128位，8个无符号整数

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

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

ABCD类地址

端口

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

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

被规定 0-65536

单个协议下，端口号不能冲突

端口分类

公有端口 0~1023

http：80

https：443

ftp：21

Telent：23

程序注册端口： 1024-49151，分配用户程序

Tomcat：8080

MySQL：3306

Oracle：1521

动态、私有端口：49152~65535

cmd查看所有端口：netstat -ano

cmd查看指定端口：netstat -ano|findstr “”

通信协议

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

TCP/IP：用户传输协议 UDP：用户数据协议

TCP UDP对比：

TCP：打电话

连接，稳定

三次握手，四次挥手

至少需要三次通信才能保证稳定连接(/ \ /)

至少需要四次通信才能保证断开(/ \ \ /)

客户端，服务端

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

UDP：发短信

不连接，不稳定

客户端，服务端，没有明确的界限

无论有没有准备好，都可以发

DDoS：洪水攻击（饱和攻击）

TCP

客户端

1、连接服务器Socket

2、发送消息

服务器

1、建立服务的端口 SeverSocket

2、等待用户的连接 accept

3、接收用户的消息

Tomcat

服务端

自定义S

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

客户端

自定义C

浏览器B

★ 同一个协议下端口号不能重复使用

UDP

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

发送端

package UDP;

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 {
   //创建socket
   DatagramSocket socket = new DatagramSocket();
   //建一个包
   String msg = "你好呀，服务器！";

   InetAddress localhost = InetAddress.getByName("localhost");

   int poor = 9090;
   //发送的数据，数据长度，发送给谁，
   DatagramPacket Packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,localhost,poor);
   //发送数据
   socket.send(Packet);
   //关闭流
   socket.close();
}
}

接收端

package UDP;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;

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(new String(packet.getData(),0,packet.getLength()));
   //关闭连接
   socket.close();
}
}

互相发送（模拟聊天）

发送方

import java.awt.desktop.SystemSleepEvent;
import java.io.BufferedReader;
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  fromprot;
    private String toIP;
    private int toPort;

    public TalkSend(int fromprot, String toIP, int toPort) {
        this.fromprot = fromprot;
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            socket = new DatagramSocket(fromprot);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                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();
    }
}

接收方

import javax.sound.sampled.Port;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Socket;
import java.net.SocketException;
import java.text.BreakIterator;

public class TalkReceive implements Runnable{
    DatagramSocket socket = null;
    private int Prot;
    private  String from;

    public TalkReceive( int Prot,String from) {
        this.Prot = Prot;
        this.from = from;
        try {
            socket = new DatagramSocket(Prot);
        }catch (SocketException e){
            e.printStackTrace();
        }

    }

    @Override
    public void run() {
        while (true){
            try {
                //准备接收包裹
                byte[] bytes = new byte[1024];
                DatagramPacket Package = new DatagramPacket(bytes,0,bytes.length);
                socket.receive(Package);//阻塞式接收包

                //断开连接 bye
                byte[] data = Package.getData();
                String receivedata = new String(data,0,data.length);
                System.out.println(from+":"+receivedata);

                if (receivedata.equals("bye")){
                    break;
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        socket.close();
    }
}