Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2016-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.data.gemfire.cache;
import java.util.concurrent.Callable;
import org.apache.geode.cache.CacheLoader;
import org.apache.geode.cache.CacheLoaderException;
import org.apache.geode.cache.LoaderHelper;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.TimeoutException;
import org.springframework.util.Assert;
/**
* The {@link CallableCacheLoaderAdapter} class is a {@link Callable} and Pivotal GemFire {@link CacheLoader} implementation
* that adapts the {@link Callable} interface into an instance of the {@link CacheLoader} interface. This class is
* useful in situations where Pivotal GemFire developers have several {@link CacheLoader} implementations that they wish to
* use with Spring's Cache Abstraction.
*
* @author John Blum
* @see java.util.concurrent.Callable
* @see org.apache.geode.cache.CacheLoader
* @see org.apache.geode.cache.LoaderHelper
* @see org.apache.geode.cache.Region
* @since 1.9.0
*/
@SuppressWarnings("unused")
public class CallableCacheLoaderAdapter implements Callable, CacheLoader {
private final K key;
private final CacheLoader cacheLoader;
private final Object argument;
private final Region region;
/**
* Constructs an instance of the CallableCacheLoaderAdapter that delegates to the given {@link CacheLoader}.
*
* @param delegate the {@link CacheLoader} delegated to by this adapter.
* @see #CallableCacheLoaderAdapter(CacheLoader, Object, Region, Object)
* @see org.apache.geode.cache.CacheLoader
*/
public CallableCacheLoaderAdapter(CacheLoader delegate) {
this(delegate, null, null, null);
}
/**
* Constructs an instance of the CallableCacheLoaderAdapter that delegates to the given {@link CacheLoader}
* and is initialized with the given key for which the value will be loaded along with the {@link Region}
* in which the entry (key/value) belongs.
*
* @param delegate the {@link CacheLoader} delegated to by this adapter.
* @param key the key for which the value will be loaded.
* @param region the {@link Region} in which the entry (key/value) belongs.
* @see #CallableCacheLoaderAdapter(CacheLoader, Object, Region, Object)
* @see org.apache.geode.cache.CacheLoader
* @see org.apache.geode.cache.Region
*/
public CallableCacheLoaderAdapter(CacheLoader delegate, K key, Region region) {
this(delegate, key, region, null);
}
/**
* Constructs an instance of the CallableCacheLoaderAdapter that delegates to the given {@link CacheLoader}
* and is initialized with the given key for which the value will be loaded along with the {@link Region}
* in which the entry (key/value) belongs. Additionally, an argument may be specified for use with the
* {@link CacheLoader} delegate.
*
* @param delegate the {@link CacheLoader} delegated to by this adapter.
* @param key the key for which the value will be loaded.
* @param region the {@link Region} in which the entry (key/value) belongs.
* @param argument the Object argument used with the {@link CacheLoader} delegate.
* @see #CallableCacheLoaderAdapter(CacheLoader, Object, Region, Object)
* @see org.apache.geode.cache.CacheLoader
* @see org.apache.geode.cache.Region
*/
public CallableCacheLoaderAdapter(CacheLoader delegate, K key, Region region, Object argument) {
Assert.notNull(delegate, "CacheLoader must not be null");
this.cacheLoader = delegate;
this.argument = argument;
this.key = key;
this.region = region;
}
/**
* Gets the argument used by this {@link CacheLoader} to load the value for the specified key.
*
* @return an Object argument used by this {@link CacheLoader} when loading the value for the specified key.
*/
protected Object getArgument() {
return argument;
}
/**
* The {@link CacheLoader} delegate used to actually load the cache value for the specified key.
*
* @return a reference to the actual {@link CacheLoader} used when loading the cache value for the specified key.
* @see org.apache.geode.cache.CacheLoader
*/
protected CacheLoader getCacheLoader() {
return cacheLoader;
}
/**
* The specified key for which a value will be loaded by this {@link CacheLoader}.
*
* @return the specified key for which the value will be loaded.
*/
protected K getKey() {
return key;
}
/**
* Returns the Region to which the entry (key/value) belongs.
*
* @return the Region to which the entry belongs.
* @see org.apache.geode.cache.Region
*/
protected Region getRegion() {
return region;
}
/**
* Invoked to load a cache value for the specified key. Delegates to {@link #load(LoaderHelper)}.
*
* @return the loaded cache value for the specified key.
* @throws java.lang.IllegalStateException if the {@link Region} or key references are null.
* @throws java.lang.Exception if the load operation fails.
* @see #load(LoaderHelper)
*/
public final V call() throws Exception {
Assert.state(getKey() != null, "The key for which the value is loaded for cannot be null");
Assert.state(getRegion() != null, "The Region to load cannot be null");
return load(new LoaderHelper() {
public V netSearch(final boolean doNetLoad) throws CacheLoaderException, TimeoutException {
throw new UnsupportedOperationException("not implemented");
}
public K getKey() {
return CallableCacheLoaderAdapter.this.getKey();
}
public Region getRegion() {
return CallableCacheLoaderAdapter.this.getRegion();
}
public Object getArgument() {
return CallableCacheLoaderAdapter.this.getArgument();
}
});
}
/**
* Closes any resources used by this {@link CacheLoader}. Delegates to the underlying {@link CacheLoader}.
*
* @see #getCacheLoader()
*/
public void close() {
getCacheLoader().close();
}
/**
* Loads a value for the specified cache (i.e. {@link Region}) and key with the help of the {@link LoaderHelper}.
* Delegates to the underlying {@link CacheLoader}.
*
* @param loaderHelper a {@link LoaderHelper} object passed in from cache service providing access to the key,
* {@link Region}, argument, and netSearch.
* @return the value supplied for the specified key, or null if no value can be supplied. A local loader will
* always be invoked if one exists. Otherwise one remote loader is invoked. Returning null causes
* {@link Region#get(Object, Object)} to return null.
* @throws CacheLoaderException if an error occurs during the load operation. This exception, or any other
* Exception thrown by this method will be propagated back to the application from the
* {@link Region#get(Object)} method.
* @see org.apache.geode.cache.CacheLoader#load(LoaderHelper)
* @see org.apache.geode.cache.LoaderHelper
* @see #getCacheLoader()
*/
public V load(LoaderHelper loaderHelper) throws CacheLoaderException {
return getCacheLoader().load(loaderHelper);
}
}
