<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JMSConstants (Apache Axis2)</title>
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="JMSConstants (Apache Axis2)";
        }
    }
    catch(err) {
    }
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/JMSConstants.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../org/apache/axis2/transport/jms/JMSConnectionFactoryManager.html" title="class in org.apache.axis2.transport.jms"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../../org/apache/axis2/transport/jms/JMSEndpoint.html" title="class in org.apache.axis2.transport.jms"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/apache/axis2/transport/jms/JMSConstants.html" target="_top">Frames</a></li>
<li><a href="JMSConstants.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#methods.inherited.from.class.java.lang.Object">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li>Method</li>
</ul>
</div>
<a name="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.apache.axis2.transport.jms</div>
<h2 title="Class JMSConstants" class="title">Class JMSConstants</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.apache.axis2.transport.jms.JMSConstants</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public class <span class="typeNameLabel">JMSConstants</span>
extends <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></pre>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- =========== FIELD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Field and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#CACHE_AUTO">CACHE_AUTO</a></span></code>
<div class="block">automatic choice of an appropriate caching level (depending on the transaction strategy)</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#CACHE_CONNECTION">CACHE_CONNECTION</a></span></code>
<div class="block">Cache only the JMS connection between tasks (when receiving), or JMS CF's (when sending)</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#CACHE_CONSUMER">CACHE_CONSUMER</a></span></code>
<div class="block">Cache the JMS connection, Session and Consumer between tasks when receiving</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#CACHE_NONE">CACHE_NONE</a></span></code>
<div class="block">Do not cache any JMS resources between tasks (when sending) or JMS CF's (when sending)</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#CACHE_PRODUCER">CACHE_PRODUCER</a></span></code>
<div class="block">Cache the JMS connection, Session and Producer within a JMSConnectionFactory when sending</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#CACHE_SESSION">CACHE_SESSION</a></span></code>
<div class="block">Cache only the JMS connection and Session between tasks (receiving), or JMS CF's (sending)</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#CONTENT_TYPE_PARAM">CONTENT_TYPE_PARAM</a></span></code>
<div class="block">The Parameter indicating the expected content type for messages received by the service.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#CONTENT_TYPE_PROPERTY_PARAM">CONTENT_TYPE_PROPERTY_PARAM</a></span></code>
<div class="block">The EPR parameter name indicating the name of the message level property that indicated the content type.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#DEFAULT_CONFAC_NAME">DEFAULT_CONFAC_NAME</a></span></code>
<div class="block">The local (Axis2) JMS connection factory name of the default connection
 factory to be used, if a service does not explicitly state the connection
 factory it should be using by a Parameter named JMSConstants.CONFAC_PARAM</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static long</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#DEFAULT_JMS_TIMEOUT">DEFAULT_JMS_TIMEOUT</a></span></code>
<div class="block">The default JMS time out waiting for a reply - also see <code>JMS_WAIT_REPLY</code></div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#DESTINATION_TYPE_GENERIC">DESTINATION_TYPE_GENERIC</a></span></code>
<div class="block">Value indicating a JMS 1.1 Generic Destination used by <code>DEST_PARAM_TYPE</code>, <code>REPLY_PARAM_TYPE</code></div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#DESTINATION_TYPE_QUEUE">DESTINATION_TYPE_QUEUE</a></span></code>
<div class="block">Value indicating a Queue used for <code>DEST_PARAM_TYPE</code>, <code>REPLY_PARAM_TYPE</code></div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#DESTINATION_TYPE_TOPIC">DESTINATION_TYPE_TOPIC</a></span></code>
<div class="block">Value indicating a Topic used for <code>DEST_PARAM_TYPE</code>, <code>REPLY_PARAM_TYPE</code></div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#GENERIC">GENERIC</a></span></code>
<div class="block">A JMS 1.1 Generic Destination type or ConnectionFactory</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_BYTE_MESSAGE">JMS_BYTE_MESSAGE</a></span></code>
<div class="block">The message type indicating a BytesMessage.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_COORELATION_ID">JMS_COORELATION_ID</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS correlation id</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_DELIVERY_MODE">JMS_DELIVERY_MODE</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS delivery mode as an Integer or String
 Value 1 - javax.jms.DeliveryMode.NON_PERSISTENT
 Value 2 - javax.jms.DeliveryMode.PERSISTENT</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_DESTINATION">JMS_DESTINATION</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS destination to use on a Send</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_EXPIRATION">JMS_EXPIRATION</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS message expiration - a Long value
 specified as a String</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_MESSAGE_ID">JMS_MESSAGE_ID</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS message id</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_MESSAGE_TYPE">JMS_MESSAGE_TYPE</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS message type</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_PREFIX">JMS_PREFIX</a></span></code>
