如何在JAVA中创建具有无符号整数的数据包

Question

I'm working on a project where I'm writing a java client communicating with a service using TCP over an SSL connection. The service writes all messages to the client fields in network byte order (big endian) and encode text in UTF-8. The client does the same.

The format of the message that the client must create to send to the service looks like this

 |    0      |    1     |     2      |     3      |
 |------------------------------------------------|
 |    Header Version    |       Message Type      |
 |------------------------------------------------|
 |               Message Length                   |
 |------------------------------------------------|
 |               Initial Timestamp                |
 |------------------------------------------------|
 |   Future use         |   Request Flags         |
 |------------------------------------------------|

1. Header Version - Unsigned 16 bits - Value is always 1
2. Message Type - Unsigned 16 bits
3. Message Length - Unsigned 32 bits
4. Initial Timestamp - Unsigned 32 bits
5. Reserved - Unsigned 16 bits -Always set to 0
6. Request Flag - bits[16]

How do I create this data structure in Java with unsigned ints??

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer ;


public class NullMessage {

private final int BASE_HEADER_SIZE = 7;

int _headerVersion;
int _messageType;
long _messageLength;
byte[] _options;


public NullMessage( byte[] format ) {

    if (format.length  == BASE_HEADER_SIZE) {

        _headerVersion = (int)( ( ( format[0] << 8 ) & 652080 ) | ( format[1 ] & 255 ));

        _messageType = (int)( ( ( format[2] << 8 ) & 652080 ) | ( format[3] & 255 ));

        _messageLength = (long)(((format[4]<<24)&4278190080l)
                |((format[5]<<16)&16711680l)
                |((format[6]<<8)&65280)
                |(format[7]&255));
    }
    else {
        throw new RuntimeException("Error in creating NullMessage format");
    }

}

public int length() {
    return BASE_HEADER_SIZE + (this._options == null ? 0 : this._options.length );
}


public NullMessage( int headerVersion, int messageType, long messageLength) {
    this._headerVersion = headerVersion;
    this._messageType = messageType;
    this._messageLength = messageLength;
}

public byte[] toByteArray() {

    ByteArrayOutputStream out = new ByteArrayOutputStream();

    try {
            out.write( getHeader() );
            if ( _options != null ){
                out.write( this._options );
            }
        } catch (IOException e) {
            System.out.println( e.toString() ) ;
        }

        return out.toByteArray()  ;

}

// Generate the NullMessage in a byte array format
public byte[] getHeader() {

    byte[] nullMessage = new byte[BASE_HEADER_SIZE];
    nullMessage[0] = (byte)((_headerVersion>>8)&255);
    nullMessage[1] = (byte)((_headerVersion&255));
    nullMessage[2] = (byte)((_messageType>>8)&255);
    nullMessage[3] = (byte)((_messageType&255));
    nullMessage[3] = (byte)((_messageLength>>24)&255);
    nullMessage[4] = (byte)((_messageLength>>16)&255);
    nullMessage[5] = (byte)((_messageLength>>8)&255);
    nullMessage[6] = (byte)((_messageLength&255));

    return nullMessage;
    }


public byte[] getOption() {

    return _options;
}

public int getHeaderVersion() {
    return this._headerVersion;
}

public void setHeaderVersion(int version) {
    this._headerVersion = version;
}

public int getMessageType() {
    return this._messageType;
}

public void setMessageType(int messageType ) {
    this._messageType = messageType;
}

public long getMessageLength() {
    return this._messageLength;
}

public void setMessageLength( long messageLength ) {

    this._messageLength = messageLength;
}

public void print() {
    byte[] head = getHeader();
    for (int j=0; j<head.length; j++) {
        System.out.format("%08X ", head[j]);
    }
    System.out.println();
}

public static void main(String args[]){
    NullMessage test = new NullMessage(1, 0, 0);
    test.print();


    byte[] array = test.toByteArray();

    for (int i=0;i<array.length;i++) {
       System.out.println("myByte["+i+"]:"+ Integer.toBinaryString(array[i] & 255 | 256).substring(1));

    }
}

}

