PubSub+ for Developers

Create event-driven apps and microservices on any platform with whatever language, open protocols, and APIs you choose.

Get Started with DockerGet Started with Cloud

MessagingService messagingService = MessagingService.builder(ConfigurationProfile.V1)
        .fromProperties(properties).build().connect();
DirectMessagePublisher publisher = messagingService.createDirectMessagePublisherBuilder()
        .onBackPressureWait(1).build().start();
OutboundMessage message = messagingService.messageBuilder().build("Hello World!");
Topic topic = Topic.of("solace/try/this/topic");
publisher.publish(message, topic);
topic = Topic.of("solace/try/this/topic")
messaging_service = MessagingService.builder().from_properties(broker_props).build().connect()
direct_publisher = messaging_service.create_direct_message_publisher_builder().build().start()
outbound_msg = messaging_service.message_builder().build("Hello world!")
direct_publisher.publish(destination=topic, message=outbound_msg)
topic := resource.TopicOf("solace/try/this/topic")
messagingService, err := messaging.NewMessagingServiceBuilder().FromConfigurationProvider(brokerConfig).Build()
directPublisher, builderErr := messagingService.CreateDirectMessagePublisherBuilder().Build()
outbound_msg, err := messagingService.MessageBuilder().BuildWithStringPayload("Hello world")
publishErr := directPublisher.Publish(outbound_msg, topic)
// Publish using Spring Cloud Stream
@Bean
public Supplier helloWorldSend(){
  return () -> {
   return "Hello World";
  };
}
var message = solace.SolclientFactory.createMessage();
message.setDestination(solace.SolclientFactory.createTopicDestination("solace/try/this/topic"));
message.setBinaryAttachment("Sample Message");
message.setDeliveryMode(solace.MessageDeliveryModeType.DIRECT);
publisher.session.send(message);
curl -X POST http://[HOST]:[PORT]/solace/try/this/topic \
-d "Hello World REST" \
-H "Content-Type: text/plain"
--user [client-username]:[password]
String content = "Hello world from MQTT!"
MqttMessage message = new MqttMessage(content.getBytes())
message.setQos(0)
String topic = "solace/try/this/topic"
mqttClient.publish(topic, message)
JMSContext context = connectionFactory.createContext();
Topic topic = context.createTopic("solace/try/this/topic");
TextMessage message = context.createTextMessage("Hello world!");
JMSProducer producer = context.createProducer().setDeliveryMode(DeliveryMode.NON_PERSISTENT);
producer.send(topic, message);
Topic topic = session.createTopic("solace/try/this/topic");
MessageProducer messageProducer = session.createProducer(topic);
TextMessage message = session.createTextMessage("Hello world!");
messageProducer.send(topic, message, DeliveryMode.NON_PERSISTENT,
Message.DEFAULT_PRIORITY, Message.DEFAULT_TIME_TO_LIVE);
PubSub+
MessagingService messagingService = MessagingService.builder(ConfigurationProfile.V1)
        .fromProperties(properties).build().connect();
Topic topic = Topic.of("solace/try/>");
DirectMessageReceiver receiver = messagingService.createDirectMessageReceiverBuilder()
        .withSubscriptions(topic).build().start();
receiver.receiveAsync(messageHandler);
topic = Topic.of("solace/try/>")
messaging_service = MessagingService.builder().from_properties(broker_props).build().connect()
direct_receiver = messaging_service.create_direct_message_receiver_builder().with_subscriptions(topic).build().start()
direct_receiver.receive_async(MessageHandlerImpl())
topic := resource.TopicSubscriptionOf("solace/try/>")
messagingService, err := messaging.NewMessagingServiceBuilder().FromConfigurationProvider(brokerConfig).Build()
directReceiver, err := messagingService.CreateDirectMessageReceiverBuilder().WithSubscriptions(topic).Build()
err := directReceiver.Start()
regErr := directReceiver.ReceiveAsync(MessageHandler)
// Consume using Spring Cloud Stream
@Bean
public Consumer helloWorldConsume(){
  return v -> System.out.println("Received: " + v);
}
subscriber.session.connect();
subscriber.session.subscribe(
solace.SolclientFactory.createTopicDestination("solace/try/>"),
true, correlationObject, 10000
);
http.createServer(function (req, res) {
console.log('Received message: ' + req.url);
res.writeHead(200);
res.end();
}).listen([PORT], '[HOST]');
console.log('Server running at http://[HOST]:[PORT]/');
mqttClient.connect(connOpts);
mqttClient.setCallback(new PrintingMqttCallback());
String topic = "solace/try/>";
int qos = 0;
mqttClient.subscribe(topic, qos);
JMSContext context = connectionFactory.createContext();
Topic topic = context.createTopic("solace/try/>");
JMSConsumer consumer = context.createConsumer(topic);
String message = consumer.receiveBody(String.class);
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
Topic topic = session.createTopic("solace/try/>");
MessageConsumer messageConsumer = session.createConsumer(topic);
messageConsumer.setMessageListener( new MessageDumpListener() );
connection.start();