<div class="block">The prefix indicating an Axis JMS URL</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_PRIORITY">JMS_PRIORITY</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS priority</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_REDELIVERED">JMS_REDELIVERED</a></span></code>
<div class="block">A MessageContext property indicating if the message is a redelivery (Boolean as a String)</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_REPLY_TO">JMS_REPLY_TO</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS replyTo Destination</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_REPLY_TO_TYPE">JMS_REPLY_TO_TYPE</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS replyTo Destination type
 See <code>DESTINATION_TYPE_QUEUE</code> and <code>DESTINATION_TYPE_TOPIC</code></div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_TEXT_MESSAGE">JMS_TEXT_MESSAGE</a></span></code>
<div class="block">The message type indicating a TextMessage.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_TIME_TO_LIVE">JMS_TIME_TO_LIVE</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS time to live for message sent</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_TIMESTAMP">JMS_TIMESTAMP</a></span></code>
<div class="block">A MessageContext property or client Option indicating the JMS timestamp (Long specified as String)</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_TYPE">JMS_TYPE</a></span></code>
<div class="block">A MessageContext property indicating the JMS type String returned by <code>javax.jms.Message.getJMSType()</code></div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMS_WAIT_REPLY">JMS_WAIT_REPLY</a></span></code>
<div class="block">A MessageContext property or client Option indicating the time to wait for a response JMS message</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMSX_GROUP_ID">JMSX_GROUP_ID</a></span></code>
<div class="block">The JMSXGroupID property</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMSX_GROUP_SEQ">JMSX_GROUP_SEQ</a></span></code>
<div class="block">The JMSXGroupSeq property</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMSX_PREFIX">JMSX_PREFIX</a></span></code>
<div class="block">The prefix that denotes JMSX properties</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_CACHE_LEVEL">PARAM_CACHE_LEVEL</a></span></code>
<div class="block">JMS Resource cachable level to be used for the service One of the following:
 <code>CACHE_NONE</code>, <code>CACHE_CONNECTION</code>, <code>CACHE_SESSION</code>, <code>CACHE_PRODUCER</code>,
 <code>CACHE_CONSUMER</code>, or <code>CACHE_AUTO</code> - to let the transport decide</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_CONCURRENT_CONSUMERS">PARAM_CONCURRENT_CONSUMERS</a></span></code>
<div class="block">The number of concurrent consumers to be created to poll for messages for this service
 For Topics, this should be ONE, to prevent receipt of multiple copies of the same message</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_CONFAC_JNDI_NAME">PARAM_CONFAC_JNDI_NAME</a></span></code>
<div class="block">The Parameter name indicating the JMS connection factory JNDI name</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_CONFAC_TYPE">PARAM_CONFAC_TYPE</a></span></code>
<div class="block">Connection factory type if using JMS 1.0, either DESTINATION_TYPE_QUEUE or DESTINATION_TYPE_TOPIC</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_DEST_TYPE">PARAM_DEST_TYPE</a></span></code>
<div class="block">The Service level Parameter name indicating the destination type for requests.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_DESTINATION">PARAM_DESTINATION</a></span></code>
<div class="block">The Service level Parameter name indicating the JMS destination for requests of a service</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_DURABLE_SUB_NAME">PARAM_DURABLE_SUB_NAME</a></span></code>
<div class="block">The name for the durable subscription See <code>PARAM_SUB_DURABLE</code></div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_IDLE_TASK_LIMIT">PARAM_IDLE_TASK_LIMIT</a></span></code>
<div class="block">The number of idle (i.e. message-less) polling attempts before a worker task commits suicide,
 to scale down resources, as load decreases</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_JMS_CONFAC">PARAM_JMS_CONFAC</a></span></code>
<div class="block">The Parameter name of an Axis2 service, indicating the JMS connection
 factory which should be used to listen for messages for it.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_JMS_PASSWORD">PARAM_JMS_PASSWORD</a></span></code>
