Apache-Ignite-2.0.0持久化

由 匿名 (未验证) 提交于 2019-12-03 00:39:02

16.持久化

16.1.持久化存储

16.1.1.ժҪ

JCache提供了javax.cache.integration.CacheLoader和javax.cache.integration.CacheWriterAPI，他们分别用于底层持久化存储的通读和ͨд
虽然Ignite可以单独地配置CacheRLoader和CacheWriter，但是在两个单独的类中实现事务化存储是非常尴尬的，因为多个load和put操作需要在同一个事务中的同一个连接中共享状态。为了缓解这个问题，Ignite提供了・org.apacche.ignite.cache.store.CacheStore・接口，他同时扩展了CacheLoader和CacheWriter。

事务
CacheStore
CacheJdbcPojoStore
Ignite附带了他自己的CacheJdbcPojoStore,他会自动地建立Java POJO和数据库模式之间的映射，可以参照3.13.自动持久化章节。

16.1.2.通读和通写


要配置通读和通写，需要实现CacheStore接口以及设置CacheConfiguration中cacheStoreFactory的readThrough和writeThrough属性，下面的例子会有说明。

16.1.3.后写缓存


对于这种情况，Ignite提供了一个选项来执行异步化的持久化存储更新，也叫做后写，这个方式的主要概念是累加更新操作然后作为一个批量操作异步化地刷入持久化存储中。真实的数据持久化可以被基于时间的事件触发（数据输入的最大时间受到队列的限制），也可以被队列的大小触发（当队列大小达到一个限值），或者通过两者的组合触发，这时任何事件都会触发刷新。

更新顺序

更新性能
批量的存储操作通常比按顺序的单一存储操作更有效率，因此可以通过开启后写模式的批量操作来利用这个特性。简单类型（put和remove）的简单顺序更新操作可以被组合成一个批量操作。比如，连续地往缓存中加入(key1,value1),(key2,value2),(key3,value3)可以通过一个单一的CacheStore.putAll(...)操作批量处理。

后写缓存可以通过CacheConfiguration.setWriteBehindEnabled(boolean)配置项来开启，下面的3.12.6.配置章节显示了一个完整的配置属性列表来进行后写缓存行为的定制。

16.1.4.CacheStore

Ignite中的CacheStore接口用于向底层的数据存储写入或者加载数据。除了标准的JCache加载和存储方法，他还引入了最终事务划界以及从底层数据存储批量载入数据的能力。

loadCache()
CacheStore.loadCache()
在每一个相关的集群节点，IgniteCache.loadCache()方法会分配给CacheStore.loadCache()方法，如果只想在本地节点上进行加载，可以用IgniteCache.localLoadCache()方法。

对于分区缓存，不管是主节点还是备份节点，如果键没有被映射到该节点，会被缓存自动丢弃。

load(), write(), delete()
当IgniteCache接口的get,put,remove方法被调用时，相对应的CacheStore的load(),write()和delete()方法会被调用，当与单个缓存数据工作时，这些方法会用于启用通读和ͨд行为。

loadAll(), writeAll(), deleteAll()
当IgniteCache接口的getAll,putAll,removeAll方法被调用时，相对应的CacheStore的loadAll(),writeAll()和deleteAll()方法会被调用，当与多个缓存数据工作时，这些方法会用于启用通读和ͨд行为，他们通常用批量操作的方式实现以提供更好的性能。

CacheStoreAdapter提供了loadAll(),writeAll()和deleteAll()方法的默认实现，他只是简单地对键进行一个一个地迭代。

sessionEnd()

对于原子化的缓存，sessionEnd()方法会在每个CacheStore方法完成之后被调用，对于事务化的缓存，不管是在底层持久化存储进行提交或者回滚多个操作，sessionEnd()方法都会在每个事务结束后被调用。

CacheStoreAdapater提供了sessionEnd()
Cassandra Cache Store
Ignite提供了将Apache Cassandra作为内存网格级CacheStore的开箱即用的集成，要了解更多的信息，可以查看相关的文档。

16.1.5.CacheStoreSession

缓存存储会话的主要目的是当CacheStore用于事务中时在多个存储操作中持有一个上下文。比如，如果使用JDBC，可以通过CacheStoreSession.attach()方法保存数据库的连接，然后可以在CacheStore.sessionEnd(boolean)
CacheStoreSession可以通过@GridCacheStoreSessionResource注解注入自定义的缓存存储实现中。

16.1.6.CacheStore示例


