public class JmsMatsEndpoint<R,S,Z> extends java.lang.Object implements MatsEndpoint<R,S>, JmsMatsStatics, JmsMatsStartStoppable
MatsEndpoint.MatsEndpoint.DetachedProcessContext, MatsEndpoint.EndpointConfig<R,S>, MatsEndpoint.MatsObject, MatsEndpoint.MatsRefuseMessageException, MatsEndpoint.ProcessContext<R>, MatsEndpoint.ProcessContextWrapper<R>, MatsEndpoint.ProcessLambda<R,S,I>, MatsEndpoint.ProcessReturnLambda<R,S,I>, MatsEndpoint.ProcessSingleLambda<R,I>, MatsEndpoint.ProcessTerminatorLambda<S,I>EXTRA_GRACE_MILLIS, ILLEGAL_CALL_FLOWS, JMS_MSG_PROP_AUDIT, JMS_MSG_PROP_DISPATCH_TYPE, JMS_MSG_PROP_FROM, JMS_MSG_PROP_INITIALIZING_APP, JMS_MSG_PROP_INITIATOR_ID, JMS_MSG_PROP_MATS_MESSAGE_ID, JMS_MSG_PROP_MESSAGE_TYPE, JMS_MSG_PROP_TO, JMS_MSG_PROP_TRACE_ID, LOG_PREFIX, MAX_STACK_HEIGHT, MAX_TOTAL_CALL_NUMBER, MDC_MATS_APP_NAME, MDC_MATS_APP_VERSION, MDC_MATS_CALL_NUMBER, MDC_MATS_IN_MESSAGE_SYSTEM_ID, MDC_MATS_INIT, MDC_MATS_OUT_MATS_MESSAGE_ID, MDC_MATS_STAGE, MDC_MATS_STAGE_ID, MDC_TRACE_ID, NO_INVOCATION_POINT, RANDOM_ALPHABET, THREAD_PREFIX, TOTAL_JMS_MSG_PROPS_SIZE| Modifier and Type | Method and Description |
|---|---|
boolean |
equals(java.lang.Object o) |
void |
finishSetup()
Should be invoked when all stages has been added.
|
java.util.List<JmsMatsStartStoppable> |
getChildrenStartStoppable()
Must be implemented to provide your children.
|
MatsEndpoint.EndpointConfig<R,S> |
getEndpointConfig() |
JmsMatsFactory<Z> |
getParentFactory() |
java.util.List<MatsStage<R,S,?>> |
getStages() |
int |
hashCode() |
java.lang.String |
idThis() |
<I> MatsStage<R,S,I> |
lastStage(java.lang.Class<I> incomingClass,
java.util.function.Consumer<? super MatsStage.StageConfig<R,S,I>> stageConfigLambda,
MatsEndpoint.ProcessReturnLambda<R,S,I> processor)
Variation of
MatsEndpoint.lastStage(Class, ProcessReturnLambda) that can be configured "on the fly". |
<I> MatsStage<R,S,I> |
lastStage(java.lang.Class<I> incomingClass,
MatsEndpoint.ProcessReturnLambda<R,S,I> processor)
Adds the last stage to a multi-stage endpoint, which also
finishes setup of the endpoint. |
boolean |
remove(int gracefulShutdownMillis)
Should most probably only be used for testing!
First invokes
stop(gracefulShutdownMillis), and if successful removes the endpoint from
its MatsFactory. |
<I> MatsStage<R,S,I> |
stage(java.lang.Class<I> incomingClass,
java.util.function.Consumer<? super MatsStage.StageConfig<R,S,I>> stageConfigLambda,
MatsEndpoint.ProcessLambda<R,S,I> processor)
Variation of
MatsEndpoint.stage(Class, ProcessLambda) that can be configured "on the fly". |
<I> MatsStage<R,S,I> |
stage(java.lang.Class<I> incomingClass,
MatsEndpoint.ProcessLambda<R,S,I> processor)
Adds a new stage to a multi-stage endpoint.
|
void |
start()
Starts the endpoint (unless
MatsEndpoint.finishSetup() has NOT been invoked), invoking MatsStage.start() on
any not-yet started stages of the endpoint (which should be all of them at application startup). |
boolean |
stop(int gracefulShutdownMillis)
Stops the endpoint, invoking
MatsStage.stop(int) on all MatsStages. |
java.lang.String |
toString() |
boolean |
waitForReceiving(int timeoutMillis)
Waits till all stages of the endpoint has entered their receive-loops, i.e.
|
clone, finalize, getClass, notify, notifyAll, wait, wait, waitstopPhase0_SetRunFlagFalse, stopPhase1_CloseSessionIfInReceive, stopPhase2_GracefulWaitAfterRunflagFalse, stopPhase3_InterruptIfStillAlive, stopPhase4_GracefulWaitAfterInterruptcreateFlowId, getInvocationPoint, handleIncomingMessageMatsObject, handleIncomingState, id, id, ms3, produceAndSendMsgSysMessages, randomString, setConcurrencyWithLog, stageOrInitpublic JmsMatsFactory<Z> getParentFactory()
getParentFactory in interface MatsEndpoint<R,S>MatsFactory.public MatsEndpoint.EndpointConfig<R,S> getEndpointConfig()
getEndpointConfig in interface MatsEndpoint<R,S>public <I> MatsStage<R,S,I> stage(java.lang.Class<I> incomingClass, MatsEndpoint.ProcessLambda<R,S,I> processor)
MatsEndpointMatsEndpoint.finishSetup() afterwards - or you could instead use the MatsEndpoint.lastStage(Class, ProcessReturnLambda)
variant which does this automatically.stage in interface MatsEndpoint<R,S>I - the type of the incoming DTO. The very first stage's incoming DTO is the endpoint's incoming DTO. If
the special type MatsEndpoint.MatsObject, this stage can take any type.processor - the lambda that will be invoked when messages arrive in the corresponding queue.MatsEndpoint.MatsObjectpublic <I> MatsStage<R,S,I> stage(java.lang.Class<I> incomingClass, java.util.function.Consumer<? super MatsStage.StageConfig<R,S,I>> stageConfigLambda, MatsEndpoint.ProcessLambda<R,S,I> processor)
MatsEndpointMatsEndpoint.stage(Class, ProcessLambda) that can be configured "on the fly".stage in interface MatsEndpoint<R,S>public <I> MatsStage<R,S,I> lastStage(java.lang.Class<I> incomingClass, MatsEndpoint.ProcessReturnLambda<R,S,I> processor)
MatsEndpointfinishes setup of the endpoint.
Note that the last-stage concept is just a convenience that lets the developer reply from the endpoint with a
return replyDTO statement - you may just as well add a standard stage, and invoke the
MatsEndpoint.ProcessContext.reply(Object) method. Note: If using a normal stage as the last stage, you must remember
to invoke MatsEndpoint.finishSetup() afterwards, as that is then not done automatically.lastStage in interface MatsEndpoint<R,S>I - the type of the incoming DTO. The very first stage's incoming DTO is the endpoint's incoming DTO. If
the special type MatsEndpoint.MatsObject, this stage can take any type.processor - the lambda that will be invoked when messages arrive in the corresponding queue.public <I> MatsStage<R,S,I> lastStage(java.lang.Class<I> incomingClass, java.util.function.Consumer<? super MatsStage.StageConfig<R,S,I>> stageConfigLambda, MatsEndpoint.ProcessReturnLambda<R,S,I> processor)
MatsEndpointMatsEndpoint.lastStage(Class, ProcessReturnLambda) that can be configured "on the fly".lastStage in interface MatsEndpoint<R,S>public java.util.List<MatsStage<R,S,?>> getStages()
getStages in interface MatsEndpoint<R,S>MatsStages, representing all the stages of the endpoint. The order is the same as the
order in which the stages will be invoked. For single-staged endpoints and terminators, this list is of
size 1.public void finishSetup()
MatsEndpointMatsEndpoint.lastStage(Class, ProcessReturnLambda), which again implies that it will be invoked when creating
single-stage endpoints and
terminators and
subscription
terminators.
This sets the state of the endpoint to "finished setup", and will invoke MatsEndpoint.start() on the endpoint,
unless MatsFactory.holdEndpointsUntilFactoryIsStarted() has been invoked prior to creating the
endpoint.
You may implement "delayed start" of an endpoint by not invoking finishedSetup() after setting it up.
Taking into account the first chapter of this JavaDoc, note that you must then only use the
staged type of Endpoint setup, as the others implicitly invokes
finishSetup(), and also not invoke lastStage on it as this
also implicitly invokes finishSetup(). When setting an Endpoint up without calling finishSetup(), even when
MatsFactory.start() is invoked, such a not-finished endpoint will then not be started. You may then later
invoke finishSetup(), e.g. when any needed caches are finished populated, and the endpoint will then be finished
and started.
Another way to implement "delayed start" is to obviously just not create the endpoint until later: MatsFactory
has no "that's it, now all endpoints must have been created"-lifecycle stage, and can fire up new
endpoints until the JVM is dead.finishSetup in interface MatsEndpoint<R,S>public void start()
MatsEndpointMatsEndpoint.finishSetup() has NOT been invoked), invoking MatsStage.start() on
any not-yet started stages of the endpoint (which should be all of them at application startup).start in interface MatsConfig.StartStoppablestart in interface MatsEndpoint<R,S>public java.util.List<JmsMatsStartStoppable> getChildrenStartStoppable()
JmsMatsStartStoppablegetChildrenStartStoppable in interface JmsMatsStartStoppablepublic boolean waitForReceiving(int timeoutMillis)
MatsEndpointMatsStage.waitForReceiving(int) on all MatsStages of the endpoint.
Note: This method makes most sense for
SubscriptionTerminators: These are based on MQ Topics, whose semantics are that if you do not listen right when
someone says something, you will not hear it. This means that a SubscriptionTerminator will never receive a
message that was sent before it had started the receive-loop. Thus, if you in a service-"boot" phase send
a message whose result will come in to a SubscriptionTerminator, you will not receive this result if the
receive-loop has not started. This is relevant for certain cache setups where you listen for event updates, and
when "booting" the cache, you need to be certain that you have started receiving updates before asking for the
"initial load" of the cache. It is also relevant for tools like the MatsFuturizer, which uses a
node-specific Topic for the final reply message from the requested service; If the SubscriptionTerminator has not
yet made it to the receive-loop, any replies will simply be lost and the future never completed.
Note: Currently, this only holds for the initial start. If the entity has started the receive-loop at some point,
it will always immediately return - even though it is currently stopped.waitForReceiving in interface JmsMatsStartStoppablewaitForReceiving in interface MatsConfig.StartStoppablewaitForReceiving in interface MatsEndpoint<R,S>timeoutMillis - number of milliseconds before giving up the wait, returning false. 0 is indefinite
wait, negative values are not allowed.true if successfully started listening for messages).public boolean stop(int gracefulShutdownMillis)
MatsEndpointMatsStage.stop(int) on all MatsStages.stop in interface JmsMatsStartStoppablestop in interface MatsConfig.StartStoppablestop in interface MatsEndpoint<R,S>gracefulShutdownMillis - number of milliseconds to let the stage processors wait after having asked for them to shut down,
and interrupting them if they have not shut down yet.true if successfully stopped all listening
threads).public boolean remove(int gracefulShutdownMillis)
MatsEndpointstop(gracefulShutdownMillis), and if successful removes the endpoint from
its MatsFactory. This enables a new endpoint to be registered with the same endpointId as the one removed (which
otherwise is not accepted). This might be of interest in testing scenarios, where you want to change the
implementation of an endpoint from one test to another. There is currently no known situation where this makes
sense to do "in production": Once the system is set up with the correct endpoints, it should most probably stay
that way!remove in interface MatsEndpoint<R,S>MatsEndpoint.stop(int gracefulShutdownMillis) was successful, and thus whether the endpoint was
removed from its MatsFactory.public boolean equals(java.lang.Object o)
equals in class java.lang.Objectpublic int hashCode()
hashCode in class java.lang.Objectpublic java.lang.String idThis()
idThis in interface JmsMatsStaticspublic java.lang.String toString()
toString in class java.lang.Object