<div class="block">The password to use when obtaining a JMS Connection</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_JMS_SPEC_VER">PARAM_JMS_SPEC_VER</a></span></code>
<div class="block">The parameter indicating the JMS API specification to be used - if this is "1.1" the JMS
 1.1 API would be used, else the JMS 1.0.2B</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_JMS_USERNAME">PARAM_JMS_USERNAME</a></span></code>
<div class="block">The username to use when obtaining a JMS Connection</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_MAX_CONSUMERS">PARAM_MAX_CONSUMERS</a></span></code>
<div class="block">The maximum number of concurrent consumers for the service - See <code>PARAM_CONCURRENT_CONSUMERS</code></div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_MAX_MSGS_PER_TASK">PARAM_MAX_MSGS_PER_TASK</a></span></code>
<div class="block">The maximum number of messages a polling worker task should process, before suicide - to
 prevent many longer running threads - default is unlimited (i.e. a worker task will live forever)</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_MSG_SELECTOR">PARAM_MSG_SELECTOR</a></span></code>
<div class="block">A message selector to be used when messages are sought for this service</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_PUBLISH_EPR">PARAM_PUBLISH_EPR</a></span></code>
<div class="block">The Parameter indicating a final EPR as a String, to be published on the WSDL of a service
 Could occur more than once, and could provide additional connection properties or a subset
 of the properties auto computed.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_PUBSUB_NO_LOCAL">PARAM_PUBSUB_NO_LOCAL</a></span></code>
<div class="block">Should a pub-sub connection receive messages published by itself?</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_RCV_TIMEOUT">PARAM_RCV_TIMEOUT</a></span></code>
<div class="block">The number of milliseconds to wait for a message on a consumer.receive() call
 negative number - wait forever
 0 - do not wait at all
 positive number - indicates the number of milliseconds to wait</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_RECON_FACTOR">PARAM_RECON_FACTOR</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_RECON_INIT_DURATION">PARAM_RECON_INIT_DURATION</a></span></code>
<div class="block">Number of milliseconds before the first reconnection attempt is tried, on detection of an
 error.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_RECON_MAX_DURATION">PARAM_RECON_MAX_DURATION</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_REPLY_DEST_TYPE">PARAM_REPLY_DEST_TYPE</a></span></code>
<div class="block">The Service level Parameter name indicating the response destination type
 also see <code>DESTINATION_TYPE_QUEUE</code>, <code>DESTINATION_TYPE_TOPIC</code></div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_REPLY_DESTINATION">PARAM_REPLY_DESTINATION</a></span></code>
<div class="block">The Service level Parameter name indicating the [default] response destination of a service</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_SESSION_ACK">PARAM_SESSION_ACK</a></span></code>
<div class="block">The Parameter indicating the Session acknowledgement for the service.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_SESSION_TRANSACTED">PARAM_SESSION_TRANSACTED</a></span></code>
<div class="block">The Parameter indicating whether the JMS Session should be transacted for the service
 Specified as a "true" or "false"</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#PARAM_SUB_DURABLE">PARAM_SUB_DURABLE</a></span></code>
<div class="block">Is the Subscription durable ?</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#QUEUE">QUEUE</a></span></code>
<div class="block">A Queue Destination type or ConnectionFactory</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#TOPIC">TOPIC</a></span></code>
<div class="block">A Topic Destination type or ConnectionFactory</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.summary">
<!--   -->
</a>
<h3>Constructor Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colOne" scope="col">Constructor and Description</th>
</tr>
<tr class="altColor">
<td class="colOne"><code><span class="memberNameLink"><a href="../../../../../org/apache/axis2/transport/jms/JMSConstants.html#JMSConstants--">JMSConstants</a></span>()</code>&nbsp;</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#clone--" title="class or interface in java.lang">clone</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#equals-java.lang.Object-" title="class or interface in java.lang">equals</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#finalize--" title="class or interface in java.lang">finalize</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#getClass--" title="class or interface in java.lang">getClass</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#hashCode--" title="class or interface in java.lang">hashCode</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#notify--" title="class or interface in java.lang">notify</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#notifyAll--" title="class or interface in java.lang">notifyAll</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#toString--" title="class or interface in java.lang">toString</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait--" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait-long-" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait-long-int-" title="class or interface in java.lang">wait</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ FIELD DETAIL =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.detail">
<!--   -->
</a>
<h3>Field Detail</h3>
<a name="JMS_PREFIX">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_PREFIX</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_PREFIX</pre>
<div class="block">The prefix indicating an Axis JMS URL</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_PREFIX">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DEFAULT_CONFAC_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DEFAULT_CONFAC_NAME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DEFAULT_CONFAC_NAME</pre>
<div class="block">The local (Axis2) JMS connection factory name of the default connection
 factory to be used, if a service does not explicitly state the connection
 factory it should be using by a Parameter named JMSConstants.CONFAC_PARAM</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.DEFAULT_CONFAC_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DEFAULT_JMS_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DEFAULT_JMS_TIMEOUT</h4>
