4219人阅读
Java（102）
简单解释就是：
短连接：建立连接，发送数据包，关闭连接
长连接：建立连接，发送数据包，发送心跳包，发送数据包，发送心跳包，发送心跳包。。。。。。
所以又频繁的数据收发的话，短连接会频繁创建TCP连接，而对于长连接，则始终用的是同一个TCP连接
package com.tree.demo.
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.net.ServerS
import java.net.S
public class ServerSocketDemo {
private static final int PORT = 1234;
private static final int BUFFER_SIZE = 1024;
public static void main(String[] args) {
// TODO Auto-generated method stub
ServerSocket ss = new ServerSocket(PORT);
Socket s = ss.accept();
System.out.println(&这是服务端，监听本机&+PORT+&端口&);
byte[] recData =
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
while(true) {
recData = new byte[BUFFER_SIZE];
int r = in.read(recData);
//int r = in.read(recData);
if(r&-1) {
String data = new String(recData);
if(data.trim().equals(&over&)) {
s.close();
System.out.println(&读取到客户端发送的来数据：&+data);
out.write(&这是服务端发给客户端的数据：&.getBytes());
out.write(recData);
System.out.println(&数据读取完毕！&);
s.close();
System.exit(0);
//ss.close();
} catch (IOException e) {
e.printStackTrace();
以上这种服务端读数据是阻塞式，如果客户端没有数据写过来，服务端就会一直阻塞在那不动
客户端开启一个telnet即可测试服务端的socket程序了，当然你也可以自己写一个socket客户端，如下：
import java.io.IOE
import java.io.OutputS
import java.net.S
import java.net.UnknownHostE
public class ClientSocketDemo {
private static final String HOST = &192.168.8.14&;
private static final int PORT = 1234;
public static void main(String[] args) throws UnknownHostException,
IOException {
Socket client = new Socket(HOST, PORT);
OutputStream out = client.getOutputStream();
while (true) {
Thread.sleep(1000);
System.out.println(&发送心跳数据包&);
out.write(&send heart beat data package !&.getBytes());
} catch (Exception e) {
e.printStackTrace();
out.close();
client.close();
同时这要是一个心跳的实例，心跳只要不出现异常的情况下，可以直接使用client连接发送数据包，不需要new socket新建连接了。
accept()等待连接，该方法阻塞当前线程直到建立连接为止
以上服务端的网络程序只能和一个客户端程序连接，拒绝多个客户端的连接。
我们可以通过线程来解决这个问题：每当程序建立一个新的套接字连接，也就是调用accept方法时，将启动一个新的线程来处理服务器和客户端的连接，而主程序将立即返回并等待下一个连接。
具体内容请见：
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：347193次
积分：5754
积分：5754
排名：第4430名
原创：204篇
转载：18篇
译文：12篇
评论：109条
(2)(1)(1)(2)(2)(1)(1)(2)(1)(2)(2)(1)(1)(3)(1)(1)(4)(2)(1)(6)(24)(6)(15)(11)(5)(3)(9)(13)(4)(1)(3)(2)(2)(8)(13)(4)(2)(4)(4)(6)(4)(4)(6)(30)(14)JAVA&Socket&底层是怎样基于TCP/IP&实现的？？？
首先必须明确：TCP/IP模型中有四层结构：
应用层（Application Layer）、传输层（Transport&
Layer）、网络层（Internet Layer& ）、链路层（LinkLayer）
&其中Ip协议（Internet
Protocol）是位于网络层的，TCP协议时位于传输层的。通过Ip协议可以使可以使两台计算机使用同一种语言，从而允许Internet上连接不同类型的计算机和不同操作系统的网络。Ip协议只保证计算机能够接收和发送分组数据。
当计算机要和远程的计算机建立连接时，TCP协议会让他们建立连接：用于发送和接收数据的虚拟电路。
在JAVA中，我们用 ServerSocket、Socket类创建一个套接字连接，从套接字得到的结果是一个InputStream以及OutputStream对象，以便将连接作为一个IO流对象对待。通过IO流可以从流中读取数据或者写数据到流中，读写IO流会有异常IOException产生。
套接字或插座(socket)是一种软件形
式的抽象，用于表达两台机器间一个连接的“终端”。针对一个特定的连接，每台机器上都有一个“套接字”，可以想象它们之间有一条虚拟的“线缆”。JAVA
有两个基于数据流的套接字类：ServerSocket，服务器用它“侦听”进入的连接；Socket，客户端用它初始一次连接。侦听套接字只能接收新的
连接请求，不能接收实际的数据包，即ServerSocket不能接收实际的数据包。
& 套接字是基于TCP/IP实现的，它是用来提供一个访问TCP的服务接口，或者说套接字socket是TCP的应用编程接口API，通过它应用层就可以访问TCP提供的服务。
在JAVA中，我们用
ServerSocket、Socket类创建一个套接字连接，从套接字得到的结果是一个InputStream以及OutputStream对象，以便
将连接作为一个IO流对象对待。通过IO流可以从流中读取数据或者写数据到流中，读写IO流会有异常IOException产生。
套接字底层是基于TCP的，所以socket的超时和TCP超时是相同的。下面先讨论套接字读写缓冲区，接着讨论连接建立超时、读写超时以及JAVA套接字编程的嵌套异常捕获和一个超时例子程序的抓包示例。
socket读写缓冲区
一旦创建了一个套接字实例，操作系统就会为其分配缓冲区以存放接收和要发送的数据。
<img src="/blog7style/images/common/sg_trans.gif" real_src ="http://hi.csdn.net/attachment//0_WUMW.gif" ALT=""
TITLE="JAVA&Socket&底层是怎样基于TCP/IP&实现的？？？" />
JAVA可以设置读写缓冲区的大小-setReceiveBufferSize(int size),
setSendBufferSize(int size)。
& 向输出流写数据并不意味着数据实际上已经被发送，它们只是被复制到了发送缓冲区队列SendQ，就是在Socket的OutputStream上调用
flush()方法，也不能保证数据能够立即发送到网络。真正的数据发送是由操作系统的TCP协议栈模块从缓冲区中取数据发送到网络来完成的。
当有数据从网络来到时，TCP协议栈模块接收数据并放入接收缓冲区队列RecvQ，输入流InputStream通过read方法从RecvQ中取出数据。
2 socket连接建立超时
socket连接建立是基于TCP的连接建立过程。TCP的连接需要通过3次握手报文来完成，开始建立TCP连接时需要发送同步SYN报文，然后等待确认
报文SYN+ACK，最后再发送确认报文ACK。TCP连接的关闭通过4次挥手来完成，主动关闭TCP连接的一方发送FIN报文，等待对方的确认报文；被
动关闭的一方也发送FIN报文，然等待确认报文。
<img src="/blog7style/images/common/sg_trans.gif" real_src ="http://hi.csdn.net/attachment//0_wwwr.gif" ALT="" NAME="image_operate_13027"
TITLE="JAVA&Socket&底层是怎样基于TCP/IP&实现的？？？" />
& 正在等待TCP连接请求的一端有一个固定长度的连接队列，该队列中的连接已经被TCP接受（即三次握手已经完成），但还没有被应用层所接受。TCP接受一个连接是将其放入这个连接队列，而应用层接受连接是将其从该队列中移出。应用层可以通过设置backlog变量来指明该连接队列的最大长度，即已被TCP接受而等待应用层接受的最大连接数。
当一个连接请求SYN到达时，TCP确定是否接受这个连接。如果队列中还有空间，TCP模块将对SYN进行确认并完成连接的建立。但应用层只有在三次握手中的第三个报文收到后才会知道这个新连接。如果队列没有空间，TCP将不理会收到的SYN。
如果应用层不能及时接受已被TCP接受的连接，这些连接可能占满整个连接队列，新的连接请求可能不被响应而会超时。如果一个连接请求SYN发送后，一段时间后没有收到确认SYN+ACK，TCP会重传这个连接请求SYN两次，每次重传的时间间隔加倍，在规定的时间内仍没有收到SYN+ACK，TCP将放弃这个连接请求，连接建立就超时了。
Socket连接建立超时和TCP是相同的，如果TCP建立连接时三次握手超时，那么导致Socket连接建立也就超时了。可以设置Socket连接建立的超时时间-
connect(SocketAddress endpoint, int
如果在timeout内，连接没有建立成功，在TimeoutException异常被抛出。如果timeout的值小于三次握手的时间，那么Socket连接永远也不会建立。
不同的应用层有不同的连接建立过程，Socket的连接建立和TCP一样-仅仅需要三次握手就完成连接，但有些应用程序需要交互很多信息后才能成功建立连接，比如Telnet协议，在TCP三次握手完成后，需要进行选项协商之后，Telnet连接才建立完成。
3 socket读超时
如果输入缓冲队列RecvQ中没有数据，read操作会一直阻塞而挂起线程，直到有新的数据到来或者有异常产生。调用setSoTimeout(int
timeout)可以设置超时时间，如果到了超时时间仍没有数据，read会抛出一个SocketTimeoutException，程序需要捕获这个异
常，但是当前的socket连接仍然是有效的。
如果对方进程崩溃、对方机器突然重启、网络断开，本端的read会一直阻塞下去（由前面可知：双方要关闭连接需要四次挥手
.对方机重启或断开只是对方机的TCP连接关闭，本端的TCP连接还没关闭，所以本端机会一直阻塞），这时设置超时时间是非常重要的，否则调用read的线程会一直挂起。
TCP模块把接收到的数据放入RecvQ中，直到应用层调用输入流的read方法来读取。如果RecvQ队列被填满了，这时TCP会根据滑动窗口机制通知
对方不要继续发送数据，本端停止接收从对端发送来的数据，直到接收者应用程序调用输入流的read方法后腾出了空间。
4 socket写超时
socket的写超时是基于TCP的超时重传。超时重传是TCP保证数据可靠性传输的一个重要机制，其原理是在发送一个数据报文后就开启一个计时器，在一
定时间内如果没有得到发送报文的确认ACK，那么就重新发送报文。如果重新发送多次之后，仍没有确认报文，就发送一个复位报文RST，然后关闭TCP连
接。首次数据报文发送与复位报文传输之间的时间差大约为9分钟，也就是说如果9分钟内没有得到确认报文，就关闭连接。但是这个值是根据不同的TCP协议栈
实现而不同。
如果发送端调用write持续地写出数据，直到SendQ队列被填满。如果在SendQ队列已满时调用write方法，则write将被阻塞，直到
SendQ有新的空闲空间为止，也就是说直到一些字节传输到了接收者套接字的RecvQ中。如果此时RecvQ队列也已经被填满，所有操作都将停止，直到
接收端调用read方法将一些字节传输到应用程序。
& 当Socket的write发送数据时，如果网线断开、对端进程崩溃或者对端机器重启动，（由前面可知：双方要关闭连接需要四次挥手
.对端进程崩溃或者对端机器重启动只是对方机的TCP连接关闭，本端的TCP连接还没关闭，所以本端机会一直阻塞）TCP模块会重传数据，最后超时而关闭连接。下次如再调用write会导致一个异常而退出。
Socket写超时是基于TCP协议栈的超时重传机制，一般不需要设置write的超时时间，也没有提供这种方法。
5 双重嵌套异常捕获
&&如果ServerSocket、Socket构造失败，只需要仅仅捕获这个构造失败异常而不需要调用套接字的close方法来释放资源(必须保证构造失败
后不会留下任何需要清除的资源)，因为这时套接字内部资源没有被成功分配。如果构造成功，必须进入一个try
finally语句块里调用close释放套接字。请参照下面例子程序。
import java.net.*;
import java.io.*;
public class SocketClientTest
& public static final int PORT = 8088;
& public static void main( String[] args ) throws
&&& InetAddress
addr = InetAddress.getByName( "127.0.0.1" );
&&& Socket
socket = new Socket();
socket.connect( new InetSocketAddress( addr, PORT ), 30000 );
socket.setSendBufferSize(100);
BufferedWriter out = new BufferedWriter( new OutputStreamWriter(
socket.getOutputStream() ) );
int i = 0;
while( true )
System.out.println( "client sent --- hello *** " + i++ );
out.write( "client sent --- hello *** " + i );
out.flush();
Thread.sleep( 1000 );
socket.close();
import java.io.*;
import java.net.ServerS
import java.net.S
public class SocketServerTest
& public static final int PORT = 8088;
& public static final int BACKLOG = 2;
& public static void main( String[] args ) throws
IOException
&&& ServerSocket
server = new ServerSocket( PORT, BACKLOG );
System.out.println("started: " + server);
Socket socket = server.accept();
BufferedReader in = new BufferedReader( new InputStreamReader(
socket.getInputStream() ) );
String info =
while( ( info = in.readLine() ) != null )
System.out.println( info );
socket.close();
server.close();
执行上面的程序，在程序运行一会儿之后，断开client和server之间的网络连接，在机器上输出如下：
Server上的输出：
Echoing:client sent
-----hello0
Echoing:client sent
-----hello1
Echoing:client sent
-----hello2
Echoing:client sent
-----hello3
Echoing:client sent
-----hello4
Echoing:client sent
-----hello5
Echoing:client sent
-----hello6
断开了网络连接之后没有数据输出
Client上的输出：
socket default timeout
Socket[addr=/10.15.9.99,port=8088,localport=4691]
client sent --- hello
client sent --- hello
client sent --- hello
client sent --- hello
client sent --- hello
client sent --- hello
client sent --- hello
client sent --- hello
client sent --- hello
client sent --- hello
client sent --- hello
&----&&&断开网络连接后客户端进程挂起
: Connection reset by peer: socket write error
java.net.SocketOutputStream.socketWrite0(
java.net.SocketOutputStream.socketWrite(
java.net.SocketOutputStream.write(
sun.nio.cs.StreamEncoder.writeBytes(
sun.nio.cs.StreamEncoder.implFlushBuffer(
sun.nio.cs.StreamEncoder.implFlush(
sun.nio.cs.StreamEncoder.flush(
java.io.OutputStreamWriter.flush(
java.io.BufferedWriter.flush(
com.xtera.view.SocketClientTest.main(
当hello6被发送到server端后，网络连接被断开，这时server端不能接收任何数据而挂起。client端仍然继续发送数据，实际上
hello7、hello8、hello9、hello10都被复制到SendQ队列中，write方法立即返回。当client的SendQ队列被填满
之后，write方法就被阻塞。TCP模块在发送报文hello7之后，没有收到确认而超时重传，再重传几次之后关闭了TCP连接，同时导致被阻塞的
write方法异常返回。
通过抓包工具，我们可以看到超时重传的报文。
<img src="/blog7style/images/common/sg_trans.gif" real_src ="http://hi.csdn.net/attachment//0_a9B.gif" ALT="" NAME="image_operate_63866"
TITLE="JAVA&Socket&底层是怎样基于TCP/IP&实现的？？？" />
<img src="/blog7style/images/common/sg_trans.gif" real_src ="http://hi.csdn.net/attachment//0_Q5.gif" ALT="" NAME="image_operate_67313"
TITLE="JAVA&Socket&底层是怎样基于TCP/IP&实现的？？？" />
下面是规范代码实例：（服务端和客户端实现双向（可通过键盘输入）交互通信）
public class JabberClient {
& public static void main(String[] args)
throws IOException {
&&& // Passing
null to getByName() produces the
&&& // special
"Local Loopback" IP address, for
&&& // testing
on one machine w/o a network:
&&& InetAddress
InetAddress.getByName("127.0.0.1");
Alternatively, you can use
&&& // the
address or name:
InetAddress addr =
InetAddress.getByName("127.0.0.1");
InetAddress addr =
InetAddress.getByName("localhost");
System.out.println("addr = " + addr);
&&& Socket
new Socket(addr, JabberServer.PORT);
&&& // Guard everything in a try-finally to make
&&& // sure that
the socket is closed:
System.out.println("socket = " + socket);
BufferedReader KeyIn = new BufferedReader(new
InputStreamReader(System.in));
BufferedReader in =
new BufferedReader(
new InputStreamReader(
&&&&&&&&&&&
socket.getInputStream()));
// Output is
automatically flushed
// by PrintWriter:
PrintWriter out =
new PrintWriter(
new BufferedWriter(
&&&&&&&&&&&
new OutputStreamWriter(
&&&&&&&&&&&&&
socket.getOutputStream())),true);
for(int i = 0; i & 10; i ++) {
out.println("howdy " + i);
String str = in.readLine();
System.out.println(str);
out.println("END");
String str =
while(true)
& str = KeyIn.readLine();
& if("END".equals(str))
& out.println(str);
System.out.println("Server:"+in.readLine());
&&& } finally
System.out.println("closing...");
socket.close();
public class JabberServer {&
& // Choose a port outside of the range
& public static final int PORT = 8088;
& public static void main(String[] args)
throws IOException {
&&& ServerSocket
s = new ServerSocket(PORT);
System.out.println("Started: " + s);
Socket socket = s.accept();
System.out.println(
"Connection accepted: "+ socket);
BufferedReader KeyIn = new BufferedReader(new
InputStreamReader(System.in));
BufferedReader in =
new BufferedReader(
&&&&&&&&&&&
new InputStreamReader(
&&&&&&&&&&&&&
socket.getInputStream()));
// Output is automatically flushed
// by PrintWriter:
PrintWriter out =
new PrintWriter(
&&&&&&&&&&&
new BufferedWriter(
&&&&&&&&&&&&&
new OutputStreamWriter(
&&&&&&&&&&&&&&&
socket.getOutputStream())),true);
while (true) {&
String str = in.readLine();
if (str.equals("END"))
System.out.println("Client: " + str);
out.println(KeyIn.readLine());
&&&&& // Always close the
two sockets...
} finally {
System.out.println("closing...");
socket.close();
&&& } finally
s.close();
注意：一般在传输字符信息（例如txt文件，聊天信息）使用bufferedRead,printWrite&
，但是在传送一些文件时一定要使用字节输入输出流socket.getInputStream&&
和scoket.getOutputStream(但是
使用上面的字符流传输文件时，当文件传送完毕时打开会报错！！！)
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。5644人阅读
Java Socket（9）
在当前网络通信中（TCP/IP也不例外）有三种通信模式：单播、广播、组播(又叫多播, 个人感觉叫多播描述的有点不恰当)，其中多播出现的时间最晚，但同时具备单播和广播的优点，最具有发展前景。
通信方式分类：
&&& 1.单播：单台主机与单台主机之间的通信；
&&& 2.广播：单台主机与网络中所有主机的通信；
&&& 3.组播：单台主机与选定的一组主机的通信；
&&&& 单播是网络通信中最常见的，网络节点之间的通信 就好像是人们之间的对话一样。如果一个人对另外一个人说话，
&&&& 那么用网络技术的术语来描述就是“单播”，此时信息的接收和传递只在两个节点之间进行。
&&&& 1. 单播的优点：
&&&&&&&& (1)服务器以及响应客户端的请求；
&&&&&&&& (2)服务器能针对每个客户端的不同请求发送不同的响应，容易显示个性化服务；
&&&& 2. 单播的缺点：
&&&&&&&& (1)服务器针对每个客户机发送数据流，服务器流量＝客户机数量×客户机流量；在客户数量大、每个客户机流量大的流媒体应用中服务器不堪重负；
&&&& 3. 应用场景：
&&&&&&&&单播在网络中得到了广泛的应用，网络上绝大部分的数据都 是以单播的形式传输的。例如：收发电子邮件、游览网页时，必须与邮件服务器、
&&&&&&& 服务器建立连接，此时使用的就是单播通信方式；
&&&&“广播”可以比方为：一个人通过广播喇叭对在场的全体说话(他才不管你是否乐意听)。换句话说: 广播是一台主机对某一个网络上的所有主机发送数据报包。
&&& 这个网络可能是网络，也可能时子网，还有可能是所有子网。
&&& 广播有两类：本地广播和定向广播：
&&&&&&&&&&& 定向广播：将数据报包发送到本网络之外的特定网络的所有主机，然而，由于互联网上的大部分路由器都不转发定向广播消息，所以这里不深入介绍了
&&&&&&&&&&& 本地广播：将数据报包发送到本地网络的所有主机，IPv4的本地广播地址为“255.255.255.255”，路由器不会转发此广播；
&&& 1.广播的优点：
&&&&&& (1)通信的效率高，信息一下子就可以传递到某一个网络上的所有主机。
&&&&&& (2)由于服务器不用向每个客户端单独发送数据，所以服务器流量比较负载低；
&&& 2.广播的缺点：
&&&&&& (1)非常占用网络的带宽；
&&&&&& (2)缺乏针对性,也不管主机是否真的需要接收该数据, 就强制的接收数据；
&&& 3.应用场景：
&&&&&& (1)有线电视就是典型的广播型网络
&&&& ”组播“可以比方为：你对着大街喊：”是男人的来一下，一人发一百块”，那么男的过来，女就不会过来,因为没有钱发她不理你(组播：其中所有的男生就是一个组)，
&&&& 换句话说: 组播是一台主机向指定的一组主机发送数据报包，因为如果采用单播方式，逐个节点传输，有多少个目标节点，就会有多少次传送过程，这种方式显然效率 极低，是不可取&&
&&&& 的；如果采用不区分目标、全部发送的广播方式，虽然一次可以传送完数据，但是显然达不到区分特定数据接收对象的目的，又会占用网络带宽。采用组播方式，既可以 实现一次传送所
&&&& 有目标节点的数据，也可以达到只对特定对象传送数据的目的。
&&&& IP网络的组播一般通过组播IP地址来实现。组播IP地址就是D类IP地址，即224.0.0.0至239.255.255.255之间的IP地址。
&&&& 1.组播的优点：
&&&&&&& (1)具备广播所具备的所有优点；
&&& (2)与单播相比，提供了发送数据报包的效率，与广播相比，减少了网络流量；
&&&& 2.组播的缺点：
&&&&&&& (1)与单播协议相比没有纠错机制，发生丢包错包后难以弥补，但可以通过一定的容错机制和QOS加以弥补；
应用实例：
&& 1.UDP单播的例子
import java.io.IOE
import java.net.DatagramP
import java.net.DatagramS
import java.net.InetA
import java.net.InetSocketA
import java.net.SocketA
public class ClientTest
private static final int MAXRECEIVED = 255;
public static void main(String[] args) throws IOException
byte[] msg = new String(&connect test successfully!!!&).getBytes();
DatagramSocket client = new DatagramSocket();
InetAddress inetAddr = InetAddress.getLocalHost();
SocketAddress socketAddr = new InetSocketAddress(inetAddr, 8888);
DatagramPacket sendPacket = new DatagramPacket(msg, msg.length,
socketAddr);
client.send(sendPacket);
client.close();
import java.io.IOE
import java.net.DatagramP
import java.net.DatagramS
import java.util.A
public class ServerTest
&&& private static final int MAXREV = 255;
&&& public static void main(String[] args) throws IOException
&&&&&&& DatagramSocket server = new DatagramSocket(8888);
&&&&&&& DatagramPacket recvPacket = new DatagramPacket(new byte[MAXREV], MAXREV);
&&&&&&& while (true)
&&&&&&&&&&& server.receive(recvPacket);
&&&&&&&&&&& byte[] receiveMsg = Arrays.copyOfRange(recvPacket.getData(),
&&&&&&&&&&&&&&&&&&& recvPacket.getOffset(),
&&&&&&&&&&&&&&&&&&& recvPacket.getOffset() + recvPacket.getLength());
&&&&&&&&&&& System.out.println(&Handing at client &
&&&&&&&&&&&&&&&&&&& + recvPacket.getAddress().getHostName() + & ip &
&&&&&&&&&&&&&&&&&&& + recvPacket.getAddress().getHostAddress());
&&&&&&&&&&& System.out.println(&Server Receive Data:& + new String(receiveMsg));
&&&&&&&&&&& server.send(recvPacket);
&& 2.UDP广播的例子
import java.io.IOE
import java.net.DatagramP
import java.net.DatagramS
import java.net.InetA
public class BroadcastSender
public static void main(String[] args) throws IOException
byte[] msg = new String(&connection successfully!!!&).getBytes();
* 在Java UDP中单播与广播的代码是相同的,要实现具有广播功能的程序只需要使用广播地址即可, 例如：这里使用了本地的广播地址
InetAddress inetAddr = InetAddress.getByName(&255.255.255.255&);
DatagramSocket client = new DatagramSocket();
DatagramPacket sendPack = new DatagramPacket(msg, msg.length, inetAddr,
client.send(sendPack);
System.out.println(&Client send msg complete&);
client.close();
import java.io.IOE
import java.net.DatagramP
import java.net.DatagramS
import java.util.A
public class BroadcastReceive
&&& public static void main(String[] args) throws IOException
&&&&&&& DatagramPacket receive = new DatagramPacket(new byte[1024], 1024);
&&&&&&& DatagramSocket server = new DatagramSocket(8888);
&&&&&&& System.out.println(&---------------------------------&);
&&&&&&& System.out.println(&Server current start......&);
&&&&&&& System.out.println(&---------------------------------&);
&&&&&&& while (true)
&&&&&&&&&&& server.receive(receive);
&&&&&&&&&&& byte[] recvByte = Arrays.copyOfRange(receive.getData(), 0,
&&&&&&&&&&&&&&&&&&& receive.getLength());
&&&&&&&&&&& System.out.println(&Server receive msg:& + new String(recvByte));
&& 3.UDP组播的例子
import java.io.IOE
import java.net.DatagramP
import java.net.InetA
import java.net.MulticastS
public class MulticastSender
public static void main(String[] args) throws IOException
int port = 8888;
byte[] msg = &Connection successfully!!!&.getBytes();
InetAddress inetRemoteAddr = InetAddress.getByName(&224.0.0.5&);
* Java UDP组播应用程序主要通过MulticastSocket实例进行通信,它是DatagramSocket的是一个子类,
* 其中包含了一些额外的可以控制多播的属性.
* 多播数据报包实际上可以通过DatagramSocket发送,只需要简单地指定一个多播地址。
* 我们这里使用MulticastSocket,是因为它具有DatagramSocket没有的能力
MulticastSocket client = new MulticastSocket();
DatagramPacket sendPack = new DatagramPacket(msg, msg.length,
inetRemoteAddr, port);
client.send(sendPack);
System.out.println(&Client send msg complete&);
client.close();
import java.io.IOE
import java.net.DatagramP
import java.net.InetA
import java.net.MulticastS
import java.util.A
public class MulticastReceive
&&& public static void main(String[] args) throws IOException
&&&&&&& InetAddress inetRemoteAddr = InetAddress.getByName(&224.0.0.5&);
&&&&&&& DatagramPacket recvPack = new DatagramPacket(new byte[1024], 1024);
&&&&&&& MulticastSocket server = new MulticastSocket(8888);
&&&&&&& /*
&&&&&&&& * 如果是发送数据报包,可以不加入多播组; 如果是接收数据报包,必须加入多播组; 这里是接收数据报包,所以必须加入多播组;
&&&&&&&& */
&&&&&&& server.joinGroup(inetRemoteAddr);
&&&&&&& System.out.println(&---------------------------------&);
&&&&&&& System.out.println(&Server current start......&);
&&&&&&& System.out.println(&---------------------------------&);
&&&&&&& while (true)
&&&&&&&&&&& server.receive(recvPack);
&&&&&&&&&&& byte[] recvByte = Arrays.copyOfRange(recvPack.getData(), 0,
&&&&&&&&&&&&&&&&&&& recvPack.getLength());
&&&&&&&&&&& System.out.println(&Server receive msg:& + new String(recvByte));
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：147398次
积分：1925
积分：1925
排名：千里之外
原创：36篇
转载：30篇
评论：36条
(1)(2)(1)(3)(1)(25)(14)(6)(4)(3)(1)(1)(3)(1)}