redis.clients.jedis.JedisPubSub Java Examples

private void subscribe(){
    this.redisTemplate.operate(new RedisCallBack() {
        @Override
        public Object operate(Jedis jedis) {
            jedis.subscribe(new JedisPubSub() {
                @Override
                public void onMessage(String channel, String message) {
                    log.debug("[Cluster] rec message from redis channel:{}",channel);
                    CommandReqOrResp request = new CommandReqOrResp(CommandCode.MESSAGE_CLUSTER_TRANSFER,JSONObject.parseObject(message,
                            Message.class));
                    consumeClusterMessage(request);
                }
            },T_REDIS);
            return null;
        }
    });
}
 

public void run() {
    try (Jedis jedis = Pool.getResource()) {

        jedis.configSet("notify-keyspace-events","KEA");

        jedis.psubscribe(new JedisPubSub() {
            @Override
            public void onPMessage(String pattern, String channel, String message) {
                System.out.println("Keyspace Changes: " + pattern + " " + channel + " " + message);

            }

        }, "__key*__:*");
    } catch (Exception e){
        e.printStackTrace();
    }
}
 

@Override
public void destroy() throws Exception {
    if (__inited) {
        __inited = false;
        //
        for (Map.Entry<String, JedisPubSub> _entry : __pubSubs.entrySet()) {
            _entry.getValue().unsubscribe();
        }
        __subscribePool.shutdown();
        __subscribePool = null;
        //
        for (IRedisDataSourceAdapter _adapter : __dataSourceCaches.values()) {
            _adapter.destroy();
        }
        __dataSourceCaches = null;
        __moduleCfg = null;
        __owner = null;
    }
}
 

/**
 *
 * @param redisConnection redis 连接类
 * @param channels 订阅的频道列表
 */
public MessageConsumerRedisImpl(RedisConnection redisConnection, String[] channels) {
    Jedis jedis = null;
    try {
        if (channels != null && channels.length > 0) {
            jedis = redisConnection.getJedis();
            jedis.subscribe(new JedisPubSub() {
                @Override
                public void onMessage(String channel, String message) {
                    System.out.println("receive " + message + " from " + channel);
                    handleMessage(message);
                }
            }, channels);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (jedis != null) {
            jedis.close();
        }
    }
}
 

@SuppressWarnings("static-access")
@Override
public void run() {
	Thread.currentThread().setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
		@Override
		public void uncaughtException(Thread arg0, Throwable arg1) {
			logger.error("[error]{}:{}",slaveRedis.getIp(), slaveRedis.getPort(), arg1);
			Cat.logError(arg1);
			redisStatCheckResult.put(slaveRedis, Boolean.FALSE);
			if (null != slave) {
				slave.close();
			}
		}
	});

	logger.debug("[Psubscribe]{}:{}", slaveRedis.getIp(), slaveRedis.getPort());
	slave.psubscribe(new JedisPubSub() {
		@Override
		public void onPMessage(String pattern, String channel, String msg) {
			logger.debug("[OnPMessage]{}:{}", slaveRedis.getIp(), slaveRedis.getPort());
			redisStatCheckResult.put(slaveRedis, Boolean.TRUE);
		}
	}, generateURL(masterRedis.getIp(), masterRedis.getPort()));
}
 

@PostConstruct
public void init() {
    new Thread() {
        @Override
        public void run() {
            redisDao.subscribe(new JedisPubSub() {
                @Override
                public void onMessage(String pchannel, String message) {
                    logger.info("redis通知，channel={},message={}", pchannel, message);
                    if (channel.equals(pchannel)) {
                        updateCache();
                    }
                }
            }, channel);
        }
    }.start();

    updateCache();
}
 

@PostConstruct
public void init() {
    new Thread() {
        @Override
        public void run() {
            redisDao.subscribe(new JedisPubSub() {
                @Override
                public void onMessage(String pchannel, String message) {
                    logger.info("redis通知，channel={},message={}", pchannel, message);
                    if (channel.equals(pchannel)) {
                        updateCache();
                    }
                }
            }, channel);
        }
    }.start();

    updateCache();
}
 

/**
 * 调用jedis的subscribe()方法
 *
 * @param jedisPubSub
 * @param channels
 */
public static void subscribe(JedisPubSub jedisPubSub, String... channels) {
    Jedis jedis = null;
    try {
        jedis = getResource();
        jedis.subscribe(jedisPubSub, channels);
    } catch (Exception e) {
        logger.warn("psubscribe channels==> {} exception==> {}", channels, e);
    } finally {
        close(jedis);
    }
}
 