<pre>public static final&nbsp;long DEFAULT_JMS_TIMEOUT</pre>
<div class="block">The default JMS time out waiting for a reply - also see <code>JMS_WAIT_REPLY</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.DEFAULT_JMS_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DESTINATION_TYPE_QUEUE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DESTINATION_TYPE_QUEUE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DESTINATION_TYPE_QUEUE</pre>
<div class="block">Value indicating a Queue used for <code>DEST_PARAM_TYPE</code>, <code>REPLY_PARAM_TYPE</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.DESTINATION_TYPE_QUEUE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DESTINATION_TYPE_TOPIC">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DESTINATION_TYPE_TOPIC</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DESTINATION_TYPE_TOPIC</pre>
<div class="block">Value indicating a Topic used for <code>DEST_PARAM_TYPE</code>, <code>REPLY_PARAM_TYPE</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.DESTINATION_TYPE_TOPIC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DESTINATION_TYPE_GENERIC">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DESTINATION_TYPE_GENERIC</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DESTINATION_TYPE_GENERIC</pre>
<div class="block">Value indicating a JMS 1.1 Generic Destination used by <code>DEST_PARAM_TYPE</code>, <code>REPLY_PARAM_TYPE</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.DESTINATION_TYPE_GENERIC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CACHE_NONE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CACHE_NONE</h4>
<pre>public static final&nbsp;int CACHE_NONE</pre>
<div class="block">Do not cache any JMS resources between tasks (when sending) or JMS CF's (when sending)</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.CACHE_NONE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CACHE_CONNECTION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CACHE_CONNECTION</h4>
<pre>public static final&nbsp;int CACHE_CONNECTION</pre>
<div class="block">Cache only the JMS connection between tasks (when receiving), or JMS CF's (when sending)</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.CACHE_CONNECTION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CACHE_SESSION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CACHE_SESSION</h4>
<pre>public static final&nbsp;int CACHE_SESSION</pre>
<div class="block">Cache only the JMS connection and Session between tasks (receiving), or JMS CF's (sending)</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.CACHE_SESSION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CACHE_CONSUMER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CACHE_CONSUMER</h4>
<pre>public static final&nbsp;int CACHE_CONSUMER</pre>
<div class="block">Cache the JMS connection, Session and Consumer between tasks when receiving</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.CACHE_CONSUMER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CACHE_PRODUCER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CACHE_PRODUCER</h4>
<pre>public static final&nbsp;int CACHE_PRODUCER</pre>
<div class="block">Cache the JMS connection, Session and Producer within a JMSConnectionFactory when sending</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.CACHE_PRODUCER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CACHE_AUTO">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CACHE_AUTO</h4>
<pre>public static final&nbsp;int CACHE_AUTO</pre>
<div class="block">automatic choice of an appropriate caching level (depending on the transaction strategy)</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.CACHE_AUTO">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="GENERIC">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>GENERIC</h4>
<pre>public static final&nbsp;int GENERIC</pre>
<div class="block">A JMS 1.1 Generic Destination type or ConnectionFactory</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.GENERIC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="QUEUE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>QUEUE</h4>
<pre>public static final&nbsp;int QUEUE</pre>
<div class="block">A Queue Destination type or ConnectionFactory</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.QUEUE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPIC">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPIC</h4>
<pre>public static final&nbsp;int TOPIC</pre>
<div class="block">A Topic Destination type or ConnectionFactory</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.TOPIC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CONTENT_TYPE_PROPERTY_PARAM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CONTENT_TYPE_PROPERTY_PARAM</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> CONTENT_TYPE_PROPERTY_PARAM</pre>
<div class="block">The EPR parameter name indicating the name of the message level property that indicated the content type.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.CONTENT_TYPE_PROPERTY_PARAM">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_DESTINATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_DESTINATION</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_DESTINATION</pre>
<div class="block">The Service level Parameter name indicating the JMS destination for requests of a service</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_DESTINATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_DEST_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_DEST_TYPE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_DEST_TYPE</pre>
<div class="block">The Service level Parameter name indicating the destination type for requests.
 also see <code>DESTINATION_TYPE_QUEUE</code>, <code>DESTINATION_TYPE_TOPIC</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_DEST_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_REPLY_DESTINATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_REPLY_DESTINATION</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_REPLY_DESTINATION</pre>
