uuid java что это
Как генерируются UUID
Вы наверняка уже использовали в своих проектах UUID и полагали, что они уникальны. Давайте рассмотрим основные аспекты реализации и разберёмся, почему UUID практически уникальны, поскольку существует мизерная возможность возникновения одинаковых значений.
Современную реализацию UUID можно проследить до RFC 4122, в котором описано пять разных подходов к генерированию этих идентификаторов. Мы рассмотрим каждый из них и пройдёмся по реализации версии 1 и версии 4.
Теория
UUID (universally unique IDentifier) — это 128-битное число, которое в разработке ПО используется в качестве уникального идентификатора элементов. Его классическое текстовое представление является серией из 32 шестнадцатеричных символов, разделённых дефисами на пять групп по схеме 8-4-4-4-12.
Информация о реализации UUID встроена в эту, казалось бы, случайную последовательность символов:
Значения на позициях M и N определяют соответственно версию и вариант UUID.
Версия
Номер версии определяется четырьмя старшими битами на позиции М. На сегодняшний день существуют такие версии:
Вариант
Это поле определяет шаблон информации, встроенной в UUID. Интерпретация всех остальных битов в UUID зависит от значения варианта.
Мы определяем его по первым 1-3 старшим битам на позиции N.
1 0 0 0 = 8
1 0 0 1 = 9
1 0 1 0 = A
1 0 1 1 = B
Так что если вы видите UUID с такими значениями на позиции N, то это идентификатор в варианте 1.
Версия 1 (время + уникальный или случайный идентификатор хоста)
В этом случае UUID генерируется так: к текущему времени добавляется какое-то идентифицирующее свойство устройства, которое генерирует UUID, чаще всего это MAC-адрес (также известный как ID узла).
Идентификатор получают с помощью конкатенации 48-битного МАС-адреса, 60-битной временной метки, 14-битной «уникализированной» тактовой последовательности, а также 6 битов, зарезервированных под версию и вариант UUID.
Тактовая последовательность — это просто значение, инкрементируемое при каждом изменении часов.
Временная метка, которая используется в этой версии, представляет собой количество 100-наносекундных интервалов с 15 октября 1582 года — даты возникновения григорианского календаря.
Возможно, вы знакомы с принятым в Unix-системах исчислением времени с начала эпохи. Это просто другая разновидность Нулевого дня. В сети есть сервисы, которые помогут вам преобразовать одно временное представление в другое, так что не будем на этом останавливаться.
Хотя эта реализация выглядит достаточно простой и надёжной, однако использование MAC-адреса машины, на которой генерируется идентификатор, не позволяет считать этот метод универсальным. Особенно, когда главным критерием является безопасность. Поэтому в некоторых реализациях вместо идентификатора узла используется 6 случайных байтов, взятых из криптографически защищённого генератора случайных чисел.
Сборка UUID версии 1 происходит так:
Поскольку эта реализация зависит от часов, нам нужно обрабатывать пограничные ситуации. Во-первых, для минимизации коррелирования между системами по умолчанию тактовая последовательность берётся как случайное число — так делается лишь один раз за весь жизненный цикл системы. Это даёт нам дополнительное преимущество: поддержку идентификаторов узлов, которые можно переносить между системами, поскольку начальное значение тактовой последовательности совершенно не зависит от идентификатора узла.
Помните, что главная цель использования тактовой последовательности — внести долю случайности в наше уравнение. Биты тактовой последовательности помогают расширить временную метку и учитывать ситуации, когда несколько UUID генерируются ещё до того, как изменяются процессорные часы. Так мы избегаем создания одинаковых идентификаторов, когда часы переводятся назад (устройство выключено) или меняется идентификатор узла. Если часы переведены назад, или могли быть переведены назад (например, пока система была отключена), и UUID-генератор не может убедиться, что идентификаторы сгенерированы с более поздними временными метками по сравнению с заданным значением часов, тогда нужно изменить тактовую последовательность. Если нам известно её предыдущее значение, его можно просто увеличить; в противном случае его нужно задать случайным образом или с помощью высококачественного ГПСЧ.
Версия 2 (безопасность распределённой вычислительной среды)
Главное отличие этой версии от предыдущей в том, что вместо «случайности» в виде младших битов тактовой последовательности здесь используется идентификатор, характерный для системы. Часто это просто идентификатор текущего пользователя. Версия 2 используется реже, она очень мало отличается от версии 1, так что идём дальше.
Версия 3 (имя + MD5-хэш)
Если нужны уникальные идентификаторы для информации, связанной с именами или наименованием, то для этого обычно используют UUID версии 3 или версии 5.
Они кодируют любые «именуемые» сущности (сайты, DNS, простой текст и т.д.) в UUID-значение. Самое важное — для одного и того же namespace или текста будет сгенерирован такой же UUID.
Обратите внимание, что namespace сам по себе является UUID.
В этой реализации UUID namespace преобразуется в строку байтов, конкатенированных с входным именем, затем хэшируется с помощью MD5, и получается 128 битов для UUID. Затем мы переписываем некоторые биты, чтобы точно воспроизвести информацию о версии и варианте, а остальное оставляем нетронутым.
Важно понимать, что ни namespace, ни входное имя не могут быть вычислены на основе UUID. Это необратимая операция. Единственное исключение — брутфорс, когда одно из значений (namespace или текст) уже известно атакующему.
При одних и тех же входных данных генерируемые UUID версий 3 и 5 будут детерминированными.
Версия 4 (ГПСЧ)
Самая простая реализация.
6 битов зарезервированы под версию и вариант, остаётся ещё 122 бита. В этой версии просто генерируется 128 случайных битов, а потом 6 из них заменяется данными о версии и варианте.
Такие UUID полностью зависят от качества ГПСЧ (генератора псевдослучайных чисел). Если его алгоритм слишком прост, или ему не хватает начальных значений, то вероятность повторения идентификаторов возрастает.
В современных языках чаще всего используются UUID версии 4.
Её реализация достаточно простая:
Версия 5 (имя + SHA-1-хэш)
Единственное отличие от версии 3 в том, что мы используем алгоритм хэширования SHA-1 вместо MD5. Эта версия предпочтительнее третьей (SHA-1 > MD5).
Практика
Одним из важных достоинств UUID является то, что их уникальность не зависит от центрального авторизующего органа или от координации между разными системами. Кто угодно может создать UUID с определённой уверенностью в том, что в обозримом будущем это значение больше никем не будет сгенерировано.
Это позволяет комбинировать в одной БД идентификаторы, созданные разными участниками, или перемещать идентификаторы между базами с ничтожной вероятностью коллизии.
UUID можно использовать в качестве первичных ключей в базах данных, в качестве уникальных имён загружаемых файлов, уникальных имён любых веб-источников. Для их генерирования вам не нужен центральный авторизующий орган. Но это обоюдоострое решение. Из-за отсутствия контролёра невозможно отслеживать сгенерированные UUID.
Есть и ещё несколько недостатков, которые нужно устранить. Неотъемлемая случайность повышает защищённость, однако она усложняет отладку. Кроме того, UUID может быть избыточным в некоторых ситуациях. Скажем, не имеет смысла использовать 128 битов для уникальной идентификации данных, общий размер которых меньше 128 битов.
Уникальность
Может показаться, что если у вас будет достаточно времени, то вы сможете повторить какое-то значение. Особенно в случае с версией 4. Но в реальности это не так. Если бы вы генерировали один миллиард UUID в секунду в течение 100 лет, то вероятность повторения одного из значений была бы около 50 %. Это с учётом того, что ГПСЧ обеспечивает достаточное количество энтропии (истинная случайность), иначе вероятность появления дубля будет выше. Более наглядный пример: если бы вы сгенерировали 10 триллионов UUID, то вероятность появления двух одинаковых значений равна 0,00000006 %.
А в случае с версией 1 часы обнулятся только в 3603 году. Так что если вы не планируете поддерживать работу своего сервиса ещё 1583 года, то вы в безопасности.
Впрочем, вероятность появления дубля остаётся, и в некоторых системах стараются это учитывать. Но в подавляющем большинстве случаев UUID можно считать полностью уникальными. Если вам нужно больше доказательств, вот простая визуализация вероятности коллизии на практике.
Uuid java что это
There exist different variants of these global identifiers. The methods of this class are for manipulating the Leach-Salz variant, although the constructors allow the creation of any variant of UUID (described below).
The layout of a variant 2 (Leach-Salz) UUID is as follows: The most significant long consists of the following unsigned fields: The least significant long consists of the following unsigned fields:
For more information including algorithms used to create UUID s, see RFC 4122: A Universally Unique IDentifier (UUID) URN Namespace, section 4.2 «Algorithms for Creating a Time-Based UUID».
Constructor Summary
| Constructor and Description |
|---|
| UUID(long mostSigBits, long leastSigBits) |
Method Summary
| Modifier and Type | Method and Description |
|---|---|
| int | clockSequence() |
Methods inherited from class java.lang.Object
Constructor Detail
Method Detail
randomUUID
nameUUIDFromBytes
fromString
getLeastSignificantBits
getMostSignificantBits
version
variant
timestamp
The timestamp value is only meaningful in a time-based UUID, which has version type 1. If this UUID is not a time-based UUID then this method throws UnsupportedOperationException.
clockSequence
The 14 bit clock sequence value is constructed from the clock sequence field of this UUID. The clock sequence field is used to guarantee temporal uniqueness in a time-based UUID.
The clockSequence value is only meaningful in a time-based UUID, which has version type 1. If this UUID is not a time-based UUID then this method throws UnsupportedOperationException.
The 48 bit node value is constructed from the node field of this UUID. This field is intended to hold the IEEE 802 address of the machine that generated this UUID to guarantee spatial uniqueness.
The node value is only meaningful in a time-based UUID, which has version type 1. If this UUID is not a time-based UUID then this method throws UnsupportedOperationException.
toString
The UUID string representation is as described by this BNF:
hashCode
equals
compareTo
The first of two UUIDs is greater than the second if the most significant field in which the UUIDs differ is greater for the first UUID.
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2020, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.
Генератор UUID Java – Java GUID
Java UUID, РУКОВОДСТВО по Java, Генератор UUID Java, Java генерирует guid, java-uuid-генератор maven, генератор guid, пример java uuid, randomUUID, compareTo, равно.
UUID Java
Класс Java UUID (Универсальный уникальный идентификатор) является частью java.util пакета. Класс Java UUID представляет собой неизменяемый универсальный уникальный идентификатор и представляет 128-разрядное значение. Он также известен как GUID (Глобально уникальный идентификатор).
Использование UUID Java
UUID Java используется для создания следующих:
Конструктор UUID Java
Создает новый UUID, используя указанные данные.
Версия и варианты UUID
Существуют различные варианты UUID, но в основном мы увидим вариант 2 (Лич-Зальц) в наших примерах.
Генератор UUID Java
Мы можем использовать java-uuid-генератор зависимость maven для генерации UUID. Вы можете включить это, используя приведенную ниже зависимость maven.
Давайте взглянем на приведенный ниже пример программы генератора uuid java.
Выходные данные вышеупомянутой программы генератора uuid приведены ниже:
Методы UUID Java
Давайте рассмотрим приведенные ниже методы UUID с примером программы.
Выходные данные вышеупомянутой программы приведены ниже:
Выходные данные вышеупомянутой программы приведены ниже:
Вывод приведенного выше примера программы java UUID является:
Результатом работы вышеуказанной программы является:
Результатом работы вышеуказанной программы является:
Создайте UUID С помощью Конструктора
Давайте рассмотрим приведенный ниже пример программы для создания UUID с помощью ее конструктора.
Сравните два UUID
Класс UUID Java предоставляет два метода для сравнения UUID.
Это все для класса Java UUID. Это отличный служебный класс, и вы можете использовать его для создания уникальных идентификаторов.
Руководство по UUID на Java
Краткое и практическое введение в UUID на Java.
1. Обзор
UUID (Универсальный уникальный идентификатор), также известный как GUID (Глобальный уникальный идентификатор), представляет собой 128-битное значение, уникальное для всех практических целей. Стандартное представление UUID использует шестнадцатеричные цифры (октеты):
Нулевой UUID-это специальная форма UUID, в которой все биты равны нулю.
В этом уроке мы рассмотрим класс UUID в Java. Сначала мы посмотрим, как использовать сам класс. Затем мы рассмотрим различные типы UUID и то, как мы можем генерировать их в Java.
Дальнейшее чтение:
CharSequence против Строка в Java
Использовать массив char[] Над строкой для манипулирования паролями в Java?
Руководство по пулу строк Java
2. Класс UUID
Класс UUID имеет один конструктор:
Если мы хотим использовать этот конструктор, нам нужно предоставить два длинных значения. Однако это требует, чтобы мы сами построили битовый шаблон для UUID.
Для удобства существует три статических метода создания UUID.
Этот первый метод создает UUID версии 3 из заданного массива байтов:
Во-вторых, метод randomUUID() создает UUID версии 4. Это самый удобный способ создания UUID :
Третий статический метод возвращает объект UUID с учетом строкового представления данного UUID:
Давайте теперь посмотрим, как структурирован UUID.
3. Структура
Давайте возьмем пример UUID:
3.1. Вариант UUID
A представляет вариант, определяющий расположение UUID. Все остальные биты в UUID зависят от настройки битов в поле вариант. Вариант определяется тремя наиболее значимыми битами:
Значение A в упомянутом UUID равно “a”. Двоичный эквивалент “а”) показывает вариант как 2.
3.2. Версия UUID
B представляет версию. Версия в упомянутом UUID (значение B ) равна 4.
Java предоставляет методы для получения варианта и версии UUID:
Это пять различных версий для варианта 2 Uuid: основанная на времени (UUID v1), безопасность DCE (UUIDv2), основанная на имени (UUID v3 и UUIDv5) и случайная (UUIDv4).
Java предоставляет реализацию для v3 и v4, но также предоставляет конструктор для создания любого типа UUID:
4. Версии UUID
4.1. Версия 1
UUID версии 1 основан на текущей метке времени, измеренной в единицах 100 наносекунд с 15 октября 1582 года, связанной с MAC-адресом устройства, на котором создается UUID.
Если вас беспокоит конфиденциальность, UUID версии 1 может быть сгенерирован со случайным 48-битным номером вместо MAC-адреса. В этой статье мы рассмотрим эту альтернативу.
Во-первых, мы сгенерируем 64 наименьших и наиболее значимых бита в виде длинных значений:
Затем мы можем передать эти два значения конструктору UUID:
4.2. Версия 2
Версия 2 основана на метке времени и MAC-адресе. Однако RFC 4122 не указывает точных деталей генерации, поэтому мы не будем рассматривать реализацию в этой статье.
4.3. Версии 3 и 5
UUID генерируются с использованием хэша пространства имен и имени. Идентификаторами пространства имен являются UUID, такие как Система доменных имен (DNS), идентификаторы объектов (OID), URL-адреса и т. Д.
Единственное различие между UUIDv3 и UUIDv5 заключается в алгоритме хеширования — v3 использует MD5 (128 бит), в то время как v5 использует SHA-1 (160 бит).
Проще говоря, мы усекаем полученный хэш до 128 бит, а затем заменяем 4 бита для версии и 2 бита для варианта.
Давайте сгенерируем UUID типа 3:
Здесь важно отметить, что шестнадцатеричная строка для пространства имен сначала должна быть преобразована в массив байтов.
Наконец, Java не предоставляет реализацию для типа 5. Проверьте исходный код репозиторий для UUIDv5.
4.4. Версия 4
Давайте сгенерируем UUID версии 4:
Давайте сгенерируем уникальный ключ, используя “SHA-256” и случайный UUID:
5. Заключение
В этой статье мы рассмотрели, как структурирован UUID и какие существуют варианты и версии.
Мы также узнали, для каких версий Java предоставляет готовую реализацию, и рассмотрели примеры кода для создания других версий.
Java.util.UUID класс в Java
Класс, представляющий неизменный универсальный уникальный идентификатор (UUID). UUID представляет 128-битное значение. Существуют разные варианты этих глобальных идентификаторов. Методы этого класса предназначены для манипулирования вариантом Лича-Зальца, хотя конструкторы допускают создание любого варианта UUID (описано ниже).
Существует четыре различных основных типа UUID: на основе времени, безопасности DCE, на основе имени и случайно сгенерированных UUID. Эти типы имеют значения версии 1, 2, 3 и 4 соответственно.
Конструктор:
Создает новый UUID, используя указанные данные.
mostSigBits — самые значимые биты UUID
lessSigBits — младшие значащие биты UUID
Методы:
// Java-код, иллюстрирующий метод clockSequence ()
public static void main(String arg[]) throws
UUID gfg = UUID.fromString( «c81d4e2e-bcf2-11e6-869b-7df92533d2db» );
// проверка последовательности часов
// Java-код, иллюстрирующий метод compareTo ()
public static void main(String arg[])
// генерируем случайный UUID
UUID gfg1 = UUID.randomUUID();
UUID gfg2 = UUID.randomUUID();
int compare = gfg1.compareTo(gfg2);
System.out.println( «gfg1 is greater than gfg2» );
System.out.println( «both are equal» );
System.out.println( «gfg1 is smaller than gfg2» );
// Java-код, иллюстрирующий метод equals ()
public static void main(String arg[])
// генерируем случайный UUID
UUID gfg1 = UUID.randomUUID();
UUID gfg2 = UUID.randomUUID();
System.out.println( «both are equal» );
System.out.println( «both are not same» );
// Java-код, иллюстрирующий метод fromString ()
public static void main(String arg[])
// генерируем случайный UUID
UUID gfg = UUID.fromString( «e52232e1-0ded-4587-999f-4dd135a4a94f» );
System.out.println( «UUID is: » + gfg);
// Java-код, иллюстрирующий метод getLeastSignificantBits ()
public static void main(String arg[])
UUID gfg = UUID.randomUUID();
// проверка младшего значащего бита
System.out.println( «Least significant bit » +
// Java-код, иллюстрирующий бит getMostSignificantBits ()
public static void main(String arg[])
UUID gfg = UUID.randomUUID();
// проверка наиболее значимого бита
System.out.println( «Most significant bit » +
// Java-код, иллюстрирующий метод hashCode
public static void main(String arg[])
UUID gfg = UUID.randomUUID();
// проверка хеш-кода для этого UUID
System.out.println( «Hash code » +
// Java-код, иллюстрирующий методы nameUUIDFromBytes ()
public static void main(String arg[]) throws
// создание байтового массива
// создаем UUID из массива
UUID gfg = UUID.nameUUIDFromBytes(b);
// Java-код, иллюстрирующий метод node ()
public static void main(String arg[])
UUID gfg = UUID.fromString( «c81d4e2e-bcf2-11e6-869b-7df92533d2db» );
// проверка значения узла для этого UUID
System.out.println( «Node value: «
// Java-код, иллюстрирующий метод randomUUID ()
public static void main(String arg[]) throws
UUID gfg = UUID.randomUUID();
// проверка этого UUID
// Java-код, иллюстрирующий метод timeStamp ()
public static void main(String arg[]) throws
UUID gfg = UUID.fromString( «c81d4e2e-bcf2-11e6-869b-7df92533d2db» );
// проверка временного интервала для этого UUID
System.out.println( «time stamp: «
// Java-код, иллюстрирующий метод toString
public static void main(String arg[]) throws
UUID gfg = UUID.fromString( «c81d4e2e-bcf2-11e6-869b-7df92533d2db» );
// проверка формата строки для этого UUID
System.out.println( «String equivalent: «
// Java-код, иллюстрирующий метод option ()
public static void main(String arg[]) throws
UUID gfg = UUID.fromString( «c81d4e2e-bcf2-11e6-869b-7df92533d2db» );
// проверка номера варианта для этого UUID
System.out.println( «variant number is: «
// Java-код, иллюстрирующий метод version ()
public static void main(String arg[]) throws
UUID gfg = UUID.fromString( «c81d4e2e-bcf2-11e6-869b-7df92533d2db» );
// проверка номера версии для этого UUID
System.out.println( «version number is: «
Пожалуйста, пишите комментарии, если вы обнаружите что-то неправильное, или вы хотите поделиться дополнительной информацией по обсуждаемой выше теме.