Ignite 持久性和分裂大脑场景

1.ignite如何处理集群模式下的大脑分裂场景

2.在putAll的情况下，它是否会为每个条目命中持久存储区，或者所有内容都会立即放入存储区

3.如果我们设置了批量大小，那么putAll对于持久存储是如何工作的

4.如果使用备份进行分区，数据移动的顺序是什么？主->备份->持久化或主->同步备份到持久化

5.如果更新是在持久性存储中完成的，那么必须做什么才能在不重新加载的情况下将其反映到缓存中？（如何处理后端更新）

6.在后端执行更新并在缓存中反映更改时，如果使用loadCache重新加载缓存，则不会在缓存中更新更改，或者如果直接使用get（）也不会反映更新。只有在清除缓存一次，然后调用loadcache或get api之后，才会反映更新。这是重新加载缓存的正确方法吗

 Person p1 = new Person(1, "Benakaraj", "KS", 11, 26, 1000);
    Person p2 = new Person(2, "Ashwin", "Konale", 13, 26, 10000);
    Connection con = null;
    Statement stmt = null;

    con = ds.getConnection();
    stmt = con.createStatement();
    String sql =
        "create table Person(per_id int,name varchar(20),last_name varchar(20),org_id int,age int,salary REAL,primary key(per_id))";
    stmt.executeUpdate(sql);

    ROCCacheConfiguration<Integer, Person> pesonConfig = new ROCCacheConfiguration<>();
    pesonConfig.setName("bkendupdtCache");
    pesonConfig.setCacheMode(CacheMode.PARTITIONED);
    JdbcType jdbcType = new JdbcType();

    jdbcType.setCacheName("bkendupdtCache");
    jdbcType.setDatabaseSchema("ROC4Test");
    jdbcType.setDatabaseTable("Person");
    jdbcType.setKeyType(Integer.class);
    jdbcType.setValueType(Person.class);
    // Key fields for PERSON.

    Collection<JdbcTypeField> keys = new ArrayList<>();
    keys.add(new JdbcTypeField(Types.INTEGER, "per_id", int.class, "perId"));
    jdbcType.setKeyFields(keys.toArray(new JdbcTypeField[keys.size()]));

    // Value fields for PERSON.
    Collection<JdbcTypeField> vals = new ArrayList<>();
    vals.add(new JdbcTypeField(Types.INTEGER, "per_id", int.class, "perId"));
    vals.add(new JdbcTypeField(Types.VARCHAR, "name", String.class, "name"));
    vals.add(new JdbcTypeField(Types.VARCHAR, "last_name", String.class, "lastName"));
    vals.add(new JdbcTypeField(Types.INTEGER, "org_id", int.class, "orgId"));
    vals.add(new JdbcTypeField(Types.INTEGER, "age", int.class, "age"));
    vals.add(new JdbcTypeField(Types.FLOAT, "salary", Float.class, "salary"));
    jdbcType.setValueFields(vals.toArray(new JdbcTypeField[vals.size()]));

    Collection<JdbcType> jdbcTypes = new ArrayList<>();

    jdbcTypes.add(jdbcType);

    CacheJdbcPojoStoreFactory<Integer, Organization> cacheJdbcdPojoStorefactory4 =
        context.getBean(CacheJdbcPojoStoreFactory.class);
    cacheJdbcdPojoStorefactory4.setTypes(jdbcTypes.toArray(new JdbcType[jdbcTypes.size()]));

    pesonConfig.setCacheStoreFactory((Factory<? extends CacheStore<Integer, Person>>) cacheJdbcdPojoStorefactory4);
    pesonConfig.setReadThrough(true);
    pesonConfig.setWriteThrough(true);
    ROCCache<Integer, Person> personCache2 = rocCachemanager.createCache(pesonConfig);
    personCache2.put(1, p1);
    personCache2.put(2, p2);
    assertEquals(personCache2.get(2).getName(), "Ashwin");
    sql = assertEquals(personCache2.get(2).getName(), "Abhi");

"update Person set name='Abhi' where per_id=2";
        stmt.execute(sql);

        //fails and asks for assertion with the stale value
        personCache.loadcache(null);
        assertEquals(personCache2.get(2).getName(), "Abhi");

        //works fine
        personCache2.clear(2);
        assertEquals(personCache2.get(2).getName(), "Abhi");

        //works fine
        personCache2.clear();
        personCache2.loadcache(null);
        assertEquals(personCache2.get(2).getName(), "Abhi");

        sql = "drop table Person";
        stmt.executeUpdate(sql);
        con.close();
        stmt.close();
        rocCachemanager.destroyCache("bkendupdtCache");