<div class="block">The Service level Parameter name indicating the [default] response destination of a service</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_REPLY_DESTINATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_REPLY_DEST_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_REPLY_DEST_TYPE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_REPLY_DEST_TYPE</pre>
<div class="block">The Service level Parameter name indicating the response destination type
 also see <code>DESTINATION_TYPE_QUEUE</code>, <code>DESTINATION_TYPE_TOPIC</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_REPLY_DEST_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_JMS_CONFAC">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_JMS_CONFAC</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_JMS_CONFAC</pre>
<div class="block">The Parameter name of an Axis2 service, indicating the JMS connection
 factory which should be used to listen for messages for it. This is
 the local (Axis2) name of the connection factory and not the JNDI name</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_JMS_CONFAC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_CONFAC_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_CONFAC_TYPE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_CONFAC_TYPE</pre>
<div class="block">Connection factory type if using JMS 1.0, either DESTINATION_TYPE_QUEUE or DESTINATION_TYPE_TOPIC</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_CONFAC_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_CONFAC_JNDI_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_CONFAC_JNDI_NAME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_CONFAC_JNDI_NAME</pre>
<div class="block">The Parameter name indicating the JMS connection factory JNDI name</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_CONFAC_JNDI_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CONTENT_TYPE_PARAM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CONTENT_TYPE_PARAM</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> CONTENT_TYPE_PARAM</pre>
<div class="block">The Parameter indicating the expected content type for messages received by the service.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.CONTENT_TYPE_PARAM">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_PUBLISH_EPR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_PUBLISH_EPR</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_PUBLISH_EPR</pre>
<div class="block">The Parameter indicating a final EPR as a String, to be published on the WSDL of a service
 Could occur more than once, and could provide additional connection properties or a subset
 of the properties auto computed. Also could replace IP addresses with hostnames, and expose
 public credentials clients. If a user specified this parameter, the auto generated EPR will
 not be exposed - unless an instance of this parameter is added with the string "legacy"
 This parameter could be used to expose EPR's conforming to the proposed SOAP/JMS spec
 until such time full support is implemented for it.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_PUBLISH_EPR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_JMS_SPEC_VER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_JMS_SPEC_VER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_JMS_SPEC_VER</pre>
<div class="block">The parameter indicating the JMS API specification to be used - if this is "1.1" the JMS
 1.1 API would be used, else the JMS 1.0.2B</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_JMS_SPEC_VER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_SESSION_TRANSACTED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_SESSION_TRANSACTED</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_SESSION_TRANSACTED</pre>
<div class="block">The Parameter indicating whether the JMS Session should be transacted for the service
 Specified as a "true" or "false"</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_SESSION_TRANSACTED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_SESSION_ACK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_SESSION_ACK</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_SESSION_ACK</pre>
<div class="block">The Parameter indicating the Session acknowledgement for the service. Must be one of the
 following Strings, or the appropriate Integer used by the JMS API
 "AUTO_ACKNOWLEDGE", "CLIENT_ACKNOWLEDGE", "DUPS_OK_ACKNOWLEDGE" or "SESSION_TRANSACTED"</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_SESSION_ACK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_MSG_SELECTOR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_MSG_SELECTOR</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_MSG_SELECTOR</pre>
