将UUID存储为base64字符串

78

我一直在尝试使用UUID作为数据库密钥。我想占用尽可能少的字节，同时仍使UUID表示易于阅读。

我认为我已经使用base64将其压缩为22个字节，并删除了一些尾随的“ ==”，这对于我来说似乎是不需要存储的。这种方法有什么缺陷吗？

基本上，我的测试代码进行了大量转换，以将UUID转换为22字节的字符串，然后将其转换回UUID。

import java.io.IOException;
import java.util.UUID;

public class UUIDTest {

    public static void main(String[] args){
        UUID uuid = UUID.randomUUID();
        System.out.println("UUID String: " + uuid.toString());
        System.out.println("Number of Bytes: " + uuid.toString().getBytes().length);
        System.out.println();

        byte[] uuidArr = asByteArray(uuid);
        System.out.print("UUID Byte Array: ");
        for(byte b: uuidArr){
            System.out.print(b +" ");
        }
        System.out.println();
        System.out.println("Number of Bytes: " + uuidArr.length);
        System.out.println();


        try {
            // Convert a byte array to base64 string
            String s = new sun.misc.BASE64Encoder().encode(uuidArr);
            System.out.println("UUID Base64 String: " +s);
            System.out.println("Number of Bytes: " + s.getBytes().length);
            System.out.println();


            String trimmed = s.split("=")[0];
            System.out.println("UUID Base64 String Trimmed: " +trimmed);
            System.out.println("Number of Bytes: " + trimmed.getBytes().length);
            System.out.println();

            // Convert base64 string to a byte array
            byte[] backArr = new sun.misc.BASE64Decoder().decodeBuffer(trimmed);
            System.out.print("Back to UUID Byte Array: ");
            for(byte b: backArr){
                System.out.print(b +" ");
            }
            System.out.println();
            System.out.println("Number of Bytes: " + backArr.length);

            byte[] fixedArr = new byte[16];
            for(int i= 0; i<16; i++){
                fixedArr[i] = backArr[i];
            }
            System.out.println();
            System.out.print("Fixed UUID Byte Array: ");
            for(byte b: fixedArr){
                System.out.print(b +" ");
            }
            System.out.println();
            System.out.println("Number of Bytes: " + fixedArr.length);

            System.out.println();
            UUID newUUID = toUUID(fixedArr);
            System.out.println("UUID String: " + newUUID.toString());
            System.out.println("Number of Bytes: " + newUUID.toString().getBytes().length);
            System.out.println();

            System.out.println("Equal to Start UUID? "+newUUID.equals(uuid));
            if(!newUUID.equals(uuid)){
                System.exit(0);
            }


        } catch (IOException e) {
        }

    }


    public static byte[] asByteArray(UUID uuid) {

        long msb = uuid.getMostSignificantBits();
        long lsb = uuid.getLeastSignificantBits();
        byte[] buffer = new byte[16];

        for (int i = 0; i < 8; i++) {
            buffer[i] = (byte) (msb >>> 8 * (7 - i));
        }
        for (int i = 8; i < 16; i++) {
            buffer[i] = (byte) (lsb >>> 8 * (7 - i));
        }

        return buffer;

    }

    public static UUID toUUID(byte[] byteArray) {

        long msb = 0;
        long lsb = 0;
        for (int i = 0; i < 8; i++)
            msb = (msb << 8) | (byteArray[i] & 0xff);
        for (int i = 8; i < 16; i++)
            lsb = (lsb << 8) | (byteArray[i] & 0xff);
        UUID result = new UUID(msb, lsb);

        return result;
    }

}

输出：

UUID String: cdaed56d-8712-414d-b346-01905d0026fe
Number of Bytes: 36

UUID Byte Array: -51 -82 -43 109 -121 18 65 77 -77 70 1 -112 93 0 38 -2 
Number of Bytes: 16

UUID Base64 String: za7VbYcSQU2zRgGQXQAm/g==
Number of Bytes: 24

UUID Base64 String Trimmed: za7VbYcSQU2zRgGQXQAm/g
Number of Bytes: 22

Back to UUID Byte Array: -51 -82 -43 109 -121 18 65 77 -77 70 1 -112 93 0 38 -2 0 38 
Number of Bytes: 18

Fixed UUID Byte Array: -51 -82 -43 109 -121 18 65 77 -77 70 1 -112 93 0 38 -2 
Number of Bytes: 16

UUID String: cdaed56d-8712-414d-b346-01905d0026fe
Number of Bytes: 36

