preface

We usually package some small tools to handle caching or other things. But everyone encapsulates the wheel once and builds the wheel over and over again, which takes a bit of time. Are there any good tool libraries to recommend – Guava. Guava is an open source library that Google encapsulates based on Java. Its performance and usability are better than our own wheels. After all, It is made by Google

• LoadingCache
• Multimap and Multiset
• BiMap
• The Table (Table).
• Sets and Maps
• EventBus
• StopWatch
• Files (File operation)
• RateLimiter
• Guava Retry

Pay attention to the public account, communicate together, wechat search: sneak forward

Guava’s Maven configuration is introduced

< the dependency > < groupId > com. Google. Guava < / groupId > < artifactId > guava < / artifactId > < version > 27.0 jre < / version > </dependency>Copy the code

LoadingCache

• LoadingCache is widely used in real-world scenarios. In general, if you encounter scenarios that require a lot of time to calculate or cache values, you should store them in the cache. LoadingCache is similar to ConcurrentMap, but not the same. The big difference is that ConcurrentMap will permanently store all element values until they are displayed and removed, whereas LoadingCache will automatically remove expired values according to the configuration to keep memory usage reasonable
• In general, Guava Caching is suitable for the following scenarios:
  • Spend some memory in exchange for speed
  • Some keys will be called more than once
  • Cache content is limited and does not exceed the value of memory space. Guava Caches does not store content to files or outside the server. Consider Memcached, Redis, if you have such a need
• LoadingCache cannot cache null keys
• CacheBuilder Describes parameters used to construct LoadingCache

• LoadingCache V get(K key)If no value exists for the key, the new value is loaded into the key by calling the load method of CacheLoader
• The sample

LoadingCache<Integer,Long> cacheMap = CacheBuilder.newBuilder().initialCapacity(10)
    .concurrencyLevel(10)
    .expireAfterAccess(Duration.ofSeconds(10))
    .weakValues()
    .recordStats()
    .removalListener(new RemovalListener<Integer,Long>(){
        @Override
        public void onRemoval(RemovalNotification<Integer, Long> notification) {
            System.out.println(notification.getValue());
        }
    })
    .build(new CacheLoader<Integer,Long>(){
        @Override
        public Long load(Integer key) throws Exception {
            returnSystem.currentTimeMillis(); }}); cacheMap.get(1);
Copy the code

Multimap and MultiSet

• A Multimap can contain multiple values with duplicate keys. You can put multiple values into the same Key without overwriting the previous one
• The sample

//Multimap: key-value The key and value can be repeated
Multimap<String, String> multimap = ArrayListMultimap.create();
multimap.put("csc"."1");
multimap.put("lwl"."1");
multimap.put("csc"."1");
multimap.put("lwl"."one");
System.out.println(multimap.get("csc"));
System.out.println(multimap.get("lwl")); -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -1.1]
[1, one]
Copy the code

• One relatively useful scenario for multisets is to keep track of the number of each object, so it can be used for quantitative statistics
• The sample

//MultiSet: unordered + repeatable count() number of times to get a word
Multiset<String> set = HashMultiset.create();
set.add("csc");
set.add("lwl");
set.add("csc");
System.out.println(set.size());
System.out.println(set.count("csc"));
---------------------------
3
2
Copy the code

BiMap

• The key and value of BiMap must be unique, and value and key can be exchanged
• The sample

BiMap<Integer,String> biMap = HashBiMap.create();
biMap.put(1."lwl");
biMap.put(2."csc");
BiMap<String, Integer> map = biMap.inverse(); // Value and key transfer each other
map.forEach((v, k) -> System.out.println(v + "-" + k));
Copy the code

Table

• Table<R,C,V> table = HashBasedTable.create();As can be seen from the generics, table is determined by the double primary key R (row) and C (column), and V is the stored value
• New data:table.put(R,C,V)
• Get data:V v = table.get(R,C)
• Traversal data:Set<R> set = table.rowKeySet(); Set<C> set = table.columnKeySet(); 　　
• The sample

// Map of double keys Map--> Table-->rowKey+columnKey+value
Table<String, String, Integer> tables = HashBasedTable.create();
tables.put("csc"."lwl".1);
//row+column corresponding value
System.out.println(tables.get("csc"."lwl"));
Copy the code

Sets and Maps

// Create an immutable collection
ImmutableList<String> iList = ImmutableList.of("csc"."lwl");
ImmutableSet<String> iSet = ImmutableSet.of("csc"."lwl");
ImmutableMap<String, String> iMap = ImmutableMap.of("csc"."hello"."lwl"."world");
Copy the code

Intersection of sets, union, difference

HashSet setA = newHashSet(1.2.3.4.5);  
HashSet setB = newHashSet(4.5.6.7.8); 
/ / and set
SetView union = Sets.union(setA, setB);   
/ / difference set setA - setB
SetView difference = Sets.difference(setA, setB);  
/ / intersection
SetView intersection = Sets.intersection(setA, setB);  
Copy the code

Map intersection, union, and difference sets

