redis redisson 集合的使用案例(RList、Rset、RMap)

public interface RList<V> extends List<V>, RExpirable, RListAsync<V>, RSortable<List<V>>, RandomAccess {

     List<V> get( int ... var1);              //获取指定的节点值

     int addAfter(V var1, V var2);          //在var1前添加var2

     int addBefore(V var1, V var2);         //在var1后添加var2

     void fastSet( int var1, V var2);        //修改var1处的只为var2

     List<V> readAll();                     //获取链表的所有值

     RList<V> subList( int var1, int var2);  //获取var1到var2的子链表

     List<V> range( int var1);               //返回var1往后的链表

     List<V> range( int var1, int var2);     //返回var1到var2的链表

     void trim( int var1, int var2);         //保留var1到var2处的链表，其余删除

     void fastRemove( int var1);             //删除var1处的值

     boolean remove(Object var1, int var2); //判断元素是否删除

     <KOut, VOut> RCollectionMapReduce<V, KOut, VOut> mapReduce();  //mapreduce操作

}

public interface RSet<V> extends Set<V>, RExpirable, RSetAsync<V>, RSortable<Set<V>> { 

     V removeRandom();

     Set<V> removeRandom( int var1);     //删除对象

     V random();

     Set<V> random( int var1);           //随机返回对象

     boolean move(String var1, V var2); //判断集合var1中是否存在var2，类似contains()方法

     Set<V> readAll();                  //获取所有对象

     int union(String... var1);         //集合并集对象个数

     Set<V> readUnion(String... var1);  //集合并集

     int diff(String... var1);          //集合差集对象个数

     Set<V> readDiff(String... var1);   //集合差集

     int intersection(String... var1);         //集合交集的对象个数

     Set<V> readIntersection(String... var1);  //集合交集

     Iterator<V> iterator( int var1);

     Iterator<V> iterator(String var1, int var2);

     Iterator<V> iterator(String var1);        //遍历集合

     <KOut, VOut> RCollectionMapReduce<V, KOut, VOut> mapReduce(); 

     RSemaphore getSemaphore(V var1);

     RCountDownLatch getCountDownLatch(V var1);

     RPermitExpirableSemaphore getPermitExpirableSemaphore(V var1);  //信号量

     RLock getLock(V var1);

     RLock getFairLock(V var1);

     RReadWriteLock getReadWriteLock(V var1); //锁操作

     Stream<V> stream( int var1);

     Stream<V> stream(String var1, int var2);

     Stream<V> stream(String var1);          //流操作

}

public interface RMap<K, V> extends ConcurrentMap<K, V>, RExpirable, RMapAsync<K, V> {

     void loadAll( boolean var1, int var2);

     void loadAll(Set<? extends K> var1, boolean var2, int var3);

     V get(Object var1);                       //获取var1的值

     V put(K var1, V var2);                    //添加对象

     V putIfAbsent(K var1, V var2);            //对象不存在则设置

     V replace(K var1, V var2);                //替换对象

     boolean replace(K var1, V var2, V var3);  //替换对象

     V remove(Object var1);                    //移除对象

     boolean remove(Object var1, Object var2); //移除对象

     void putAll(Map<? extends K, ? extends V> var1);

     void putAll(Map<? extends K, ? extends V> var1, int var2);   //添加对象

     Map<K, V> getAll(Set<K> var1);                               //获取key在集合var1中的键值对

     int valueSize(K var1);                   //key为var1的value大小

     V addAndGet(K var1, Number var2);        //key为var1的value加var2

     long fastRemove(K... var1);              //移除对象

     boolean fastPut(K var1, V var2);         //添加对象

     boolean fastReplace(K var1, V var2);     //替换key为var1的值为var2

     boolean fastPutIfAbsent(K var1, V var2); //如果不存在则设置

     Set<K> readAllKeySet();                  //获取所有key，以set形式返回

     Collection<V> readAllValues();           //获取所有value，以collection返回

     Set<Entry<K, V>> readAllEntrySet();      //遍历键值对

     Map<K, V> readAllMap();                  //集合形式转换为map类型

     Set<K> keySet();

     Set<K> keySet( int var1);

     Set<K> keySet(String var1, int var2);

     Set<K> keySet(String var1);              //获取key集合

     Collection<V> values();

     Collection<V> values(String var1);

     Collection<V> values(String var1, int var2);

     Collection<V> values( int var1);          //获取所有value

     Set<Entry<K, V>> entrySet();

     Set<Entry<K, V>> entrySet(String var1);

     Set<Entry<K, V>> entrySet(String var1, int var2);

     Set<Entry<K, V>> entrySet( int var1);     //遍历键值对

     <KOut, VOut> RMapReduce<K, V, KOut, VOut> mapReduce(); 

     RSemaphore getSemaphore(K var1);

     RCountDownLatch getCountDownLatch(K var1);

     RPermitExpirableSemaphore getPermitExpirableSemaphore(K var1);  //信号量操作

     RLock getLock(K var1);

     RLock getFairLock(K var1);

     RReadWriteLock getReadWriteLock(K var1);  //锁操作

}

public class MyTest {

     public static void main(String[] args){

         Config config= new Config();

         config.useSingleServer().setAddress( "redis://******:6379" ).setPassword( "123456" );

         RedissonClient client= Redisson.create(config);

          RList<String> list=client.getList( "list" );

         for ( int i= 0 ;i< 10 ;i++){

             list.add( "瓜田李下 " +i);

         }

         list.readAll().forEach(System.out::println);

         System.out.println( "list的数量为：" +list.size()+ "\n" );

         RSet<String> set=client.getSet( "set" );

         for ( int i= 0 ;i< 10 ;i++){

             set.add( "瓜田李下 " +i);

         }

         for (String s : set) {

             System.out.println(s);

         }

         System.out.println( "set的大小为：" +set.size()+ "\n" );

         RMap<Integer,String> map=client.getMap( "map" );

         for ( int i= 0 ;i< 10 ;i++){

             map.put(i, "瓜田李下 " +i);

         }

         for (Map.Entry<Integer,String> entry:map.entrySet()){

             System.out.println(entry.getKey()+ " ==> " +entry.getValue());

         }

         System.out.println( "map的大小为：" +map.size());

     }

}

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.serializer.SerializerFeature;

import io.netty.buffer.ByteBuf;

import io.netty.buffer.ByteBufAllocator;

import io.netty.buffer.ByteBufInputStream;

import io.netty.buffer.ByteBufOutputStream;

import org.redisson.client.codec.BaseCodec;

import org.redisson.client.protocol.Decoder;

import org.redisson.client.protocol.Encoder;​

import java.io.IOException;

​

public class FastjsonCodec extends BaseCodec {​

  private final Encoder encoder = in -> {

  ByteBuf out = ByteBufAllocator.DEFAULT.buffer();

  try {

  ByteBufOutputStream os = new ByteBufOutputStream(out);

  JSON.writeJSONString(os, in,SerializerFeature.WriteClassName);

  return os.buffer();

  } catch (IOException e) {

  out.release();

  throw e;

  } catch (Exception e) {

  out.release();

  throw new IOException(e);

  }

  };

​

  private final Decoder<Object> decoder = (buf, state) ->

  JSON.parseObject( new ByteBufInputStream(buf), Object. class );

​

  @Override

  public Decoder<Object> getValueDecoder() {

  return decoder;

  }

​

  @Override

  public Encoder getValueEncoder() {

  return encoder;

  }

}