Generate UUID in Java

UUID v4 - Random (recommended default)

import java.util.UUID;

// 122 bits of randomness - SecureRandom-backed
UUID id = UUID.randomUUID();
System.out.println(id.toString());
// → "550e8400-e29b-41d4-a716-446655440000"

UUID v3 - Deterministic / MD5 Namespace

import java.util.UUID;
import java.nio.charset.StandardCharsets;

// MD5 hash of namespace bytes + name - same inputs always produce the same UUID
// Prefer v5 (SHA-1) when possible; Java stdlib only provides v3
byte[] nameBytes = "example.com".getBytes(StandardCharsets.UTF_8);
UUID id = UUID.nameUUIDFromBytes(nameBytes);
System.out.println(id);

Spring Boot JPA - UUID primary key (JPA 3.1+)

import jakarta.persistence.*;
import java.util.UUID;

@Entity
public class Order {
    // JPA 3.1+ (Spring Boot 3+): auto-generates UUID v4 via SecureRandom
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private UUID id;

    private String customerName;
    // getters, setters...
}

1. Spring Boot REST API - request tracing

import org.springframework.web.filter.OncePerRequestFilter;
import jakarta.servlet.http.*;
import java.util.UUID;

public class RequestIdFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest req,
                                    HttpServletResponse res,
                                    FilterChain chain)
            throws IOException, ServletException {
        String requestId = UUID.randomUUID().toString();
        req.setAttribute("requestId", requestId);
        res.setHeader("X-Request-ID", requestId);
        chain.doFilter(req, res);
    }
}

2. Hibernate entity with UUID PK

import org.hibernate.annotations.UuidGenerator;
import jakarta.persistence.*;
import java.util.UUID;

@Entity
@Table(name = "products")
public class Product {
    @Id
    @UuidGenerator  // Hibernate 6+ - generates UUID v4 automatically
    @Column(columnDefinition = "uuid", updatable = false, nullable = false)
    private UUID id;

    private String name;
    private BigDecimal price;
}

3. Kafka message ID for deduplication

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.messaging.support.MessageBuilder;
import java.util.UUID;

@Service
public class OrderEventPublisher {
    private final KafkaTemplate<String, OrderEvent> kafkaTemplate;

    public void publish(OrderEvent event) {
        String messageId = UUID.randomUUID().toString();
        kafkaTemplate.send(
            MessageBuilder.withPayload(event)
                .setHeader("messageId", messageId)
                .build()
        );
    }
}

How do I generate a UUID in Java?

Java ships java.util.UUID in the standard library. Call UUID.randomUUID() for a cryptographically random v4 UUID (backed by SecureRandom) and .toString() for the canonical form. The JDK has no built-in v7, so use a library such as java-uuid-generator (com.fasterxml.uuid) for time-ordered UUIDs.

Is UUID.randomUUID() cryptographically secure?

Yes. UUID.randomUUID() uses the platform CSPRNG (operating system secure random source), suitable for session tokens, API keys, and idempotency keys. Do not use non-cryptographic random sources for security-sensitive identifiers.

What is the difference between UUID v4 and v7 in Java?

UUID v4 (UUID.randomUUID() or equivalent) is fully random and not sortable. UUID v7 embeds a millisecond timestamp for chronological sorting (RFC 9562). Use v4 for general-purpose IDs; use v7 for database primary keys at scale.

Do I need to install a package for UUID generation in Java?

No additional package is required for basic v4 generation in Java. Check the Installation section for version-specific notes.

How do I validate a UUID string in Java?

Use the platform's UUID parse/validation function, or test against the RFC 4122 regex: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i. Always validate external input at API boundaries.

Should I use UUIDs as database primary keys in Java applications?

UUIDs work well as primary keys for distributed systems. Prefer native UUID/BINARY(16) column types over VARCHAR(36). For very large tables, consider UUID v7 for better B-tree insert locality.

Can I generate UUIDs in Java without a network connection?

Yes. UUID generation uses local OS entropy sources and does not require network access. Each call is independent and thread-safe on modern platforms.

What output formats are available in Java?

The standard hyphenated lowercase string (36 chars) is the default. Most APIs also support 32-char hex (no hyphens) and 16-byte binary formats. Use string format for APIs and binary for database storage.

What RFC standards apply to Java UUID generation?

Version 4 UUIDs follow RFC 4122. UUID v7 follows RFC 9562 (May 2024). Ensure your chosen method produces compliant version and variant bits.

When should I avoid UUID v1?

Avoid UUID v1 in security-sensitive contexts - it embeds MAC address and timestamp information. Prefer v4 (UUID.randomUUID() or equivalent) unless you need legacy Cassandra timeuuid compatibility.