HashMap<String, Integer> mapA = Maps.newHashMap();
mapA.put("a".1); mapA.put("b".2); mapA.put("c".3);
HashMap<String, Integer> mapB = Maps.newHashMap();
mapB.put("b".20); mapB.put("c".3); mapB.put("d".4);
MapDifference<String, Integer> mapDifference = Maps.difference(mapA, mapB);
//mapA has the same entry as mapB
System.out.println(mapDifference.entriesInCommon());
// The mapA and mapB keys have the same value and different entries
System.out.println(mapDifference.entriesDiffering());
// Only mapA entries exist
System.out.println(mapDifference.entriesOnlyOnLeft());
// Only mapB entry existsSystem.out.println(mapDifference.entriesOnlyOnRight());; ------------- result ------------- {c=3}
{b=(2.20)}
{a=1}
{d=4}
Copy the code

EventBus

• EventBus, Guava’s event handling mechanism, is an elegant implementation of the observer pattern (production/consumer programming model) in the design pattern. For event listening and publish subscribe patterns
• EventBus maintains a Multimap
  
  , Subscriber> map, key represents the corresponding class of the message (different messages are of different types and different messages are distinguished), value is a Subscriber, Subscriber is actually the corresponding message handler. If there is a message released, find the Subscriber corresponding to the message in this map and execute it
  >
• Use the sample

@Data
@AllArgsConstructor
public class OrderMessage {
    String message;
}
// Use the @SUBSCRIBE annotation to indicate that the dealWithEvent method is used to process messages corresponding to the OrderMessage type
// Multiple methods can be annotated, and different methods handle different object messages
public class OrderEventListener {
    @Subscribe
    public void dealWithEvent(OrderMessage event) {
        System.out.println(Content:"+ event.getMessage()); }} -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --// new AsyncEventBus(String identifier, Executor executor);
EventBus eventBus = new EventBus("lwl"); 
eventBus.register(new OrderEventListener());
// Publish the message
eventBus.post(new OrderMessage("csc"));
Copy the code

StopWatch

Stopwatch stopwatch = Stopwatch.createStarted();
for(int i=0; i<100000; i++){
    // do some thing
}
long nanos = stopwatch.elapsed(TimeUnit.MILLISECONDS);
System.out.println("Logical code runtime:"+nanos);
Copy the code

Files File operation

• Data is written to

File newFile = new File("D:/text.txt");
Files.write("this is a test".getBytes(), newFile);
// Write again will flush out the previous content
Files.write("csc".getBytes(), newFile);
/ / append to write
Files.append("lwl", newFile, Charset.defaultCharset());
Copy the code

• Text data reading

File newFile = new File("E:/text.txt");
List<String> lines = Files.readLines(newFile, Charset.defaultCharset());
Copy the code

• Other operating

RateLimiter

// The RateLimiter constructor, permitsPerSecond
public static RateLimiter create(double permitsPerSecond) 
// permitsPerSecond, warmupPeriod is the initial warm-up time of data, calculated from the first acquire or tryAcquire execution
public static RateLimiter create(double permitsPerSecond, Duration warmupPeriod)
// Get a token, block, return blocking time
public double acquire(a)
Permitting token, block, return block time
public double acquire(int permits)
// Get a token, time out returns
public boolean tryAcquire(Duration timeout)
//// obtains a permitting token, and returns with timeout
public boolean tryAcquire(int permits, Duration timeout)
Copy the code

• Use the sample

RateLimiter limiter = RateLimiter.create(2.3, TimeUnit.SECONDS);
System.out.println("get one permit cost time: " + limiter.acquire(1) + "s");
System.out.println("get one permit cost time: " + limiter.acquire(1) + "s");
System.out.println("get one permit cost time: " + limiter.acquire(1) + "s");
System.out.println("get one permit cost time: " + limiter.acquire(1) + "s");
System.out.println("get one permit cost time: " + limiter.acquire(1) + "s");
System.out.println("get one permit cost time: " + limiter.acquire(1) + "s");
System.out.println("get one permit cost time: " + limiter.acquire(1) + "s");
System.out.println("get one permit cost time: " + limiter.acquire(1) + "s"); -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- the -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- get one permit cost time:0.0s
get one permit cost time: 1.331672s
get one permit cost time: 0.998392s
get one permit cost time: 0.666014s
get one permit cost time: 0.498514s
get one permit cost time: 0.498918s
get one permit cost time: 0.499151s
get one permit cost time: 0.488548s
Copy the code

• Because RateLimiter is processed behind time, the first time is zero seconds, no matter how many times
• It can be seen that acquire took three seconds to warm up data in the first four times, while acquire time tended to be smooth from the fifth to the eighth time

Guava Retry

• Maven is introduced into

< the dependency > < groupId > com. Making. Rholder < / groupId > < artifactId > guava - retrying < / artifactId > < version > 2.0.0 < / version > </dependency>Copy the code

• RetryerBuilder constructor

Retryer<Boolean> retryer = RetryerBuilder.<Boolean>newBuilder()
    .retryIfException()
    .retryIfResult(Predicates.equalTo(false))
    .withAttemptTimeLimiter(AttemptTimeLimiters.fixedTimeLimit(1, TimeUnit.SECONDS))
    .withStopStrategy(StopStrategies.stopAfterAttempt(5))
    .build();
/ / Retryer calls
retryer.call(() -> true);
Copy the code

• Spring also has a Retry mechanism. Read about the Retry frameworks Guava-Retry and Spring-Retry

Welcome to correct the errors in the article (the story is pure fiction, if any similarities are pure coincidence)

Refer to the article

• Introduction and use of the Google Guava utility class
• Retry frameworks Guava-Retry and Spring-retry
• Ultra-detailed analysis of the Guava RateLimiter flow limiting principle