Java网络编程之TCP、UDP

2014-11-25 15:23 513人阅读 评论(0) 收藏 举报
分类：
java基础及多线程（28）

版权声明：本文为博主原创文章，未经博主允许不得转载。

Java网络编程提供了两种协议：TCP（传输控制协议）和UDP（数据报协议）。TCP（Transmission Control Protocol）是一种可靠的传输协议，传输时会采用“三次握手”端的方式建立连接，以保证数据的可靠性和安全性；而UDP（User Datagram Protocol）协议是一种不可靠的传输协议，发送的数据不一定能够接受的到，网上的聊天是工具一般采用的此协议。下面将详细的接受TCP和UDP的使 用以及相应的编码。

一、TCP网络通信
       Java中使用Socket（套接字）实现TCP。服务器端使用ServerSocket类，客户端使用Socket类实现。
     
       1、ServerSocket类
        其主要有如下的方法：

ServerSocket()   创建非绑定服务器套接字。
          ServerSocket(int port)  创建绑定到特定端口的服务器套接字。
        
          Socket accept()    侦听并接受到此套接字的连接。
           void close()    关闭此套接字
          boolean isClosed()   返回 ServerSocket 的关闭状态。
          InetAddress getInetAddress()    返回此服务器套接字的本地地址。
          void bind(SocketAddress endpoint)   将 ServerSocket 绑定到特定地址（IP 地址和端口号）。
          boolean isBound()   返回 ServerSocket 的绑定状态。
          SocketAddress getLocalSocketAddress()   返回此套接字绑定的端点的地址，如果尚未绑定则返回 null。
        
         服务器端每次运行是都要使用accept（）方法等待客户端的连接，此方法执行之后服务器端将进入阻塞状态，知道客户端连接之后程序才继续执行，此方法返回是Socket，代表一个客户端对象。
        
       2、Socket类
       两台机器连接通信的端点。主要使用如下方法：
     
      Socket(String host, int port)  创建一个流套接字并将其连接到指定主机上的指定端口号。
      OutputStream getOutputStream()   返回此套接字的输出流。
      InputStream getInputStream()    返回此套接字的输入流。
      boolean isBound()    返回套接字的绑定状态。
      boolean isClosed()   返回套接字的关闭状态。
      boolean isConnected()     返回套接字的连接状态。
      void close()     关闭此套接字。
     其通过字节流和服务端进行通信。

实例一、下面是实现一个简单的TCP客户端可服务器端通信。
   （1）服务器端：

[java] view plaincopy
  1. package andy.network.test;
  2. import java.io.IOException;
  3. import java.io.PrintStream;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6. /**
  7. * @author Zhang,Tianyou
  8. * version：2014-11-25 上午10:49:11
  9. *
  10. *
  11. */
  12. public class FirstTCPServer {
  13. /**
  14. * @param args
  15. * @throws IOException
  16. */
  17. public static void main(String[] args) throws IOException {
  18. //创建服务器
  19. ServerSocket server = null;
  20. Socket socket = null;
  21. PrintStream out = null;
  22. //服务器在9999上等待客户端的访问
  23. server = new ServerSocket(9999);
  24. System.out.println("服务器端已经运行，等待客户的响应。。。");
  25. //程序阻塞 等待客户端的访问
  26. socket = server.accept();
  27. //向客户端输出信息
  28. String str = "hello andy.";
  29. out = new PrintStream(socket.getOutputStream());
  30. out.print(str);
  31. out.close();
  32. socket.close();
  33. server.close();
  34. }
  35. }

（2）客户端：

[java] view plaincopy
  1. package andy.network.test;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.net.Socket;
  6. import java.net.UnknownHostException;
  7. /**
  8. * @author Zhang,Tianyou
  9. * version：2014-11-25 上午11:02:17
  10. *
  11. *
  12. */
  13. public class FirstTCPSocket {
  14. /**
  15. * @param args
  16. * @throws IOException
  17. * @throws UnknownHostException
  18. */
  19. public static void main(String[] args) throws UnknownHostException,
  20. IOException {
  21. // 定义客户端
  22. Socket client = null;
  23. // 设置地址和端口
  24. client = new Socket("localhost", 9999);
  25. BufferedReader buf = null; // 结束服务端流
  26. buf = new BufferedReader(new InputStreamReader(client.getInputStream()));
  27. String str = buf.readLine();
  28. System.out.println("服务器端通知信息：" + str);
  29. buf.close();
  30. client.close();
  31. }
  32. }

