Java Suppliers.memoizeWithExpiration方法代码示例

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
public GSuiteGroupAuthorizationFilter(final GSuiteDirectoryService gsuiteDirService, AppConfiguration config) {
    this.config = config;
    this.externalAccountsCache = Suppliers.memoizeWithExpiration(
            () -> {
                String allowGroup = config.getExternalAccountsGroup();
                Set<String> result = Collections.emptySet();
                try {
                    GroupMembership membership = gsuiteDirService.getGroupMembers(allowGroup);
                    result = membership.getMembers() == null ? Collections.emptySet()
                    : membership.getMembers().stream().map(m -> m.getEmail()).collect(Collectors.toSet());
                } catch (ResourceNotFoundException e) {
                    log.warn("Group for external accounts {} does not exists", allowGroup);
                }
                return result;
            }, 15, TimeUnit.MINUTES);
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
public static void main(String[] args) throws InterruptedException {
    // {{start:memoize}}
    log.info("Memoized");
    Supplier<String> memoized = Suppliers.memoize(SuppliersExamples::helloWorldSupplier);
    log.info(memoized.get());
    log.info(memoized.get());
    // {{end:memoize}}

    // {{start:memoizeWithExpiration}}
    log.info("Memoized with Expiration");
    Supplier<String> memoizedExpiring = Suppliers.memoizeWithExpiration(
        SuppliersExamples::helloWorldSupplier, 50, TimeUnit.MILLISECONDS);
    log.info(memoizedExpiring.get());
    log.info(memoizedExpiring.get());
    log.info("sleeping");
    TimeUnit.MILLISECONDS.sleep(100);
    log.info(memoizedExpiring.get());
    log.info(memoizedExpiring.get());
    log.info("sleeping");
    TimeUnit.MILLISECONDS.sleep(100);
    log.info(memoizedExpiring.get());
    log.info(memoizedExpiring.get());
    // {{end:memoizeWithExpiration}}
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
public ConfigService(List<ConfigurationProvider> configurationProviders, Authorizer authorizer, long maximumCacheSize, long cacheTtlMillis) {
    this.authorizer = authorizer;
    this.objectMapper = new ObjectMapper();
    if (configurationProviders == null || configurationProviders.size() == 0) {
        throw new IllegalArgumentException("Expected at least one configuration provider");
    }
    this.configurationProviderInfo = Suppliers.memoizeWithExpiration(() -> initContentTypeInfo(configurationProviders), cacheTtlMillis, TimeUnit.MILLISECONDS);
    CacheBuilder<Object, Object> cacheBuilder = CacheBuilder.newBuilder();
    if (maximumCacheSize >= 0) {
        cacheBuilder = cacheBuilder.maximumSize(maximumCacheSize);
    }
    if (cacheTtlMillis >= 0) {
        cacheBuilder = cacheBuilder.refreshAfterWrite(cacheTtlMillis, TimeUnit.MILLISECONDS);
    }
    this.configurationCache = cacheBuilder
            .build(new CacheLoader<ConfigurationProviderKey, ConfigurationProviderValue>() {
                @Override
                public ConfigurationProviderValue load(ConfigurationProviderKey key) throws Exception {
                    return initConfigurationProviderValue(key);
                }
            });
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
@Override
public void refresh() {
    _cache = Suppliers.memoizeWithExpiration(new Supplier<CachedInfo>() {
        @Override
        public CachedInfo get() {
            Map<String, DataCenter> dataCenters = _dataCenterDao.loadAll();
            if (!_ignoredDataCenters.isEmpty()) {
                ImmutableMap.Builder<String, DataCenter> dataCentersBuilder = ImmutableMap.builder();
                for (Map.Entry<String, DataCenter> entry : dataCenters.entrySet()) {
                    if (!_ignoredDataCenters.contains(entry.getKey())) {
                        dataCentersBuilder.put(entry);
                    } else if (_loggedIgnored.add(entry.getKey())) {
                        // Only want to log that we're ignoring the data center once
                        _log.info("Ignoring data center: {}", entry.getKey());
                    }
                }
                dataCenters = dataCentersBuilder.build();
            }
            return new CachedInfo(dataCenters);
        }
    }, 10, TimeUnit.MINUTES);
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
@VisibleForTesting
StandardStashReader(URI stashRoot, AmazonS3 s3, long refreshLatestMs) {
    super(stashRoot, s3);

    Supplier<String> s3LatestRootSupplier = new Supplier<String>() {
        @Override
        public String get() {
            String latest = readLatestStash();
            return String.format("%s/%s", _rootPath, latest);
        }
    };

    if (refreshLatestMs > 0) {
        // Cache the latest stash directory and periodically recheck
        _latestRootSupplier = Suppliers.memoizeWithExpiration(s3LatestRootSupplier, refreshLatestMs, TimeUnit.MILLISECONDS);
    } else {
        _latestRootSupplier = s3LatestRootSupplier;
    }
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
@Inject
public ShardSizeExpression(final IndexShard indexShard) {
    sizeSupplier = Suppliers.memoizeWithExpiration(new Supplier<Long>() {
        @Override
        public Long get() {
            return indexShard.storeStats().getSizeInBytes();
        }
    }, 10, TimeUnit.SECONDS);
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
@Inject
public BlobShardSizeExpression(final BlobShard blobShard) {
    totalUsageSupplier = Suppliers.memoizeWithExpiration(new Supplier<Long>() {
        @Override
        public Long get() {
            return blobShard.blobStats().totalUsage();
        }
    }, 10, TimeUnit.SECONDS);
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
private void configure() {
    log.info("Configuring GSuiteDirectoryService ...");
    long tokenLifetime = config.getServiceAccountTokenLifetime();
    log.info("Token lifetime set to {}", tokenLifetime);
    this.tokenCache = Suppliers.memoizeWithExpiration(() -> getAccessToken(), tokenLifetime - 3, TimeUnit.SECONDS);
    this.membershipCache = Suppliers.memoizeWithExpiration(() -> getAllGroupMembershipInternal(), 3, TimeUnit.MINUTES);
    try {
        privateKey = config.getServiceAccountKey();
        log.info("Service account private key {}loaded", privateKey != null ? "" : "was not ");
    } catch (NoPrivateKeyException e) {
        log.error(e.getMessage(), e.getCause());
    }
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
public static InMemorySitemap fromSupplierWithExpiration(
        Supplier<Map<String, List<String>>> supplier,
        long duration,
        TimeUnit unit) {
    Supplier<Map<String, String>> sup = mapSupplier(supplier);
    Supplier<Map<String, String>> memoized = Suppliers.memoizeWithExpiration(sup::get, duration, unit);
    return new InMemorySitemap(memoized);
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
@VisibleForTesting
ServiceConfigFetcher(Supplier<Service> supplier) {
  this.serviceSupplier = Suppliers.memoizeWithExpiration(supplier, 10, TimeUnit.MINUTES);
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
@Inject
public DefaultJobService(LifeCycleRegistry lifeCycleRegistry,
                         QueueService queueService,
                         @JobQueueName String queueName,
                         JobHandlerRegistryInternal jobHandlerRegistry,
                         JobStatusDAO jobStatusDAO,
                         @JobZooKeeper CuratorFramework curator,
                         @JobConcurrencyLevel Integer concurrencyLevel,
                         @QueueRefreshTime Duration queueRefreshTime,
                         final @QueuePeekLimit Integer queuePeekLimit,
                         @NotOwnerRetryDelay Duration notOwnerRetryDelay) {
    _queueService = checkNotNull(queueService, "queueService");
    _queueName = checkNotNull(queueName, "queueName");
    _jobHandlerRegistry = checkNotNull(jobHandlerRegistry, "jobHandlerRegistry");
    _jobStatusDAO = checkNotNull(jobStatusDAO, "jobStatusDAO");
    _curator = checkNotNull(curator, "curator");
    _concurrencyLevel = checkNotNull(concurrencyLevel, "concurrencyLevel");
    checkArgument(_concurrencyLevel >= 0, "Concurrency level cannot be negative");
    _notOwnerRetryDelay = checkNotNull(notOwnerRetryDelay, "notOwnerRetryDelay");
    checkNotNull(queuePeekLimit, "queuePeekLimit");
    checkNotNull(lifeCycleRegistry, "lifecycleRegistry");

    _recentNotOwnerDelays = CacheBuilder.newBuilder()
            .expireAfterWrite(notOwnerRetryDelay.getMillis(), TimeUnit.MILLISECONDS)
            .build();

    Supplier<Queue<Message>> sourceMessageSupplier = new Supplier<Queue<Message>>() {
        @Override
        public Queue<Message> get() {
            return Queues.synchronizedQueue(Queues.newArrayDeque(_queueService.peek(_queueName, queuePeekLimit)));
        }
    };

    checkNotNull(queueRefreshTime, "queueRefreshTime");
    if (queueRefreshTime.getMillis() == 0) {
        _messageSupplier = sourceMessageSupplier;
    } else {
        _messageSupplier = Suppliers.memoizeWithExpiration(
                sourceMessageSupplier, queueRefreshTime.getMillis(), TimeUnit.MILLISECONDS);
    }

    lifeCycleRegistry.manage(this);
}
 

import com.google.common.base.Suppliers; //导入方法依赖的package包/类
/**
 * Memoization similar to {@link Suppliers#memoizeWithExpiration(Supplier, long, TimeUnit)} except the expiration
 * is randomly selected to be a value within provided bounds.  For example:
 *
 * <code>
 *     Supplier&lt;Object&t; supplier = MoreSuppliers.memoizeWithRandomExpiration(delegate, 5, 10, TimeUnit.SECONDS);
 * </code>
 *
 * returns a Supplier that will memoize the delegate's response for a random number of nanoseconds between 5
 * (inclusive) to 10 (exclusive) seconds.
 *
 * This is useful when numerous memoized values are typically computed independently but used within the same operation.
 * If all values were computed and memoized together then each call that refreshes from delegate could take longer
 * than desirable.  Similarly, if each value were memomized independently using the same expiration then herding
 * behavior would result in the same long calls at expiration time.  A random expiration allows each value to be
 * cached but spread out the refresh cycle so that it is unlikely that any single call will refresh the entire value
 * set, so long as the call frequency is significantly below <code>minDuration</code>.
 */
public static <T> Supplier<T> memoizeWithRandomExpiration(Supplier<T> delegate, long minDuration, long maxDuration, TimeUnit units) {
    if (minDuration == maxDuration) {
        // This case resolves to standard expiration
        return Suppliers.memoizeWithExpiration(delegate, minDuration, units);
    }
    return new RandomExpirationSupplier<T>(delegate, minDuration, maxDuration, units);
}