Java基础巩固系列 TCP与UDP编程（网络通信的要素——网络通信协议）

最新推荐文章于 2019-12-07 22:36:21 发布
最新推荐文章于 2019-12-07 22:36:21 发布
阅读量163 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Peter__Li/article/details/89155704
版权

TCP与UDP属于传输层

TCP与UDP：

基于Socket的TCP编程

由上理论可知想要TCP编程必须使用到Socket，客户端（client）使用Socket，服务端（server）使用ServerSocket，也叫Socket编程

代码示例如下：

例一：

//TCP编程例一：客户端给服务端发送信息。服务端输出此信息到控制台上
//网络编程实际上就是Socket的编程
public class TestTCP1 {

    //客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;
        try {
            //1.创建一个Socket的对象，通过构造器指明服务端的IP地址，以及其接收程序的端口号
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
            //2.getOutputStream()：发送数据，方法返回OutputStream的对象
            os = socket.getOutputStream();
            //3.具体的输出过程
            os.write("我是客户端,请多关照".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭相应的流和Socket对象
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //服务端
    @Test
    public void server() {
        ServerSocket ss = null;
        Socket s = null;
        InputStream is = null;
        try {
            //1.创建一个ServerSocket的对象，通过构造器指明自身的端口号
            ss = new ServerSocket(9090);
            //2.调用其accept()方法，返回一个Socket的对象
            s = ss.accept();
            //3.调用Socket对象的getInputStream()获取一个从客户端发送过来的输入流
            is = s.getInputStream();
            //4.对获取的输入流进行的操作
            byte[] b = new byte[20];
            int len;
            while ((len = is.read(b)) != -1) {
                String str = new String(b, 0, len);
                System.out.print(str);
            }
            System.out.println("收到来自于:"+s.getInetAddress().getHostAddress()+"的连接");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.关闭相应的流以及Socket、ServerSocket的对象
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (s != null) {
                try {
                    s.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果：

client（客户端）：

 

server（服务端）：

我是客户端,请多关照 收到来自于:127.0.0.1的连接

例二：

//TCP编程例二：客户端给服务端发送信息，服务端将信息打印到控制台上，同时发送“已收到信息”给客户端
public class TestTCP2 {
    //客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;
        InputStream is = null;
        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 8989);
            os = socket.getOutputStream();
            os.write("我是客户端".getBytes());
            //shutdownOutput():执行此方法，显式地告诉服务端发送完毕!
            socket.shutdownOutput();
            is = socket.getInputStream();
            byte[] b = new byte[20];
            int len;
            while ((len = is.read(b)) != -1) {
                String str = new String(b, 0, len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    //服务端
    @Test
    public void server() {
        ServerSocket ss = null;
        Socket s = null;
        InputStream is = null;
        OutputStream os = null;
        try {
            ss = new ServerSocket(8989);
            s = ss.accept();
            is = s.getInputStream();
            byte[] b = new byte[20];
            int len;
            while ((len = is.read(b)) != -1) {
                String str = new String(b, 0, len);
                System.out.print(str);
            }
            os = s.getOutputStream();
            os.write("已收到信息".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (s != null) {
                try {
                    s.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

结果：

client：

已收到信息

server：

 我是客户端

例三：

//TCP编程例三：从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。并关闭相应的连接。
public class TestTCP3 {

    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        InputStream is = null;
        try {
            //创建Socket对象
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9898);
           //从本地获取一个文件发送给服务端
            os = socket.getOutputStream();
            fis = new FileInputStream(new File("1.png"));
            byte[] b = new byte[1024];
            int len;
            while ((len = fis.read(b)) != -1) {
                os.write(b, 0, len);
            }
            //3.终止输出流，告诉客户端已经写入发送完毕
            socket.shutdownOutput();
            //4.接收来自于服务端的信息
            is = socket.getInputStream();
            byte[] b2 = new byte[20];
            int len2;
            while ((len2 = is.read(b2)) != -1) {
                String str = new String(b2, 0, len2);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.关闭相应的流和Socket对象
            if (os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    @Test
    public void server() {
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        OutputStream os = null;
        try {
            //1.创建一个ServerSocket对象
            ss = new ServerSocket(9898);
            //2.调用其accept()方法，返回一个Socket对象
            socket = ss.accept();
            //3.将从客户端发送来的信息保存到本地
            is = socket.getInputStream();
            File file = new File("D:\\Java\\1.png");
            fos = new FileOutputStream(file);

            byte[] b = new byte[20];
            int len;
            while ((len = is.read(b)) != -1) {
                fos.write(b, 0, len);
            }
            System.out.println("收到来自于："+socket.getInetAddress().getHostAddress()+"的文件！");
            //4.发送“接收成功”的信息反馈给客户端
            os = socket.getOutputStream();
            os.write("success!发送成功！".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭相应的流和Socket以及ServerSocket对象
            if (os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null){
                try {
                    fos.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 (ss != null){
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

结果：

client：

success!发送成功！

server：

收到来自于：127.0.0.1的文件！

 

UDP编程则通过“Datagram”（数据报）来发送与接收，发送端使用DatagramSocket，接收端使用DatagramPacket：

UDP网络通信的流程：

代码示例如下：

//UDP编程的实现
public class TestUDP {

    //发送端
    @Test
    public void send() {
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket();
            byte[] b = "你好，我是要发送的数据".getBytes();
            //创建一个数据报，每一个数据报不能大于64k，都记录着数据信息，发送端的IP、端口号
            //以及要发送到的接收端的IP、端口号
            DatagramPacket pack = new DatagramPacket(b, 0, b.length,
                    InetAddress.getByName("127.0.0.1"), 9090);

            ds.send(pack);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ds != null) {
                ds.close();
            }
        }

    }

    //接收端
    @Test
    public void receive() {
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(9090);
            byte[] b = new byte[1024];
            DatagramPacket pack = new DatagramPacket(b, 0, b.length);
            ds.receive(pack);

            String str = new String(pack.getData(), 0, pack.getLength());
            System.out.println(str);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ds != null) {
                ds.close();
            }
        }

    }

}

结果：

send(发送端)：

 

reveive(接收端)：

你好，我是要发送的数据

 

 

--------------------------------------------------------------------------------我是分割线---------------------------------------------------------------------------------------

综合练习：

//客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端
public class TestExer {

    public static void main(String[] args) {
        TestExer.client();
    }

    private static void client() {

        Socket socket = null;
        Scanner scanner = null;
        OutputStream os = null;
        InputStream is = null;
        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9191);
            os = socket.getOutputStream();
            System.out.println("请输入多个字符：");
            scanner = new Scanner(System.in);
            String input = scanner.next();
            os.write(input.getBytes());
            socket.shutdownOutput();

            is = socket.getInputStream();
            byte[] b = new byte[10];
            int len;
            while ((len = is.read(b)) != -1) {
                String str = new String(b, 0, len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (scanner != null) {
                scanner.close();
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }


    @Test
    public void server() {
        ServerSocket ss = null;
        Socket s = null;
        InputStream is = null;
        OutputStream os = null;
        try {
            ss = new ServerSocket(9191);
            s = ss.accept();
            os = s.getOutputStream();
            is = s.getInputStream();
            byte[] b = new byte[10];
            int len;
            StringBuilder str = new StringBuilder();
            while ((len = is.read(b)) != -1) {
                String str1 = new String(b, 0, len);
                str.append(str1);
            }
            System.out.println("接收到的数据是：" + str);

            String strUpperCase = str.toString().toUpperCase();
            os.write(strUpperCase.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (s != null) {
                try {
                    s.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

结果:

client：

请输入多个字符：
asfsfdgfdhkfhmoirejioewnifnesonfniesionda
ASFSFDGFDHKFHMOIREJIOEWNIFNESONFNIESIONDA

server：

接收到的数据是：asfsfdgfdhkfhmoirejioewnifnesonfniesionda

 

Peter__Li
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
欧姆龙NJ系列FINS通讯.7z
06-20
OMRON系列PLC,NJ、NX1P2等PLC支持FINS/TCP UDP通讯仅限于学习使用，切勿用做商业运作。
Delphi通过TCP(Socket)读写欧姆龙PLC
07-18
一、基于Socket通讯，用TCP实现读写欧姆龙(Omron)PLC数据，包括布尔型、整型、双整型、浮点型、字符型等的读取写入方法。 二、程序附加了本人整理的Fins命令,软件测试结果实例。 三、作为测试程序，可能有些故障错误信息未完善，请大家多提宝贵建议。
CP1H与CH1L通信与自动化设备程序
03-11
CP1H与CH1L通信与自动化设备程序
简单使用SOCKET,TCP,UDP模式之间的通信
weixin_33991418的博客
07-10 97
TCP（Transmission Control Protocol传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能，用户数据报协议（UDP）是同一层内[1]另一个重要的传输协议。在因特网协议族（Internet protocol suite）中，TCP层是位于IP层之上，应用层之下...
欧姆龙PLC以太网FINSTCP通信例程与操作步骤
weixin_30846599的博客
09-02 2992
http://wenku.baidu.com/link?url=aa8kvtCg1eYp-wkIZY_hDpE5IuENT21Uvk1zVNtFiIyPTk-kjfarzSVyGt2DPs4ikXLT3zcpIY5V4b2ayJ91fmHtxxpqyiA34cIbuDseSeO http://wenku.baidu.com/view/b6b4f268f01dc281e53af0a...
Qt通过TCP/UDP实现网络通信
最新发布
04-04
Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信Qt通过TCP/UDP实现网络通信...
java网络编程使用tcp、udp实现多用户对话
01-10
总之，Java网络编程使用TCP和UDP实现多用户对话，涉及到客户端与服务器的连接建立、数据传输、异常处理、多线程或异步编程、以及安全性等多个方面。通过学习和实践，可以掌握这些关键技术，为开发高效、稳定的网络...
JAVA TCP-IP Socket网络通信编程研究.pdf
04-05
JAVA TCP-IP Socket 网络通信编程研究是关于使用 Java 语言实现基于 TCP/IP 协议的网络通信编程的研究。该研究主要关注于使用 Java Socket 实现 TCP/IP 网络程序框架及网络通信的程序实现。 关键词: 网络通信；Tcp/...
java网络编程UDP协议通信
06-14
通过java网络编程深入理解UDP协议通信，与TCP的区别等等 源码包每一行都有注释，在代码里面每一个类都有详细的注释来解释这个类的功能这个方法的功能，调用哪一个类的哪一个功能等等。 压缩包包含实验报告（实验原理...
使用C#实现基于TCP和UDP协议的网络通信程序的基本示例
01-20
C#中使用TCP通信 TCP通信需要通信双方都在线，所以需要先启动服务端进行监听，客户端才能获得连接，服务端代码： static void Main(string[] args) { TcpClient client = null; NetworkStream stream = null; ...
TCP/IP及Socket网络通讯
u010304442的博客
05-20 487
1.TCP/IP TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的通信协议，数据在传输前要建立连接，传输完毕后还要断开连接。客户端在收发数据前要使用 connect() 函数和服务器建立连接。建立连接的目的是保证IP地址、端口、物理链路等正确无误，为数据的传输开辟通道。其在网络的七层协议中所处的位置如下图： 1.1TCP数据...
Java数组算法——“回形数”或“回形矩阵” （数组元素的赋值类别算法）
Peter__Li的博客
12-07 2626
介绍： 从键盘输入一个整数（1~20） 则以该数字为矩阵的大小，把1,2,3…n*n的数字按照顺时针螺旋的形式填入其中。 例如：输入数字2，则程序输出： 1 2 4 3 输入数字3，则程序输出： 1 2 3 8 9 4 7 6 5 输入数字4，则程序输出： 1 2 ...
Java基础巩固系列 包装类
Peter__Li的博客
03-31 793
八种数据类型互对应的包装类示意图： 包装类转化： 代码： //包装类 8种基本数据类型对应着一个类，此类即为包装类 public class TestWrapper { //基本数据类型、包装类与String类之间的转换 @Test public void test2() { //基本数据类型、包装类 -----&g...
Java基础巩固系列 线程的通信
Peter__Li的博客
04-06 682
代码示例： //线程通信。如下的三个关键字使用的话，都得在同步代码块或同步方法中。 //wait()：一旦一个线程执行到wait()，就释放当前的锁。 //notify() notifyAll()：唤醒wait的一个或所有的线程 //使用两个线程打印1-100。线程1，线程2 交替打印 class PrintNumber implements Runnable { int num ...
Java基础巩固系列 通过反射获取类的完整结构——Mothed（方法篇）
Peter__Li的博客
04-09 663
因为演示需要，所以把Person类尽量的造得尽可能的复杂，如下 Person类： @MyAnnotation(value = "PeterLi") public class Person extends Creature<String> implements Comparable, MyInterface { public String name; privat...
Java基础巩固系列 通过反射获取类的完整结构——Field（属性篇）
Peter__Li的博客
04-08 432
因为演示需要，所以把Person类尽量的造得尽可能的复杂，如下 Person类： @MyAnnotation(value = "PeterLi") public class Person extends Creature<String> implements Comparable, MyInterface { public String name; privat...
Java基础巩固系列 死锁（DeadLock）
Peter__Li的博客
04-06 419
代码示例： //死锁的问题，处理线程同步容易出现。' //不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁 //写代码时，要避免死锁！ public class TestDeadLock { static StringBuffer sb1 = new StringBuffer(); static StringBuffer sb...
Java基础巩固系列 Buffered（缓冲流）
Peter__Li的博客
04-04 408
代码示例： /* * 抽象基类 节点流 缓冲流（处理流的一种,可以提升文件操作的效率） * InputSteam FileInputStream BufferedInputStream * OutputSteam FileOutputStream BufferedOutput...
Java基础巩固系列 IO流概述
Peter__Li的博客
04-04 367
IO原理1： IO原理2： 流的分类结构图： 流的分类： IO流体系： 节点流与处理流：
Java语言基础 Java网络编程技术 Java程序设计使用教程 第10章 网络通信（共53页）.ppt
12-25
"Java语言基础 Java网络编程技术 Java程序设计使用教程 第10章 网络通信（共53页）.ppt" 本资源详细介绍了Java语言在进行网络编程时的基本概念和技术，主要包括以下几个核心知识点： 1. **网络知识基础**：讲解了...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值