Java解决socket粘包 java socket包

1. Client/Server Networking

Java通过socket来完成它所有的网络底层的通讯，socket是一种通讯的通道，通过它可以将数据通过特定的端中发送及接收。Java中的socket可以分成二大类：

（1） Datagram Sockets：数据包socket；

（2） Stream Sockets：流socket；

1.2 Datagram Socket

Datagram socket使用UDP来实现数据通讯，因此它不能保证数据能够到达目的地，但是由于它不需要专用的网络链接，所以它所需的资源相对少的多。

Datagram以包的方式发送数据，但它不能保证这些数据包以特定的顺序到达目的，因此包中往往需要包含序列号的信息，接收方可以根据序列号的信息决定是否所有的包都已收到，并按正常顺序重组这些包。

Java通过两个类DatagramSocket和DatagramPacket来支持Datagram socket。DatagramSocket实现了Datagram socket的基本功能，而DatagramPacket则提供了对包的一些支持。

DatagramSocket的几个重要方法：

（1） DatagramSocket()：随机绑定一个有效的端口；

（2） DatagramSocket(int port)：绑定指定的端口；

（3） Void send(DatagramPacket p)：发送数据报，由于目的地的地址信息已包含在数据报中，所以不需要在本函数中提供地址信息；

（4） synchronized void receive(DatagramPacket p)：接收数据包，线程安全；

（5） synchronized void close()：关闭socket；

在DatagramSocket中并不区分ServerSocket和ClientSocket，如果一定要区分，那么发送的是client，而接收的是server。

DatagramPacket有以几个重要的方法：

（1） DatagramPacket(byte ibuf[], int ilength)：用于接收数据报；
（2） DatagramPacket(byte ibuf[], int ilength, InetAddressiaddr, int iport)：用于发送的数据报；
（3） byte[] getData()
（4） int getLength()
以下是完整的Datagram Socket的例子：
接收端，Server端代码：
import java.io.*;
import java.net.*;
  
class FortuneServer1 extends Thread
{
  DatagramSocket ServerSocket;
  public FortuneServer1() 
  { 
    super("FortuneServer1");
    try 
      {
        ServerSocket = new DatagramSocket(1114);
        System.out.println("FortuneServer up and running...");
      }
    catch (SocketException e) 
      {
        System.err.println("Exception: couldn't create datagram socket");
        System.exit(1);
      }  }  
  
  public static void main(String[] args) 
  {
     FortuneServer1 server = new FortuneServer1();
     server.start();
  }
  
 public void run() 
 {
   if (ServerSocket == null)
     return;
  
   while (true) 
   {
     try 
       {
          InetAddress     address;
          int             port;
          DatagramPacket  packet;
          byte[]          data = new byte[256];
          int             num = 1;
          
          packet = new DatagramPacket(data, data.length);
          ServerSocket.receive(packet);   
          address = packet.getAddress();
          port = packet.getPort();
          
          File inFile = new File("Fortunes.txt");
          FileInputStream inStream = new FileInputStream(inFile);
          
          if (inStream.read(data) <= 0) 
            {
               System.err.println("Error: couldn't read fortunes");             
            }
          
         packet = new DatagramPacket(data, data.length, address, port);
          ServerSocket.send(packet);
       }
     catch (Exception e) 
       {
          System.err.println("Exception: " + e);
          e.printStackTrace();
       }   } } }
说明：
（1） 这个例子中接收端的socket使用了多线程，多线程的概念可以参考本文的多线程部分；
（2） 在构造函数中创建了DatagramSocket，并且使用了1114这个端口；
（3） 本例子的关键函数是run，它使用了死循环，在循环中使用了receive这方法来临听1114端口，如果1114端口没有请求数据到来，那么这个程序就一直停留在receive这个位置，不再往下执行；
（4） 当1114端有数据时，receive方法将接收到的DatagramPacket数据包放在packet这个对象中，然后解析其中的数据，获取发送方的地址信息；
（5） 然后再创建DatagramPacket包，并填充数据，发送到原接收端。
以下是发送端的代码：
import java.io.*;
import java.net.*; 
class FortuneClient
{
    public static void main(String args[])
    {
        FortuneClient client = new FortuneClient();
        System.out.println(client.getMessage());
    }
    
