{"id":3822,"date":"2025-12-24T10:00:49","date_gmt":"2025-12-24T15:00:49","guid":{"rendered":"https:\/\/www.mymiller.name\/wordpress\/?p=3822"},"modified":"2025-12-24T10:00:49","modified_gmt":"2025-12-24T15:00:49","slug":"beyond-basic-crud-mapping-life-cycle-event-methods-to-spring-data-rest-operations","status":"publish","type":"post","link":"https:\/\/www.mymiller.name\/wordpress\/spring_rest\/beyond-basic-crud-mapping-life-cycle-event-methods-to-spring-data-rest-operations\/","title":{"rendered":"Beyond Basic CRUD: Mapping Life Cycle Event Methods to Spring Data REST Operations"},"content":{"rendered":"\n<div class=\"wp-block-jetpack-markdown\"><p>Spring Data REST elegantly exposes your JPA entities as RESTful resources, handling the underlying Create, Retrieve, Update, and Delete (CRUD) operations. But how do the life cycle events we discussed earlier align with these API interactions? Understanding this mapping is crucial for effectively implementing custom logic at the right moments.<\/p>\n<p>This article updates our previous discussion to explicitly illustrate how Spring Data REST operations trigger the various Spring Data Commons life cycle events.<\/p>\n<p><strong>Mapping REST Operations to Life Cycle Events<\/strong><\/p>\n<p>Here\u2019s a breakdown of how the standard Spring Data REST endpoints correspond to the published life cycle events:<\/p>\n<p><strong>1. Create (POST \/your-entity-path)<\/strong><\/p>\n<p>When a client sends a <code>POST<\/code> request to create a new entity, the following events are typically published in this order:<\/p>\n<ul>\n<li><strong><code>BeforeConvertEvent&lt;T&gt;<\/code>:<\/strong> Published <em>before<\/em> the incoming request body (typically JSON) is converted into an entity object.<\/li>\n<li><strong><code>BeforeCreateEvent&lt;T&gt;<\/code>:<\/strong> Published <em>before<\/em> the new entity is persisted to the database for the first time. This is a prime spot for setting initial values or performing creation-specific validations. (Corresponds to JPA\u2019s <code>@PrePersist<\/code> if defined within the entity).<\/li>\n<li><strong><code>BeforeSaveEvent&lt;T&gt;<\/code>:<\/strong> Published <em>before<\/em> the entity is saved, encompassing both creation and updates.<\/li>\n<li><strong><code>AfterCreateEvent&lt;T&gt;<\/code>:<\/strong> Published <em>after<\/em> the new entity has been successfully persisted to the database. You might use this for sending confirmation emails or triggering follow-up processes. (Corresponds to JPA\u2019s <code>@PostPersist<\/code> if defined within the entity).<\/li>\n<li><strong><code>AfterSaveEvent&lt;T&gt;<\/code>:<\/strong> Published <em>after<\/em> the entity has been successfully saved (creation in this case).<\/li>\n<\/ul>\n<p><strong>Example Listener for Create Operations:<\/strong><\/p>\n<pre><code class=\"language-java\">import org.springframework.context.event.EventListener;\nimport org.springframework.stereotype.Component;\nimport org.springframework.data.rest.core.event.BeforeCreateEvent;\nimport org.springframework.data.rest.core.event.AfterCreateEvent;\n\n@Component\npublic class ProductCreateListener {\n\n    @EventListener\n    public void handleBeforeCreate(BeforeCreateEvent&lt;Product&gt; event) {\n        Product product = event.getEntity();\n        System.out.println(&quot;About to create product: &quot; + product.getName());\n        if (product.getPrice() &lt;= 0) {\n            throw new IllegalArgumentException(&quot;Product price must be positive for creation.&quot;);\n        }\n        \/\/ Perform other pre-creation logic\n    }\n\n    @EventListener\n    public void handleAfterCreate(AfterCreateEvent&lt;Product&gt; event) {\n        Product createdProduct = event.getEntity();\n        System.out.println(&quot;Product created successfully with ID: &quot; + createdProduct.getId());\n        \/\/ Trigger post-creation actions (e.g., send notification)\n    }\n}\n<\/code><\/pre>\n<p><strong>2. Retrieve (GET \/your-entity-path\/{id} or GET \/your-entity-path)<\/strong><\/p>\n<p>Retrieving entities via <code>GET<\/code> requests generally <strong>does not trigger<\/strong> the standard Spring Data Commons life cycle events related to persistence (create, save, delete). The data is simply read from the database.<\/p>\n<p>You might, however, implement custom logic within your entity or a service layer that is invoked <em>after<\/em> the entity is retrieved by your repository\u2019s <code>findById()<\/code> or similar methods. This is outside the scope of the standard Spring Data REST event publishing.<\/p>\n<p><strong>3. Update (PUT \/your-entity-path\/{id} or PATCH \/your-entity-path\/{id})<\/strong><\/p>\n<p>When a client sends a <code>PUT<\/code> (full update) or <code>PATCH<\/code> (partial update) request to modify an existing entity, the following events are typically published:<\/p>\n<ul>\n<li><strong><code>BeforeConvertEvent&lt;T&gt;<\/code>:<\/strong> Published <em>before<\/em> the incoming request body is converted into an entity object.<\/li>\n<li><strong><code>BeforeUpdateEvent&lt;T&gt;<\/code>:<\/strong> Published <em>before<\/em> the existing entity is updated in the database. This is an ideal place for update-specific validations or modifications. (Corresponds to JPA\u2019s <code>@PreUpdate<\/code> if defined within the entity).<\/li>\n<li><strong><code>BeforeSaveEvent&lt;T&gt;<\/code>:<\/strong> Published <em>before<\/em> the entity is saved (update in this case).<\/li>\n<li><strong><code>AfterUpdateEvent&lt;T&gt;<\/code>:<\/strong> Published <em>after<\/em> the existing entity has been successfully updated in the database. You might use this for auditing changes. (Corresponds to JPA\u2019s <code>@PostUpdate<\/code> if defined within the entity).<\/li>\n<li><strong><code>AfterSaveEvent&lt;T&gt;<\/code>:<\/strong> Published <em>after<\/em> the entity has been successfully saved (update in this case).<\/li>\n<\/ul>\n<p><strong>Example Listener for Update Operations:<\/strong><\/p>\n<pre><code class=\"language-java\">import org.springframework.context.event.EventListener;\nimport org.springframework.stereotype.Component;\nimport org.springframework.data.rest.core.event.BeforeUpdateEvent;\nimport org.springframework.data.rest.core.event.AfterUpdateEvent;\n\n@Component\npublic class ProductUpdateListener {\n\n    @EventListener\n    public void handleBeforeUpdate(BeforeUpdateEvent&lt;Product&gt; event) {\n        Product product = event.getEntity();\n        System.out.println(&quot;About to update product with ID: &quot; + product.getId());\n        if (product.getPrice() &lt; 0) {\n            throw new IllegalArgumentException(&quot;Product price cannot be negative for update.&quot;);\n        }\n        \/\/ Perform pre-update logic\n    }\n\n    @EventListener\n    public void handleAfterUpdate(AfterUpdateEvent&lt;Product&gt; event) {\n        Product updatedProduct = event.getEntity();\n        System.out.println(&quot;Product with ID &quot; + updatedProduct.getId() + &quot; updated successfully.&quot;);\n        \/\/ Perform post-update actions (e.g., logging changes)\n    }\n}\n<\/code><\/pre>\n<p><strong>4. Delete (DELETE \/your-entity-path\/{id})<\/strong><\/p>\n<p>When a client sends a <code>DELETE<\/code> request to remove an entity, the following events are typically published:<\/p>\n<ul>\n<li><strong><code>BeforeDeleteEvent&lt;T&gt;<\/code>:<\/strong> Published <em>before<\/em> the entity is deleted from the database. This is the last chance to perform actions before removal, such as checking for dependencies or logging. (Corresponds to JPA\u2019s <code>@PreRemove<\/code> if defined within the entity).<\/li>\n<li><strong><code>AfterDeleteEvent&lt;T&gt;<\/code>:<\/strong> Published <em>after<\/em> the entity has been successfully deleted from the database. You might use this for cleanup tasks or notifications. (Corresponds to JPA\u2019s <code>@PostRemove<\/code> if defined within the entity).<\/li>\n<\/ul>\n<p><strong>Example Listener for Delete Operations:<\/strong><\/p>\n<pre><code class=\"language-java\">import org.springframework.context.event.EventListener;\nimport org.springframework.stereotype.Component;\nimport org.springframework.data.rest.core.event.BeforeDeleteEvent;\nimport org.springframework.data.rest.core.event.AfterDeleteEvent;\n\n@Component\npublic class ProductDeleteListener {\n\n    @EventListener\n    public void handleBeforeDelete(BeforeDeleteEvent&lt;Product&gt; event) {\n        Product product = event.getEntity();\n        System.out.println(&quot;About to delete product with ID: &quot; + product.getId() + &quot; ('&quot; + product.getName() + &quot;')&quot;);\n        \/\/ Perform pre-deletion checks (e.g., ensure no active orders)\n    }\n\n    @EventListener\n    public void handleAfterDelete(AfterDeleteEvent&lt;Product&gt; event) {\n        Product deletedProduct = event.getEntity();\n        System.out.println(&quot;Product with ID &quot; + deletedProduct.getId() + &quot; deleted successfully.&quot;);\n        \/\/ Perform post-deletion actions (e.g., update related records)\n    }\n}\n<\/code><\/pre>\n<p><strong>Key Takeaways:<\/strong><\/p>\n<ul>\n<li><strong>Create Operations:<\/strong> Trigger <code>BeforeConvertEvent<\/code>, <code>BeforeCreateEvent<\/code>, <code>BeforeSaveEvent<\/code>, <code>AfterCreateEvent<\/code>, and <code>AfterSaveEvent<\/code>.<\/li>\n<li><strong>Retrieve Operations:<\/strong> Generally do not trigger standard persistence-related life cycle events.<\/li>\n<li><strong>Update Operations:<\/strong> Trigger <code>BeforeConvertEvent<\/code>, <code>BeforeUpdateEvent<\/code>, <code>BeforeSaveEvent<\/code>, <code>AfterUpdateEvent<\/code>, and <code>AfterSaveEvent<\/code>.<\/li>\n<li><strong>Delete Operations:<\/strong> Trigger <code>BeforeDeleteEvent<\/code> and <code>AfterDeleteEvent<\/code>.<\/li>\n<\/ul>\n<p><strong>Choosing the Right Event:<\/strong><\/p>\n<p>Selecting the appropriate event listener depends on when you need your logic to execute:<\/p>\n<ul>\n<li><strong><code>Before<\/code> events:<\/strong> Ideal for validation, setting initial values, preventing operations, or performing actions that need to happen <em>before<\/em> database interaction. Throwing an exception in a <code>before<\/code> event will typically prevent the operation from proceeding and result in an error response.<\/li>\n<li><strong><code>After<\/code> events:<\/strong> Suitable for tasks that should occur <em>after<\/em> the database operation is successful, such as auditing, logging, sending notifications, or triggering asynchronous processes.<\/li>\n<\/ul>\n<p>By understanding this mapping between Spring Data REST operations and the underlying life cycle events, you can effectively extend the default behavior of your automatically generated APIs to meet the specific needs of your application. Remember to choose the right event for your logic and implement your listeners as Spring-managed components.<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"","protected":false},"author":1,"featured_media":3488,"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":[447],"tags":[],"series":[],"class_list":["post-3822","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-spring_rest"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/04\/cpu-8661093_640.jpg?fit=640%2C640&ssl=1","jetpack-related-posts":[{"id":3820,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_rest\/effortless-api-creation-generating-crud-endpoints-with-spring-data-rest\/","url_meta":{"origin":3822,"position":0},"title":"Effortless API Creation: Generating CRUD Endpoints with Spring Data REST","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Building RESTful APIs for your data can often feel like a repetitive task. Defining endpoints, handling HTTP methods (GET, POST, PUT, DELETE), serializing and deserializing data \u2013 it all adds up. But what if you could significantly reduce this boilerplate and focus on your core domain logic? Enter Spring Data\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:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/05\/ai-generated-8041774_640.jpg?fit=640%2C479&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/05\/ai-generated-8041774_640.jpg?fit=640%2C479&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/05\/ai-generated-8041774_640.jpg?fit=640%2C479&ssl=1&resize=525%2C300 1.5x"},"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":3822,"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":3824,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_rest\/customizing-reads-triggering-events-on-get-requests-with-spring-data-rest\/","url_meta":{"origin":3822,"position":2},"title":"Customizing Reads: Triggering Events on GET Requests with Spring Data REST","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"While Spring Data REST excels at generating CRUD endpoints, the standard life cycle events we\u2019ve discussed primarily revolve around data modification (Create, Update, Delete). You might encounter scenarios where you need to trigger specific actions or logic when an entity is read via a GET request. Out of the box,\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:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/05\/ai-generated-8041774_640.jpg?fit=640%2C479&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/05\/ai-generated-8041774_640.jpg?fit=640%2C479&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/05\/ai-generated-8041774_640.jpg?fit=640%2C479&ssl=1&resize=525%2C300 1.5x"},"classes":[]},{"id":3539,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/spring-data-cassandra-simplifying-java-development-with-apache-cassandra\/","url_meta":{"origin":3822,"position":3},"title":"Spring Data Cassandra: Simplifying Java Development with Apache Cassandra","author":"Jeffery Miller","date":"September 22, 2025","format":false,"excerpt":"Apache Cassandra is a powerful NoSQL database known for its scalability and high availability. Spring Data Cassandra seamlessly integrates Spring\u2019s familiar programming model with Cassandra, boosting developer productivity. Why Spring Data Cassandra? Simplified Configuration: Spring Boot auto-configuration minimizes manual setup. Object-Relational Mapping (ORM): Easily map Java objects to Cassandra tables.\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:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/network-3396348_1280.jpg?fit=1200%2C720&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/network-3396348_1280.jpg?fit=1200%2C720&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/network-3396348_1280.jpg?fit=1200%2C720&ssl=1&resize=525%2C300 1.5x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/network-3396348_1280.jpg?fit=1200%2C720&ssl=1&resize=700%2C400 2x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/network-3396348_1280.jpg?fit=1200%2C720&ssl=1&resize=1050%2C600 3x"},"classes":[]},{"id":3553,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/spring-data-rest-simplify-restful-api-development\/","url_meta":{"origin":3822,"position":4},"title":"Spring Data REST: Simplify RESTful API Development","author":"Jeffery Miller","date":"September 22, 2025","format":false,"excerpt":"Spring Data REST: Simplify RESTful API Development What is Spring Data REST? Spring Data REST is a Spring module that automatically creates RESTful APIs for Spring Data repositories. It eliminates boilerplate code, allowing you to focus on your application\u2019s core logic. Benefits: Reduced Boilerplate: No need to write controllers for\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:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/desk-593327_1280.jpg?fit=1200%2C800&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/desk-593327_1280.jpg?fit=1200%2C800&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/desk-593327_1280.jpg?fit=1200%2C800&ssl=1&resize=525%2C300 1.5x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/desk-593327_1280.jpg?fit=1200%2C800&ssl=1&resize=700%2C400 2x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/desk-593327_1280.jpg?fit=1200%2C800&ssl=1&resize=1050%2C600 3x"},"classes":[]},{"id":3502,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/spring-data-jpa-for-dummies-persisting-data-like-a-pro\/","url_meta":{"origin":3822,"position":5},"title":"Spring Data JPA for Dummies: Persisting Data Like a Pro","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Ever feel bogged down by writing tons of code just to interact with your database? If you're a Java developer working with relational databases, Spring Data JPA is your new best friend. This blog post will give you a beginner-friendly introduction to Spring Data JPA, showing you how to save\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:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/binary-2904980_1280.jpg?fit=1200%2C674&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/binary-2904980_1280.jpg?fit=1200%2C674&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/binary-2904980_1280.jpg?fit=1200%2C674&ssl=1&resize=525%2C300 1.5x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/binary-2904980_1280.jpg?fit=1200%2C674&ssl=1&resize=700%2C400 2x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/binary-2904980_1280.jpg?fit=1200%2C674&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\/3822","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=3822"}],"version-history":[{"count":1,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3822\/revisions"}],"predecessor-version":[{"id":3823,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3822\/revisions\/3823"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media\/3488"}],"wp:attachment":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media?parent=3822"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/categories?post=3822"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/tags?post=3822"},{"taxonomy":"series","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/series?post=3822"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}