JDK -- 网络编程(TCP/UDP)

最新推荐文章于 2023-01-08 18:18:38 发布
最新推荐文章于 2023-01-08 18:18:38 发布
阅读量191 收藏
点赞数
分类专栏： JDK常用类 文章标签： tcp/ip udp 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33753147/article/details/127835101
版权

三要素:

IP地址: 设备在网络中的地址，是唯一的标识

端口： 应用程序在设备中唯一的标识

协议 ： 数据在网络中传输的规则，常见的协议有UDP协议和TCP协议

InetAddress -- 代表IP地址

名称       说明

public static InetAddress getLocalHost()

返回本主机的地址对象

public static InetAddress getByName​(String host)

得到指定主机的IP地址对象，参数是域名或者IP地址

public String getHostName​()

获取此IP地址的主机名

public String getHostAddress​()

返回IP地址字符串

public boolean isReachable(int timeout)

在指定毫秒内连通该IP地址对应的主机，连通返回true

端口

端口号：标识正在计算机设备上运行的进程（程序），被规定为一个 16 位的二进制，范围是 0~65535。

端口类型

周知端口：0~1023，被预先定义的知名应用占用（如：HTTP占用 80，FTP占用21）

注册端口：1024~49151，分配给用户进程或某些应用程序。（如：Tomcat占 用8080，MySQL占用3306）

动态端口：49152到65535，之所以称为动态端口，是因为它 一般不固定分配某种进程，而是动态分配

TCP 三次握手/四次挥手

 可以理解为，

1.客户端发送消息给服务端 -- 当服务器接收到消息，表明客户端发送消息能力OK，服务端接受能力OK

2.服务端发送消息给客户端 -- 当客户端接收到消息，表明服务端发送消息能力OK

  • 3.客户端在发送消息给服务端 -- 当服务端再次接受到消息，表明客户端接受消息能力OK

 UDP协议

  • UDP是一种无连接、不可靠传输的协议。
  • 将数据源IP、目的地IP和端口封装成数据包，不需要建立连接
  • 每个数据包的大小限制在64KB内
  • 发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
  • 可以广播发送 ，发送数据结束时无需释放资源，开销小，速度快。

代码

客户端

/**
  发送端  多发 多收
 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("=====客户端启动======");

        // 1、创建发送端对象：发送端自带默认的端口号（人）
        DatagramSocket socket = new DatagramSocket(7777);
        

        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请说：");
            String msg = sc.nextLine();

            if("exit".equals(msg)){
                System.out.println("离线成功！");
                socket.close();
                break;
            }

            // 2、创建一个数据包对象封装数据（韭菜盘子）
            byte[] buffer = msg.getBytes();
            DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                    InetAddress.getLocalHost() , 8888);

            // 3、发送数据出去
            socket.send(packet);
        }

    }
}

接受端


/**
  接收端
 */
public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("=====服务端启动======");
        // 1、创建接收端对象：注册端口（人）
        DatagramSocket socket = new DatagramSocket(8888);

        // 2、创建一个数据包对象接收数据（韭菜盘子）
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        while (true) {
            // 3、等待接收数据。
            socket.receive(packet);
            // 4、取出数据即可
            // 读取多少倒出多少
            int len = packet.getLength();
            String rs = new String(buffer,0, len);
            System.out.println("收到了来自：" + packet.getAddress() +", 对方端口是" + packet.getPort() +"的消息：" + rs);
        }
    }
}

广播

广播：当前主机与所在网络中的所有主机通信。

