Habari Client for ActiveMQ

Habari Client for ActiveMQ is a library for Delphi and Free Pascal which provides access to the Apache ActiveMQ free open source Message Broker.

With this library, developers can build integrated solutions, connecting cross language clients and protocols, using the peer-to-peer or the publish-and-subscribe communication model.

It is easy to configure and provides a high-level API and programming model, based on connections, sessions, destinations, message producers, and message consumers.

The library uses the STOMP protocol for its communication with the message broker. Supported STOMP protocol version levels are 1.0, 1.1 and 1.2.

Habari Client libraries support several broker-specific extensions of the STOMP protocol standard. Please note that library support for broker-specific extensions may be limited or incompatible across clients and broker versions.

Message Expiration

By default, a message never expires. If a message will become obsolete after a certain period, however, you may want to set an expiration time for the message.

Message Priority

A client can specify a priority for each message it sends. Message priorities affect the order in which the messages are delivered to the consumers.

Persistent Messages

Brokers support reliable messaging by allowing messages to be persisted so that they can be recovered if there is failure which kills the broker.

Durable Subscriptions

Even if the client which created the durable subscription is not online, he can still get a copy of all the messages sent to the topic when he comes back online.

Rich Message Conversion

Binary and text messages can be exchanged between STOMP and non-STOMP clients. (Object and map messages are exchanged as text messages)

Temporary Queues

Temporary destinations are typically used to receive response messages in a request/response messaging exchange. (Not supported by Apache ActiveMQ Artemis)

Message Selector

Message selectors allow a subscription to only receive a subset of the messages sent to a destination. (Not supported by RabbitMQ)

Queue Browser

If you want to browse all the messages on a queue in a non-destructive fashion, you can create a browsing subscription. (Only supported by Apache ActiveMQ)

Released 06 October 2018

Manual

Read the "Getting Started" user guide for Habari Client for ActiveMQ

API

Browse the online API documentation for Habari Client for ActiveMQ

Release notes

Browse release notes (new features, enhancements, and bug fixes)

FAQ

Frequently asked questions: use cases, licensing, and technical

Contact

Contact Habarisoft for support and sales inqueries

#$*!0@

Submit a bug report

New Simple API

Code for sending (producing) and receiving (consuming) messages:

procedure TNewApiTests.TestSendMessage;
var
  Factory: IConnectionFactory;
  Context: IMQContext;
  Destination: IQueue;
  Producer: IMQProducer;
  Consumer: IMQConsumer;
  TextMessage: ITextMessage;
begin
  Factory := TBTConnectionFactory.Create;
  
  Context := Factory.CreateContext;
  try
    Destination := Context.CreateQueue(GetQueueName);
 
    Producer := Context.CreateProducer;
    Producer.Send(Destination, 'Hello World');
 
    Consumer := Context.CreateConsumer(Destination);
    TextMessage := Consumer.Receive(2500) as ITextMessage;
 
    CheckEquals('Hello World', TextMessage.Text);
  finally
    Context.Close;
  end;
end;

Standard API

Code for sending (producing) messages:

// Getting connection from the server and starting it
ConnectionFactory := TBTConnectionFactory.Create;

try
    Connection := ConnectionFactory.CreateConnection;
    Connection.Start;

    // Messages are sent and received using a Session. We will
    // create here a non-transactional session object. If you want
    // to use transactions you should set the first parameter to 'true'
    Session := Connection.CreateSession(False, amAutoAcknowledge);

    // Destination represents here our queue 'ExampleQueue' on the
    // server. You don't have to do anything special on the
    // server to create it, it will be created automatically.
    Destination := Session.CreateQueue('ExampleQueue');

    // MessageProducer is used for sending messages (as opposed
    // to MessageConsumer which is used for receiving them)
    Producer := Session.CreateProducer(Destination);                

    // We will send a small TextMessage saying 'My hovercraft is full of eels' in Mandarin:
    TextMessage := Session.CreateTextMessage("我的氣墊船裝滿了鱔魚");

    // Here we are sending the message
    Producer.Send(Message);
finally
    Connection.Close;
end;

Code for receiving (consuming) messages:

// Getting connection from the server and starting it
ConnectionFactory := TBTConnectionFactory.Create;

try
    Connection := ConnectionFactory.CreateConnection;
    Connection.Start;

    // Messages are sent and received using a Session. We will
    // create here a non-transactional session object. If you want
    // to use transactions you should set the first parameter to 'true'
    Session := Connection.CreateSession(False, amAutoAcknowledge);

    // Destination represents here our queue 'ExampleQueue' on the
    // server. You don't have to do anything special on the
    // server to create it, it will be created automatically.
    Destination := Session.CreateQueue('ExampleQueue');

    // MessageConsumer is used for receiving messages (as opposed
    // to MessageProducer which is used for sending them)
    Consumer := Session.CreateConsumer(Destination);                

    // We will try to receive send a TextMessage within 5 seconds:
    TextMessage := Consumer.Receive(5000);

    WriteLn(TextMessage.Text);

finally
    Connection.Close;
end;

Not a registered user? Purchase your developer license of Habari Client for ActiveMQ:

Buy now »

Registered users may download the installer for version 6.0 of Habari Client for ActiveMQ here:

Download »

Try before you buy - get the demo applications of Habari Client for ActiveMQ:

Download »

Instant electronic delivery

Full library source code included

Free redistribution with your product when used in binary compiled applications

Non-exclusive lifetime license and optional subscription (yearly renewal)

Minor and major updates included for one year after purchase

60 day money back guarantee

About the Apache ActiveMQ free open source message broker

Apache ActiveMQ™ is a popular and powerful open source messaging and Integration Patterns server.

Apache ActiveMQ is fast, supports many Cross Language Clients and Protocols, comes with easy to use Enterprise Integration Patterns and many advanced features while fully supporting JMS 1.1 and J2EE 1.4. Apache ActiveMQ is released under the Apache 2.0 License
http://activemq.apache.org/

Habari Client for ActiveMQ version 6.0

Supported broker-specific STOMP extensions