java - Wildfly 9 AS中Infinispan缓存的实现(考虑集群)

Question

情况:

我有一个包含数千条记录的清算表。它们被分成例如以下的包: 500 条记录。然后每个数据包通过消息驱动 Bean 发送到 AS。 AS根据每条记录的内容(如货币、validStart、validEnd)计算出一个key，并需要将这个key与内容的组合一起存储在数据库中。

请求:

为了避免重复，我需要一个集中的“工具”来计算 key 并存储它们，从而通过将这些 key 与记录一起缓存来减少与数据库的通信。

现在我尝试对每个包处理线程使用在实用程序类实现中访问的本地 Infinispan 缓存。这导致多个包计算出相同的 key ，从而将重复项插入到数据库中。或者有时我会陷入僵局。

我尝试通过静态变量实现“锁”，以在数据库插入期间阻止对缓存的访问，但没有成功。下一次尝试是使用复制的、分布式的 Infinispan 缓存。这并没有改变 AS 行为的结果。

我的最后一个想法是实现为 bean 管理的单例 session bean，以便在插入数据库期间获取事务锁。

AS目前以独立模式运行，但不久的将来将迁移到集群，因此首选高可用性解决方案。

恢复:

在创建(键、值)对期间锁定 Infinispan 缓存访问以避免重复的正确方法是什么？

更新:

@cruftex:我的请求是:我有一组(键，值)对，应将其缓存。如果要插入新记录，则会对其应用算法并计算 key 。然后应检查缓存是否已存在该键，并将该值附加到新记录中。但如果该值不存在，则应创建该值并将其存储在数据库中。

由于AS要运行在集群中，因此需要使用Infinispan来实现缓存。存在用于创建 key 的算法。也将值插入数据库(通过 JDBC 或实体)。但我有一个问题，即使用消息驱动 Bean(以及 AS 中的多线程)在不同的线程中计算相同的(键、值)对，因此每个线程都尝试将值插入数据库中(我想避免!)。

@戴夫:

public class Cache {
     private static final Logger log = Logger.getLogger(Cache.class);
     private final Cache<Key, FullValueViewer> fullCache;
     private HomeCache homes;        // wraps EntityManager
     private final Session session;

     public Cache(Session session, EmbeddedCacheManager cacheContainer, HomeCache homes) {
         this.session = session;
         this.homes = homes;
         fullCache = cacheContainer.getCache(Const.CACHE_CONDCOMBI);
     } 

     public Long getId(FullValueViewer viewerWithoutId) {
         Long result = null;

         final Key key = new Key(viewerWithoutId);
         FullValueViewer view = fullCache.get(key);

         if(view == null) {
             view = checkDatabase(viewerWithoutId);
             if(view != null) {
                 fullCache.put(key, view);
             }
         }

         if(view == null) {
             view = createValue(viewerWithoutId);

             // 1. Try
             fullCache.put(key, view);

             // 2. Try
             //      if(!fullCache.containsKey(key)) {
             //           fullCache.put(key, view);
             //       } else {
             //           try {
             //               homes.condCombi().remove(view.idnr);
             //           } catch (Exception e) {
             //               log.error("remove", e);
             //           }
             //       }

             // 3. Try
             //       synchronized(fullCache) {
             //           view = createValue(viewerWithoutId);
             //           fullCache.put(key, view);
             //       }
         }
         result = view.idnr;
         return result;
     }

     private FullValueViewer checkDatabase(FullValueViewer newView) {
         FullValueViewer result = null;
         try {
             CondCombiBean bean = homes.condCombi().findByTypeAndKeys(_parameters_);
             result = bean.getAsView();
         } catch (FinderException e) {
         }
         return result;
     }

     private FullValueViewer createValue(FullValueViewer newView) {
         FullValueViewer result = null;
         try {
             CondCombiBean bean = homes.condCombi().create(session.subpk);
             bean.setFromView(newView);
             result = bean.getAsView();
         } catch (Exception e) {
             log.error("createValue", e);
         }
         return result;
     }

     private class Key {

         private final FullValueViewer view;

         public Key(FullValueViewer v) {
            this.view = v;
         }

         @Override
         public int hashCode() {
             _omitted_
         }

         @Override
         public boolean equals(Object obj) {
             _omitted_
         }
     }
 }

我在 Wildfly 上尝试的缓存配置:

<cache-container name="server" default-cache="default" module="org.wildfly.clustering.server">
   <local-cache name="default">
      <transaction mode="BATCH"/>
   </local-cache>
</cache-container>

<cache-container name="server" default-cache="default" module="org.wildfly.clustering.server">
   <transport lock-timeout="60000"/>
   <distributed-cache name="default" mode="ASYNC"/>
</cache-container>

Answer 1

我只会对简历问题使用react:

你不能锁定整个缓存；那无法扩展。最好的方法是使用 cache.putIfAbsent(key, value) 操作，如果条目已经存在，则生成不同的键(或者使用列表作为值并使用条件 cache.replace(key, oldValue, newValue) 替换它)。

如果您想真正禁止写入某个键，您可以使用带有悲观锁定策略的事务缓存，并发出cache.getAdvancedCache().lock(key)。请注意，没有解锁:当通过事务管理器提交/回滚事务时，所有锁都会被释放。