实例二
   实现客户端和服务器端的通信，服务器端可以响应多个客户端，每个客户端请求就启动一个线程。

(1)服务端

[java] view plaincopy
  1. package andy.network.test;
  2. import java.io.IOException;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  5. /**
  6. * @author Zhang,Tianyou
  7. * version：2014-11-25 上午11:41:22
  8. *
  9. *         聊天服务器端
  10. */
  11. public class ChatServer {
  12. /**
  13. * @param args
  14. * @throws IOException
  15. */
  16. public static void main(String[] args) throws IOException {
  17. ServerSocket server = null;
  18. Socket client = null;
  19. // 监听9999端口的连接
  20. server = new ServerSocket(9999);
  21. boolean  flag = true;
  22. while (flag) {
  23. System.out.println("服务器运行，等待客户端连接。");
  24. client = server.accept();
  25. // 对每一个客户端请求启动一个线程
  26. new Thread(new ChatThread(client)).start();
  27. }
  28. server.close();
  29. }
  30. }

对应服务端线程任务：

[java] view plaincopy
  1. package andy.network.test;
  2. import java.io.BufferedReader;
  3. import java.io.InputStreamReader;
  4. import java.io.PrintStream;
  5. import java.net.Socket;
  6. /**
  7. * @author Zhang,Tianyou
  8. * version：2014-11-25 上午11:24:26
  9. *
  10. *         使用多线程机制，在每个用户响应之后启动一个新任务
  11. *
  12. */
  13. public class ChatThread implements Runnable {
  14. // 接受客户端
  15. private Socket client = null;
  16. public ChatThread(Socket client) {
  17. this.client = client;
  18. }
  19. @Override
  20. public void run() {
  21. // 向客户端发送数据
  22. PrintStream out = null;
  23. // 接收客户端发来的数据
  24. BufferedReader buff = null;
  25. try {
  26. // 得到客户端的输入信息
  27. buff = new BufferedReader(new InputStreamReader(
  28. client.getInputStream()));
  29. out = new PrintStream(client.getOutputStream());
  30. //标志是否一个客户端的操作完毕
  31. boolean flag = true;
  32. while (flag) {
  33. //不断的接收信息
  34. String str = buff.readLine();
  35. if(str == null || "".equals(str)){
  36. flag = false;//客户端操作结束
  37. }else{
  38. if("bye".equals(str)){
  39. flag = false;
  40. out.println("bye-bye");
  41. }else {
  42. //向客户端回显输入
  43. out.println("you input:" + str);
  44. }
  45. }
  46. }
  47. out.close();
  48. client.close();
  49. } catch (Exception e) {
  50. System.out.println("服务器异常！");
  51. }
  52. }
  53. }

（2）客户端

[java] view plaincopy
  1. package andy.network.test;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.io.PrintStream;
  6. import java.net.Socket;
  7. import java.net.UnknownHostException;
  8. /**
  9. * @author Zhang,Tianyou
  10. * version：2014-11-25 上午11:53:03
  11. *
  12. *         聊天客户端程序
  13. *
  14. */
  15. public class ChatClient {
  16. public static void main(String[] args) throws UnknownHostException,
  17. IOException {
  18. Socket client = null;
  19. client = new Socket("localhost", 9999);
  20. // 接收服务器端的信息
  21. BufferedReader buff = null;
  22. // 向服务器端发送数据
  23. PrintStream out = null;
  24. BufferedReader input = null;
  25. // 获取键盘输入数据
  26. input = new BufferedReader(new InputStreamReader(System.in));
  27. out = new PrintStream(client.getOutputStream());
  28. buff = new BufferedReader(
  29. new InputStreamReader(client.getInputStream()));
  30. // 标志位
  31. boolean flag = true;
  32. while (flag) {
  33. System.out.println("输入信息：");
  34. String str = input.readLine();
  35. // 向服务器端输出信息
  36. out.println(str);
  37. if ("bye".equals(str)) {
  38. flag = false;
  39. } else {
  40. String chatCont = buff.readLine();
  41. System.out.println(chatCont);
  42. }
  43. }
  44. client.close();
  45. buff.close();
  46. }
  47. }