Person p1=新人（1，“Benakaraj”，“KS”，11,26,1000）；
人员p2=新人员（2，“Ashwin”，“Konale”，13,26,10000）；
连接con=null；
语句stmt=null；
con=ds.getConnection（）；
stmt=con.createStatement（）；
字符串sql=
“创建表Person（peru_id int，name varchar（20），last_name varchar（20），org_id int，age int，salary REAL，primary key（peru id））”；
stmt.executeUpdate（sql）；
ROCCacheConfiguration pesonConfig=新的ROCCacheConfiguration（）；
pesonConfig.setName（“bkendupdtCache”）；
pesonConfig.setCacheMode（CacheMode.PARTITIONED）；
JdbcType JdbcType=新JdbcType（）；
setCacheName（“bkendupdtCache”）；
setDatabaseSchema（“ROC4Test”）；
jdbcType.setDatabaseTable（“Person”）；
setKeyType（Integer.class）；
setValueType（Person.class）；
//个人的关键字段。
集合键=新的ArrayList（）；
添加（新的JdbcTypeField（Types.INTEGER，“per_id”，int.class，“perId”）；
setKeyFields（keys.toArray（新的JdbcTypeField[keys.size（）]）；
//个人的值字段。
集合VAL=新的ArrayList（）；
add（新的JdbcTypeField（Types.INTEGER，“per_id”，int.class，“perId”）；
add（新的JdbcTypeField（Types.VARCHAR，“name”，String.class，“name”）；
add（新的JdbcTypeField（Types.VARCHAR，“last_name”，String.class，“lastName”）；
add（新的JdbcTypeField（Types.INTEGER，“org_id”，int.class，“orgId”）；
add（新的JdbcTypeField（Types.INTEGER，“age”，int.class，“age”）；
添加（新的JdbcTypeField（Types.FLOAT，“salary”，FLOAT.class，“salary”）；
setValueFields（vals.toArray（新的JdbcTypeField[vals.size（）]）；
集合jdbcTypes=newarraylist（）；
添加（jdbcType）；
CacheJdbcPojoStoreFactory CacheJDBCDPOjoToRefactory4=
getBean（CacheJdbcPojoStoreFactory.class）；
cachejdbcdpojostrefactory4.setTypes（jdbcTypes.toArray（新的JdbcType[jdbcTypes.size（）]）；
pesonConfig.setCacheStoreFactory（（工厂
默认情况下，您将得到两个相互独立的集群，它们将永远不再相互连接（否则数据可能不一致）。您必须手动停止其中一个群集，并在网络恢复后重新启动。但是，自动解析可以作为插件实现。例如，GridGain提供了这种开箱即用的功能：

Ignites尝试尽可能减少持久性存储调用。如果您的存储支持批读和批写，那么在实现
loadAll
、
writeAll
和
removeAll
方法时，最好利用这一点

批处理更新操作将根据节点映射拆分批处理。批处理的每个部分将立即在相应的主节点上持久化

存储与主节点一起自动更新（如果写入存储失败，则缓存不更新，反之亦然）。默认情况下，备份在后台异步更新

如果可能，您应该避免这种情况，并将Ignite视为一个主数据存储，在后端有一个可选存储（即始终通过Ignite API访问数据）。没有简单的方法将数据库更新传播到Ignite

您可以使用
clear/clearAll
方法使条目无效，或使用
loadAll
方法重新加载条目。另一个选项是使用过期：

批量大小指的是，即使存储异步更新，在回写期间一次缓存中的条目数？备份是否仍会异步更新？对，回写存储是异步更新的。是否同步更新备份由
CacheConfiguration.writeSynchronizationMo定义de
属性。默认值为
PRIMARY\u SYNC
，其中仅同步更新主节点。在
FULL\u SYNC
模式下，客户端将等待所有节点。多个缓存会发生什么情况？基本上有三种情况：1）缓存在多个段中更新，但不会更新到同一个键2）缓存在多个段中更新，但同一密钥在两侧更新（冲突）3）缓存仅在一个段中更新这三种情况的处理方式会有所不同吗？“independent”clusters语句是否仅适用于场景2中的缓存，还是同样适用于1和/或3？