通信协议、UDP、TCP

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

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

大事化小：分层

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

重要：

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

出名的协议：

TCP
IP：网络互连协议

TCP UDP对比

TCP：打电话

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

三次握手：

A：你瞅啥？

B：瞅你咋滴？

A：干一场！

四次挥手：

A：我要走了

B：你真的要走了吗？

B：你真的真的要走了吗？

A：我真的要走了

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

UDP：发短信

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

TCP：

服务器
1. 建立服务器的端口 ServerSocket
2. 等待用户的连接 accept
3. 接收用户的消息

package com.wzz.A04网络编程.B03TestTcp;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务端
public class C01TcpServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            serverSocket = new ServerSocket(9999);//1.我得有一个地址
            socket = serverSocket.accept();//等待客户端连接过来
            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();
                }
            }
        }
    }
}

客户端：
1. 连接服务器 Socket
2. 发送消息

package com.wzz.A04网络编程.B03TestTcp;

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

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

文件上传

服务器端：

package com.wzz.A04网络编程.B03TestTcp;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class C03TcpServer1 {
    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);
        }

        //6.通知客户端我接受完毕了
        OutputStream os = socket.getOutputStream();
        os.write("我接受完毕了，你可以断开了".getBytes());

        //5.关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

客户端：

package com.wzz.A04网络编程.B03TestTcp;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class C04TcpClient1 {
    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("1.jpg"));
        //写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }

        //7.通知服务器，我已经结束了
        socket.shutdownOutput();//我已经传输完了

        //6.确定服务器接受完毕，才能够断开连接
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }
        System.out.println(baos.toString());

        //5.关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }

}

UDP

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

发送消息：

package com.wzz.A04网络编程.B04TestUDP;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

//不需要连接服务器
public class C01UdpClient {
    public static void main(String[] args) throws Exception {
        //1.建立一个Socket
        DatagramSocket socket = new DatagramSocket();
        //2.建个包
        String msg = "你好啊，服务器!";
        //2_1.发给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;

        //2_2.数据，数据的长度起始，要发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        //3.发送包
        socket.send(packet);

        //4.关闭流
        socket.close();
    }
}

接收消息：

package com.wzz.A04网络编程.B04TestUDP;

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

public class C02UdpServer {
    public static void main(String[] args) throws Exception {
        //1.开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //2.接收数据包
        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()));

        //3.关闭连接
        socket.close();
    }
}

咨询：

循环发送消息：

package com.wzz.A04网络编程.B05UDPChart;

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 C01UdpSender01 {
    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();
            DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));

            socket.send(packet);
            if (data.equals("bye")){
                break;
            }
        }

        socket.close();
    }
}

循环接收消息：

package com.wzz.A04网络编程.B05UDPChart;

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

public class C02UdpReceive01 {
    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();
        }
    }
}

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

发送消息：

package com.wzz.A04网络编程.B06Chart;

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 C01TalkSend implements Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int formPort;
    private String toIP;
    private int toPort;

    public C01TalkSend(int formPort, String toIP, int toPort) {
        this.formPort = formPort;
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            socket = new DatagramSocket(formPort);
            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 (IOException e) {
                e.printStackTrace();
            }

        }
        socket.close();
    }
}

接收消息：

package com.wzz.A04网络编程.B06Chart;

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

public class C02TalkReceive implements Runnable{
    DatagramSocket socket = null;
    private int port;
    private String msgFrom;

    public C02TalkReceive(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[] 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(msgFrom+":"+receiveData);

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

老师端：

package com.wzz.A04网络编程.B06Chart;

public class C04TalkTeacher {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new C01TalkSend(5555,"localhost",8888)).start();
        new Thread(new C02TalkReceive(9999,"学生")).start();
    }
}

学生端：

package com.wzz.A04网络编程.B06Chart;

public class C03TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new C01TalkSend(7777,"localhost",9999)).start();
        new Thread(new C02TalkReceive(8888,"老师")).start();
    }
}

posted @ 2021-10-21 15:52 隔岸稻花香阅读(96) 评论(0) 编辑收藏举报

刷新页面返回顶部

隔岸稻花香

通信协议、UDP、TCP

公告