Queue (Red Hat JBoss Enterprise Application Platform 7.3.0.CD18 public API)

All Superinterfaces:

Bindable, CriticalComponent

All Known Implementing Classes:

LastValueQueue, QueueImpl
```
public interface Queue
extends Bindable, CriticalComponent
```

Field Summary

Fields
Modifier and Type Field and Description

static int MAX_CONSUMERS_UNLIMITED

Fields
Modifier and Type	Field and Description
`static int`	`MAX_CONSUMERS_UNLIMITED`

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`void`	`acknowledge(MessageReference ref)`
`void`	`acknowledge(MessageReference ref, AckReason reason, ServerConsumer consumer)`
`void`	`acknowledge(MessageReference ref, ServerConsumer consumer)`
`void`	`acknowledge(Transaction tx, MessageReference ref)`
`void`	`acknowledge(Transaction tx, MessageReference ref, AckReason reason, ServerConsumer consumer)`
`void`	`addConsumer(Consumer consumer)`
`void`	`addHead(List<MessageReference> refs, boolean scheduling)`
`void`	`addHead(MessageReference ref, boolean scheduling)`
`void`	`addRedistributor(long delay)`
`void`	`addTail(MessageReference ref)`
`void`	`addTail(MessageReference ref, boolean direct)`
`boolean`	`allowsReferenceCallback()` the current queue and consumer settings will allow use of the Reference Execution and callback.
`LinkedListIterator<MessageReference>`	`browserIterator()`
`void`	`cancel(MessageReference reference, long timeBase)`
`void`	`cancel(Transaction tx, MessageReference ref)`
`void`	`cancel(Transaction tx, MessageReference ref, boolean ignoreRedeliveryCheck)`
`void`	`cancelRedistributor()`
`boolean`	`changeReferencePriority(long messageID, byte newPriority)`
`int`	`changeReferencesPriority(Filter filter, byte newPriority)`
`Pair<Boolean,Boolean>`	`checkRedelivery(MessageReference ref, long timeBase, boolean ignoreRedeliveryDelay)`
`void`	`close()`
`int`	`deleteAllReferences()`
`int`	`deleteAllReferences(int flushLimit)`
`int`	`deleteMatchingReferences(Filter filter)`
`default int`	`deleteMatchingReferences(int flushLImit, Filter filter)`
`int`	`deleteMatchingReferences(int flushLImit, Filter filter, AckReason ackReason)`
`void`	`deleteQueue()`
`void`	`deleteQueue(boolean removeConsumers)`
`boolean`	`deleteReference(long messageID)`
`void`	`deliverAsync()`
`void`	`deliverScheduledMessages()` cancels scheduled messages and send them to the head of the queue.
`void`	`destroyPaging()`
`default void`	`errorProcessing(Consumer consumer, Throwable t, MessageReference messageReference)`
`void`	`expire(MessageReference ref)`
`void`	`expire(MessageReference ref, ServerConsumer consumer)`
`boolean`	`expireReference(long messageID)`
`void`	`expireReferences()`
`int`	`expireReferences(Filter filter)` Expire all the references in the queue which matches the filter
`boolean`	`flushExecutor()`
`void`	`forceDelivery()` This method will make sure that any pending message (including paged message) will be delivered
`long`	`getAcknowledgeAttempts()`
`SimpleString`	`getAddress()`
`long`	`getAutoDeleteDelay()`
`long`	`getAutoDeleteMessageCount()`
`int`	`getConsumerCount()`
`long`	`getConsumerRemovedTimestamp()`
`Collection<Consumer>`	`getConsumers()`
`int`	`getConsumersBeforeDispatch()`
`ReferenceCounter`	`getConsumersRefCount()`
`long`	`getDelayBeforeDispatch()`
`int`	`getDeliveringCount()`
`Map<String,List<MessageReference>>`	`getDeliveringMessages()` Return a Map consisting of consumer.toString and its messages Delivering message is a property of the consumer, this method will aggregate the results per Server's consumer object
`long`	`getDeliveringSize()`
`long`	`getDispatchStartTime()`
`int`	`getDurableDeliveringCount()`
`long`	`getDurableDeliveringSize()`
`long`	`getDurableMessageCount()` This is the number of the durable messages in the queue
`long`	`getDurablePersistentSize()` This is the persistent size of all the durable messages in the queue
`int`	`getDurableScheduledCount()`
`long`	`getDurableScheduledSize()`
`Executor`	`getExecutor()`
`SimpleString`	`getExpiryAddress()`
`Filter`	`getFilter()`
`int`	`getGroupBuckets()`
`int`	`getGroupCount()`
`SimpleString`	`getGroupFirstKey()`
`Map<SimpleString,Consumer>`	`getGroups()`
`long`	`getID()`
`SimpleString`	`getLastValueKey()`
`int`	`getMaxConsumers()`
`long`	`getMessageCount()`
`long`	`getMessagesAcknowledged()`
`long`	`getMessagesAdded()`
`long`	`getMessagesExpired()`
`long`	`getMessagesKilled()`
`SimpleString`	`getName()`
`PageSubscription`	`getPageSubscription()`
`long`	`getPersistentSize()` This is the size of the messages in the queue when persisted on disk which is used for metrics tracking to give an idea of the amount of data on the queue to be consumed Note that this includes all messages on the queue, even messages that are non-durable which may only be in memory
`float`	`getRate()`
`MessageReference`	`getReference(long id)`
`RoutingType`	`getRoutingType()`
`int`	`getScheduledCount()`
`List<MessageReference>`	`getScheduledMessages()`
`long`	`getScheduledSize()`
`SimpleString`	`getUser()`
`boolean`	`hasMatchingConsumer(Message message)`
`void`	`incrementMesssagesAdded()`
`boolean`	`isAutoCreated()`
`boolean`	`isAutoDelete()`
`boolean`	`isConfigurationManaged()`
`boolean`	`isDirectDeliver()`
`boolean`	`isDispatching()`
`boolean`	`isDurable()`
`boolean`	`isDurableMessage()` The queue definition could be durable, but the messages could eventually be considered non durable.
`boolean`	`isExclusive()`
`boolean`	`isGroupRebalance()`
`boolean`	`isInternalQueue()` We can't send stuff to DLQ on queues used on clustered-bridge-communication
`boolean`	`isLastValue()`
`boolean`	`isNonDestructive()`
`boolean`	`isPaused()`
`boolean`	`isPersistedPause()` if the pause was persisted
`boolean`	`isPurgeOnNoConsumers()`
`boolean`	`isTemporary()`
`LinkedListIterator<MessageReference>`	`iterator()` It will iterate thorugh memory only (not paging)
`boolean`	`moveReference(long messageID, SimpleString toAddress, Binding binding, boolean rejectDuplicates)`
`int`	`moveReferences(Filter filter, SimpleString toAddress, Binding binding)`
`int`	`moveReferences(int flushLimit, Filter filter, SimpleString toAddress, boolean rejectDuplicates, Binding binding)`
`void`	`pause()` Pauses the queue.
`void`	`pause(boolean persist)` Pauses the queue.
`void`	`postAcknowledge(MessageReference ref, AckReason reason)`
`void`	`reacknowledge(Transaction tx, MessageReference ref)`
`void`	`recheckRefCount(OperationContext context)` This is to perform a check on the counter again
`void`	`referenceHandled(MessageReference ref)`
`void`	`reload(MessageReference ref)`
`void`	`reloadPause(long recordID)`
`void`	`removeConsumer(Consumer consumer)`
`MessageReference`	`removeReferenceWithID(long id)`
`void`	`resetAllGroups()`
`void`	`resetAllIterators()`
`void`	`resetGroup(SimpleString groupID)`
`void`	`resetMessagesAcknowledged()`
`void`	`resetMessagesAdded()`
`void`	`resetMessagesExpired()`
`void`	`resetMessagesKilled()`
`void`	`resume()` Resumes the delivery of message for the queue.
`int`	`retryMessages(Filter filter)`
`int`	`sendMessagesToDeadLetterAddress(Filter filter)`
`boolean`	`sendMessageToDeadLetterAddress(long messageID)`
`boolean`	`sendToDeadLetterAddress(Transaction tx, MessageReference ref)`
`void`	`setConfigurationManaged(boolean configurationManaged)`
`void`	`setConsumersBeforeDispatch(int consumersBeforeDispatch)`
`void`	`setConsumersRefCount(ReferenceCounter referenceCounter)` This will set a reference counter for every consumer present on the queue.
`void`	`setDelayBeforeDispatch(long delayBeforeDispatch)`
`void`	`setDispatching(boolean dispatching)`
`void`	`setExclusive(boolean value)`
`void`	`setFilter(Filter filter)`
`void`	`setGroupBuckets(int groupBuckets)`
`void`	`setGroupFirstKey(SimpleString groupFirstKey)`
`void`	`setGroupRebalance(boolean groupRebalance)`
`void`	`setInternalQueue(boolean internalQueue)`
`void`	`setMaxConsumer(int maxConsumers)`
`void`	`setNonDestructive(boolean nonDestructive)`
`void`	`setPurgeOnNoConsumers(boolean value)`
`void`	`setRoutingType(RoutingType routingType)`
`void`	`setUser(SimpleString user)`
`void`	`unproposed(SimpleString groupID)`

