Apache ActiveMQ All JAR Bundle

<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-all</artifactId>
    <version>6.1.7</version>
</dependency>

// Core JMS client classes
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.ActiveMQXAConnectionFactory;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQSession;

// Message types
import org.apache.activemq.command.ActiveMQTextMessage;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.command.ActiveMQTopic;

// Embedded broker
import org.apache.activemq.broker.BrokerService;
import org.apache.activemq.broker.BrokerFactory;

// XA Transaction support
import jakarta.jms.XAConnectionFactory;
import jakarta.jms.XAConnection;
import jakarta.jms.XAJMSContext;

// Spring integration
import org.apache.activemq.spring.ActiveMQConnectionFactory;
import org.apache.activemq.xbean.XBeanBrokerFactory;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQQueue;
import jakarta.jms.*;

// Create connection factory
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
Connection connection = connectionFactory.createConnection();
connection.start();

// Create session and destination
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination destination = new ActiveMQQueue("example.queue");

// Send a message
MessageProducer producer = session.createProducer(destination);
TextMessage message = session.createTextMessage("Hello ActiveMQ!");
producer.send(message);

// Receive a message
MessageConsumer consumer = session.createConsumer(destination);
Message receivedMessage = consumer.receive(1000);

// Clean up
connection.close();

import org.apache.activemq.broker.BrokerService;

// Create and start embedded broker
BrokerService broker = new BrokerService();
broker.setBrokerName("embedded-broker");
broker.addConnector("tcp://localhost:61616");
broker.setPersistent(false); // Use memory storage
broker.start();

// Use the broker...

// Stop broker
broker.stop();

import org.apache.activemq.ActiveMQConnectionFactory;
import jakarta.jms.*;

// Create JMS 2.0 context (simpler than traditional JMS 1.1)
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

try (JMSContext context = connectionFactory.createContext()) {
    // Create destination and producer
    Queue queue = context.createQueue("example.queue");
    JMSProducer producer = context.createProducer();
    
    // Send message
    producer.send(queue, "Hello from JMS 2.0!");
    
    // Create consumer and receive message
    JMSConsumer consumer = context.createConsumer(queue);
    String message = consumer.receiveBody(String.class, 1000);
    
    System.out.println("Received: " + message);
}

// Primary connection factory
public class ActiveMQConnectionFactory implements ConnectionFactory, QueueConnectionFactory, TopicConnectionFactory {
    public ActiveMQConnectionFactory();
    public ActiveMQConnectionFactory(String brokerURL);
    public Connection createConnection() throws JMSException;
    public Connection createConnection(String userName, String password) throws JMSException;
    public void setBrokerURL(String brokerURL);
    public String getBrokerURL();
}

// XA transaction-enabled connection factory
public class ActiveMQXAConnectionFactory extends ActiveMQConnectionFactory implements XAConnectionFactory, XAQueueConnectionFactory, XATopicConnectionFactory {
    public ActiveMQXAConnectionFactory();
    public ActiveMQXAConnectionFactory(String brokerURL);
    public ActiveMQXAConnectionFactory(String userName, String password, String brokerURL);
    public XAConnection createXAConnection() throws JMSException;
    public XAConnection createXAConnection(String userName, String password) throws JMSException;
    public XAJMSContext createXAContext();
    public XAJMSContext createXAContext(String userName, String password);
}

// JMS 2.0 Context API
public class ActiveMQContext implements JMSContext {
    public JMSProducer createProducer();
    public JMSConsumer createConsumer(Destination destination);
    public JMSConsumer createConsumer(Destination destination, String messageSelector);
    public JMSConsumer createDurableConsumer(Topic topic, String name);
    public Queue createQueue(String queueName);
    public Topic createTopic(String topicName);
    public TextMessage createTextMessage(String text);
    public BytesMessage createBytesMessage();
    public MapMessage createMapMessage();
    public void commit() throws JMSRuntimeException;
    public void rollback() throws JMSRuntimeException;
}

// Base message with scheduling support
public class ActiveMQMessage implements Message, ScheduledMessage {
    public void setScheduledDeliveryTime(long scheduledDeliveryTime);
    public long getScheduledDeliveryTime();
    public void setRedeliveryDelay(long redeliveryDelay);
}

// Destination types
public class ActiveMQQueue extends ActiveMQDestination implements Queue {
    public ActiveMQQueue(String name);
    public String getQueueName() throws JMSException;
}

public class ActiveMQTopic extends ActiveMQDestination implements Topic {
    public ActiveMQTopic(String name);
    public String getTopicName() throws JMSException;
}

public class BrokerService implements Service {
    public void start() throws Exception;
    public void stop() throws Exception;
    public TransportConnector addConnector(String bindAddress) throws Exception;
    public void setPersistenceAdapter(PersistenceAdapter persistenceAdapter);
    public void setBrokerName(String brokerName);
    public void setUseJmx(boolean useJmx);
}

public class BrokerFactory {
    public static BrokerService createBroker(URI config) throws Exception;
    public static BrokerService createBrokerFromURI(String uri) throws Exception;
}

