Java ITopic類代碼示例

import com.hazelcast.core.ITopic; //導入依賴的package包/類
@Test
public void testThreeArgConstructorRegistersTopicListener() {
    MapConfig mapConfig = mock(MapConfig.class);

    Config config = mock(Config.class);
    when(config.findMapConfig(eq(CACHE_NAME))).thenReturn(mapConfig);

    ITopic<Object> topic = mock(ITopic.class);
    when(topic.addMessageListener(isNotNull(MessageListener.class))).thenReturn("ignored");

    HazelcastInstance instance = mock(HazelcastInstance.class);
    when(instance.getConfig()).thenReturn(config);
    when(instance.getTopic(eq(CACHE_NAME))).thenReturn(topic);

    new LocalRegionCache(CACHE_NAME, instance, null);
    verify(config).findMapConfig(eq(CACHE_NAME));
    verify(instance).getConfig();
    verify(instance).getTopic(eq(CACHE_NAME));
    verify(topic).addMessageListener(isNotNull(MessageListener.class));
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
private <T extends Serializable> void registerHazelcastEventPipe(final ITopic<DolphinEvent<T>> topic) {
    hazelcastEventPipeLock.lock();
    try {
        Assert.requireNonNull(topic, "hazelcastTopic");

        final String registrationId = topic.addMessageListener(new com.hazelcast.core.MessageListener<DolphinEvent<T>>() {
            @Override
            public void onMessage(com.hazelcast.core.Message<DolphinEvent<T>> message) {
                final DolphinEvent<T> event = message.getMessageObject();
                triggerEventHandling(event);
            }
        });
        Assert.requireNonBlank(registrationId, "registrationId");

        iTopicRegistrations.put(topic.getName(), registrationId);
        iTopicCount.put(topic.getName(), 1);
    } finally {
        hazelcastEventPipeLock.unlock();
    }
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
private <T extends Serializable> void unregisterHazelcastEventPipe(final ITopic<DolphinEvent<T>> topic) {
    hazelcastEventPipeLock.lock();
    try {
        Assert.requireNonNull(topic, "hazelcastTopic");

        final Integer count = iTopicCount.get(topic.getName());
        if (count == null || count != 1) {
            throw new IllegalStateException("Count for topic " + topic.getName() + " is wrong: " + count);
        }

        final String registrationId = iTopicRegistrations.get(topic.getName());
        Assert.requireNonBlank(registrationId, "registrationId");

        topic.removeMessageListener(registrationId);

        iTopicRegistrations.remove(topic.getName());
        iTopicCount.remove(topic.getName());
    } finally {
        hazelcastEventPipeLock.unlock();
    }
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
@Test
public void addMessageListener() throws InterruptedException {
    HazelcastClient hClient = getHazelcastClient();
    ITopic<String> topic = hClient.getTopic("addMessageListener");
    final CountDownLatch latch = new CountDownLatch(1);
    final String message = "Hazelcast Rocks!";
    topic.addMessageListener(new MessageListener<String>() {
        public void onMessage(Message<String> msg) {
            if (msg.getMessageObject().equals(message)) {
                latch.countDown();
            }
        }
    });
    topic.publish(message);
    assertTrue(latch.await(10000, TimeUnit.MILLISECONDS));
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
@Test
    public void removeMessageListener() throws InterruptedException {
        HazelcastClient hClient = getHazelcastClient();
        ITopic<String> topic = hClient.getTopic("removeMessageListener");
        final CountDownLatch latch = new CountDownLatch(2);
        final CountDownLatch cp = new CountDownLatch(1);
//        final String message = "Hazelcast Rocks!";
        MessageListener<String> messageListener = new MessageListener<String>() {
            public void onMessage(Message<String> msg) {
//                if (msg.startsWith(message)) {
                System.out.println("Received " + msg + " at " + this);
                latch.countDown();
                cp.countDown();
//                }
            }
        };
        final String message = "message_" + messageListener.hashCode() + "_";
        topic.addMessageListener(messageListener);
        topic.publish(message + "1");
        cp.await();
        topic.removeMessageListener(messageListener);
        topic.publish(message + "2");
        Thread.sleep(50);
        assertEquals(1, latch.getCount());
    }
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
@Test
public void testPerformance() throws InterruptedException {
    HazelcastClient hClient = getHazelcastClient();
    long begin = System.currentTimeMillis();
    int count = 10000;
    final ITopic topic = hClient.getTopic("perf");
    ExecutorService ex = Executors.newFixedThreadPool(10);
    final CountDownLatch l = new CountDownLatch(count);
    for (int i = 0; i < count; i++) {
        ex.submit(new Runnable() {
            public void run() {
                topic.publish("my object");
                l.countDown();
            }
        });
    }
    assertTrue(l.await(20, TimeUnit.SECONDS));
    long time = System.currentTimeMillis() - begin;
    System.out.println("per second: " + count * 1000 / time);
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
@Test
public void testSimpleUsage() {
    withHazelcast(3, hazelcastInstance -> {
        ITopic<String> topic = hazelcastInstance.getReliableTopic("default");

        List<String> receivedMessage = new ArrayList<>();
        topic.addMessageListener(message -> receivedMessage.add(message.getMessageObject()));

        topic.publish("Hello World");
        topic.publish("Hello Hazelcast!");

        assertThat(receivedMessage)
                .isEqualTo(Arrays.asList("Hello World", "Hello Hazelcast!"));

        assertThat(topic.getLocalTopicStats().getPublishOperationCount())
                .isEqualTo(2L);
        assertThat(topic.getLocalTopicStats().getReceiveOperationCount())
                .isEqualTo(2L);
    });
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
@Test
public void testWithRingbufferTtl() {
    withHazelcast(3, hazelcastInstance -> {
        ITopic<String> topic = hazelcastInstance.getReliableTopic("with-ttl");

        long start = System.currentTimeMillis();

        IntStream
                .rangeClosed(1, 10005)
                .forEach(i -> topic.publish("message-" + i));

        long elapsed = System.currentTimeMillis() - start;

        assertThat(topic.getLocalTopicStats().getPublishOperationCount())
                .isEqualTo(10005L);
        assertThat(topic.getLocalTopicStats().getReceiveOperationCount())
                .isEqualTo(0L);

        assertThat(elapsed)
                .isGreaterThanOrEqualTo(30 * 1000L);
    });
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
@Setup
@SuppressWarnings("unchecked")
public void setup() {
    totalMessagesSend = targetInstance.getAtomicLong(name + ":TotalExpectedCounter");
    topics = new ITopic[topicCount];
    listeners = new LinkedList<MessageListenerImpl>();

    String[] names = generateStringKeys(name, topicCount, keyLocality, targetInstance);

    int listenerIdCounter = 0;
    for (int i = 0; i < topics.length; i++) {
        ITopic<MessageEntity> topic = targetInstance.getReliableTopic(names[i]);
        topics[i] = topic;
        for (int l = 0; l < listenersPerTopic; l++) {
            MessageListenerImpl topicListener = new MessageListenerImpl(listenerIdCounter);
            listenerIdCounter++;
            topic.addMessageListener(topicListener);
            listeners.add(topicListener);
        }
    }
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
@Setup
public void setup() {
    totalExpectedCounter = targetInstance.getAtomicLong(name + ":TotalExpectedCounter");
    totalFoundCounter = targetInstance.getAtomicLong(name + ":TotalFoundCounter");

    topics = new ITopic[topicCount];
    listeners = new LinkedList<TopicListener>();
    for (int topicIndex = 0; topicIndex < topics.length; topicIndex++) {
        ITopic<Long> topic = targetInstance.getTopic(name + topicIndex);
        topics[topicIndex] = topic;

        for (int listenerIndex = 0; listenerIndex < listenersPerTopic; listenerIndex++) {
            TopicListener topicListener = new TopicListener();
            topic.addMessageListener(topicListener);
            listeners.add(topicListener);
        }
    }
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
@Test
public void doTest() {
    logger.info( "do test" );
    Hazelcast.addInstanceListener( this );

    ITopic<Object> topic = Hazelcast.getTopic( "default" );
    topic.addMessageListener( this );
    topic.publish( "my-message-object" );

    Collection<Instance> instances = Hazelcast.getInstances();
    for ( Instance instance : instances ) {
        logger.info( "ID: [" + instance.getId() + "] Type: [" + instance.getInstanceType() + "]" );
    }

    Set<Member> setMembers = Hazelcast.getCluster().getMembers();
    for ( Member member : setMembers ) {
        logger.info( "isLocalMember " + member.localMember() );
        logger.info( "member.inetsocketaddress " + member.getInetSocketAddress() );
    }
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
/**
 * Subscribe for Mule events under the specified topic name
 * <p/>
 * {@sample.xml ../../../doc/pubsub-module.xml.sample pubsub:listener}
 *
 * @param topic    Name of the topic
 * @param callback flow to process
 */
@Source(exchangePattern = MessageExchangePattern.ONE_WAY)
public void listener(String topic, final SourceCallback callback) {
    ITopic hazelcastTopic = HazelcastManager.getInstance().getHazelcastInstance().getTopic(topic);
    hazelcastTopic.addMessageListener(new MessageListener() {
        @Override
        public void onMessage(Message message) {
            Thread.currentThread().setContextClassLoader(muleContext.getExecutionClassLoader());

            MuleEvent newEvent = createMuleEvent(message);

            // process it
            try {
                callback.processEvent(newEvent);
            } catch (MuleException e) {
                LOGGER.error(e.getMessage(), e);
            }
        }
    });
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
/**
 * Creates an {@link ITopic} proxy on the combination of a
 * {@link TransactionalQueue} and an actual {@link ITopic} instance. The proxy
 * will offer items to the transactional queue when they are published on the
 * topic. All other topic methods are simply passed through to the underlying
 * topic. By offering items to the queue on publish, a transactional topic can
 * be simulated via the ITopic interface.
 *
 * @param <E> the type of items in the topic
 * @param queue the transactional queue to offer all published objects
 * @param topic the underlying topic to handle all other operations
 *
 * @return the proxy around the queue and topic
 */
@SuppressWarnings("unchecked")
public static <E> ITopic<E> createTopicProxy(
    final TransactionalQueue<E> queue, final ITopic<E> topic) {
  InvocationHandler handler = new InvocationHandler() {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {

      if (method.getName().equals("publish")) {
        return queue.offer((E) args[0]);
      }
      else {
        return method.invoke(topic, args);
      }
    }
  };

  return (ITopic<E>) Proxy.newProxyInstance(
      ITopic.class.getClassLoader(), new Class[]{ITopic.class},
      handler);
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
@Test
public void testPerformance() throws InterruptedException {
    HazelcastClient hClient = getHazelcastClient();
    long begin = Clock.currentTimeMillis();
    int count = 10000;
    final ITopic topic = hClient.getTopic("perf");
    ExecutorService ex = Executors.newFixedThreadPool(10);
    final CountDownLatch l = new CountDownLatch(count);
    for (int i = 0; i < count; i++) {
        ex.submit(new Runnable() {
            public void run() {
                topic.publish("my object");
                l.countDown();
            }
        });
    }
    assertTrue(l.await(20, TimeUnit.SECONDS));
    long time = Clock.currentTimeMillis() - begin;
    System.out.println("per second: " + count * 1000 / time);
}
 

import com.hazelcast.core.ITopic; //導入依賴的package包/類
public static void main(String[] args) {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        ITopic<String> topic = hz.getTopic("foo");
//        topic.addMessageListener(System.out::println);
        while(true){
            topic.publish("Hi from Anatole at " + new Date());
        }
    }