public void run(){
    try (Jedis jedis = Pool.getResource()) {
        jedis.subscribe(new JedisPubSub() {
            @Override
            public void onMessage(String channel, String message) {
                System.out.println("Subscriber : " + message);
            }
        }, "channel");
    } catch (Exception e){
        e.printStackTrace();
    }
}
 

@Override
public void psubscribe(JedisPubSub jedisPubSub, String... patterns) {
	redis.clients.jedis.Jedis delegate = pool.getResource();
	try {
		delegate.psubscribe(jedisPubSub, patterns);
	} finally {
		pool.returnResource(delegate);
	}
}
 

@Override
public void subscribe(JedisPubSub jedisPubSub, String... channels) {
	redis.clients.jedis.Jedis delegate = pool.getResource();
	try {
		delegate.subscribe(jedisPubSub, channels);
	} finally {
		pool.returnResource(delegate);
	}
}
 

@Override
public void subscribe(final String dsName, final JedisPubSub jedisPubSub, final String... channels) {
    String _key = dsName + "@" + jedisPubSub.getClass().getName() + ":" + StringUtils.join(channels, '|');
    if (!__pubSubs.containsKey(_key)) {
        __pubSubs.put(_key, jedisPubSub);
        __subscribePool.execute(new Runnable() {
            @Override
            public void run() {
                while (__inited) {
                    try {
                        openSession(dsName, new IRedisSessionExecutor<Object>() {
                            @Override
                            public Void execute(IRedisSession session) throws Exception {
                                session.getCommandHolder().getJedis().subscribe(jedisPubSub, channels);
                                return null;
                            }
                        });
                    } catch (Exception e) {
                        _LOG.error("Redis connection [" + dsName + "] has been interrupted and is constantly trying to reconnect....", RuntimeUtils.unwrapThrow(e));
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e1) {
                            break;
                        }
                    }
                }
            }
        });
    }
}
 

/**
 * 订阅给定的一个或多个频道的信息
 *
 * @param jedisPubSub
 * @param channels
 */
public void subscribe(final JedisPubSub jedisPubSub, final String... channels) {
    redisTemplate.execute(new RedisCallback<Object>() {
        @Override
        public Object doInRedis(RedisConnection connection) throws DataAccessException {
            ((Jedis) connection.getNativeConnection()).subscribe(jedisPubSub, channels);
            return null;
        }
    });
}
 

RedisShardSubscription(
    JedisPubSub subscriber,
    InterruptingRunnable onUnsubscribe,
    Consumer<JedisCluster> onReset,
    Supplier<List<String>> subscriptions,
    RedisClient client) {
  this.subscriber = subscriber;
  this.onUnsubscribe = onUnsubscribe;
  this.onReset = onReset;
  this.subscriptions = subscriptions;
  this.client = client;
}
 

@Override
public void psubscribe(JedisPubSub jedisPubSub, String... patterns) {
  Span span = helper.buildSpan("psubscribe");
  span.setTag("patterns", Arrays.toString(patterns));
  try {
    super.psubscribe(jedisPubSub, patterns);
  } catch (Exception e) {
    onError(e, span);
    throw e;
  } finally {
    span.finish();
  }
}
 

@Override
public void subscribe(JedisPubSub jedisPubSub, String... channels) {
  Span span = helper.buildSpan("subscribe");
  span.setTag("channels", Arrays.toString(channels));
  try {
    super.subscribe(jedisPubSub, channels);
  } catch (Exception e) {
    onError(e, span);
    throw e;
  } finally {
    span.finish();
  }
}
 

@Override
public void subscribe(JedisPubSub jedisPubSub, String... channels) {
  Span span = helper.buildSpan("subscribe");
  span.setTag("channels", Arrays.toString(channels));
  try {
    super.subscribe(jedisPubSub, channels);
  } catch (Exception e) {
    onError(e, span);
    throw e;
  } finally {
    span.finish();
  }
}
 

@Override
public void psubscribe(JedisPubSub jedisPubSub, String... patterns) {
  Span span = helper.buildSpan("psubscribe");
  span.setTag("patterns", Arrays.toString(patterns));
  try {
    super.psubscribe(jedisPubSub, patterns);
  } catch (Exception e) {
    onError(e, span);
    throw e;
  } finally {
    span.finish();
  }
}
 

