import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
@Test
public void testBucketRegistryWithKeyIndependentConfiguration() {
    BucketConfiguration configuration = Bucket4j.configurationBuilder()
            .addLimit(Bandwidth.simple(10, Duration.ofDays(1)))
            .buildConfiguration();

    ProxyManager<String> registry = newProxyManager();
    Bucket bucket1 = registry.getProxy(key, () -> configuration);
    assertTrue(bucket1.tryConsume(10));
    assertFalse(bucket1.tryConsume(1));

    Bucket bucket2 = registry.getProxy(anotherKey, () -> configuration);
    assertTrue(bucket2.tryConsume(10));
    assertFalse(bucket2.tryConsume(1));
}
 

import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
/**
 * This method  
 * 
 * @param config
 * @param cacheManager
 * @param expressionParser
 * @param beanFactory
 * @return
 */
public FilterConfiguration buildFilterConfig(Bucket4JConfiguration config, CacheManager cacheManager, ExpressionParser expressionParser, BeanFactory beanFactory) {
	
	FilterConfiguration filterConfig = new FilterConfiguration();
	filterConfig.setUrl(config.getUrl());
	filterConfig.setOrder(config.getFilterOrder());
	filterConfig.setStrategy(config.getStrategy());
	filterConfig.setHttpResponseBody(config.getHttpResponseBody());
	ProxyManager<String> buckets = Bucket4j.extension(JCache.class).proxyManagerForCache(jCache(config.getCacheName(), cacheManager));
	
	config.getRateLimits().forEach(rl -> {
		ConfigurationBuilder<?> configBuilder = Bucket4j.configurationBuilder();
		for (BandWidthConfig bandWidth : rl.getBandwidths()) {
			configBuilder = configBuilder.addLimit(Bandwidth.simple(bandWidth.getCapacity(), Duration.of(bandWidth.getTime(), bandWidth.getUnit())));
		};
		
		final ConfigurationBuilder<?> configBuilderToUse = configBuilder;
		RateLimitCheck rlc = (servletRequest) -> {
			
	        boolean skipRateLimit = false;
	        if (rl.getSkipCondition() != null) {
	        	skipRateLimit = skipCondition(rl, expressionParser, beanFactory).evalute(servletRequest);
	        } 
	        
	        if(rl.getExecuteCondition() != null && !skipRateLimit) {
	        	skipRateLimit = !executeCondition(rl, expressionParser, beanFactory).evalute(servletRequest);
	        }
	        
	        if(!skipRateLimit) {
	        	String key = getKeyFilter(filterConfig.getUrl(), rl, expressionParser, beanFactory).key(servletRequest);
	        	Bucket bucket = buckets.getProxy(key, () -> configBuilderToUse.buildConfiguration());
	        	
	        	ConsumptionProbe probe = bucket.tryConsumeAndReturnRemaining(1);
	        	
	        	return probe;
	        }
			return null;
			
		};
		filterConfig.getRateLimitChecks().add(rlc);
		
	});
	
	return filterConfig;
}
 

import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(getExtensionClass()).proxyManagerForMap(map);
}
 

import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(Infinispan.class).proxyManagerForMap(readWriteMap);
}
 

import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(JCache.class).proxyManagerForCache(getCache());
}
 

import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(getExtensionClass()).proxyManagerForCache(cache);
}
 

import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
/**
 * Creates {@link HazelcastProxyManager} for specified map.
 *
 * @param map map for storing state of buckets
 * @param <T> type of keys in the map
 * @return {@link ProxyManager} for specified map.
 */
public <T extends Serializable> ProxyManager<T> proxyManagerForMap(IMap<T, GridBucketState> map) {
    return new HazelcastProxyManager<>(map);
}
 

import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
/**
 * Creates {@link InfinispanProxyManager} for specified cache.
 *
 * @param readWriteMap cache for storing state of buckets
 * @param <K> type of keys in the cache
 * @return {@link ProxyManager} for specified cache.
 */
public <K extends Serializable> ProxyManager<K> proxyManagerForMap(ReadWriteMap<K, GridBucketState> readWriteMap) {
    return new InfinispanProxyManager<>(readWriteMap);
}
 

import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
/**
 * Creates {@link JCacheProxyManager} for specified cache.
 *
 * @param cache cache for storing state of buckets
 * @param <T> type of keys in the cache
 * @return {@link ProxyManager} for specified cache.
 */
public <T extends Serializable> ProxyManager<T> proxyManagerForCache(Cache<T, GridBucketState> cache) {
    return new JCacheProxyManager<>(cache);
}
 

import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
/**
 * Creates {@link IgniteProxyManager} for specified cache.
 *
 * @param cache cache for storing state of buckets
 * @param <T> type of keys in the cache
 * @return {@link ProxyManager} for specified cache.
 */
public <T extends Serializable> ProxyManager<T> proxyManagerForCache(IgniteCache<T, GridBucketState> cache) {
    return new IgniteProxyManager<>(cache);
}
 

import io.github.bucket4j.grid.ProxyManager; //导入依赖的package包/类
protected abstract ProxyManager<String> newProxyManager();