Methods inherited from interface org.apache.activemq.artemis.core.server.Bindable
route, routeWithAck

Methods inherited from interface org.apache.activemq.artemis.utils.critical.CriticalComponent
enterCritical, getCriticalAnalyzer, isExpired, leaveCritical

Field Detail
- MAX_CONSUMERS_UNLIMITED
```
static final int MAX_CONSUMERS_UNLIMITED
```
  See Also:
  
  Constant Field Values

Method Detail

getName
```
SimpleString getName()
```

getID
```
long getID()
```

getFilter
```
Filter getFilter()
```

setFilter
```
void setFilter(Filter filter)
```

getPageSubscription
```
PageSubscription getPageSubscription()
```

getRoutingType
```
RoutingType getRoutingType()
```

setRoutingType

void setRoutingType(RoutingType routingType)

allowsReferenceCallback
```
boolean allowsReferenceCallback()
```
the current queue and consumer settings will allow use of the Reference Execution and callback. This is because

isDurable
```
boolean isDurable()
```

isDurableMessage
```
boolean isDurableMessage()
```
The queue definition could be durable, but the messages could eventually be considered non durable. (e.g. purgeOnNoConsumers)

Returns:

isAutoDelete
```
boolean isAutoDelete()
```

getAutoDeleteDelay
```
long getAutoDeleteDelay()
```