二、UDP网络通信
   TCP的通信是建立在可靠通信的基础上，UDP则是不可靠的通信，使用数据报形式发送数据。
   在Java中主要有DatagramPacket和DatagramSocket实现。

1、DatagramPacket主要方法
       DatagramPacket(byte[] buf, int length)
            构造 DatagramPacket，用来接收长度为 length 的数据包。
      DatagramPacket(byte[] buf, int length, InetAddress address, int port)
           构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
      byte[] getData()
            返回数据缓冲区。
     int getLength()
          返回将要发送或接收到的数据的长度。

2、DatagramSocket主要方法
     DatagramSocket(int port)
            创建数据报套接字并将其绑定到本地主机上的指定端口。
     void receive(DatagramPacket p)
            从此套接字接收数据报包。
     void send(DatagramPacket p)
            从此套接字发送数据报包。
 在使用UDP时，先使用客户端指定好要接受的数据和端口。然后开启服务端发送数据。

实现如下：
（1）客户端

[java] view plaincopy
  1. package andy.network.test;
  2. import java.io.IOException;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. /**
  6. * @author Zhang,Tianyou
  7. * version：2014-11-25 下午3:04:10
  8. *
  9. *         UDP客户端
  10. */
  11. public class UDPClient {
  12. /**
  13. * @param args
  14. * @throws IOException
  15. */
  16. public static void main(String[] args) throws IOException {
  17. // 客户在9999端口监听
  18. DatagramSocket dSocket = null;
  19. dSocket = new DatagramSocket(9999);
  20. // 定义接收数据的字节长度
  21. byte[] buff = new byte[1024];
  22. DatagramPacket dPacket = null;
  23. // 指定接收数据的长度1024
  24. dPacket = new DatagramPacket(buff, 1024);
  25. System.out.println("等待接受数据。。");
  26. //接收数据
  27. dSocket.receive(dPacket);
  28. String str = new String(dPacket.getData(), 0, dPacket.getLength())
  29. + "from" + dPacket.getAddress().getHostAddress() + ":"
  30. + dPacket.getPort();
  31. System.out.println(str);
  32. //关闭数据报套接字
  33. dSocket.close();
  34. }
  35. }

（2）服务器端

[java] view plaincopy
  1. package andy.network.test;
  2. import java.io.IOException;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. import java.net.InetAddress;
  6. /**
  7. * @author Zhang,Tianyou
  8. * version：2014-11-25 下午3:13:38
  9. *
  10. * UDP服务器端
  11. *
  12. */
  13. public class UDPServer {
  14. /**
  15. * @param args
  16. * @throws IOException
  17. */
  18. public static void main(String[] args) throws IOException {
  19. DatagramSocket dSocket = null;
  20. //服务端在3333端口监听
  21. dSocket = new DatagramSocket(3333);
  22. DatagramPacket dPacket = null;
  23. //要发生的数据
  24. String str = "hello andy!";
  25. //向目标端口地址发送数据报
  26. dPacket = new DatagramPacket(str.getBytes(), str.length(),
  27. InetAddress.getByName("localhost") , 9999);
  28. System.out.println("发送数据报");
  29. dSocket.send(dPacket);
  30. dSocket.close();
  31. }
  32. }

转载于:https://www.cnblogs.com/lykxqhh/p/5691225.html

