Java TopicConnectionFactory.createTopicConnection方法代碼示例

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
/**
 * @param args
 * @throws JMSException
 * @throws IOException
 */
public static void main(String[] args) throws JMSException, IOException {
	
	if (args.length != 1) {
		System.out.println("User Name is required....");
	} else {
		userId = args[0];
		ApplicationContext ctx = new ClassPathXmlApplicationContext(
				"com/springtraining/jms/spring-config.xml");

		BasicJMSChat basicJMSChat = (BasicJMSChat) ctx
				.getBean("basicJMSChat");
		TopicConnectionFactory topicConnectionFactory = (TopicConnectionFactory) basicJMSChat.chatJMSTemplate
				.getConnectionFactory();
		TopicConnection tc = topicConnectionFactory.createTopicConnection();

		basicJMSChat.publish(tc,  basicJMSChat.chatTopic, userId);
		basicJMSChat.subscribe(tc,  basicJMSChat.chatTopic, basicJMSChat);
	}
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
public TopicConnection getTopicConnection(TopicConnectionFactory tcf, String uniqueID )
		throws JMSException {

	final TopicConnection tc;
	final String username = Config.parms.getString("us");
	if (username != null && username.length() != 0) {
		Log.logger.log(Level.INFO, "getTopicConnection(): authenticating as \"" + username + "\"");
		final String password = Config.parms.getString("pw");
		tc = tcf.createTopicConnection(username, password);
	} else {
		tc = tcf.createTopicConnection();
	}

	if (durable) {
		// Note: change signature to match getConnection
		setDurableConnectionId( tc, ((WorkerThread)Thread.currentThread()), uniqueID );
	} // end if durable

	return tc;

}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
public JMSSink(final String tcfBindingName, final String topicBindingName, final String username,
               final String password) {

   try {
      final Context ctx = new InitialContext();
      final TopicConnectionFactory topicConnectionFactory = (TopicConnectionFactory) lookup(ctx,
              tcfBindingName);

      final TopicConnection topicConnection =
              topicConnectionFactory.createTopicConnection(username,
                      password);
      topicConnection.start();

      final TopicSession topicSession = topicConnection.createTopicSession(false,
              Session.AUTO_ACKNOWLEDGE);

      final Topic topic = (Topic) ctx.lookup(topicBindingName);

      final TopicSubscriber topicSubscriber = topicSession.createSubscriber(topic);

      topicSubscriber.setMessageListener(this);

   } catch (final Exception e) {
      logger.error("Could not read JMS message.", e);
   }
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
public static Topic createTopic(String uri, String topicName) throws JMSException {
	TopicConnectionFactory connectionFactory = null;
	TopicConnection connection = null;
	TopicSession session = null;
	Topic topic = null;
	try {
		connectionFactory = new ActiveMQConnectionFactory(uri);
		connection = connectionFactory.createTopicConnection();
		connection.start();
		session = connection.createTopicSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
		topic = session.createTopic(topicName);
		session.commit();
	} finally {
		closeQuietly(session);
		closeQuietly(connection);
	}
	return topic;
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
/**
 * Product message for assigned topic.
 * 
 * @param uri
 *            e.g.: tcp://3CNL12096:61616
 * @param queueName
 *            name of queue
 * @throws JMSException
 */
public static void publishTextMsg2Topic(String uri, String topicName, String text) throws JMSException {
	TopicConnectionFactory connectionFactory = null;
	TopicConnection connection = null;
	TopicSession session = null;
	TopicPublisher tp = null;
	try {
		connectionFactory = new ActiveMQConnectionFactory(uri);
		connection = connectionFactory.createTopicConnection();
		connection.start();
		session = connection.createTopicSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
		tp = session.createPublisher(session.createTopic(topicName));
		tp.setDeliveryMode(DeliveryMode.PERSISTENT);
		tp.publish(session.createTextMessage(text));
		session.commit();
	} finally {
		closeQuietly(tp);
		closeQuietly(session);
		closeQuietly(connection);
	}
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
/**
 * {@inheritDoc}
 */
public void sendEnqueueMessage() {
    ServiceLocator locator = ServiceLocatorFactory.getLocator();
    final TopicConnectionFactory factory = (TopicConnectionFactory) locator.lookup(DEFAULT_QUEUE_CONN_FACTORY);
    final Topic topic = (Topic) locator.lookup(FileManagementMDB.QUEUE_JNDI_NAME);
    TopicConnection connection = null;
    TopicSession session = null;
    TopicPublisher publisher = null;
    try {
        connection = factory.createTopicConnection();
        session = connection.createTopicSession(true, 0);
        publisher = session.createPublisher(topic);
        
        final Message message = session.createTextMessage("enqueue");
        publisher.send(message);
    } catch (JMSException e) {
        LOG.error("Couldn't submit job to JMS", e);
    } finally {
        close(publisher);
        close(session);
        close(connection);
    }
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
@Parameters({ "broker-port"})
@Test
public void testSubscriberPublisher(String port) throws Exception {
    String topicName = "MyTopic1";
    int numberOfMessages = 100;

    InitialContext initialContext = ClientHelper
            .getInitialContextBuilder("admin", "admin", "localhost", port)
            .withTopic(topicName)
            .build();

    TopicConnectionFactory connectionFactory
            = (TopicConnectionFactory) initialContext.lookup(ClientHelper.CONNECTION_FACTORY);
    TopicConnection connection = connectionFactory.createTopicConnection();
    connection.start();

    // Initialize subscriber
    TopicSession subscriberSession = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
    Topic subscriberDestination = (Topic) initialContext.lookup(topicName);
    TopicSubscriber subscriber = subscriberSession.createSubscriber(subscriberDestination);

    // publish 100 messages
    TopicSession producerSession = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
    TopicPublisher producer = producerSession.createPublisher(subscriberDestination);

    for (int i = 0; i < numberOfMessages; i++) {
        producer.publish(producerSession.createTextMessage("Test message " + i));
    }

    producerSession.close();

    for (int i = 0; i < numberOfMessages; i++) {
        Message message = subscriber.receive(1000);
        Assert.assertNotNull(message, "Message #" + i + " was not received");
    }

    connection.close();
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
@Parameters({ "broker-port", "admin-username", "admin-password" })
@Test
public void testValidClientConnection(String port, String adminUsername, String adminPassword) throws Exception {
    String topicName = "MyTopic1";
    InitialContext initialContext = ClientHelper
            .getInitialContextBuilder(adminUsername, adminPassword, "localhost", port).withTopic(topicName).build();
    TopicConnectionFactory connectionFactory = (TopicConnectionFactory) initialContext
            .lookup(ClientHelper.CONNECTION_FACTORY);
    TopicConnection connection = connectionFactory.createTopicConnection();
    connection.start();
    connection.close();
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
@Parameters({ "broker-port", "admin-username" })
@Test(expectedExceptions = JMSException.class)
public void testInvalidClientConnection(String port, String adminUsername) throws Exception {
    String topicName = "MyTopic1";
    InitialContext initialContext = ClientHelper
            .getInitialContextBuilder(adminUsername, "invalidPassword", "localhost", port).withTopic(topicName)
            .build();
    TopicConnectionFactory connectionFactory = (TopicConnectionFactory) initialContext
            .lookup(ClientHelper.CONNECTION_FACTORY);
    connectionFactory.createTopicConnection();
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
@Before
public void setUp() throws Exception {
  cut = new DefaultJmsMessageConverter(new XStreamSerializer());
  TopicConnectionFactory connectionFactory = embeddedBroker.createConnectionFactory();
  topicConnection = connectionFactory.createTopicConnection();
  topicSession = topicConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
public synchronized void load() throws GenericServiceException {
    try {
        InitialContext jndi = JNDIContextFactory.getInitialContext(jndiServer);
        TopicConnectionFactory factory = (TopicConnectionFactory) jndi.lookup(jndiName);

        if (factory != null) {
            con = factory.createTopicConnection(userName, password);
            con.setExceptionListener(this);
            session = con.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
            topic = (Topic) jndi.lookup(topicName);
            if (topic != null) {
                TopicSubscriber subscriber = session.createSubscriber(topic);
                subscriber.setMessageListener(this);
                con.start();
                this.setConnected(true);
                if (Debug.infoOn()) Debug.logInfo("Listening to topic [" + topicName + "] on [" + jndiServer + "]...", module);
            } else {
                throw new GenericServiceException("Topic lookup failed.");
            }
        } else {
            throw new GenericServiceException("Factory (broker) lookup failed.");
        }
    } catch (NamingException ne) {
        throw new GenericServiceException("JNDI lookup problems; listener not running.", ne);
    } catch (JMSException je) {
        throw new GenericServiceException("JMS internal error; listener not running.", je);
    } catch (GeneralException ge) {
        throw new GenericServiceException("Problems with InitialContext; listener not running.", ge);
    }
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
/**
 * This implementation delegates to the {@code createTopicConnection(username, password)}
 * method of the target TopicConnectionFactory, passing in the specified user credentials.
 * If the specified username is empty, it will simply delegate to the standard
 * {@code createTopicConnection()} method of the target ConnectionFactory.
 * @param username the username to use
 * @param password the password to use
 * @return the Connection
 * @see javax.jms.TopicConnectionFactory#createTopicConnection(String, String)
 * @see javax.jms.TopicConnectionFactory#createTopicConnection()
 */
protected TopicConnection doCreateTopicConnection(String username, String password) throws JMSException {
	Assert.state(this.targetConnectionFactory != null, "'targetConnectionFactory' is required");
	if (!(this.targetConnectionFactory instanceof TopicConnectionFactory)) {
		throw new javax.jms.IllegalStateException("'targetConnectionFactory' is not a TopicConnectionFactory");
	}
	TopicConnectionFactory queueFactory = (TopicConnectionFactory) this.targetConnectionFactory;
	if (StringUtils.hasLength(username)) {
		return queueFactory.createTopicConnection(username, password);
	}
	else {
		return queueFactory.createTopicConnection();
	}
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
public synchronized void start() throws RestException {
    try {
        String jndiProviderUrl = String.format(PROVIDER_URL_FMT, jmsHost, jmsPort);
        String jndiFactory = JNDI_FACTORY;
        String jmsFactory = JMS_FACTORY;

        // Debug
        logger.debug("Creating JNDI connection to: " + jndiProviderUrl + " using factory: " + jndiFactory);

        // Initialize JNDI connection
        Properties env = new Properties();
        env.put(Context.INITIAL_CONTEXT_FACTORY, jndiFactory);
        env.put(Context.PROVIDER_URL, jndiProviderUrl);
        context = new InitialContext(env);

        // Debug
        logger.debug("Creating JMS connection using factory: " + jmsFactory + " user: " + jmsUser + " passwd: " + jmsPassword);

        // Create the JMS topic connection and start it
        TopicConnectionFactory topicConnectionFactory = (TopicConnectionFactory) context.lookup(jmsFactory);
        topicConnection = topicConnectionFactory.createTopicConnection(jmsUser, jmsPassword);
        topicConnection.start();

        // Debug
        logger.debug("Subscribing to JMS topic: " + jmsTopic);

        // Create the subscriber
        Topic topic = (Topic) context.lookup(jmsTopic);
        TopicSession topicSession = topicConnection.createTopicSession(false, TopicSession.AUTO_ACKNOWLEDGE);
        createSubscriber(topicSession, topic);

        // Debug
        logger.info("JMS connection started");
    } catch (NamingException | JMSException ex) {
        throw new RestException(ex);
    }
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
public synchronized void start() throws RestException {
    try {

        // Debug
        logger.debug("Creating JMS connection using host: " + jmsHost + " user: " + jmsUser + " passwd: " + jmsPassword);

        // Create topic connection factory - connecting directly to VSD,
        // bypassing JNDI factory
        String brokerUrl = String.format(BROKER_URL_FMT, jmsHost, jmsPort);
        TopicConnectionFactory topicConnectionFactory = new ActiveMQConnectionFactory(brokerUrl);

        // Create the JMS topic connection and start it
        topicConnection = topicConnectionFactory.createTopicConnection(jmsUser, jmsPassword);
        topicConnection.start();

        // Debug
        logger.debug("Subscribing to JMS topic: " + jmsTopic);

        // Create the subscriber
        TopicSession topicSession = topicConnection.createTopicSession(false, TopicSession.AUTO_ACKNOWLEDGE);
        String[] topicSubNames = jmsTopic.split("/");
        String topicName = topicSubNames[topicSubNames.length - 2] + '/' + topicSubNames[topicSubNames.length - 1];
        Topic topic = topicSession.createTopic(topicName);
        createSubscriber(topicSession, topic);

        // Debug
        logger.info("JMS connection started");
    } catch (JMSException ex) {
        throw new RestException(ex);
    }
}
 

import javax.jms.TopicConnectionFactory; //導入方法依賴的package包/類
/**
 * Create all administrated objects connections and sessions ready to use for tests.
 * <br />
 * Start connections.
 */
@Override
@Before
public void setUp() throws Exception {
   super.setUp();

   try {
      // ...and creates administrated objects and binds them
      admin.createTopicConnectionFactory(PubSubTestCase.TCF_NAME);
      admin.createTopic(PubSubTestCase.TOPIC_NAME);

      Context ctx = admin.createContext();

      publisherTCF = (TopicConnectionFactory) ctx.lookup(PubSubTestCase.TCF_NAME);
      publisherTopic = (Topic) ctx.lookup(PubSubTestCase.TOPIC_NAME);
      publisherConnection = publisherTCF.createTopicConnection();
      publisherConnection.setClientID("publisherConnection");
      publisherSession = publisherConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
      publisher = publisherSession.createPublisher(publisherTopic);

      subscriberTCF = (TopicConnectionFactory) ctx.lookup(PubSubTestCase.TCF_NAME);
      subscriberTopic = (Topic) ctx.lookup(PubSubTestCase.TOPIC_NAME);
      subscriberConnection = subscriberTCF.createTopicConnection();
      subscriberConnection.setClientID("subscriberConnection");
      subscriberSession = subscriberConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
      subscriber = subscriberSession.createSubscriber(subscriberTopic);

      publisherConnection.start();
      subscriberConnection.start();
      // end of client step
   } catch (Exception e) {
      e.printStackTrace();
      throw new RuntimeException(e);
   }
}