{"id":3502,"date":"2025-12-24T10:00:12","date_gmt":"2025-12-24T15:00:12","guid":{"rendered":"https:\/\/www.mymiller.name\/wordpress\/?p=3502"},"modified":"2025-12-24T10:00:12","modified_gmt":"2025-12-24T15:00:12","slug":"spring-data-jpa-for-dummies-persisting-data-like-a-pro","status":"publish","type":"post","link":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/spring-data-jpa-for-dummies-persisting-data-like-a-pro\/","title":{"rendered":"Spring Data JPA for Dummies: Persisting Data Like a Pro"},"content":{"rendered":"\n

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 time and write cleaner code.<\/p>\n\n\n\n

Hold on, what’s JPA?<\/strong><\/p>\n\n\n\n

JPA (Java Persistence API) acts as a bridge between your Java objects and your relational database. It lets you map your objects to database tables, meaning you can interact with your data using familiar Java code instead of writing raw SQL queries.<\/p>\n\n\n\n

Spring Data JPA to the rescue!<\/strong><\/p>\n\n\n\n

Spring Data JPA builds on top of JPA, offering a powerful abstraction layer. This means it takes care of a lot of the repetitive tasks you’d normally do with JPA, like writing boilerplate code for data access.<\/p>\n\n\n\n

Here’s the magic:<\/strong> Spring Data JPA lets you define interfaces for your data access layer. These interfaces describe how you want to interact with your data (find by ID, delete all, etc.). Spring then automatically implements these interfaces for you at runtime!<\/p>\n\n\n\n

Let’s see it in action!<\/strong><\/p>\n\n\n\n

Imagine you have a simple application that stores information about books. Here’s a basic Book<\/code> entity class with JPA annotations:<\/p>\n\n\n\n

@Entity\npublic class Book {\n\n  @Id\n  @GeneratedValue(strategy = GenerationType.IDENTITY)\n  private Long id;\n\n  private String title;\n  private String author;\n\n  \/\/ Getters and setters omitted for brevity\n}\n<\/code><\/pre>\n\n\n\n
The @Entity<\/code> annotation marks Book<\/code> as a JPA entity, and @Id<\/code> specifies the id<\/code> field as the primary key.<\/p>\n\n\n\n
Effortless persistence with Repositories!<\/strong><\/p>\n\n\n\n
Now, to interact with Book<\/code> objects in your database, you can define a repository interface:<\/p>\n\n\n\n
<\/p>\n\n\n\n
public interface BookRepository extends JpaRepository<Book, Long> {\n\n}\n<\/code><\/pre>\n\n\n\n
This interface extends JpaRepository<\/code>, a pre-built interface from Spring Data JPA. Because of this, Spring automatically creates an implementation for BookRepository<\/code> that provides methods for common CRUD (Create, Read, Update, Delete) operations.<\/p>\n\n\n\n
Here’s a sample of how you might use BookRepository<\/code>:<\/p>\n\n\n\n
BookRepository bookRepository = \/\/ Injected by Spring\n\n\/\/ Save a new book\nBook newBook = new Book(\"The Hitchhiker's Guide to the Galaxy\", \"Douglas Adams\");\nbookRepository.save(newBook);\n\n\/\/ Find a book by ID\nLong bookId = 1L;\nBook retrievedBook = bookRepository.findById(bookId).get();\n\n\/\/ Update a book\nretrievedBook.setTitle(\"A New Hope\");\nbookRepository.save(retrievedBook);\n<\/code><\/pre>\n\n\n\n
See how clean and concise this code is? Spring Data JPA takes care of the underlying database interactions, allowing you to focus on your application logic.<\/p>\n\n\n\n
Spring Data JPA – More than CRUD!<\/strong><\/p>\n\n\n\n
Spring Data JPA offers more than just basic CRUD operations. You can define custom finder methods by following a naming convention. For example, findByTitle<\/code> would return a list of Book<\/code> objects with a matching title.<\/p>\n\n\n\n
JQL for Queries<\/strong><\/p>\n\n\n\n
Spring Data JPA offers multiple ways to formulate queries for interacting with your data. While repository methods provide a convenient way for basic operations, you might encounter situations where you need more fine-grained control over your queries. This is where JQL (Java Persistence Query Language) comes in.<\/p>\n\n\n\n
JQL in a Nutshell<\/strong><\/p>\n\n\n\n
JQL is a query language specifically designed for working with JPA entities. It resembles SQL (Structured Query Language) in syntax, but it operates on your entity classes instead of database tables.<\/p>\n\n\n\n
Why Use JQL?<\/strong><\/p>\n\n\n\n
While Spring Data JPA’s repository methods are great for most scenarios, JQL offers some advantages:<\/p>\n\n\n\n
    \n
  • Complex Queries:<\/strong>\u00a0JQL allows you to construct intricate queries that might be difficult to express using repository method names.<\/li>\n\n\n\n
  • Dynamic Queries:<\/strong>\u00a0You can build JQL queries dynamically based on user input or other runtime conditions.<\/li>\n<\/ul>\n\n\n\n
    Example Time!<\/strong><\/p>\n\n\n\n
    Let’s look at a basic example using the Book<\/code> entity from before:<\/p>\n\n\n\n
    Imagine you want to find all books written by a specific author, say “Douglas Adams.” Here’s how you could achieve this with JQL:<\/p>\n\n\n\n
    Java<\/p>\n\n\n\n
    String jpql = \"SELECT b FROM Book b WHERE b.author = :author\";\n\nBookRepository bookRepository = \/\/ Injected by Spring\n\nTypedQuery<Book> query = bookRepository.entityManager.createQuery(jpql, Book.class);\nquery.setParameter(\"author\", \"Douglas Adams\");\n\nList<Book> douglasAdamsBooks = query.getResultList();\n<\/code><\/pre>\n\n\n\n
    @Query in Action<\/strong><\/p>\n\n\n\n
    The @Query<\/code> annotation allows you to define custom finder methods within your repository interfaces. You can specify the JQL query directly within the annotation.<\/p>\n\n\n\n
    Let’s revisit our Book<\/code> example!<\/strong><\/p>\n\n\n\n
    Suppose you want to find all books published after a specific year. Here’s a custom finder method using @Query<\/code>:<\/p>\n\n\n\n
    Java<\/p>\n\n\n\n
    public interface BookRepository extends JpaRepository<Book, Long> {\n\n  @Query(\"SELECT b FROM Book b WHERE b.publicationYear > :publicationYear\")\n  List<Book> findBooksByPublicationYearAfter(@Param(\"publicationYear\") int year);\n\n}\n<\/code><\/pre>\n\n\n\n
    In this example, the findBooksByPublicationYearAfter<\/code> method is annotated with @Query<\/code>. The annotation value specifies the JQL query itself. Note that we’re using named parameters (@Param(\"publicationYear\")<\/code>) for clarity and to prevent SQL injection vulnerabilities.<\/p>\n\n\n\n
    Updating Data with @Modifying<\/strong><\/p>\n\n\n\n
    Spring Data JPA provides methods for basic CRUD operations, but what about custom update queries? The @Modifying<\/code> annotation comes to the rescue.<\/p>\n\n\n\n
    Modifying Magic<\/strong><\/p>\n\n\n\n
    The @Modifying<\/code> annotation is used in conjunction with @Query<\/code> to indicate that the query modifies data in the database (update or delete). Spring Data JPA wouldn’t execute such queries by default as they could potentially lead to unintended data loss.<\/p>\n\n\n\n
    Here’s an example of deleting all books by a specific author:<\/p>\n\n\n\n
    @Modifying\n@Query(\"DELETE FROM Book b WHERE b.author = :author\")\nvoid deleteAllBooksByAuthor(@Param(\"author\") String author);\n<\/code><\/pre>\n\n\n\n
    The deleteAllBooksByAuthor<\/code> method uses @Modifying<\/code> along with @Query<\/code> to specify a JQL deletion query.<\/p>\n\n\n\n
    This code snippet constructs a JQL query that selects all Book<\/code> objects (b<\/code>) where the author<\/code> field matches the provided value (\"Douglas Adams\"<\/code>). The query is then executed using the entityManager<\/code> and the results are stored in a list.<\/p>\n\n\n\n
    Spring Data JPA and JQL: Working Together<\/strong><\/p>\n\n\n\n
    Spring Data JPA doesn’t replace JQL. Instead, it provides ways to leverage JQL within your repository methods. You can use @Query<\/code> annotation to define custom finder methods that use JQL for their queries.<\/p>\n\n\n\n
    JQL – A Powerful Tool, Use Wisely<\/strong><\/p>\n\n\n\n
    JQL offers a powerful way to craft complex queries. However, it can also make your code less readable if overused. It’s generally recommended to use Spring Data JPA’s repository methods whenever possible and resort to JQL for specific scenarios where those methods fall short.<\/p>\n\n\n\n
    Repository Types in Spring Data JPA<\/strong><\/p>\n\n\n\n
    Spring Data JPA offers a variety of repository interfaces that cater to different data access needs. Here’s a quick breakdown of some common repository types:<\/p>\n\n\n\n
      \n
    • CrudRepository:<\/strong> This is the most basic repository interface, providing methods for essential CRUD operations (create, read, update, delete) on your entities.<\/li>\n\n\n\n
    • PagingAndSortingRepository:<\/strong> Extends CrudRepository<\/code> and adds functionalities for sorting and paginating your data. This is useful for handling large datasets or implementing features like infinite scrolling.<\/li>\n\n\n\n
    • JpaRepository:<\/strong> This is the one-stop shop for most JPA use cases. It combines the functionalities of CrudRepository<\/code> and PagingAndSortingRepository<\/code>, along with additional methods specific to JPA, like flushing the persistence context or deleting records in bulk.<\/li>\n\n\n\n
    • JpaSpecificationExecutor:<\/strong> This interface allows you to create complex queries using JPA Criteria API or Spring Data JPA’s query creation features. This is helpful for building dynamic queries based on specific criteria.<\/li>\n<\/ul>\n\n\n\n
      Choosing the Right Repository<\/strong><\/p>\n\n\n\n
      The best repository type for your needs depends on the complexity of your data access requirements.<\/p>\n\n\n\n
        \n
      • If you only need basic CRUD operations,\u00a0CrudRepository<\/code>\u00a0is a good starting point.<\/li>\n\n\n\n
      • For working with large datasets or implementing pagination, go for\u00a0PagingAndSortingRepository<\/code>\u00a0or\u00a0JpaRepository<\/code>.<\/li>\n\n\n\n
      • If you need to create intricate queries, consider using\u00a0JpaRepository<\/code>\u00a0in combination with\u00a0JpaSpecificationExecutor<\/code>.<\/li>\n<\/ul>\n\n\n\n
        Spring Data JPA provides flexibility in how you interact with your data. Understanding these different repository types will help you write more efficient and maintainable code.<\/p>\n\n\n\n
        Spring Auditing<\/strong><\/p>\n\n\n\n
        Spring Security seamlessly integrates with Spring Data JPA to provide auditing capabilities. This means you can track who made changes to your entities and when.<\/p>\n\n\n\n
        Why Audit?<\/strong><\/p>\n\n\n\n
        Auditing offers several benefits:<\/p>\n\n\n\n
          \n
        • Improved Data Security:<\/strong>\u00a0You can identify users who made specific changes to data, aiding in security investigations.<\/li>\n\n\n\n
        • Regulatory Compliance:<\/strong>\u00a0Certain regulations might require you to track data changes for audit purposes.<\/li>\n\n\n\n
        • Data Lineage Tracking:<\/strong>\u00a0Auditing helps you understand how your data has evolved over time.<\/li>\n<\/ul>\n\n\n\n
          Enabling Auditing<\/strong><\/p>\n\n\n\n
          Spring Security provides annotations to enable auditing on your JPA entities. Here’s what you need to do:<\/p>\n\n\n\n
            \n
          1. Add Dependencies:<\/strong>\u00a0Include the required Spring Security dependencies in your project’s pom.xml file.<\/li>\n\n\n\n
          2. Enable Auditing:<\/strong>\u00a0Annotate your entity classes with\u00a0@EnableJpaAuditing<\/code>\u00a0from Spring Data JPA.<\/li>\n\n\n\n
          3. Auditing Fields:<\/strong>\u00a0Use the\u00a0@CreatedDate<\/code>\u00a0and\u00a0@LastModifiedDate<\/code>\u00a0annotations from JPA to mark the fields that will store creation and modification timestamps.<\/li>\n\n\n\n
          4. Auditing User (Optional):<\/strong>\u00a0If you want to track the user who made the changes, you can use the\u00a0@CreatedBy<\/code>\u00a0and\u00a0@LastModifiedBy<\/code>\u00a0annotations along with a suitable user entity class.<\/li>\n<\/ol>\n\n\n\n
            Auditing in Action!<\/strong><\/p>\n\n\n\n
            Once you’ve enabled auditing, Spring automatically populates the designated fields (@CreatedDate<\/code>, @LastModifiedDate<\/code>, etc.) whenever an entity is persisted or updated. You can then access this information in your application logic.<\/p>\n\n\n\n
            Leveraging Auditing Data<\/strong><\/p>\n\n\n\n
            Spring Security doesn’t provide built-in functionalities to access or display audit information. However, you can retrieve the audit fields (creation date, modified date, modified by user) using getters in your entity class.<\/p>\n\n\n\n
            You can then choose how to store and utilize this data based on your specific needs. Common options include:<\/p>\n\n\n\n
              \n
            • Persisting audit information in a separate audit log table.<\/li>\n\n\n\n
            • Integrating the audit data with your security framework for user activity tracking.<\/li>\n<\/ul>\n\n\n\n
              Supported Databases<\/strong><\/p>\n\n\n\n
              Spring Data JPA shines in its ability to work with a variety of database vendors. This flexibility allows you to choose the database that best suits your project’s needs without sacrificing the convenience of Spring Data JPA’s abstractions.<\/p>\n\n\n\n
              Here’s a glimpse at some of the widely supported relational databases for Spring Data JPA:<\/p>\n\n\n\n
                \n
              • Popular Choices:<\/strong>\n
                  \n
                • H2:<\/strong> A lightweight, in-memory database that’s perfect for development and testing. Spring Boot can even auto-configure H2, making it a breeze to get started.<\/li>\n\n\n\n
                • MySQL:<\/strong> The world’s most popular open-source relational database management system (RDBMS). Spring Data JPA seamlessly integrates with MySQL, making it a go-to option for many projects.<\/li>\n\n\n\n
                • PostgreSQL:<\/strong> Another powerful open-source RDBMS known for its robustness and advanced features. Spring Data JPA provides full support for PostgreSQL.<\/li>\n\n\n\n
                • Oracle Database:<\/strong> A widely used commercial RDBMS offering high scalability and performance. Spring Data JPA allows you to leverage Oracle’s capabilities within your JPA applications.<\/li>\n\n\n\n
                • Microsoft SQL Server:<\/strong> A mature and feature-rich commercial RDBMS from Microsoft. Spring Data JPA integrates smoothly with SQL Server, making it a viable option for projects within the Microsoft ecosystem.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                  Beyond Relational Databases<\/strong><\/p>\n\n\n\n
                  While Spring Data JPA excels in the relational world, the Spring Data family extends its data access magic to other data storage solutions:<\/p>\n\n\n\n
                    \n
                  • NoSQL Databases:<\/strong> Spring Data offers modules for interacting with popular NoSQL databases like MongoDB and Cassandra, providing similar abstractions for these data stores.<\/li>\n\n\n\n
                  • Document Databases:<\/strong> Spring Data MongoDB allows you to interact with document-oriented databases like MongoDB using familiar JPA concepts.<\/li>\n<\/ul>\n\n\n\n
                    Choosing the Right Database<\/strong><\/p>\n\n\n\n
                    The best database for your project depends on various factors, including:<\/p>\n\n\n\n
                      \n
                    • Project Requirements:<\/strong> Consider the data model, scalability needs, and performance requirements of your application.<\/li>\n\n\n\n
                    • Team Expertise:<\/strong> If your team has experience working with a specific database, that might influence your choice.<\/li>\n\n\n\n
                    • Deployment Environment:<\/strong> Think about where you’ll be deploying your application and any potential database licensing costs.<\/li>\n<\/ul>\n\n\n\n
                      Spring Data JPA’s beauty extends to the cloud! Let’s explore some popular cloud providers and their supported databases for Spring Data JPA:<\/p>\n\n\n\n
                      Amazon Web Services (AWS):<\/strong><\/p>\n\n\n\n
                        \n
                      • Amazon Relational Database Service (RDS):<\/strong>\u00a0AWS RDS offers a managed service for popular relational databases like MySQL, PostgreSQL, Aurora (MySQL and PostgreSQL compatible), MariaDB, and Oracle Database. Spring Data JPA seamlessly integrates with all of these, allowing you to leverage the scalability and manageability of AWS RDS.<\/li>\n<\/ul>\n\n\n\n
                        Microsoft Azure:<\/strong><\/p>\n\n\n\n
                          \n
                        • Azure SQL Database:<\/strong>\u00a0A managed relational database service compatible with Microsoft SQL Server. Spring Data JPA allows you to leverage familiar JPA patterns when working with Azure SQL Database.<\/li>\n<\/ul>\n\n\n\n
                          Google Cloud Platform (GCP):<\/strong><\/p>\n\n\n\n
                            \n
                          • Cloud SQL:<\/strong>\u00a0A managed relational database service for MySQL and PostgreSQL. Spring Data JPA integrates smoothly with Cloud SQL, making it easy to benefit from GCP’s scalability and reliability for your JPA applications.<\/li>\n<\/ul>\n\n\n\n
                            Other Cloud Providers:<\/strong><\/p>\n\n\n\n
                            Many other cloud providers offer managed database services compatible with Spring Data JPA. Here are a few examples:<\/p>\n\n\n\n
                              \n
                            • DigitalOcean:<\/strong>\u00a0Managed databases for MySQL, PostgreSQL, and other options.<\/li>\n\n\n\n
                            • Heroku:<\/strong>\u00a0Supports various database options, including PostgreSQL and MySQL.<\/li>\n<\/ul>\n\n\n\n
                              Here are some additional features of Spring JPA that we haven’t covered yet:<\/p>\n\n\n\n
                                \n
                              • Caching:<\/strong> Spring Data JPA integrates with caching providers like Ehcache and JCache to cache frequently accessed data, improving performance.<\/li>\n\n\n\n
                              • Transactions:<\/strong> Spring JPA allows you to manage database transactions within your service layer using annotations like @Transactional<\/code>.<\/li>\n\n\n\n
                              • Entity Listeners:<\/strong> You can define entity listeners to execute specific code before or after certain lifecycle events of your entities (e.g., before persisting, after deleting).<\/li>\n\n\n\n
                              • Specifications:<\/strong> Spring Data JPA provides a powerful way to build complex queries using JPA Criteria API or Spring Data JPA’s query creation features.<\/li>\n\n\n\n
                              • Projections:<\/strong> You can define projections to return specific data from your entities instead of the entire entity object, optimizing data transfer.<\/li>\n\n\n\n
                              • Data Persistence with XML (Optional):<\/strong> While annotations are preferred for most cases, Spring JPA also supports defining persistence logic using XML configuration files.<\/li>\n\n\n\n
                              • Advanced JPA Features:<\/strong> Spring Data JPA doesn’t prevent you from using more advanced features of JPA like entity inheritance, lazy loading, and eager fetching.<\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"
                                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 time and write cleaner code. […]<\/p>\n","protected":false},"author":1,"featured_media":3588,"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":[69,319],"series":[397],"class_list":["post-3502","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-spring_databases","tag-java-2","tag-spring","series-spring"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/binary-2904980_1280.jpg?fit=1280%2C719&ssl=1","jetpack-related-posts":[{"id":3925,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/spring-data-jpa-java-records-the-ultimate-duo-for-clean-fast-query-projections\/","url_meta":{"origin":3502,"position":0},"title":"Spring Data JPA & Java Records: The Ultimate Duo for Clean, Fast Query Projections","author":"Jeffery Miller","date":"April 20, 2026","format":false,"excerpt":"Architecting Efficient Data Access with Immutability As Spring developers, we spend a significant amount of time optimizing the path between the database and the client. One of the most common performance pitfalls is the over-fetching of data\u2014loading entire, complex JPA entities when all we need is a small subset of\u2026","rel":"","context":"In "Spring Databases"","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\/11\/record-shop-9180482_1280.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/11\/record-shop-9180482_1280.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/11\/record-shop-9180482_1280.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/11\/record-shop-9180482_1280.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/11\/record-shop-9180482_1280.avif 3x"},"classes":[]},{"id":3539,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/spring-data-cassandra-simplifying-java-development-with-apache-cassandra\/","url_meta":{"origin":3502,"position":1},"title":"Spring Data Cassandra: Simplifying Java Development with Apache Cassandra","author":"Jeffery Miller","date":"April 20, 2026","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 "Spring Databases"","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":3471,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/spring-jpa-auditing\/","url_meta":{"origin":3502,"position":2},"title":"Spring JPA Auditing","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Simplifying Entity Auditing with Spring Data JPA Annotations Keeping track of who created and modified your entities is crucial for various purposes, including audit trails, security, and data lineage. Spring Data JPA offers a convenient and efficient way to achieve this through dedicated annotations: @CreatedBy, @LastModifiedBy, @CreatedDate, and @LastModifiedDate. Leveraging\u2026","rel":"","context":"In "Spring Databases"","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\/02\/audit-4190944_640.jpg?fit=640%2C377&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/02\/audit-4190944_640.jpg?fit=640%2C377&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/02\/audit-4190944_640.jpg?fit=640%2C377&ssl=1&resize=525%2C300 1.5x"},"classes":[]},{"id":3530,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/spring-jpa-auditing-track-data-changes\/","url_meta":{"origin":3502,"position":3},"title":"Spring JPA Auditing: Track Data Changes","author":"Jeffery Miller","date":"April 20, 2026","format":false,"excerpt":"In the dynamic world of software development, understanding the complete history of your data is crucial. Who made a change? When did it occur? Who viewed the data? Spring JPA Auditing, combined with custom solutions, offers a comprehensive way to answer these questions, acting as a time machine for your\u2026","rel":"","context":"In "Spring Databases"","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\/image.png?fit=1200%2C686&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/image.png?fit=1200%2C686&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/image.png?fit=1200%2C686&ssl=1&resize=525%2C300 1.5x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/image.png?fit=1200%2C686&ssl=1&resize=700%2C400 2x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/06\/image.png?fit=1200%2C686&ssl=1&resize=1050%2C600 3x"},"classes":[]},{"id":3704,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_databases\/mastering-location-data-with-spring-jpa-a-comprehensive-guide\/","url_meta":{"origin":3502,"position":4},"title":"Mastering Location Data with Spring JPA: A Comprehensive Guide","author":"Jeffery Miller","date":"April 20, 2026","format":false,"excerpt":"In today\u2019s interconnected world, location data plays a pivotal role in numerous applications, from e-commerce and logistics to travel and social networking. Efficiently managing and accessing this wealth of geographical information is crucial for developers. This article delves into the realm of location data management using Spring JPA (Java Persistence\u2026","rel":"","context":"In "Spring Databases"","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\/09\/international-1751293_1280.png?fit=1186%2C1200&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/international-1751293_1280.png?fit=1186%2C1200&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/international-1751293_1280.png?fit=1186%2C1200&ssl=1&resize=525%2C300 1.5x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/international-1751293_1280.png?fit=1186%2C1200&ssl=1&resize=700%2C400 2x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/international-1751293_1280.png?fit=1186%2C1200&ssl=1&resize=1050%2C600 3x"},"classes":[]},{"id":3692,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_aop\/tracking-method-access-in-spring-aop-security-and-jpa\/","url_meta":{"origin":3502,"position":5},"title":"Tracking Method Access in Spring: AOP, Security, and JPA","author":"Jeffery Miller","date":"April 20, 2026","format":false,"excerpt":"In the world of Spring applications, understanding how your methods are accessed can be crucial for various reasons like monitoring usage patterns, auditing security, or simply gathering insights into your application\u2019s behavior. Let\u2019s explore a powerful approach to track method access using Spring AOP (Aspect-Oriented Programming), Spring Security, and Spring\u2026","rel":"","context":"In "Spring AOP"","block_context":{"text":"Spring AOP","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_aop\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/money-3523131_1280-jpg.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/money-3523131_1280-jpg.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/money-3523131_1280-jpg.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/money-3523131_1280-jpg.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/money-3523131_1280-jpg.avif 3x"},"classes":[]}],"jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3502","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=3502"}],"version-history":[{"count":1,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3502\/revisions"}],"predecessor-version":[{"id":3503,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3502\/revisions\/3503"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media\/3588"}],"wp:attachment":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media?parent=3502"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/categories?post=3502"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/tags?post=3502"},{"taxonomy":"series","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/series?post=3502"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}