com.google.common.cache.CacheLoader Java Examples

GitLabAccess(@NotNull LocalContext local, @NotNull GitLabMappingConfig config, int projectId) {
  this.environment = Collections.singletonMap("GL_REPOSITORY", String.format("project-%s", projectId));

  final GitLabContext context = GitLabContext.sure(local.getShared());

  this.cache = CacheBuilder.newBuilder()
      .maximumSize(config.getCacheMaximumSize())
      .expireAfterWrite(config.getCacheTimeSec(), TimeUnit.SECONDS)
      .build(
          new CacheLoader<String, GitlabProject>() {
            @Override
            public GitlabProject load(@NotNull String userId) throws Exception {
              if (userId.isEmpty())
                return GitlabAPI.connect(context.getGitLabUrl(), null).getProject(projectId);

              final GitlabAPI api = context.connect();
              final String tailUrl = GitlabProject.URL + "/" + projectId + "?sudo=" + userId;
              return api.retrieve().to(tailUrl, GitlabProject.class);
            }
          }
      );
}
 

public DbDicService(DicStore dicStore, String pattern) {
    this.dicStore = dicStore;
    this.pattern = pattern;
    this.name2IdCache = CacheBuilder.newBuilder()
            .maximumSize(MAX_SIZE).expireAfterAccess(1, TimeUnit.DAYS)
            .build(new CacheLoader<String, String>() {
                @Override
                public String load(String key) {
                    try {
                        return getOrCreateId(key);
                    } catch (EmptyResultDataAccessException e) {
                        return "";
                    }
                }
            });
}
 

public ThriftHiveMetastore(MetastoreLocator metastoreLocator, HiveConfig hiveConfig, ThriftMetastoreConfig thriftConfig, HdfsEnvironment hdfsEnvironment, boolean authenticationEnabled)
{
    this.hdfsContext = new HdfsContext(ConnectorIdentity.ofUser(DEFAULT_METASTORE_USER));
    this.clientProvider = requireNonNull(metastoreLocator, "metastoreLocator is null");
    this.hdfsEnvironment = requireNonNull(hdfsEnvironment, "hdfsEnvironment is null");
    this.backoffScaleFactor = thriftConfig.getBackoffScaleFactor();
    this.minBackoffDelay = thriftConfig.getMinBackoffDelay();
    this.maxBackoffDelay = thriftConfig.getMaxBackoffDelay();
    this.maxRetryTime = thriftConfig.getMaxRetryTime();
    this.maxRetries = thriftConfig.getMaxRetries();
    this.impersonationEnabled = thriftConfig.isImpersonationEnabled();
    this.deleteFilesOnDrop = thriftConfig.isDeleteFilesOnDrop();
    this.translateHiveViews = hiveConfig.isTranslateHiveViews();
    this.maxWaitForLock = thriftConfig.getMaxWaitForTransactionLock();
    this.authenticationEnabled = authenticationEnabled;

    this.delegationTokenCache = CacheBuilder.newBuilder()
            .expireAfterWrite(thriftConfig.getDelegationTokenCacheTtl().toMillis(), MILLISECONDS)
            .maximumSize(thriftConfig.getDelegationTokenCacheMaximumSize())
            .build(CacheLoader.from(this::loadDelegationToken));
}
 

public static List<PriceInfo> search(String term, int limit) {
	try {
		Request request = Request.Get(API_URL + "search?term=" + URLEncoder.encode(term, "UTF-8") + "&limit=" + limit);
		request.addHeader(AUTH_HEADER_KEY, "Bearer " + Session.get().getApiToken());

		HttpResponse response = Executor.newInstance(HttpUtil.getClient()).execute(request).returnResponse();
		if (response != null) {
			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
				byte[] bytes = EntityUtils.toByteArray(response.getEntity());
				return GSON.fromJson(new String(bytes), PRICE_INFO_LIST_TYPE);
			}
		}
		return new ArrayList<>();
	} catch (IOException | CacheLoader.InvalidCacheLoadException e) {
		e.printStackTrace();
		return new ArrayList<>();
	}
}
 

