<div class="wiki-content maincontent"><h4>Configuration issues for Tomcat 7 and later</h4><structured-macro ac:macro-id="2d3a18bd-173c-4ea9-8852-7e57cded973c" ac:name="warning" ac:schema-version="1"><rich-text-body><p>Tomcat needs to be configured to ignore Jetty SCI annotations so that the Jetty WebSocket ServerContainerInitializer class is not inadvertently picked up by Tomcat. For more information on this problem see <a shape="rect" href="https://issues.apache.org/jira/browse/AMQ-6154">AMQ-6154</a> and <a shape="rect" href="https://wiki.apache.org/tomcat/HowTo/FasterStartUp">https://wiki.apache.org/tomcat/HowTo/FasterStartUp</a> and consult the Tomcat documentation for the version you are using to properly exclude the Jetty jar files from being scanned by Tomcat.</p></rich-text-body></structured-macro><h2>Pre-integrated Tomcat with ActiveMQ</h2><p>Apache TomEE is a distribution of <a shape="rect" href="http://tomee.apache.org/tomcat-jms.html">Tomcat with fully integrated ActiveMQ</a>. All integration steps detailed here have already been done. The stack supports injection of Topic, Queue and ConnectionFactory references as well as transactional sending and delivery.</p><p>Something like the following works out of the box with no configuration:</p><structured-macro ac:macro-id="24bb04f8-4aa8-41f0-9c8a-64f57792e4d0" ac:name="code" ac:schema-version="1"><plain-text-body>import javax.annotation.Resource;
import javax.servlet.http.HttpServlet;
import javax.jms.Topic;
import javax.jms.Queue;
import javax.jms.ConnectionFactory;

public class MyServet extends HttpServlet {

    @Resource(name = "foo")
    private Topic fooTopic;

    @Resource(name = "bar")
    private Queue barQueue;

    @Resource
    private ConnectionFactory connectionFactory;
</plain-text-body></structured-macro><h2>Manually integrating Tomcat and ActiveMQ</h2><p>Note, manually integrating ActiveMQ with Tomcat does allow for Topic, Queue, and ConnectionFactory injection but does not support transactional sending and delivery.</p><p>You should go to Tomcat documentation and read JNDI Resources HOW-TO, especially part: Configure Tomcat's Resource Factory.</p><p>ActiveMQ has ready JNDI resource factory for all its administered objects: ConnectionFactory and destinations.</p><p>You must provide it as a parameter factory for your resources:</p><structured-macro ac:macro-id="5e448eca-234d-4151-b605-c11188458cf1" ac:name="code" ac:schema-version="1"><plain-text-body>&lt;Context ...&gt;
  ...
  &lt;Resource name="jms/ConnectionFactory" auth="Container"
            type="org.apache.activemq.ActiveMQConnectionFactory"/&gt;
  &lt;ResourceParams name="jms/ConnectionFactory"&gt;
    &lt;parameter&gt;
      &lt;name&gt;factory&lt;/name&gt;
      &lt;value&gt;org.activemq.jndi.JNDIReferenceFactory&lt;/value&gt;
    &lt;/parameter&gt;
    &lt;parameter&gt;
      &lt;name&gt;brokerURL&lt;/name&gt;
      &lt;value&gt;vm://localhost&lt;/value&gt;
    &lt;/parameter&gt;
    &lt;parameter&gt;
      &lt;name&gt;brokerName&lt;/name&gt;
      &lt;value&gt;LocalActiveMQBroker&lt;/value&gt;
    &lt;/parameter&gt;
    &lt;parameter&gt;
      &lt;name&gt;useEmbeddedBroker&lt;/name&gt;
      &lt;value&gt;true&lt;/value&gt;
    &lt;/parameter&gt;
  &lt;/ResourceParams&gt;
  ...
&lt;/Context&gt;
</plain-text-body></structured-macro><p>&#160;</p><p>If you are using Tomcat 5.5 or later then try this instead...</p><structured-macro ac:macro-id="00c87efb-6eec-496e-a4af-d3a070c87f72" ac:name="code" ac:schema-version="1"><plain-text-body>&lt;Context&gt;
    ...
  &lt;Resource name="jms/ConnectionFactory" auth="Container" type="org.apache.activemq.ActiveMQConnectionFactory" description="JMS Connection Factory"
        factory="org.apache.activemq.jndi.JNDIReferenceFactory" brokerURL="vm://localhost" brokerName="LocalActiveMQBroker"/&gt;
    ....
&lt;/Context&gt;
</plain-text-body></structured-macro><p>&#160;</p><p>Also, don't forget to put ActiveMQ and dependent jars to tomcat shared lib directory.</p><h3>Creating destinations in Tomcat 5.5 or later</h3><p>This is completely untested but should work <emoticon ac:name="smile"></emoticon></p><structured-macro ac:macro-id="22a959cc-c88b-4377-8d5b-e6f308eb1deb" ac:name="code" ac:schema-version="1"><plain-text-body>&lt;Context&gt;
    ...
  &lt;Resource name="jms/someTopic" auth="Container" type="org.apache.activemq.command.ActiveMQTopic" description="my Topic"
        factory="org.apache.activemq.jndi.JNDIReferenceFactory" physicalName="FOO.BAR"/&gt;

  &lt;Resource name="jms/aQueue" auth="Container" type="org.apache.activemq.command.ActiveMQQueue" description="my Queue"
        factory="org.apache.activemq.jndi.JNDIReferenceFactory" physicalName="FOO.BAR"/&gt;
    ....
&lt;/Context&gt;
</plain-text-body></structured-macro><structured-macro ac:macro-id="73b03045-8f8e-45c9-b824-5aa7e922affb" ac:name="info" ac:schema-version="1"><parameter ac:name="title">JMX Tip when working with Tomcat</parameter><rich-text-body><p>If you want to use JMX with Tomcat and then connect via JConsole to view the <link><page ri:content-title="JMX"></page></link> MBeans of the server then set the following</p><structured-macro ac:macro-id="6fdc53cc-6f94-41e2-8539-04ffa0128942" ac:name="code" ac:schema-version="1"><plain-text-body>CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=1099 \
    -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false"
</plain-text-body></structured-macro></rich-text-body></structured-macro></div>

