How to use

getListMultimap

method

in

org.redisson.api.RedissonClient

@Override
public void emit(K key, V value) {
  try {
    ByteBuf encodedKey = codec.getValueEncoder().encode(key);
    long hash = Hash.hash64(encodedKey);
    encodedKey.release();
    int part = (int) Math.abs(hash % parts);
    String partName = name + ":" + part;
    
    RListMultimap<K, V> multimap = client.getListMultimap(partName, codec);
    multimap.put(key, value);
    if (timeout > 0 && !expirationsBitSet.get(part)) {
      multimap.expire(timeout, TimeUnit.MILLISECONDS);
      expirationsBitSet.set(part);
    }
  } catch (IOException e) {
    throw new IllegalArgumentException(e);
  }
}

@Override
public void emit(K key, V value) {
  try {
    ByteBuf encodedKey = codec.getValueEncoder().encode(key);
    long hash = Hash.hash64(encodedKey);
    encodedKey.release();
    int part = (int) Math.abs(hash % parts);
    String partName = name + ":" + part;
    
    RListMultimap<K, V> multimap = client.getListMultimap(partName, codec);
    multimap.put(key, value);
    if (timeout > 0 && !expirationsBitSet.get(part)) {
      multimap.expire(timeout, TimeUnit.MILLISECONDS);
      expirationsBitSet.set(part);
    }
  } catch (IOException e) {
    throw new IllegalArgumentException(e);
  }
}

@Override
public void run() {
  try {
    this.codec = (Codec) codecClass.getConstructor().newInstance();
  } catch (Exception e) {
    throw new IllegalArgumentException(e);
  }
  
  Injector.inject(reducer, redisson);
  
  RMap<KOut, VOut> map = redisson.getMap(resultMapName);
  RListMultimap<KOut, VOut> multimap = redisson.getListMultimap(name, codec);
  for (KOut key : multimap.keySet()) {
    if (Thread.currentThread().isInterrupted()) {
      break;
    }
    List<VOut> values = multimap.get(key);
    VOut out = reducer.reduce(key, values.iterator());
    map.put(key, out);
  }
  if (timeout > 0) {
    map.expire(timeout, TimeUnit.MILLISECONDS);
  }
  multimap.delete();
}

@Override
public void run() {
  try {
    this.codec = (Codec) codecClass.getConstructor().newInstance();
  } catch (Exception e) {
    throw new IllegalArgumentException(e);
  }
  
  Injector.inject(reducer, redisson);
  
  RMap<KOut, VOut> map = redisson.getMap(resultMapName);
  RListMultimap<KOut, VOut> multimap = redisson.getListMultimap(name, codec);
  for (KOut key : multimap.keySet()) {
    if (Thread.currentThread().isInterrupted()) {
      break;
    }
    List<VOut> values = multimap.get(key);
    VOut out = reducer.reduce(key, values.iterator());
    map.put(key, out);
  }
  if (timeout > 0) {
    map.expire(timeout, TimeUnit.MILLISECONDS);
  }
  multimap.delete();
}

 @Override
 public void removeJobScripts(String jobId) {
  redissonClient.<String, JobScript>getListMultimap(JobConfig.JOB_INFO_SCRIPT).removeAll(jobId);
 }
}

@Override
public List<JobScript> queryJobScripts(String jobId) {
 return redissonClient.<String, JobScript>getListMultimap(JobConfig.JOB_INFO_SCRIPT)
   .getAll(jobId);
}

@Override
public void addJobRecordStatus(JobRecordStatus recordStatus) {
 RListMultimap<String, JobRecordStatus> listMultimap = redissonClient
   .getListMultimap(JobConfig.RECORD_STATUS);
 listMultimap.put(recordStatus.getLoggerId(), recordStatus);
}

@Override
public String bindLog(String jobId) {
 String id = UUID.randomUUID().toString();
 redissonClient.<String, String>getMap(JobConfig.LOG_BIND).put(id, jobId);
 redissonClient.<String, String>getListMultimap(JobConfig.LOG_REL).put(jobId, id);
 return id;
}

@Override
public int countJobRecords(String groupKey, String jobKey, String jobId) {
 RListMultimap<String, String> sortmap = redissonClient.getListMultimap(JobConfig.RECORD_SORT);
 if (jobId != null && jobId.length() > 0) {
  return sortmap.get(jobId).size();
 }
 String key = Constants.EMPTY;
 if (groupKey != null && groupKey.length() > 0) {
  key = groupKey;
 }
 if (jobKey != null && jobKey.length() > 0) {
  key = String.join(Constants.COLON, key, jobKey);
 }
 return sortmap.get(key).size();
}

@Override
public void emit(K key, V value) {
  try {
    ByteBuf encodedKey = codec.getValueEncoder().encode(key);
    long hash = Hash.hash64(encodedKey);
    encodedKey.release();
    int part = (int) Math.abs(hash % parts);
    String partName = name + ":" + part;
    
    RListMultimap<K, V> multimap = client.getListMultimap(partName, codec);
    multimap.put(key, value);
    if (timeout > 0 && !expirationsBitSet.get(part)) {
      multimap.expire(timeout, TimeUnit.MILLISECONDS);
      expirationsBitSet.set(part);
    }
  } catch (IOException e) {
    throw new IllegalArgumentException(e);
  }
}

@Override
public void removeLogger(String jobId) {
 RMap<String, String> map = redissonClient.getMap(JobConfig.LOG_BIND);
 for (String id : redissonClient.<String, String>getListMultimap(JobConfig.LOG_REL)
   .removeAll(jobId)) {
  map.remove(id);
 }
}