public ChallengeCompletionLogic(uSkyBlock plugin, FileConfiguration config) {
    this.plugin = plugin;
    storeOnIsland = config.getString("challengeSharing", "island").equalsIgnoreCase("island");
    completionCache = CacheBuilder
            .from(plugin.getConfig().getString("options.advanced.completionCache", "maximumSize=200,expireAfterWrite=15m,expireAfterAccess=10m"))
            .removalListener(new RemovalListener<String, Map<String, ChallengeCompletion>>() {
                @Override
                public void onRemoval(RemovalNotification<String, Map<String, ChallengeCompletion>> removal) {
                    saveToFile(removal.getKey(), removal.getValue());
                }
            })
            .build(new CacheLoader<String, Map<String, ChallengeCompletion>>() {
                       @Override
                       public Map<String, ChallengeCompletion> load(String id) throws Exception {
                           return loadFromFile(id);
                       }
                   }
            );
    storageFolder = new File(plugin.getDataFolder(), "completion");
    if (!storageFolder.exists() || !storageFolder.isDirectory()) {
        storageFolder.mkdirs();
    }
}
 

@Override protected Map<String, Table> getTableMap() {
  if (!discoverTables) {
    return ImmutableMap.of();
  }

  if (tableMap == null) {
    final DruidConnectionImpl connection = new DruidConnectionImpl(url, coordinatorUrl);
    Set<String> tableNames = connection.tableNames();

    tableMap = Maps.asMap(
        ImmutableSet.copyOf(tableNames),
        CacheBuilder.newBuilder()
            .build(CacheLoader.from(name -> table(name, connection))));
  }

  return tableMap;
}
 

@Override
protected boolean tryRefresh(LimiterConfig config) {
    // rate limiter
    this.rateLimiter = AdjustableRateLimiter.create(config.getRate().getMaxRate());
    // concurrent limiter
    this.semaphore = new AdjustableSemaphore(config.getConcurrent().getMaxPermit(), true);
    // counter limiter
    // request limiter
    CacheBuilder<Object, Object> cacheBuilder = CacheBuilder.newBuilder();
    cacheBuilder.expireAfterWrite(config.getCounter().getTimeout(), TimeUnit.MILLISECONDS);
    this.counter = cacheBuilder.build(CacheLoader.from(() -> new AtomicLong(0)));

    // the refresh rateLimiter
    rateLimiter.setRate(config.getRate().getRateUnit());
    // the refresh semaphore
    semaphore.setMaxPermits(config.getConcurrent().getMaxPermit());
    return true;
}
 

/**
 * @param methodName the name of the implementation method in the extension file
 * @param methodParameters a mapping of field names to values for a given rule
 * @param attributes a mapping of field names to attributes for a given rule
 *     com.facebook.buck.core.artifact.Artifact}s
 * @param context mapping of build targets to {@link ProviderInfoCollection} for rules that this
 *     rule
 */
private SkylarkRuleContextAttr(
    String methodName,
    Map<String, Object> methodParameters,
    Map<String, Attribute<?>> attributes,
    RuleAnalysisContext context) {
  this.methodName = methodName;
  this.attributes = attributes;
  this.postCoercionTransformValues =
      CacheBuilder.newBuilder()
          .build(
              new CacheLoader<String, Object>() {
                @Override
                public Object load(String paramName) {
                  Object coercedValue =
                      Preconditions.checkNotNull(methodParameters.get(paramName));
                  return Preconditions.checkNotNull(attributes.get(paramName))
                      .getPostCoercionTransform()
                      .postCoercionTransform(coercedValue, context);
                }
              });
}
 