Answer 1

使用DataInputStream和DataOutputStream的方法。

Answer 2

Unsigned data types do not exist in Java. What I did as a substitute for unsigned was use the next higher up data type.

public class MessageFormat
{
    // int covers the range of an unsigned short (16 bits)
    public int HeaderVersion;

    public int MessageType;

    // long covers the range of an unsigned int (32 bits)
    public long MessageLength

    public long InitialTimestamp;

    public int Reserved;

    public int RequestFlag;
}

Since you're talking about DataPackets from sockets, I used the ByteBuffer class to convert byte arrays to my fields and vice versa.

Here's a sample of ByteBuffer:

byte[] arr = { 0x00, 0x01 };
ByteBuffer wrapped = ByteBuffer.wrap(arr); // big-endian by default
short num = wrapped.getShort(); // 1

ByteBuffer dbuf = ByteBuffer.allocate(2);
dbuf.putShort(num);
byte[] bytes = dbuf.array(); // { 0, 1 }

Now the cumbersome part... The way we evaluated bytes was from 0 to 255, Java would evaluate a byte from -127 to +127. So what I had to do in this situation was AND the bytes against 0xFF (255) so that I could evaluate them as 0 to 255 instead of -127 to +127.

Here's an example of taking a short (2 bytes) and promoting it to an int so that we can have it represent an unsigned short range of 0 - 65535

byte[] bytes = { (byte)0xFF, (byte)0xFF }; 
System.out.println(Arrays.toString(bytes));

ByteBuffer bb = ByteBuffer.wrap(bytes);
// As a signed short
System.out.println(bb.getShort());

// Reset back to the beginning
bb.position(0);

// As an "unsigned short", but really an int
System.out.println(bb.getShort() & 0xFFFF);

Output:

[-1, -1]
-1
65535

Answer 3

When a field is supposed to be "unsigned" for an outgoing message, then:

• The side that needs to interpret it as unsigned is the server.
• On the client side, you simply need to make sure you are doing your calculations in such a way that will not overflow the number.

For the message size, for example, if your particular client is designed never to send very long messages (that is, not longer than Integer.MAX_VALUE ), for example, if it always sends well-known length-limited message payloads, then you can actually use a plain int when you calculate it.

If it is conceivable that it will send very long messages, then you should use a long to calculate the size (eg long calculatedSize ). Then check that it does not exceed the capacity of a signed integer, eg:

if ( calculatedSize & 0xffffffffL != calculatedSize ) {
    throw new InvalidMessageException();
}

( InvalidMessageException is not an existing type. Just an Exception type that you will create for this purpose).

And then you can use (int)calculatedSize for your actual data. This simply drops the most significant 4 bytes, which you have made sure are zero anyway, leaving you with the least significant 4 bites.

The fact that Java interprets this integer as signed is not relevant, because the only use you'll make of it is to write its bytes to the message.

The same goes for the time stamp field. Here it's very likely you'll need to go beyond signed int capacity (which will break by the year 2038). So work with long . In fact, use the usual Java idiom of milliseconds since the epoch, and then when you need to create the message header, divide by 1000, and do the same check and the same conversion as I've shown above.

General advice:

• You'll probably do best to design your message as a class that has all the various constants (header version, message types, future use, various flags), and instance fields for the time stamp and the actual message payload. Don't worry about the sign of your constants. They are not subject to calculations and therefore their sign is irrelevant.
• This class should have a method for creating a message header, which will use a ByteBuffer (which allows you to set the particular byte order), and put the various fields in it, some directly from the constants, and the message length and time stamp calculated from the fields, using putInt() for your 4-byte integers and putWord() for your 2-byte integers.
• In case you were planning to work with a plain Socket() , you should consider working with channels, as they work very well with ByteBuffer objects.