getAutoDeleteMessageCount
```
long getAutoDeleteMessageCount()
```

isTemporary
```
boolean isTemporary()
```

isAutoCreated
```
boolean isAutoCreated()
```

isPurgeOnNoConsumers
```
boolean isPurgeOnNoConsumers()
```

setPurgeOnNoConsumers

void setPurgeOnNoConsumers(boolean value)

getConsumersBeforeDispatch
```
int getConsumersBeforeDispatch()
```

setConsumersBeforeDispatch

void setConsumersBeforeDispatch(int consumersBeforeDispatch)

getDelayBeforeDispatch
```
long getDelayBeforeDispatch()
```

setDelayBeforeDispatch

void setDelayBeforeDispatch(long delayBeforeDispatch)

getDispatchStartTime
```
long getDispatchStartTime()
```

isDispatching
```
boolean isDispatching()
```

setDispatching

void setDispatching(boolean dispatching)

isExclusive
```
boolean isExclusive()
```

setExclusive
```
void setExclusive(boolean value)
```

isLastValue
```
boolean isLastValue()
```

getLastValueKey
```
SimpleString getLastValueKey()
```

isNonDestructive
```
boolean isNonDestructive()
```

setNonDestructive

void setNonDestructive(boolean nonDestructive)

getMaxConsumers
```
int getMaxConsumers()
```

setMaxConsumer
```
void setMaxConsumer(int maxConsumers)
```

getGroupBuckets
```
int getGroupBuckets()
```

setGroupBuckets

void setGroupBuckets(int groupBuckets)

isGroupRebalance
```
boolean isGroupRebalance()
```

setGroupRebalance

void setGroupRebalance(boolean groupRebalance)

getGroupFirstKey
```
SimpleString getGroupFirstKey()
```

setGroupFirstKey

void setGroupFirstKey(SimpleString groupFirstKey)

isConfigurationManaged
```
boolean isConfigurationManaged()
```

setConfigurationManaged

void setConfigurationManaged(boolean configurationManaged)

