基于tcp和udp的socket实现

本文介绍如何用Java实现Socket编程。首先介绍Java针对Socket编程提供的类，以及它们之间的关系。然后分别针对TCP和UDP两种传输层协议实现Socket编程。

1 Java中的Socket编程接口介绍

Java为Socket编程封装了几个重要的类。

1.1 Socket类

Socket类实现了一个客户端socket，作为两台机器通信的终端，默认采用的传输层协议为TCP，是一个可靠传输的协议。Socket类除了构造函数返回一个socket外，还提供了connect, getOutputStream, getInputStream和close方法。connect方法用于请求一个socket连接，getOutputStream用于获得写socket的输出流，getInputStream用于获得读socket的输入流，close方法用于关闭一个流。

1.2 DatagramSocket类

DatagramSocket类实现了一个发送和接收数据报的socket，传输层协议使用UDP，不能保证数据报的可靠传输。DataGramSocket主要有send, receive和close三个方法。send用于发送一个数据报，Java提供了DatagramPacket对象用来表达一个数据报。receive用于接收一个数据报，调用该方法后，一直阻塞接收到直到数据报或者超时。close是关闭一个socket。

1.3 ServerSocket类

ServerSocket类实现了一个服务器socket，一个服务器socket等待客户端网络请求，然后基于这些请求执行操作，并返回给请求者一个结果。ServerSocket提供了bind、accept和close三个方法。bind方法为ServerSocket绑定一个IP地址和端口，并开始监听该端口。accept方法为ServerSocket接受请求并返回一个Socket对象，accept方法调用后，将一直阻塞直到有请求到达。close方法关闭一个ServerSocket对象。

1.4 SocketAddress

SocketAddress提供了一个socket地址，不关心传输层协议。这是一个虚类，由子类来具体实现功能、绑定传输协议。它提供了一个不可变的对象，被socket用来绑定、连接或者返回数值。

1.5 InetSocketAddress

InetSocketAddress实现了IP地址的SocketAddress，也就是有IP地址和端口号表达Socket地址。如果不制定具体的IP地址和端口号，那么IP地址默认为本机地址，端口号随机选择一个。

1.6. DatagramPacket

DatagramSocket是面向数据报socket通信的一个可选通道。数据报通道不是对网络数据报socket通信的完全抽象。socket通信的控制由DatagramSocket对象实现。DatagramPacket需要与DatagramSocket配合使用才能完成基于数据报的socket通信。

2. 基于TCP的Socket编程

上面描述了Java对Socket编程提供的接口，本节介绍如何实现一个基于TCP连接的Socket通信。

下面例子是Server端等待从Client端接收一条消息，然后再给客户端发送一个消息。

服务器端首先实例化ServerSocket对象，然后为其绑定一个本机地址，并开始监听。一直阻塞状态下等待客户端请求，当获得客户端连接请求后，返回一个socket对象。然后用这个socket接收一条消息，并发送一条消息。代码如下：

package server.socket.java;  import java.io.IOException; import java.io.PrintWriter; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.net.Socket; import java.net.SocketAddress;  public class SocketTcp {     static private String TAG = "SocketTcp: ";          public static void main(String[] args){         try {             ServerSocket server = new ServerSocket();             SocketAddress address = new InetSocketAddress(InetAddress.getLocalHost(), 10001);             server.bind(address);             System.out.println("==waiting for being connected...");             Socket client = server.accept();             System.out.println("==connected with " +                      client.getRemoteSocketAddress() );                          PrintWriter socketOut = new PrintWriter(client.getOutputStream());                          System.out.println("==waiting message from client...");             byte buf[] = new byte[1024];             if ( client.getInputStream().read(buf) > 0 ) {                 System.out.println("Receive Message: " + new String(buf));             }                          System.out.println("==sending message to client...");             String sendStr = "This is the message for client.";             socketOut.write(sendStr);             socketOut.flush();                          socketOut.close();             client.close();             server.close();         } catch (IOException e) {             System.out.println(TAG + e.getMessage());             e.printStackTrace();         }     } }

客户端首先实例化一个socket对象，用这个对象连接服务器端。连接成功后，发送一条消息，然后等待接收一条消息。代码如下：

package client.socket.java;  import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.Socket; import java.net.SocketAddress;  public class SocketTcp {     static private String TAG = "SocketTcp: ";          public static void main(String[] args){         try {             final Socket socket = new Socket();             SocketAddress address = new InetSocketAddress(InetAddress.getLocalHost(), 10001);             System.out.println("==connecting to server ...");             socket.connect(address);                          PrintWriter socketOut = new PrintWriter(socket.getOutputStream());             BufferedReader socketIn = new BufferedReader(                     new InputStreamReader(socket.getInputStream()) );                          String sendStr = "This is the message for server.";             System.out.println("==sending message to server ...");             socketOut.write(sendStr);             socketOut.flush();             System.out.println("==waiting message from server ...");             String receiveStr = socketIn.readLine();             System.out.println("Receive Message: " + receiveStr);                          socketOut.close();             socketIn.close();             socket.close();         } catch (IOException e) {             System.out.println(TAG + e.getMessage());             e.printStackTrace();         } finally {                      }     } }

