{"id":3840,"date":"2025-12-24T10:01:12","date_gmt":"2025-12-24T15:01:12","guid":{"rendered":"https:\/\/www.mymiller.name\/wordpress\/?p=3840"},"modified":"2025-12-24T10:01:12","modified_gmt":"2025-12-24T15:01:12","slug":"speedy-testing-with-h3-your-in-memory-powerhouse-for-spring-boot-unit-tests","status":"publish","type":"post","link":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/speedy-testing-with-h3-your-in-memory-powerhouse-for-spring-boot-unit-tests\/","title":{"rendered":"Speedy Testing with H3: Your In-Memory Powerhouse for Spring Boot Unit Tests"},"content":{"rendered":"\n<div class=\"wp-block-jetpack-markdown\"><p>Unit testing is the bedrock of robust software. When it comes to testing your Spring Boot applications that interact with a database, spinning up a full-fledged database instance for every test can be time-consuming and resource-intensive. This is where in-memory databases like <strong>H3<\/strong> (HyperSQL Database Engine) shine.<\/p>\n<p>H3 is a lightweight, pure Java SQL database that runs entirely in memory. This makes it incredibly fast for unit tests, as there\u2019s no disk I\/O involved. It supports standard SQL and integrates seamlessly with Spring Boot and Spring Data JPA, making it an excellent choice for isolating your data access logic during unit testing.<\/p>\n<p>This article will guide you through using H3 for your Spring Boot unit tests, covering initialization, data setup, and teardown.<\/p>\n<p><strong>Why Choose H3 for Unit Testing?<\/strong><\/p>\n<ul>\n<li><strong>Blazing Fast:<\/strong> Runs in memory, significantly reducing test execution time.<\/li>\n<li><strong>Lightweight:<\/strong> Minimal overhead and easy to set up.<\/li>\n<li><strong>Pure Java:<\/strong> Platform-independent and requires no external dependencies beyond its JAR.<\/li>\n<li><strong>Standard SQL Support:<\/strong> Familiar SQL syntax makes it easy to work with.<\/li>\n<li><strong>Spring Boot Integration:<\/strong> Effortless configuration with Spring Boot\u2019s testing features.<\/li>\n<li><strong>Isolation:<\/strong> Each test can have its own isolated database instance, preventing data contamination between tests.<\/li>\n<\/ul>\n<p><strong>1. Adding the H3 Dependency<\/strong><\/p>\n<p>First, you need to include the H3 database dependency in your <code>pom.xml<\/code> (for Maven) or <code>build.gradle<\/code> (for Gradle) file:<\/p>\n<p><strong>Maven (<code>pom.xml<\/code>):<\/strong><\/p>\n<pre><code class=\"language-xml\">&lt;dependency&gt;\n    &lt;groupId&gt;com.h2database&lt;\/groupId&gt;\n    &lt;artifactId&gt;h2&lt;\/artifactId&gt;\n    &lt;scope&gt;test&lt;\/scope&gt;\n&lt;\/dependency&gt;\n<\/code><\/pre>\n<p><strong>Gradle (<code>build.gradle<\/code>):<\/strong><\/p>\n<pre><code class=\"language-gradle\">testImplementation 'com.h2database:h2'\n<\/code><\/pre>\n<p>The <code>test<\/code> scope ensures that the H3 dependency is only included during testing and not in your production build.<\/p>\n<p><strong>2. Configuring H3 for Unit Tests in Spring Boot<\/strong><\/p>\n<p>Spring Boot automatically configures an embedded in-memory database if it finds one on the classpath and no explicit database configuration is provided. By default, it might choose H2 or Derby if both are present. To ensure H3 is used, you can explicitly configure it in your <code>application.properties<\/code> or <code>application.yml<\/code> within your <code>src\/test\/resources<\/code> directory.<\/p>\n<p><strong><code>application.properties<\/code>:<\/strong><\/p>\n<pre><code class=\"language-properties\">spring.datasource.url=jdbc:h2:mem:unittestdb;DB_CLOSE_DELAY=-1\nspring.datasource.driver-class-name=org.h2.Driver\nspring.jpa.database-platform=org.hibernate.dialect.H2Dialect\nspring.jpa.hibernate.ddl-auto=create-drop\n<\/code><\/pre>\n<p><strong><code>application.yml<\/code>:<\/strong><\/p>\n<pre><code class=\"language-yaml\">spring:\n  datasource:\n    url: jdbc:h2:mem:unittestdb;DB_CLOSE_DELAY=-1\n    driver-class-name: org.h2.Driver\n  jpa:\n    database-platform: org.hibernate.dialect.H2Dialect\n    hibernate:\n      ddl-auto: create-drop\n<\/code><\/pre>\n<p><strong>Explanation of the Configuration:<\/strong><\/p>\n<ul>\n<li><strong><code>spring.datasource.url=jdbc:h2:mem:unittestdb;DB_CLOSE_DELAY=-1<\/code><\/strong>: This is the JDBC URL for an in-memory H3 database named <code>unittestdb<\/code>.\n<ul>\n<li><code>mem:<\/code>: Specifies an in-memory database.<\/li>\n<li><code>unittestdb<\/code>: The name you choose for your test database. Each test can potentially use a different name for isolation.<\/li>\n<li><code>DB_CLOSE_DELAY=-1<\/code>: This crucial setting prevents the in-memory database from being closed when the last connection is closed, ensuring it remains available for the duration of your test context.<\/li>\n<\/ul>\n<\/li>\n<li><strong><code>spring.datasource.driver-class-name=org.h2.Driver<\/code><\/strong>: Specifies the JDBC driver class for H3.<\/li>\n<li><strong><code>spring.jpa.database-platform=org.hibernate.dialect.H2Dialect<\/code><\/strong>: Tells Hibernate (if you\u2019re using Spring Data JPA) to use the H3-specific SQL dialect.<\/li>\n<li><strong><code>spring.jpa.hibernate.ddl-auto=create-drop<\/code><\/strong>: This Hibernate property automatically creates the database schema based on your JPA entities when the application context starts and drops it when the context closes. This is very convenient for unit tests as it ensures a clean database for each test run.<\/li>\n<\/ul>\n<p><strong>3. Setting Up Data for Your Tests<\/strong><\/p>\n<p>You have several options for setting up data in your H3 database for unit testing:<\/p>\n<p><strong>a) Using <code>@Sql<\/code> Annotation (Spring Test):<\/strong><\/p>\n<p>The <code>@Sql<\/code> annotation from Spring Test allows you to execute SQL scripts before and\/or after your test methods or classes. This is a clean and declarative way to populate your database with test data.<\/p>\n<pre><code class=\"language-java\">import org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;\nimport org.springframework.test.context.jdbc.Sql;\n\nimport com.example.model.Product;\nimport com.example.repository.ProductRepository;\n\nimport java.util.List;\n\nimport static org.assertj.core.api.Assertions.assertThat;\n\n@DataJpaTest\n@Sql(scripts = &quot;\/import.sql&quot;) \/\/ Executes import.sql before the test class\npublic class ProductRepositoryH3SqlAnnotationTest {\n\n    @Autowired\n    private ProductRepository productRepository;\n\n    @Test\n    @Sql(scripts = &quot;\/insert_product.sql&quot;, executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)\n    void testFindByName() {\n        List&lt;Product&gt; products = productRepository.findByName(&quot;Test Product&quot;);\n        assertThat(products).hasSize(1);\n        assertThat(products.get(0).getPrice()).isEqualTo(25.0);\n    }\n\n    @Test\n    void testFindByPriceGreaterThan() {\n        List&lt;Product&gt; products = productRepository.findByPriceGreaterThan(20.0);\n        assertThat(products).hasSize(2); \/\/ Assuming import.sql inserts more than one product\n    }\n}\n<\/code><\/pre>\n<ul>\n<li>Create SQL script files (e.g., <code>import.sql<\/code>, <code>insert_product.sql<\/code>) in your <code>src\/test\/resources<\/code> directory containing your data setup SQL statements (INSERT statements).<\/li>\n<li>Use <code>@Sql(scripts = &quot;\/path\/to\/your\/script.sql&quot;)<\/code> at the class or method level to specify the script to execute.<\/li>\n<li><code>executionPhase<\/code> allows you to control when the script is executed (e.g., <code>BEFORE_TEST_METHOD<\/code>, <code>AFTER_TEST_METHOD<\/code>).<\/li>\n<\/ul>\n<p><strong>b) Using <code>@BeforeEach<\/code> with Repository <code>save()<\/code> Methods:<\/strong><\/p>\n<p>You can programmatically set up data within your test methods or using <code>@BeforeEach<\/code> to execute before each test. This is useful for more dynamic or test-specific data.<\/p>\n<pre><code class=\"language-java\">import org.junit.jupiter.api.BeforeEach;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;\n\nimport com.example.model.Product;\nimport com.example.repository.ProductRepository;\n\nimport java.util.List;\n\nimport static org.assertj.core.api.Assertions.assertThat;\n\n@DataJpaTest\npublic class ProductRepositoryH3BeforeEachTest {\n\n    @Autowired\n    private ProductRepository productRepository;\n\n    @BeforeEach\n    void setUp() {\n        productRepository.save(new Product(&quot;Product A&quot;, 20.0));\n        productRepository.save(new Product(&quot;Product B&quot;, 30.0));\n        productRepository.save(new Product(&quot;Test Product&quot;, 25.0));\n    }\n\n    @Test\n    void testFindByName() {\n        List&lt;Product&gt; products = productRepository.findByName(&quot;Test Product&quot;);\n        assertThat(products).hasSize(1);\n        assertThat(products.get(0).getPrice()).isEqualTo(25.0);\n    }\n\n    @Test\n    void testFindByPriceGreaterThan() {\n        List&lt;Product&gt; products = productRepository.findByPriceGreaterThan(20.0);\n        assertThat(products).hasSize(2);\n    }\n}\n<\/code><\/pre>\n<p><strong>c) Using Spring Data JPA\u2019s <code>saveAll()<\/code>:<\/strong><\/p>\n<p>For inserting multiple records at once, you can use the <code>saveAll()<\/code> method in your repository within a <code>@BeforeEach<\/code> block.<\/p>\n<pre><code class=\"language-java\">@BeforeEach\nvoid setUp() {\n    productRepository.saveAll(List.of(\n            new Product(&quot;Product A&quot;, 20.0),\n            new Product(&quot;Product B&quot;, 30.0),\n            new Product(&quot;Test Product&quot;, 25.0)\n    ));\n}\n<\/code><\/pre>\n<p><strong>4. Teardown and Clean Up<\/strong><\/p>\n<p>With H3 and the <code>spring.jpa.hibernate.ddl-auto=create-drop<\/code> configuration, the database schema is automatically dropped after your test context closes. This provides a clean slate for each test run without requiring explicit teardown in most cases.<\/p>\n<p>However, if you need more granular control or want to clean up specific data after a test method, you can use:<\/p>\n<ul>\n<li><strong><code>@Sql(scripts = &quot;\/cleanup.sql&quot;, executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)<\/code>:<\/strong> Create a <code>cleanup.sql<\/code> script with <code>DELETE<\/code> statements.<\/li>\n<li><strong><code>@AfterEach<\/code> with Repository <code>deleteAll()<\/code> or specific <code>delete()<\/code> methods:<\/strong> Programmatically delete data after each test.<\/li>\n<\/ul>\n<pre><code class=\"language-java\">import org.junit.jupiter.api.AfterEach;\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;\n\nimport com.example.model.Product;\nimport com.example.repository.ProductRepository;\n\nimport java.util.List;\n\nimport static org.assertj.core.api.Assertions.assertThat;\n\n@DataJpaTest\npublic class ProductRepositoryH3TeardownTest {\n\n    @Autowired\n    private ProductRepository productRepository;\n\n    @BeforeEach\n    void setUp() {\n        productRepository.save(new Product(&quot;Test Product&quot;, 25.0));\n    }\n\n    @Test\n    void testFindByName() {\n        List&lt;Product&gt; products = productRepository.findByName(&quot;Test Product&quot;);\n        assertThat(products).hasSize(1);\n    }\n\n    @AfterEach\n    void tearDown() {\n        productRepository.deleteAll(); \/\/ Clears all data after each test\n    }\n}\n<\/code><\/pre>\n<p><strong>Best Practices for Unit Testing with H3:<\/strong><\/p>\n<ul>\n<li><strong>Keep Tests Focused:<\/strong> Each unit test should verify a specific behavior of your data access logic.<\/li>\n<li><strong>Use Meaningful Data:<\/strong> Create test data that clearly demonstrates the scenario you are testing.<\/li>\n<li><strong>Ensure Test Isolation:<\/strong> While <code>create-drop<\/code> helps, be mindful of potential shared state if you reuse the same database name across tests without proper setup\/teardown. Consider using unique database names or cleaning up data explicitly.<\/li>\n<li><strong>Test Edge Cases:<\/strong> Don\u2019t just test the happy path. Include tests for empty results, null values, and boundary conditions.<\/li>\n<li><strong>Verify State:<\/strong> Focus on asserting the state of your entities after repository operations.<\/li>\n<\/ul>\n<p><strong>Conclusion:<\/strong><\/p>\n<p>H3 is a powerful ally in your Spring Boot unit testing strategy. Its speed and ease of integration make it ideal for isolating and verifying your data access layer. By following the steps outlined in this article for initialization, data setup using <code>@Sql<\/code> or programmatic methods, and understanding the automatic teardown provided by Spring Boot and H3, you can write faster, more reliable, and more maintainable unit tests for your Spring Data REST applications. Embrace the speed of in-memory testing and elevate the quality of your code!<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"","protected":false},"author":1,"featured_media":3855,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_coblocks_attr":"","_coblocks_dimensions":"","_coblocks_responsive_height":"","_coblocks_accordion_ie_support":"","jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_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}},"categories":[435],"tags":[],"series":[],"class_list":["post-3840","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-spring_databases"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/big-data-7216839_1280-png.avif","jetpack-related-posts":[{"id":3846,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/speed-and-reliability-unit-testing-with-mongodb-memory-server-in-spring-boot\/","url_meta":{"origin":3840,"position":0},"title":"Speed and Reliability: Unit Testing with MongoDB Memory Server in Spring Boot","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"When you\u2019re building Spring Boot applications that interact with MongoDB, ensuring the reliability of your data access layer is crucial. Unit tests play a vital role, but setting up and tearing down a real MongoDB instance for each test can be slow and cumbersome. This is where MongoDB Memory Server\u2026","rel":"","context":"In &quot;Spring Databases&quot;","block_context":{"text":"Spring Databases","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_databases\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/scientist-9234951_1280-png.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/scientist-9234951_1280-png.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/scientist-9234951_1280-png.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/scientist-9234951_1280-png.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/scientist-9234951_1280-png.avif 3x"},"classes":[]},{"id":3836,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_rest\/testing-the-waters-writing-effective-unit-tests-for-spring-data-rest-apis\/","url_meta":{"origin":3840,"position":1},"title":"Testing the Waters: Writing Effective Unit Tests for Spring Data REST APIs","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Spring Data REST is a powerful tool for rapidly exposing your JPA entities as RESTful APIs with minimal code. However, the \u201cminimal code\u201d aspect doesn\u2019t absolve you from the crucial responsibility of writing unit tests. While Spring Data REST handles much of the underlying API infrastructure, your business logic, entity\u2026","rel":"","context":"In &quot;Spring Rest&quot;","block_context":{"text":"Spring Rest","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_rest\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8136170_1280-png.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8136170_1280-png.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8136170_1280-png.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8136170_1280-png.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8136170_1280-png.avif 3x"},"classes":[]},{"id":3842,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_messaging\/taming-the-stream-effective-unit-testing-with-kafka-in-spring-boot\/","url_meta":{"origin":3840,"position":2},"title":"Taming the Stream: Effective Unit Testing with Kafka in Spring Boot","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Kafka\u2019s asynchronous, distributed nature introduces unique challenges to testing. Unlike traditional synchronous systems, testing Kafka interactions requires verifying message production, consumption, and handling potential asynchronous delays. This article explores strategies for robust unit testing of Kafka components within a Spring Boot application. Understanding the Testing Landscape Before diving into specifics,\u2026","rel":"","context":"In &quot;Spring Messaging&quot;","block_context":{"text":"Spring Messaging","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_messaging\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/intro-7400243_640.jpg?fit=640%2C334&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/intro-7400243_640.jpg?fit=640%2C334&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/intro-7400243_640.jpg?fit=640%2C334&ssl=1&resize=525%2C300 1.5x"},"classes":[]},{"id":3848,"url":"https:\/\/www.mymiller.name\/wordpress\/java\/level-up-your-testing-structuring-unit-tests-with-subclasses\/","url_meta":{"origin":3840,"position":3},"title":"Level Up Your Testing: Structuring Unit Tests with Subclasses","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"When your project grows, unit test classes can become repetitive. You often find yourself duplicating setup code, utility methods, or common assertions across multiple test suites. Subclassing provides a powerful way to eliminate this redundancy, promote code reuse, and create a more organized and maintainable testing structure. Why Use Subclasses\u2026","rel":"","context":"In &quot;JAVA&quot;","block_context":{"text":"JAVA","link":"https:\/\/www.mymiller.name\/wordpress\/category\/java\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8686283_1280-jpg.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8686283_1280-jpg.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8686283_1280-jpg.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8686283_1280-jpg.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/10\/ai-generated-8686283_1280-jpg.avif 3x"},"classes":[]},{"id":3616,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_test\/mastering-spring-boot-testing-with-junit-5-setup-teardown-and-mockito-a-comprehensive-guide\/","url_meta":{"origin":3840,"position":4},"title":"Mastering Spring Boot Testing with JUnit 5, Setup\/Teardown, and Mockito: A Comprehensive Guide","author":"Jeffery Miller","date":"December 22, 2025","format":false,"excerpt":"JUnit 5, the latest iteration of the popular Java testing framework, provides a powerful arsenal of tools for testing Spring applications. This post dives into how you can leverage JUnit 5\u2019s annotations like @BeforeEach, @AfterEach, and others, along with Spring\u2019s testing capabilities, to create well-structured, maintainable, and efficient tests. Why\u2026","rel":"","context":"In &quot;Spring Testing&quot;","block_context":{"text":"Spring Testing","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_test\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/07\/test-4092025_1280-jpg.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/07\/test-4092025_1280-jpg.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/07\/test-4092025_1280-jpg.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/07\/test-4092025_1280-jpg.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/07\/test-4092025_1280-jpg.avif 3x"},"classes":[]},{"id":3548,"url":"https:\/\/www.mymiller.name\/wordpress\/spring\/beyond-the-basics-optimizing-your-spring-boot-applications-for-performance-fine-tune-your-application-for-speed-and-efficiency\/","url_meta":{"origin":3840,"position":5},"title":"Beyond the Basics: Optimizing Your Spring Boot Applications for Performance &#8211; Fine-tune your application for speed and efficiency.","author":"Jeffery Miller","date":"November 25, 2025","format":false,"excerpt":"Absolutely! Here\u2019s a blog article on optimizing Spring Boot applications, aimed at those who already have some experience with the framework: Beyond the Basics: Optimizing Your Spring Boot Applications for Performance Spring Boot is a fantastic framework for rapidly building production-ready applications. However, as your application grows and handles more\u2026","rel":"","context":"In &quot;Spring&quot;","block_context":{"text":"Spring","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/ai-generated-8619544_1280.jpg?fit=1200%2C685&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/ai-generated-8619544_1280.jpg?fit=1200%2C685&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/ai-generated-8619544_1280.jpg?fit=1200%2C685&ssl=1&resize=525%2C300 1.5x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/ai-generated-8619544_1280.jpg?fit=1200%2C685&ssl=1&resize=700%2C400 2x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/ai-generated-8619544_1280.jpg?fit=1200%2C685&ssl=1&resize=1050%2C600 3x"},"classes":[]}],"jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3840","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=3840"}],"version-history":[{"count":1,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3840\/revisions"}],"predecessor-version":[{"id":3841,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3840\/revisions\/3841"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media\/3855"}],"wp:attachment":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media?parent=3840"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/categories?post=3840"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/tags?post=3840"},{"taxonomy":"series","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/series?post=3840"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}