addConsumer

void addConsumer(Consumer consumer)
          throws Exception

Throws:: Exception

removeConsumer

void removeConsumer(Consumer consumer)

getConsumerCount
```
int getConsumerCount()
```

getConsumerRemovedTimestamp
```
long getConsumerRemovedTimestamp()
```

setConsumersRefCount
```
void setConsumersRefCount(ReferenceCounter referenceCounter)
```
This will set a reference counter for every consumer present on the queue. The ReferenceCounter will know what to do when the counter became zeroed. This is used to control what to do with temporary queues, especially on shared subscriptions where the queue needs to be deleted when all the consumers are closed.

getConsumersRefCount

ReferenceCounter getConsumersRefCount()

reload
```
void reload(MessageReference ref)
```

addTail
```
void addTail(MessageReference ref)
```

addTail

void addTail(MessageReference ref,
             boolean direct)

addHead

void addHead(MessageReference ref,
             boolean scheduling)

addHead

void addHead(List<MessageReference> refs,
             boolean scheduling)

acknowledge

void acknowledge(MessageReference ref)
          throws Exception

Throws:: Exception

acknowledge

void acknowledge(MessageReference ref,
                 ServerConsumer consumer)
          throws Exception

Throws:: Exception

acknowledge

void acknowledge(MessageReference ref,
                 AckReason reason,
                 ServerConsumer consumer)
          throws Exception

Throws:: Exception

acknowledge

void acknowledge(Transaction tx,
                 MessageReference ref)
          throws Exception

Throws:: Exception

acknowledge

void acknowledge(Transaction tx,
                 MessageReference ref,
                 AckReason reason,
                 ServerConsumer consumer)
          throws Exception

Throws:: Exception

reacknowledge

void reacknowledge(Transaction tx,
                   MessageReference ref)
            throws Exception

Throws:: Exception

cancel

void cancel(Transaction tx,
            MessageReference ref)

cancel

void cancel(Transaction tx,
            MessageReference ref,
            boolean ignoreRedeliveryCheck)

cancel

void cancel(MessageReference reference,
            long timeBase)
     throws Exception

Throws:: Exception

deliverAsync
```
void deliverAsync()
```

unproposed
```
void unproposed(SimpleString groupID)
```

forceDelivery
```
void forceDelivery()
```
This method will make sure that any pending message (including paged message) will be delivered

deleteQueue

void deleteQueue()
          throws Exception

Throws:: Exception

deleteQueue

void deleteQueue(boolean removeConsumers)
          throws Exception

Throws:: Exception

destroyPaging

void destroyPaging()
            throws Exception

Throws:: Exception

getMessageCount
```
long getMessageCount()
```

getPersistentSize
```
long getPersistentSize()
```
This is the size of the messages in the queue when persisted on disk which is used for metrics tracking to give an idea of the amount of data on the queue to be consumed Note that this includes all messages on the queue, even messages that are non-durable which may only be in memory

getDurableMessageCount
```
long getDurableMessageCount()
```
This is the number of the durable messages in the queue

getDurablePersistentSize
```
long getDurablePersistentSize()
```
This is the persistent size of all the durable messages in the queue

getDeliveringCount
```
int getDeliveringCount()
```

getDeliveringSize
```
long getDeliveringSize()
```

getDurableDeliveringCount
```
int getDurableDeliveringCount()
```

getDurableDeliveringSize
```
long getDurableDeliveringSize()
```

referenceHandled

void referenceHandled(MessageReference ref)

getScheduledCount
```
int getScheduledCount()
```

getScheduledSize
```
long getScheduledSize()
```

getDurableScheduledCount
```
int getDurableScheduledCount()
```

getDurableScheduledSize
```
long getDurableScheduledSize()
```

getScheduledMessages

List<MessageReference> getScheduledMessages()

getDeliveringMessages
```
Map<String,List<MessageReference>> getDeliveringMessages()
```
Return a Map consisting of consumer.toString and its messages Delivering message is a property of the consumer, this method will aggregate the results per Server's consumer object

Returns:

getMessagesAdded
```
long getMessagesAdded()
```

getAcknowledgeAttempts
```
long getAcknowledgeAttempts()
```

getMessagesAcknowledged
```
long getMessagesAcknowledged()
```