Java网络编程之TCP、UDP相关推荐

  1. java网络编程之TCP通讯

    java中的网络编程之TCP协议的详细介绍,以及如何使用,同时我在下面举2例说明如何搭配IO流进行操作, 1 /* 2 *TCP 3 *建立连接,形成传输数据的通道: 4 *在连接中进行大数据量传输: ...

  2. 网络编程之 TCP / UDP 及其流程比较

    TCP与UDP的区别 1.基于连接与无连接 2.对系统资源的要求(TCP较多,UDP少) 3.UDP程序结构较简单 流模式与数据报模式 4.TCP保证数据正确性,UDP可能丢包 5.TCP保证数据顺序 ...

  3. 网络编程之TCP协议与UDP对比

    网络编程之TCP协议与UDP对比 UDP协议: 1,面向无连接. 2,不可靠协议,容易丢包. 3,速度快. 4,包体积有限制,64k以内. 通常,聊天,在线视频,凌波. TCP协议: 1.面向连接. ...

  4. java 网络编程简单聊天_网络编程之 TCP 实现简单聊天

    网络编程之 TCP 实现简单聊天 客户端 1.连接服务器 Socket 2.发送消息 package lesson02;import java.io.IOException;import java.i ...

  5. 萌新解--Java网络编程之UDP

    Java网络编程之UDP UDP协议为无连接的通信协议,在传数据前发送端与接收端不会先建立连接,也就是你发我就收但不一定会收到哦,以我们自身为发送端,我们不会事先让接收方知道我要给接收方发数据啦.就像 ...

  6. Python中的网络编程之TCP

    Python中的网络编程之TCP 文章目录 Python中的网络编程之TCP 1.TCP介绍 2.TCP特点 3.TCP与UDP的不同点 4.tcp通信模型 5.tcp客户端 6.tcp服务器 7.T ...

  7. 浅谈Java网络编程之Socket (2)

    <浅谈Java网络编程之Socket (1)>中我们已经和大家说到客户端的网络编程,下面和大家分享的是服务器的实现代码. import java.net.*; import java.io ...

  8. 浅谈Java网络编程之Socket (1)

    和大家一起分享的是Java网络编程之Socket.在Java中Socket可以理解为客户端或者服务器端的一个特殊的对象,这个对象有两个关键的方法,一个是getInputStream方法,另一个是get ...

  9. Java网络编程之NIO编程(待补充)

    Java网络编程之NIO编程(待补充) 学习网站1:http://ifeve.com/java-nio-all/ 学习网站2:http://www.ibm.com/developerworks/cn/ ...

最新文章

  1. js 数组、对象转json 以及json转 数组、对象
  2. Unity HDRP渲染管线基础指南
  3. [逆向][Writeup]ISG2015 flagfinder - .NET程序逆向
  4. 雷赛运动控制卡能不能用c语言_基于PMAC控制卡的三坐标测量机控制系统
  5. service get list一般规范
  6. 好947 Mybatis 配置resultMap 带參数查询Map 注意selectOne数据库返回结果一条数据库 否则会报错...
  7. iframe src 不加载页面_iframe和frame的区别是什么？iframe和frame的区别总结
  8. 计算机专业的八字,生辰八字自动计算器软件 生辰八字在线计算器
  9. 【线性代数】1.6矩阵的特征值和特征向量
  10. UI设计的色彩搭配及原则
  11. 机器学习笔记笔记之三——文本类型处理-词袋法、TF-IDF理解
  12. 基于asp.net的排球赛事网站设计与实现
  13. 玩转微信营销和推广的10种方法和技巧
  14. 新装修的房子多久能入住
  15. Lq93：复原 IP 地址
  16. 进一步的飞鸽传书官方网站消息
  17. 月薪30k和月薪15k的区别，程序员要迈的第一个门槛~
  18. 基于stm32的秒表计时器设计系统Proteus仿真（源码+仿真+全套资料）
  19. 博客小白如何快捷而又优雅的写好一篇博客
  20. 无需代码即可训练和可视化口罩检测模型

热门文章

  1. python 爬虫实例 电影-Python爬虫入门实战之猫眼电影数据抓取（实战篇）
  2. 零基础学python需要多久-Python要学习多久能入门?精通需要多久?
  3. python就业前景-Python就业前景分析
  4. python语言是谁发明的咋读-Python简史
  5. python动态图-Python处理gif动态图的解析与合成操作的介绍
  6. python话雷达图-python使用matplotlib绘制雷达图
  7. python使用方法视频-Python读取视频的两种方法（imageio和cv2）
  8. python映射类型-Python基础类型之字典（dict）
  9. python掌握程度怎么判断-Python学到什么程度可以面试工作？
  10. python运行非常慢的解决-为什么python运行的慢