jedis例子

@Test public void testDiscoverNodesAutomatically(){
  Set<HostAndPort> jedisClusterNode=new HashSet<HostAndPort>();
  jedisClusterNode.add(new HostAndPort("127.0.0.1",7379));
  JedisCluster jc=new JedisCluster(jedisClusterNode);
  assertEquals(3,jc.getClusterNodes().size());
}

@Test public void testCalculateConnectionPerSlot(){
  Set<HostAndPort> jedisClusterNode=new HashSet<HostAndPort>();
  jedisClusterNode.add(new HostAndPort("127.0.0.1",7379));
  JedisCluster jc=new JedisCluster(jedisClusterNode);
  jc.set("foo","bar");
  jc.set("test","test");
  assertEquals("bar",node3.get("foo"));
  assertEquals("test",node2.get("test"));
}

@Test public void testRecalculateSlotsWhenMoved() throws InterruptedException {
  Set<HostAndPort> jedisClusterNode=new HashSet<HostAndPort>();
  jedisClusterNode.add(new HostAndPort("127.0.0.1",7379));
  JedisCluster jc=new JedisCluster(jedisClusterNode);
  int slot51=JedisClusterCRC16.getSlot("51");
  node2.clusterDelSlots(slot51);
  node3.clusterDelSlots(slot51);
  node3.clusterAddSlots(slot51);
  JedisClusterTestUtil.waitForClusterReady(node1,node2,node3);
  jc.set("51","foo");
  assertEquals("foo",jc.get("51"));
}

@Test public void testAskResponse() throws InterruptedException {
  Set<HostAndPort> jedisClusterNode=new HashSet<HostAndPort>();
  jedisClusterNode.add(new HostAndPort("127.0.0.1",7379));
  JedisCluster jc=new JedisCluster(jedisClusterNode);
  int slot51=JedisClusterCRC16.getSlot("51");
  node3.clusterSetSlotImporting(slot51,JedisClusterTestUtil.getNodeId(node2.clusterNodes()));
  node2.clusterSetSlotMigrating(slot51,JedisClusterTestUtil.getNodeId(node3.clusterNodes()));
  jc.set("51","foo");
  assertEquals("foo",jc.get("51"));
}

@Test(expected=JedisClusterException.class) public void testThrowExceptionWithoutKey(){
  Set<HostAndPort> jedisClusterNode=new HashSet<HostAndPort>();
  jedisClusterNode.add(new HostAndPort("127.0.0.1",7379));
  JedisCluster jc=new JedisCluster(jedisClusterNode);
  jc.ping();
}

@Test(expected=JedisClusterMaxRedirectionsException.class) public void testRedisClusterMaxRedirections(){
  Set<HostAndPort> jedisClusterNode=new HashSet<HostAndPort>();
  jedisClusterNode.add(new HostAndPort("127.0.0.1",7379));
  JedisCluster jc=new JedisCluster(jedisClusterNode);
  int slot51=JedisClusterCRC16.getSlot("51");
  node2.clusterSetSlotMigrating(slot51,JedisClusterTestUtil.getNodeId(node3.clusterNodes()));
  jc.set("51","foo");
}

@Test public void testClusterCountKeysInSlot(){
  Set<HostAndPort> jedisClusterNode=new HashSet<HostAndPort>();
  jedisClusterNode.add(new HostAndPort(nodeInfo1.getHost(),nodeInfo1.getPort()));
  JedisCluster jc=new JedisCluster(jedisClusterNode);
  for (int index=0; index < 5; index++) {
    jc.set("foo{bar}" + index,"hello");
  }
  int slot=JedisClusterCRC16.getSlot("foo{bar}");
  assertEquals(5,node1.clusterCountKeysInSlot(slot).intValue());
}

private void setSuperConnectionHandler(JedisClusterConnectionHandler handler){
  try {
    Field connectionHandlerField=JedisCluster.class.getDeclaredField("connectionHandler");
    connectionHandlerField.setAccessible(true);
    connectionHandlerField.set(this,handler);
  }
 catch (  Exception e) {
    e.printStackTrace();
  }
}

/** 
 * Store a job in Redis
 * @param jobDetail       the {@link JobDetail} object to be stored
 * @param replaceExisting if true, any existing job with the same group and name as the given job will be overwritten
 * @param jedis           a thread-safe Redis connection
 * @throws ObjectAlreadyExistsException
 */
@Override @SuppressWarnings("unchecked") public void storeJob(JobDetail jobDetail,boolean replaceExisting,JedisCluster jedis) throws ObjectAlreadyExistsException {
  final String jobHashKey=redisSchema.jobHashKey(jobDetail.getKey());
  final String jobDataMapHashKey=redisSchema.jobDataMapHashKey(jobDetail.getKey());
  final String jobGroupSetKey=redisSchema.jobGroupSetKey(jobDetail.getKey());
  if (!replaceExisting && jedis.exists(jobHashKey)) {
    throw new ObjectAlreadyExistsException(jobDetail);
  }
  jedis.hmset(jobHashKey,(Map<String,String>)mapper.convertValue(jobDetail,new TypeReference<HashMap<String,String>>(){
  }
));
  if (jobDetail.getJobDataMap() != null && !jobDetail.getJobDataMap().isEmpty()) {
    jedis.hmset(jobDataMapHashKey,getStringDataMap(jobDetail.getJobDataMap()));
  }
  jedis.sadd(redisSchema.jobsSet(),jobHashKey);
  jedis.sadd(redisSchema.jobGroupsSet(),jobGroupSetKey);
  jedis.sadd(jobGroupSetKey,jobHashKey);
}

