本文介绍如何用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.