PubSub+ for Developers

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

Get Started with Docker Get 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);

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 PubSub+ 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.

PubSub+ Event Portal

PubSub+ 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 APIs

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

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

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

Read the Documentation

Learn more about Event Portal

Integrate Event Portal w/ SDLC

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.

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
  Get Started
  Solace JCSMP API
  SMF
  Get Started
  Solace JavaRTO
  SMF
  Get Started
  Solace JMS API
  SMF
  Get Started
  Solace REST Messaging API
  REST
  Get Started
  Eclipse Paho Java Client
  MQTT
  Get Started
  QPID JMS 1.1
  AMQP
  Get Started
  QPID JMS 2.0
  AMQP
  Get Started
- Connect with C and C++
  Solace C API over SMF, Paho over MQTT
  Library
  Protocol
  Solace C
  SMF
  Get Started
  Solace REST Messaging API
  REST
  Get Started
  Eclipse Paho C Client
  MQTT
  Get Started
  Eclipse Paho C++ Client
  MQTT
  Get Started
- Connect with Python
  Solace Python API over SMF, Paho over MQTT
  Library
  Protocol
  Solace Python API
  SMF
  Get Started
  Solace REST Messaging API
  REST
  Get Started
  Eclipse Paho Python Client
  MQTT
  Get Started
- Connect with Go
  Solace Go API over SMF
  Library
  Protocol
  Solace Go API
  SMF
  Get Started
- Connect with JavaScript
  Solace Javascript API over SMF, Paho over MQTT
  Library
  Protocol
  Solace JavaScript API
  SMF
  Get Started
  Solace REST Messaging API
  REST
  Get Started
  Eclipse Paho JavaScript Client
  MQTT
  Get Started
- Connect with Node.js
  Solace Node.js API over SMF, AMPQP10 Open Source over AMQP
  Library
  Protocol
  Solace Node.js API
  SMF
  Get Started
  Solace REST Messaging API
  REST
  Get Started
  AMQP10 Open Source API
  AMQP
  Get Started
- Connect with .NET
  Solace .NET API over SMF, Paho over MQTT
  Library
  Protocol
  Solace .NET
  SMF
  Get Started
  Solace REST Messaging API
  REST
  Get Started
  Eclipse Paho .NET Client
  MQTT
  Get Started
- Connect with Spring
  Spring Cloud Stream, Spring Boot
  Projects
  Protocol
  Spring Cloud Stream
  SMF
  Get Started
  Spring Boot Java API
  SMF
  Get Started
  Spring Boot JMS API
  SMF
  Get Started

Resources

API Tutorials

Get up-to-speed in sending and receiving messages over open APIs and protocols, Solace Messaging APIs, and Pivotal Platform.

GitHub Samples

Check out our Solace samples for Spring, JMS, MQTT, AMQP, JavaScript, and more.

Connector Hub

Get a jump start plugging PubSub+ into AWS, Kafka, Spark, IBM WebSphere, and much more.

Training & Certifications

Get up to speed on our managed messaging service.

SDKPerf

SDKPerf is a command line tool for validating performance, checking configuration, and exploring features associated with your PubSub+ message broker.

Developer Community

Technical community for PubSub+.

Codelabs & Workshops

Get guided, hands on coding experience with PubSub+ Codelabs.