服务器端运行结果：

==waiting for being connected... ==connected with /172.26.176.69:53912 ==waiting message from client... Receive Message: This is the message for server.

客户端运行结果：

==connecting to server ... ==sending message to server ... ==waiting message from server ... Receive Message: This is the message for client.

3 基于UDP的Socket编程示例

基于UDP的Socket编程与基于TCP的socket编程稍有不同，socket server和client都用DatagramSocket实现。

下面例子是Server端等待从Client端接收一条消息，然后再给客户端发送一个消息。

服务器端首先实例化DatagramSocket对象，然后为其绑定一个本机地址，并开始监听。一直阻塞状态下等待从客户端接收数据报。然后从数据报中获取数据报的源地址，然后用这个源地址作为目的地址打包一个数据报，然后发送出去。代码如下：

package server.socket.java;  import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.SocketAddress; import java.net.SocketException; import java.net.UnknownHostException;  public class SocketUdp {     final private static String TAG = "SocketUdp: ";          public static void main(String args[]) {         DatagramSocket socket = null;         DatagramPacket datapacket = null;         InetSocketAddress address = null;                  try {             address = new InetSocketAddress(InetAddress.getLocalHost(), 7778);             socket = new DatagramSocket(address);             // socket.bind(address);                          byte buf[] = new byte[1024];             datapacket = new DatagramPacket(buf, buf.length);             System.out.println("==block for receive messages...");             socket.receive(datapacket);             buf = datapacket.getData();             InetAddress addr = datapacket.getAddress();             int port = datapacket.getPort();             System.out.println("Message Content: " + new String(buf) );             System.out.println("Receive From " + addr + ":" + port);                          SocketAddress toAddress = datapacket.getSocketAddress();             String sendStr = "I'm Server, this is the message for client.";             buf = sendStr.getBytes();             datapacket = new DatagramPacket(buf, buf.length);             datapacket.setSocketAddress(toAddress);             socket.send(datapacket);             System.out.println("==message sended");                      } catch (UnknownHostException e) {             System.out.println(TAG + e.getMessage());             e.printStackTrace();         } catch (SocketException e) {             System.out.println(TAG + e.getMessage());             e.printStackTrace();         } catch (IOException e) {             System.out.println(TAG + e.getMessage());             e.printStackTrace();         }     }  }

客户端首先实例化一个DatagramSocket对象。利用服务器地址和端口号作为目的地址打包一个数据报，并发送。然后等待从服务器回复的数据报。代码如下：

package client.socket.java;  import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.SocketException; import java.net.UnknownHostException;  public class SocketUdp {     final private static String TAG = "SocketUdp: ";          public static void main(String args[]) {         try {             DatagramSocket getSocket = new DatagramSocket();             DatagramPacket datapacket = null;             InetSocketAddress toAddress = new InetSocketAddress(InetAddress.getLocalHost(), 7778);                          String sendStr = "I'm client, this is the message for server.";             byte buf[] = sendStr.getBytes();             datapacket = new DatagramPacket(buf, buf.length);             datapacket.setSocketAddress(toAddress);             getSocket.send(datapacket);             System.out.println("==message sended");                          System.out.println("==block for receive messages...");             getSocket.receive(datapacket);             buf = datapacket.getData();             System.out.println("Message Content: " + new String(buf));         } catch (SocketException e) {             System.out.println(TAG + e.getMessage());             e.printStackTrace();         } catch (UnknownHostException e) {             System.out.println(TAG + e.getMessage());             e.printStackTrace();         } catch (IOException e) {             System.out.println(TAG + e.getMessage());             e.printStackTrace();         }              } }

服务器端运行结果：

==block for receive messages... Message Content: I'm client, this is the message for server.

客户端运行结果：

==message sended ==block for receive messages... Message Content: I'm Server, this is the message for client.

分类: 网络编程,Java学习笔记

好文要顶关注我收藏该文

洪雁君
 关注 - 7
粉丝 - 3

+加关注

« 上一篇：传输层中的TCP和UDP浅析
 » 下一篇：长连接与短连接

posted on 2013-09-02 00:56 洪雁君阅读(4109) 评论(0) 编辑收藏

刷新评论刷新页面返回顶部

注册用户登录后才能发表评论，请登录或注册，访问网站首页。

» 更多知识库文章...

2017年11月

日

一

二

三

四

五

六

统计

随笔 - 27
文章 - 1
评论 - 1
引用 - 0

公告

昵称：洪雁君
园龄：7年6个月
粉丝：3
关注：7

+加关注

搜索

常用链接

我的标签

随笔分类

随笔档案

相册

blog配图(4)