{"id":4038,"date":"2026-09-21T10:00:00","date_gmt":"2026-09-21T14:00:00","guid":{"rendered":"https:\/\/www.mymiller.name\/wordpress\/?p=4038"},"modified":"2026-09-18T08:42:58","modified_gmt":"2026-09-18T12:42:58","slug":"whats-new-in-jdk-27-features-jeps-and-architectural-enhancements","status":"publish","type":"post","link":"https:\/\/www.mymiller.name\/wordpress\/java\/whats-new-in-jdk-27-features-jeps-and-architectural-enhancements\/","title":{"rendered":"What’s New in JDK 27: Features, JEPs, and Architectural Enhancements"},"content":{"rendered":"\n

Released on September 15, 2026<\/strong>, JDK 27<\/strong> continues Java’s six-month release cadence following JDK 26 and Java 25 (LTS). As the Reference Implementation of Java SE 27 under JSR 402<\/strong>, JDK 27 delivers nine official JDK Enhancement Proposals (JEPs)<\/strong> along with landmark performance and security advancements.<\/p>\n\n\n\n

Among the headline changes are Compact Object Headers turned on by default<\/strong> (Project Lilliput), G1 becoming the universal default garbage collector across all environments<\/strong>, native Post-Quantum Hybrid Key Exchange for TLS 1.3<\/strong>, and in-process data redaction for JDK Flight Recorder (JFR)<\/strong>.<\/p>\n\n\n\n

Here is an exhaustive guide to everything included in JDK 27.<\/p>\n\n\n\n

At a Glance: The 9 JEPs of JDK 27<\/h2>\n\n\n\n
JEP<\/strong><\/td>Category<\/strong><\/td>Status<\/strong><\/td>Summary<\/strong><\/td><\/tr>
523<\/strong><\/td>HotSpot \/ GC<\/td>Permanent<\/td>Make G1 the Default Garbage Collector in All Environments<\/strong> (Universal default across client & server)<\/td><\/tr>
527<\/strong><\/td>Security \/ TLS<\/td>Permanent<\/td>Post-Quantum Hybrid Key Exchange for TLS 1.3<\/strong> (Defends against “harvest now, decrypt later” attacks)<\/td><\/tr>
531<\/strong><\/td>Core Libraries<\/td>3rd Preview<\/td>Lazy Constants<\/strong> (Thread-safe, deferred constant-folding computation)<\/td><\/tr>
532<\/strong><\/td>Language Specification<\/td>5th Preview<\/td>Primitive Types in Patterns, instanceof, and switch<\/strong> (Exhaustiveness & exact conversions)<\/td><\/tr>
533<\/strong><\/td>Concurrency<\/td>7th Preview<\/td>Structured Concurrency<\/strong> (Streamlined coordinated task handling)<\/td><\/tr>
534<\/strong><\/td>HotSpot \/ Runtime<\/td>Permanent<\/td>Compact Object Headers by Default<\/strong> (64-bit object headers across 64-bit architectures)<\/td><\/tr>
536<\/strong><\/td>Serviceability \/ JFR<\/td>Permanent<\/td>JFR In-Process Data Redaction<\/strong> (Mask sensitive and private diagnostic data before capture)<\/td><\/tr>
537<\/strong><\/td>Performance \/ SIMD<\/td>12th Incubator<\/td>Vector API<\/strong> (Expressing SIMD computations on modern vector hardware)<\/td><\/tr>
538<\/strong><\/td>Security<\/td>3rd Preview<\/td>PEM Encodings of Cryptographic Objects<\/strong> (Standardized PEM encoder\/decoder APIs)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

1. Landmark Runtime & Memory Advances<\/h2>\n\n\n\n

JEP 534: Compact Object Headers by Default<\/h3>\n\n\n\n

A historic milestone from Project Lilliput<\/strong>, JDK 27 enables Compact Object Headers<\/strong> by default on supported 64-bit architectures (x64 and AArch64).<\/p>\n\n\n\n

The Problem<\/h4>\n\n\n\n

Historically, every object on the 64-bit HotSpot JVM carried an object header overhead of 96 to 128 bits<\/strong> (comprising a 64-bit mark<\/code> word and a 32-bit compressed or 64-bit uncompressed klass<\/code> pointer). In applications with hundreds of millions of small objects (such as strings, wrappers, nodes, or domain entities), object headers consumed up to 20%\u201330% of total heap memory<\/strong>.<\/p>\n\n\n\n

The Solution in JDK 27<\/h4>\n\n\n\n

Compact Object Headers condense the object header down to a single 64-bit mark word<\/strong>, encoding both the object metadata (hash code, locking state, age bits) and the compressed class pointer into one unified layout.<\/p>\n\n\n\n

Traditional 64-bit Header (96 to 128 bits):\n+----------------------------------+-----------------------+\n|            Mark Word             |    Klass Pointer      |\n|             (64 bits)            |   (32 or 64 bits)     |\n+----------------------------------+-----------------------+\n\nJDK 27 Compact Object Header (64 bits total):\n+----------------------------------------------------------+\n|       Combined Mark Word + Compressed Class Pointer      |\n|                         (64 bits)                        |\n+----------------------------------------------------------+\n<\/code><\/pre>\n\n\n\n
Real-World Impact<\/h4>\n\n\n\n
    \n
  • Heap Footprint Reduction<\/strong>: Real-world applications typically see an immediate 10% to 20% reduction<\/strong> in live heap memory without code modifications.<\/li>\n\n\n\n
  • Improved CPU Cache Density<\/strong>: Smaller objects translate to higher $L1\/L2\/L3$ cache line utilization, yielding noticeable throughput gains on data-intensive workloads.<\/li>\n\n\n\n
  • Fallback Flag<\/strong>: If legacy tooling or low-level agents experience incompatibility with native offsets, compact headers can be disabled using:-XX:-UseCompactObjectHeaders<\/code><\/li>\n<\/ul>\n\n\n\n
    JEP 523: Make G1 the Default Garbage Collector in All Environments<\/h3>\n\n\n\n
    Since JDK 9, the Garbage-First (G1) collector has been the default GC for “server-class” machines (systems with at least 2 CPU cores and 2 GB of RAM). However, on resource-constrained containers or single-core virtual machines, HotSpot previously reverted to the single-threaded Serial GC<\/strong>.<\/p>\n\n\n\n
    What Changes in JDK 27<\/h4>\n\n\n\n
    JEP 523 removes the environment distinction: G1 is now the default collector for all JVM instances<\/strong>, regardless of core count or memory size.<\/p>\n\n\n\n
      \n
    • Why?<\/strong> Advances in G1 (including the write-barrier synchronization overhauls completed in JDK 26) have reduced its baseline memory overhead and latency jitter to the point where it consistently matches or outperforms Serial GC even in constrained cloud containers.<\/li>\n\n\n\n
    • Consistency<\/strong>: Eliminates unexpected behavioral and performance divergence when containerized microservices transition between low-resource development instances and production environments.<\/li>\n\n\n\n
    • Manual Override<\/strong>: For embedded or ultralight CLI applications where minimal memory usage supersedes parallel throughput, Serial GC remains available via:-XX:+UseSerialGC<\/code><\/li>\n<\/ul>\n\n\n\n
      2. Post-Quantum Cryptography & Enterprise Security<\/h2>\n\n\n\n
      JEP 527: Post-Quantum Hybrid Key Exchange for TLS 1.3<\/h3>\n\n\n\n
      With quantum computers rapidly progressing toward breaking standard asymmetric cryptography (RSA, ECDHE), organizations face the threat of “Harvest Now, Decrypt Later”<\/strong> attacks\u2014where adversaries intercept and store encrypted traffic today to decrypt it once quantum resources become available.<\/p>\n\n\n\n
      JEP 527 integrates standardized post-quantum hybrid key exchange schemes into the native Java TLS 1.3 implementation:<\/p>\n\n\n\n
        \n
      • Hybrid Mechanisms Supported<\/strong>:\n
          \n
        • X25519MLKEM768<\/code> (Combines classical X25519 with ML-KEM-768 \/ FIPS 203)<\/li>\n\n\n\n
        • SecP256r1MLKEM768<\/code> (Combines classical ECDHE NIST P-256 with ML-KEM-768)<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
          How It Works<\/h4>\n\n\n\n
          The hybrid approach combines a classical key agreement algorithm with a post-quantum algorithm. An attacker must break both<\/strong> underlying mathematical problems simultaneously to compromise the session keys.<\/p>\n\n\n\n
          import javax.net.ssl.SSLParameters;\nimport javax.net.ssl.SSLSocket;\n\n\/\/ Inspecting or configuring TLS 1.3 Named Groups\nSSLParameters params = sslSocket.getSSLParameters();\n\n\/\/ Hybrid post-quantum algorithm is negotiated automatically when both endpoints support it\nparams.setNamedGroups(new String[] { \n    \"X25519MLKEM768\", \n    \"x25519\", \n    \"secp256r1\" \n});\nsslSocket.setSSLParameters(params);\n<\/code><\/pre>\n\n\n\n
          HotSpot activates hybrid post-quantum groups by default when negotiating TLS 1.3 connections, requiring zero boilerplate code for standard HttpClient<\/code>, SSLSocket<\/code>, and HTTP microservice servers.<\/p>\n\n\n\n
          JEP 536: JFR In-Process Data Redaction<\/h3>\n\n\n\n
          Java Flight Recorder (JFR) is an indispensable diagnostic and performance tracing tool. However, production dumps often inadvertently capture sensitive personal identifiable information (PII), API tokens, passwords, or cryptographic material embedded in thread names, query strings, or system properties.<\/p>\n\n\n\n
          JEP 536 introduces in-process data redaction<\/strong> directly into the JFR engine:<\/p>\n\n\n\n
          # Launch application with a configured JFR redaction policy\njava -XX:StartFlightRecording=filename=recording.jfr,redact=sensitive-data.xml -jar app.jar\n<\/code><\/pre>\n\n\n\n
          Key Capabilities<\/h4>\n\n\n\n
            \n
          • Pattern-Based Masking<\/strong>: Automatically detects credit card numbers, authorization headers, environment secrets, and user credentials.<\/li>\n\n\n\n
          • In-Memory Sanitization<\/strong>: Redaction occurs before<\/em> flight recording buffers flush to disk or remote streaming endpoints, ensuring unredacted secrets never persist to disk.<\/li>\n\n\n\n
          • Custom XML\/Regex Profiles<\/strong>: Security teams can supply global enterprise redaction profiles across clusters to guarantee compliance with HIPAA, GDPR, and PCI-DSS.<\/li>\n<\/ul>\n\n\n\n
            3. Language & Pattern Matching Refinements<\/h2>\n\n\n\n
            JEP 532: Primitive Types in Patterns, instanceof, and switch (5th Preview)<\/h3>\n\n\n\n
            Project Amber takes another step toward harmonizing primitive and reference types. In Java 27, primitive patterns allow direct inspection, conversion, and validation within switch<\/code> expressions and instanceof<\/code>:<\/p>\n\n\n\n
            public String describeData(Object obj) {\n    return switch (obj) {\n        \/\/ Matches exact primitive or wrapped numeric values\n        case byte b               -> \"Byte: \" + b;\n        case short s              -> \"Short: \" + s;\n        case int i when i >= 0    -> \"Positive integer: \" + i;\n        case int i                -> \"Negative integer: \" + i;\n        case long l               -> \"Long: \" + l;\n        case float f              -> \"Float: \" + f;\n        case double d             -> \"Double: \" + d;\n        case boolean bool         -> \"Flag: \" + bool;\n        case null, default        -> \"Other \/ Null: \" + obj;\n    };\n}\n<\/code><\/pre>\n\n\n\n
            Fifth Preview Enhancements:<\/h4>\n\n\n\n
              \n
            • Tighter Dominance Rules<\/strong>: The compiler provides stricter checks against unreachable patterns when primitive conversion branches overlap.<\/li>\n\n\n\n
            • Lossless Unconditional Exactness<\/strong>: Refined casting mechanics prevent silent truncation when widening or narrowing primitive types during pattern binding.<\/li>\n<\/ul>\n\n\n\n
              JEP 531: Lazy Constants (3rd Preview)<\/h3>\n\n\n\n
              Formerly explored under Project Leyden as Stable Values<\/em>, Lazy Constants<\/strong> offer a high-performance alternative to traditional double-checked locking, AtomicReference<\/code>, and cumbersome memoization utilities:<\/p>\n\n\n\n
              import java.lang.LazyConstant;\n\npublic class ConfigurationProvider {\n    \/\/ Thread-safe deferred initialization with compile-time final field performance\n    private static final LazyConstant<ServerConfig> CONFIG = \n            LazyConstant.of(() -> loadConfigFromRemoteVault());\n\n    public static ServerConfig get() {\n        return CONFIG.get();\n    }\n\n    private static ServerConfig loadConfigFromRemoteVault() {\n        return new ServerConfig(\"us-east-1.vault.internal\", 8443);\n    }\n}\n<\/code><\/pre>\n\n\n\n
              In its third preview, JEP 531 adds:<\/p>\n\n\n\n
                \n
              • Collection Integration<\/strong>: Support for lazily evaluated arrays and maps where individual elements or keys are computed only when queried, while preserving JIT constant-folding invariants once resolved.<\/li>\n\n\n\n
              • Diagnostic Inspectability<\/strong>: Built-in methods to verify initialization state without triggering computation (CONFIG.isComputed()<\/code>).<\/li>\n<\/ul>\n\n\n\n
                4. Concurrency, Cryptography & SIMD Vectorization<\/h2>\n\n\n\n
                JEP 533: Structured Concurrency (7th Preview)<\/h3>\n\n\n\n
                Structured Concurrency under Project Loom eliminates thread leaks and orphaned subtasks by coordinating concurrent operations within clear lexical scopes.<\/p>\n\n\n\n
                import java.util.concurrent.StructuredTaskScope;\n\npublic OrderSummary processOrder(String orderId) throws Exception {\n    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {\n        StructuredTaskScope.Subtask<InventoryStatus> invTask = \n                scope.fork(() -> inventoryClient.checkStock(orderId));\n        StructuredTaskScope.Subtask<PaymentConfirmation> payTask = \n                scope.fork(() -> paymentClient.authorize(orderId));\n\n        \/\/ Wait for all subtasks to complete or any to fail\n        scope.join();\n        scope.throwIfFailed();\n\n        \/\/ Safe consumption of guaranteed completed subtasks\n        return new OrderSummary(invTask.get(), payTask.get());\n    }\n}\n<\/code><\/pre>\n\n\n\n
                Seventh Preview Refinements:<\/h4>\n\n\n\n
                  \n
                • Enhanced observability integrations with JFR thread-dump events<\/strong>, explicitly visualizing parent-child subtask hierarchies.<\/li>\n\n\n\n
                • Streamlined Joiner<\/code> contract for fine-grained timeout fallbacks and partial result collection.<\/li>\n<\/ul>\n\n\n\n
                  JEP 538: PEM Encodings of Cryptographic Objects (3rd Preview)<\/h3>\n\n\n\n
                  Eliminating the historical need to pull third-party dependencies like BouncyCastle for basic certificate handling, JEP 538 introduces native APIs to read and write standard PEM formats:<\/p>\n\n\n\n
                  import java.security.PEMDecoder;\nimport java.security.PublicKey;\n\npublic class CertificateReader {\n    public static PublicKey decodeKey(String pemString) throws Exception {\n        PEMDecoder decoder = PEMDecoder.of();\n        return decoder.decode(pemString, PublicKey.class);\n    }\n}\n<\/code><\/pre>\n\n\n\n
                  Preview 3 adds support for encrypted PEM structures using password callbacks directly compatible with modern password hashing and key derivation algorithms (PKCS#5 and PKCS#8).<\/p>\n\n\n\n
                  JEP 537: Vector API (12th Incubator)<\/h3>\n\n\n\n
                  The Vector API enables developers to write architecture-agnostic SIMD code that compiles to AVX-512, Intel AMX, or ARM Neon\/SVE vector instructions:<\/p>\n\n\n\n
                  import jdk.incubator.vector.FloatVector;\nimport jdk.incubator.vector.VectorSpecies;\n\npublic class MathEngine {\n    private static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;\n\n    public void vectorScalarMultiply(float[] array, float scalar) {\n        int i = 0;\n        int bound = SPECIES.loopBound(array.length);\n        for (; i < bound; i += SPECIES.length()) {\n            var v = FloatVector.fromArray(SPECIES, array, i);\n            v.mul(scalar).intoArray(array, i);\n        }\n        \/\/ Scalar cleanup for remaining elements\n        for (; i < array.length; i++) {\n            array[i] *= scalar;\n        }\n    }\n}\n<\/code><\/pre>\n\n\n\n
                  The Vector API remains an incubating API awaiting the finalization of Project Valhalla’s Value Objects, which will allow vector elements to be represented as flat, unboxed objects on the stack.<\/p>\n\n\n\n
                  Summary of Benefits & Upgrade Strategy<\/h2>\n\n\n\n
                  Focus Area<\/strong><\/td>Direct Benefit in JDK 27<\/strong><\/td><\/tr>
                  Cloud & Infrastructure Cost<\/strong><\/td>Compact Object Headers<\/strong> instantly shrink heap footprints by up to 20%, allowing significantly higher container density.<\/td><\/tr>
                  Predictability<\/strong><\/td>Universal G1 Default<\/strong> guarantees unified GC characteristics across developer laptops, CI test runners, and multi-core production clusters.<\/td><\/tr>
                  Future-Proof Security<\/strong><\/td>Post-Quantum TLS 1.3 Key Exchange<\/strong> immediately protects transit data against future quantum threats with zero application code changes.<\/td><\/tr>
                  Operational Privacy<\/strong><\/td>JFR In-Process Data Redaction<\/strong> makes production performance traces safe and compliant for cloud environments.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                  How to Upgrade to JDK 27<\/h3>\n\n\n\n
                    \n
                  1. Verify Header Compatibility<\/strong>: Run test suites with -XX:+UseCompactObjectHeaders<\/code> (default in 27) to verify that any third-party reflection, Unsafe, or JNI libraries continue operating smoothly.<\/li>\n\n\n\n
                  2. Review Default GC Settings<\/strong>: If you previously relied on implicit Serial GC behavior on single-CPU micro-containers, verify memory budgets under G1 or specify -XX:+UseSerialGC<\/code> where needed.<\/li>\n\n\n\n
                  3. Audit TLS Configurations<\/strong>: Ensure intermediate enterprise proxies support post-quantum key exchange groups in TLS 1.3 handshakes.<\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"
                    Released on September 15, 2026, JDK 27 continues Java’s six-month release cadence following JDK 26 and Java 25 (LTS). As the Reference Implementation of Java SE 27 under JSR 402, JDK 27 delivers nine official JDK Enhancement Proposals (JEPs) along with landmark performance and security advancements. Among the headline changes are Compact Object Headers turned […]<\/p>\n","protected":false},"author":1,"featured_media":4039,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_coblocks_attr":"","_coblocks_dimensions":"","_coblocks_responsive_height":"","_coblocks_accordion_ie_support":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[280],"tags":[69,498],"series":[],"class_list":["post-4038","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-2","tag-jdk"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2026\/09\/Gemini_Generated_Image_lgbas2lgbas2lgba-1.avif","jetpack-related-posts":[{"id":4035,"url":"https:\/\/www.mymiller.name\/wordpress\/java\/whats-new-in-jdk-26-features-jeps-and-enhancements\/","url_meta":{"origin":4038,"position":0},"title":"What’s New in JDK 26: Features, JEPs, and Enhancements","author":"Jeffery Miller","date":"September 18, 2026","format":false,"excerpt":"Released on March 17, 2026, JDK 26 is the six-month feature release following Java 25 (LTS). Bringing 10 official JDK Enhancement Proposals (JEPs) along with critical HotSpot runtime optimizations, JDK 26 introduces modern networking protocols, tightens language safety, optimizes garbage collection throughput, and refines concurrency patterns. Here is a comprehensive\u2026","rel":"","context":"In "JAVA"","block_context":{"text":"JAVA","link":"https:\/\/www.mymiller.name\/wordpress\/category\/java\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2026\/09\/Gemini_Generated_Image_rgp2zkrgp2zkrgp2-scaled.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2026\/09\/Gemini_Generated_Image_rgp2zkrgp2zkrgp2-scaled.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2026\/09\/Gemini_Generated_Image_rgp2zkrgp2zkrgp2-scaled.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2026\/09\/Gemini_Generated_Image_rgp2zkrgp2zkrgp2-scaled.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2026\/09\/Gemini_Generated_Image_rgp2zkrgp2zkrgp2-scaled.avif 3x"},"classes":[]},{"id":3619,"url":"https:\/\/www.mymiller.name\/wordpress\/java_new_features\/virtual-threads-revolutionizing-concurrency-in-jdk-21\/","url_meta":{"origin":4038,"position":1},"title":"Virtual Threads: Revolutionizing Concurrency in JDK 21","author":"Jeffery Miller","date":"April 20, 2026","format":false,"excerpt":"In JDK 21, Java introduces a groundbreaking feature that\u2019s poised to redefine how we handle concurrency: virtual threads. Virtual threads promise to simplify concurrent programming, improve application scalability, and unlock new levels of efficiency. Let\u2019s delve into what virtual threads are and how you can harness their power. The Challenge\u2026","rel":"","context":"In "Java New Features"","block_context":{"text":"Java New Features","link":"https:\/\/www.mymiller.name\/wordpress\/category\/java_new_features\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/04\/ai-generated-8241450_640.jpg?fit=640%2C480&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/04\/ai-generated-8241450_640.jpg?fit=640%2C480&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/04\/ai-generated-8241450_640.jpg?fit=640%2C480&ssl=1&resize=525%2C300 1.5x"},"classes":[]},{"id":3594,"url":"https:\/\/www.mymiller.name\/wordpress\/docker\/fips-jdk-21-image\/","url_meta":{"origin":4038,"position":2},"title":"FIPS JDK 21 Image","author":"Jeffery Miller","date":"July 12, 2024","format":false,"excerpt":"Warning: Use FIPS Instructions at Your Own Risk The provided Dockerfile and instructions are intended to assist in creating a FIPS-compliant environment for your Spring Boot application. However, achieving and maintaining FIPS compliance is a complex process with potential legal and security implications. By following these instructions, you acknowledge and\u2026","rel":"","context":"In "Docker"","block_context":{"text":"Docker","link":"https:\/\/www.mymiller.name\/wordpress\/category\/docker\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/Gemini_Generated_Image_6lwv546lwv546lwv-jpg.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/Gemini_Generated_Image_6lwv546lwv546lwv-jpg.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/Gemini_Generated_Image_6lwv546lwv546lwv-jpg.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/Gemini_Generated_Image_6lwv546lwv546lwv-jpg.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/Gemini_Generated_Image_6lwv546lwv546lwv-jpg.avif 3x"},"classes":[]},{"id":3249,"url":"https:\/\/www.mymiller.name\/wordpress\/java_tips\/java-tips-part-5\/","url_meta":{"origin":4038,"position":3},"title":"Java Tips Part 5","author":"Jeffery Miller","date":"August 19, 2026","format":false,"excerpt":"Tip 21: Use Prepared Statements When working with JPA\/Hibernate make use of Prepared Statements that can be reused. Basically, I'm saying do not do the following: Query query = JPA.em().createNativeQuery(\"select count(*) from user u inner join\" + \"address a where a.user_id=u.id and a.city='\" + city + \"'\"); BigInteger val =\u2026","rel":"","context":"In "Java Tips"","block_context":{"text":"Java Tips","link":"https:\/\/www.mymiller.name\/wordpress\/category\/java_tips\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2021\/12\/sam-dan-truong-rF4kuvgHhU-unsplash-scaled-e1640791434235.jpg?fit=640%2C427&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2021\/12\/sam-dan-truong-rF4kuvgHhU-unsplash-scaled-e1640791434235.jpg?fit=640%2C427&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2021\/12\/sam-dan-truong-rF4kuvgHhU-unsplash-scaled-e1640791434235.jpg?fit=640%2C427&ssl=1&resize=525%2C300 1.5x"},"classes":[]},{"id":3912,"url":"https:\/\/www.mymiller.name\/wordpress\/uncategorized\/spring-boot-4-0-whats-next-for-the-modern-java-architect\/","url_meta":{"origin":4038,"position":4},"title":"Spring Boot 4.0: What’s Next for the Modern Java Architect?","author":"Jeffery Miller","date":"September 24, 2025","format":false,"excerpt":"A Forward-Looking Comparison of Spring Boot 3.x and 4.0 Staying on top of the rapidly evolving Java ecosystem is paramount for any software architect. The shift from Spring Boot 2.x to 3.x brought significant changes, notably the move to Jakarta EE. Now, with the horizon of Spring Boot 4.0 and\u2026","rel":"","context":"Similar post","block_context":{"text":"Similar post","link":""},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/09\/per-2056740_1280.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/09\/per-2056740_1280.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/09\/per-2056740_1280.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/09\/per-2056740_1280.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/09\/per-2056740_1280.avif 3x"},"classes":[]},{"id":3444,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_discovery\/spring-boot-admin-server-with-spring-cloud-discovery\/","url_meta":{"origin":4038,"position":5},"title":"Spring Boot Admin Server with Spring Cloud Discovery","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Spring Boot Admin Server is a powerful tool for monitoring and managing Spring Boot applications. It provides a centralized dashboard for viewing application health, metrics, and logs. Spring Cloud Discovery, on the other hand, enables service registration and discovery for microservices-based applications. By integrating Spring Boot Admin Server with Spring\u2026","rel":"","context":"In "Spring Discovery"","block_context":{"text":"Spring Discovery","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_discovery\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/manhattan-3866140_640.jpg?fit=640%2C427&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/manhattan-3866140_640.jpg?fit=640%2C427&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/manhattan-3866140_640.jpg?fit=640%2C427&ssl=1&resize=525%2C300 1.5x"},"classes":[]}],"jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/4038","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/comments?post=4038"}],"version-history":[{"count":1,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/4038\/revisions"}],"predecessor-version":[{"id":4040,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/4038\/revisions\/4040"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media\/4039"}],"wp:attachment":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media?parent=4038"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/categories?post=4038"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/tags?post=4038"},{"taxonomy":"series","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/series?post=4038"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}