public ScmSourceProviderImpl(final Function<String, PieroneOperations> pieroneOperationsProvider) {
    this.pieroneOperationsProvider = pieroneOperationsProvider;
    this.cache = CacheBuilder.newBuilder()
            .maximumSize(100)
            .expireAfterAccess(5, MINUTES)
            .build(new CacheLoader<String, Optional<Map<String, String>>>() {
        @Override
        public Optional<Map<String, String>> load(@Nonnull final String source) throws Exception {
            final Optional<Map<String, String>> result = scmSourceFor(source);
            if (!result.isPresent()) {
                log.warn("Could not find scm source '{}' in Pierone", source);
            }
            return result;
        }
    });
}
 

public AppleDependenciesCache(TargetGraph projectGraph) {
  this.depsCache =
      CacheBuilder.newBuilder()
          .build(
              CacheLoader.from(
                  node -> {
                    ImmutableSortedSet.Builder<TargetNode<?>> defaultDepsBuilder =
                        ImmutableSortedSet.naturalOrder();
                    ImmutableSortedSet.Builder<TargetNode<?>> exportedDepsBuilder =
                        ImmutableSortedSet.naturalOrder();
                    AppleBuildRules.addDirectAndExportedDeps(
                        projectGraph,
                        node,
                        defaultDepsBuilder,
                        exportedDepsBuilder,
                        Optional.empty());
                    return new CacheItem(defaultDepsBuilder.build(), exportedDepsBuilder.build());
                  }));
}
 

public ApplicationIdCacheImpl(
    final EntityManager managementEnityManager, ManagerCache managerCache, ApplicationIdCacheFig fig) {

    this.managementEnityManager = managementEnityManager;
    this.managerCache = managerCache;

    appCache = CacheBuilder.newBuilder()
        .maximumSize(fig.getCacheSize())
        .expireAfterWrite(fig.getCacheTimeout(), TimeUnit.MILLISECONDS)
        .build(new CacheLoader<String, UUID>() {
            @Override
            public UUID load(final String key) throws Exception {
                UUID appId = fetchApplicationId(key);
                if ( appId == null ) {
                    throw new PersistenceException("Error getting applicationId");
                }
                return appId;
            }
        });
}
 

private LoadingCache<Long, Page<T>> buildCache(int size) {
	return CacheBuilder.newBuilder().concurrencyLevel(1).initialCapacity(size).maximumSize(size)
	      .removalListener(new RemovalListener<Long, Page<T>>() {

		      @Override
		      public void onRemoval(RemovalNotification<Long, Page<T>> notification) {
			      m_recentlyExpiredPagesCache.get().put(notification.getKey(), true);
		      }
	      }).build(new CacheLoader<Long, Page<T>>() {

		      @Override
		      public Page<T> load(Long pageNo) throws Exception {
			      return new Page<>(pageNo, m_pageSize, m_pageLoadIntervalMillis);
		      }

	      });
}
 

@Override
protected void doInit(Map<String, ?> config) {
    schemaCache = CacheBuilder.newBuilder()
            .maximumSize(getCacheMaxSize(config))
            .expireAfterAccess(getCacheExpiryInSecs(config), TimeUnit.SECONDS)
            .build(new CacheLoader<SchemaVersionKey, S>() {
                @Override
                public S load(SchemaVersionKey schemaVersionKey) {
                    try {
                        return getParsedSchema(schemaVersionKey);
                    } catch (SchemaNotFoundException | InvalidSchemaException e) {
                       throw new RegistryException(e);
                    }
                }
            });
}
 

public ClassLoaderCache(final SchemaRegistryClient schemaRegistryClient) {
    this.schemaRegistryClient = schemaRegistryClient;

    CacheLoader<String, ClassLoader> cacheLoader = new CacheLoader<String, ClassLoader>() {
        @Override
        public ClassLoader load(String fileId) throws Exception {
            File file = getFile(fileId);
            return new URLClassLoader(new URL[]{file.toURI().toURL()});
        }
    };

    SchemaRegistryClient.Configuration configuration = schemaRegistryClient.getConfiguration();
    loadingCache = CacheBuilder.newBuilder()
                               .maximumSize(((Number) configuration.getValue(CACHE_SIZE_KEY)).longValue())
                               .expireAfterAccess(((Number) configuration.getValue(CACHE_EXPIRY_INTERVAL_KEY)).longValue(),
                                                  TimeUnit.SECONDS)
                               .build(cacheLoader);

    localJarsDir = new File((String) this.schemaRegistryClient.getConfiguration().getValue(SchemaRegistryClient.Configuration.LOCAL_JAR_PATH.name()));
    ensureLocalDirsExist();
}
 