getMessagesExpired
```
long getMessagesExpired()
```

getMessagesKilled
```
long getMessagesKilled()
```

removeReferenceWithID

MessageReference removeReferenceWithID(long id)
                                throws Exception

Throws:: Exception

getReference

MessageReference getReference(long id)
                       throws ActiveMQException

Throws:: ActiveMQException

deleteAllReferences

int deleteAllReferences()
                 throws Exception

Throws:: Exception

deleteAllReferences

int deleteAllReferences(int flushLimit)
                 throws Exception

Throws:: Exception

deleteReference

boolean deleteReference(long messageID)
                 throws Exception

Throws:: Exception

deleteMatchingReferences

int deleteMatchingReferences(Filter filter)
                      throws Exception

Throws:: Exception

deleteMatchingReferences

default int deleteMatchingReferences(int flushLImit,
                                     Filter filter)
                              throws Exception

Throws:: Exception

deleteMatchingReferences

int deleteMatchingReferences(int flushLImit,
                             Filter filter,
                             AckReason ackReason)
                      throws Exception

Throws:: Exception

expireReference

boolean expireReference(long messageID)
                 throws Exception

Throws:: Exception

expireReferences
```
int expireReferences(Filter filter)
              throws Exception
```
Expire all the references in the queue which matches the filter

Throws:

Exception

expireReferences

void expireReferences()
               throws Exception

Throws:: Exception

expire

void expire(MessageReference ref)
     throws Exception

Throws:: Exception

expire

void expire(MessageReference ref,
            ServerConsumer consumer)
     throws Exception

Throws:: Exception

sendMessageToDeadLetterAddress

boolean sendMessageToDeadLetterAddress(long messageID)
                                throws Exception

Throws:: Exception

sendMessagesToDeadLetterAddress

int sendMessagesToDeadLetterAddress(Filter filter)
                             throws Exception

Throws:: Exception

sendToDeadLetterAddress

boolean sendToDeadLetterAddress(Transaction tx,
                                MessageReference ref)
                         throws Exception

Parameters:: tx -; ref -
Returns:: whether or not the message was actually sent to a DLA with bindings
Throws:: Exception

changeReferencePriority

boolean changeReferencePriority(long messageID,
                                byte newPriority)
                         throws Exception

Throws:: Exception

changeReferencesPriority

int changeReferencesPriority(Filter filter,
                             byte newPriority)
                      throws Exception

Throws:: Exception

moveReference

boolean moveReference(long messageID,
                      SimpleString toAddress,
                      Binding binding,
                      boolean rejectDuplicates)
               throws Exception

Throws:: Exception

moveReferences

int moveReferences(Filter filter,
                   SimpleString toAddress,
                   Binding binding)
            throws Exception

Throws:: Exception

moveReferences

int moveReferences(int flushLimit,
                   Filter filter,
                   SimpleString toAddress,
                   boolean rejectDuplicates,
                   Binding binding)
            throws Exception

Throws:: Exception

retryMessages

int retryMessages(Filter filter)
           throws Exception

Throws:: Exception

addRedistributor
```
void addRedistributor(long delay)
```

cancelRedistributor

void cancelRedistributor()
                  throws Exception

Throws:: Exception

hasMatchingConsumer

boolean hasMatchingConsumer(Message message)

getConsumers
```
Collection<Consumer> getConsumers()
```

getGroups
```
Map<SimpleString,Consumer> getGroups()
```

resetGroup
```
void resetGroup(SimpleString groupID)
```

resetAllGroups
```
void resetAllGroups()
```

getGroupCount
```
int getGroupCount()
```

checkRedelivery
```
Pair<Boolean,Boolean> checkRedelivery(MessageReference ref,
                                      long timeBase,
                                      boolean ignoreRedeliveryDelay)
                               throws Exception
```
Parameters:

ref -

timeBase -

ignoreRedeliveryDelay -

Returns:

a Pair of Booleans: the first indicates whether or not redelivery happened; the second indicates whether or not the message was actually sent to a DLA with bindings

Throws:

Exception

iterator
```
LinkedListIterator<MessageReference> iterator()
```
It will iterate thorugh memory only (not paging)

Returns:

browserIterator

LinkedListIterator<MessageReference> browserIterator()

