Difference between revisions of "Swordfish Documentation: Architecture: Interceptor Framework"

Latest revision as of 05:06, 20 November 2009

Overview

The Interceptor Framework provides generic support for intercepting messages in different stages of the communication between consumer and provider. It enables implementations that allow the distinguishing role (consumer / provider) and scope (request, response).

Description

The basic ideas of the interceptor framework are:

• Interceptors are exposed as OSGi services with properties that the planner uses to construct interceptor chains based on implemented strategies.
• The interceptor interface has to be as simple as possible to allow straightforward processing of the elements in the chain.
• In order to allow simple implementations, interceptor should not have to verify the current communication stage. (As the planner constructs the chain of interceptors based on implemented strategies the communication stage is clear when the interceptor is called.)
• It should be possible to plug in an instance of a generic interceptors in different interceptor chains.
• Although interceptors should not have to rely on context information they should be able to access, store and even modify it, if necessary:
  • a message tracking interceptor may want to store information about when a message was sent to check how long it took to get a response
  • an interceptor on consumer side may want to add information to a message that is picked up by an interceptor on provider side

Example scenarios

Context based Interceptor registration

Sampe Interceptors

In the example scenario below there are 4 different interceptors implementing the process(...) method defined in the base interface Interceptor. The names of the interceptor classes indicate the purpose of the interceptor. Basically they are supposed to be plugged in on consumer (ExampleConsResInterceptor) and provider side (exampleProvReqInterceptor) to process requests (ExampleConsReqInterceptor) and responses (exampleProvResInterceptor).

Configuration

<!-- Instances of the interceptors -->
<bean id="exampleConsReqInterceptor" class="org.eclipse.swordfish.plugins.samples.ExampleConsReqInterceptor"/>
<bean id="exampleConsResInterceptor" class="org.eclipse.swordfish.plugins.samples.ExampleConsResInterceptor"/>
<bean id="exampleProvReqInterceptor" class="org.eclipse.swordfish.plugins.samples.ExampleProvReqInterceptor"/>
<bean id="exampleProvResInterceptor" class="org.eclipse.swordfish.plugins.samples.ExampleProvResInterceptor"/>

<!-- Expose the exampleConsReqInterceptor as an OSGi service to be used on outgoing requests on consumer side -->
<osgi:service ref="exampleConsReqInterceptor" interface=“org.eclipse.swordfish.core.Interceptor“>
	<osgi:service-properties>
		<entry key=“role“ value=“consumer“/>
		<entry key=“scope“ value=“request“/>
	</osgi:service-properties>
</osgi:service>

<!-- Expose the exampleConsResInterceptor as an OSGi service to be used on incoming responses on consumer side -->
<osgi:service ref="exampleConsResInterceptor" interface=“org.eclipse.swordfish.core.Interceptor“>
	<osgi:service-properties>
		<entry key=“role“ value=“consumer“/>
		<entry key=“scope“ value=“response“/>
	</osgi:service-properties>
</osgi:service>

<!-- Expose the exampleProviderReqInterceptor as an OSGi service to be used on incoming requests on provider side -->
<osgi:service ref="exampleProviderReqInterceptor" interface=“org.eclipse.swordfish.core.Interceptor“>
	<osgi:service-properties>
		<entry key=“role“ value=“provider“/>
		<entry key=“scope“ value=“request“/>
	</osgi:service-properties>
</osgi:service>

<!-- Expose the exampleProvResInterceptor as an OSGi service to be used on outgoing responses on provider side -->
<osgi:service ref="exampleProvResInterceptor" interface=“org.eclipse.swordfish.core.Interceptor“>
	<osgi:service-properties>
		<entry key=“role“ value=“provider“/>
		<entry key=“scope“ value=“response“/>
	</osgi:service-properties>
</osgi:service>

Generic Interceptor registration

If an interceptor should exhibit the same behaviour in all four processing positions, only one instance of the implementation class would be needed and registered as shown below:

<bean id="exampleInterceptor" class="org.eclipse.swordfish.plugins.samples.ExampleInterceptor"/>

<osgi:service ref="exampleInterceptor" interface=“org.eclipse.swordfish.core.Interceptor“>
	<osgi:service-properties>
		<entry key=“role“ value=“consumer,provider“/>
		<entry key=“scope“ value=“request,response“/>
	</osgi:service-properties>
</osgi:service>

See also

Architecture overview

Swordfish JavaDoc