/**
  发送端  多发 多收
 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("=====客户端启动======");

        // 1、创建发送端对象：发送端自带默认的端口号（人）
        DatagramSocket socket = new DatagramSocket();
        

        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请说：");
            String msg = sc.nextLine();

            if("exit".equals(msg)){
                System.out.println("离线成功！");
                socket.close();
                break;
            }

            // 2、创建一个数据包对象封装数据（韭菜盘子）
            byte[] buffer = msg.getBytes();
            // 注意：只要目的地IP是 255.255.255.255 这个消息将以广播的形式对外发送
            DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                    InetAddress.getByName("255.255.255.255") , 8888);

                    // 3、发送数据出去
            socket.send(packet);
        }

    }
}

 组播

组播：当前主机与选定的一组主机的通信。

 发送端

    public static void main(String[] args) throws Exception {
        System.out.println("=====客户端启动======");

        // 1、创建发送端对象：发送端自带默认的端口号（人）
        DatagramSocket socket = new DatagramSocket();
        

        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请说：");
            String msg = sc.nextLine();

            if("exit".equals(msg)){
                System.out.println("离线成功！");
                socket.close();
                break;
            }

            // 2、创建一个数据包对象封装数据
            DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                    InetAddress.getByName("224.0.1.1") , 9898);

            // 3、发送数据出去
            socket.send(packet);
        }

    }

接收端

public class ServerDemo3 {
    public static void main(String[] args) throws Exception {
        System.out.println("=====服务端启动======");
        // 1、创建接收端对象：注册端口（人）
        MulticastSocket socket = new MulticastSocket(9898);

        // 注意：绑定组播地址（加群）
        socket.joinGroup(new InetSocketAddress(InetAddress.getByName("224.0.1.1") , 9898),
                NetworkInterface.getByInetAddress(InetAddress.getLocalHost()));

        // 2、创建一个数据包对象接收数据（韭菜盘子）
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);


        while (true) {
            // 3、等待接收数据。
            socket.receive(packet);
            // 4、取出数据即可
            // 读取多少倒出多少
            int len = packet.getLength();
            String rs = new String(buffer,0, len);
            System.out.println("收到了来自：" + packet.getAddress() +", 对方端口是" + packet.getPort() +"的消息：" + rs);
        }
    }
}

TCP协议

  • TCP是一种面向连接，安全、可靠的传输数据的协议
  • 传输前，采用“三次握手”方式，点对点通信，是可靠的

 代码

客户端 

public class ClientDemo1 {
    public static void main(String[] args) {
        try {
            System.out.println("====客户端启动===");
            // 1、创建Socket通信管道请求有服务端的连接
            // public Socket(String host, int port)
            // 参数一：服务端的IP地址
            // 参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1", 6666);

            // 2、从socket通信管道中得到一个字节输出流 负责发送数据
            OutputStream os = socket.getOutputStream();

            // 3、把低级的字节流包装成打印流
            PrintStream ps = new PrintStream(os);

            Scanner sc =  new Scanner(System.in);
            while (true) {
                System.out.println("请说：");
                String msg = sc.nextLine();
                // 4、发送消息
                ps.println(msg);
                ps.flush();
            }
            // 关闭资源。
            // socket.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端:

/**
   目标：实现服务端可以同时处理多个客户端的消息。
 */
public class ServerDemo2 {

    // 使用静态变量记住一个线程池对象
    private static ExecutorService pool = new ThreadPoolExecutor(300,
            1500, 6, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(2)
    , Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(6666);
            // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
            while (true) {
                // 2、每接收到一个客户端的Socket管道，
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");

                // 任务对象负责读取消息。
                Runnable target = new ServerReaderRunnable(socket);
                pool.execute(target);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
public class ServerReaderRunnable implements Runnable{
    private Socket socket;
    public ServerReaderRunnable(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 5、按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
        }
    }
}

即时通信 -- 发给其他客户端

客户端：发消息的同时，随时有人发消息过来

public class ClientDemo1 {
    public static void main(String[] args) {
        try {
            System.out.println("====客户端启动===");
            // 1、创建Socket通信管道请求有服务端的连接
            // public Socket(String host, int port)
            // 参数一：服务端的IP地址
            // 参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1", 6868);

            // 马上为客户端分配一个独立的线程负责读取它收到的消息
            new ClientReaderThread(socket).start();

            // 2、从socket通信管道中得到一个字节输出流 负责发送数据
            OutputStream os = socket.getOutputStream();

            // 3、把低级的字节流包装成打印流
            PrintStream ps = new PrintStream(os);

            Scanner sc =  new Scanner(System.in);
            while (true) {
                System.out.println("请说：");
                String msg = sc.nextLine();
                // 4、发送消息
                ps.println(msg);
                ps.flush();
            }
            // 关闭资源。
            // socket.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ClientReaderThread extends Thread{
    private Socket socket;
    public ClientReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 5、按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "收到了: " + msg);
            }
        } catch (Exception e) {
            System.out.println("服务端把你踢出去了~~");
        }
    }

}

服务端：接收消息后，推送给其他所有在线socket

public class ServerDemo2 {