/** 
 * Remove the given job from Redis
 * @param jobKey the job to be removed
 * @param jedis  a thread-safe Redis connection
 * @return true if the job was removed; false if it did not exist
 */
@Override public boolean removeJob(JobKey jobKey,JedisCluster jedis) throws JobPersistenceException {
  final String jobHashKey=redisSchema.jobHashKey(jobKey);
  final String jobDataMapHashKey=redisSchema.jobDataMapHashKey(jobKey);
  final String jobGroupSetKey=redisSchema.jobGroupSetKey(jobKey);
  final String jobTriggerSetKey=redisSchema.jobTriggersSetKey(jobKey);
  Long delJobHashKeyResponse=jedis.del(jobHashKey);
  jedis.del(jobDataMapHashKey);
  jedis.srem(redisSchema.jobsSet(),jobHashKey);
  jedis.srem(jobGroupSetKey,jobHashKey);
  Set<String> jobTriggerSetResponse=jedis.smembers(jobTriggerSetKey);
  jedis.del(jobTriggerSetKey);
  Long jobGroupSetSizeResponse=jedis.scard(jobGroupSetKey);
  if (jobGroupSetSizeResponse == 0) {
    jedis.srem(redisSchema.jobGroupsSet(),jobGroupSetKey);
  }
  for (  String triggerHashKey : jobTriggerSetResponse) {
    final TriggerKey triggerKey=redisSchema.triggerKey(triggerHashKey);
    final String triggerGroupSetKey=redisSchema.triggerGroupSetKey(triggerKey);
    unsetTriggerState(triggerHashKey,jedis);
    jedis.srem(redisSchema.triggersSet(),triggerHashKey);
    jedis.srem(redisSchema.triggerGroupsSet(),triggerGroupSetKey);
    jedis.srem(triggerGroupSetKey,triggerHashKey);
    jedis.del(triggerHashKey);
  }
  return delJobHashKeyResponse == 1;
}
 

/** 
 * Remove (delete) the <code> {@link Trigger}</code> with the given key.
 * @param triggerKey          the key of the trigger to be removed
 * @param removeNonDurableJob if true, the job associated with the given trigger will be removed if it is non-durableand has no other triggers
 * @param jedis               a thread-safe Redis connection
 * @return true if the trigger was found and removed
 */
@Override protected boolean removeTrigger(TriggerKey triggerKey,boolean removeNonDurableJob,JedisCluster jedis) throws JobPersistenceException, ClassNotFoundException {
  final String triggerHashKey=redisSchema.triggerHashKey(triggerKey);
  final String triggerGroupSetKey=redisSchema.triggerGroupSetKey(triggerKey);
  if (!jedis.exists(triggerHashKey)) {
    return false;
  }
  OperableTrigger trigger=retrieveTrigger(triggerKey,jedis);
  final String jobHashKey=redisSchema.jobHashKey(trigger.getJobKey());
  final String jobTriggerSetKey=redisSchema.jobTriggersSetKey(trigger.getJobKey());
  jedis.srem(redisSchema.triggersSet(),triggerHashKey);
  jedis.srem(triggerGroupSetKey,triggerHashKey);
  jedis.srem(jobTriggerSetKey,triggerHashKey);
  if (jedis.scard(triggerGroupSetKey) == 0) {
    jedis.srem(redisSchema.triggerGroupsSet(),triggerGroupSetKey);
  }
  if (removeNonDurableJob) {
    Long jobTriggerSetKeySizeResponse=jedis.scard(jobTriggerSetKey);
    Boolean jobExistsResponse=jedis.exists(jobHashKey);
    if (jobTriggerSetKeySizeResponse == 0 && jobExistsResponse) {
      JobDetail job=retrieveJob(trigger.getJobKey(),jedis);
      if (!job.isDurable()) {
        removeJob(job.getKey(),jedis);
        signaler.notifySchedulerListenersJobDeleted(job.getKey());
      }
    }
  }
  if (isNullOrEmpty(trigger.getCalendarName())) {
    jedis.srem(redisSchema.calendarTriggersSetKey(trigger.getCalendarName()),triggerHashKey);
  }
  unsetTriggerState(triggerHashKey,jedis);
  jedis.del(triggerHashKey);
  return true;
}

/** 
 * Unsets the state of the given trigger key by removing the trigger from all trigger state sets.
 * @param triggerHashKey the redis key of the desired trigger hash
 * @param jedis          a thread-safe Redis connection
 * @return true if the trigger was removed, false if the trigger was stateless
 * @throws JobPersistenceException if the unset operation failed
 */