What is PubSub+?

Solace PubSub+ Platform is a complete event streaming solution that enables the design, deployment, and operation of Event-Driven Architecture (EDA) across hybrid cloud, multi-cloud and IoT environments. The heart of the platform consists of PubSub+ Event Brokers , which connect to form Event Meshes that dynamically route events in real-time, and the Event Portal which is pioneering how organizations manage their EDA.

Solace.dev is the home base for developers using PubSub+ Platform. You'll find information about our Messaging APIs, Platform APIs and more in the sections below. Have questions? Let us know over in the Solace Community.

Solace Event Portal

Solace Event Portal is the leading solution for organizations looking to maximize the value of their Event-Driven Architecture by enhancing the ability to optimize event flows, improve collaboration between developers and architects, and more!

Design and Visualize event-driven systems

Design & Visualize your EDA

Visualize event flows between application domains, applications, and payload schema to event relationships.

Embrace Event API Products

Embrace Event APIs

Curate and share sets of related high-value business events with internal and external developers to enrich customer experiences.

Catalog Your Event Data

Catalog Your Event Data

Document and track existing topics, schemas, event meshes, pub/sub interfaces for each application, owners and points of contact, and changes for each of the managed EDA entities.

Operate your EDA

Operate your EDA

Create and track versions of EDA objects, promote them through environments and analyze dependencies to assess impact

Messaging APIs and Protocols

Solace PubSub+ Event Brokers have built-in support for a variety of proprietary and open standard protocols and APIs, so you can create and connect apps with whatever language, open protocols and APIs you choose, without worrying about translation.

Solace messaging APIs offer uniform client access to all Solace PubSub+ capabilities and qualities of service, and are available for C, .NET, iOS, Java, JavaScript, JMS, Python and Node.js. Solace also supports popular open protocols like AMQP, JMS, MQTT, REST and WebSocket, and open APIs such as Paho and Qpid.

Diagram: APIs and Protocols

Connect Using a Supported Client Library

Select a connection point and supported client library below to start messaging.
View by:
    • Connect with Java
      Solace JCSMP, Solace Java, Solace JMS over SMF, Paho over MQTT, QPID JMS 1.1 over AMQP, QPID JMS 2.0 over AMQP
      Library
      Protocol
      • Solace Java API
        SMF
      • Solace JCSMP API
        SMF
      • Solace JavaRTO
        SMF
      • Solace JMS API
        SMF
      • Solace REST Messaging API
        REST
      • Eclipse Paho Java Client
        MQTT
      • QPID JMS 1.1
        AMQP
      • QPID JMS 2.0
        AMQP
    • Connect with C and C++
      Solace C API over SMF, Paho over MQTT
      Library
      Protocol
      • Solace C
        SMF
      • Solace REST Messaging API
        REST
      • Eclipse Paho C Client
        MQTT
      • Eclipse Paho C++ Client
        MQTT
    • Connect with Python
      Solace Python API over SMF, Paho over MQTT
      Library
      Protocol
      • Solace Python API
        SMF
      • Solace REST Messaging API
        REST
      • Eclipse Paho Python Client
        MQTT
    • Connect with Go
      Solace Go API over SMF
      Library
      Protocol
      • Solace Go API
        SMF
    • Connect with JavaScript
      Solace Javascript API over SMF, Paho over MQTT
      Library
      Protocol
      • Solace JavaScript API
        SMF
      • Solace REST Messaging API
        REST
      • Eclipse Paho JavaScript Client
        MQTT
    • Connect with Node.js
      Solace Node.js API over SMF, AMPQP10 Open Source over AMQP
      Library
      Protocol
      • Solace Node.js API
        SMF
      • Solace REST Messaging API
        REST
      • AMQP10 Open Source API
        AMQP
    • Connect with .NET
      Solace .NET API over SMF, Paho over MQTT
      Library
      Protocol
      • Solace .NET
        SMF
      • Solace REST Messaging API
        REST
      • Eclipse Paho .NET Client
        MQTT
    • Connect with Spring
      Spring Cloud Stream, Spring Boot
      Projects
      Protocol
      • Spring Cloud Stream
        SMF
      • Spring Boot Java API
        SMF
      • Spring Boot JMS API
        SMF

PubSub+ Platform APIs

The PubSub+ Platform APIs are RESTful APIs that enable an API first approach to designing, managing, developing, and operating your Event-Driven Architecture while using PubSub+.

SEMP (Solace Element Management Protocol)

Configure, Monitor, or take Action on the PubSub+ Event Brokers.