Equal to Start UUID? true
java  sql  bytearray  base64  uuid 
— mainstringargs
source
一种看待它的方法是，UUID是128个随机位，因此每个base64项6位是128/6 = 21.3，因此您正确地需要22个base64位置来存储相同的数据。
— Stijn Sanders
您以前的问题似乎基本相同：stackoverflow.com/questions/772325/…–
— erickson
我不确定您的代码在asByteBuffer的第二个for循环中是否从7中减去i，但从8迭代到16，这意味着它将移位负数。IIRC <<<会回绕，但似乎仍然不正确。
— 乔恩·蒂尔森
我认为这是比较容易，只需使用字节缓冲区的两个多头转换为字节数组像这样一个问题：stackoverflow.com/questions/6881659/...
— 乔恩Tirsen

Answers:

31

您可以安全地在此应用程序中删除填充“ ==”。如果要将base-64文本解码回字节，则某些库希望它存在，但是由于您只是将结果字符串用作键，所以这不是问题。

我之所以使用Base-64，是因为它的编码字符可以是URL安全的，并且看起来不太像胡言乱语。但是还有Base-85。它使用更多的符号并将4个字节编码为5个字符，因此您可以将文本减少到20个字符。

— 埃里克森
source
17
BAse85仅保存2个字符。另外，Base85在URL中使用并不安全，UUID的主要用途之一是数据库中的实体标识符，然后以URL结束。
— 丹尼斯
@erickson能否请您分享一些代码片段以转换为Base85。我尝试过但无法获得任何可靠的Base85 Java库
— Manish
@Manish有一些base-85的变体，但是每个变体都需要一个以上的“代码段”来实现。这种答案确实不适合本网站。您在尝试过的库中发现了哪些问题？我真的建议使用base-64，因为它在核心Java中具有支持，并且仅占用编码值大约7％的空间。
— 埃里克森
@erickson，但是base64不能解决我将uuid减少到20个字符长度的目的。
— 曼尼什
@Manish我明白了。您的要求是否禁止使用任何特殊字符，例如引号，百分号（%）或反斜杠（`\`）？您是否必须对标识符进行编码和解码？（也就是说，您是否希望能够转换回常规的UUID，或者只是将其缩短？）
— erickson
62

我也在尝试做类似的事情。我正在使用Java应用程序，该应用程序使用以下形式的UUID 6fcb514b-b878-4c9d-95b7-8dc3a7ce6fd8（由Java中的标准UUID库生成）。就我而言，我需要能够将此UUID减少到30个字符或更少。我使用了Base64，这些是我的便利功能。希望它们会对某人有所帮助，因为解决方案对我而言并不立刻显而易见。

用法：

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

输出：

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

职能：

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();
}
— 泔水
source
1
抱歉，我没有注意到此评论。是的，我正在使用Apache commons编解码器。 import org.apache.commons.codec.binary.Base64;
— swill
尺寸减少了39％。真好
— 斯图·汤普森
6
您可以使用内置的从Java 8 Base64.getUrlEncoder().encodeToString(bb.array())和Base64.getUrlDecoder().decode(id)
— Wpigott
您可以选择不实例化Base64类，方法encodeBase64URLSafeString（b []）和encodeBase64（str）是静态的，不是吗？
— Kumar Mani
9

这是我的代码，它使用org.apache.commons.codec.binary.Base64生成长度为22个字符（且具有与UUID相同的唯一性）的URL安全的唯一字符串。

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));
}
— 斯蒂科斯
source
8

我有一个应用程序，在其中我几乎可以做到这一点。22个字符编码的UUID。它工作正常。但是，我这样做的主要原因是ID在Web应用程序的URI中公开，对于URI中显示的内容，36个字符确实很大。22个字符仍然很长，但我们做到了。

这是为此的Ruby代码：

  # 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

它与base64编码并不完全相同，因为base64使用的字符如果出现在URI路径组件中就必须转义。Java实现可能会大不相同，因为您更有可能拥有原始字节数组，而不是真正的大整数。

— 鲍勃·阿曼
source
3

您没有说使用什么DBMS，但是如果您担心节省空间，似乎RAW是最好的方法。您只需要记住为所有查询进行转换，否则您将面临巨大的性能下降的风险。

但是我不得不问：您住的地方字节真的那么贵吗？

— 格里高利
source
是的，我想是这样。。。我想尽可能地节省空间，同时又要让人们可以阅读。
— mainstringargs
好，你为什么这么认为？您要存储十亿行吗？您将节省80亿字节，这并不多。实际上，您将节省更少，因为您的DBMS可能会保留额外的空间用于编码。而且，如果您使用VARCHAR而不是固定大小的CHAR，那么您将失去保存实际长度所需的空间。
— kdgregory 2009年
...并且只有在使用CHAR（32）时才表示“节省”。如果使用RAW，实际上可以节省空间。
— kdgregory 2009年
8
任何合理的DBMS都允许您以本机格式存储UUID，这需要16个字节。任何合理的数据库工具都会在查询结果中将其转换为标准格式（例如“ cdaed56d-8712-414d-b346-01905d0026fe”）。人们已经做了很长时间了。无需重新发明轮子。
— 罗伯·刘易斯2009年
1
他可能试图将UUID包含在QR码中，这意味着压缩对于创建更容易扫描的QR码很有用。
— 2013年
3

这是java.util.Base64在JDK8中引入的示例：

import java.nio.ByteBuffer;
import java.util.Base64;
import java.util.Base64.Encoder;
import java.util.UUID;

public class Uuid64 {

  private static final Encoder BASE64_URL_ENCODER = Base64.getUrlEncoder().withoutPadding();

  public static void main(String[] args) {
    // String uuidStr = UUID.randomUUID().toString();
    String uuidStr = "eb55c9cc-1fc1-43da-9adb-d9c66bb259ad";
    String uuid64 = uuidHexToUuid64(uuidStr);
    System.out.println(uuid64); //=> 61XJzB_BQ9qa29nGa7JZrQ
    System.out.println(uuid64.length()); //=> 22
    String uuidHex = uuid64ToUuidHex(uuid64);
    System.out.println(uuidHex); //=> eb55c9cc-1fc1-43da-9adb-d9c66bb259ad
  }

  public static String uuidHexToUuid64(String uuidStr) {
    UUID uuid = UUID.fromString(uuidStr);
    byte[] bytes = uuidToBytes(uuid);
    return BASE64_URL_ENCODER.encodeToString(bytes);
  }

  public static String uuid64ToUuidHex(String uuid64) {
    byte[] decoded = Base64.getUrlDecoder().decode(uuid64);
    UUID uuid = uuidFromBytes(decoded);
    return uuid.toString();
  }

  public static byte[] uuidToBytes(UUID uuid) {
    ByteBuffer bb = ByteBuffer.wrap(new byte[16]);
    bb.putLong(uuid.getMostSignificantBits());
    bb.putLong(uuid.getLeastSignificantBits());
    return bb.array();
  }

  public static UUID uuidFromBytes(byte[] decoded) {
    ByteBuffer bb = ByteBuffer.wrap(decoded);
    long mostSigBits = bb.getLong();
    long leastSigBits = bb.getLong();
    return new UUID(mostSigBits, leastSigBits);
  }
}

用Base64编码的UUID是URL安全的，没有填充。

— 谢尔盖·波诺马列夫（Sergey Ponomarev）
source
3

这并不是您所要求的（不是Base64），但值得一看，因为它具有更高的灵活性：有一个Clojure库实现了UUID的紧凑的26字符URL安全表示（https：// github .com / tonsky / compact-uuids）。

一些重点：

  • 产生的字符串小30％（26个字符比传统的36个字符）
  • 支持完整的UUID范围（128位）
  • 编码安全（仅使用来自ASCII的可读字符）
  • URL /文件名安全
  • 小写/大写安全
  • 避免歧义字符（i / I / l / L / 1 / O / o / 0）
  • 编码的26个字符的字符串按字母顺序排序符合默认的UUID排序顺序

这些都是不错的属性。我一直在我的应用程序中使用此编码来存储数据库密钥和用户可见的标识符，并且效果很好。

— 扬·瑞希特（Jan Rychter）
source
如果最有效的格式是16个二进制字节，为什么将它用于数据库密钥？
— 克拉韦米尔
为了方便。以字符串形式使用UUID是显而易见的：每个软件都可以处理它。使用它作为二进制形式的密钥是一种优化，这将招致巨大的开发和维护成本。我认为这不值得付出努力。
— Jan Rychter
1

以下是我用于UUID（组合样式）的内容。它包含用于将uuid字符串或uuid类型转换为base64的代码。我每64位执行一次，因此我不会处理任何等号：

爪哇

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;
    }
}
— 丹尼斯
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.