TCP、UDP

最新推荐文章于 2024-02-08 16:06:19 发布

dxj1016

最新推荐文章于 2024-02-08 16:06:19 发布

阅读量266

点赞数

分类专栏：计算机专业课程文章标签： udp TCP

本文链接：https://blog.csdn.net/weixin_44718865/article/details/116505321

版权

计算机专业课程专栏收录该内容

8 篇文章 1 订阅

订阅专栏

1、TCP UDP对比

狂神说java视频

TCP

打电话：

连接，稳定

三次握手、四次挥手

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


A：我不发了（关闭发送）
B：好，那我不收了（关闭接收）
B：我也不发了（关闭发送）
A：好，那我也不收了（关闭接收）

三次握手：

四次挥手：

客户端、服务端
传输完成，释放连接，效率低

UDP

发短信：

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

2、TCP

通信实践

客户端

连接服务器Socket
发送消息

package cn.dxj1016.lesson02;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        try {
//        1.要知道服务器的地址、端口号
            InetAddress byName = InetAddress.getByName("127.0.0.1");
            int port = 9999;
//            2.创建一个socket连接
             socket = new Socket(byName,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();
                }
            }

        }
    }
}

服务端

建立服务的端口ServerSocket
等待用户的连接 accept
接收用的信息

package cn.dxj1016.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 inputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;

        try {
//        1.我要有一个地址
             serverSocket = new ServerSocket(9999);

            while (true) {
                //            2.等待客户端连接过来
                socket = serverSocket.accept();
//            3.读取客户端的消息
                inputStream = socket.getInputStream();

//            管道流
                byteArrayOutputStream = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len = inputStream.read(buffer)) != -1) {
                    byteArrayOutputStream.write(buffer, 0, len);
                }
                System.out.println(byteArrayOutputStream.toString());
            }



        } catch (IOException e) {
            e.printStackTrace();
        }finally {
//            关闭资源
            if (byteArrayOutputStream != null) {
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.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();
                }
            }


        }
    }
}
 /*
            以前的做法：
              byte[] bytes = new byte[1024];
            int len;
            while ((len = inputStream.read()) != -1) {
                String s = new String(bytes, 0, len);
                System.out.println(s);

            }
             */

测试：先启动服务端，再启动客户端

文件上传实践

客户端

package cn.dxj1016.lesson02;
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 outputStream = socket.getOutputStream();

//        3.文件流 读取文件
        FileInputStream fileInputStream = new FileInputStream(new File("zly.jpg"));
//        4.写出文件
        byte[] bytes = new byte[1024];
        int len;
        while ((len = fileInputStream.read(bytes)) != -1) {
            outputStream.write(bytes,0,len);
        }
//通知服务器，我已经结束了
        socket.shutdownOutput();//我已经传输完了


//        确定服务器接收完毕，才能断开连接
        InputStream inputStream = socket.getInputStream();
//        String类型的数组
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] bytes1 = new byte[1024];
        int len2;
        while ((len2 = inputStream.read(bytes1)) != -1) {
            byteArrayOutputStream.write(bytes1, 0, len2);
        }
        System.out.println(byteArrayOutputStream.toString());
//        5.关闭资源
        fileInputStream.close();
        inputStream.close();
        outputStream.close();
        socket.close();

    }
}

服务端

package cn.dxj1016.lesson02;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
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.jpg"));
        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();
    }
}

3、UDP

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

UDP实现发送消息

package cn.dxj1016.lesson03;

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

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
//        1.建立一个Socket
        DatagramSocket datagramSocket = new DatagramSocket();
//        2.建个包
        String msg = "你好啊，服务器！";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;
//        数据，数据的长度起始，要发给谁
        DatagramPacket datagramPacket = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length,localhost,port);

//        3.发送包
        datagramSocket.send(datagramPacket);
//        4.关闭资源
        datagramSocket.close();
    }
}

接收端

package cn.dxj1016.lesson03;

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

