TCP与UDP的区别 用途 例子
2011-01-08 19:56
357 查看
一.区别
二者都是有用的和常用的，如果纯粹从概念上区分二者就比较费解了，我们直接从功能上进行区分，简单明了：
这两种传输协议也就是合于适配不同的业务和不同的硬件终端。
在使用中，类似于图像、声音等对可靠性要求没有那么高的业务可以用UDP，他们不需要准确存储对准确性无要求但要求速度快。
类似于文本、程序、文件等要求可靠的数据最好就用TCP，但会牺牲一些速度。
对系统资源的要求：CP较多，UDP少。
程序结构：UDP程序结构较简单，TCP复杂。
流模式与数据报模式:TCP保证数据正确性，UDP可能丢包; TCP保证数据顺序，UDP不保证
二.用途
TCP是面向连接的，有比较高的可靠性，一些要求比较高的服务一般使用这个协议，如FTP、Telnet、SMTP、HTTP、POP3等，而UDP是面向无连接的，使用这个协议的常见服务有DNS、SNMP、QQ等。对于QQ必须另外说明一下，QQ2003以前是只使用UDP协议的，其服务器使用8000端口，侦听是否有信息传来，客户端使用4000端口，向外发送信息（这也就不难理解在一般的显IP的QQ版本中显示好友的IP地址信息中端口常为4000或其后续端口的原因了），即QQ程序既接受服务又提供服务，在以后的QQ版本中也支持使用TCP协议了。
Udp是一种面向无连接的通信协议，该协议使得数据传输的速度得到大幅度的提高。视频聊天语音聊天基本都是用UPD协议。
三. 在Java中使用UDP协议编程的相关类
1. InetAddress
用于描述和包装一个Internet IP地址。有如下方法返回实例：
getLocalhost()：返回封装本地地址的实例。
getAllByName(String host)：返回封装Host地址的InetAddress实例数组。
getByName(String host)：返回一个封装Host地址的实例。其中，Host可以是域名或者是一个合法的IP地址。
InetAddress.getByAddress(addr)：根据地址串返回InetAddress实例。
InetAddress.getByAddress(host, addr)：根据主机地符串和地址串返回InetAddress实例。
2. DatagramSocket
用于接收和发送UDP的Socket实例。该类有3个构造函数：
DatagramSocket()：通常用于客户端编程，它并没有特定监听的端口，仅仅使用一个临时的。程序会让操作系统分配一个可用的端口。
DatagramSocket(int port)：创建实例，并固定监听Port端口的报文。通常用于服务端
DatagramSocket(int port, InetAddress localAddr)：这是个非常有用的构建器，当一台机器拥有多于一个IP地址的时候，由它创建的实例仅仅接收来自LocalAddr的报文。
DatagramSocket具有的主要方法如下：
1）receive(DatagramPacket d)：接收数据报文到d中。receive方法产生一个“阻塞”。“阻塞”是一个专业名词，它会产生一个内部循环，使程序暂停在这个地方，直到一个条件触发。
2）send(DatagramPacket dp)：发送报文dp到目的地。
3）setSoTimeout(int timeout)：设置超时时间，单位为毫秒。
4）close()：关闭DatagramSocket。在应用程序退出的时候，通常会主动释放资源，关闭Socket，但是由于异常地退出可能造成资源无法回收。所以，应该在程序完成时，主动使用此方法关闭Socket，或在捕获到异常抛出后关闭Socket。
3. DatagramPacket
用于处理报文，它将Byte数组、目标地址、目标端口等数据包装成报文或者将报文拆卸成Byte数组。应用程序在产生数据包是应该注意，TCP/IP规定数据报文大小最多包含65507个，通常主机接收548个字节，但大多数平台能够支持8192字节大小的报文。DatagramPacket类的构建器共有4个：
DatagramPacket(byte[] buf, int length)：将数据包中Length长的数据装进Buf数组，一般用来接收客户端发送的数据。
DatagramPacket(byte[] buf, int offset, int length)：将数据包中从Offset开始、Length长的数据装进Buf数组。
DatagramPacket(byte[] buf, int length, InetAddress clientAddress, int clientPort)：从Buf数组中，取出Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口, 通常用来发送数据给客户端。
DatagramPacket(byte[] buf, int offset, int length, InetAddress clientAddress, int clientPort)：从Buf数组中，取出Offset开始的、Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口，通常用来发送数据给客户端。
主要的方法如下：
1）getData(): 从实例中取得报文的Byte数组编码。
2）setDate(byte[] buf)：将byte数组放入要发送的报文中。
四.例子
TCP: ServerSocket ss = new ServerSocket(2000);
UDP: 创建DatagramSocket对象，DatagramSocket区别于Tcp方式下的socket对象。
DatagramSocket ds=new DatagramSocket();
下面是具体的程序代码，已经编译通过，另外附件也是源码可以直接下载。
TCP服务器端
Java代码
package com.zakisoft.tcp;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServer {
public static void main(String[] args) throws Exception {
ServerSocket ss = new ServerSocket(2000);
while (true) {
Socket s = ss.accept();
System.out.println("A client has heen connected.");
InputStreamReader r = new InputStreamReader(s.getInputStream());
int c = 0;
while ((c = r.read()) > -1) {
System.out.print((char) c);
}
System.out.println();
r.close();
s.close();
}
}
}
TCP客户端
Java代码
package com.zakisoft.tcp;
import java.io.OutputStreamWriter;
import java.net.Socket;
public class TCPClient {
public static void main(String[] args) throws Exception {
Socket s = new Socket("127.0.0.1", 2000);
OutputStreamWriter w = new OutputStreamWriter(s.getOutputStream());
w.write("Hello服务器");
w.flush();
w.close();
s.close();
}
}
------------------------------------------------------------
UDP服务器端
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;
/**
* UDP服务类
*/
public class UdpServerSocket {
private byte[] buffer = new byte[1024];
private DatagramSocket ds = null;
private DatagramPacket packet = null;
private InetSocketAddress socketAddress = null;
private String orgIp;
/**
* 构造函数，绑定主机和端口.
*
* @param host
* 主机
* @param port
* 端口
* @throws Exception
*/
public UdpServerSocket(String host, int port) throws Exception {
socketAddress = new InetSocketAddress(host, port);
ds = new DatagramSocket(socketAddress);
System.out.println("服务端启动!");
}
public final String getOrgIp() {
return orgIp;
}
/**
* 设置超时时间，该方法必须在bind方法之后使用.
*
* @param timeout
* 超时时间
* @throws Exception
*/
public final void setSoTimeout(int timeout) throws Exception {
ds.setSoTimeout(timeout);
}
/**
* 获得超时时间.
*
* @return 返回超时时间.
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:34:36
*/
public final int getSoTimeout() throws Exception {
return ds.getSoTimeout();
}
/**
* 绑定监听地址和端口.
*
* @param host
* 主机IP
* @param port
* 端口
* @throws SocketException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:36:17
*/
public final void bind(String host, int port) throws SocketException {
socketAddress = new InetSocketAddress(host, port);
ds = new DatagramSocket(socketAddress);
}
/**
* 接收数据包，该方法会造成线程阻塞.
*
* @return 返回接收的数据串信息
* @throws IOException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:38:24
*/
public final String receive() throws IOException {
packet = new DatagramPacket(buffer, buffer.length);
ds.receive(packet);
orgIp = packet.getAddress().getHostAddress();
String info = new String(packet.getData(), 0, packet.getLength());
System.out.println("接收信息：" + info);
return info;
}
/**
* 将响应包发送给请求端.
*
* @param bytes
* 回应报文
* @throws IOException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午11:05:31
*/
public final void response(String info) throws IOException {
System.out.println("客户端地址 : " + packet.getAddress().getHostAddress()
+ ",端口：" + packet.getPort());
DatagramPacket dp = new DatagramPacket(buffer, buffer.length, packet
.getAddress(), packet.getPort());
dp.setData(info.getBytes());
ds.send(dp);
}
/**
* 设置报文的缓冲长度.
*
* @param bufsize
* 缓冲长度
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:47:49
*/
public final void setLength(int bufsize) {
packet.setLength(bufsize);
}
/**
* 获得发送回应的IP地址.
*
* @return 返回回应的IP地址
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:48:27
*/
public final InetAddress getResponseAddress() {
return packet.getAddress();
}
/**
* 获得回应的主机的端口.
*
* @return 返回回应的主机的端口.
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:48:56
*/
public final int getResponsePort() {
return packet.getPort();
}
/**
* 关闭udp监听口.
*
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:49:23
*/
public final void close() {
try {
ds.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 测试方法.
*
* @param args
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:49:50
*/
public static void main(String[] args) throws Exception {
String serverHost = "127.0.0.1";
int serverPort = 3366;
UdpServerSocket udpServerSocket = new UdpServerSocket(serverHost,
serverPort);
while (true) {
udpServerSocket.receive();
udpServerSocket.response("你好,KuToKu.com!");
}
}
}
UDP客户端
Java代码
package com.zakisoft.upd;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* UDP客户端程序，用于对服务端发送数据，并接收服务端的回应信息.
*/
public class UdpClientSocket {
private byte[] buffer = new byte[1024];
private DatagramSocket ds = null;
/**
* 构造函数，创建UDP客户端
*
* @throws Exception
*/
public UdpClientSocket() throws Exception {
ds = new DatagramSocket();
}
/**
* 设置超时时间，该方法必须在bind方法之后使用.
*
* @param timeout
* 超时时间
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:55:12
*/
public final void setSoTimeout(final int timeout) throws Exception {
ds.setSoTimeout(timeout);
}
/**
* 获得超时时间.
*
* @return 返回超时时间
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:55:25
*/
public final int getSoTimeout() throws Exception {
return ds.getSoTimeout();
}
public final DatagramSocket getSocket() {
return ds;
}
/**
* 向指定的服务端发送数据信息.
*
* @param host
* 服务器主机地址
* @param port
* 服务端端口
* @param bytes
* 发送的数据信息
* @return 返回构造后俄数据报
* @throws IOException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午11:02:41
*/
public final DatagramPacket send(final String host, final int port,
final byte[] bytes) throws IOException {
DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress
.getByName(host), port);
ds.send(dp);
return dp;
}
/**
* 接收从指定的服务端发回的数据.
*
* @param lhost
* 服务端主机
* @param lport
* 服务端端口
* @return 返回从指定的服务端发回的数据.
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:52:36
*/
public final String receive(final String lhost, final int lport)
throws Exception {
DatagramPacket dp = new DatagramPacket(buffer, buffer.length);
ds.receive(dp);
String info = new String(dp.getData(), 0, dp.getLength());
return info;
}
/**
* 关闭udp连接.
*
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:53:52
*/
public final void close() {
try {
ds.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 测试客户端发包和接收回应信息的方法.
*
* @param args
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午11:03:54
*/
public static void main(String[] args) throws Exception {
UdpClientSocket client = new UdpClientSocket();
String serverHost = "127.0.0.1";
int serverPort = 3366;
client.send(serverHost, serverPort, ("你好!").getBytes());
String info = client.receive(serverHost, serverPort);
System.out.println("服务端回应数据：" + info);
}
}
更多TCP和UPD的资料：
TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数 据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。
UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它 们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。
UDP 与 TCP 的主要区别在于 UDP 不一定提供可靠的数据传输。事实上，该协议不能保证数据准确无误地到达目的地。UDP 在许多方面非常有效。当某个程序的目标是尽快地传输尽可能多的信息时（其中任意给定数据的重要性相对较低），可使用 UDP。ICQ 短消息使用 UDP 协议发送消息。
许多程序将使用单独的TCP连接和单独的UDP连接。重要的状态信息随可靠的TCP连接发送，而主数据流通过UDP发送。
TCP的目的是提供可靠的数据传输，并在相互进行通信的设备或服务之间保持一个虚拟连接。TCP在数据包接收无序、丢失或在交付期间被破坏时，负责数据恢 复。它通过为其发送的每个数据包提供一个序号来完成此恢复。记住，较低的网络层会将每个数据包视为一个独立的单元，因此，数据包可以沿完全不同的路径发 送，即使它们都是同一消息的组成部分。这种路由与网络层处理分段和重新组装数据包的方式非常相似，只是级别更高而已。
为确保正确地接收数据，TCP要求在目标计算机成功收到数据时发回一个确认（即 ACK）。如果在某个时限内未收到相应的 ACK，将重新传送数据包。如果网络拥塞，这种重新传送将导致发送的数据包重复。但是，接收计算机可使用数据包的序号来确定它是否为重复数据包，并在必要 时丢弃它。
TCP与UDP的选择
如果比较UDP包和TCP包的结构，很明显UDP包不具备TCP包复杂的可靠性与控制机制。与TCP协议相同，UDP的源端口数和目的端口数也都支持一台 主机上的多个应用。一个16位的UDP包包含了一个字节长的头部和数据的长度，校验码域使其可以进行整体校验。（许多应用只支持UDP，如：多媒体数据 流，不产生任何额外的数据，即使知道有破坏的包也不进行重发。）
很明显，当数据传输的性能必须让位于数据传输的完整性、可控制性和可靠性时，TCP协议是当然的选择。当强调传输性能而不是传输的完整性时，如：音频和多 媒体应用，UDP是最好的选择。在数据传输时间很短，以至于此前的连接过程成为整个流量主体的情况下，UDP也是一个好的选择，如：DNS交换。把 SNMP建立在UDP上的部分原因是设计者认为当发生网络阻塞时，UDP较低的开销使其有更好的机会去传送管理数据。TCP丰富的功能有时会导致不可预料 的性能低下，但是我们相信在不远的将来，TCP可靠的点对点连接将会用于绝大多数的网络应用。
FTP协议即文件传输协议,它是一个标准协议,FTP协议也是应用TCP/IP协议的应用协议标准,它是在计算机和网络之间交换文件的最简单的方法。
文章地址：http://javapub.javaeye.com/blog/681138
二者都是有用的和常用的，如果纯粹从概念上区分二者就比较费解了，我们直接从功能上进行区分，简单明了：
这两种传输协议也就是合于适配不同的业务和不同的硬件终端。
在使用中，类似于图像、声音等对可靠性要求没有那么高的业务可以用UDP，他们不需要准确存储对准确性无要求但要求速度快。
类似于文本、程序、文件等要求可靠的数据最好就用TCP，但会牺牲一些速度。
对系统资源的要求：CP较多，UDP少。
程序结构：UDP程序结构较简单，TCP复杂。
流模式与数据报模式:TCP保证数据正确性，UDP可能丢包; TCP保证数据顺序，UDP不保证
二.用途
TCP是面向连接的，有比较高的可靠性，一些要求比较高的服务一般使用这个协议，如FTP、Telnet、SMTP、HTTP、POP3等，而UDP是面向无连接的，使用这个协议的常见服务有DNS、SNMP、QQ等。对于QQ必须另外说明一下，QQ2003以前是只使用UDP协议的，其服务器使用8000端口，侦听是否有信息传来，客户端使用4000端口，向外发送信息（这也就不难理解在一般的显IP的QQ版本中显示好友的IP地址信息中端口常为4000或其后续端口的原因了），即QQ程序既接受服务又提供服务，在以后的QQ版本中也支持使用TCP协议了。
Udp是一种面向无连接的通信协议，该协议使得数据传输的速度得到大幅度的提高。视频聊天语音聊天基本都是用UPD协议。
三. 在Java中使用UDP协议编程的相关类
1. InetAddress
用于描述和包装一个Internet IP地址。有如下方法返回实例：
getLocalhost()：返回封装本地地址的实例。
getAllByName(String host)：返回封装Host地址的InetAddress实例数组。
getByName(String host)：返回一个封装Host地址的实例。其中，Host可以是域名或者是一个合法的IP地址。
InetAddress.getByAddress(addr)：根据地址串返回InetAddress实例。
InetAddress.getByAddress(host, addr)：根据主机地符串和地址串返回InetAddress实例。
2. DatagramSocket
用于接收和发送UDP的Socket实例。该类有3个构造函数：
DatagramSocket()：通常用于客户端编程，它并没有特定监听的端口，仅仅使用一个临时的。程序会让操作系统分配一个可用的端口。
DatagramSocket(int port)：创建实例，并固定监听Port端口的报文。通常用于服务端
DatagramSocket(int port, InetAddress localAddr)：这是个非常有用的构建器，当一台机器拥有多于一个IP地址的时候，由它创建的实例仅仅接收来自LocalAddr的报文。
DatagramSocket具有的主要方法如下：
1）receive(DatagramPacket d)：接收数据报文到d中。receive方法产生一个“阻塞”。“阻塞”是一个专业名词，它会产生一个内部循环，使程序暂停在这个地方，直到一个条件触发。
2）send(DatagramPacket dp)：发送报文dp到目的地。
3）setSoTimeout(int timeout)：设置超时时间，单位为毫秒。
4）close()：关闭DatagramSocket。在应用程序退出的时候，通常会主动释放资源，关闭Socket，但是由于异常地退出可能造成资源无法回收。所以，应该在程序完成时，主动使用此方法关闭Socket，或在捕获到异常抛出后关闭Socket。
3. DatagramPacket
用于处理报文，它将Byte数组、目标地址、目标端口等数据包装成报文或者将报文拆卸成Byte数组。应用程序在产生数据包是应该注意，TCP/IP规定数据报文大小最多包含65507个，通常主机接收548个字节，但大多数平台能够支持8192字节大小的报文。DatagramPacket类的构建器共有4个：
DatagramPacket(byte[] buf, int length)：将数据包中Length长的数据装进Buf数组，一般用来接收客户端发送的数据。
DatagramPacket(byte[] buf, int offset, int length)：将数据包中从Offset开始、Length长的数据装进Buf数组。
DatagramPacket(byte[] buf, int length, InetAddress clientAddress, int clientPort)：从Buf数组中，取出Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口, 通常用来发送数据给客户端。
DatagramPacket(byte[] buf, int offset, int length, InetAddress clientAddress, int clientPort)：从Buf数组中，取出Offset开始的、Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口，通常用来发送数据给客户端。
主要的方法如下：
1）getData(): 从实例中取得报文的Byte数组编码。
2）setDate(byte[] buf)：将byte数组放入要发送的报文中。
四.例子
TCP: ServerSocket ss = new ServerSocket(2000);
UDP: 创建DatagramSocket对象，DatagramSocket区别于Tcp方式下的socket对象。
DatagramSocket ds=new DatagramSocket();
下面是具体的程序代码，已经编译通过，另外附件也是源码可以直接下载。
TCP服务器端
Java代码
package com.zakisoft.tcp;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServer {
public static void main(String[] args) throws Exception {
ServerSocket ss = new ServerSocket(2000);
while (true) {
Socket s = ss.accept();
System.out.println("A client has heen connected.");
InputStreamReader r = new InputStreamReader(s.getInputStream());
int c = 0;
while ((c = r.read()) > -1) {
System.out.print((char) c);
}
System.out.println();
r.close();
s.close();
}
}
}
package com.zakisoft.tcp;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServer {
public static void main(String[] args) throws Exception {
ServerSocket ss = new ServerSocket(2000);
while (true) {
Socket s = ss.accept();
System.out.println("A client has heen connected.");
InputStreamReader r = new InputStreamReader(s.getInputStream());
int c = 0;
while ((c = r.read()) > -1) {
System.out.print((char) c);
}
System.out.println();
r.close();
s.close();
}
}
}TCP客户端
Java代码
package com.zakisoft.tcp;
import java.io.OutputStreamWriter;
import java.net.Socket;
public class TCPClient {
public static void main(String[] args) throws Exception {
Socket s = new Socket("127.0.0.1", 2000);
OutputStreamWriter w = new OutputStreamWriter(s.getOutputStream());
w.write("Hello服务器");
w.flush();
w.close();
s.close();
}
}
package com.zakisoft.tcp;
import java.io.OutputStreamWriter;
import java.net.Socket;
public class TCPClient {
public static void main(String[] args) throws Exception {
Socket s = new Socket("127.0.0.1", 2000);
OutputStreamWriter w = new OutputStreamWriter(s.getOutputStream());
w.write("Hello服务器");
w.flush();
w.close();
s.close();
}
}------------------------------------------------------------
UDP服务器端
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;
/**
* UDP服务类
*/
public class UdpServerSocket {
private byte[] buffer = new byte[1024];
private DatagramSocket ds = null;
private DatagramPacket packet = null;
private InetSocketAddress socketAddress = null;
private String orgIp;
/**
* 构造函数，绑定主机和端口.
*
* @param host
* 主机
* @param port
* 端口
* @throws Exception
*/
public UdpServerSocket(String host, int port) throws Exception {
socketAddress = new InetSocketAddress(host, port);
ds = new DatagramSocket(socketAddress);
System.out.println("服务端启动!");
}
public final String getOrgIp() {
return orgIp;
}
/**
* 设置超时时间，该方法必须在bind方法之后使用.
*
* @param timeout
* 超时时间
* @throws Exception
*/
public final void setSoTimeout(int timeout) throws Exception {
ds.setSoTimeout(timeout);
}
/**
* 获得超时时间.
*
* @return 返回超时时间.
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:34:36
*/
public final int getSoTimeout() throws Exception {
return ds.getSoTimeout();
}
/**
* 绑定监听地址和端口.
*
* @param host
* 主机IP
* @param port
* 端口
* @throws SocketException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:36:17
*/
public final void bind(String host, int port) throws SocketException {
socketAddress = new InetSocketAddress(host, port);
ds = new DatagramSocket(socketAddress);
}
/**
* 接收数据包，该方法会造成线程阻塞.
*
* @return 返回接收的数据串信息
* @throws IOException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:38:24
*/
public final String receive() throws IOException {
packet = new DatagramPacket(buffer, buffer.length);
ds.receive(packet);
orgIp = packet.getAddress().getHostAddress();
String info = new String(packet.getData(), 0, packet.getLength());
System.out.println("接收信息：" + info);
return info;
}
/**
* 将响应包发送给请求端.
*
* @param bytes
* 回应报文
* @throws IOException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午11:05:31
*/
public final void response(String info) throws IOException {
System.out.println("客户端地址 : " + packet.getAddress().getHostAddress()
+ ",端口：" + packet.getPort());
DatagramPacket dp = new DatagramPacket(buffer, buffer.length, packet
.getAddress(), packet.getPort());
dp.setData(info.getBytes());
ds.send(dp);
}
/**
* 设置报文的缓冲长度.
*
* @param bufsize
* 缓冲长度
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:47:49
*/
public final void setLength(int bufsize) {
packet.setLength(bufsize);
}
/**
* 获得发送回应的IP地址.
*
* @return 返回回应的IP地址
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:48:27
*/
public final InetAddress getResponseAddress() {
return packet.getAddress();
}
/**
* 获得回应的主机的端口.
*
* @return 返回回应的主机的端口.
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:48:56
*/
public final int getResponsePort() {
return packet.getPort();
}
/**
* 关闭udp监听口.
*
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:49:23
*/
public final void close() {
try {
ds.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 测试方法.
*
* @param args
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:49:50
*/
public static void main(String[] args) throws Exception {
String serverHost = "127.0.0.1";
int serverPort = 3366;
UdpServerSocket udpServerSocket = new UdpServerSocket(serverHost,
serverPort);
while (true) {
udpServerSocket.receive();
udpServerSocket.response("你好,KuToKu.com!");
}
}
}
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketException;
/**
* UDP服务类
*/
public class UdpServerSocket {
private byte[] buffer = new byte[1024];
private DatagramSocket ds = null;
private DatagramPacket packet = null;
private InetSocketAddress socketAddress = null;
private String orgIp;
/**
* 构造函数，绑定主机和端口.
*
* @param host
* 主机
* @param port
* 端口
* @throws Exception
*/
public UdpServerSocket(String host, int port) throws Exception {
socketAddress = new InetSocketAddress(host, port);
ds = new DatagramSocket(socketAddress);
System.out.println("服务端启动!");
}
public final String getOrgIp() {
return orgIp;
}
/**
* 设置超时时间，该方法必须在bind方法之后使用.
*
* @param timeout
* 超时时间
* @throws Exception
*/
public final void setSoTimeout(int timeout) throws Exception {
ds.setSoTimeout(timeout);
}
/**
* 获得超时时间.
*
* @return 返回超时时间.
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:34:36
*/
public final int getSoTimeout() throws Exception {
return ds.getSoTimeout();
}
/**
* 绑定监听地址和端口.
*
* @param host
* 主机IP
* @param port
* 端口
* @throws SocketException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:36:17
*/
public final void bind(String host, int port) throws SocketException {
socketAddress = new InetSocketAddress(host, port);
ds = new DatagramSocket(socketAddress);
}
/**
* 接收数据包，该方法会造成线程阻塞.
*
* @return 返回接收的数据串信息
* @throws IOException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:38:24
*/
public final String receive() throws IOException {
packet = new DatagramPacket(buffer, buffer.length);
ds.receive(packet);
orgIp = packet.getAddress().getHostAddress();
String info = new String(packet.getData(), 0, packet.getLength());
System.out.println("接收信息：" + info);
return info;
}
/**
* 将响应包发送给请求端.
*
* @param bytes
* 回应报文
* @throws IOException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午11:05:31
*/
public final void response(String info) throws IOException {
System.out.println("客户端地址 : " + packet.getAddress().getHostAddress()
+ ",端口：" + packet.getPort());
DatagramPacket dp = new DatagramPacket(buffer, buffer.length, packet
.getAddress(), packet.getPort());
dp.setData(info.getBytes());
ds.send(dp);
}
/**
* 设置报文的缓冲长度.
*
* @param bufsize
* 缓冲长度
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:47:49
*/
public final void setLength(int bufsize) {
packet.setLength(bufsize);
}
/**
* 获得发送回应的IP地址.
*
* @return 返回回应的IP地址
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:48:27
*/
public final InetAddress getResponseAddress() {
return packet.getAddress();
}
/**
* 获得回应的主机的端口.
*
* @return 返回回应的主机的端口.
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:48:56
*/
public final int getResponsePort() {
return packet.getPort();
}
/**
* 关闭udp监听口.
*
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:49:23
*/
public final void close() {
try {
ds.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 测试方法.
*
* @param args
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:49:50
*/
public static void main(String[] args) throws Exception {
String serverHost = "127.0.0.1";
int serverPort = 3366;
UdpServerSocket udpServerSocket = new UdpServerSocket(serverHost,
serverPort);
while (true) {
udpServerSocket.receive();
udpServerSocket.response("你好,KuToKu.com!");
}
}
}UDP客户端
Java代码
package com.zakisoft.upd;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* UDP客户端程序，用于对服务端发送数据，并接收服务端的回应信息.
*/
public class UdpClientSocket {
private byte[] buffer = new byte[1024];
private DatagramSocket ds = null;
/**
* 构造函数，创建UDP客户端
*
* @throws Exception
*/
public UdpClientSocket() throws Exception {
ds = new DatagramSocket();
}
/**
* 设置超时时间，该方法必须在bind方法之后使用.
*
* @param timeout
* 超时时间
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:55:12
*/
public final void setSoTimeout(final int timeout) throws Exception {
ds.setSoTimeout(timeout);
}
/**
* 获得超时时间.
*
* @return 返回超时时间
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:55:25
*/
public final int getSoTimeout() throws Exception {
return ds.getSoTimeout();
}
public final DatagramSocket getSocket() {
return ds;
}
/**
* 向指定的服务端发送数据信息.
*
* @param host
* 服务器主机地址
* @param port
* 服务端端口
* @param bytes
* 发送的数据信息
* @return 返回构造后俄数据报
* @throws IOException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午11:02:41
*/
public final DatagramPacket send(final String host, final int port,
final byte[] bytes) throws IOException {
DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress
.getByName(host), port);
ds.send(dp);
return dp;
}
/**
* 接收从指定的服务端发回的数据.
*
* @param lhost
* 服务端主机
* @param lport
* 服务端端口
* @return 返回从指定的服务端发回的数据.
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:52:36
*/
public final String receive(final String lhost, final int lport)
throws Exception {
DatagramPacket dp = new DatagramPacket(buffer, buffer.length);
ds.receive(dp);
String info = new String(dp.getData(), 0, dp.getLength());
return info;
}
/**
* 关闭udp连接.
*
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:53:52
*/
public final void close() {
try {
ds.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 测试客户端发包和接收回应信息的方法.
*
* @param args
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午11:03:54
*/
public static void main(String[] args) throws Exception {
UdpClientSocket client = new UdpClientSocket();
String serverHost = "127.0.0.1";
int serverPort = 3366;
client.send(serverHost, serverPort, ("你好!").getBytes());
String info = client.receive(serverHost, serverPort);
System.out.println("服务端回应数据：" + info);
}
}
package com.zakisoft.upd;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* UDP客户端程序，用于对服务端发送数据，并接收服务端的回应信息.
*/
public class UdpClientSocket {
private byte[] buffer = new byte[1024];
private DatagramSocket ds = null;
/**
* 构造函数，创建UDP客户端
*
* @throws Exception
*/
public UdpClientSocket() throws Exception {
ds = new DatagramSocket();
}
/**
* 设置超时时间，该方法必须在bind方法之后使用.
*
* @param timeout
* 超时时间
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:55:12
*/
public final void setSoTimeout(final int timeout) throws Exception {
ds.setSoTimeout(timeout);
}
/**
* 获得超时时间.
*
* @return 返回超时时间
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:55:25
*/
public final int getSoTimeout() throws Exception {
return ds.getSoTimeout();
}
public final DatagramSocket getSocket() {
return ds;
}
/**
* 向指定的服务端发送数据信息.
*
* @param host
* 服务器主机地址
* @param port
* 服务端端口
* @param bytes
* 发送的数据信息
* @return 返回构造后俄数据报
* @throws IOException
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午11:02:41
*/
public final DatagramPacket send(final String host, final int port,
final byte[] bytes) throws IOException {
DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress
.getByName(host), port);
ds.send(dp);
return dp;
}
/**
* 接收从指定的服务端发回的数据.
*
* @param lhost
* 服务端主机
* @param lport
* 服务端端口
* @return 返回从指定的服务端发回的数据.
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:52:36
*/
public final String receive(final String lhost, final int lport)
throws Exception {
DatagramPacket dp = new DatagramPacket(buffer, buffer.length);
ds.receive(dp);
String info = new String(dp.getData(), 0, dp.getLength());
return info;
}
/**
* 关闭udp连接.
*
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午10:53:52
*/
public final void close() {
try {
ds.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 测试客户端发包和接收回应信息的方法.
*
* @param args
* @throws Exception
* @author <a href="mailto:abczww@163.com">KuToKu.com</a> Creation date:
* 2007-8-16 - 下午11:03:54
*/
public static void main(String[] args) throws Exception {
UdpClientSocket client = new UdpClientSocket();
String serverHost = "127.0.0.1";
int serverPort = 3366;
client.send(serverHost, serverPort, ("你好!").getBytes());
String info = client.receive(serverHost, serverPort);
System.out.println("服务端回应数据：" + info);
}
}更多TCP和UPD的资料：
TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数 据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。
UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它 们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。
UDP 与 TCP 的主要区别在于 UDP 不一定提供可靠的数据传输。事实上，该协议不能保证数据准确无误地到达目的地。UDP 在许多方面非常有效。当某个程序的目标是尽快地传输尽可能多的信息时（其中任意给定数据的重要性相对较低），可使用 UDP。ICQ 短消息使用 UDP 协议发送消息。
许多程序将使用单独的TCP连接和单独的UDP连接。重要的状态信息随可靠的TCP连接发送，而主数据流通过UDP发送。
TCP的目的是提供可靠的数据传输，并在相互进行通信的设备或服务之间保持一个虚拟连接。TCP在数据包接收无序、丢失或在交付期间被破坏时，负责数据恢 复。它通过为其发送的每个数据包提供一个序号来完成此恢复。记住，较低的网络层会将每个数据包视为一个独立的单元，因此，数据包可以沿完全不同的路径发 送，即使它们都是同一消息的组成部分。这种路由与网络层处理分段和重新组装数据包的方式非常相似，只是级别更高而已。
为确保正确地接收数据，TCP要求在目标计算机成功收到数据时发回一个确认（即 ACK）。如果在某个时限内未收到相应的 ACK，将重新传送数据包。如果网络拥塞，这种重新传送将导致发送的数据包重复。但是，接收计算机可使用数据包的序号来确定它是否为重复数据包，并在必要 时丢弃它。
TCP与UDP的选择
如果比较UDP包和TCP包的结构，很明显UDP包不具备TCP包复杂的可靠性与控制机制。与TCP协议相同，UDP的源端口数和目的端口数也都支持一台 主机上的多个应用。一个16位的UDP包包含了一个字节长的头部和数据的长度，校验码域使其可以进行整体校验。（许多应用只支持UDP，如：多媒体数据 流，不产生任何额外的数据，即使知道有破坏的包也不进行重发。）
很明显，当数据传输的性能必须让位于数据传输的完整性、可控制性和可靠性时，TCP协议是当然的选择。当强调传输性能而不是传输的完整性时，如：音频和多 媒体应用，UDP是最好的选择。在数据传输时间很短，以至于此前的连接过程成为整个流量主体的情况下，UDP也是一个好的选择，如：DNS交换。把 SNMP建立在UDP上的部分原因是设计者认为当发生网络阻塞时，UDP较低的开销使其有更好的机会去传送管理数据。TCP丰富的功能有时会导致不可预料 的性能低下，但是我们相信在不远的将来，TCP可靠的点对点连接将会用于绝大多数的网络应用。
FTP协议即文件传输协议,它是一个标准协议,FTP协议也是应用TCP/IP协议的应用协议标准,它是在计算机和网络之间交换文件的最简单的方法。
文章地址：http://javapub.javaeye.com/blog/681138
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- TCP与UDP的区别与用途
- 转载一个很好的TCP UDP 区别的例子
- C语言的Socket编程例子（TCP和UDP）
- TCP和UDP的区别和应用
- TCP与UDP的区别
- TCP和UDP的区别，如何选择使用
- SOCKET ： TCP和UDP区别的体现？？
- TCP和UDP的区别
- socket与TcpListener/TcpClient/UdpClient 的区别及联系
- Socket与TcpListener、TcpClient、UdpClient 的区别及联系
- TCP、UDP、HTTP、SOCKET之间的区别
- TCP协议，UDP协议，TCP/IP的区别
- 爱创课堂每日一题第七天8/31TCP和UDP的区别？
- TCP和UDP的原理、区别
- TCP与UDP的区别，以及它们各自的定义
- 网络编程：TCP 与 UDP 的区别
- socket、tcp、udp、http 的认识及区别
- UDP协议和TCP协议的区别
- Linux TCP/UDP小例子
- TCP、UDP、HTTP的区别