Przechowywanie UUID jako ciąg base64

Próbowałem też zrobić coś podobnego. Pracuję z aplikacją Java, która używa uuid w postaci 6fcb514b-b878-4c9d-95b7-8dc3a7ce6fd8 (które są generowane ze standardowym UUID lib w Javie). W moim przypadku musiałem być w stanie uzyskać ten UUID do 30 znaków lub mniej. Użyłem Base64 i to są moje funkcje wygody. Mam nadzieję, że będą pomocne dla kogoś, ponieważ rozwiązanie nie było dla mnie oczywiste daleko.

Użycie:

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));

Wyjście:

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

Funkcje:

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();
}

Mam aplikację, w której robię prawie dokładnie to. 22 znak zakodowany UUID. Działa dobrze. Jednak głównym powodem, dla którego robię to w ten sposób, jest to, że identyfikatory są eksponowane w URI aplikacji internetowej, a znaki 36 są naprawdę dość duże, jak na coś, co pojawia się w URI. 22 znaki to jeszcze trochę długo, ale damy radę.

Oto kod Ruby do tego:

  # 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

To nie jest dokładnie to samo co kodowanie base64, ponieważ base64 używa znaków, które muszą być unikane jeśli pojawiły się w komponencie ścieżki URI. Implementacja Javy prawdopodobnie będzie zupełnie inna, ponieważ bardziej prawdopodobne jest posiadanie tablicy surowych bajtów zamiast naprawdę dużej liczby całkowitej.

Oto Mój kod, używa org.Apacz.commons.kodek.binary.Base64 tworzy bezpieczne dla url unikalne ciągi znaków o długości 22 znaków (i które mają taką samą unikalność jak 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));
}

Nie mówisz, jakiego DBMS używasz, ale wydaje się, że RAW byłoby najlepszym podejściem, jeśli martwisz się o oszczędność miejsca. Musisz tylko pamiętać, aby przekonwertować na wszystkie zapytania, lub ryzykujesz ogromny spadek wydajności.

Ale muszę zapytać: czy bajty są naprawdę takie drogie, gdzie mieszkasz?

Poniżej jest to, czego używam dla uuid (styl grzebieniowy). Zawiera kod do konwersji uuid string lub UUID typu do base64. Robię to na 64 bity, więc nie mam do czynienia z żadnymi znakami równości:

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;
    }
}