getExpiryAddress
```
SimpleString getExpiryAddress()
```

pause
```
void pause()
```
Pauses the queue. It will receive messages but won't give them to the consumers until resumed. If a queue is paused, pausing it again will only throw a warning. To check if a queue is paused, invoke isPaused()

pause
```
void pause(boolean persist)
```
Pauses the queue. It will receive messages but won't give them to the consumers until resumed. If a queue is paused, pausing it again will only throw a warning. To check if a queue is paused, invoke isPaused()

reloadPause
```
void reloadPause(long recordID)
```

resume
```
void resume()
```
Resumes the delivery of message for the queue. If a queue is resumed, resuming it again will only throw a warning. To check if a queue is resumed, invoke isPaused()

isPaused
```
boolean isPaused()
```
Returns:

true if paused, false otherwise.

isPersistedPause
```
boolean isPersistedPause()
```
if the pause was persisted

Returns:

getExecutor
```
Executor getExecutor()
```

resetAllIterators
```
void resetAllIterators()
```

flushExecutor
```
boolean flushExecutor()
```

close
```
void close()
    throws Exception
```
Throws:

Exception

isDirectDeliver
```
boolean isDirectDeliver()
```

getAddress
```
SimpleString getAddress()
```

isInternalQueue
```
boolean isInternalQueue()
```
We can't send stuff to DLQ on queues used on clustered-bridge-communication

Returns:

setInternalQueue

void setInternalQueue(boolean internalQueue)

resetMessagesAdded
```
void resetMessagesAdded()
```

resetMessagesAcknowledged
```
void resetMessagesAcknowledged()
```

resetMessagesExpired
```
void resetMessagesExpired()
```

resetMessagesKilled
```
void resetMessagesKilled()
```

incrementMesssagesAdded
```
void incrementMesssagesAdded()
```

deliverScheduledMessages
```
void deliverScheduledMessages()
                       throws ActiveMQException
```
cancels scheduled messages and send them to the head of the queue.

Throws:

ActiveMQException

postAcknowledge

void postAcknowledge(MessageReference ref,
                     AckReason reason)

getRate
```
float getRate()
```

getUser
```
SimpleString getUser()
```
Returns:

the user associated with this queue

setUser
```
void setUser(SimpleString user)
```
Parameters:

user - the user associated with this queue

recheckRefCount
```
void recheckRefCount(OperationContext context)
```
This is to perform a check on the counter again

errorProcessing

default void errorProcessing(Consumer consumer,
                             Throwable t,
                             MessageReference messageReference)

Interface Queue

Field Summary

Method Summary

Methods inherited from interface org.apache.activemq.artemis.core.server.Bindable

Methods inherited from interface org.apache.activemq.artemis.utils.critical.CriticalComponent

Field Detail

MAX_CONSUMERS_UNLIMITED

Method Detail

getName

getID

getFilter

setFilter

getPageSubscription

getRoutingType

setRoutingType

allowsReferenceCallback

isDurable

isDurableMessage

isAutoDelete

getAutoDeleteDelay

getAutoDeleteMessageCount

isTemporary

isAutoCreated

isPurgeOnNoConsumers

setPurgeOnNoConsumers

getConsumersBeforeDispatch

setConsumersBeforeDispatch

getDelayBeforeDispatch

setDelayBeforeDispatch

getDispatchStartTime

isDispatching

setDispatching

isExclusive

setExclusive

isLastValue

getLastValueKey

isNonDestructive

setNonDestructive

getMaxConsumers

setMaxConsumer

getGroupBuckets

setGroupBuckets

isGroupRebalance

setGroupRebalance

getGroupFirstKey

setGroupFirstKey

isConfigurationManaged

setConfigurationManaged

addConsumer

removeConsumer

getConsumerCount

getConsumerRemovedTimestamp

setConsumersRefCount

getConsumersRefCount

reload

addTail

addTail

addHead

addHead

acknowledge

acknowledge

acknowledge

acknowledge

acknowledge

reacknowledge

cancel

cancel

cancel

deliverAsync

unproposed

forceDelivery

deleteQueue

deleteQueue

destroyPaging

getMessageCount

getPersistentSize

getDurableMessageCount

getDurablePersistentSize

getDeliveringCount

getDeliveringSize