@Override
public void pauseJob(String jobId) {
 RListMultimap<String, String> listmap = getRedissonClient().getListMultimap(JobConfig.TASK_ID);
 RScheduledExecutorService service = getRedissonClient().getExecutorService(JobConfig.WORKER);
 Iterator<String> it = listmap.get(jobId).iterator();
 while (it.hasNext()) {
  String id = it.next();
  service.cancelTask(id);
  it.remove();
 }
}

@Override
public String addSimpleJob(String jobId, long timestamp) {
 String taskId = getRedissonClient().getExecutorService(JobConfig.WORKER)
   .scheduleAsync(new JobDispatchWrapper(jobId),
     timestamp - ZonedDateTime.now().toInstant().toEpochMilli(), TimeUnit.MILLISECONDS)
   .getTaskId();
 getRedissonClient().<String, String>getListMultimap(JobConfig.TASK_ID).put(jobId, taskId);
 return taskId;
}

@Override
public JobExecuteRecord findJobExecuteRecordById(String id) {
 RMap<String, JobExecuteRecord> map = redissonClient.getMap(JobConfig.RECORD);
 JobExecuteRecord record = map.get(id);
 RListMultimap<String, JobRecordStatus> recordStatus = redissonClient
   .getListMultimap(JobConfig.RECORD_STATUS);
 List<JobRecordStatus> statuses = recordStatus.getAll(id);
 statuses.forEach(r -> r.fill(record));
 record.setRecordStatuses(statuses);
 return record;
}

@Override
public void addJobScript(JobScript script) {
 RListMultimap<String, JobScript> scriptList = redissonClient
   .getListMultimap(JobConfig.JOB_INFO_SCRIPT);
 script.setId(UUID.randomUUID().toString());
 script.setTime(Date.from(ZonedDateTime.now().toInstant()));
 scriptList.put(script.getJobId(), script);
 if (scriptList.get(script.getJobId()).size() > 20) {
  scriptList.get(script.getJobId()).remove(0);
 }
}

@Override
public void addJob(JobInfo jobInfo) {
 RMap<String, JobInfo> map = redissonClient.getMap(JobConfig.JOB_INFO);
 jobInfo.setId(UUID.randomUUID().toString());
 RList<String> sortList = redissonClient.getList(JobConfig.JOB_INFO_SORT);
 sortList.add(jobInfo.getId());
 // script
 if (JobInfo.TYPE.SCRIPT.name().equals(jobInfo.getType())) {
  JobScript script = new JobScript();
  script.setId(UUID.randomUUID().toString());
  script.setJobId(jobInfo.getId());
  script.setScript(jobInfo.getScript());
  script.setTime(Date.from(ZonedDateTime.now().toInstant()));
  script.setVersion("default");
  redissonClient.<String, JobScript>getListMultimap(JobConfig.JOB_INFO_SCRIPT)
    .put(jobInfo.getId(), script);
 }
 jobInfo.setScript(null);
 map.put(jobInfo.getId(), jobInfo);
}

@Override
public String addDelayJob(String jobId, long initDelay, long delay) {
 String taskId = getRedissonClient().getExecutorService(JobConfig.WORKER)
   .scheduleAtFixedRateAsync(new JobDispatchWrapper(jobId), initDelay, delay, TimeUnit.SECONDS)
   .getTaskId();
 getRedissonClient().<String, String>getListMultimap(JobConfig.TASK_ID).put(jobId, taskId);
 return taskId;
}

@Override
public void removeJobRecords(String jobId) {
 RMap<String, JobExecuteRecord> map = redissonClient.getMap(JobConfig.RECORD);
 RListMultimap<String, String> sortmap = redissonClient.getListMultimap(JobConfig.RECORD_SORT);
 List<String> list = sortmap.removeAll(jobId);
 RListMultimap<String, JobRecordStatus> statusMultimap = redissonClient
   .getListMultimap(JobConfig.RECORD_STATUS);
 JobGroup group = findJobInfoById(jobId).getGroup();
 for (String key : list) {
  sortmap.get(Constants.EMPTY).remove(key);
  if (group != null) {
   sortmap.get(group.getGroupKey()).remove(key);
   sortmap.get(String.join(Constants.COLON, group.getGroupKey(), group.getJobKey()))
     .remove(key);
  }
  statusMultimap.removeAll(key);
  map.remove(key);
  redissonClient.getKeys().delete(String.format(JobConfig.EVENT_SHARDING, jobId, key));
 }
}

@Override
public String addCronJob(String jobId, String cron) {
 String taskId = getRedissonClient().getExecutorService(JobConfig.WORKER)
   .scheduleAsync(new JobDispatchWrapper(jobId), CronSchedule.of(cron)).getTaskId();
 getRedissonClient().<String, String>getListMultimap(
   JobConfig.TASK_ID).put(jobId, taskId);
 return taskId;
}

@Override
public JobInfo findJobInfoById(String id) {
 RMap<String, JobInfo> map = redissonClient.getMap(JobConfig.JOB_INFO);
 JobInfo jobInfo = map.get(id);
 if (jobInfo == null) {
  return jobInfo;
 }
 RListMultimap<String, JobScript> scriptList = redissonClient
   .getListMultimap(JobConfig.JOB_INFO_SCRIPT);
 RList<JobScript> list = scriptList.get(id);
 int size = list.size();
 if (size > 0) {
  JobScript script = list.get(size - 1);
  jobInfo.setScript(script.getScript());
 }
 return jobInfo;
}