<div class="block">A message selector to be used when messages are sought for this service</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_MSG_SELECTOR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_SUB_DURABLE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_SUB_DURABLE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_SUB_DURABLE</pre>
<div class="block">Is the Subscription durable ? - "true" or "false" See <code>PARAM_DURABLE_SUB_NAME</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_SUB_DURABLE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_DURABLE_SUB_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_DURABLE_SUB_NAME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_DURABLE_SUB_NAME</pre>
<div class="block">The name for the durable subscription See <code>PARAM_SUB_DURABLE</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_DURABLE_SUB_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_CACHE_LEVEL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_CACHE_LEVEL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_CACHE_LEVEL</pre>
<div class="block">JMS Resource cachable level to be used for the service One of the following:
 <code>CACHE_NONE</code>, <code>CACHE_CONNECTION</code>, <code>CACHE_SESSION</code>, <code>CACHE_PRODUCER</code>,
 <code>CACHE_CONSUMER</code>, or <code>CACHE_AUTO</code> - to let the transport decide</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_CACHE_LEVEL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_PUBSUB_NO_LOCAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_PUBSUB_NO_LOCAL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_PUBSUB_NO_LOCAL</pre>
<div class="block">Should a pub-sub connection receive messages published by itself?</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_PUBSUB_NO_LOCAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_RCV_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_RCV_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_RCV_TIMEOUT</pre>
<div class="block">The number of milliseconds to wait for a message on a consumer.receive() call
 negative number - wait forever
 0 - do not wait at all
 positive number - indicates the number of milliseconds to wait</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_RCV_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_CONCURRENT_CONSUMERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_CONCURRENT_CONSUMERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_CONCURRENT_CONSUMERS</pre>
<div class="block">The number of concurrent consumers to be created to poll for messages for this service
 For Topics, this should be ONE, to prevent receipt of multiple copies of the same message</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_CONCURRENT_CONSUMERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_MAX_CONSUMERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_MAX_CONSUMERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_MAX_CONSUMERS</pre>
<div class="block">The maximum number of concurrent consumers for the service - See <code>PARAM_CONCURRENT_CONSUMERS</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_MAX_CONSUMERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_IDLE_TASK_LIMIT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_IDLE_TASK_LIMIT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_IDLE_TASK_LIMIT</pre>
<div class="block">The number of idle (i.e. message-less) polling attempts before a worker task commits suicide,
 to scale down resources, as load decreases</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_IDLE_TASK_LIMIT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_MAX_MSGS_PER_TASK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_MAX_MSGS_PER_TASK</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_MAX_MSGS_PER_TASK</pre>
<div class="block">The maximum number of messages a polling worker task should process, before suicide - to
 prevent many longer running threads - default is unlimited (i.e. a worker task will live forever)</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_MAX_MSGS_PER_TASK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_RECON_INIT_DURATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_RECON_INIT_DURATION</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_RECON_INIT_DURATION</pre>
<div class="block">Number of milliseconds before the first reconnection attempt is tried, on detection of an
 error. Subsequent retries follow a geometric series, where the
 duration = previous duration * factor
 This is further limited by the <code>PARAM_RECON_MAX_DURATION</code> to be meaningful</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_RECON_INIT_DURATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_RECON_FACTOR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_RECON_FACTOR</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_RECON_FACTOR</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>PARAM_RECON_INIT_DURATION</code>, 
<a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_RECON_FACTOR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_RECON_MAX_DURATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_RECON_MAX_DURATION</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_RECON_MAX_DURATION</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>PARAM_RECON_INIT_DURATION</code>, 
<a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_RECON_MAX_DURATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_JMS_USERNAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_JMS_USERNAME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_JMS_USERNAME</pre>
<div class="block">The username to use when obtaining a JMS Connection</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_JMS_USERNAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PARAM_JMS_PASSWORD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PARAM_JMS_PASSWORD</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PARAM_JMS_PASSWORD</pre>
<div class="block">The password to use when obtaining a JMS Connection</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.PARAM_JMS_PASSWORD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_MESSAGE_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_MESSAGE_TYPE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_MESSAGE_TYPE</pre>
<div class="block">A MessageContext property or client Option indicating the JMS message type</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_MESSAGE_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_BYTE_MESSAGE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_BYTE_MESSAGE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_BYTE_MESSAGE</pre>
<div class="block">The message type indicating a BytesMessage. See <code>JMS_MESSAGE_TYPE</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_BYTE_MESSAGE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_TEXT_MESSAGE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_TEXT_MESSAGE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_TEXT_MESSAGE</pre>
<div class="block">The message type indicating a TextMessage. See <code>JMS_MESSAGE_TYPE</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_TEXT_MESSAGE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_WAIT_REPLY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_WAIT_REPLY</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_WAIT_REPLY</pre>
<div class="block">A MessageContext property or client Option indicating the time to wait for a response JMS message</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_WAIT_REPLY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_COORELATION_ID">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_COORELATION_ID</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_COORELATION_ID</pre>
<div class="block">A MessageContext property or client Option indicating the JMS correlation id</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_COORELATION_ID">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_MESSAGE_ID">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_MESSAGE_ID</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_MESSAGE_ID</pre>
<div class="block">A MessageContext property or client Option indicating the JMS message id</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_MESSAGE_ID">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_DELIVERY_MODE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_DELIVERY_MODE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_DELIVERY_MODE</pre>
<div class="block">A MessageContext property or client Option indicating the JMS delivery mode as an Integer or String
 Value 1 - javax.jms.DeliveryMode.NON_PERSISTENT
 Value 2 - javax.jms.DeliveryMode.PERSISTENT</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_DELIVERY_MODE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_DESTINATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_DESTINATION</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_DESTINATION</pre>
