import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public CommandResult execute(Serializable key, GridCommand command) {
    if (exception != null) {
        throw new RuntimeException();
    }
    if (state == null) {
        return CommandResult.bucketNotFound();
    }
    emulateSerialization(key);
    command = emulateSerialization(command);
    GridBucketState newState = emulateSerialization(state);
    Serializable resultData = command.execute(newState, timeMeter.currentTimeNanos());
    if (command.isBucketStateModified()) {
        state = newState;
    }
    resultData = emulateSerialization(resultData);
    return CommandResult.success(resultData);
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public Optional<BucketConfiguration> getConfiguration(K key) {
    try {
        SerializableFunction<EntryView.ReadWriteEntryView<K, GridBucketState>, GridBucketState> findFunction =
                (SerializableFunction<EntryView.ReadWriteEntryView<K, GridBucketState>, GridBucketState>)
                entry -> entry.find().orElse(null);
        GridBucketState state = readWriteMap.eval(key, findFunction).get();
        if (state == null) {
            return Optional.empty();
        } else {
            return Optional.of(state.getConfiguration());
        }
    } catch (InterruptedException | ExecutionException e) {
        throw new CacheException(e);
    }
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
private void checkProviders(Cache<K, GridBucketState> cache) {
    CacheManager cacheManager = cache.getCacheManager();
    if (cacheManager == null) {
        return;
    }

    CachingProvider cachingProvider = cacheManager.getCachingProvider();
    if (cachingProvider == null) {
        return;
    }

    String providerClassName = cachingProvider.getClass().getName();
    incompatibleProviders.forEach((providerPrefix, recommendation) -> {
        if (providerClassName.startsWith(providerPrefix)) {
            String message = "The Cache provider " + providerClassName + " is incompatible with Bucket4j, " + recommendation;
            throw new UnsupportedOperationException(message);
        }
    });
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
public RateLimitingFilter(JHipsterProperties jHipsterProperties) {
    this.jHipsterProperties = jHipsterProperties;

    CachingProvider cachingProvider = Caching.getCachingProvider();
    CacheManager cacheManager = cachingProvider.getCacheManager();
    CompleteConfiguration<String, GridBucketState> config =
        new MutableConfiguration<String, GridBucketState>()
            .setTypes(String.class, GridBucketState.class);

    this.cache = cacheManager.createCache(GATEWAY_RATE_LIMITING_CACHE_NAME, config);
    this.buckets = Bucket4j.extension(JCache.class).proxyManagerForCache(cache);
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
/**
 * This methods 
 * 
 * @param cacheName the name of the cache to retrieve
 * @param cacheManager
 * @return
 */
@SuppressWarnings("unchecked")
public Cache<String, GridBucketState> jCache(String cacheName, CacheManager cacheManager) {
       Cache springCache = cacheManager.getCache(cacheName);
       if(springCache == null) {
       	throw new JCacheNotFoundException(cacheName);
       }
	
       return (Cache<String, GridBucketState>) springCache;
   }
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public void createInitialState(Serializable key, BucketConfiguration configuration) {
    if (exception != null) {
        throw new RuntimeException();
    }
    BucketState bucketState = BucketState.createInitialState(configuration, timeMeter.currentTimeNanos());
    this.state = new GridBucketState(configuration, bucketState);
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public Object process(Map.Entry<K, GridBucketState> entry) {
    HazelcastMutableEntryAdapter<K> entryAdapter = new HazelcastMutableEntryAdapter<>(entry);
    CommandResult<T> result = entryProcessor.process(entryAdapter);
    if (entryAdapter.isModified()) {
        GridBucketState state = entry.getValue();
        backupProcessor = new SimpleBackupProcessor<>(state);
    }
    return result;
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public Optional<BucketConfiguration> getConfiguration(K key) {
    GridBucketState state = cache.get(key);
    if (state == null) {
        return Optional.empty();
    } else {
        return Optional.of(state.getConfiguration());
    }
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public CommandResult<Nothing> process(MutableEntry<K, GridBucketState> mutableEntry, Object... arguments) {
    if (mutableEntry.exists()) {
        return CommandResult.success(null);
    }
    long currentTimeNanos = currentTimeNanos();
    BucketState bucketState = BucketState.createInitialState(configuration, currentTimeNanos);
    GridBucketState gridBucketState = new GridBucketState(configuration, bucketState);
    mutableEntry.setValue(gridBucketState);
    return CommandResult.success(null);
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public CommandResult<T> process(MutableEntry<K, GridBucketState> mutableEntry, Object... arguments) {
    if (!mutableEntry.exists()) {
        return CommandResult.bucketNotFound();
    }
    long currentTimeNanos = currentTimeNanos();
    GridBucketState gridBucketState = mutableEntry.getValue();

    T result = targetCommand.execute(gridBucketState, currentTimeNanos);
    if (targetCommand.isBucketStateModified()) {
        mutableEntry.setValue(gridBucketState);
    }
    return CommandResult.success(result);
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
HazelcastProxyManager(IMap<K, GridBucketState> map) {
    if (map == null) {
        throw new IllegalArgumentException("map must not be null");
    }
    this.gridProxy = new HazelcastProxy<>(map);
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public EntryBackupProcessor<K, GridBucketState> getBackupProcessor() {
    return backupProcessor;
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
public HazelcastProxy(IMap<K, GridBucketState> cache) {
    this.cache = cache;
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
public HazelcastMutableEntryAdapter(Map.Entry<K, GridBucketState> entry) {
    this.entry = entry;
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public void setValue(GridBucketState value) {
    entry.setValue(value);
    this.modified = true;
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public GridBucketState getValue() {
    return entry.getValue();
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
public SimpleBackupProcessor(GridBucketState state) {
    this.state = state;
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public void processBackup(Map.Entry<K, GridBucketState> entry) {
    entry.setValue(state);
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
@Override
public CommandResult<R> apply(EntryView.ReadWriteEntryView<K, GridBucketState> entryView) {
    return entryProcessor.process(new MutableEntryAdapter<>(entryView));
}
 

import io.github.bucket4j.grid.GridBucketState; //导入依赖的package包/类
public MutableEntryAdapter(EntryView.ReadWriteEntryView<K, GridBucketState> entryView) {
    this.entryView = entryView;
}