@Override public boolean unsetTriggerState(String triggerHashKey,JedisCluster jedis) throws JobPersistenceException {
  boolean removed=false;
  List<Long> responses=new ArrayList<>(RedisTriggerState.values().length);
  for (  RedisTriggerState state : RedisTriggerState.values()) {
    responses.add(jedis.zrem(redisSchema.triggerStateKey(state),triggerHashKey));
  }
  for (  Long response : responses) {
    removed=response == 1;
    if (removed) {
      jedis.del(redisSchema.triggerLockKey(redisSchema.triggerKey(triggerHashKey)));
      break;
    }
  }
  return removed;
}
 

/** 
 * Store a  {@link Calendar}
 * @param name            the name of the calendar
 * @param calendar        the calendar object to be stored
 * @param replaceExisting if true, any existing calendar with the same name will be overwritten
 * @param updateTriggers  if true, any existing triggers associated with the calendar will be updated
 * @param jedis           a thread-safe Redis connection
 * @throws JobPersistenceException
 */
@Override public void storeCalendar(String name,Calendar calendar,boolean replaceExisting,boolean updateTriggers,JedisCluster jedis) throws JobPersistenceException {
  final String calendarHashKey=redisSchema.calendarHashKey(name);
  if (!replaceExisting && jedis.exists(calendarHashKey)) {
    throw new ObjectAlreadyExistsException(String.format("Calendar with key %s already exists.",calendarHashKey));
  }
  Map<String,String> calendarMap=new HashMap<>();
  calendarMap.put(CALENDAR_CLASS,calendar.getClass().getName());
  try {
    calendarMap.put(CALENDAR_JSON,mapper.writeValueAsString(calendar));
  }
 catch (  JsonProcessingException e) {
    throw new JobPersistenceException("Unable to serialize calendar.",e);
  }
  jedis.hmset(calendarHashKey,calendarMap);
  jedis.sadd(redisSchema.calendarsSet(),calendarHashKey);
  if (updateTriggers) {
    final String calendarTriggersSetKey=redisSchema.calendarTriggersSetKey(name);
    Set<String> triggerHashKeys=jedis.smembers(calendarTriggersSetKey);
    for (    String triggerHashKey : triggerHashKeys) {
      OperableTrigger trigger=retrieveTrigger(redisSchema.triggerKey(triggerHashKey),jedis);
      long removed=jedis.zrem(redisSchema.triggerStateKey(RedisTriggerState.WAITING),triggerHashKey);
      trigger.updateWithNewCalendar(calendar,misfireThreshold);
      if (removed == 1) {
        setTriggerState(RedisTriggerState.WAITING,(double)trigger.getNextFireTime().getTime(),triggerHashKey,jedis);
      }
    }
  }
}
 

/** 
 * Remove (delete) the <code> {@link Calendar}</code> with the given name.
 * @param calendarName the name of the calendar to be removed
 * @param jedis        a thread-safe Redis connection
 * @return true if a calendar with the given name was found and removed
 */
@Override public boolean removeCalendar(String calendarName,JedisCluster jedis) throws JobPersistenceException {
  final String calendarTriggersSetKey=redisSchema.calendarTriggersSetKey(calendarName);
  if (jedis.scard(calendarTriggersSetKey) > 0) {
    throw new JobPersistenceException(String.format("There are triggers pointing to calendar %s, so it cannot be removed.",calendarName));
  }
  final String calendarHashKey=redisSchema.calendarHashKey(calendarName);
  Long deleteResponse=jedis.del(calendarHashKey);
  jedis.srem(redisSchema.calendarsSet(),calendarHashKey);
  return deleteResponse == 1;
}
 

/** 
 * Get the keys of all of the <code> {@link Job}</code> s that have the given group name.
 * @param matcher the matcher with which to compare group names
 * @param jedis   a thread-safe Redis connection
 * @return the set of all JobKeys which have the given group name
 */
@Override public Set<JobKey> getJobKeys(GroupMatcher<JobKey> matcher,JedisCluster jedis){
  Set<JobKey> jobKeys=new HashSet<>();
  if (matcher.getCompareWithOperator() == StringMatcher.StringOperatorName.EQUALS) {
    final String jobGroupSetKey=redisSchema.jobGroupSetKey(new JobKey("",matcher.getCompareToValue()));
    final Set<String> jobs=jedis.smembers(jobGroupSetKey);
    if (jobs != null) {
      for (      final String job : jobs) {
        jobKeys.add(redisSchema.jobKey(job));
      }
    }
  }
 else {
    List<Set<String>> jobGroups=new ArrayList<>();
    for (    final String jobGroupSetKey : jedis.smembers(redisSchema.jobGroupsSet())) {
      if (matcher.getCompareWithOperator().evaluate(redisSchema.jobGroup(jobGroupSetKey),matcher.getCompareToValue())) {
        jobGroups.add(jedis.smembers(jobGroupSetKey));
      }
    }
    for (    Set<String> jobGroup : jobGroups) {
      if (jobGroup != null) {
        for (        final String job : jobGroup) {
          jobKeys.add(redisSchema.jobKey(job));
        }
      }
    }
  }
  return jobKeys;
}