java - generate - spring uuid
UUID es el mismo de diferentes cadenas (5)
"123438e1036d-7527-42a3-98ca-f2f19d3155db"
Esto no es un UUID. Es una cadena concatenada de "1234" y un UUID. El problema aquí es que el analizador debería haberle dicho esto lanzando una excepción. En su lugar, hace todo lo posible para encontrar el UUID enterrado en algún lugar allí.
Una vez que extraiga el UUID de su cadena concatenada, es idéntico al primer UUID, que es el resultado correcto que está observando.
Podemos analizar el analizador (gracias a @ tim-biegeleisen por proporcionar el enlace):
public static UUID fromString(String name) {
String[] components = name.split("-");
if (components.length != 5)
throw new IllegalArgumentException("Invalid UUID string: "+name);
for (int i=0; i<5; i++)
components[i] = "0x"+components[i];
long mostSigBits = Long.decode(components[0]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(components[1]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(components[2]).longValue();
long leastSigBits = Long.decode(components[3]).longValue();
leastSigBits <<= 48;
leastSigBits |= Long.decode(components[4]).longValue();
return new UUID(mostSigBits, leastSigBits);
}
Como podemos ver, no hay validación excepto para contar el número de grupos limitados por guiones. Solo toma esos grupos y luego los cambia a posiciones. Has agregado caracteres adicionales al primer grupo, que es la parte más significativa. Se analiza y almacena primero, y luego se desplaza hacia arriba y hacia arriba hasta que ocupa la parte más significativa. Ahora, todos los bits que quedaron más a la izquierda de lo que se supone se eliminan del límite long , por lo tanto, se ignoran por completo.
Tengo dos cadenas diferentes, pero después de analizar UUID parece ser el mismo
public static void main(String[] args) {
try {
UUID t1 = UUID.fromString("38e1036d-7527-42a3-98ca-f2f19d3155db");
UUID t2 = UUID.fromString("123438e1036d-7527-42a3-98ca-f2f19d3155db");
System.out.println(t1.toString().equals(t2.toString()));
} catch (Exception e) {
e.printStackTrace();
}
}
¿Alguna idea de por qué es?
El desplazamiento de bits del segundo componente ''7527'' elimina el efecto de la modificación que realizó en el primer componente ''123438e1036d'', lo que hace que se genere el mismo UUID.
El procesamiento del primer componente por sí mismo es diferente, pero este efecto se pierde cuando se desplaza el segundo componente del uuid.
Este es un error conocido en Java 8, publicado en junio de 2016: http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8159339
Consulte también http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8165199 (informado en agosto de 2016):
4d4d8f3b-3b81-44f3-968d-d1c1a48b4ac8 es un UUID válido.
4d4d8f-3b3b81-44f3-968d-d1c1a48b4ac8 no está (movió los primeros guiones dos caracteres a la izquierda)
Llamar a UUID :: fromString () con el inválido da como resultado un UUID que representa 004d4dbf-3b81-44f3-968d-d1c1a48b4ac8.
Esto se debe a que se comprueba de derecha a izquierda, toma solo 32 caracteres como UUID y elimina otros. una vez que se toman 32 caracteres en orden, no se preocupa por los demás, ya que implementa la interfaz Serializable.
public final class UUID
extends Object
implements Serializable, Comparable<UUID>
1234 se recorta de usted 2do UUID.
Aquí está su código, ayuda mucho mejor.
public static UUID More ...fromString(String name) {
String[] components = name.split("-");
if (components.length != 5)
throw new IllegalArgumentException("Invalid UUID string: "+name);
for (int i=0; i<5; i++)
components[i] = "0x"+components[i];
long mostSigBits = Long.decode(components[0]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(components[1]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(components[2]).longValue();
long leastSigBits = Long.decode(components[3]).longValue();
leastSigBits <<= 48;
leastSigBits |= Long.decode(components[4]).longValue();
return new UUID(mostSigBits, leastSigBits);
}