    public static List<Socket> onLineSockets = new ArrayList<>();

    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(6868);
            // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
            while (true) {
                // 2、每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");
                // 把当前客户端管道Socket加入到在线集合中去
                onLineSockets.add(socket);

                // 3、开始创建独立线程处理socket
                new ServerReaderThread(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ServerReaderThread extends Thread{
    private Socket socket;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 5、按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
                // 把这个消息发给当前所有在线socket
                sendMsgToAll(msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
            // 从在线集合中抹掉本客户端socket
            ServerDemo2.onLineSockets.remove(socket);
        }
    }

    private void sendMsgToAll(String msg) {
        try {
            // 遍历全部的在线 socket给他们发消息
            for (Socket onLineSocket : ServerDemo2.onLineSockets) {
                // 除了自己的socket，其他socket我都发！！
                if(onLineSocket != socket){
                    PrintStream ps = new PrintStream(socket.getOutputStream());
                    ps.println(msg);
                    ps.flush();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

BS（Browser-server） 通信

/**
    了解：BS-浏览器-服务器基本了解。

    客户端：浏览器。（无需开发）
    服务端：自己开发。
    需求：在浏览器中请求本程序，响应一个网页文字给浏览器显示

 */
public class BSserverDemo {
    // 使用静态变量记住一个线程池对象
    private static ExecutorService pool = new ThreadPoolExecutor(3,
            5, 6, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(2)
            , Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        try {
            // 1.注册端口
            ServerSocket ss = new ServerSocket(8080);
            // 2.创建一个循环接收多个客户端的请求。
            while(true){
                Socket socket = ss.accept();
                // 3.交给一个独立的线程来处理！
                pool.execute(new ServerReaderRunnable(socket));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ServerReaderRunnable implements Runnable{
    private Socket socket;
    public ServerReaderRunnable(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 浏览器 已经与本线程建立了Socket管道
            // 响应消息给浏览器显示
            PrintStream ps = new PrintStream(socket.getOutputStream());
            // 必须响应HTTP协议格式数据，否则浏览器不认识消息
            ps.println("HTTP/1.1 200 OK"); // 协议类型和版本 响应成功的消息！
            ps.println("Content-Type:text/html;charset=UTF-8"); // 响应的数据类型：文本/网页

            ps.println(); // 必须发送一个空行

            // 才可以响应数据回去给浏览器
            ps.println("<span style='color:red;font-size:90px'>hello BS! </span>");
            ps.close();
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
        }
    }
}

naki_bb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdk6的配置方法(用于网络开发)
11-10
jdk6的配置方法 希望可以帮助不会配置jdk的人
安卓第七天笔记--网络编程
02-26
Android完全支持JDK本身的TCP,UDP网络通信API,也可以使用ServerSocket,Socket来建立基于TCP/IP协议的网络通信,还可以使用DatagramSocket,Datagrampacket,MulticastSocket来建立基于UDP的协议网络通信.同时支持JDK...
13. Java网络编程
Buluchacha的博客
12-18 1034
Java网络编程
【网络编程】原生JDK网络编程
猫巳的博客
06-19 275
1.原生JDK网络编程-BIO(blocking I/O)2.原生JDK网络编程-AIO3.原生JDK网络编程-NIO之Reactor模式4.原生JDK网络编程-Buffer5.原生JDK网络编程-NIO(nonblocking I/O) 网络编程里通用常识既然是通信，那么是肯定是有两个对端的。在通信编程里提供服务的叫服务端...
原生JDK网络编程- NIO
weixin_30407099的博客
07-08 123
什么是NIO？ NIO 库是在 JDK 1.4 中引入的。NIO 弥补了原来的 I/O 的不足，它在标准 Java 代码中提供了高速的、面向块的 I/O。NIO翻译成 no-blocking io 或者 new io都说得通。 和BIO的主要区别 面向流与面向缓冲 Java NIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次...
JDK发送接收TCP/UDP数据
iteye_878的博客
04-12 237
本文的理论和代码摘录于《疯狂Java讲义》[url]http://book.51cto.com/art/201203/322540.htm[/url]，测试部分的截图是本人增加的。 1.UDP协议和TCP协议简单对比如下。 TCP协议：可靠，传输大小无限制，但是需要连接建立时间，差错控制开销大。 UDP协议：不可靠，差错控制开销较小，传输大小限制在64KB以下，不需要建立连接。 2...
第9章 网络编程-课后习题1
08-08
网络编程是计算机通信的核心部分，它允许程序通过网络进行数据交换。...以上是网络编程中关于TCP和UDP协议的基本知识，以及Java中实现这些协议的相关类和方法的详细解释。理解这些概念对于进行网络编程至关重要。
Android基于TCP和URL协议的网络编程示例【附demo源码下载】
01-20
Android完全支持JDK本身的TCP，UDP网络通信API，也可以使用ServerSocket,Socket来建立基于TCP/IP协议的网络通信，也可以使用DatagramSocket,Datagrampacket来建立基于UDP协议的网络通信。Android也支持JDK提供的URL...
网络编程经典书籍
08-24
本书内容全面涵盖了从网络基础知识到远程方法调用（RMI）等各方面的内容，书中章集涉及到TCP和UDP socket 、服务器socket、URL和URI、组播以及特殊用途的API（如JavaMail）等等。本书展示了如何使用JSSE编写安全的...
java网络编程
12-19
本书内容全面，涵盖了从网络基础知识到远程方法调用（RMI）等各方面的内容，书中章节涉及到TCP和UDP socket、服务器socket、URL和URI、组播以及特殊用途的API（如JavaMail）等等。本书展示了如何使用JSSE编写安全的...
原生JDK网络编程之NIO篇
wangguodong1993的博客
05-09 520
原生JDK网络编程之NIO篇 一、NIO是什么     NIO库是在JDK1.4中引入的。NIO弥补了原来的I/O的不足，它在标准Java代码中提供了高速的、面向块的I/O。     NIO可以称为 no-blocking io 或者 new io都可以。 二、NIO和BIO的主要区别 1、面向流和面向缓冲     BIO是面向流的，NIO是面向缓冲区的。   &nbs
通过构造方法连接服务器
guzhen518的博客
12-07 154
通过构造方法连接服务器 我们可以通过6个重载构造函数以不同的方式来连接服务器。这6个重载的构造函数可以分为两类： 1. 自动选择IP 这种方式是最常用的。所谓自动选择IP，是指当本机有多块网卡或者在一个网卡上绑定了多个IP时，Socket类会自动为我们选择一个可用的IP。在上述6个构造方法中有4个是使用这种方法来连接服务器的。 (1) public S...
JDK6.0学习笔记（十一）UDP通信服务器
陌上尘的Java学习旅程
11-17 728
/** * UDP开发，无连接的Socket操作采用UDP协议，一个数据报文是一个独立的单元， * 包含所有这次投递的信息：目的地址和要发送的内容。 * UDP模式下，Socket不需要连接到一个目的地Socket，只是简单的投出数据 * 无连接的操作是高效和快速的，但是数据传输的可靠性不佳 * 常用于音频和视频的传输，偶尔丢失一两个数据包，不会对接受效果产生很大的影响 * UDP不提供数据的分组
JAVA16版本.JDK16关于TCP和UDP的优化
张晨光老师的播客
02-13 546
性能加倍：虚拟线程（光纤）和JDK15/16！ 如果您使用UDP作为传输，并希望将性能提高一倍：请继续阅读！ 如果使用TCP，性能不会有太大变化。您可能仍然对最近的jdk和虚拟线程（以前称为“fibers”）将带来什么感兴趣。 虚拟线程 虚拟线程是轻量级线程，在概念上类似于旧的绿色线程，由JVM而不是内核来管理。许多虚拟线程可以映射到同一个操作系统本机（运营商）线程（当然，一次只能映射一个），因此我们可以拥有数百万个虚拟线程。 虚拟线程是用continuations实现的，但这只是一个细节。重要的是JDK中
JDK安装与环境变量配置(链接by网络)
weixin_34221112的博客
03-24 57
http://jingyan.baidu.com/article/6dad5075d1dc40a123e36ea3.html 转载于:https://www.cnblogs.com/sunhongmei/p/5316285.html
Java网络编程二（Java原生网络编程）
l18320786461的博客
04-20 916
一些常见术语： 说到Java原生网络编程，肯定离不开Socket。Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。 短连接： 连接->数据传输->关闭连接 传统http是无状态的，浏览器和服务器每次进行一次http请求，就奖励一次连接，但是任务结束后就中断。...
警惕 JDK8 UDP 和 Thread.interrupt 的 Bug
m0_46163918的博客
12-24 271
在DatagramChannelImpl.send 方法中会拿到两把锁，注意其中一把为 stateLock，即线程中的 - locked (a java.lang.Object)。1. 在 Thread.interrupt 方法中会调用 b.interrupt，注意这里会拿到 blokcerLock，即线程栈中的 - locked (a java.lang.Object)。所以，要么升级 JDK 到 13，要么死！
Linux中JDK配置和数据库安装与连接
BlackironRK的博客
10-22 209
Linux环境搭建 IP 检查IP地址：ip addr 如果没有显示ip地址则执行命令： service network restart 重启network网卡 service NetworkManager stop 关闭网卡 chkconfig NetworkManager off 永久关闭 Manager网卡 检查IP是否开启： 如果IP地址不对则进入IP地址的目录 cd /etc/sysconfig/network-scripts/ 之后修改IP地址 vim ifcfg-ens33
Netty框架-java基础网络-2 -原生jdk之AIO,BIO,NIO,Buffer
qq_36949403的博客
01-08 149
服务端提供IP和监听端口，客户端通过连接操作想服务端监听的地址发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字进行通信。 传统的同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口；Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
Netty 17道面试题和答案.docx
最新发布
06-15
它极大地简化并优化了TCP和UDP套接字服务器等网络编程，并且在性能以及安全性等很多方面甚至都要更好。支持多种协议如FTP、SMTP、HTTP以及各种二进制和基于文本的传统协议。官方总结称Netty成功地找到了一种在不妥协...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值