Stockage de UUID en tant que chaîne de base64

j'essayais aussi de faire quelque chose de similaire. Je travaille avec une application Java qui utilise les UUIDs du formulaire 6fcb514b-b878-4c9d-95b7-8dc3a7ce6fd8 (qui sont générés avec le standard UUID lib en Java). Dans mon cas, je devais être en mesure d'obtenir ce UUID à 30 caractères ou moins. J'ai utilisé Base64 et ce sont mes fonctions de confort. J'espère qu'ils seront utiles pour quelqu'un car la solution n'était pas évidente pour moi tout de suite.

Utilisation:

String uuid_str = "6fcb514b-b878-4c9d-95b7-8dc3a7ce6fd8";
String uuid_as_64 = uuidToBase64(uuid_str);
System.out.println("as base64: "+uuid_as_64);
System.out.println("as uuid: "+uuidFromBase64(uuid_as_64));

sortie:

as base64: b8tRS7h4TJ2Vt43Dp85v2A
as uuid  : 6fcb514b-b878-4c9d-95b7-8dc3a7ce6fd8

fonctions:

import org.apache.commons.codec.binary.Base64;

private static String uuidToBase64(String str) {
    Base64 base64 = new Base64();
    UUID uuid = UUID.fromString(str);
    ByteBuffer bb = ByteBuffer.wrap(new byte[16]);
    bb.putLong(uuid.getMostSignificantBits());
    bb.putLong(uuid.getLeastSignificantBits());
    return base64.encodeBase64URLSafeString(bb.array());
}
private static String uuidFromBase64(String str) {
    Base64 base64 = new Base64(); 
    byte[] bytes = base64.decodeBase64(str);
    ByteBuffer bb = ByteBuffer.wrap(bytes);
    UUID uuid = new UUID(bb.getLong(), bb.getLong());
    return uuid.toString();
}

j'ai une application où je fais presque exactement cela. 22 char encoded UUID. Il fonctionne très bien. Cependant, la principale raison pour laquelle je le fais de cette façon est que les IDs sont exposés dans L'URIs de l'application web, et 36 caractères est vraiment assez grand pour quelque chose qui apparaît dans une URI. 22 personnages, c'est long, mais on s'en sort.

voici le code Ruby pour ceci:

  # Make an array of 64 URL-safe characters
  CHARS64 = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["-", "_"]
  # Return a 22 byte URL-safe string, encoded six bits at a time using 64 characters
  def to_s22
    integer = self.to_i # UUID as a raw integer
    rval = ""
    22.times do
      c = (integer & 0x3F)
      rval += CHARS64[c]
      integer = integer >> 6
    end
    return rval.reverse
  end

ce n'est pas exactement la même chose que l'encodage de base64 parce que base64 utilise des caractères qui devraient être échappés s'ils apparaissaient dans un composant URI path. L'implémentation Java est susceptible d'être très différente puisque vous êtes plus susceptible d'avoir un tableau d'octets bruts au lieu d'un très grand nombre entier.

Voici mon code, il utilise org.Apache.commun.codec.binaire.Base64 pour produire des chaînes uniques sécurisées qui ont une longueur de 22 caractères (et qui ont la même unicité que UUID).

private static Base64 BASE64 = new Base64(true);
public static String generateKey(){
    UUID uuid = UUID.randomUUID();
    byte[] uuidArray = KeyGenerator.toByteArray(uuid);
    byte[] encodedArray = BASE64.encode(uuidArray);
    String returnValue = new String(encodedArray);
    returnValue = StringUtils.removeEnd(returnValue, "\r\n");
    return returnValue;
}
public static UUID convertKey(String key){
    UUID returnValue = null;
    if(StringUtils.isNotBlank(key)){
        // Convert base64 string to a byte array
        byte[] decodedArray = BASE64.decode(key);
        returnValue = KeyGenerator.fromByteArray(decodedArray);
    }
    return returnValue;
}
private static byte[] toByteArray(UUID uuid) {
    byte[] byteArray = new byte[(Long.SIZE / Byte.SIZE) * 2];
    ByteBuffer buffer = ByteBuffer.wrap(byteArray);
    LongBuffer longBuffer = buffer.asLongBuffer();
    longBuffer.put(new long[] { uuid.getMostSignificantBits(), uuid.getLeastSignificantBits() });
    return byteArray;
}
private static UUID fromByteArray(byte[] bytes) {
    ByteBuffer buffer = ByteBuffer.wrap(bytes);
    LongBuffer longBuffer = buffer.asLongBuffer();
    return new UUID(longBuffer.get(0), longBuffer.get(1));
}

vous ne dites pas ce que les SGBD que vous utilisez, mais il semble que RAW serait la meilleure approche si vous êtes soucieux de sauver de l'espace. Vous avez juste besoin de se rappeler de convertir pour toutes les requêtes, ou vous risquez une chute de performance énorme.

mais je dois demander: les octets sont-ils vraiment si chers là où vous vivez?

ci-dessous est ce que j'utilise pour un UUID (style peigne). Il inclut le code pour convertir une chaîne uuid ou un type uuid en base64. Je le fais par 64 bits, donc je ne traite pas avec des signes égaux:

JAVA

import java.util.Calendar;
import java.util.UUID;
import org.apache.commons.codec.binary.Base64;

public class UUIDUtil{
    public static UUID combUUID(){
        private UUID srcUUID = UUID.randomUUID();
        private java.sql.Timestamp ts = new java.sql.Timestamp(Calendar.getInstance().getTime().getTime());

        long upper16OfLowerUUID = this.zeroLower48BitsOfLong( srcUUID.getLeastSignificantBits() );
        long lower48Time = UUIDUtil.zeroUpper16BitsOfLong( ts );
        long lowerLongForNewUUID = upper16OfLowerUUID | lower48Time;
        return new UUID( srcUUID.getMostSignificantBits(), lowerLongForNewUUID );
    }   
    public static base64URLSafeOfUUIDObject( UUID uuid ){
        byte[] bytes = ByteBuffer.allocate(16).putLong(0, uuid.getLeastSignificantBits()).putLong(8, uuid.getMostSignificantBits()).array();
        return Base64.encodeBase64URLSafeString( bytes );
    }
    public static base64URLSafeOfUUIDString( String uuidString ){
    UUID uuid = UUID.fromString( uuidString );
        return UUIDUtil.base64URLSafeOfUUIDObject( uuid );
    }
    private static long zeroLower48BitsOfLong( long longVar ){
        long upper16BitMask =  -281474976710656L;
        return longVar & upper16BitMask;
    }
    private static void zeroUpper16BitsOfLong( long longVar ){
        long lower48BitMask =  281474976710656L-1L;
        return longVar & lower48BitMask;
    }
}