JDBC非事务：

  1. public class CacheJdbcPersonStore extends CacheStoreAdapter<Long, Person> {
  2.   // This mehtod is called whenever "get(...)" methods are called on IgniteCache.
  3.   @Override public Person load(Long key) {
  4.     try (Connection conn = connection()) {
  5.       try (PreparedStatement st = conn.prepareStatement("select * from PERSONS where id=?")) {
  6.         st.setLong(1, key);
  8.         ResultSet rs = st.executeQuery();
  10.         return rs.next() ? new Person(rs.getLong(1), rs.getString(2), rs.getString(3)) : null;
  11.       }
  12.     }
  13.     catch (SQLException e) {
  14.       throw new CacheLoaderException("Failed to load: " + key, e);
  15.     }
  16.   }
  18.   // This mehtod is called whenever "put(...)" methods are called on IgniteCache.
  19.   @Override public void write(Cache.Entry<Long, Person> entry) {
  20.     try (Connection conn = connection()) {
  21.       // Syntax of MERGE statement is database specific and should be adopted for your database.
  22.       // If your database does not support MERGE statement then use sequentially update, insert statements.
  23.       try (PreparedStatement st = conn.prepareStatement(
  24.         "merge into PERSONS (id, firstName, lastName) key (id) VALUES (?, ?, ?)")) {
  25.         for (Cache.Entry<Long, Person> entry : entries) {
  26.           Person val = entry.getValue();
  28.           st.setLong(1, entry.getKey());
  29.           st.setString(2, val.getFirstName());
  30.           st.setString(3, val.getLastName());
  32.           st.executeUpdate();
  33.         }
  34.       }
  35.     }
  36.     catch (SQLException e) {
  37.       throw new CacheWriterException("Failed to write [key=" + key + ", val=" + val + ']', e);
  38.     }
  39.   }
  41.   // This mehtod is called whenever "remove(...)" methods are called on IgniteCache.
  42.   @Override public void delete(Object key) {
  43.     try (Connection conn = connection()) {
  44.       try (PreparedStatement st = conn.prepareStatement("delete from PERSONS where id=?")) {
  45.         st.setLong(1, (Long)key);
  47.         st.executeUpdate();
  48.       }
  49.     }
  50.     catch (SQLException e) {
  51.       throw new CacheWriterException("Failed to delete: " + key, e);
  52.     }
  53.   }
  55.   // This mehtod is called whenever "loadCache()" and "localLoadCache()"
  56.   // methods are called on IgniteCache. It is used for bulk-loading the cache.
  57.   // If you don't need to bulk-load the cache, skip this method.
  58.   @Override public void loadCache(IgniteBiInClosure<Long, Person> clo, Object... args) {
  59.     if (args == null || args.length == 0 || args[0] == null)
  60.       throw new CacheLoaderException("Expected entry count parameter is not provided.");
  62.     final int entryCnt = (Integer)args[0];
  64.     try (Connection conn = connection()) {
  65.       try (PreparedStatement st = conn.prepareStatement("select * from PERSONS")) {
  66.         try (ResultSet rs = st.executeQuery()) {
  67.           int cnt = 0;
  69.           while (cnt < entryCnt && rs.next()) {
  70.             Person person = new Person(rs.getLong(1), rs.getString(2), rs.getString(3));
  72.             clo.apply(person.getId(), person);
  74.             cnt++;
  75.           }
  76.         }
  77.       }
  78.     }
  79.     catch (SQLException e) {
  80.       throw new CacheLoaderException("Failed to load values from cache store.", e);
  81.     }
  82.   }
  84.   // Open JDBC connection.
  85.   private Connection connection() throws SQLException  {
  86.     // Open connection to your RDBMS systems (Oracle, MySQL, Postgres, DB2, Microsoft SQL, etc.)
  87.     // In this example we use H2 Database for simplification.
  88.     Connection conn = DriverManager.getConnection("jdbc:h2:mem:example;DB_CLOSE_DELAY=-1");
  90.     conn.setAutoCommit(true);
  92.     return conn;
  93.   }
  94. }
JDBC事务：
  1. public class CacheJdbcPersonStore extends CacheStoreAdapter<Long, Person> {
  2.   /** Auto-injected store session. */
  3.   @CacheStoreSessionResource
  4.   private CacheStoreSession ses;
  6.   // Complete transaction or simply close connection if there is no transaction.
  7.   @Override public void sessionEnd(boolean commit) {
  8.     try (Connection conn = ses.getAttached()) {
  9.       if (conn != null && ses.isWithinTransaction()) {
  10.         if (commit)
  11.           conn.commit();
  12.         else
  13.           conn.rollback();
  14.       }
  15.     }
  16.     catch (SQLException e) {
  17.       throw new CacheWriterException("Failed to end store session.", e);
  18.     }
  19.   }
  21.   // This mehtod is called whenever "get(...)" methods are called on IgniteCache.
  22.   @Override public Person load(Long key) {
  23.     try (Connection conn = connection()) {
  24.       try (PreparedStatement st = conn.prepareStatement("select * from PERSONS where id=?")) {
  25.         st.setLong(1, key);
  27.         ResultSet rs = st.executeQuery();
  29.         return rs.next() ? new Person(rs.getLong(1), rs.getString(2), rs.getString(3)) : null;
  30.       }
  31.     }
  32.     catch (SQLException e) {
  33.       throw new CacheLoaderException("Failed to load: " + key, e);
  34.     }
  35.   }
  37.   // This mehtod is called whenever "put(...)" methods are called on IgniteCache.
  38.   @Override public void write(Cache.Entry<Long, Person> entry) {
  39.     try (Connection conn = connection()) {
  40.       // Syntax of MERGE statement is database specific and should be adopted for your database.
  41.       // If your database does not support MERGE statement then use sequentially update, insert statements.
  42.       try (PreparedStatement st = conn.prepareStatement(
  43.         "merge into PERSONS (id, firstName, lastName) key (id) VALUES (?, ?, ?)")) {
  44.         for (Cache.Entry<Long, Person> entry : entries) {
  45.           Person val = entry.getValue();
  47.           st.setLong(1, entry.getKey());
  48.           st.setString(2, val.getFirstName());
  49.           st.setString(3, val.getLastName());
  51.           st.executeUpdate();
  52.         }
  53.       }
  54.     }        
  55.     catch (SQLException e) {
  56.       throw new CacheWriterException("Failed to write [key=" + key + ", val=" + val + ']', e);
  57.     }
  58.   }
  60.   // This mehtod is called whenever "remove(...)" methods are called on IgniteCache.
  61.   @Override public void delete(Object key) {
  62.     try (Connection conn = connection()) {
  63.       try (PreparedStatement st = conn.prepareStatement("delete from PERSONS where id=?")) {
  64.         st.setLong(1, (Long
        

      
  

    
标签

          

              
数据持久化

          
try

          
delete

              

      


  







  
    

      
            
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!