public CachingAsyncLeaderElector(AsyncLeaderElector<T> delegateLeaderElector, CacheConfig cacheConfig) {
  super(delegateLeaderElector);
  cache = CacheBuilder.newBuilder()
      .maximumSize(cacheConfig.getSize())
      .build(CacheLoader.from(super::getLeadership));

  cacheUpdater = event -> {
    Leadership<T> leadership = event.newLeadership();
    cache.put(event.topic(), CompletableFuture.completedFuture(leadership));
  };
  statusListener = status -> {
    if (status == PrimitiveState.SUSPENDED || status == PrimitiveState.CLOSED) {
      cache.invalidateAll();
    }
  };
  addListener(cacheUpdater);
  addStateChangeListener(statusListener);
}
 

@Inject
public ZookeeperLock(ZookeeperConfiguration config) {
    LOCK_NAMESPACE = config.getProperty("workflow.decider.locking.namespace", "");
    RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
    client = CuratorFrameworkFactory.newClient(
            config.getZkConnection(),
            config.getZkSessiontimeoutMs(),
            config.getZkConnectiontimeoutMs(),
            retryPolicy
    );
    client.start();
    zkLocks = CacheBuilder.newBuilder()
            .maximumSize(CACHE_MAXSIZE)
            .expireAfterAccess(CACHE_EXPIRY_TIME, TimeUnit.MINUTES)
            .build(new CacheLoader<String, InterProcessMutex>() {
                       @Override
                       public InterProcessMutex load(String key) throws Exception {
                           return new InterProcessMutex(client, zkPath.concat(key));
                       }
                   }
            );

    zkPath = StringUtils.isEmpty(LOCK_NAMESPACE)
            ? ("/conductor/")
            : ("/conductor/" + LOCK_NAMESPACE + "/");
}
 

/**
 * Initialize this TaskWriter with the specified context object.
 */
@SuppressWarnings("unchecked")
public void initialize(TaskWriterContext context) {
    this.context = context;
    this.parameter = (T) context.getWriterParameter();
    this.handlers = CacheBuilder.newBuilder().build(new CacheLoader<Class<? extends Record>, Handler>() {
        @Override
        public Handler load(Class<? extends Record> clazz) throws Exception {
            Handler handler = getHandler(clazz);
            if (handler == null) {
                throw new RecordNotSupportException(clazz);
            }
            handler.initialize(context);
            return handler;
        }
    });
}
 

@Inject
public ArchiveManager(StorageManager storageManager, Config systemConfig)
{
    this.storageManager = storageManager;
    this.storageCache = CacheBuilder.newBuilder()
        .maximumSize(2)
        .build(
                new CacheLoader<ArchiveType, Storage>()
                {
                    public Storage load(ArchiveType type)
                    {
                        return openStorage(type);
                    }
                });
    this.systemConfig = systemConfig;
    this.uploadArchiveType = systemConfig.get("archive.type", ArchiveType.class, ArchiveType.DB);
    this.pathPrefix = getArchivePathPrefix(systemConfig, uploadArchiveType);
    this.directDownloadEnabled = systemConfig.get("archive." + uploadArchiveType + ".direct_download", Boolean.class, false);
}
 

