能否通过Hibernate OGM实现同一数据模型映射Neo4j与Infinispan？

Absolutely! You can absolutely use a single POJO data model with Hibernate OGM to map to both Neo4j and Infinispan, and this setup aligns perfectly with your goal of offloading redundant Neo4j queries to an in-memory data grid, running queries directly in memory, and getting notified of data changes. Let’s break down how to make this work:

The core value of Hibernate OGM is that it lets you use a single set of JPA-annotated POJOs to map to multiple datastores—no need to write separate models for Neo4j and Infinispan. Your entities will work with both, thanks to OGM handling the underlying storage differences.

For example, a simple User entity with relationships (which will map to Neo4j graph edges and Infinispan serialized associations) looks like this:

@Entity
@Cacheable // Optional: Explicitly mark for caching in Infinispan
public class User {
    @Id
    private String userId;
    private String fullName;
    @ManyToMany(fetch = FetchType.LAZY)
    private List<Role> assignedRoles;

    // Standard getters, setters, and constructors
}

You’ll set up two distinct persistence units (via persistence.xml or programmatic configuration) to connect to Neo4j and Infinispan respectively. Each unit uses the same POJOs but points to a different datastore provider.

Neo4j Persistence Unit Example #

<persistence-unit name="neo4j-primary">
    <provider>org.hibernate.ogm.jpa.HibernateOgmPersistence</provider>
    <class>com.yourcompany.model.User</class>
    <class>com.yourcompany.model.Role</class>
    <properties>
        <property name="hibernate.ogm.datastore.provider" value="neo4j"/>
        <property name="hibernate.ogm.neo4j.database_uri" value="bolt://localhost:7687"/>
        <property name="hibernate.ogm.neo4j.username" value="neo4j"/>
        <property name="hibernate.ogm.neo4j.password" value="your-neo4j-password"/>
    </properties>
</persistence-unit>

Infinispan Persistence Unit Example #

<persistence-unit name="infinispan-cache">
    <provider>org.hibernate.ogm.jpa.HibernateOgmPersistence</provider>
    <class>com.yourcompany.model.User</class>
    <class>com.yourcompany.model.Role</class>
    <properties>
        <property name="hibernate.ogm.datastore.provider" value="infinispan"/>
        <property name="hibernate.ogm.infinispan.configuration_resource_name" value="infinispan-config.xml"/>
        <!-- Optional: Tune caching behavior -->
        <property name="hibernate.cache.use_second_level_cache" value="true"/>
    </properties>
</persistence-unit>

This setup directly addresses your key needs:

• Reduce Neo4j Query Load: Configure your application to first query the Infinispan persistence unit. Only fall back to Neo4j when data isn’t in the cache (or is stale). You can use Hibernate’s caching annotations like @Cacheable and @Cache to control which entities are cached and how long they persist in memory.
• In-Memory Queries: Hibernate OGM translates JPA queries into Infinispan’s native query language, so you can run complex queries directly against the in-memory cache without hitting Neo4j.
• Data Change Notifications: Infinispan provides built-in cache event listeners. You can register a CacheListener to get notified when entities are created, updated, or deleted in the cache. For example:

  @Listener
  public class CacheUpdateListener {
      @CacheEntryCreated
      public void onEntryCreated(CacheEntryCreatedEvent<String, User> event) {
          // Handle new user added to cache
      }
  
      @CacheEntryModified
      public void onEntryModified(CacheEntryModifiedEvent<String, User> event) {
          // Handle user update in cache
      }
  }
  

  If you need to sync cache changes back to Neo4j, you can also configure Infinispan’s cache writers to propagate updates to the Neo4j datastore automatically.

• Data Consistency: When Neo4j data is updated outside the cache, you’ll need to invalidate or refresh the corresponding entries in Infinispan. You can use Neo4j’s transaction event listeners to trigger cache invalidations, or set up a periodic cache refresh for less critical data.
• Graph vs. Object Storage Differences: Neo4j maps associations to graph edges, while Infinispan stores serialized object relationships. Hibernate OGM handles this translation automatically, but you may want to adjust fetch strategies (like LAZY vs EAGER) based on which datastore you’re querying.
• Performance Tuning: Tweak Infinispan’s configuration (like entry expiration, cache size, or query indexes) to optimize for your most frequent queries.

内容的提问来源于stack exchange，提问作者rico