<div class="block">A MessageContext property or client Option indicating the JMS destination to use on a Send</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_DESTINATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_EXPIRATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_EXPIRATION</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_EXPIRATION</pre>
<div class="block">A MessageContext property or client Option indicating the JMS message expiration - a Long value
 specified as a String</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_EXPIRATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_REDELIVERED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_REDELIVERED</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_REDELIVERED</pre>
<div class="block">A MessageContext property indicating if the message is a redelivery (Boolean as a String)</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_REDELIVERED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_REPLY_TO">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_REPLY_TO</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_REPLY_TO</pre>
<div class="block">A MessageContext property or client Option indicating the JMS replyTo Destination</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_REPLY_TO">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_REPLY_TO_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_REPLY_TO_TYPE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_REPLY_TO_TYPE</pre>
<div class="block">A MessageContext property or client Option indicating the JMS replyTo Destination type
 See <code>DESTINATION_TYPE_QUEUE</code> and <code>DESTINATION_TYPE_TOPIC</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_REPLY_TO_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_TIMESTAMP">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_TIMESTAMP</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_TIMESTAMP</pre>
<div class="block">A MessageContext property or client Option indicating the JMS timestamp (Long specified as String)</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_TIMESTAMP">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_TYPE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_TYPE</pre>
<div class="block">A MessageContext property indicating the JMS type String returned by <code>javax.jms.Message.getJMSType()</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_PRIORITY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_PRIORITY</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_PRIORITY</pre>
<div class="block">A MessageContext property or client Option indicating the JMS priority</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_PRIORITY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMS_TIME_TO_LIVE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMS_TIME_TO_LIVE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMS_TIME_TO_LIVE</pre>
<div class="block">A MessageContext property or client Option indicating the JMS time to live for message sent</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMS_TIME_TO_LIVE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMSX_PREFIX">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMSX_PREFIX</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMSX_PREFIX</pre>
<div class="block">The prefix that denotes JMSX properties</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMSX_PREFIX">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMSX_GROUP_ID">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JMSX_GROUP_ID</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMSX_GROUP_ID</pre>
<div class="block">The JMSXGroupID property</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMSX_GROUP_ID">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JMSX_GROUP_SEQ">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>JMSX_GROUP_SEQ</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> JMSX_GROUP_SEQ</pre>
<div class="block">The JMSXGroupSeq property</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../constant-values.html#org.apache.axis2.transport.jms.JMSConstants.JMSX_GROUP_SEQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
</li>
</ul>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a name="JMSConstants--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>JMSConstants</h4>
<pre>public&nbsp;JMSConstants()</pre>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/JMSConstants.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../org/apache/axis2/transport/jms/JMSConnectionFactoryManager.html" title="class in org.apache.axis2.transport.jms"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../../org/apache/axis2/transport/jms/JMSEndpoint.html" title="class in org.apache.axis2.transport.jms"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/apache/axis2/transport/jms/JMSConstants.html" target="_top">Frames</a></li>
<li><a href="JMSConstants.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#methods.inherited.from.class.java.lang.Object">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li>Method</li>
</ul>
</div>
<a name="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &copy; <a href="https://www.apache.org/">The Apache Software Foundation</a>. All Rights Reserved.</small></p>
</body>
</html>