// STOMP protocol support
public interface Stomp {
    String CONNECT = "CONNECT";
    String SEND = "SEND";
    String SUBSCRIBE = "SUBSCRIBE";
    String UNSUBSCRIBE = "UNSUBSCRIBE";
    String ACK = "ACK";
    String NACK = "NACK";
}

// AMQP transport
public class AmqpTransport extends TransportSupport {
    public AmqpTransport(WireFormat wireFormat, Socket socket) throws IOException;
}

public interface PersistenceAdapter extends Service {
    MessageStore createQueueMessageStore(ActiveMQQueue destination) throws IOException;
    TopicMessageStore createTopicMessageStore(ActiveMQTopic destination) throws IOException;
    TransactionStore createTransactionStore() throws IOException;
    Set<ActiveMQDestination> getDestinations();
}

public class KahaDBPersistenceAdapter implements PersistenceAdapter, JournaledStore {
    public void setDirectory(File directory);
    public void setJournalMaxFileLength(int journalMaxFileLength);
    public void setIndexCacheSize(int indexCacheSize);
}

// JAAS Login Modules
public class PropertiesLoginModule implements LoginModule {
    public boolean login() throws LoginException;
    public boolean commit() throws LoginException;
    public void initialize(Subject subject, CallbackHandler callbackHandler, 
                          Map<String,?> sharedState, Map<String,?> options);
}

// Shiro Integration
public class ShiroPlugin implements BrokerPlugin {
    public Broker installPlugin(Broker broker) throws Exception;
    public void setIniResourcePath(String iniResourcePath);
}

// Modern pooling implementation
public class PooledConnectionFactory implements ConnectionFactory, JNDIStorableInterface, Service {
    public void setConnectionFactory(ConnectionFactory connectionFactory);
    public void setMaxConnections(int maxConnections);
    public void setMaximumActiveSessionPerConnection(int maximumActiveSessionPerConnection);
    public Connection createConnection() throws JMSException;
}

// XA-enabled pooling
public class JcaPooledConnectionFactory extends PooledConnectionFactory {
    public void setTransactionManager(TransactionManager transactionManager);
    public XAConnection createXAConnection() throws JMSException;
}

// Spring-enhanced connection factory
public class ActiveMQConnectionFactory extends org.apache.activemq.ActiveMQConnectionFactory 
    implements BeanNameAware {
    public void setBeanName(String beanName);
    public void setUseBeanNameAsClientIdPrefix(boolean useBeanNameAsClientIdPrefix);
}

// Spring broker factory
public class BrokerFactoryBean implements FactoryBean<BrokerService>, InitializingBean, 
    DisposableBean, ApplicationContextAware {
    public BrokerService getObject() throws Exception;
    public void setConfig(Resource config);
    public void start() throws Exception;
}

public abstract class NetworkConnector extends DefaultBrokerService implements Service {
    public void setUri(URI uri);
    public void setDiscoveryUri(URI discoveryUri);
    public void setDuplex(boolean duplex);
    public void setNetworkTTL(int networkTTL);
}

public class DiscoveryNetworkConnector extends NetworkConnector {
    public void setDiscoveryAgent(DiscoveryAgent discoveryAgent);
}

public interface BrokerViewMBean {
    String getBrokerId();
    String getBrokerName();
    long getTotalEnqueueCount();
    long getTotalDequeueCount();
    long getTotalConsumerCount();
    void gc() throws Exception;
    void resetStatistics();
}

public interface QueueViewMBean extends DestinationViewMBean {
    long getQueueSize();
    void purge() throws Exception;
    boolean removeMessage(String messageId) throws Exception;
}

public class AlreadyClosedException extends JMSException {
    public AlreadyClosedException();
    public AlreadyClosedException(String reason);
}

public class ConnectionClosedException extends IllegalStateException {
    public ConnectionClosedException();
    public ConnectionClosedException(String message);
}

public class ConnectionFailedException extends JMSException {
    public ConnectionFailedException();
    public ConnectionFailedException(IOException cause);
}

public class MaxFrameSizeExceededException extends IOException {
    public MaxFrameSizeExceededException(String message);
    public MaxFrameSizeExceededException(String message, Throwable cause);
}

// Configuration policies
public class ActiveMQPrefetchPolicy implements Serializable {
    public void setQueuePrefetch(int queuePrefetch);
    public int getQueuePrefetch();
    public void setTopicPrefetch(int topicPrefetch);
    public int getTopicPrefetch();
    public void setDurableTopicPrefetch(int durableTopicPrefetch);
    public int getDurableTopicPrefetch();
}

public class RedeliveryPolicy extends DestinationMapEntry implements Cloneable, Serializable {
    public void setMaximumRedeliveries(int maximumRedeliveries);
    public int getMaximumRedeliveries();
    public void setInitialRedeliveryDelay(long initialRedeliveryDelay);
    public long getInitialRedeliveryDelay();
}

// Usage tracking
public class SystemUsage {
    public void setStoreUsage(StoreUsage storeUsage);
    public StoreUsage getStoreUsage();
    public void setMemoryUsage(MemoryUsage memoryUsage);
    public MemoryUsage getMemoryUsage();
}