See: Description
See: Description
| Package | Description |
|---|---|
| asia.stampy.client.listener.connected |
Provides the abstract listener to intercept incoming CONNECTED messages
|
| asia.stampy.client.listener.disconnect |
Provides the abstract listener to intercept incoming DISCONNECT messages
|
| asia.stampy.client.listener.validate |
Provides a listener to ensure only server messages are accepted on the client
|
| asia.stampy.client.message |
Provides the abstract client header classes
|
| asia.stampy.client.message.abort |
Provides the STOMP 1.2 ABORT header and message classes
|
| asia.stampy.client.message.ack |
Provides the STOMP 1.2 ACK header and message classes
|
| asia.stampy.client.message.begin |
Provides the STOMP 1.2 BEGIN header and message classes
|
| asia.stampy.client.message.commit |
Provides the STOMP 1.2 COMMIT header and message classes
|
| asia.stampy.client.message.connect |
Provides the STOMP 1.2 COMMIT header and message classes
|
| asia.stampy.client.message.disconnect |
Provides the STOMP 1.2 DISCONNECT header and message classes
|
| asia.stampy.client.message.nack |
Provides the STOMP 1.2 NACK header and message classes
|
| asia.stampy.client.message.send |
Provides the STOMP 1.2 SEND header and message classes
|
| asia.stampy.client.message.stomp |
Provides the STOMP 1.2 STOMP header and message classes
|
| asia.stampy.client.message.subscribe |
Provides the STOMP 1.2 SUBSCRIBE header and message classes
|
| asia.stampy.client.message.unsubscribe |
Provides the STOMP 1.2 UNSUBSCRIBE header and message classes
|
| asia.stampy.client.netty |
Provides the gateway and handler to run a Stampy NETTY client
|
| asia.stampy.client.netty.connected |
Provides the NETTY implementation of a CONNECTED message listener
|
| asia.stampy.client.netty.disconnect |
Provides the NETTY implementation of a DISCONNECT message listener
|
| asia.stampy.common |
Provides common classes
|
| asia.stampy.common.gateway |
Provides interfaces and super classes for the implementation of STOMP 1.2 clients and servers
|
| asia.stampy.common.heartbeat |
Provides heartbeat management classes
|
| asia.stampy.common.message |
Provides the STOMP 1.2 common interfaces and super classes for messages
|
| asia.stampy.common.message.interceptor |
Provides interceptor classes to capture outgoing message state, trigger events etc.
|
| asia.stampy.common.netty |
Provides abstract NETTY implementations for clients and servers
|
| asia.stampy.common.parsing |
Provides message parsing tools
|
| asia.stampy.common.serialization |
Provides serialization tools
|
| asia.stampy.server.listener.connect |
Provides the abstract listener to intercept incoming CONNECT messages
|
| asia.stampy.server.listener.heartbeat |
Provides the abstract listener to intercept incoming CONNECT messages requesting heartbeats
|
| asia.stampy.server.listener.login |
Provides the abstract listener to intercept incoming CONNECT messages with login credentials
|
| asia.stampy.server.listener.receipt |
Provides the abstract listener to generate RECEIPT messages for incoming messages requesting such
|
| asia.stampy.server.listener.subscription |
Provides the abstract listener to expect an ACK from a sent MESSAGE
|
| asia.stampy.server.listener.transaction |
Provides the abstract listener to manage transactional boundaries
|
| asia.stampy.server.listener.validate |
Provides a listener to ensure only client messages are accepted on the server
|
| asia.stampy.server.listener.version |
Provides the listener to check version information
|
| asia.stampy.server.message.connected |
Provides the STOMP 1.2 CONNECTED header and message classes
|
| asia.stampy.server.message.error |
Provides the STOMP 1.2 ERROR header and message classes
|
| asia.stampy.server.message.message |
Provides the STOMP 1.2 MESSAGE header and message classes
|
| asia.stampy.server.message.receipt |
Provides the STOMP 1.2 RECEIPT header and message classes
|
| asia.stampy.server.netty |
Provides the gateway and handler to run a Stampy NETTY server
|
| asia.stampy.server.netty.connect |
Provides the NETTY implementation of a CONNECT message listener
|
| asia.stampy.server.netty.heartbeat |
Provides the NETTY implementation of a CONNECT message requesting heartbeats
|
| asia.stampy.server.netty.login |
Provides the NETTY implementation of a CONNECT message with login credentials
|
| asia.stampy.server.netty.receipt |
Provides the NETTY implementation to generate RECEIPT messages for those incoming requesting such
|
| asia.stampy.server.netty.subscription |
Provides the NETTY implementation to expect an ACK for a sent MESSAGE
|
| asia.stampy.server.netty.transaction |
Provides the NETTY implementation to manage transactional boundaries
|
This library provides a Netty implementation of the stampy-client-server-1.0-RELEASE STOMP 1.2 architecture.
While easy to programmatically configure a Netty client gateway, it is expected that a DI framework such as Spring or Guice will be used to perform this task.
The following code demonstrates all that is necessary to configure a STOMP 1.2 compliant client:
public static AbstractStampyMessageGateway initialize() {
HeartbeatContainer heartbeatContainer = new HeartbeatContainer();
ClientNettyMessageGateway gateway = new ClientNettyMessageGateway();
gateway.setPort(1234);
gateway.setHost("localhost");
gateway.setHeartbeat(1000);
ClientNettyChannelHandler channelHandler = new ClientNettyChannelHandler();
channelHandler.setGateway(gateway);
channelHandler.setHeartbeatContainer(heartbeatContainer);
gateway.addMessageListener(new IDontNeedSecurity()); // DON'T DO THIS!!!
gateway.addMessageListener(new ClientMessageValidationListener());
NettyConnectedMessageListener cml = new NettyConnectedMessageListener();
cml.setHeartbeatContainer(heartbeatContainer);
cml.setGateway(gateway);
gateway.addMessageListener(cml);
NettyDisconnectListenerAndInterceptor disconnect = new NettyDisconnectListenerAndInterceptor();
disconnect.setCloseOnDisconnectMessage(false);
gateway.addMessageListener(disconnect);
gateway.addOutgoingMessageInterceptor(disconnect);
disconnect.setGateway(gateway);
gateway.setHandler(channelHandler);
return gateway;
}
While easy to programmatically configure a Netty server gateway, it is expected that a DI framework such as Spring or Guice will be used to perform this task.
The following code demonstrates all that is necessary to configure a STOMP 1.2 compliant server:
public static AbstractStampyMessageGateway initialize() {
HeartbeatContainer heartbeatContainer = new HeartbeatContainer();
ServerNettyMessageGateway gateway = new ServerNettyMessageGateway();
gateway.setPort(1234);
gateway.setHeartbeat(1000);
gateway.setAutoShutdown(true);
ServerNettyChannelHandler channelHandler = new ServerNettyChannelHandler();
channelHandler.setGateway(gateway);
channelHandler.setHeartbeatContainer(heartbeatContainer);
gateway.addMessageListener(new IDontNeedSecurity()); // DON'T DO THIS!!!
gateway.addMessageListener(new ServerMessageValidationListener());
gateway.addMessageListener(new VersionListener());
NettyLoginMessageListener login = new NettyLoginMessageListener();
login.setGateway(gateway);
login.setLoginHandler(new SystemLoginHandler());
gateway.addMessageListener(login);
NettyConnectStateListener connect = new NettyConnectStateListener();
connect.setGateway(gateway);
gateway.addMessageListener(connect);
NettyHeartbeatListener heartbeat = new NettyHeartbeatListener();
heartbeat.setHeartbeatContainer(heartbeatContainer);
heartbeat.setGateway(gateway);
gateway.addMessageListener(heartbeat);
NettyTransactionListener transaction = new NettyTransactionListener();
transaction.setGateway(gateway);
gateway.addMessageListener(transaction);
SystemAcknowledgementHandler sys = new SystemAcknowledgementHandler();
NettyAcknowledgementListenerAndInterceptor acknowledgement = new NettyAcknowledgementListenerAndInterceptor();
acknowledgement.setHandler(sys);
acknowledgement.setGateway(gateway);
acknowledgement.setAckTimeoutMillis(200);
gateway.addMessageListener(acknowledgement);
gateway.addOutgoingMessageInterceptor(acknowledgement);
NettyReceiptListener receipt = new NettyReceiptListener();
receipt.setGateway(gateway);
gateway.addMessageListener(receipt);
NettyConnectResponseListener connectResponse = new NettyConnectResponseListener();
connectResponse.setGateway(gateway);
gateway.addMessageListener(connectResponse);
gateway.setHandler(channelHandler);
return gateway;
}
This library provides the structure to implement STOMP 1.2 clients and servers using the stampy-core library.
A Stampy gateway is the interface between an application and the technology used to create/accept connections from STOMP 1.2 compliant clients and servers. All gateways extend from AbstractStampyMessageGateway. This class contains common methods for all Stampy gateways and defines abstract methods which must be implemented in an implementation.
All gateways allow the addition of any number of StampyMessageListeners which are invoked when a STOMP 1.2 message has been received. By themselves the gateway implementations are not STOMP 1.2 compliant. Compliancy is obtained by adding implementations of this listener. The stampy-client-server library contains implementations which enforce compliance. Any additional custom functionality is obtained by creating a new implementation & adding it to the gateway ie: intercepting a specific message type and notifying the application to perform some bit of functionality. Note: the order of addition of these listeners is important.
At least one implementation of this interface must be included in the list of message listeners, and one must be first in the list else a security exception is thrown. This is to ensure that any custom implementations implement any necessary security for their platform.
Additional security pre-Stampy can be added to the gateway implementations.
All gateways allow the addition of interceptors which are invoked for outgoing messages. There are two types; a message interceptor and a text interceptor. Message interceptors can be tailored to intercept specific types & messages while text interceptors inspect all strings prior to sending them down the pipe. They can be used for outgoing security but are more useful for capturing the state of messages prior to the send. This state can be used to then evaluate any subsequent messages received.
The AbstractDisconnectListenerAndInterceptor and AbstractAcknowledgementListenerAndInterceptor are two classes which make effective use of this functionality.
A heartbeat container instance is used by the gateway to automatically send heartbeats at the agreed upon rate. Heartbeats are started by the client and server using the AbstractConnectedMessageListener and AbstractHeartbeatListener StampyMessageListeners.
This library provides class representations of STOMP 1.2 messages and the ability to convert to and from the classes. It can be used with the additional Stampy libraries or it can be used with existing STOMP client or server implementations.
All STOMP message classes implement the StampyMessage interface. Message classes typically have at least two constructors, one blank & the other with parameters - the parameterized constructors are all the mandatory header values that must be set for a valid STOMP message. Should any mandatory header information be missing an exception will be thrown when the message's
validate()method is called.
Each StampyMessage class has an associated header class which can be obtained by calling the
getHeader()method. The header classes are wrappers around a map which manages the key value pairs. Known key names have their own getter and setter methods; any key value pair can be added to a Stampy message header.
Note: should a header key already exist in the map any subsequent adds for that key will be ignored. This is to enforce the specification: If a client or a server receives repeated frame header entries, only the first header entry SHOULD be used as the value of header entry. Subsequent values are only used to maintain a history of state changes of the header and MAY be ignored. To replace an existing key the header's
removeHeader(existingKey)method must be called first.
A message parser is included for converting the raw string messages to their associated StampyMessage objects.
Any STOMP message that has a body can accept a string as the body as well as any Java serializable object. The mime type used by Stampy to represent such serialized objects is
java/base64Encoding to and from Base64 is handled by the message superclasses & the parser, respectively.
Additional functionality is described in these JavaDocs. This work is released under the GPL 2.0 license. No warranty of any kind is offered. Stampy Copyright (C) 2013 Burton Alexander.