@VisibleForTesting
public AmazonS3Provider(AWSCredentialsProvider credentialsProvider, String localRegionName) {
    _credentialsProvider = credentialsProvider;
    _localRegionName = localRegionName;

    _clientsByRegion = CacheBuilder.newBuilder()
            .maximumSize(4)
            .build(new CacheLoader<String, AmazonS3>() {
                @Override
                public AmazonS3 load(String regionName) throws Exception {
                    return createS3ClientForRegion(regionName);
                }
            });

    _clientsByBucket = CacheBuilder.newBuilder()
            .maximumSize(10)
            .build();
}
 

@Inject
public LockCache() {
  cache = CacheBuilder.newBuilder().weakValues().build(new CacheLoader<K, Object>() {
    @Override
    public Object load(K key) {
      return new Object();
    }
  });
}
 

private void initTables(final JdbcTemplate jdbcTemplate) {
    this.tables = CacheBuilder.newBuilder().softValues().build(new CacheLoader<List<String>, Table>() {
        @Override
        public Table load(List<String> names) throws Exception {
            Assert.isTrue(names.size() == 2);
            try {
                beforeFindTable(jdbcTemplate, names.get(0), names.get(0), names.get(1));
                DdlUtilsFilter filter = getDdlUtilsFilter(jdbcTemplate, names.get(0), names.get(0), names.get(1));
                Table table = DdlUtils.findTable(
                        jdbcTemplate,
                        getActualSchemaName(names.get(0)),
                        isGetTablesWithSchema() ? getActualSchemaName(names.get(0)) : null,
                        names.get(1),
                        filter);
                afterFindTable(table, jdbcTemplate, names.get(0), names.get(0), names.get(1));
                if (table == null) {
                    throw new NestableRuntimeException("no found table [" + names.get(0) + "." + names.get(1)
                            + "] , pls check");
                } else {
                    return table;
                }
            } catch (Exception e) {
                throw new NestableRuntimeException("find table [" + names.get(0) + "." + names.get(1) + "] error",
                        e);
            }
        }
    });

}
 

private static CacheLoader<Integer, ServicePolicies> createServicePoliciesCacheLoader() {
	return new CacheLoader<Integer, ServicePolicies>() {
		@Override
		public ServicePolicies load(Integer numberOfPolicies) throws Exception {
			return RangerPolicyFactory.createServicePolicy(numberOfPolicies);
		}
	};
}
 

private LoadingCache<UnorderedPair<T>, Double> createCache() {
	CacheLoader<UnorderedPair<T>, Double> loader = CacheLoader
		.from(similarityMeasure::calculateSimilarity);
	return CacheBuilder.newBuilder()
		.maximumSize(maximumSize)
		.build(loader);
}
 

/**
 * Instantiate with the underlying writer to delegate to, and the size of the internal buffer to use.
 *
 * @param delegateWriter underlying writer to delegate writes and deletes to
 * @param bufferSize size of the internal write buffer to use
 * @param documentOutputCounter Hadoop counter for recording the number of Solr documents output
 * @param documentBatchOutputCounter Hadoop counter for recording the number of document batches output
 */
public BufferedSolrInputDocumentWriter(SolrInputDocumentWriter delegateWriter, int bufferSize,
        Counter documentOutputCounter, Counter documentBatchOutputCounter) {
    this.delegateWriter = delegateWriter;
    this.bufferSize = bufferSize;
    this.adds = 0;
    this.writeBuffers = CacheBuilder.newBuilder().build(new CacheLoader<Integer, Map<String, SolrInputDocument>>() {
        @Override
        public Map<String, SolrInputDocument> load(Integer key) throws Exception {
            return new HashMap(BufferedSolrInputDocumentWriter.this.bufferSize);
        }
    });
    this.docOutputCounter = documentOutputCounter;
    this.docBatchCounter = documentBatchOutputCounter;
}
 

Writes(Supplier<Instance> instanceSupplier, long writeExpiresAfter, TimeUnit writeExpiresUnit) {
  this.instanceSupplier = instanceSupplier;
  blobWriteInstances =
      CacheBuilder.newBuilder()
          .expireAfterWrite(writeExpiresAfter, writeExpiresUnit)
          .build(
              new CacheLoader<BlobWriteKey, Instance>() {
                @Override
                public Instance load(BlobWriteKey key) {
                  return instanceSupplier.get();
                }
              });
}
 

