2 Replies Latest reply on Jan 28, 2015 1:52 AM by Markus Schwarz

    Remote Sender and Consumer JMS using HTTP in Wildfly 8.2

    Tássio Coêlho Newbie

      Hi,

       

      I can not make it work even in http.

       

      I followed all the documentation I found on the websites of Wildfly and HornetQ.

       

      I used Wildfly 8.2.

       

      I configured standalone.xml as more important excerpts below:

      -------------------------------------------------------------------------------------------------------------------------------------------------------

      <subsystem xmlns="urn:jboss:domain:messaging:2.0">

          <hornetq-server>

              <journal-file-size>102400</journal-file-size>

              <connectors>

                  <http-connector name="http-connector" socket-binding="http">

                      <param key="http-upgrade-endpoint" value="http-acceptor"/>

                  </http-connector>

                  <http-connector name="http-connector-throughput" socket-binding="http">

                      <param key="http-upgrade-endpoint" value="http-acceptor-throughput"/>

                      <param key="batch-delay" value="50"/>

                  </http-connector>

              </connectors>

        

              <acceptors>

                  <http-acceptor http-listener="default" name="http-acceptor"/>

                  <http-acceptor http-listener="default" name="http-acceptor-throughput">

                      <param key="batch-delay" value="50"/>

                      <param key="direct-deliver" value="false"/>

                  </http-acceptor>          

              </acceptors>

        

              <security-settings>

                  <security-setting match="#">

                      <permission type="send" roles="JMSRole"/>

                      <permission type="consume" roles="JMSRole"/>

                      <permission type="createNonDurableQueue" roles="JMSRole"/>

                      <permission type="deleteNonDurableQueue" roles="JMSRole"/>

                  </security-setting>

              </security-settings>

              <jms-connection-factories>

                  <connection-factory name="RemoteConnectionFactory">

                      <connectors>

                          <connector-ref connector-name="http-connector"/>

                      </connectors>

                      <entries>

                          <entry name="java:jboss/exported/jms/RemoteConnectionFactory"/>

                      </entries>

                      <ha>true</ha>

                      <block-on-acknowledge>true</block-on-acknowledge>

                      <retry-interval>1000</retry-interval>

                      <retry-interval-multiplier>1.0</retry-interval-multiplier>

                      <reconnect-attempts>-1</reconnect-attempts>

                  </connection-factory>

              </jms-connection-factories>

              <jms-destinations>

                  <jms-queue name="JMSOrderDownloadPage">

                      <entry name="java:/jms/queue/JMSOrderDownloadPage"/>

                      <durable>true</durable>

                      <entry name="java:jboss/exported/jms/queue/JMSOrderDownloadPage"/>

                  </jms-queue>

                  <jms-queue name="DLQ">

                      <entry name="java:/jms/queue/DLQ"/>

                      <durable>true</durable>

                  </jms-queue>

              </jms-destinations>

          </hornetq-server>

      </subsystem>

      -------------------------------------------------------------------------------------------------------------------------------------------------------


      I tried running the code below. Everything works correctly yet I ask the connectionFactory to create a new connection.


      -------------------------------------------------------------------------------------------------------------------------------------------------------

                  HornetQConnectionFactory connectionFactory = null;

                  Connection connection = null;

                  Session session = null;

                  MessageProducer producer = null;

                  MessageConsumer consumer = null;

                  Destination destination = null;

                  TextMessage message = null;

                  Context context = null;

       

                  try {

                      // Set up the context for the JNDI lookup

                      final Properties env = new Properties();

                      env.put(Context.INITIAL_CONTEXT_FACTORY, "org.jboss.naming.remote.client.InitialContextFactory");

                      env.put(Context.PROVIDER_URL, "http-remoting://www.xyz.com:8080");

                      env.put(Context.SECURITY_PRINCIPAL, "jmsuser");

                      env.put(Context.SECURITY_CREDENTIALS, "pass1");

                      env.put("jboss.naming.client.ejb.context", true);

                      context = new InitialContext(env);

       

                      connectionFactory = (HornetQConnectionFactory) context.lookup("jms/RemoteConnectionFactory"); //The lockup function correctly. Including authentication.

                      destination = (Destination) context.lookup("java:/jms/queue/JMSOrderDownloadPage");

                      connection = connectionFactory.createConnection("jmsuser", "pass1"); //At this time the error occurs following below, after the code.

                      session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

                      producer = session.createProducer(destination);

                      connection.start();

                      int count = Integer.parseInt("1");

                      String content = System.getProperty("message.content", "Hello, World!");

                      for (int i = 0; i < count; i++) {

                          message = session.createTextMessage(content);

                          producer.send(message);

                      }

                  } catch (Exception e) {

                    e.printStackTrace();

                }

      -------------------------------------------------------------------------------------------------------------------------------------------------------


      The StackTrace is:


      javax.jms.JMSException: Failed to create session factory

        at org.hornetq.jms.client.HornetQConnectionFactory.createConnectionInternal(HornetQConnectionFactory.java:673)

        at org.hornetq.jms.client.HornetQConnectionFactory.createConnection(HornetQConnectionFactory.java:112)

        at br.com.voelivre.finder.queue.search.alert.Start.main(Start.java:106)

      Caused by: HornetQNotConnectedException[errorType=NOT_CONNECTED message=HQ119007: Cannot connect to server(s). Tried with all available servers.]

        at org.hornetq.core.client.impl.ServerLocatorImpl.createSessionFactory(ServerLocatorImpl.java:905)

        at org.hornetq.jms.client.HornetQConnectionFactory.createConnectionInternal(HornetQConnectionFactory.java:669)

        ... 2 more

      -------------------------------------------------------------------------------------------------------------------------------------------------------


      I really appreciate any help.

        • 1. Re: Remote Sender and Consumer JMS using HTTP in Wildfly 8.2
          Tássio Coêlho Newbie

          Hi!

           

          After testing various configurations without success thank God I managed to find the solution. I share with the community so that it can help other friends in the future.

           

          My standalone.xml was as follows (highlighted the most important points):

           

          ---------------------------------------------------------------------------------------------------------------------------------------------------------------

          <?xml version='1.0' encoding='UTF-8'?>

           

           

          <server xmlns="urn:jboss:domain:2.2">

           

           

              <extensions>

                  <extension module="org.jboss.as.clustering.infinispan"/>

                  <extension module="org.jboss.as.connector"/>

                  <extension module="org.jboss.as.deployment-scanner"/>

                  <extension module="org.jboss.as.ee"/>

                  <extension module="org.jboss.as.ejb3"/>

                  <extension module="org.jboss.as.jaxrs"/>

                  <extension module="org.jboss.as.jdr"/>

                  <extension module="org.jboss.as.jmx"/>

                  <extension module="org.jboss.as.jpa"/>

                  <extension module="org.jboss.as.jsf"/>

                  <extension module="org.jboss.as.logging"/>

                  <extension module="org.jboss.as.messaging"/>

                  <extension module="org.jboss.as.naming"/>

                  <extension module="org.jboss.as.pojo"/>

                  <extension module="org.jboss.as.remoting"/>

                  <extension module="org.jboss.as.sar"/>

                  <extension module="org.jboss.as.security"/>

                  <extension module="org.jboss.as.transactions"/>

                  <extension module="org.jboss.as.weld"/>

                  <extension module="org.wildfly.extension.batch"/>

                  <extension module="org.wildfly.extension.io"/>

                  <extension module="org.wildfly.extension.undertow"/>

              </extensions>

           

           

              <management>

                  <security-realms>

                      <security-realm name="ManagementRealm">

                          <authentication>

                              <local default-user="$local" skip-group-loading="true"/>

                              <properties path="mgmt-users.properties" relative-to="jboss.server.config.dir"/>

                          </authentication>

                          <authorization map-groups-to-roles="false">

                              <properties path="mgmt-groups.properties" relative-to="jboss.server.config.dir"/>

                          </authorization>

                      </security-realm>

                      <security-realm name="ApplicationRealm">

                          <authentication>

                              <local default-user="$local" allowed-users="*" skip-group-loading="true"/>

                              <properties path="application-users.properties" relative-to="jboss.server.config.dir"/>

                          </authentication>

                          <authorization>

                              <properties path="application-roles.properties" relative-to="jboss.server.config.dir"/>

                          </authorization>

                      </security-realm>

                      <security-realm name="SSLRealm">

                          <server-identities>

                              <ssl>

                                  <keystore path="/xxx.../...tomcat.keystore" keystore-password="the password"/>

                              </ssl>

                          </server-identities>

                      </security-realm>

                  </security-realms>

                  <audit-log>

                      <formatters>

                          <json-formatter name="json-formatter"/>

                      </formatters>

                      <handlers>

                          <file-handler name="file" formatter="json-formatter" path="audit-log.log" relative-to="jboss.server.data.dir"/>

                      </handlers>

                      <logger log-boot="true" log-read-only="false" enabled="false">

                          <handlers>

                              <handler name="file"/>

                          </handlers>

                      </logger>

                  </audit-log>

                  <management-interfaces>

                      <http-interface security-realm="ManagementRealm" http-upgrade-enabled="true">

                          <socket-binding http="management-http"/>

                      </http-interface>

                  </management-interfaces>

                  <access-control provider="simple">

                      <role-mapping>

                          <role name="SuperUser">

                              <include>

                                  <user name="$local"/>

                              </include>

                          </role>

                      </role-mapping>

                  </access-control>

              </management>

           

           

              <profile>

                  <subsystem xmlns="urn:jboss:domain:logging:2.0">

                      <console-handler name="CONSOLE">

                          <level name="INFO"/>

                          <formatter>

                              <named-formatter name="COLOR-PATTERN"/>

                          </formatter>

                      </console-handler>

                      <periodic-rotating-file-handler name="FILE" autoflush="true">

                          <formatter>

                              <named-formatter name="PATTERN"/>

                          </formatter>

                          <file relative-to="jboss.server.log.dir" path="server.log"/>

                          <suffix value=".yyyy-MM-dd"/>

                          <append value="true"/>

                      </periodic-rotating-file-handler>

                      <logger category="com.arjuna">

                          <level name="WARN"/>

                      </logger>

                      <logger category="org.apache.tomcat.util.modeler">

                          <level name="WARN"/>

                      </logger>

                      <logger category="org.jboss.as.config">

                          <level name="DEBUG"/>

                      </logger>

                      <logger category="sun.rmi">

                          <level name="WARN"/>

                      </logger>

                      <logger category="jacorb">

                          <level name="WARN"/>

                      </logger>

                      <logger category="jacorb.config">

                          <level name="ERROR"/>

                      </logger>

                      <root-logger>

                          <level name="INFO"/>

                          <handlers>

                              <handler name="CONSOLE"/>

                              <handler name="FILE"/>

                          </handlers>

                      </root-logger>

                      <formatter name="PATTERN">

                          <pattern-formatter pattern="%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p [%c] (%t) %s%E%n"/>

                      </formatter>

                      <formatter name="COLOR-PATTERN">

                          <pattern-formatter pattern="%K{level}%d{HH:mm:ss,SSS} %-5p [%c] (%t) %s%E%n"/>

                      </formatter>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:batch:1.0">

                      <job-repository>

                          <in-memory/>

                      </job-repository>

                      <thread-pool>

                          <max-threads count="10"/>

                          <keepalive-time time="30" unit="seconds"/>

                      </thread-pool>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:datasources:2.0">

                      <datasources />

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:deployment-scanner:2.0">

                      <deployment-scanner path="deployments" relative-to="jboss.server.base.dir" scan-interval="5000"/>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:ee:2.0">

                      <spec-descriptor-property-replacement>false</spec-descriptor-property-replacement>

                      <concurrent>

                          <context-services>

                              <context-service name="default" jndi-name="java:jboss/ee/concurrency/context/default" use-transaction-setup-provider="true"/>

                          </context-services>

                          <managed-thread-factories>

                              <managed-thread-factory name="default" jndi-name="java:jboss/ee/concurrency/factory/default" context-service="default"/>

                          </managed-thread-factories>

                          <managed-executor-services>

                              <managed-executor-service name="default" jndi-name="java:jboss/ee/concurrency/executor/default" context-service="default" hung-task-threshold="60000" core-threads="5" max-threads="25" keepalive-time="5000"/>

                          </managed-executor-services>

                          <managed-scheduled-executor-services>

                              <managed-scheduled-executor-service name="default" jndi-name="java:jboss/ee/concurrency/scheduler/default" context-service="default" hung-task-threshold="60000" core-threads="2" keepalive-time="3000"/>

                          </managed-scheduled-executor-services>

                      </concurrent>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:ejb3:2.0">

                      <session-bean>

                          <stateful default-access-timeout="5000" cache-ref="simple" passivation-disabled-cache-ref="simple"/>

                          <singleton default-access-timeout="5000"/>

                      </session-bean>

           

           

                      <pools>

                          <bean-instance-pools>

                              <strict-max-pool name="slsb-strict-max-pool" max-pool-size="20" instance-acquisition-timeout="5" instance-acquisition-timeout-unit="MINUTES"/>

                              <strict-max-pool name="mdb-strict-max-pool" max-pool-size="20" instance-acquisition-timeout="5" instance-acquisition-timeout-unit="MINUTES"/>

                          </bean-instance-pools>

                      </pools>

                      <caches>

                          <cache name="simple"/>

                          <cache name="distributable" passivation-store-ref="infinispan" aliases="passivating clustered"/>

                      </caches>

                      <passivation-stores>

                          <passivation-store name="infinispan" cache-container="ejb" max-size="10000"/>

                      </passivation-stores>

                      <async thread-pool-name="default"/>

                      <timer-service thread-pool-name="default" default-data-store="default-file-store">

                          <data-stores>

                              <file-data-store name="default-file-store" path="timer-service-data" relative-to="jboss.server.data.dir"/>

                          </data-stores>

                      </timer-service>

                      <remote connector-ref="http-remoting-connector" thread-pool-name="default"/>

                      <thread-pools>

                          <thread-pool name="default">

                              <max-threads count="10"/>

                              <keepalive-time time="100" unit="milliseconds"/>

                          </thread-pool>

                      </thread-pools>

                      <default-security-domain value="other"/>

                      <default-missing-method-permissions-deny-access value="true"/>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:io:1.1">

                      <worker name="default"/>

                      <buffer-pool name="default"/>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:infinispan:2.0">

                      <cache-container name="web" default-cache="passivation" module="org.wildfly.clustering.web.infinispan">

                          <local-cache name="passivation" batching="true">

                              <file-store passivation="true" purge="false"/>

                          </local-cache>

                          <local-cache name="persistent" batching="true">

                              <file-store passivation="false" purge="false"/>

                          </local-cache>

                      </cache-container>

                      <cache-container name="ejb" default-cache="passivation" module="org.wildfly.clustering.ejb.infinispan" aliases="sfsb">

                          <local-cache name="passivation" batching="true">

                              <file-store passivation="true" purge="false"/>

                          </local-cache>

                          <local-cache name="persistent" batching="true">

                              <file-store passivation="false" purge="false"/>

                          </local-cache>

                      </cache-container>

                      <cache-container name="hibernate" default-cache="local-query" module="org.hibernate">

                          <local-cache name="entity">

                              <transaction mode="NON_XA"/>

                              <eviction strategy="LRU" max-entries="10000"/>

                              <expiration max-idle="100000"/>

                          </local-cache>

                          <local-cache name="local-query">

                              <transaction mode="NONE"/>

                              <eviction strategy="LRU" max-entries="10000"/>

                              <expiration max-idle="100000"/>

                          </local-cache>

                          <local-cache name="timestamps">

                              <transaction mode="NONE"/>

                              <eviction strategy="NONE"/>

                          </local-cache>

                      </cache-container>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:jaxrs:1.0"/>

                  <subsystem xmlns="urn:jboss:domain:jca:2.0">

                      <archive-validation enabled="true" fail-on-error="true" fail-on-warn="false"/>

                      <bean-validation enabled="true"/>

                      <default-workmanager>

                          <short-running-threads>

                              <core-threads count="50"/>

                              <queue-length count="50"/>

                              <max-threads count="50"/>

                              <keepalive-time time="10" unit="seconds"/>

                          </short-running-threads>

                          <long-running-threads>

                              <core-threads count="50"/>

                              <queue-length count="50"/>

                              <max-threads count="50"/>

                              <keepalive-time time="10" unit="seconds"/>

                          </long-running-threads>

                      </default-workmanager>

                      <cached-connection-manager/>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:jdr:1.0"/>

                  <subsystem xmlns="urn:jboss:domain:jmx:1.3">

                      <expose-resolved-model/>

                      <expose-expression-model/>

                      <remoting-connector/>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:jpa:1.1">

                      <jpa default-datasource="" default-extended-persistence-inheritance="DEEP"/>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:jsf:1.0"/>

                  <subsystem xmlns="urn:jboss:domain:messaging:2.0">

                      <hornetq-server>

                          <security-enabled>true</security-enabled>

                          <journal-file-size>102400</journal-file-size>

           

                          <connectors>

                              <http-connector name="http-connector" socket-binding="http">

                                  <param key="http-upgrade-endpoint" value="http-acceptor"/>

                              </http-connector>

                          </connectors>

           

                          <acceptors>

                              <http-acceptor http-listener="default" name="http-acceptor"/>

                          </acceptors>

           

                          <jms-connection-factories>

                              <connection-factory name="RemoteConnectionFactory">

                                  <connectors>

                                      <connector-ref connector-name="http-connector"/>

                                  </connectors>

                                  <entries>

                                      <entry name="java:jboss/exported/jms/RemoteConnectionFactory"/>

                                  </entries>

                                  <ha>true</ha>

                                  <block-on-acknowledge>true</block-on-acknowledge>

                                  <retry-interval>1000</retry-interval>

                                  <retry-interval-multiplier>1.0</retry-interval-multiplier>

                                  <reconnect-attempts>-1</reconnect-attempts>

                              </connection-factory>

                          </jms-connection-factories>

           

           

                         <security-settings>

                              <security-setting match="#">

                                  <permission type="send" roles="JMSRole"/>

                                  <permission type="consume" roles="JMSRole"/>

                                  <permission type="createNonDurableQueue" roles="JMSRole"/>

                                  <permission type="deleteNonDurableQueue" roles="JMSRole"/>

                              </security-setting>

                          </security-settings>

           

           

                          <address-settings>

                              <address-setting match="#">

                                  <dead-letter-address>jms.queue.DLQ</dead-letter-address>

                                  <expiry-address>jms.queue.ExpiryQueue</expiry-address>

                                  <expiry-delay>-1</expiry-delay>

                                  <redelivery-delay>0</redelivery-delay>

                                  <max-delivery-attempts>10</max-delivery-attempts>

                                  <max-size-bytes>10485760</max-size-bytes>

                                  <page-size-bytes>2097152</page-size-bytes>

                                  <page-max-cache-size>5</page-max-cache-size>

                                  <address-full-policy>PAGE</address-full-policy>

                                  <message-counter-history-day-limit>10</message-counter-history-day-limit>

                                  <last-value-queue>false</last-value-queue>

                                  <redistribution-delay>-1</redistribution-delay>

                                  <send-to-dla-on-no-route>false</send-to-dla-on-no-route>

                              </address-setting>

                          </address-settings>

           

           

                          <jms-destinations>

                              <jms-queue name="JMSOrderDownloadPage">

                                  <entry name="java:/jms/queue/JMSOrderDownloadPage"/>

                                  <durable>true</durable>

                                  <entry name="java:jboss/exported/jms/queue/JMSOrderDownloadPage"/>

                              </jms-queue>

                              <jms-queue name="DLQ">

                                  <entry name="java:/jms/queue/DLQ"/>

                                  <durable>true</durable>

                              </jms-queue>

                              <jms-queue name="ExpiryQueue">

                                  <entry name="java:/jms/queue/ExpiryQueue"/>

                                  <durable>true</durable>

                              </jms-queue>

                          </jms-destinations>

           

           

                      </hornetq-server>

                  </subsystem>

           

           

                  <subsystem xmlns="urn:jboss:domain:naming:2.0">

                      <remote-naming/>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:pojo:1.0"/>

                  <subsystem xmlns="urn:jboss:domain:remoting:2.0">

                      <endpoint worker="default"/>

                      <http-connector name="http-remoting-connector" connector-ref="default" security-realm="ApplicationRealm"/>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:resource-adapters:2.0"/>

                  <subsystem xmlns="urn:jboss:domain:sar:1.0"/>

                  <subsystem xmlns="urn:jboss:domain:security:1.2">

                      <security-domains>

                          <security-domain name="other" cache-type="default">

                              <authentication>

                                  <login-module code="Remoting" flag="optional">

                                      <module-option name="password-stacking" value="useFirstPass"/>

                                  </login-module>

                                  <login-module code="RealmDirect" flag="required">

                                      <module-option name="password-stacking" value="useFirstPass"/>

                                  </login-module>

                              </authentication>

                          </security-domain>

                          <security-domain name="jboss-web-policy" cache-type="default">

                              <authorization>

                                  <policy-module code="Delegating" flag="required"/>

                              </authorization>

                          </security-domain>

                          <security-domain name="jboss-ejb-policy" cache-type="default">

                              <authorization>

                                  <policy-module code="Delegating" flag="required"/>

                              </authorization>

                          </security-domain>

                      </security-domains>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:transactions:2.0">

                      <core-environment>

                          <process-id>

                              <uuid/>

                          </process-id>

                      </core-environment>

                      <recovery-environment socket-binding="txn-recovery-environment" status-socket-binding="txn-status-manager"/>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:undertow:1.2">

                      <buffer-cache name="default"/>

                      <server name="default-server">

                          <http-listener name="default" socket-binding="http" proxy-address-forwarding="true"/>

                          <https-listener name="https" socket-binding="https" security-realm="SSLRealm"/>

                          <host name="default-host" alias="localhost" default-web-module="voelivre-webservice-1.0.war"/>

                      </server>

                      <servlet-container name="default">

                          <jsp-config/>

                          <websockets/>

                      </servlet-container>

                      <handlers>

                          <file name="welcome-content" path="${jboss.home.dir}/welcome-content"/>

                      </handlers>

                      <filters>

                          <response-header name="server-header" header-name="Server" header-value="WildFly/8"/>

                          <response-header name="x-powered-by-header" header-name="X-Powered-By" header-value="Undertow/1"/>

                      </filters>

                  </subsystem>

                  <subsystem xmlns="urn:jboss:domain:weld:2.0"/>

              </profile>

           

              <interfaces>

                  <interface name="management">

                      <inet-address value="${jboss.bind.address.management:127.0.0.1}"/>

                  </interface>

                  <interface name="public">

                      <inet-address value="${jboss.bind.address:127.0.0.1}"/>

                  </interface>

                  <interface name="unsecure">

                      <inet-address value="${jboss.bind.address.unsecure:127.0.0.1}"/>

                  </interface>

              </interfaces>

           

           

              <socket-binding-group name="standard-sockets" default-interface="public" port-offset="${jboss.socket.binding.port-offset:0}">

                  <socket-binding name="management-http" interface="management" port="${jboss.management.http.port:9990}"/>

                  <socket-binding name="management-https" interface="management" port="${jboss.management.https.port:9993}"/>

                  <socket-binding name="ajp" port="${jboss.ajp.port:8009}"/>

                  <socket-binding name="http" port="${jboss.http.port:8080}"/>

                  <socket-binding name="https" port="${jboss.https.port:8443}"/>

                  <socket-binding name="txn-recovery-environment" port="4712"/>

                  <socket-binding name="txn-status-manager" port="4713"/>

              </socket-binding-group>

           

          </server>

          ---------------------------------------------------------------------------------------------------------------------------------------------------------------


          To test the configuration I used the following Java code:


          import java.util.Properties;

           

           

          import javax.jms.Connection;

          import javax.jms.Destination;

          import javax.jms.JMSContext;

          import javax.jms.JMSException;

          import javax.jms.MessageConsumer;

          import javax.jms.MessageProducer;

          import javax.jms.Session;

          import javax.jms.TextMessage;

          import javax.naming.Context;

          import javax.naming.InitialContext;

          import javax.naming.NamingException;

           

           

          import org.hornetq.jms.client.HornetQConnectionFactory;

           

           

          public class TestJMS {

           

           

            public static void main(String[] args) throws NamingException, JMSException {

           

           

            HornetQConnectionFactory connectionFactory = null;

            Connection connection = null;

            Session session = null;

            MessageProducer producer = null;

            MessageConsumer consumer = null;

            Destination destination = null;

            TextMessage message = null;

            Context context = null;

           

           

            try {

            final Properties env = new Properties();

            env.put(Context.INITIAL_CONTEXT_FACTORY, "org.jboss.naming.remote.client.InitialContextFactory");

            env.put(Context.PROVIDER_URL, "http-remoting://yourserver.com:8080");

            env.put(Context.SECURITY_PRINCIPAL, "jmsuser");

            env.put(Context.SECURITY_CREDENTIALS, "your password");

            context = new InitialContext(env);

           

           

            connectionFactory = (HornetQConnectionFactory) context.lookup("jms/RemoteConnectionFactory");

           

           

            System.out.println("lookup: jms/RemoteConnectionFactory success!");

           

           

            destination = (Destination) context.lookup("java:/jms/queue/JMSOrderDownloadPage");

           

           

            System.out.println("lookup: java:/jms/queue/JMSOrderDownloadPage success!");

           

           

            JMSContext createContext = connectionFactory.createContext("jmsuser", "your password", JMSContext.AUTO_ACKNOWLEDGE);

           

           

            System.out.println("connectionFactory.createContext success!");

           

           

            createContext.createConsumer(destination);

           

           

            System.out.println("createContext.createConsumer success!");

           

           

            connection = connectionFactory.createConnection("jmsuser", "your password");

           

           

            System.out.println("connectionFactory.createConnection success!");

           

           

            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

            producer = session.createProducer(destination);

           

           

            System.out.println("session.createProducer success!");

           

           

            connection.start();

           

           

            int count = Integer.parseInt("1");

            String content = "Hello, World!";

           

           

            // Send the specified number of messages

            for (int i = 0; i < count; i++) {

            message = session.createTextMessage(content);

            producer.send(message);

           

           

            System.out.println("Message sent successfully: " + message);

            }

           

           

            } catch (Exception e) {

           

           

            e.printStackTrace();

           

           

            } finally {

            if (context != null) {

            context.close();

            }

           

           

            // closing the connection takes care of the session, producer, and consumer

            if (connection != null) {

            connection.close();

            }

            }

           

           

            }

           

           

          }


          • 2. Re: Remote Sender and Consumer JMS using HTTP in Wildfly 8.2
            Markus Schwarz Newbie

            Hi,

            for me it is working, but as far as I remember I never touched the standalone.xml directly. I just created a user and a topic, and it worked. What I have done on a clean Wildfly 8.1.0.FINAL installation:

            • Add a user:
              • Run "JBOSS_HOME\bin\add-user"
                • Username "jmsuser"
                • Password "any"
                • Role "guest"
            • Create topic
              • Run "JBOSS_HOME/bin/jboss-cli"
              • In client interface enter:
                • connect
                • jms-topic add --topic-address=MyTopic --entries=topic/MyTopic,java:/jms/topic/MyTopic,java:jboss/exported/jms/topic/MyTopic
                • exit

             

            Now you can write your Java-Client like this:

             

            public class JmsTest {

              private static final String INITIAL_CONTEXT_FACTORY = "org.jboss.naming.remote.client.InitialContextFactory";

              private static final String PROVIDER_URL = "http-remoting://localhost:8080";

              private static final String DEFAULT_CONNECTION_FACTORY = "jms/RemoteConnectionFactory";

              private static final String TOPIC_NAME = "jms/topic/MyTopic";

              private static final String USERNAME = "jmsuser";

              private static final String PASSWORD = "any";

             

             

              private static JMSContext context = null;

              private static JMSConsumer consumer = null;

             

             

              public static void main(String[] args) throws Exception {

              final Properties env = new Properties();

              env.put(Context.INITIAL_CONTEXT_FACTORY, INITIAL_CONTEXT_FACTORY);

              env.put(Context.PROVIDER_URL, PROVIDER_URL);

              env.put(Context.SECURITY_PRINCIPAL, USERNAME);

              env.put(Context.SECURITY_CREDENTIALS, PASSWORD);

             

             

              final InitialContext iniCtx;

              final ConnectionFactory connectionFactory;

              final Destination destination;

             

             

              iniCtx = new InitialContext(env);

              connectionFactory = (ConnectionFactory) iniCtx.lookup(DEFAULT_CONNECTION_FACTORY);

              destination = (Destination) iniCtx.lookup(TOPIC_NAME);

              context = connectionFactory.createContext(USERNAME, PASSWORD, JMSContext.AUTO_ACKNOWLEDGE);

              consumer = context.createConsumer(destination);

              consumer.setMessageListener(new MyMessageListener());

              }

            }

             

             

            I think thats it. Should work the same way for Wildfly 8.2.