Habari STOMP Client for RabbitMQ

Version 8.1, tested with RabbitMQ 3.11.11

Habari STOMP Client for RabbitMQ is a high-level, object-oriented Stomp client library for Delphi and Free Pascal which provides access to the RabbitMQ free open source message broker.

language

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.

favorite_border

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

filter_list

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 STOMP Client libraries support broker-specific extensions of the Stomp specification. Most of them can be accessed with the same client side code across all broker versions.

timer

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.

traffic

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.

storage

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.

pause_circle_outline

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.

Stomp Extensions

✓ Message Expiration
✓ Message Priority
✓ Persistent Messages
✓ Durable Subscriptions
✓ Rich Message Conversion

import_export

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)

sync

Temporary Queues

Temporary destinations are typically used to receive response messages in a request/response messaging exchange.

Not available for Artemis

Released 1 April 2023

book

Manual

Read the "Getting Started" user guide for Habari STOMP Client for RabbitMQ

search

API

Browse the online API documentation for Habari STOMP Client for RabbitMQ

list

Release Notes

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

help_outline

FAQ

Frequently asked questions: use cases, licensing, and technical

alternate_email

Contact

Contact Habarisoft for support and sales inqueries

view_comfy

Feature Matrix

View the Habari STOMP Client feature matrix

Code Examples

Message Producer Example

code

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;

Message Consumer Example

code

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 a TextMessage within 5 seconds:
    TextMessage := Consumer.Receive(5000);

    WriteLn(TextMessage.Text);

finally
    Connection.Close;
end;

add_shopping_cart

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

Buy now »

lock

Registered users may download the installer for version 8.1 of Habari STOMP Client for RabbitMQ here:

Download »

get_app

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

Download »

update

Minor and major updates included for one year after purchase

cake

Basic support included for one year after purchase

language

Royalty-free usage in your applications

event_seat

Licensed per developer seat

code

Full library source code included

alternate_email

Instant electronic delivery

About the RabbitMQ free open source message broker

With tens of thousands of users, RabbitMQ is one of the most popular open source message brokers. From T-Mobile to Runtastic, RabbitMQ is used worldwide at small startups and large enterprises. (source)

RabbitMQ is lightweight and easy to deploy on premises and in the cloud. It supports multiple messaging protocols. RabbitMQ can be deployed in distributed and federated configurations to meet high-scale, high-availability requirements.

RabbitMQ runs on many operating systems and cloud environments, and provides a wide range of developer tools for most popular languages.

https://www.rabbitmq.com/