In my last blog I discussed the rise of a new era in SOA development with the use of Java Web Services technology powered by the implementation of WS-* specifications. Today, I would like to write few lines about policy metadata - the real core of these new technologies.
Policy language and its usage is described in two separate specifications (which have already been submitted for standardization by W3 Consortium):
- Web Services Policy Framework (WS-Policy) specification and
- Web Services Policy Attachment (WS-PolicyAttachment) specification
These two specifications bind all other WS-* specifications together into one complex solution.
The main goal of the WS-Policy specification is to introduce a flexible and extensible way of expressing and understanding the capabilities, requirements and general web service properties. In other words, WS-Policy provides a web services policy language together with domain-neutral rules as to how to process and interpret these policies. To complement the WS-Policy specification - which is strictly focused on defining policy language - WS-PolicyAttachment completes the whole picture by defining the means of attaching actual policy expresions to policy subjects to which these expressions apply. This second specification also describes the way how to use policies in the context of web services description mechanisms – WSDL and UDDI.
WSIT introduces its own policy engine and I am a part of a team working on its design and implementation. We do our best to make sure the implementation is interoperable and - of course - fully compliant with WS-Policy and WS-PolicyAttachment specifications. Currently, we are still in a development phase and there's much to be tested and polished yet. But we have already achieved success in supporting all main use case scenarios as well as having demonstrated our ability to interoperate with policy engines from other vendors at several Interoperability workshops.
As many of you probably know, web services play an integral part in SOA driven design and development nowadays. This technology emphasizes interoperability and platform independence, which makes it a very important part of most enterprise integration solutions today.
However until recently - in order to set up and deploy a web service and successfully configure its client(s) - lots of duplicated manual administration was required on both sides when configuring all those "extra" features, such as atomic transactions, secured communication, reliable messaging etc. Another issue one had to consider with such advanced web service communication channel configuration was a possible loss of interoperability. Many people working in this area could feel this strong need to change it: to automatize configuration of communication channel as much as possible, so that both - client and service - just need to agree on a set of applicable communication policies and express those in a commonly understandable and widely accepted language.
But this is changing right now! A set of WS-* specifications was introduced to address these issues. Today I am a part of project Tango where we, together with other Sun's Java Web Services engineers involved, are focused on addressing these issues. One of the main goals of this project is to bring to life the new generation of Web Services Interoperability Technology (WSIT) - an open source java implementation of WS-* specifications that enables all this cool stuff to happen while also ensuring interoperability with other vendors.
So are you interested? If yes, the development version of WSIT is there ready for you to download and play with. And don't forget to try it out together with new 5.5 beta release of NetBeans™ IDE and its WSIT modules.
...and - of course - if possible, you should definitely come and join our Java One sessions, where you can
- see the big picture of it,
- watch a tutorial on it,
- get involved and play with it or
- learn something more specific about it