    public String getMessage()
    {
        String fortune;
   try {
     DatagramSocket  socket;
     DatagramPacket  packet;
     byte[]          data = new byte[256];
  
     socket = new DatagramSocket();
     packet = new DatagramPacket(data, data.length,InetAddress.getByName("127.0.0.1"), 1114);
     socket.send(packet);
  
     packet = new DatagramPacket(data, data.length);
     socket.receive(packet);
     fortune = new String(packet.getData(), 0);
     socket.close();
   }
   catch (UnknownHostException e) {
     System.err.println("Exception: host could not be found");
     return null;
   }
   catch (Exception e) {
     System.err.println("Exception: " + e);
     e.printStackTrace();
     return null;
   }
   return fortune;
  } }

客户端的代码与服务器端的代码基本相同，只是没有了循环，并且处理步骤与服务器端的基本相反。这也说明了Datagram Socket不真正区分Server和Client。

1.3 Stream Socket

Stream Socket与Datagram Socket不同，它有一个永久性的链接，可以确保数据可靠的发送到对方。但是Stream Socket所占的资源更多。

Java主要通过Socket及ServerSocket来实现Stream Socket，一个用于客户端，另一个用户服务器端。

Socket类的几个重要方法如下：

（1） Socket(String host, int port)

（2） Socket(InetAddress address, int port)

（3） synchronized void close()

（4） InputStream getInputStream()

（5） OutputStream getOutputStream()

可以看出Stream Socket中的Socket与Datagram Socket中的Socket的区别：

（1） 在构造函数中，这里需要指定服务器的地址与端口，用于它发送数据之前建立链接，而Datagram的Socket不需要建立链接，它仅需要在要发送的数据包中包含地址信息即可；

（2） Stream Socket的两个重要方法和其它流的方法类似，而且在操作上也相似，其实在操作Stream Socket时，只要建立了链接，那么以后的操作和流的操作一样了，你可以忘了你在操作Socket，只当做自己在操作普通的流。

ServerSocket有以下几个重要的方法：

（1） ServerSocket(int port)：监听指定端口，监听时间为默认值50；

（2） ServerSocket(int port, int count)：监听指定端口，并指定监听时间；

（3） ServerSocket(int port, int backlog, InetAddress bindAddr)：只接收指定接口发过来的数据；

（4） Socket accept()：accpet方法会返回一个Socket对象，使用该Socket对象的getInputStream及getOutputStream方法获取输入及输出流。由此可见无论是服务器端还是客户端，它们都是通过Socket对象来收发数据的。程序执行到accpet时会进入监听状态，不再向下执行一直到接收到数据。

（5） void close()

以下是关于Stream Socket的一个例子，在这个例子中使用单独的二个类Receiver和Sender负责对指定的输入及输出流进行操作，用另一个类SocketPerformer来创建Receiver和Sender这两个类的实例，并传入指定的输入及输出流，而在Client及Server这两个类中，负责创建SocketPerformer对象，并传入指定的Socket。因此这五个类在功能上分为三层，第一层负责对流进行操作，第二层负责创建指定的Socket流，并这些Socket流传到第一层，第三层负责创建Socket并将这些Socket传到第二层。

Receriver代码：

package socketChat;
import java.io.BufferedReader;
public class Receiver extends Thread {
    BufferedReader reader;
    public Receiver(BufferedReader theSocketReader) {
        reader = theSocketReader;
    }
  
    public void run() {
        while (true) {
            try {
                String words = reader.readLine();                System.out.println("/r/n<<< " + words);
            } catch (Exception e) {
                e.printStackTrace();
                return;
            }        }    }}
Sender代码：
package socketChat;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;