import javax.cache.integration.CacheWriter; //导入依赖的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.integration.CacheWriter; //导入依赖的package包/类
public WriteThruProviderMgr(String cacheName, CacheWriter writer, CacheRuntimeContext context, int timeout, long operationDelay, String providerName) throws ConfigurationException {
    _context = context;
    _cacheName = cacheName;
    _operationDelay = operationDelay;
    _myProvider = providerName;
    _dsWriter = new JCacheWriteThruProvider((CacheWriter<Object,Object>)writer);
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
ActionRunner(ActionContext<K,V> actionContext)
{
	// actionContext. It is currently taken directly from the Cache
        CacheWriter<K, V> writer = actionContext.cacheWriter();
        if (writer instanceof NopCacheWriter)
        {
            this.cacheWriter = null;
        }
        else
        {               
            this.cacheWriter = actionContext.cacheWriter();
        }
	this.listeners = actionContext.listeners();
	this.stats = actionContext.statisticsCalculator();		
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
public CacheWriterWrapper(CacheWriter<? super K, ? super V> cw, boolean isAsync)
	{
		@SuppressWarnings("unchecked")
		CacheWriter<K, V> cw2 = (CacheWriter<K, V>) cw;
		this.cacheWriter = cw2;
//		this.isAsync = isAsync;
	}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
/**
 * @param ldr Loader.
 * @param writer Writer.
 */
GridCacheLoaderWriterStore(@Nullable CacheLoader<K, V> ldr, @Nullable CacheWriter<K, V> writer) {
    assert ldr != null || writer != null;

    this.ldr = ldr;
    this.writer = writer;
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
/**
 * @param ldrFactory Loader factory.
 * @param writerFactory Writer factory.
 */
GridCacheLoaderWriterStoreFactory(@Nullable Factory<CacheLoader<K, V>> ldrFactory,
    @Nullable Factory<CacheWriter<K, V>> writerFactory) {
    this.ldrFactory = ldrFactory;
    this.writerFactory = writerFactory;

    assert ldrFactory != null || writerFactory != null;
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public CacheStore<K, V> create() {
    CacheLoader<K, V> ldr = ldrFactory == null ? null : ldrFactory.create();

    CacheWriter<K, V> writer = writerFactory == null ? null : writerFactory.create();

    return new GridCacheLoaderWriterStore<>(ldr, writer);
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public CacheConfiguration<K, V> setCacheWriterFactory(
    Factory<? extends CacheWriter<? super K, ? super V>> factory) {
    super.setCacheWriterFactory(factory);

    return this;
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
Eh107CacheLoaderWriter(CacheLoader<K, V> cacheLoader, boolean readThrough, CacheWriter<K, V> cacheWriter, boolean writeThrough) {
  this.cacheLoader = cacheLoader;
  this.readThrough = cacheLoader != null && readThrough;
  if (writeThrough) {
    this.cacheWriter = cacheWriter;
  } else {
    this.cacheWriter = null;
  }
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
private <K, V> Jsr107CacheLoaderWriter<K, V> initCacheLoaderWriter(CompleteConfiguration<K, V> config, MultiCacheException mce) {
  Factory<CacheLoader<K, V>> cacheLoaderFactory = config.getCacheLoaderFactory();
  @SuppressWarnings("unchecked")
  Factory<CacheWriter<K, V>> cacheWriterFactory = (Factory<CacheWriter<K, V>>) (Object) config.getCacheWriterFactory();

  if (config.isReadThrough() && cacheLoaderFactory == null) {
    throw new IllegalArgumentException("read-through enabled without a CacheLoader factory provided");
  }
  if (config.isWriteThrough() && cacheWriterFactory == null) {
    throw new IllegalArgumentException("write-through enabled without a CacheWriter factory provided");
  }

  CacheLoader<K, V> cacheLoader = cacheLoaderFactory == null ? null : cacheLoaderFactory.create();
  CacheWriter<K, V> cacheWriter;
  try {
    cacheWriter = cacheWriterFactory == null ? null : cacheWriterFactory.create();
  } catch (Throwable t) {
    if (t != mce) {
      mce.addThrowable(t);
    }
    CacheResources.close(cacheLoader, mce);
    throw mce;
  }

  if (cacheLoader == null && cacheWriter == null) {
    return null;
  } else {
    return new Eh107CacheLoaderWriter<>(cacheLoader, config.isReadThrough(), cacheWriter, config.isWriteThrough());
  }
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
@Test
public void jsr107WriterGetsRegistered() {
  MutableConfiguration<Object, Object> configuration = new MutableConfiguration<>();
  CacheWriter<Object, Object> mock = mock(CacheWriter.class);
  RecordingFactory<CacheWriter<Object, Object>> factory = factoryOf(mock);
  configuration.setWriteThrough(true).setCacheWriterFactory(factory);

  merger.mergeConfigurations("cache", configuration);

  assertThat(factory.called, is(true));
  verify(cacheLoaderWriterFactory).registerJsr107Loader(eq("cache"), ArgumentMatchers.<CacheLoaderWriter<Object, Object>>isNotNull());
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
private MutableConfiguration<Long, String> getConfiguration(final boolean readThrough, final CacheLoader<Long, String> cacheLoader,
                                                            final boolean writeThrough, final CacheWriter<Long, String> cacheWriter) {
  MutableConfiguration<Long, String> config = new MutableConfiguration<>();
  config.setTypes(Long.class, String.class);
  config.setReadThrough(readThrough);
  config.setCacheLoaderFactory(() -> cacheLoader);
  config.setWriteThrough(writeThrough);
  config.setCacheWriterFactory(() -> cacheWriter);
  return config;
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
/**
 * Constructs an CacheWriterServer.
 *
 * @param port        the port on which to accept {@link CacheWriterClient} requests
 * @param cacheWriter (optional) the {@link CacheWriter} that will be used to handle
 *                    client requests
 */
public CacheWriterServer(int port, CacheWriter<K, V> cacheWriter) {
    super(port);

    // establish the client-server operation handlers
    addOperationHandler(new WriteOperationHandler());
    addOperationHandler(new WriteAllOperationHandler());
    addOperationHandler(new DeleteOperationHandler());
    addOperationHandler(new DeleteAllOperationHandler());

    this.cacheWriter = cacheWriter;
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
@Override
public Factory<CacheWriter<? super K, ? super V>> getCacheWriterFactory() {
    return delegate.getCacheWriterFactory();
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
/**
 * The {@link CacheWriter} factory
 */
public Factory<CacheWriter> getCacheWriterFactory() {
    return cacheWriterFactory;
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
public void setCacheWriterFactory(Factory<CacheWriter> cacheWriterFactory) {
    this.cacheWriterFactory = cacheWriterFactory;
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
public static Factory<CacheWriter<Object, Object>> factory() {
    return new FactoryBuilder.SingletonFactory(new MyCacheWriter());
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
public JCacheWriteThruProvider(CacheWriter<K,V> jcacheWriter){
    _jcacheWriter = jcacheWriter;
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
public final Factory<CacheWriter> getCacheWriterFactory()
{
    return cacheWriterFactory;
}
 

import javax.cache.integration.CacheWriter; //导入依赖的package包/类
public final void setCacheWriterFactory(Factory<CacheWriter> cacheWriterFactory)
{
    this.cacheWriterFactory = cacheWriterFactory;
}