中文文档目录
redisson中文文档目录
分布式对象
package com.example.redissondemo.test;
import com.example.redissondemo.RedissonDemoApplication;
import com.example.redissondemo.test.domain.Order;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.redisson.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = RedissonDemoApplication.class)
@Slf4j
public class RedissonObjectExampleTests {
@Autowired
private RedissonClient redissonClient;
@Test
public void bucketTest() {
RBucket<Order> orderBucket = redissonClient.getBucket("myOrder");
System.out.println("init : " + orderBucket.get());
orderBucket.set(new Order(10L, "OR001"), 1, TimeUnit.MINUTES);
System.out.println("设置 : " + orderBucket.get());
System.out.println("删除状态:" + orderBucket.delete() + "当前" + orderBucket.get());
orderBucket.set(new Order(10L, "OR001"), 1, TimeUnit.MINUTES);
System.out.println("重新设置 : " + orderBucket.get());
orderBucket.compareAndSet(new Order(10L, "OR001"), new Order(10L, "OR002"));
System.out.println("存在or1 改为or2 : " + orderBucket.get());
orderBucket.compareAndSet(new Order(10L, "OR001"), new Order(10L, "OR003"));
System.out.println("存在or1 改为or3 : " + orderBucket.get());
orderBucket.setIfExists(new Order(10L, "OR003"), 1, TimeUnit.MINUTES);
System.out.println("存在bucket对象就修改为OR3 : " + orderBucket.get());
orderBucket.isExists();
orderBucket.delete();
}
@Test
public void numberTest() throws ExecutionException, InterruptedException, TimeoutException {
RDoubleAdder doubleAdder = redissonClient.getDoubleAdder("doubleAdder");
doubleAdder.add(1.9999);
doubleAdder.add(2.0001);
doubleAdder.add(3.0000000000000001);
RFuture<Double> future = doubleAdder.sumAsync();
Double sum = future.get(1000, TimeUnit.MILLISECONDS);
System.out.println(sum);
doubleAdder.delete();
RLongAdder longAdder = redissonClient.getLongAdder("longAdder");
longAdder.add(100);
longAdder.increment();
longAdder.increment();
long longSum = longAdder.sum();
System.out.println(longSum);
longAdder.delete();
longAdder.destroy();
RAtomicDouble atomicDouble = redissonClient.getAtomicDouble("atoDouble");
double v = atomicDouble.incrementAndGet();
System.out.println(v);
atomicDouble.compareAndSet(v, 2.0);
System.out.println(atomicDouble.get());
atomicDouble.delete();
RLongAdder atoLong = redissonClient.getLongAdder("atoLong");
atoLong.increment();
System.out.println(atoLong.sum());
atoLong.delete();
}
@Test
public void rateLimiterTest() {
RRateLimiter limiter = redissonClient.getRateLimiter("orderImport");
limiter.trySetRate(RateType.OVERALL, 10, 1, RateIntervalUnit.HOURS);
boolean b = limiter.tryAcquire(1);
System.out.println(" tryAcquire 1 availablePermits : " + limiter.availablePermits());
b = limiter.tryAcquire(10);
System.out.println(" tryAcquire 10 availablePermits : " + limiter.availablePermits());
limiter.acquire(3);
System.out.println("acquire 3 availablePermits : " + limiter.availablePermits());
new Thread(() -> {
limiter.acquire(2);
System.out.println(" acquire 2 availablePermits : " + limiter.availablePermits());
}).start();
limiter.acquire(7);
System.out.println(" acquire 7 availablePermits : " + limiter.availablePermits());
limiter.acquire(1);
System.out.println(" acquire 1 availablePermits : " + limiter.availablePermits());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
limiter.acquire(7);
System.out.println(" acquire 7 availablePermits : " + limiter.availablePermits());
limiter.delete();
}
@Test
public void mapDemo() {
RBucket<MyBucket> myBucket = redissonClient.getBucket("myBucket");
myBucket.set(new MyBucket(), 1, TimeUnit.MINUTES);
System.out.println(myBucket.get());
myBucket.rename("myBucket1");
RBucket<MyBucket> myBucket1 = redissonClient.getBucket("myBucket");
System.out.println(myBucket1.get());
RBucket<MyBucket> myBucket2 = redissonClient.getBucket("myBucket1");
System.out.println(myBucket2.get());
}
@Data
public static class MyBucket {
private String name = "test";
private int age = 10;
}
}
分布式集合
package com.example.redissondemo.test;
import com.alibaba.fastjson.JSONObject;
import com.example.redissondemo.RedissonDemoApplication;
import com.example.redissondemo.test.domain.Order;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.redisson.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = RedissonDemoApplication.class)
@Slf4j
public class RedissonCollectionsExampleTests {
@Autowired
private RedissonClient redissonClient;
@Test
public void mapTest() throws ExecutionException, InterruptedException {
String key = "user";
RMap<String, String> map = redissonClient.getMap(key);
map.put("name", "zhangsan");
map.put("age", "18");
String name = map.get("name");
System.out.println ("user name : " + name);
boolean b = map.containsKey("age");
System.out.println("has age ? : " + b);
Set<Map.Entry<String, String>> entries = map.entrySet();
System.out.println(Arrays.toString(entries.toArray()));
map.remove("age");
map.fastPut("like", "eat");
System.out.println(JSONObject.toJSONString(map));
map.fastRemove("like");
RFuture<String> putAsyncFuture = map.putAsync("321","");
RFuture<Boolean> booleanRFuture = map.fastPutAsync("123", "");
putAsyncFuture.get();
booleanRFuture.get();
System.out.println(JSONObject.toJSONString(map));
}
@Test
public void myMultimapTest(){
RSetMultimap<String, String> map = redissonClient.getSetMultimap("RSetMultimap");
map.put("age", "19");
map.put("age", "20");
map.put("name", "zhangsan");
Set<String> allValues = map.get("age");
System.out.println(allValues);
List<String> newValues = Arrays.asList("17", "16", "15");
Set<String> oldValues = map.replaceValues("age", newValues);
System.out.println(oldValues);
Set<String> removedValues = map.removeAll("age");
System.out.println(removedValues);
map.put("carCount", "2");
Set<Map.Entry<String, String>> entries = map.entries();
System.out.println(JSONObject.toJSONString(entries));
map.delete();
redissonClient.getListMultimap("myListMultimap");
RListMultimapCache<Object, Object> myListMultimap2 = redissonClient.getListMultimapCache("myListMultimap2");
myListMultimap2.expireKey("2", 10, TimeUnit.MINUTES);
RSetMultimapCache<Object, Object> getSetMultimapCache = redissonClient.getSetMultimapCache("getSetMultimapCache");
getSetMultimapCache.expireKey("2", 10, TimeUnit.MINUTES);
}
@Test
public void baseSet(){
RSet<Order> set1 = redissonClient.getSet("anySet");
set1.add(new Order());
set1.remove(new Order());
RSetCache<Object> set2 = redissonClient.getSetCache("anySet2");
set2.add(new Order(), 10, TimeUnit.SECONDS);
RSortedSet<Integer> set = redissonClient.getSortedSet("anySet");
set.trySetComparator(Comparator.comparingInt(a -> a));
set.add(3);
set.add(1);
set.add(2);
set.removeAsync(0);
set.addAsync(5);
}
@Test
public void baseListAndQueue(){
RList<Order> list = redissonClient.getList("anyList");
list.add(new Order());
Order order = list.get(0);
list.remove(new Order());
RQueue<Order> queue1 = redissonClient.getQueue("anyQueue");
RDeque<Order> queue2 = redissonClient.getDeque("anyDeque");
RBlockingQueue<Order> queue3= redissonClient.getBlockingQueue("anyQueue");
RBoundedBlockingQueue<Order> queue4 = redissonClient.getBoundedBlockingQueue("anyQueue");
RDelayedQueue<Order> delayedQueue = redissonClient.getDelayedQueue(queue1);
RPriorityQueue<Integer> queue = redissonClient.getPriorityQueue("anyQueue");
}
}
分布式锁
redisson分布式锁学习
private void redissonDoc() throws InterruptedException {
RLock lock = redissonClient.getLock("generalLock");
lock.lock();
boolean res1 = lock.tryLock(10, TimeUnit.SECONDS);
lock.lock(10, TimeUnit.SECONDS);
boolean res2 = lock.tryLock(100, 10, TimeUnit.SECONDS);
RLock fairLock = redissonClient.getFairLock("fairLock");
RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("readWriteLock");
readWriteLock.readLock().lock();
readWriteLock.writeLock().lock();
}