private QueryContext createQueryContext(Session session) {
  QueryContext newQueryContext =  new QueryContext(context.getConf(), session);

  // Set default space uri and its root uri
  newQueryContext.setDefaultSpaceUri(TablespaceManager.getDefault().getUri());
  newQueryContext.setDefaultSpaceRootUri(TablespaceManager.getDefault().getRootUri());

  if (TajoConstants.IS_TEST_MODE) {
    newQueryContext.putAll(CommonTestingUtil.getSessionVarsForTest());
  }

  // Set queryCache in session
  int queryCacheSize = context.getConf().getIntVar(TajoConf.ConfVars.QUERY_SESSION_QUERY_CACHE_SIZE);
  if (queryCacheSize > 0 && session.getQueryCache() == null) {
    Weigher<String, Expr> weighByLength = new Weigher<String, Expr>() {
      public int weigh(String key, Expr expr) {
        return key.length();
      }
    };
    LoadingCache<String, Expr> cache = CacheBuilder.newBuilder()
      .maximumWeight(queryCacheSize * 1024)
      .weigher(weighByLength)
      .expireAfterAccess(1, TimeUnit.HOURS)
      .build(new CacheLoader<String, Expr>() {
        public Expr load(String sql) throws SQLSyntaxError {
          return analyzer.parse(sql);
        }
      });
    session.setQueryCache(cache);
  }
  return newQueryContext;
}
 

@Test
public void testCacheBuilder() throws ExecutionException {
  LoadingCache<String, Matcher> cache = CacheBuilder.newBuilder()
      .maximumSize(10)
      .build(
          new CacheLoader<String, Matcher>() {
            public Matcher load(String key) {
              return Pattern.compile(key).matcher("");
            }
          });
  
  Matcher m = cache.get(".*");
  Matcher m2 = cache.get(".*");
}
 

public StaticDatabaseMappingService(
    MetaStoreMappingFactory metaStoreMappingFactory,
    List<AbstractMetaStore> initialMetastores) {
  this.metaStoreMappingFactory = metaStoreMappingFactory;
  primaryDatabasesCache = CacheBuilder
      .newBuilder()
      .expireAfterAccess(1, TimeUnit.MINUTES)
      .maximumSize(1)
      .build(new CacheLoader<String, List<String>>() {

        @Override
        public List<String> load(String key) throws Exception {
          if (primaryDatabaseMapping != null) {
            return primaryDatabaseMapping.getClient().get_all_databases();
          } else {
            return Lists.newArrayList();
          }
        }
      });

  mappingsByMetaStoreName = Collections.synchronizedMap(new LinkedHashMap<>());
  mappingsByDatabaseName = Collections.synchronizedMap(new LinkedHashMap<>());
  databaseMappingToDatabaseList = new ConcurrentHashMap<>();
  for (AbstractMetaStore federatedMetaStore : initialMetastores) {
    add(federatedMetaStore);
  }
}
 

public PageLoader(){
	System.setProperty("http.agent", "TinkerTime Mod Manager Agent");
	cache = CacheBuilder.newBuilder()
			.expireAfterAccess(CACHING_EXIPIRY_MINUTES, TimeUnit.MINUTES)
			.build(
					new CacheLoader<URL, T>() {
						@Override
						public T load(URL url) throws IOException {
							return loadPage(url);
						}
					});
}
 

@VisibleForTesting
static LoadingCache<String, PremiumList> createCachePremiumLists(Duration cachePersistDuration) {
  return CacheBuilder.newBuilder()
      .expireAfterWrite(cachePersistDuration.getMillis(), MILLISECONDS)
      .build(
          new CacheLoader<String, PremiumList>() {
            @Override
            public PremiumList load(final String name) {
              return tm().doTransactionless(() -> loadPremiumList(name));
            }
          });
}