Java Factory类代码示例

import javax.cache.configuration.Factory; //导入依赖的package包/类
public JCache(JCacheManager cacheManager, Redisson redisson, String name, JCacheConfiguration<K, V> config, boolean hasOwnRedisson) {
    super(redisson.getConfig().getCodec(), redisson.getCommandExecutor(), name);
    
    this.hasOwnRedisson = hasOwnRedisson;
    this.redisson = redisson;
    
    Factory<CacheLoader<K, V>> cacheLoaderFactory = config.getCacheLoaderFactory();
    if (cacheLoaderFactory != null) {
        cacheLoader = cacheLoaderFactory.create();
    }
    Factory<CacheWriter<? super K, ? super V>> cacheWriterFactory = config.getCacheWriterFactory();
    if (config.getCacheWriterFactory() != null) {
        cacheWriter = (CacheWriter<K, V>) cacheWriterFactory.create();
    }
    
    this.cacheManager = cacheManager;
    this.config = config;
    
    redisson.getEvictionScheduler().scheduleJCache(getName(), getTimeoutSetName(), getExpiredChannelName());
    
    for (CacheEntryListenerConfiguration<K, V> listenerConfig : config.getCacheEntryListenerConfigurations()) {
        registerCacheEntryListener(listenerConfig, false);
    }
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testCall() throws Exception {
    runTest(callableFactories, new ComputeTest() {
        @Override public void test(Factory factory, Ignite ignite) throws Exception {
            Collection<Object> results = new ArrayList<>(MAX_JOB_COUNT);

            for (int i = 0; i < MAX_JOB_COUNT; ++i) {
                EchoCallable job = (EchoCallable)factory.create();
                job.setArg(value(i - 1));
                results.add(ignite.compute().call(job));
            }

            checkResultsClassCount(MAX_JOB_COUNT - 1, results, value(0).getClass());
            assertCollectionsEquals("Results value mismatch", createGoldenResults(), results);
        }
    });
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
@Override
public void deregisterCacheEntryListener(CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) {
    verifyCacheConnectivity();
    final Factory<CacheEntryListener<? super K,? super V>> factory = cacheEntryListenerConfiguration.getCacheEntryListenerFactory();
    final CacheEntryListener cacheEntryListener = factory.create();
    final CacheEventListener<K,V> cacheEventListener = new CacheEventListener<K, V>(cacheEntryListener, this, cacheEntryListenerConfiguration);
    try {
    if(cacheEventListener.isOnCreatedListenerConfigured() && addEventDescriptor != null) 
        innerCache.removeCacheDataModificationListener(addEventDescriptor);
    if(cacheEventListener.isOnUpdatedListenerConfigured() && updateEventDescriptor != null)
        innerCache.removeCacheDataModificationListener(updateEventDescriptor);
    if(cacheEventListener.isOnRemovedListenerConfigured() && deleteEventDescriptor != null) {
        if(!isExpiryEventConfigured)
            innerCache.removeCacheDataModificationListener(deleteEventDescriptor);
    }
    if(cacheEventListener.isOnExpiredListenerConfigured() && deleteEventDescriptor != null) {
        isExpiryEventConfigured = false;
        innerCache.removeCacheDataModificationListener(deleteEventDescriptor);
    }
    }
    catch (Exception e) {
        
    }
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testMultiCacheByPartIdAffinityRun() throws Exception {
    runTest(runnableFactories, new ComputeTest() {
        @Override public void test(Factory factory, Ignite ignite) throws Exception {
            ignite.getOrCreateCache("test0");
            ignite.getOrCreateCache("test1");

            final IgniteCompute comp = ignite.compute();

            for (int i = 0; i < MAX_JOB_COUNT; ++i) {
                IgniteRunnable job = (IgniteRunnable)factory.create();

                comp.affinityRun(Arrays.asList("test0", "test1"), 0, job);
            }
        }
    });
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testAffinityRunAsync() throws Exception {
    runTest(runnableFactories, new ComputeTest() {
        @Override public void test(Factory factory, Ignite ignite) throws Exception {
            ignite.getOrCreateCache(CACHE_NAME);

            final IgniteCompute comp = ignite.compute();

            for (int i = 0; i < MAX_JOB_COUNT; ++i) {
                IgniteRunnable job = (IgniteRunnable)factory.create();

                IgniteFuture<Void> fut = comp.affinityRunAsync("test", key(0), job);

                fut.get();
            }
        }
    });
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testMultiCacheAffinityRunAsync() throws Exception {
    runTest(runnableFactories, new ComputeTest() {
        @Override public void test(Factory factory, Ignite ignite) throws Exception {
            ignite.getOrCreateCache("test0");
            ignite.getOrCreateCache("test1");

            final IgniteCompute comp = ignite.compute();

            for (int i = 0; i < MAX_JOB_COUNT; ++i) {
                IgniteRunnable job = (IgniteRunnable)factory.create();

                IgniteFuture<Void> fut = comp.affinityRunAsync(Arrays.asList("test0", "test1"), key(0), job);

                fut.get();
            }
        }
    });
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @param atomicityMode Atomicity mode.
 * @return Cache configuration.
 */
@SuppressWarnings({"rawtypes", "unchecked"})
private CacheConfiguration<String, List<Double>> createCacheConfiguration(CacheAtomicityMode atomicityMode) {
    CacheConfiguration<String, List<Double>> cc = new CacheConfiguration<>(DEFAULT_CACHE_NAME);

    cc.setCacheMode(PARTITIONED);
    cc.setAtomicityMode(atomicityMode);
    cc.setWriteSynchronizationMode(FULL_SYNC);

    cc.setReadThrough(true);
    cc.setWriteThrough(true);

    Factory cacheStoreFactory = new FactoryBuilder.SingletonFactory(new DummyCacheStore());

    cc.setCacheStoreFactory(cacheStoreFactory);

    cc.setBackups(2);

    return cc;
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testMultiCacheByPartIdAffinityRunAsync() throws Exception {
    runTest(runnableFactories, new ComputeTest() {
        @Override public void test(Factory factory, Ignite ignite) throws Exception {
            ignite.getOrCreateCache("test0");
            ignite.getOrCreateCache("test1");

            final IgniteCompute comp = ignite.compute();

            for (int i = 0; i < MAX_JOB_COUNT; ++i) {
                IgniteRunnable job = (IgniteRunnable)factory.create();

                IgniteFuture<Void> fut = comp.affinityRunAsync(Arrays.asList("test0", "test1"), 0, job);

                fut.get();
            }
        }
    });
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * Writes the policy factory.
 *
 * @param out Writer.
 */
private static void writeExpiryPolicyFactory(BinaryRawWriter out, Factory<? extends ExpiryPolicy> factory) {
    if (!(factory instanceof PlatformExpiryPolicyFactory)) {
        out.writeBoolean(false);

        return;
    }

    out.writeBoolean(true);

    PlatformExpiryPolicyFactory f = (PlatformExpiryPolicyFactory)factory;

    out.writeLong(f.getCreate());
    out.writeLong(f.getUpdate());
    out.writeLong(f.getAccess());
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testAffinityCallAsync() throws Exception {
    runTest(callableFactories, new ComputeTest() {
        @Override public void test(Factory factory, Ignite ignite) throws Exception {
            ignite.getOrCreateCache(CACHE_NAME);

            final IgniteCompute comp = ignite.compute();

            Collection<Object> results = new ArrayList<>(MAX_JOB_COUNT);

            for (int i = 0; i < MAX_JOB_COUNT; ++i) {
                EchoCallable job = (EchoCallable)factory.create();

                job.setArg(value(i - 1));

                IgniteFuture<Object> fut = comp.affinityCallAsync("test", key(0), job);

                results.add(fut.get());
            }

            checkResultsClassCount(MAX_JOB_COUNT - 1, results, value(0).getClass());
            assertCollectionsEquals("Results value mismatch", createGoldenResults(), results);
        }
    });
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testMultiCacheByPartIdAffinityCallAsync() throws Exception {
    runTest(callableFactories, new ComputeTest() {
        @Override public void test(Factory factory, Ignite ignite) throws Exception {
            ignite.getOrCreateCache("test0");
            ignite.getOrCreateCache("test1");

            final IgniteCompute comp = ignite.compute();

            Collection<Object> results = new ArrayList<>(MAX_JOB_COUNT);

            for (int i = 0; i < MAX_JOB_COUNT; ++i) {
                EchoCallable job = (EchoCallable)factory.create();

                job.setArg(value(i - 1));

                IgniteFuture fut = comp.affinityCallAsync(Arrays.asList("test0", "test1"), 0, job);

                results.add(fut.get());
            }

            checkResultsClassCount(MAX_JOB_COUNT - 1, results, value(0).getClass());
            assertCollectionsEquals("Results value mismatch", createGoldenResults(), results);
        }
    });
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @param cacheName Cache name.
 * @param factory Factory to use.
 * @return Cache configuration.
 */
private CacheConfiguration cacheConfiguration(String cacheName, Factory<CacheStore> factory) {
    CacheConfiguration cfg = defaultCacheConfiguration();

    cfg.setNearConfiguration(null);
    cfg.setName(cacheName);

    cfg.setBackups(1);

    if (factory != null) {
        cfg.setCacheStoreFactory(factory);

        cfg.setWriteThrough(true);
    }

    return cfg;
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testMultiCacheAffinityCall() throws Exception {
    runTest(callableFactories, new ComputeTest() {
        @Override public void test(Factory factory, Ignite ignite) throws Exception {
            ignite.getOrCreateCache("test0");
            ignite.getOrCreateCache("test1");

            final IgniteCompute comp = ignite.compute();

            Collection<Object> results = new ArrayList<>(MAX_JOB_COUNT);

            for (int i = 0; i < MAX_JOB_COUNT; ++i) {
                EchoCallable job = (EchoCallable)factory.create();

                job.setArg(value(i - 1));

                results.add(comp.affinityCall(Arrays.asList("test0", "test1"), key(0), job));
            }

            checkResultsClassCount(MAX_JOB_COUNT - 1, results, value(0).getClass());
            assertCollectionsEquals("Results value mismatch", createGoldenResults(), results);
        }
    });
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testCallCollection() throws Exception {
    runTest(callableFactories, new ComputeTest() {
        @Override public void test(Factory factory, Ignite ignite) throws Exception {
            Collection<EchoCallable> jobs = new ArrayList<>(MAX_JOB_COUNT);

            for (int i = 0; i < MAX_JOB_COUNT; ++i) {
                EchoCallable job = (EchoCallable)factory.create();
                job.setArg(value(i - 1));
                jobs.add(job);
            }

            Collection<Object> results = ignite.compute().call(jobs);

            checkResultsClassCount(MAX_JOB_COUNT - 1, results, value(0).getClass());
            assertCollectionsEquals("Results value mismatch", createGoldenResults(), results);
        }
    });
}
 

import javax.cache.configuration.Factory; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testExecuteTaskClassAsync() throws Exception {
    runTest(jobFactories, new ComputeTest() {
        @Override public void test(Factory factory, Ignite ignite) throws Exception {
            // Begin with negative to check 'null' value in the test.
            final int[] i = {-1};

            ComputeTaskFuture<List<Object>> fut = ignite.compute().executeAsync(
                TestTask.class,
                new T2<>((Factory<ComputeJobAdapter>)factory,
                    (Factory<Object>)new Factory<Object>() {
                        @Override public Object create() {
                            return value(i[0]++);
                        }
                    }));

            checkResultsClassCount(MAX_JOB_COUNT - 1, fut.get(), value(0).getClass());
            assertCollectionsEquals("Results value mismatch", createGoldenResults(), fut.get());
        }
    });
}