//还是要等待客户端的连接
public class UdpServerDemo01 {
    public static void main(String[] args) throws IOException {
//        开放端口
        DatagramSocket datagramSocket = new DatagramSocket(9090);
//        接收数据包
        byte[] bytes = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length);//接收
        datagramSocket.receive(datagramPacket);//阻塞接收
        System.out.println(datagramPacket.getAddress().getHostAddress());
        System.out.println(new String(datagramPacket.getData(), 0, datagramPacket.getLength()));
//        关闭连接
        datagramSocket.close();
    }
}

UDP实现循环发送消息

package cn.dxj1016.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 datagramSocket = new DatagramSocket(8888);
//        准备数据：控制台读取 System.in
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

        while (true) {
            String data = bufferedReader.readLine();
            byte[] bytes = data.getBytes();
            DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, new InetSocketAddress("localhost", 6666));


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

UDP实现循环接收消息

package cn.dxj1016.chat;

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


public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket datagramSocket = new DatagramSocket(6666);
        while (true) {
            //        准备接收包裹
            byte[] bytes = new byte[1024];
            DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
            datagramSocket.receive(packet);//阻塞式接收包裹
//        断开连接 bye
            byte[] data = packet.getData();
            String s = new String(data, 0, data.length);

            System.out.println(s);

            if (s.equals("bye")) {
                break;
            }
        }
        datagramSocket.close();
        }

}

在线咨询：

两个人都可以是发送方，也都可以是接收方！

发送端代码

package cn.dxj1016.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 datagramSocket = new DatagramSocket(8888);
//        准备数据：控制台读取 System.in
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

        while (true) {
            String data = bufferedReader.readLine();
            byte[] bytes = data.getBytes();
            DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, new InetSocketAddress("localhost", 6666));


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

接收方代码

package cn.dxj1016.chat;

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

public class TalkReceive implements Runnable{
    DatagramSocket datagramSocket = null;

    private int port;
    private String msgForm;

    public TalkReceive(int port,String msgForm) {
        this.port = port;
        this.msgForm = msgForm;
        try {
            datagramSocket= 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);
                datagramSocket.receive(packet);//阻塞式接收包裹
//        断开连接 bye
                byte[] data = packet.getData();
                String s = new String(data, 0, data.length);

                System.out.println(msgForm+":"+s);

                if (s.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        datagramSocket.close();
    }
    public static void main(String[] args) {

    }
}

一个用户开启多线程

学生端

package cn.dxj1016.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 cn.dxj1016.chat;

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

4、URL

https://www.baidu.com/

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

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

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

package cn.dxj1016.lesson04;

import java.net.MalformedURLException;
import java.net.URL;
//http://localhost:8080/Jiao/SecurityFile.txt
public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=kuangshen&password=123");
        System.out.println(url.getProtocol());
        System.out.println(url.getHost());
        System.out.println(url.getPort());
        System.out.println(url.getFile());
        System.out.println(url.getQuery());
    }
}
/*
localhost
8080
/helloworld/index.jsp?username=kuangshen&password=123
username=kuangshen&password=123
 */

package cn.dxj1016.lesson04;

import java.io.FileOutputStream;
import java.io.IOException;
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("https://m701.music.126.net/20210206235426/f6bc58c1b65effb7813bf84270df3e18/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/7282034514/6e0d/a7a8/e100/c9c961fb1c06d54f4ef3b6b164ec5098.m4a");

//        2.连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fileOutputStream = new FileOutputStream("f.m4a");

        byte[] bytes = new byte[1024];
        int len;
        while ((len = inputStream.read(bytes)) != -1) {
            fileOutputStream.write(bytes, 0, len);//写出这个数组
        }
        fileOutputStream.close();
        inputStream.close();
        urlConnection.disconnect();//断开连接

    }
}

dxj1016

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
TCP、UDP

1、TCP UDP对比TCP打电话：连接，稳定三次握手、四次挥手最少需要三次，保证稳定连接A:你愁啥B：瞅你咋地A：干一场A：我不发了（关闭发送）B：好，那我不收了（关闭接收）B：我也不发了（关闭发送）A：好，那我也不收了（关闭接收）三次握手：四次挥手：客户端、服务端传输完成，释放连接，效率低UDP发短信：不连接，不稳定客户端、服务端：没有明确的界限不管有没有准备好，都可以发给你导弹DDOS：洪水攻击（饱和攻击）2、TCP
复制链接

扫一扫

专栏目录