public static void main(String[] args){
    Jedis jedis = new Jedis("192.168.108.130" , 6379);
    jedis.subscribe(new JedisPubSub() {
        @Override
        public void onMessage(String channel, String message) {
            System.out.println("receive channel ["+channel+"] message ["+message+"]");
        }
    } , "aliTV" , "googleTV");
}
 

/**
 * 调用jedis的psubscribe()方法
 *
 * @param jedisPubSub
 * @param patterns
 */
public static void psubscribe(JedisPubSub jedisPubSub, String... patterns) {
    Jedis jedis = null;
    try {
        jedis = getResource();
        jedis.psubscribe(jedisPubSub, patterns);
    } catch (Exception e) {
        logger.warn("psubscribe patterns==> {} exception==> {}", patterns, e);
    } finally {
        close(jedis);
    }
}
 

@Override
public void subscribe(final JedisPubSub jedisPubSub, final String... channels) {
	new EnhancedJedisClusterCommand<Integer>(connectionHandler, maxAttempts) {
		@Override
		public Integer doExecute(Jedis connection) {
			connection.subscribe(jedisPubSub, channels);
			return 0;
		}
	}.runWithAnyNode();
}
 

@Override
public void psubscribe(final JedisPubSub jedisPubSub, final String... patterns) {
	new EnhancedJedisClusterCommand<Integer>(connectionHandler, maxAttempts) {
		@Override
		public Integer doExecute(Jedis connection) {
			connection.psubscribe(jedisPubSub, patterns);
			return 0;
		}
	}.runWithAnyNode();
}
 

public void subscribe(final JedisPubSub jedisPubSub, final String... channels) {
    execute(new JedisExecutor<Void>() {
        @Override
        Void doInJedis(Jedis jedis) {
            jedis.subscribe(jedisPubSub, channels);
            return null;
        }
    });
}
 

public void subscribe(final JedisPubSub jedisPubSub, final String... channels) {
    if (cluster) {
        jedisCluster.subscribe(jedisPubSub, channels);
    } else {
        jedisOperator.subscribe(jedisPubSub, channels);
    }
}
 

DefaultRedisPubSub(JedisPubSub jps) {
	this.jps = jps;
}
 

@Override
public void psubscribe(JedisPubSub jedisPubSub, String... patterns) {
	super.psubscribe(jedisPubSub, patterns);
}
 

@Override
public void subscribe(JedisPubSub jedisPubSub, String... channels) {
	super.subscribe(jedisPubSub, channels);
}
 

@Override
public void subscribe(JedisPubSub jedisPubSub, String... channels) {
    subscribe(__moduleCfg.getDataSourceDefaultName(), jedisPubSub, channels);
}
 

private void startRead(String keyPrefix) {
    if (!readStarted.compareAndSet(false, true)) {
        System.out.println("Read already started!");
        return;
    }

    if (keyPrefix == null || keyPrefix.trim().equals("")) {
        keyPrefix = defaultKeyPrefix;
    }

    System.out.println(String.format("Start reading %d records with keyPrefix: %s", total, keyPrefix));

    final String finalKeyPrefix = keyPrefix;
    final AtomicLong totalDelay = new AtomicLong();
    final AtomicLong counter = new AtomicLong();
    final SettableFuture<Boolean> readCompleted = SettableFuture.create();

    executorService.submit(new Runnable() {
        @Override
        public void run() {
            try {
                readCompleted.get();
                double avgDelay = (double) totalDelay.get() / (double) (total);
                System.out.println(String.format("Read completed, average delay is: %s ms", decimalFormat.format
                        (avgDelay)));
            } catch (Throwable ex) {
                ex.printStackTrace();
            }
        }
    });

    executorService.submit(new Runnable() {
        @Override
        public void run() {
            final Jedis slaveJedis = createJedis("localhost", 6379);
            slaveJedis.psubscribe(new JedisPubSub() {
                @Override
                public void onPMessage(String pattern, String channel, String message) {
                    totalDelay.addAndGet(System.currentTimeMillis() - Long.valueOf(message));
                    long current = counter.incrementAndGet();
                    if (current != 0 && current % countIndicator == 0) {
                        System.out.println(String.format("%d records read", current));
                    }
                    if (current >= total) {
                        readCompleted.set(true);
                    }
                }
            }, String.format("%s*", finalKeyPrefix));
        }
    });
}
 

public JedisPubSub getSubscriber() {
  return subscriber;
}