1
2Service Component Architecture SCA-J 3Common Annotations and APIs 4Specification Version 1.1
5Committee Specification Draft 06
615 August 2011
7Specification URIs 8This version: 9 http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec-csd06.pdf (Authoritative) 10 http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec-csd06.html 11 http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec-csd06.doc 12Previous version: 13 http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec-csprd03.pdf (Authoritative) 14 http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec-csprd03.html 15 http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec-csprd03.doc 16Latest version: 17 http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec.pdf (Authoritative) 18 http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec.html 19 http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec.doc 20Technical Committee: 21 OASIS Service Component Architecture / J (SCA-J) TC 22Chairs: 23 David Booz ([email protected]), IBM 24 Anish Karmarkar ([email protected]), Oracle 25Editors: 26 David Booz ([email protected]), IBM 27 Mike Edwards ([email protected]), IBM 28 Anish Karmarkar ([email protected]), Oracle 29Additional artifacts: 30 This prose specification is one component of a Work Product which also includes: 31 Compiled Java API: http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec- 32 csd06/sca-j-caa-apis-1.1-csd06.jar 33 Java artifacts: http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec-csd06/sca-j- 34 caa-sources-1.1-csd06.zip 35 Downloadable Javadoc: http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec- 36 csd06/sca-j-caa-javadoc-1.1-csd06.zip 37 Hosted Javadoc: http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec- 38 csd06/javadoc/index.html 1sca-javacaa-1.1-spec-csd06 15 August 2011 2Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 1 of 121 39Related work: 40 This specification replaces or supersedes: 41 Service Component Architecture Java Common Annotations and APIs Specification Version 42 1.00. March 21 2007. 43 http://www.osoa.org/download/attachments/35/SCA_JavaAnnotationsAndAPIs_V100.pdf?version=1 44 This specification is related to: 45 Service Component Architecture Assembly Model Specification Version 1.1. Latest version. 46 http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec.html 47 SCA Policy Framework Version 1.1. Latest version. 48 http://docs.oasis-open.org/opencsa/sca-policy/sca-policy-1.1.html 49Declared XML namespaces: 50 http://docs.oasis-open.org/ns/opencsa/sca/200912 51Abstract: 52 The SCA-J Common Annotations and APIs Specification defines a Java syntax for programming 53 concepts defined in the SCA Assembly Model Specification. It specifies a set of APIs and 54 annotations that can be used by Java-based artifacts described by other SCA specifications such 55 as the POJO Component Implementation Specification [JAVA_CI]. 56 Specifically, this specification covers: 57 1. Implementation metadata for specifying component services, references, and properties 58 2. A client and component API 59 3. Metadata for asynchronous services 60 4. Metadata for callbacks 61 5. Definitions of standard component implementation scopes 62 6. Java to WSDL and WSDL to Java mappings 63 7. Security policy annotations 64 Note that other Java-based SCA specifications can choose to implement their own mappings of 65 assembly model concepts using native APIs and idioms when appropriate. 66Status: 67 This document was last revised or approved by the OASIS Service Component Architecture / J 68 (SCA-J) TC on the above date. The level of approval is also listed above. Check the “Latest 69 version” location noted above for possible later revisions of this document. 70 Technical Committee members should send comments on this specification to the Technical 71 Committee’s email list. Others should send comments to the Technical Committee by using the 72 “Send A Comment” button on the Technical Committee’s web page at http://www.oasis- 73 open.org/committees/sca-j/. 74 For information on whether any patents have been disclosed that may be essential to 75 implementing this specification, and any offers of patent licensing terms, please refer to the 76 Intellectual Property Rights section of the Technical Committee web page (http://www.oasis- 77 open.org/committees/sca-j/ipr.php). 78Citation format: 79 When referencing this specification the following citation format should be used: 80 [SCA-JavaCAA-v1.1] 81 Service Component Architecture SCA-J Common Annotations and APIs Specification Version 82 1.1. 15 August 2011. OASIS Committee Specification Draft 06. 83 http://docs.oasis-open.org/opencsa/sca-j/sca-javacaa-1.1-spec-csd06.html
3sca-javacaa-1.1-spec-csd06 15 August 2011 4Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 2 of 121 84Notices
85Copyright © OASIS Open 2011. All Rights Reserved. 86All capitalized terms in the following text have the meanings assigned to them in the OASIS Intellectual 87Property Rights Policy (the "OASIS IPR Policy"). The full Policy may be found at the OASIS website. 88This document and translations of it may be copied and furnished to others, and derivative works that 89comment on or otherwise explain it or assist in its implementation may be prepared, copied, published, 90and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice 91and this section are included on all such copies and derivative works. However, this document itself may 92not be modified in any way, including by removing the copyright notice or references to OASIS, except as 93needed for the purpose of developing any document or deliverable produced by an OASIS Technical 94Committee (in which case the rules applicable to copyrights, as set forth in the OASIS IPR Policy, must 95be followed) or as required to translate it into languages other than English. 96The limited permissions granted above are perpetual and will not be revoked by OASIS or its successors 97or assigns. 98This document and the information contained herein is provided on an "AS IS" basis and OASIS 99DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY 100WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY 101OWNERSHIP RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A 102PARTICULAR PURPOSE. 103OASIS requests that any OASIS Party or any other party that believes it has patent claims that would 104necessarily be infringed by implementations of this OASIS Committee Specification or OASIS Standard, 105to notify OASIS TC Administrator and provide an indication of its willingness to grant patent licenses to 106such patent claims in a manner consistent with the IPR Mode of the OASIS Technical Committee that 107produced this specification. 108OASIS invites any party to contact the OASIS TC Administrator if it is aware of a claim of ownership of 109any patent claims that would necessarily be infringed by implementations of this specification by a patent 110holder that is not willing to provide a license to such patent claims in a manner consistent with the IPR 111Mode of the OASIS Technical Committee that produced this specification. OASIS may include such 112claims on its website, but disclaims any obligation to do so. 113OASIS takes no position regarding the validity or scope of any intellectual property or other rights that 114might be claimed to pertain to the implementation or use of the technology described in this document or 115the extent to which any license under such rights might or might not be available; neither does it represent 116that it has made any effort to identify any such rights. Information on OASIS' procedures with respect to 117rights in any document or deliverable produced by an OASIS Technical Committee can be found on the 118OASIS website. Copies of claims of rights made available for publication and any assurances of licenses 119to be made available, or the result of an attempt made to obtain a general license or permission for the 120use of such proprietary rights by implementers or users of this OASIS Committee Specification or OASIS 121Standard, can be obtained from the OASIS TC Administrator. OASIS makes no representation that any 122information or list of intellectual property rights will at any time be complete, or that any claims in such list 123are, in fact, Essential Claims. 124The name "OASIS" is a trademark of OASIS, the owner and developer of this specification, and should be 125used only to refer to the organization and its official outputs. OASIS welcomes reference to, and 126implementation and use of, specifications, while reserving the right to enforce its marks against 127misleading uses. Please see http://www.oasis-open.org/who/trademark.php for above guidance. 128
5sca-javacaa-1.1-spec-csd06 15 August 2011 6Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 3 of 121 129Table of Contents
1301 Introduction...... 7 131 1.1 Terminology...... 7 132 1.2 Normative References...... 7 133 1.3 Non-Normative References...... 8 134 1.4 Testcases...... 8 1352 Implementation Metadata...... 9 136 2.1 Service Metadata...... 9 137 2.1.1 @Service...... 9 138 2.1.2 Java Semantics of a Remotable Service...... 9 139 2.1.3 Java Semantics of a Local Service...... 9 140 2.1.4 @Reference...... 10 141 2.1.5 @Property...... 10 142 2.2 Implementation Scopes: @Scope, @Init, @Destroy...... 10 143 2.2.1 Stateless Scope...... 10 144 2.2.2 Composite Scope...... 11 145 2.3 @AllowsPassByReference...... 11 146 2.3.1 Marking Services as “allows pass by reference”...... 12 147 2.3.2 Marking References as “allows pass by reference”...... 12 148 2.3.3 Applying “allows pass by reference” to Service Proxies...... 12 149 2.3.4 Using “allows pass by reference” to Optimize Remotable Calls...... 13 1503 Interface...... 14 151 3.1 Java Interface Element –
7sca-javacaa-1.1-spec-csd06 15 August 2011 8Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 4 of 121 173 7.1 @OneWay...... 24 174 7.2 Callbacks...... 24 175 7.2.1 Using Callbacks...... 24 176 7.2.2 Callback Instance Management...... 26 177 7.2.3 Callback Injection...... 26 178 7.2.4 Implementing Multiple Bidirectional Interfaces...... 26 179 7.2.5 Accessing Callbacks...... 27 180 7.3 Asynchronous handling of Long Running Service Operations...... 28 181 7.4 SCA Asynchronous Service Interface...... 28 1828 Policy Annotations for Java...... 31 183 8.1 General Intent Annotations...... 31 184 8.2 Specific Intent Annotations...... 33 185 8.2.1 How to Create Specific Intent Annotations...... 34 186 8.3 Application of Intent Annotations...... 34 187 8.3.1 Intent Annotation Examples...... 35 188 8.3.2 Inheritance and Annotation...... 37 189 8.4 Relationship of Declarative and Annotated Intents...... 38 190 8.5 Policy Set Annotations...... 38 191 8.6 Security Policy Annotations...... 39 192 8.7 Transaction Policy Annotations...... 40 1939 Java API...... 42 194 9.1 Component Context...... 42 195 9.2 Request Context...... 47 196 9.3 ServiceReference Interface...... 49 197 9.4 ResponseDispatch interface...... 50 198 9.5 ServiceRuntimeException...... 51 199 9.6 ServiceUnavailableException...... 52 200 9.7 InvalidServiceException...... 52 201 9.8 Constants...... 52 202 9.9 SCAClientFactory Class...... 53 203 9.10 SCAClientFactoryFinder Interface...... 56 204 9.11 SCAClientFactoryFinderImpl Class...... 57 205 9.12 NoSuchDomainException...... 58 206 9.13 NoSuchServiceException...... 58 20710 Java Annotations...... 59 208 10.1 @AllowsPassByReference...... 59 209 10.2 @AsyncFault...... 60 210 10.3 @AsyncInvocation...... 61 211 10.4 @Authentication...... 61 212 10.5 @Authorization...... 62 213 10.6 @Callback...... 63 214 10.7 @ComponentName...... 64 215 10.8 @Confidentiality...... 65 216 10.9 @Constructor...... 65 217 10.10 @Context...... 66
9sca-javacaa-1.1-spec-csd06 15 August 2011 10Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 5 of 121 218 10.11 @Destroy...... 67 219 10.12 @EagerInit...... 67 220 10.13 @Init...... 68 221 10.14 @Integrity...... 68 222 10.15 @Intent...... 69 223 10.16 @ManagedSharedTransaction...... 70 224 10.17 @ManagedTransaction...... 70 225 10.18 @MutualAuthentication...... 71 226 10.19 @NoManagedTransaction...... 72 227 10.20 @OneWay...... 72 228 10.21 @PolicySets...... 73 229 10.22 @Property...... 74 230 10.23 @Qualifier...... 75 231 10.24 @Reference...... 76 232 10.24.1 Reinjection...... 78 233 10.25 @Remotable...... 80 234 10.26 @Requires...... 82 235 10.27 @Scope...... 82 236 10.28 @Service...... 83 23711 WSDL to Java and Java to WSDL...... 85 238 11.1 JAX-WS Annotations and SCA Interfaces...... 85 239 11.2 JAX-WS Client Asynchronous API for a Synchronous Service...... 91 240 11.3 Treatment of SCA Asynchronous Service API...... 92 24112 Conformance...... 93 242 12.1 SCA Java XML Document...... 93 243 12.2 SCA Java Class...... 93 244 12.3 SCA Runtime...... 93 245Appendix A. XML Schema: sca-interface-java-1.1.xsd...... 94 246Appendix B. Java Classes and Interfaces...... 95 247 B.1 SCAClient Classes and Interfaces...... 95 248 B.1.1 SCAClientFactory Class...... 95 249 B.1.2 SCAClientFactoryFinder interface...... 97 250 B.1.3 SCAClientFactoryFinderImpl class...... 98 251 B.1.4 SCAClient Classes and Interfaces - what does a vendor need to do?...... 103 252Appendix C. Conformance Items...... 104 253Appendix D. Acknowledgements...... 119 254Appendix E. Revision History...... 121 255 256
11sca-javacaa-1.1-spec-csd06 15 August 2011 12Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 6 of 121 2571 Introduction 258The SCA-J Common Annotations and APIs specification defines a Java syntax for programming concepts 259defined in the SCA Assembly Model Specification [ASSEMBLY]. It specifies a set of APIs and annotations 260that can be used by SCA Java-based specifications. 261Specifically, this specification covers: 262 1. Implementation metadata for specifying component services, references, and properties 263 2. A client and component API 264 3. Metadata for asynchronous services 265 4. Metadata for callbacks 266 5. Definitions of standard component implementation scopes 267 6. Java to WSDL and WSDL to Java mappings 268 7. Security policy annotations 269The goal of defining the annotations and APIs in this specification is to promote consistency and reduce 270duplication across the various SCA Java-based specifications. The annotations and APIs defined in this 271specification are designed to be used by other SCA Java-based specifications in either a partial or 272complete fashion.
273 1.1 Terminology 274The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD 275NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described 276in [RFC2119].
277 1.2 Normative References 278 [RFC2119] S. Bradner, Key words for use in RFCs to Indicate Requirement Levels, 279 http://www.ietf.org/rfc/rfc2119.txt, IETF RFC 2119, March 1997. 280 [ASSEMBLY] OASIS Committee Specification Draft 08, SCA Assembly Model Specification 281 Version 1.1, May 2011. 282 http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-spec-v1.1- 283 csd08.pdf 284 [SDO] OASIS Committee Draft 02, Service Data Objects Specification Version 3.0, 285 November 2009. 286 http://www.oasis-open.org/committees/download.php/35313/sdo-3.0-cd02.zip 287 [JAX-B] JAXB 2.1 Specification, http://www.jcp.org/en/jsr/detail?id=222 288 [WSDL] WSDL Specification, WSDL 1.1: http://www.w3.org/TR/wsdl, 289 [POLICY] OASIS Committee Specification Draft 05, SCA Policy Framework Version 1.1, 290 July 2011. 291 http://docs.oasis-open.org/opencsa/sca-policy/sca-policy-spec-v1.1-csd05.pdf 292 [JSR-250] Common Annotations for the Java Platform specification (JSR-250), 293 http://www.jcp.org/en/jsr/detail?id=250 294 [JAX-WS] JAX-WS 2.1 Specification (JSR-224), http://www.jcp.org/en/jsr/detail?id=224 295 [JAVABEANS] JavaBeans 1.01 Specification, 296 http://java.sun.com/javase/technologies/desktop/javabeans/api/ 297 [JAAS] Java Authentication and Authorization Service Reference Guide
298 http://java.sun.com/javase/6/docs/technotes/guides/security/jaas/JAASRefGuide. 299 html
13sca-javacaa-1.1-spec-csd06 15 August 2011 14Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 7 of 121 301 1.3 Non-Normative References 302 [EBNF-Syntax] Extended BNF syntax format used for formal grammar of constructs 303 http://www.w3.org/TR/2004/REC-xml-20040204/#sec-notation 304 [JAVA_CI] OASIS Committee Specification Draft 04, SCA POJO Component 305 Implementation Specification Version 1.1, August 2011. 306 http://docs.oasis-open.org/opencsa/sca-j/sca-javaci-1.1-spec-csd04.pdf 307 [CAA_Testcases] OASIS Committee Specification Draft 02, TestCases for the SCA-J Common 308 Annotations and APIs Version 1.1 Specification, August 2011. 309 http://docs.oasis-open.org/opencsa/sca-j/sca-j-caa-testcases-v1.1-csd02.pdf
310 1.4 Testcases 311The TestCases for the SCA-J Common Annotations and APIs Version 1.1 Specification [CAA_Testcases] 312defines the TestCases for the SCA-J Common Annotations and API specification. The TestCases 313represent a series of tests that SCA runtimes are expected to pass in order to claim conformance to the 314requirements of the SCA-J Common Annotations and API specification.
15sca-javacaa-1.1-spec-csd06 15 August 2011 16Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 8 of 121 3152 Implementation Metadata 316This section describes SCA Java-based metadata, which applies to Java-based implementation types.
317 2.1 Service Metadata
318 2.1.1 @Service 319The @Service annotation is used on a Java class to specify the interfaces of the services provided by 320the implementation. Service interfaces are defined in one of the following ways: 321 As a Java interface 322 As a Java class 323 As a Java interface generated from a Web Services Description Language [WSDL] (WSDL) portType 324 (Java interfaces generated from WSDL portTypes are always remotable)
325 2.1.2 Java Semantics of a Remotable Service 326A remotable service is defined using the @Remotable annotation on the Java interface or Java class 327that defines the service, or on a service reference. Remotable services are intended to be used for 328coarse grained services, and the parameters are passed by-value. Remotable Services MUST NOT 329make use of method overloading. [JCA20001] 330Snippet 2-1 shows an example of a Java interface for a remotable service: 331 332 package services.hello; 333 @Remotable 334 public interface HelloService { 335 String hello(String message); 336 } 337Snippet 2-1: Remotable Java Interface
338 2.1.3 Java Semantics of a Local Service 339A local service can only be called by clients that are deployed within the same address space as the 340component implementing the local service. 341A local interface is defined by a Java interface or a Java class with no @Remotable annotation. 342Snippet 2-2 shows an example of a Java interface for a local service: 343 344 package services.hello; 345 public interface HelloService { 346 String hello(String message); 347 } 348Snippet 2-2: Local Java Interface 349 350The style of local interfaces is typically fine grained and is intended for tightly coupled interactions. 351The data exchange semantic for calls to local services is by-reference. This means that implementation 352code which uses a local interface needs to be written with the knowledge that changes made to 353parameters (other than simple types) by either the client or the provider of the service are visible to the 354other.
17sca-javacaa-1.1-spec-csd06 15 August 2011 18Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 9 of 121 355 2.1.4 @Reference 356Accessing a service using reference injection is done by defining a field, a setter method, or a constructor 357parameter typed by the service interface and annotated with a @Reference annotation.
358 2.1.5 @Property 359Implementations can be configured with data values through the use of properties, as defined in the SCA 360Assembly Model specification [ASSEMBLY]. The @Property annotation is used to define an SCA 361property.
362 2.2 Implementation Scopes: @Scope, @Init, @Destroy 363Component implementations can either manage their own state or allow the SCA runtime to do so. In the 364latter case, SCA defines the concept of implementation scope, which specifies a visibility and lifecycle 365contract an implementation has with the SCA runtime. Invocations on a service offered by a component 366will be dispatched by the SCA runtime to an implementation instance according to the semantics of its 367implementation scope. 368Scopes are specified using the @Scope annotation on the implementation class. 369This specification defines two scopes: 370 STATELESS 371 COMPOSITE 372Java-based implementation types can choose to support any of these scopes, and they can define new 373scopes specific to their type. 374An implementation type can allow component implementations to declare lifecycle methods that are 375called when an implementation is instantiated or the scope is expired. 376@Init denotes a method called upon first use of an instance during the lifetime of the scope (except for 377composite scoped implementation marked to eagerly initialize, see section Composite Scope). 378@Destroy specifies a method called when the scope ends. 379Note that only no-argument methods with a void return type can be annotated as lifecycle methods. 380Snippet 2-3 is an example showing a fragment of a service implementation annotated with lifecycle 381methods: 382 383 @Init 384 public void start() { 385 ... 386 } 387 388 @Destroy 389 public void stop() { 390 ... 391 } 392Snippet 2-3: Java Component Implementation with Lifecycle Methods 393 394The following sections specify the two standard scopes which a Java-based implementation type can 395support.
396 2.2.1 Stateless Scope 397For stateless scope components, there is no implied correlation between implementation instances used 398to dispatch service requests. 399The concurrency model for the stateless scope is single threaded. This means that the SCA runtime 400MUST ensure that a stateless scoped implementation instance object is only ever dispatched on one 19sca-javacaa-1.1-spec-csd06 15 August 2011 20Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 10 of 121 401thread at any one time. [JCA20002] In addition, within the SCA lifecycle of a stateless scoped 402implementation instance, the SCA runtime MUST only make a single invocation of one business method. 403[JCA20003] Note that the SCA lifecycle might not correspond to the Java object lifecycle due to runtime 404techniques such as pooling.
405 2.2.2 Composite Scope 406The meaning of "composite scope" is defined in relation to the composite containing the component. 407It is important to distinguish between different uses of a composite, where these uses affect the numbers 408of instances of components within the composite. There are 2 cases: 409a) Where the composite containing the component using the Java implementation is the SCA Domain 410 (i.e. a deployment composite declares the component using the implementation) 411b) Where the composite containing the component using the Java implementation is itself used as the 412 implementation of a higher level component (any level of nesting is possible, but the component is 413 NOT at the Domain level) 414Where an implementation is used by a "domain level component", and the implementation is marked 415"Composite" scope, the SCA runtime MUST ensure that all consumers of the component appear to be 416interacting with a single runtime instance of the implementation. [JCA20004] 417Where an implementation is marked "Composite" scope and it is used by a component that is nested 418inside a composite that is used as the implementation of a higher level component, the SCA runtime 419MUST ensure that all consumers of the component appear to be interacting with a single runtime instance 420of the implementation. There can be multiple instances of the higher level component, each running on 421different nodes in a distributed SCA runtime. [JCA20008] 422The SCA runtime can exploit shared state technology in combination with other well known high 423availability techniques to provide the appearance of a single runtime instance for consumers of composite 424scoped components. 425The lifetime of the containing composite is defined as the time it becomes active in the runtime to the time 426it is deactivated, either normally or abnormally. 427When the implementation class is marked for eager initialization, the SCA runtime MUST create a 428composite scoped instance when its containing component is started. [JCA20005] If a method of an 429implementation class is marked with the @Init annotation, the SCA runtime MUST call that method when 430the implementation instance is created. [JCA20006] 431The concurrency model for the composite scope is multi-threaded. This means that the SCA runtime MAY 432run multiple threads in a single composite scoped implementation instance object and the SCA runtime 433MUST NOT perform any synchronization. [JCA20007]
434 2.3 @AllowsPassByReference 435Calls to remotable services (see section "Java Semantics of a Remotable Service") have by-value 436semantics. This means that input parameters passed to the service can be modified by the service 437without these modifications being visible to the client. Similarly, the return value or exception from the 438service can be modified by the client without these modifications being visible to the service 439implementation. For remote calls (either cross-machine or cross-process), these semantics are a 440consequence of marshalling input parameters, return values and exceptions “on the wire” and 441unmarshalling them “off the wire” which results in physical copies being made. For local method calls 442within the same JVM, Java language calling semantics are by-reference and therefore do not provide the 443correct by-value semantics for SCA remotable interfaces. To compensate for this, the SCA runtime can 444intervene in these calls to provide by-value semantics by making copies of any mutable objects passed. 445The cost of such copying can be very high relative to the cost of making a local call, especially if the data 446being passed is large. Also, in many cases this copying is not needed if the implementation observes 447certain conventions for how input parameters, return values and exceptions are used. The 448@AllowsPassByReference annotation allows service method implementations and client references to be 449marked as “allows pass by reference” to indicate that they use input parameters, return values and
21sca-javacaa-1.1-spec-csd06 15 August 2011 22Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 11 of 121 450exceptions in a manner that allows the SCA runtime to avoid the cost of copying mutable objects when a 451remotable service is called locally within the same JVM.
452 2.3.1 Marking Services as “allows pass by reference” 453Marking a service method implementation as “allows pass by reference” asserts that the method 454implementation observes the following restrictions: 455 Method execution will not modify any input parameter before the method returns. 456 The service implementation will not retain a reference to any mutable input parameter, mutable return 457 value or mutable exception after the method returns. 458 The method will observe “allows pass by reference” client semantics (see section 2.3.2) for any 459 callbacks that it makes. 460See section "@AllowsPassByReference" for details of how the @AllowsPassByReference annotation is 461used to mark a service method implementation as “allows pass by reference”.
462 2.3.2 Marking References as “allows pass by reference” 463Marking a client reference as “allows pass by reference” asserts that method calls through the reference 464observe the following restrictions: 465 The client implementation will not modify any of the method’s input parameters before the method 466 returns. Such modifications might occur in callbacks or separate client threads. 467 If the method is one-way, the client implementation will not modify any of the method’s input 468 parameters at any time after calling the method. This is because one-way method calls return 469 immediately without waiting for the service method to complete. 470See section "Applying “allows pass by reference” to Service Proxies" for details of how the 471@AllowsPassByReference annotation is used to mark a client reference as “allows pass by reference”.
472 2.3.3 Applying “allows pass by reference” to Service Proxies 473Service method calls are made by clients using service proxies, which can be obtained by injection into 474client references or by making API calls. A service proxy is marked as “allows pass by reference” if and 475only if any of the following applies: 476 It is injected into a reference or callback reference that is marked “allows pass by reference”. 477 It is obtained by calling ComponentContext.getService() or ComponentContext.getServices() with the 478 name of a reference that is marked “allows pass by reference”. 479 It is obtained by calling RequestContext.getCallback() from a service implementation that is marked 480 “allows pass by reference”. 481 It is obtained by calling ServiceReference.getService() on a service reference that is marked “allows 482 pass by reference”. 483A service reference for a remotable service call is marked “allows pass by reference” if and only if any of 484the following applies: 485 It is injected into a reference or callback reference that is marked “allows pass by reference”. 486 It is obtained by calling ComponentContext.getServiceReference() or 487 ComponentContext.getServiceReferences() with the name of a reference that is marked “allows pass 488 by reference”. 489 It is obtained by calling RequestContext.getCallbackReference() from a service implementation that is 490 marked “allows pass by reference”. 491 It is obtained by calling ComponentContext.cast() on a proxy that is marked “allows pass by 492 reference”.
23sca-javacaa-1.1-spec-csd06 15 August 2011 24Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 12 of 121 493 2.3.4 Using “allows pass by reference” to Optimize Remotable Calls 494The SCA runtime MUST use by-value semantics when passing input parameters, return values and 495exceptions on calls to remotable services within the same JVM if the service method implementation is 496not marked “allows pass by reference” or the service proxy used by the client is not marked “allows pass 497by reference”. [JCA20010] 498The SCA runtime can use by-reference semantics when passing input parameters, return values or 499exceptions on calls to remotable services within the same JVM if both the service method implementation 500and the service proxy used by the client are marked “allows pass by reference".
25sca-javacaa-1.1-spec-csd06 15 August 2011 26Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 13 of 121 5013 Interface 502This section describes the SCA Java interface element and the SCA metadata for Java interfaces.
503 3.1 Java Interface Element –
522Snippet 3-4: interface.java Pseudo-Schema
523 524 The interface.java element has the attributes: 525 interface : NCName (1..1) – the Java interface class to use for the service interface. The value of the 526 @interface attribute MUST be the fully qualified name of a Java class [JCA30001] 527 If the identified class is annotated with either the JAX-WS @WebService or @WebServiceProvider 528 annotations and the annotation has a non-empty wsdlLocation property, then the SCA Runtime 529 MUST act as if an
27sca-javacaa-1.1-spec-csd06 15 August 2011 28Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 14 of 121 545 to using the @Remotable annotation on the interface class. The value of the @remotable attribute on 546 the
570 3.2 @Remotable 571The @Remotable annotation on a Java interface, a service implementation class, or a service reference 572denotes an interface or class that is designed to be used for remote communication. Remotable 573interfaces are intended to be used for coarse grained services. Operations' parameters, return values 574and exceptions are passed by-value. Remotable Services are not allowed to make use of method 575overloading.
576 3.3 @Callback 577A callback interface is declared by using a @Callback annotation on a Java service interface, with the 578Java Class object of the callback interface as a parameter. There is another form of the @Callback 579annotation, without any parameters, that specifies callback injection for a setter method or a field of an 580implementation.
581 3.4 @AsyncInvocation 582An interface can be annotated with @AsyncInvocation or with the equivalent 583@Requires("sca:asyncInvocation") annotation to indicate that request/response operations of that 584interface are long running and that response messages are likely to be sent an arbitrary length of time 585after the initial request message is sent to the target service. This is described in the SCA Assembly 586Specification [ASSEMBLY]. 587For a service client, it is strongly recommended that the client uses the asynchronous form of the client 588interface when using a reference to a service with an interface annotated with @AsyncInvocation, using 589either polling or callbacks to receive the response message. See the sections "Asynchronous 590Programming" and the section "JAX-WS Client Asynchronous API for a Synchronous Service" for more 591details about the asynchronous client API.
29sca-javacaa-1.1-spec-csd06 15 August 2011 30Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 15 of 121 592For a service implementation, SCA provides an asynchronous service mapping of the WSDL 593request/response interface which enables the service implementation to send the response message at 594an arbitrary time after the original service operation is invoked. This is described in the section 595"Asynchronous handling of Long Running Service Operations".
596 3.5 SCA Java Annotations for Interface Classes 597 A Java interface referenced by the @interface attribute of an
601 3.6 Compatibility of Java Interfaces 602The SCA Assembly Model specification [ASSEMBLY] defines a number of criteria that need to be 603satisfied in order for two interfaces to be compatible or have a compatible superset or subset relationship. 604If these interfaces are both Java interfaces, compatibility also means that every method that is present in 605both interfaces is defined consistently in both interfaces with respect to the @OneWay annotation, that is, 606the annotation is either present in both interfaces or absent in both interfaces. [JCA30009]
31sca-javacaa-1.1-spec-csd06 15 August 2011 32Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 16 of 121 6074 SCA Component Implementation Lifecycle 608This section describes the lifecycle of an SCA component implementation.
6094.1 Overview of SCA Component Implementation Lifecycle 610At a high level, there are 3 main phases through which an SCA component implementation will transition 611when it is used by an SCA Runtime: 612 The Initialization phase. This involves constructing an instance of the component implementation 613 class and injecting any properties and references. Once injection is complete, the method annotated 614 with @Init is called, if present, which provides the component implementation an opportunity to 615 perform any internal initialization it requires. 616 The Running phase. This is where the component implementation has been initialized and the SCA 617 Runtime can dispatch service requests to it over its Service interfaces. 618 The Destroying phase. This is where the component implementation’s scope has ended and the 619 SCA Runtime destroys the component implementation instance. The SCA Runtime calls the method 620 annotated with @Destroy, if present, which provides the component implementation an opportunity to 621 perform any internal clean up that is required.
6224.2 SCA Component Implementation Lifecycle State Diagram 623The state diagram in Figure 4-1 shows the lifecycle of an SCA component implementation. The sections 624that follow it describe each of the states that it contains. 625It should be noted that some component implementation specifications might not implement all states of 626the lifecycle. In this case, that state of the lifecycle is skipped over.
33sca-javacaa-1.1-spec-csd06 15 August 2011 34Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 17 of 121
Scope begins Constructing Exception
Injecting Exception
Initializing Exception
Running
Destroying
Terminated
627 628Figure 4-1: SCA - Component Implementation Lifecycle
629 4.2.1 Constructing State 630The SCA Runtime MUST call a constructor of the component implementation at the start of the 631Constructing state. [JCA40001] The SCA Runtime MUST perform any constructor reference or property 632injection when it calls the constructor of a component implementation. [JCA40002] 633The result of invoking operations on any injected references when the component implementation is in the 634Constructing state is undefined. 635When the constructor completes successfully, the SCA Runtime MUST transition the component 636implementation to the Injecting state. [JCA40003] If an exception is thrown whilst in the Constructing 637state, the SCA Runtime MUST transition the component implementation to the Terminated state. 638[JCA40004]
639 4.2.2 Injecting State 640When a component implementation instance is in the Injecting state, the SCA Runtime MUST first inject 641all field and setter properties that are present into the component implementation. [JCA40005] The order 642in which the properties are injected is unspecified. 643When a component implementation instance is in the Injecting state, the SCA Runtime MUST inject all 644field and setter references that are present into the component implementation, after all the properties 645have been injected. [JCA40006] The order in which the references are injected is unspecified.
35sca-javacaa-1.1-spec-csd06 15 August 2011 36Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 18 of 121 646The SCA Runtime MUST ensure that the correct synchronization model is used so that all injected 647properties and references are made visible to the component implementation without requiring the 648component implementation developer to do any specific synchronization. [JCA40007] 649The SCA Runtime MUST NOT invoke Service methods on the component implementation when the 650component implementation is in the Injecting state. [JCA40008] 651The result of invoking operations on any injected references when the component implementation is in the 652Injecting state is undefined. 653When the injection of properties and references completes successfully, the SCA Runtime MUST 654transition the component implementation to the Initializing state. [JCA40009] If an exception is thrown 655whilst injecting properties or references, the SCA Runtime MUST transition the component 656implementation to the Destroying state. [JCA40010] If a property or reference is unable to be injected, the 657SCA Runtime MUST transition the component implementation to the Destroying state. [JCA40024]
658 4.2.3 Initializing State 659When the component implementation enters the Initializing State, the SCA Runtime MUST call the 660method annotated with @Init on the component implementation, if present. [JCA40011] 661The component implementation can invoke operations on any injected references when it is in the 662Initializing state. However, depending on the order in which the component implementations are 663initialized, the target of the injected reference might not be available since it has not yet been initialized. If 664a component implementation invokes an operation on an injected reference that refers to a target that has 665not yet been initialized, the SCA Runtime MUST throw a ServiceUnavailableException. [JCA40012] 666The SCA Runtime MUST NOT invoke Service methods on the component implementation when the 667component implementation instance is in the Initializing state. [JCA40013] 668Once the method annotated with @Init completes successfully, the SCA Runtime MUST transition the 669component implementation to the Running state. [JCA40014] If an exception is thrown whilst initializing, 670the SCA Runtime MUST transition the component implementation to the Destroying state. [JCA40015]
671 4.2.4 Running State 672The SCA Runtime MUST invoke Service methods on a component implementation instance when the 673component implementation is in the Running state and a client invokes operations on a service offered by 674the component. [JCA40016] 675The component implementation can invoke operations on any injected references when the component 676implementation instance is in the Running state. 677When the component implementation scope ends, the SCA Runtime MUST transition the component 678implementation to the Destroying state. [JCA40017]
679 4.2.5 Destroying State 680When a component implementation enters the Destroying state, the SCA Runtime MUST call the method 681annotated with @Destroy on the component implementation, if present. [JCA40018] 682The component implementation can invoke operations on any injected references when it is in the 683Destroying state. However, depending on the order in which the component implementations are 684destroyed, the target of the injected reference might no longer be available since it has been destroyed. If 685a component implementation invokes an operation on an injected reference that refers to a target that has 686been destroyed, the SCA Runtime MUST throw an InvalidServiceException. [JCA40019] 687The SCA Runtime MUST NOT invoke Service methods on the component implementation when the 688component implementation instance is in the Destroying state. [JCA40020] 689Once the method annotated with @Destroy completes successfully, the SCA Runtime MUST transition 690the component implementation to the Terminated state. [JCA40021] If an exception is thrown whilst 691destroying, the SCA Runtime MUST transition the component implementation to the Terminated state. 692[JCA40022]
37sca-javacaa-1.1-spec-csd06 15 August 2011 38Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 19 of 121 693 4.2.6 Terminated State 694The lifecycle of the SCA Component has ended. 695The SCA Runtime MUST NOT invoke Service methods on the component implementation when the 696component implementation instance is in the Terminated state. [JCA40023]
39sca-javacaa-1.1-spec-csd06 15 August 2011 40Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 20 of 121 6975 Client API 698This section describes how SCA services can be programmatically accessed from components and also 699from non-managed code, that is, code not running as an SCA component.
700 5.1 Accessing Services from an SCA Component 701An SCA component can obtain a service reference either through injection or programmatically through 702the ComponentContext API. Using reference injection is the recommended way to access a service, 703since it results in code with minimal use of middleware APIs. The ComponentContext API is provided for 704use in cases where reference injection is not possible.
705 5.1.1 Using the Component Context API 706When a component implementation needs access to a service where the reference to the service is not 707known at compile time, the reference can be located using the component’s ComponentContext.
708 5.2 Accessing Services from non-SCA Component Implementations 709This section describes how Java code not running as an SCA component that is part of an SCA 710composite accesses SCA services via references.
711 5.2.1 SCAClientFactory Interface and Related Classes 712Client code can use the SCAClientFactory class to obtain proxy reference objects for a service which is 713in an SCA Domain. The URI of the domain, the relative URI of the service and the business interface of 714the service must all be known in order to use the SCAClientFactory class. 715 716Objects which implement the SCAClientFactory are obtained using the newInstance() methods of the 717SCAClientFactory class. 718Snippet 5-6 is a sample of the code that a client would use: 719 720 package org.oasisopen.sca.client.example; 721 722 import java.net.URI; 723 724 import org.oasisopen.sca.client.SCAClientFactory; 725 import org.oasisopen.sca.client.example.HelloService; 726 727 /** 728 * Example of use of Client API for a client application to obtain 729 * an SCA reference proxy for a service in an SCA Domain. 730 */ 731 public class Client1 { 732 733 public void someMethod() { 734 735 try { 736 737 String serviceURI = "SomeHelloServiceURI"; 738 URI domainURI = new URI("SomeDomainURI"); 739 740 SCAClientFactory scaClient = 741 SCAClientFactory.newInstance( domainURI ); 742 HelloService helloService = 743 scaClient.getService(HelloService.class,
41sca-javacaa-1.1-spec-csd06 15 August 2011 42Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 21 of 121 744 serviceURI); 745 String reply = helloService.sayHello("Mark"); 746 747 } catch (Exception e) { 748 System.out.println("Received exception"); 749 } 750 } 751 } 752Snippet 5-6: Using the SCAClientFactory Interface 753 754For details about the SCAClientFactory interface and its related classes see the section 755"SCAClientFactory Class".
43sca-javacaa-1.1-spec-csd06 15 August 2011 44Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 22 of 121 7566 Error Handling 757Clients calling service methods can experience business exceptions and SCA runtime exceptions. 758Business exceptions are thrown by the implementation of the called service method, and are defined as 759checked exceptions on the interface that types the service. 760SCA runtime exceptions are raised by the SCA runtime and signal problems in management of 761component execution or problems interacting with remote services. The SCA runtime exceptions are 762defined in the Java API section.
45sca-javacaa-1.1-spec-csd06 15 August 2011 46Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 23 of 121 7637 Asynchronous Programming 764Asynchronous programming of a service is where a client invokes a service and carries on executing 765without waiting for the service to execute. Typically, the invoked service executes at some later time. 766Output from the invoked service, if any, is fed back to the client through a separate mechanism, since no 767output is available at the point where the service is invoked. This is in contrast to the call-and-return style 768of synchronous programming, where the invoked service executes and returns any output to the client 769before the client continues. The SCA asynchronous programming model consists of: 770 support for non-blocking method calls 771 callbacks 772Each of these topics is discussed in the following sections.
773 7.1 @OneWay 774Non-blocking calls represent the simplest form of asynchronous programming, where the client of the 775service invokes the service and continues processing immediately, without waiting for the service to 776execute. 777A method with a void return type and which has no declared exceptions can be marked with a @OneWay 778annotation. This means that the method is non-blocking and communication with the service provider can 779use a binding that buffers the request and sends it at some later time. 780For a Java client to make a non-blocking call to methods that either return values or throw exceptions, a 781Java client can use the JAX-WS asynchronous client API model that is described in the section "JAX-WS 782Client Asynchronous API for a Synchronous Service". It is considered to be a best practice that service 783designers define one-way methods as often as possible, in order to give the greatest degree of binding 784flexibility to deployers.
785 7.2 Callbacks 786A callback service is a service that is used for asynchronous communication from a service provider 787back to its client, in contrast to the communication through return values from synchronous operations. 788Callbacks are used by bidirectional services, which are services that have two interfaces: 789 an interface for the provided service 790 a callback interface that is provided by the client 791Callbacks can be used for both remotable and local services. Either both interfaces of a bidirectional 792service are remotable, or both are local. It is illegal to mix the two, as defined in the SCA Assembly 793Model specification [ASSEMBLY]. 794A callback interface is declared by using a @Callback annotation on a service interface, with the Java 795Class object of the interface as a parameter. The annotation can also be applied to a method or to a field 796of an implementation, which is used in order to have a callback injected, as explained in the next section.
797 7.2.1 Using Callbacks 798Bidirectional interfaces and callbacks are used when a simple request/response pattern isn’t sufficient to 799capture the business semantics of a service interaction. Callbacks are well suited for cases when a 800service request can result in multiple responses or new requests from the service back to the client, or 801where the service might respond to the client some time after the original request has completed. 802Snippet 7-7 shows a scenario in which bidirectional interfaces and callbacks could be used. A client 803requests a quotation from a supplier. To process the enquiry and return the quotation, some suppliers 804might need additional information from the client. The client does not know which additional items of 805information will be needed by different suppliers. This interaction can be modeled as a bidirectional 806interface with callback requests to obtain the additional information. 47sca-javacaa-1.1-spec-csd06 15 August 2011 48Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 24 of 121 807 808 package somepackage; 809 import org.oasisopen.sca.annotation.Callback; 810 import org.oasisopen.sca.annotation.Remotable;
812 @Remotable 813 @Callback(QuotationCallback.class) 814 public interface Quotation {h 815 double requestQuotation(String productCode, int quantity); 816 } 817 818 @Remotable 819 public interface QuotationCallback { 820 String getState(); 821 String getZipCode(); 822 String getCreditRating(); 823 } 824Snippet 7-7: Using a Bidirectional Interface 825 826In Snippet 7-7, the requestQuotation operation requests a quotation to supply a given quantity of a 827specified product. The QuotationCallBack interface provides a number of operations that the supplier can 828use to obtain additional information about the client making the request. For example, some suppliers 829might quote different prices based on the state or the ZIP code to which the order will be shipped, and 830some suppliers might quote a lower price if the ordering company has a good credit rating. Other 831suppliers might quote a standard price without requesting any additional information from the client. 832Snippet 7-8 illustrates a possible implementation of the example service, using the @Callback annotation 833to request that a callback proxy be injected. 834 835 @Callback 836 protected QuotationCallback callback; 837 838 public double requestQuotation(String productCode, int quantity) { 839 double price = getPrice(productQuote, quantity); 840 double discount = 0; 841 if (quantity > 1000 && callback.getState().equals("FL")) { 842 discount = 0.05; 843 } 844 if (quantity > 10000 && callback.getCreditRating().charAt(0) == 'A') { 845 discount += 0.05; 846 } 847 return price * (1-discount); 848 } 849Snippet 7-8: Example Implementation of a Service with a Bidirectional Interface 850 851Snippet 7-9 is taken from the client of this example service. The client’s service implementation class 852implements the methods of the QuotationCallback interface as well as those of its own service interface 853ClientService. 854 855 public class ClientImpl implements ClientService, QuotationCallback { 856 857 private QuotationService myService; 858 859 @Reference 860 public void setMyService(QuotationService service) { 861 myService = service; 862 } 863 49sca-javacaa-1.1-spec-csd06 15 August 2011 50Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 25 of 121 864 public void aClientMethod() { 865 ... 866 double quote = myService.requestQuotation("AB123", 2000); 867 ... 868 } 869 870 public String getState() { 871 return "TX"; 872 } 873 public String getZipCode() { 874 return "78746"; 875 } 876 public String getCreditRating() { 877 return "AA"; 878 } 879 } 880Snippet 7-9: Example Client Using a Biderictional Interface 881 882Snippet 7-9 the callback is stateless, i.e., the callback requests do not need any information relating to 883the original service request. For a callback that needs information relating to the original service request 884(a stateful callback), this information can be passed to the client by the service provider as parameters 885on the callback request.
886 7.2.2 Callback Instance Management 887Instance management for callback requests received by the client of the bidirectional service is handled in 888the same way as instance management for regular service requests. If the client implementation has 889STATELESS scope, the callback is dispatched using a newly initialized instance. If the client 890implementation has COMPOSITE scope, the callback is dispatched using the same shared instance that 891is used to dispatch regular service requests. 892As described in the section "Using Callbacks", a stateful callback can obtain information relating to the 893original service request from parameters on the callback request. Alternatively, a composite-scoped 894client could store information relating to the original request as instance data and retrieve it when the 895callback request is received. These approaches could be combined by using a key passed on the 896callback request (e.g., an order ID) to retrieve information that was stored in a composite-scoped instance 897by the client code that made the original request.
898 7.2.3 Callback Injection 899When a bidirectional service is invoked, the SCA runtime MUST inject a callback reference for the 900invoking service into all fields and setter methods of the service implementation class that are marked 901with a @Callback annotation and typed by the callback interface of the bidirectional service, and the SCA 902runtime MUST inject null into all other fields and setter methods of the service implementation class that 903are marked with a @Callback annotation. [JCA60001] When a non-bidirectional service is invoked, the 904SCA runtime MUST inject null into all fields and setter methods of the service implementation class that 905are marked with a @Callback annotation. [JCA60002]
906 7.2.4 Implementing Multiple Bidirectional Interfaces 907Since it is possible for a single implementation class to implement multiple services, it is also possible for 908callbacks to be defined for each of the services that it implements. The service implementation can 909include an injected field for each of its callbacks. The runtime injects the callback onto the appropriate 910field based on the type of the callback. Snippet 7-10 shows the declaration of two fields, each of which 911corresponds to a particular service offered by the implementation. 912 913 @Callback 914 protected MyService1Callback callback1; 51sca-javacaa-1.1-spec-csd06 15 August 2011 52Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 26 of 121 915 916 @Callback 917 protected MyService2Callback callback2; 918Snippet 7-10: Multiple Bidirectional Interfaces in an Implementation 919 920If a single callback has a type that is compatible with multiple declared callback fields, then all of them will 921be set.
922 7.2.5 Accessing Callbacks 923In addition to injecting a reference to a callback service, it is also possible to obtain a reference to a 924Callback instance by annotating a field or method of type ServiceReference with the @Callback 925annotation. 926 927A reference implementing the callback service interface can be obtained using 928ServiceReference.getService(). 929Snippet 7-11 comes from a service implementation that uses the callback API: 930 931 @Callback 932 protected ServiceReference
53sca-javacaa-1.1-spec-csd06 15 August 2011 54Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 27 of 121 963 7.3 Asynchronous handling of Long Running Service Operations 964Long-running request-response operations are described in the SCA Assembly Specification 965[ASSEMBLY]. These operations are characterized by following the WSDL request-response message 966exchange pattern, but where the timing of the sending of the response message is arbitrarily later than 967the receipt of the request message, with an impact on the client component, on the service component 968and also on the transport binding used to communicate between them. 969In SCA, such operations are marked with an intent "asyncInvocation" and is expected that the client 970component, the service component and the binding are all affected by the presence of this intent. This 971specification does not describe the effects of the intent on the binding, other than to note that in general, 972there is an implication that the sending of the response message is typically separate from the sending of 973the request message, typically requiring a separate response endpoint on the client to which the response 974can be sent. 975For components that are clients of a long-running request-response operation, it is strongly recommended 976that the client makes use of the JAX-WS Client Asynchronous API, either using the polling interface or the 977callback mechanism described in the section "JAX-WS Client Asynchronous API for a Synchronous 978Service". The principle is that the client should not synchronously wait for a response from the long 979running operation since this could take a long time and it is preferable not to tie up resources while 980waiting. 981For the service implementation component, the JAX-WS client asynchronous API is not suitable, so the 982SCA Java Common Annotations and APIs specification defines the SCA Asynchronous Service interface, 983which, like the JAX-WS client asynchronous API, is an alternative mapping of a WSDL request-response 984operation into a Java interface.
985 7.4 SCA Asynchronous Service Interface 986The SCA Asynchronous Service interface follows some of the patterns defined by the JAX-WS client 987asynchronous API, but it is a simpler interface aligned with the needs of a service implementation class. 988As an example, for a WSDL portType with a single operation "getPrice" with a String request parameter 989and a float response, the synchronous Java interface mapping appears in Snippet 7-13. 990 991 // synchronous mapping 992 public interface StockQuote { 993 float getPrice(String ticker); 994 } 995Snippet 7-13: Example Synchronous Java Interface Mapping 996 997The JAX-WS client asynchronous API for the same portType adds two asynchronous forms for each 998synchronous method, as shown in Snippet 7-14. 999 1000 // asynchronous mapping 1001 public interface StockQuote { 1002 float getPrice(String ticker); 1003 Response
55sca-javacaa-1.1-spec-csd06 15 August 2011 56Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 28 of 121 1012 @Requires("sca:asyncInvocation") 1013 public interface StockQuote { 1014 void getPriceAsync(String ticker, ResponseDispatch
57sca-javacaa-1.1-spec-csd06 15 August 2011 58Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 29 of 121 10558 Policy Annotations for Java 1056SCA provides facilities for the attachment of policy-related metadata to SCA assemblies, which influence 1057how implementations, services and references behave at runtime. The policy facilities are described in 1058the SCA Policy Framework specification [POLICY]. In particular, the facilities include Intents and Policy 1059Sets, where intents express abstract, high-level policy requirements and policy sets express low-level 1060detailed concrete policies. 1061Policy metadata can be added to SCA assemblies through the means of declarative statements placed 1062into Composite documents and into Component Type documents. These annotations are completely 1063independent of implementation code, allowing policy to be applied during the assembly and deployment 1064phases of application development. 1065However, it can be useful and more natural to attach policy metadata directly to the code of 1066implementations. This is particularly important where the policies concerned are relied on by the code 1067itself. An example of this from the Security domain is where the implementation code expects to run 1068under a specific security Role and where any service operations invoked on the implementation have to 1069be authorized to ensure that the client has the correct rights to use the operations concerned. By 1070annotating the code with appropriate policy metadata, the developer can rest assured that this metadata 1071is not lost or forgotten during the assembly and deployment phases. 1072This specification has a series of annotations which provide the capability for the developer to attach 1073policy information to Java implementation code. The annotations concerned first provide general facilities 1074for attaching SCA Intents and Policy Sets to Java code. Secondly, there are further specific annotations 1075that deal with particular policy intents for certain policy domains such as Security and Transactions. 1076This specification supports using the Common Annotations for the Java Platform specification (JSR-250) 1077[JSR-250]. An implication of adopting the common annotation for Java platform specification is that the 1078SCA Java specification supports consistent annotation and Java class inheritance relationships. SCA 1079policy annotation semantics follow the General Guidelines for Inheritance of Annotations in the Common 1080Annotations for the Java Platform specification [JSR-250], except that member-level annotations in a 1081class or interface do not have any effect on how class-level annotations are applied to other members of 1082the class or interface. 1083
1084 8.1 General Intent Annotations 1085SCA provides the annotation @Requires for the attachment of any intent to a Java class, to a Java 1086interface or to elements within classes and interfaces such as methods and fields. 1087The @Requires annotation can attach one or multiple intents in a single statement. 1088Each intent is expressed as a string. Intents are XML QNames, which consist of a Namespace URI 1089followed by the name of the Intent. The precise form used follows the string representation used by the 1090javax.xml.namespace.QName class, which is shown in Snippet 8-16. 1091 1092 "{" + Namespace URI + "}" + intentname
1093Snippet 8-16: Intent Format 1094 1095Intents can be qualified, in which case the string consists of the base intent name, followed by a ".", 1096followed by the name of the qualifier. There can also be multiple levels of qualification. 1097This representation is quite verbose, so we expect that reusable String constants will be defined for the 1098namespace part of this string, as well as for each intent that is used by Java code. SCA defines 1099constants for intents such as those in Snippet 8-17. 1100 59sca-javacaa-1.1-spec-csd06 15 August 2011 60Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 30 of 121 1101 public static final String SCA_PREFIX = 1102 "{http://docs.oasis-open.org/ns/opencsa/sca/200912}"; 1103 public static final String CONFIDENTIALITY = 1104 SCA_PREFIX + "confidentiality"; 1105 public static final String CONFIDENTIALITY_MESSAGE = 1106 CONFIDENTIALITY + ".message"; 1107Snippet 8-17: Example Intent Constants 1108 1109Notice that, by convention, qualified intents include the qualifier as part of the name of the constant, 1110separated by an underscore. These intent constants are defined in the file that defines an annotation for 1111the intent (annotations for intents, and the formal definition of these constants, are covered in a following 1112section). 1113Multiple intents (qualified or not) are expressed as separate strings within an array declaration. 1114An example of the @Requires annotation with 2 qualified intents (from the Security domain) is shown in 1115Snippet 8-18: 1116 1117 @Requires({CONFIDENTIALITY_MESSAGE, INTEGRITY_MESSAGE}) 1118Snippet 8-18: Multiple Intnets in One Annotation 1119 1120The annotation in Snippet 8-18 attaches the intents "confidentiality.message" and "integrity.message". 1121Snippet 8-19 is an example of a reference requiring support for confidentiality: 1122 1123 package com.foo; 1124 1125 import static org.oasisopen.sca.annotation.Confidentiality.*; 1126 import static org.oasisopen.sca.annotation.Reference; 1127 import static org.oasisopen.sca.annotation.Requires; 1128 1129 public class Foo { 1130 @Requires(CONFIDENTIALITY) 1131 @Reference 1132 public void setBar(Bar bar) { 1133 … 1134 } 1135 } 1136Snippet 8-19: Annotation a Reference 1137 1138Users can also choose to only use constants for the namespace part of the QName, so that they can add 1139new intents without having to define new constants. In that case, the definition of Snippet 8-19 would 1140instead look like Snippet 8-20. 1141 1142 package com.foo; 1143 1144 import static org.oasisopen.sca.Constants.*; 1145 import static org.oasisopen.sca.annotation.Reference; 1146 import static org.oasisopen.sca.annotation.Requires; 1147 1148 public class Foo { 1149 @Requires(SCA_PREFIX+"confidentiality") 1150 @Reference 1151 public void setBar(Bar bar) { 1152 … 1153 } 1154 }
61sca-javacaa-1.1-spec-csd06 15 August 2011 62Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 31 of 121 1155Snippet 8-20: Using Intent Constants and strings 1156 1157The formal syntax [EBNF-Syntax] for the @Requires annotation follows: 1158 '@Requires("' QualifiedIntent '"' (',"' QualifiedIntent '"')* ')' 1159where 1160 QualifiedIntent ::= QName('.' Qualifier)* 1161 Qualifier ::= NCName
1162 1163See section @Requires for the formal definition of the @Requires annotation.
1164 8.2 Specific Intent Annotations 1165In addition to the general intent annotation supplied by the @Requires annotation described in section 11668.2, it is also possible to have Java annotations that correspond to specific policy intents. SCA provides a 1167number of these specific intent annotations and it is also possible to create new specific intent 1168annotations for any intent. 1169The general form of these specific intent annotations is an annotation with a name derived from the name 1170of the intent itself. If the intent is a qualified intent, qualifiers are supplied as an attribute to the annotation 1171in the form of a string or an array of strings. 1172For example, the SCA confidentiality intent described in the section on General Intent Annotations using 1173the @Requires(CONFIDENTIALITY) annotation can also be specified with the @Confidentiality specific 1174intent annotation. The specific intent annotation for the "integrity" security intent is shown in Snippet 8-21. 1175 1176 @Integrity 1177Snippet 8-21: Example Specific Intent Annotation 1178 1179An example of a qualified specific intent for the "authentication" intent is shown in Snippet 8-22. 1180 1181 @Authentication( {"message", "transport"} ) 1182Snippet 8-22: Example Qualified Specific Intent Annotation 1183 1184This annotation attaches the pair of qualified intents: "authentication.message" and 1185"authentication.transport" (the sca: namespace is assumed in this both of these cases – 1186"http://docs.oasis-open.org/ns/opencsa/sca/200912"). 1187The general form of specific intent annotations is shown in Snippet 8-23 1188 1189 '@' Intent ('(' qualifiers ')')? 1190where Intent is an NCName that denotes a particular type of intent. 1191 Intent ::= NCName 1192 qualifiers ::= '"' qualifier '"' (',"' qualifier '"')* 1193 qualifier ::= NCName ('.' qualifier)?
1194Snippet 8-23: Specific Intent Annotation Format
63sca-javacaa-1.1-spec-csd06 15 August 2011 64Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 32 of 121 1195 8.2.1 How to Create Specific Intent Annotations 1196SCA identifies annotations that correspond to intents by providing an @Intent annotation which MUST be 1197used in the definition of a specific intent annotation. [JCA70001] 1198The @Intent annotation takes a single parameter, which (like the @Requires annotation) is the String 1199form of the QName of the intent. As part of the intent definition, it is good practice (although not required) 1200to also create String constants for the Namespace, for the Intent and for Qualified versions of the Intent (if 1201defined). These String constants are then available for use with the @Requires annotation and it is also 1202possible to use one or more of them as parameters to the specific intent annotation. 1203Alternatively, the QName of the intent can be specified using separate parameters for the 1204targetNamespace and the localPart, as shown in Snippet 8-24: 1205 1206 @Intent(targetNamespace=SCA_NS, localPart="confidentiality") 1207Snippet 8-24: Defining a Specific Intent Annotation 1208 1209See section @Intent for the formal definition of the @Intent annotation. 1210When an intent can be qualified, it is good practice for the first attribute of the annotation to be a string (or 1211an array of strings) which holds one or more qualifiers. 1212In this case, the attribute’s definition needs to be marked with the @Qualifier annotation. The @Qualifier 1213tells SCA that the value of the attribute is treated as a qualifier for the intent represented by the whole 1214annotation. If more than one qualifier value is specified in an annotation, it means that multiple qualified 1215forms exist. For example the annotation in Snippet 8-25 1216 1217 @Confidentiality({"message","transport"}) 1218Snippet 8-25: Multiple Qualifiers in an Annotation' 1219 1220implies that both of the qualified intents "confidentiality.message" and "confidentiality.transport" are set for 1221the element to which the @Confidentiality annotation is attached. 1222See section @Qualifier for the formal definition of the @Qualifier annotation. 1223Examples of the use of the @Intent and the @Qualifier annotations in the definition of specific intent 1224annotations are shown in the section dealing with Security Interaction Policy.
1225 8.3 Application of Intent Annotations 1226The SCA Intent annotations can be applied to the following Java elements: 1227 Java class 1228 Java interface 1229 Method 1230 Field 1231 Constructor parameter 1232 Intent annotations MUST NOT be applied to the following: 1233[JCA70002] 1234Intent annotations can be applied to classes, interfaces, and interface methods. Applying an intent 1235annotation to a field, setter method, or constructor parameter allows intents to be defined at references. 1236Intent annotations can also be applied to reference interfaces and their methods.
65sca-javacaa-1.1-spec-csd06 15 August 2011 66Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 33 of 121 1237Where multiple intent annotations (general or specific) are applied to the same Java element, the SCA 1238runtime MUST compute the combined intents for the Java element by merging the intents from all intent 1239annotations on the Java element according to the SCA Policy Framework [POLICY] rules for merging 1240intents at the same hierarchy level. [JCA70003] 1241An example of multiple policy annotations being used together is shown in Snippet 8-26: 1242 1243 @Authentication 1244 @Requires({CONFIDENTIALITY_MESSAGE, INTEGRITY_MESSAGE}) 1245Snippet 8-26: Multiple Policy Annotations 1246 1247In this case, the effective intents are "authentication", "confidentiality.message" and "integrity.message". 1248If intent annotations are specified on both an interface method and the method's declaring interface, the 1249SCA runtime MUST compute the effective intents for the method by merging the combined intents from 1250the method with the combined intents for the interface according to the SCA Policy Framework [POLICY] 1251rules for merging intents within a structural hierarchy, with the method at the lower level and the interface 1252at the higher level. [JCA70004] This merging process does not remove or change any intents that are 1253applied to the interface.
1254 8.3.1 Intent Annotation Examples 1255The following examples show how the rules defined in section 8.3 are applied. 1256Snippet 8-27 shows how intents on references are merged. In this example, the intents for myRef are 1257"authentication" and "confidentiality.message". 1258 1259 @Authentication 1260 @Requires(CONFIDENTIALITY) 1261 @Confidentiality("message") 1262 @Reference 1263 protected MyService myRef; 1264Snippet 8-27: Merging Intents on References 1265 1266Snippet 8-28 shows that mutually exclusive intents cannot be applied to the same Java element. In this 1267example, the Java code is in error because of contradictory mutually exclusive intents 1268"managedTransaction" and "noManagedTransaction". 1269 1270 @Requires({SCA_PREFIX+"managedTransaction", 1271 SCA_PREFIX+"noManagedTransaction"}) 1272 @Reference 1273 protected MyService myRef; 1274Snippet 8-28: Mutually Exclusive Intents 1275 1276Snippet 8-29 shows that intents can be applied to Java service interfaces and their methods. In this 1277example, the effective intents for MyService.mymethod() are "authentication" and "confidentiality". 1278 1279 @Authentication 1280 public interface MyService { 1281 @Confidentiality 1282 public void mymethod(); 1283 } 1284 @Service(MyService.class) 1285 public class MyServiceImpl {
67sca-javacaa-1.1-spec-csd06 15 August 2011 68Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 34 of 121 1286 public void mymethod() {...} 1287 } 1288Snippet 8-29: Intents on Java Interfaces, Interface Methods, and Java Classes 1289 1290Snippet 8-30 shows that intents can be applied to Java service implementation classes. In this example, 1291the effective intents for MyService.mymethod() are "authentication", "confidentiality", and 1292"managedTransaction". 1293 1294 @Authentication 1295 public interface MyService { 1296 @Confidentiality 1297 public void mymethod(); 1298 } 1299 @Service(MyService.class) 1300 @Requires(SCA_PREFIX+"managedTransaction") 1301 public class MyServiceImpl { 1302 public void mymethod() {...} 1303 } 1304Snippet 8-30: Intents on Java Service Implementation Classes 1305 1306Snippet 8-31 shows that intents can be applied to Java reference interfaces and their methods, and also 1307to Java references. In this example, the effective intents for the method mymethod() of the reference 1308myRef are "authentication", "integrity", and "confidentiality". 1309 1310 @Authentication 1311 public interface MyRefInt { 1312 @Integrity 1313 public void mymethod(); 1314 } 1315 @Service(MyService.class) 1316 public class MyServiceImpl { 1317 @Confidentiality 1318 @Reference 1319 protected MyRefInt myRef; 1320 } 1321Snippet 8-31: Intents on Java References and their Interfaces and Methods 1322 1323Snippet 8-32 shows that intents cannot be applied to methods of Java implementation classes. In this 1324example, the Java code is in error because of the @Authentication intent annotation on the 1325implementation method MyServiceImpl.mymethod(). 1326 1327 public interface MyService { 1328 public void mymethod(); 1329 } 1330 @Service(MyService.class) 1331 public class MyServiceImpl { 1332 @Authentication 1333 public void mymethod() {...} 1334 } 1335Snippet 8-32: Intent on Implementation Method 1336Snippet 8-33 shows one effect of applying the SCA Policy Framework rules for merging intents within a 1337structural hierarchy to Java service interfaces and their methods. In this example a qualified intent
69sca-javacaa-1.1-spec-csd06 15 August 2011 70Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 35 of 121 1338overrides an unqualified intent, so the effective intent for MyService.mymethod() is 1339"confidentiality.message". 1340 1341 @Confidentiality("message") 1342 public interface MyService { 1343 @Confidentiality 1344 public void mymethod(); 1345 } 1346Snippet 8-33: Merging Qualified and Unqualified Intents on Java Interfaces and Methods 1347 1348Snippet 8-34 shows another effect of applying the SCA Policy Framework rules for merging intents within 1349a structural hierarchy to Java service interfaces and their methods. In this example a lower-level intent 1350causes a mutually exclusive higher-level intent to be ignored, so the effective intent for mymethod1() is 1351"managedTransaction" and the effective intent for mymethod2() is "noManagedTransaction". 1352 1353 @Requires(SCA_PREFIX+"managedTransaction") 1354 public interface MyService { 1355 public void mymethod1(); 1356 @Requires(SCA_PREFIX+"noManagedTransaction") 1357 public void mymethod2(); 1358 } 1359Snippet 8-34: Merging Mutually Exclusive Intents on Java Interfaces and Methods
1360 8.3.2 Inheritance and Annotation 1361Snippet 8-35 shows the inheritance relations of intents on classes, operations, and super classes. 1362 1363 package services.hello; 1364 import org.oasisopen.sca.annotation.Authentication; 1365 import org.oasisopen.sca.annotation.Integrity; 1366 1367 @Integrity("transport") 1368 @Authentication 1369 public class HelloService { 1370 @Integrity 1371 @Authentication("message") 1372 public String hello(String message) {...} 1373 1374 @Integrity 1375 @Authentication("transport") 1376 public String helloThere() {...} 1377 } 1378 1379 package services.hello; 1380 import org.oasisopen.sca.annotation.Authentication; 1381 import org.oasisopen.sca.annotation.Confidentiality; 1382 1383 @Confidentiality("message") 1384 public class HelloChildService extends HelloService { 1385 @Confidentiality("transport") 1386 public String hello(String message) {...} 1387 @Authentication 1388 String helloWorld() {...} 1389 } 1390Snippet 8-35: Usage example of Annotated Policy and Inheritance 1391
71sca-javacaa-1.1-spec-csd06 15 August 2011 72Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 36 of 121 1392The effective intent annotation on the helloWorld method of HelloChildService is @Authentication and 1393@Confidentiality("message"). 1394The effective intent annotation on the hello method of HelloChildService is @Confidentiality("transport"), 1395The effective intent annotation on the helloThere method of HelloChildService is @Integrity and 1396@Authentication("transport"), the same as for this method in the HelloService class. 1397The effective intent annotation on the hello method of HelloService is @Integrity and 1398@Authentication("message") 1399 1400Table 8-1 shows the equivalent declarative security interaction policy of the methods of the HelloService 1401and HelloChildService implementations corresponding to the Java classes shown in Snippet 8-35. 1402 Method Class hello() helloThere() helloWorld() HelloService integrity integrity N/A authentication.message authentication.transport HelloChildService confidentiality.transport integrity authentication authentication.transport confidentiality.message
1403Table 8-1: Declarative Intents Equivalent to Annotated Intents in Snippet 8-35
1404 8.4 Relationship of Declarative and Annotated Intents 1405Annotated intents on a Java class cannot be overridden by declarative intents in a composite document 1406which uses the class as an implementation. This rule follows the general rule for intents that they 1407represent requirements of an implementation in the form of a restriction that cannot be relaxed. 1408However, a restriction can be made more restrictive so that an unqualified version of an intent expressed 1409through an annotation in the Java class can be qualified by a declarative intent in a using composite 1410document.
1411 8.5 Policy Set Annotations 1412The SCA Policy Framework uses Policy Sets to capture detailed low-level concrete policies. For example, 1413a concrete policy is the specific encryption algorithm to use when encrypting messages when using a 1414specific communication protocol to link a reference to a service. 1415Policy Sets can be applied directly to Java implementations using the @PolicySets annotation. The 1416@PolicySets annotation either takes the QName of a single policy set as a string or the name of two or 1417more policy sets as an array of strings: 1418 1419 '@PolicySets({' policySetQName (',' policySetQName )* '})'
1420Snippet 8-36: PolicySet Annotation Format 1421 1422As for intents, PolicySet names are QNames – in the form of "{Namespace-URI}localPart". 1423An example of the @PolicySets annotation is shown in Snippet 8-37: 1424 1425 @Reference(name="helloService", required=true) 1426 @PolicySets({ MY_NS + "WS_Encryption_Policy", 1427 MY_NS + "WS_Authentication_Policy" }) 1428 public setHelloService(HelloService service) { 1429 . . .
73sca-javacaa-1.1-spec-csd06 15 August 2011 74Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 37 of 121 1430 } 1431Snippet 8-37: Use of @PolicySets 1432 1433In this case, the Policy Sets WS_Encryption_Policy and WS_Authentication_Policy are applied, both 1434using the namespace defined for the constant MY_NS. 1435PolicySets need to satisfy intents expressed for the implementation when both are present, according to 1436the rules defined in the Policy Framework specification [POLICY]. 1437The SCA Policy Set annotation can be applied to the following Java elements: 1438 Java class 1439 Java interface 1440 Method 1441 Field 1442 Constructor parameter 1443 The @PolicySets annotation MUST NOT be applied to the following: 1444[JCA70005] 1445The @PolicySets annotation can be applied to classes, interfaces, and interface methods. Applying a 1446@PolicySets annotation to a field, setter method, or constructor parameter allows policy sets to be 1447defined at references. The @PolicySets annotation can also be applied to reference interfaces and their 1448methods. 1449If the @PolicySets annotation is specified on both an interface method and the method's declaring 1450interface, the SCA runtime MUST compute the effective policy sets for the method by merging the policy 1451sets from the method with the policy sets from the interface. [JCA70006] This merging process does not 1452remove or change any policy sets that are applied to the interface.
1453 8.6 Security Policy Annotations 1454This section introduces annotations for commonly used SCA security intents, as defined in the SCA 1455Policy Framework Specification [POLICY]. Also see the SCA Policy Framework Specification for 1456additional security policy intents that can be used with the @Requires annotation. The following 1457annotations for security policy intents and qualifiers are defined: 1458 @Authentication 1459 @Authorization 1460 @Confidentiality 1461 @Integrity 1462 @MutualAuthentication 1463The @Authentication, @Confidentiality, and @Integrity intents have the same pair of Qualifiers: 1464 message 1465 transport 1466The formal definitions of the security intent annotations are found in the section “Java Annotations”. 1467Snippet 8-38 shows an example of applying security intents to the setter method used to inject a 1468reference. Accessing the hello operation of the referenced HelloService requires both "integrity.message" 1469and "authentication.message" intents to be honored. 1470 1471 package services.hello; 1472 // Interface for HelloService 1473 public interface HelloService { 1474 String hello(String helloMsg); 1475 } 75sca-javacaa-1.1-spec-csd06 15 August 2011 76Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 38 of 121 1476 1477 package services.client; 1478 // Interface for ClientService 1479 public interface ClientService { 1480 public void clientMethod(); 1481 } 1482 1483 // Implementation class for ClientService 1484 package services.client; 1485 1486 import services.hello.HelloService; 1487 import org.oasisopen.sca.annotation.*; 1488 1489 @Service(ClientService.class) 1490 public class ClientServiceImpl implements ClientService { 1491 1492 private HelloService helloService; 1493 1494 @Reference(name="helloService", required=true) 1495 @Integrity("message") 1496 @Authentication("message") 1497 public void setHelloService(HelloService service) { 1498 helloService = service; 1499 } 1500 1501 public void clientMethod() { 1502 String result = helloService.hello("Hello World!"); 1503 … 1504 } 1505 } 1506Snippet 8-38: Usage of Security Intents on a Reference
1507 8.7 Transaction Policy Annotations 1508This section introduces annotations for commonly used SCA transaction intents, as defined in the SCA 1509Policy Framework specification [POLICY]. Also see the SCA Policy Framework Specification for 1510additional transaction policy intents that can be used with the @Requires annotation. The following 1511annotations for transaction policy intents and qualifiers are defined: 1512 @ManagedTransaction 1513 @NoManagedTransaction 1514 @SharedManagedTransaction 1515The @ManagedTransaction intent has the following Qualifiers: 1516 global 1517 local 1518The formal definitions of the transaction intent annotations are found in the section “Java Annotations”. 1519Snippet 8-39 shows an example of applying a transaction intent to a component implementation, where 1520the component implementation requires a global transaction. 1521 1522 package services.hello; 1523 // Interface for HelloService 1524 public interface HelloService { 1525 String hello(String helloMsg); 1526 } 1527 1528 // Implementation class for HelloService 1529 package services.hello.impl; 1530
77sca-javacaa-1.1-spec-csd06 15 August 2011 78Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 39 of 121 1531 import services.hello.HelloService; 1532 import org.oasisopen.sca.annotation.*; 1533 1534 @Service(HelloService.class) 1535 @ManagedTransaction("global") 1536 public class HelloServiceImpl implements HelloService { 1537 1538 public void someMethod() { 1539 … 1540 } 1541 } 1542Snippet 8-39: Usage of Transaction Intents in an Implementation
79sca-javacaa-1.1-spec-csd06 15 August 2011 80Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 40 of 121 15439 Java API 1544This section provides a reference for the Java API offered by SCA.
1545 9.1 Component Context 1546Figure 9-2 defines the ComponentContext interface: 1547 1548 package org.oasisopen.sca; 1549 import java.util.Collection; 1550 public interface ComponentContext { 1551 1552 String getURI(); 1553 1554 B getService(Class businessInterface, String referenceName); 1555 1556 ServiceReference getServiceReference( Class businessInterface, 1557 String referenceName); 1558 Collection getServices( Class businessInterface, 1559 String referenceName); 1560 1561 Collection
1577 Figure 9-2: ComponentContext Interface 1578 1579getURI () method: 1580Returns the structural URI [ASSEMBLY] of the component within the SCA Domain. 1581Returns: 1582 String which contains the absolute URI of the component in the SCA Domain 1583 The ComponentContext.getURI method MUST return the structural URI of the component in the SCA 1584 Domain. [JCA80008] 1585Parameters: 1586 none 1587Exceptions: 1588 none 1589 1590getService ( Class businessInterface, String referenceName ) method:
81sca-javacaa-1.1-spec-csd06 15 August 2011 82Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 41 of 121 1591Returns a typed service proxy object for a reference defined by the current component, where the 1592reference has multiplicity 0..1 or 1..1. 1593Returns: 1594 B which is a proxy object for the reference, which implements the interface B contained in the 1595 businessInterface parameter. 1596 The ComponentContext.getService method MUST return the proxy object implementing the interface 1597 provided by the businessInterface parameter, for the reference named by the referenceName 1598 parameter with the interface defined by the businessInterface parameter when that reference has a 1599 target service configured. [JCA80009] 1600 The ComponentContext.getService method MUST return null if the multiplicity of the reference 1601 named by the referenceName parameter is 0..1 and the reference has no target service configured. 1602 [JCA80010] 1603Parameters: 1604 Class businessInterface - the Java interface for the service reference 1605 String referenceName - the name of the service reference 1606Exceptions: 1607 The ComponentContext.getService method MUST throw an IllegalArgumentException if the 1608 reference identified by the referenceName parameter has multiplicity of 0..n or 1..n. [JCA80001] 1609 The ComponentContext.getService method MUST throw an IllegalArgumentException if the 1610 component does not have a reference with the name supplied in the referenceName parameter. 1611 [JCA80011] 1612 The ComponentContext.getService method MUST throw an IllegalArgumentException if the service 1613 reference with the name supplied in the referenceName does not have an interface compatible with 1614 the interface supplied in the businessInterface parameter. [JCA80012] 1615 1616getServiceReference ( Class businessInterface, String referenceName ) method: 1617Returns a ServiceReference object for a reference defined by the current component, where the 1618reference has multiplicity 0..1 or 1..1. 1619Returns: 1620 ServiceReference which is a ServiceReference proxy object for the reference, which implements 1621 the interface contained in the businessInterface parameter. 1622 The ComponentContext.getServiceReference method MUST return a ServiceReference object typed 1623 by the interface provided by the businessInterface parameter, for the reference named by the 1624 referenceName parameter with the interface defined by the businessInterface parameter when that 1625 reference has a target service configured. [JCA80013] 1626 The ComponentContext.getServiceReference method MUST return null if the multiplicity of the 1627 reference named by the referenceName parameter is 0..1 and the reference has no target service 1628 configured. [JCA80007] 1629Parameters: 1630 Class businessInterface - the Java interface for the service reference 1631 String referenceName - the name of the service reference 1632Exceptions: 1633 The ComponentContext.getServiceReference method MUST throw an IllegalArgumentException if 1634 the reference named by the referenceName parameter has multiplicity greater than one. [JCA80004] 1635 The ComponentContext.getServiceReference method MUST throw an IllegalArgumentException if 1636 the reference named by the referenceName parameter does not have an interface of the type defined 1637 by the businessInterface parameter. [JCA80005]
83sca-javacaa-1.1-spec-csd06 15 August 2011 84Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 42 of 121 1638 The ComponentContext.getServiceReference method MUST throw an IllegalArgumentException if 1639 the component does not have a reference with the name provided in the referenceName parameter. 1640 [JCA80006] 1641 1642getServices(Class businessInterface, String referenceName) method: 1643Returns a list of typed service proxies for a reference defined by the current component, where the 1644reference has multiplicity 0..n or 1..n. 1645Returns: 1646 Collection which is a collection of proxy objects for the reference, one for each target service to 1647 which the reference is wired, where each proxy object implements the interface B contained in the 1648 businessInterface parameter. 1649 The ComponentContext.getServices method MUST return a collection containing one proxy object 1650 implementing the interface provided by the businessInterface parameter for each of the target 1651 services configured on the reference identified by the referenceName parameter. [JCA80014] 1652 The ComponentContext.getServices method MUST return an empty collection if the service reference 1653 with the name supplied in the referenceName parameter is not wired to any target services. 1654 [JCA80015] 1655Parameters: 1656 Class businessInterface - the Java interface for the service reference 1657 String referenceName - the name of the service reference 1658Exceptions: 1659 The ComponentContext.getServices method MUST throw an IllegalArgumentException if the 1660 reference identified by the referenceName parameter has multiplicity of 0..1 or 1..1. [JCA80016] 1661 The ComponentContext.getServices method MUST throw an IllegalArgumentException if the 1662 component does not have a reference with the name supplied in the referenceName parameter. 1663 [JCA80017] 1664 The ComponentContext.getServices method MUST throw an IllegalArgumentException if the service 1665 reference with the name supplied in the referenceName does not have an interface compatible with 1666 the interface supplied in the businessInterface parameter. [JCA80018] 1667 1668getServiceReferences(Class businessInterface, String referenceName) method: 1669Returns a list of typed ServiceReference objects for a reference defined by the current component, where 1670the reference has multiplicity 0..n or 1..n. 1671Returns: 1672 Collection
85sca-javacaa-1.1-spec-csd06 15 August 2011 86Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 43 of 121 1685 String referenceName - the name of the service reference 1686Exceptions: 1687 The ComponentContext.getServiceReferences method MUST throw an IllegalArgumentException if 1688 the reference identified by the referenceName parameter has multiplicity of 0..1 or 1..1. [JCA80021] 1689 The ComponentContext.getServiceReferences method MUST throw an IllegalArgumentException if 1690 the component does not have a reference with the name supplied in the referenceName parameter. 1691 [JCA80022] 1692 The ComponentContext.getServiceReferences method MUST throw an IllegalArgumentException if 1693 the service reference with the name supplied in the referenceName does not have an interface 1694 compatible with the interface supplied in the businessInterface parameter. [JCA80023] 1695 1696createSelfReference(Class businessInterface) method: 1697Returns a ServiceReference object that can be used to invoke this component over the designated 1698service. 1699Returns: 1700 ServiceReference which is a ServiceReference object for the service of this component which 1701 has the supplied business interface. If the component has multiple services with the same business 1702 interface the SCA runtime can return a ServiceReference for any one of them. 1703 The ComponentContext.createSelfReference method MUST return a ServiceReference object typed 1704 by the interface defined by the businessInterface parameter for one of the services of the invoking 1705 component which has the interface defined by the businessInterface parameter. [JCA80024] 1706Parameters: 1707 Class businessInterface - the Java interface for the service 1708Exceptions: 1709 The ComponentContext.getServiceReferences method MUST throw an IllegalArgumentException if 1710 the component does not have a service which implements the interface identified by the 1711 businessInterface parameter. [JCA80025] 1712 1713createSelfReference(Class businessInterface, String serviceName) method: 1714Returns a ServiceReference that can be used to invoke this component over the designated service. The 1715serviceName parameter explicitly declares the service name to invoke 1716Returns: 1717 ServiceReference which is a ServiceReference proxy object for the reference, which implements 1718 the interface contained in the businessInterface parameter. 1719 The ComponentContext.createSelfReference method MUST return a ServiceReference object typed 1720 by the interface defined by the businessInterface parameter for the service identified by the 1721 serviceName of the invoking component and which has the interface defined by the businessInterface 1722 parameter. [JCA80026] 1723Parameters: 1724 Class businessInterface - the Java interface for the service reference 1725 String serviceName - the name of the service reference 1726Exceptions: 1727 The ComponentContext.createSelfReference method MUST throw an IllegalArgumentException if the 1728 component does not have a service with the name identified by the serviceName parameter. 1729 [JCA80027]
87sca-javacaa-1.1-spec-csd06 15 August 2011 88Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 44 of 121 1730 The ComponentContext.createSelfReference method MUST throw an IllegalArgumentException if the 1731 component service with the name identified by the serviceName parameter does not implement a 1732 business interface which is compatible with the supplied businessInterface parameter. [JCA80028] 1733 1734getProperty (Class type, String propertyName) method: 1735Returns the value of an SCA property defined by this component. 1736Returns: 1737 which is an object of the type identified by the type parameter containing the value specified for 1738 the property in the SCA configuration of the component. null if the SCA configuration of the 1739 component does not specify any value for the property. 1740 The ComponentContext.getProperty method MUST return an object of the type identified by the type 1741 parameter containing the value specified in the component configuration for the property named by 1742 the propertyName parameter or null if no value is specified in the configuration. [JCA80029] 1743Parameters: 1744 Class type - the Java class of the property (Object mapped type for primitive Java types - e.g. 1745 Integer if the type is int) 1746 String propertyName - the name of the property 1747Exceptions: 1748 The ComponentContext.getProperty method MUST throw an IllegalArgumentException if the 1749 component does not have a property with the name identified by the propertyName parameter. 1750 [JCA80030] 1751 The ComponentContext.getProperty method MUST throw an IllegalArgumentException if the 1752 component property with the name identified by the propertyName parameter does not have a type 1753 which is compatible with the supplied type parameter. [JCA80031] 1754 1755getRequestContext() method: 1756Returns the RequestContext for the current SCA service request. 1757Returns: 1758 RequestContext which is the RequestContext object for the current SCA service invocation. null if 1759 there is no current request or if the context is unavailable. 1760 The ComponentContext.getRequestContext method MUST return non-null when invoked during the 1761 execution of a Java business method for a service operation or a callback operation, on the same 1762 thread that the SCA runtime provided, and MUST return null in all other cases. [JCA80002] 1763Parameters: 1764 none 1765Exceptions: 1766 none 1767 1768cast(B target) method: 1769Casts a type-safe reference to a ServiceReference 1770Returns: 1771 ServiceReference which is a ServiceReference object which implements the same business 1772 interface B as a reference proxy object 1773 The ComponentContext.cast method MUST return a ServiceReference object which is typed by the 1774 same business interface as specified by the reference proxy object supplied in the target parameter. 1775 [JCA80032]
89sca-javacaa-1.1-spec-csd06 15 August 2011 90Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 45 of 121 1776Parameters: 1777 B target - a type safe reference proxy object which implements the business interface B 1778Exceptions: 1779 The ComponentContext.cast method MUST throw an IllegalArgumentException if the supplied target 1780 parameter is not an SCA reference proxy object. [JCA80033] 1781A component can access its component context by defining a field or setter method typed by 1782org.oasisopen.sca.ComponentContext and annotated with @Context. To access a target service, the 1783component uses ComponentContext.getService(..). 1784Snippet 9-40 shows an example of component context usage in a Java class using the @Context 1785annotation. 1786 private ComponentContext componentContext; 1787 1788 @Context 1789 public void setContext(ComponentContext context) { 1790 componentContext = context; 1791 } 1792 1793 public void doSomething() { 1794 HelloWorld service = 1795 componentContext.getService(HelloWorld.class,"HelloWorldComponent"); 1796 service.hello("hello"); 1797 } 1798Snippet 9-40: ComponentContext Injection Example 1799Similarly, non-SCA client code can use the ComponentContext API to perform operations against a 1800component in an SCA domain. How the non-SCA client code obtains a reference to a ComponentContext 1801is runtime specific.
1802 9.2 Request Context 1803Figure 9-3 shows the RequestContext interface:
1805 package org.oasisopen.sca; 1806 1807 import javax.security.auth.Subject; 1808 1809 public interface RequestContext { 1810 1811 Subject getSecuritySubject(); 1812 1813 String getServiceName(); 1814
1818Figure 9-3: RequestContext Interface 1819 1820getSecuritySubject ( ) method: 1821Returns the JAAS Subject of the current request (see the JAAS Reference Guide [JAAS] for details of 1822JAAS). 1823Returns: 1824 javax.security.auth.Subject object which is the JAAS subject for the request. 1825 null if there is no subject for the request.
91sca-javacaa-1.1-spec-csd06 15 August 2011 92Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 46 of 121 1826 The RequestContext.getSecuritySubject method MUST return the JAAS subject of the current 1827 request, or null if there is no subject or null if the method is invoked from code not processing a 1828 service request or callback request. [JCA80034] 1829Parameters: 1830 none 1831Exceptions: 1832 none 1833 1834getServiceName ( ) method: 1835Returns the name of the service on the Java implementation the request came in on. 1836Returns: 1837 String containing the name of the service. null if the method is invoked from a thread that is not 1838 processing a service operation or a callback operation. 1839 The RequestContext.getServiceName method MUST return the name of the service for which an 1840 operation is being processed, or null if invoked from a thread that is not processing a service 1841 operation or a callback operation. [JCA80035] 1842Parameters: 1843 none 1844Exceptions: 1845 none 1846 1847getCallbackReference ( ) method: 1848Returns a service reference proxy for the callback for the invoked service operation, as specified by the 1849service client. 1850Returns: 1851 ServiceReference
93sca-javacaa-1.1-spec-csd06 15 August 2011 94Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 47 of 121 1870 null if the invoked service has an interface which is not bidirectional or if the getCallback() method is 1871 called during the processing of a callback operation. 1872 null if the method is invoked from a thread that is not processing a service operation. 1873 The RequestContext.getCallback method MUST return a reference proxy object typed by the 1874 interface of the callback supplied by the client of the invoked service, or null if either the invoked 1875 service is not bidirectional or if the method is invoked from a thread that is not processing a service 1876 operation. [JCA80037] 1877Parameters: 1878 none 1879Exceptions: 1880 none 1881 1882getServiceReference ( ) method: 1883Returns a ServiceReference object for the service that was invoked. 1884Returns: 1885 ServiceReference which is a service reference for the invoked service. It is typed with the 1886 interface of the service. 1887 null if the method is invoked from a thread that is not processing a service operation or a callback 1888 operation. 1889 When invoked during the execution of a service operation, the RequestContext.getServiceReference 1890 method MUST return a ServiceReference that represents the service that was invoked. [JCA80003] 1891 When invoked during the execution of a callback operation, the RequestContext.getServiceReference 1892 method MUST return a ServiceReference that represents the callback that was invoked. [JCA80038] 1893 When invoked from a thread not involved in the execution of either a service operation or of a 1894 callback operation, the RequestContext.getServiceReference method MUST return null. [JCA80039] 1895Parameters: 1896 none 1897Exceptions: 1898 none 1899ServiceReferences can be injected using the @Reference annotation on a field, a setter method, or 1900constructor parameter taking the type ServiceReference. The detailed description of the usage of these 1901methods is described in the section on Asynchronous Programming in this document.
1902 9.3 ServiceReference Interface 1903ServiceReferences can be injected using the @Reference annotation on a field, a setter method, or 1904constructor parameter taking the type ServiceReference. The detailed description of the usage of these 1905methods is described in the section on Asynchronous Programming in this document. 1906Figure 9-4 defines the ServiceReference interface: 1907 1908 package org.oasisopen.sca; 1909 1910 public interface ServiceReference extends java.io.Serializable { 1911 1912 1913 B getService(); 1914 Class getBusinessInterface(); 1915 }
95sca-javacaa-1.1-spec-csd06 15 August 2011 96Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 48 of 121 1916Figure 9-4: ServiceReference Interface 1917 1918getService ( ) method: 1919Returns a type-safe reference to the target of this reference. The instance returned is guaranteed to 1920implement the business interface for this reference. The value returned is a proxy to the target that 1921implements the business interface associated with this reference. 1922Returns: 1923 which is type-safe reference proxy object to the target of this reference. It is typed with the 1924 interface of the target service. 1925 The ServiceReference.getService method MUST return a reference proxy object which can be used 1926 to invoke operations on the target service of the reference and which is typed with the business 1927 interface of the reference. [JCA80040] 1928Parameters: 1929 none 1930Exceptions: 1931 none 1932 1933getBusinessInterface ( ) method: 1934Returns the Java class for the business interface associated with this ServiceReference. 1935Returns: 1936 Class which is a Class object of the business interface associated with the reference. 1937 The ServiceReference.getBusinessInterface method MUST return a Class object representing the 1938 business interface of the reference. [JCA80041] 1939Parameters: 1940 none 1941Exceptions: 1942 none
1943 9.4 ResponseDispatch interface 1944The ResponseDispatch interface is shown in Figure 9-5: 1945 1946 package org.oasisopen.sca; 1947 1948 public interface ResponseDispatch
1953Figure 9-5: ResponseDispatch Interface 1954 1955sendResponse ( T response ) method: 1956Sends the response message from an asynchronous service method. This method can only be invoked 1957once for a given ResponseDispatch object and cannot be invoked if sendFault has previously been 1958invoked for the same ResponseDispatch object. 1959Returns:
97sca-javacaa-1.1-spec-csd06 15 August 2011 98Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 49 of 121 1960 void 1961 The ResponseDispatch.sendResponse() method MUST send the response message to the client of 1962 an asynchronous service. [JCA50057] 1963Parameters: 1964 T - an instance of the response message returned by the service operation 1965Exceptions: 1966 The ResponseDispatch.sendResponse() method MUST throw an InvalidStateException if either the 1967 sendResponse method or the sendFault method has already been called once. [JCA80058] 1968 1969sendFault ( Throwable e ) method: 1970Sends an exception as a fault from an asynchronous service method. This method can only be invoked 1971once for a given ResponseDispatch object and cannot be invoked if sendResponse has previously been 1972invoked for the same ResponseDispatch object. 1973Returns: 1974 void 1975 The ResponseDispatch.sendFault() method MUST send the supplied fault to the client of an 1976 asynchronous service. [JCA80059] 1977Parameters: 1978 e - an instance of an exception returned by the service operation 1979Exceptions: 1980 The ResponseDispatch.sendFault() method MUST throw an InvalidStateException if either the 1981 sendResponse method or the sendFault method has already been called once. [JCA80060] 1982 1983getContext () method: 1984Obtains the context object for the ResponseDispatch method 1985Returns: 1986 Map
1993 9.5 ServiceRuntimeException 1994Figure 9-6 shows the ServiceRuntimeException. 1995 1996 package org.oasisopen.sca; 1997 1998 public class ServiceRuntimeException extends RuntimeException { 1999 … 2000 }
2001Figure 9-6: ServiceRuntimeException 2002 2003This exception signals problems in the management of SCA component execution.
99sca-javacaa-1.1-spec-csd06 15 August 2011 100Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 50 of 121 2004 9.6 ServiceUnavailableException 2005Figure 9-7 shows the ServiceUnavailableException. 2006 2007 package org.oasisopen.sca; 2008 2009 public class ServiceUnavailableException extends ServiceRuntimeException { 2010 … 2011 }
2012Figure 9-7: ServiceUnavailableException 2013 2014This exception signals problems in the interaction with remote services. These are exceptions that can 2015be transient, so retrying is appropriate. Any exception that is a ServiceRuntimeException that is not a 2016ServiceUnavailableException is unlikely to be resolved by retrying the operation, since it most likely 2017requires human intervention
2018 9.7 InvalidServiceException 2019Figure 9-8 shows the InvalidServiceException. 2020 2021 package org.oasisopen.sca; 2022 2023 public class InvalidServiceException extends ServiceRuntimeException { 2024 … 2025 }
2026Figure 9-8: InvalidServiceException 2027 2028This exception signals that the ServiceReference is no longer valid. This can happen when the target of 2029the reference is undeployed. This exception is not transient and therefore is unlikely to be resolved by 2030retrying the operation and will most likely require human intervention.
2031 9.8 Constants 2032The SCA Constants interface defines a number of constant values that are used in the SCA Java APIs 2033and Annotations. Figure 9-9 shows the Constants interface: 2034 package org.oasisopen.sca; 2035 2036 public interface Constants { 2037 2038 String SCA_NS = "http://docs.oasis-open.org/ns/opencsa/sca/200912"; 2039 2040 String SCA_PREFIX = "{"+SCA_NS+"}"; 2041 2042 String SERVERAUTHENTICATION = SCA_PREFIX + "serverAuthentication"; 2043 String CLIENTAUTHENTICATION = SCA_PREFIX + "clientAuthentication"; 2044 String ATLEASTONCE = SCA_PREFIX + "atLeastOnce"; 2045 String ATMOSTONCE = SCA_PREFIX + "atMostOnce"; 2046 String EXACTLYONCE = SCA_PREFIX + "exactlyOnce"; 2047 String ORDERED = SCA_PREFIX + "ordered"; 2048 String TRANSACTEDONEWAY = SCA_PREFIX + "transactedOneWay"; 2049 String IMMEDIATEONEWAY = SCA_PREFIX + "immediateOneWay"; 2050 String PROPAGATESTRANSACTION = SCA_PREFIX + "propagatesTransaction"; 2051 String SUSPENDSTRANSACTION = SCA_PREFIX + "suspendsTransaction"; 2052 String ASYNCINVOCATION = SCA_PREFIX + "asyncInvocation"; 2053 String SOAP = SCA_PREFIX + "SOAP";
101sca-javacaa-1.1-spec-csd06 15 August 2011 102Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 51 of 121 2054 String JMS = SCA_PREFIX + "JMS"; 2055 String NOLISTENER = SCA_PREFIX + "noListener"; 2056 String EJB = SCA_PREFIX + "EJB"; 2057 2058 }
2059Figure 9-9: Constants Interface
2060 9.9 SCAClientFactory Class 2061The SCAClientFactory class provides the means for client code to obtain a proxy reference object for a 2062service within an SCA Domain, through which the client code can invoke operations of that service. This 2063is particularly useful for client code that is running outside the SCA Domain containing the target service, 2064for example where the code is "unmanaged" and is not running under an SCA runtime. 2065The SCAClientFactory is an abstract class which provides a set of static newInstance(...) methods which 2066the client can invoke in order to obtain a concrete object implementing the SCAClientFactory interface for 2067a particular SCA Domain. The returned SCAClientFactory object provides a getService() method which 2068provides the client with the means to obtain a reference proxy object for a service running in the SCA 2069Domain. 2070The SCAClientFactory class is shown in Figure 9-10: 2071 2072 package org.oasisopen.sca.client; 2073 2074 import java.net.URI; 2075 import java.util.Properties; 2076 2077 import org.oasisopen.sca.NoSuchDomainException; 2078 import org.oasisopen.sca.NoSuchServiceException; 2079 import org.oasisopen.sca.client.SCAClientFactoryFinder; 2080 import org.oasisopen.sca.client.impl.SCAClientFactoryFinderImpl; 2081 2082 public abstract class SCAClientFactory { 2083 2084 protected static SCAClientFactoryFinder factoryFinder; 2085 2086 private URI domainURI; 2087 2088 private SCAClientFactory() { 2089 } 2090 2091 protected SCAClientFactory(URI domainURI) 2092 throws NoSuchDomainException { 2093 this.domainURI = domainURI; 2094 } 2095 2096 protected URI getDomainURI() { 2097 return domainURI; 2098 } 2099 2100 public static SCAClientFactory newInstance( URI domainURI ) 2101 throws NoSuchDomainException { 2102 return newInstance(null, null, domainURI); 2103 } 2104 2105 public static SCAClientFactory newInstance(Properties properties, 2106 URI domainURI) 2107 throws NoSuchDomainException { 2108 return newInstance(properties, null, domainURI); 2109 } 2110 2111 public static SCAClientFactory newInstance(ClassLoader classLoader,
103sca-javacaa-1.1-spec-csd06 15 August 2011 104Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 52 of 121 2112 URI domainURI) 2113 throws NoSuchDomainException { 2114 return newInstance(null, classLoader, domainURI); 2115 } 2116 2117 public static SCAClientFactory newInstance(Properties properties, 2118 ClassLoader classLoader, 2119 URI domainURI) 2120 throws NoSuchDomainException { 2121 final SCAClientFactoryFinder finder = 2122 factoryFinder != null ? factoryFinder : 2123 new SCAClientFactoryFinderImpl(); 2124 final SCAClientFactory factory 2125 = finder.find(properties, classLoader, domainURI); 2126 return factory; 2127 } 2128 2129 public abstract
2132Figure 9-10: SCAClientFactory Class 2133 2134newInstance ( URI domainURI ) method: 2135Obtains a object implementing the SCAClientFactory class. 2136Returns: 2137 object which implements the SCAClientFactory class 2138 The SCAClientFactory.newInstance( URI ) method MUST return an object which implements the 2139 SCAClientFactory class for the SCA Domain identified by the domainURI parameter. [JCA80042] 2140Parameters: 2141 domainURI - a URI for the SCA Domain which is targeted by the returned SCAClient object 2142Exceptions: 2143 The SCAClientFactory.newInstance( URI ) method MUST throw a NoSuchDomainException if the 2144 domainURI parameter does not identify a valid SCA Domain. [JCA80043] 2145 2146newInstance(Properties properties, URI domainURI) method: 2147Obtains a object implementing the SCAClientFactory class, using a specified set of properties. 2148Returns: 2149 object which implements the SCAClientFactory class 2150 The SCAClientFactory.newInstance( Properties, URI ) method MUST return an object which 2151 implements the SCAClientFactory class for the SCA Domain identified by the domainURI parameter. 2152 [JCA80044] 2153Parameters: 2154 properties - a set of Properties that can be used when creating the object which implements the 2155 SCAClientFactory class. 2156 domainURI - a URI for the SCA Domain which is targeted by the returned SCAClient object 2157Exceptions: 2158 The SCAClientFactory.newInstance( Properties, URI ) method MUST throw a 2159 NoSuchDomainException if the domainURI parameter does not identify a valid SCA Domain. 2160 [JCA80045] 2161 105sca-javacaa-1.1-spec-csd06 15 August 2011 106Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 53 of 121 2162newInstance(Classloader classLoader, URI domainURI) method: 2163Obtains a object implementing the SCAClientFactory class using a specified classloader. 2164Returns: 2165 object which implements the SCAClientFactory class 2166 The SCAClientFactory.newInstance( Classloader, URI ) method MUST return an object which 2167 implements the SCAClientFactory class for the SCA Domain identified by the domainURI parameter. 2168 [JCA80046] 2169Parameters: 2170 classLoader - a ClassLoader to use when creating the object which implements the 2171 SCAClientFactory class. 2172 domainURI - a URI for the SCA Domain which is targeted by the returned SCAClient object 2173Exceptions: 2174 The SCAClientFactory.newInstance( Classloader, URI ) method MUST throw a 2175 NoSuchDomainException if the domainURI parameter does not identify a valid SCA Domain. 2176 [JCA80047] 2177 2178newInstance(Properties properties, Classloader classLoader, URI domainURI) method: 2179Obtains a object implementing the SCAClientFactory class using a specified set of properties and a 2180specified classloader. 2181Returns: 2182 object which implements the SCAClientFactory class 2183 The SCAClientFactory.newInstance( Properties, Classloader, URI ) method MUST return an object 2184 which implements the SCAClientFactory class for the SCA Domain identified by the domainURI 2185 parameter. [JCA80048] 2186Parameters: 2187 properties - a set of Properties that can be used when creating the object which implements the 2188 SCAClientFactory class. 2189 classLoader - a ClassLoader to use when creating the object which implements the 2190 SCAClientFactory class. 2191 domainURI - a URI for the SCA Domain which is targeted by the returned SCAClient object 2192Exceptions: 2193 The SCAClientFactory.newInstance( Properties, Classloader, URI ) MUST throw a 2194 NoSuchDomainException if the domainURI parameter does not identify a valid SCA Domain. 2195 [JCA80049] 2196 2197getService( Class
2240 9.10 SCAClientFactoryFinder Interface 2241The SCAClientFactoryFinder interface is a Service Provider Interface representing a SCAClientFactory 2242finder. SCA provides a default reference implementation of this interface. SCA runtime vendors can 2243create alternative implementations of this interface that use different class loading or lookup mechanisms: 2244 2245 package org.oasisopen.sca.client; 2246 2247 public interface SCAClientFactoryFinder { 2248 2249 SCAClientFactory find(Properties properties, 2250 ClassLoader classLoader, 2251 URI domainURI ) 2252 throws NoSuchDomainException ; 2253 }
109sca-javacaa-1.1-spec-csd06 15 August 2011 110Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 55 of 121 2254Figure 9-11: SCAClientFactoryFinder Interface 2255 2256find (Properties properties, ClassLoader classloader, URI domainURI) method: 2257Obtains an implementation of the SCAClientFactory interface. 2258Returns: 2259 SCAClientFactory implementation object 2260 The implementation of the SCAClientFactoryFinder.find method MUST return an object which is an 2261 implementation of the SCAClientFactory interface, for the SCA Domain represented by the 2262 doaminURI parameter, using the supplied properties and classloader. [JCA80055] 2263Parameters: 2264 properties - a set of Properties that can be used when creating the object which implements the 2265 SCAClientFactory interface. 2266 classLoader - a ClassLoader to use when creating the object which implements the 2267 SCAClientFactory interface. 2268 domainURI - a URI for the SCA Domain targeted by the SCAClientFactory 2269Exceptions: 2270 The implementation of the SCAClientFactoryFinder.find method MUST throw a 2271 ServiceRuntimeException if the SCAClientFactory implementation could not be found. [JCA80056]
2272 9.11 SCAClientFactoryFinderImpl Class 2273This class is a default implementation of an SCAClientFactoryFinder, which is used to find an 2274implementation of an SCAClientFactory subclass, as used to obtain an SCAClient object for use by a 2275client. SCA runtime providers can replace this implementation with their own version. 2276 2277 package org.oasisopen.sca.client.impl; 2278 2279 public class SCAClientFactoryFinderImpl implements SCAClientFactoryFinder { 2280 ... 2281 public SCAClientFactoryFinderImpl() {...} 2282 2283 public SCAClientFactory find(Properties properties, 2284 ClassLoader classLoader 2285 URI domainURI) 2286 throws NoSuchDomainException, ServiceRuntimeException {...} 2287 ... 2288 } 2289Snippet 9-41: SCAClientFactoryFinderImpl Class 2290 2291SCAClientFactoryFinderImpl () method: 2292Public constructor for the SCAClientFactoryFinderImpl. 2293Returns: 2294 SCAClientFactoryFinderImpl which implements the SCAClientFactoryFinder interface 2295Parameters: 2296 none 2297Exceptions: 2298 none 2299
111sca-javacaa-1.1-spec-csd06 15 August 2011 112Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 56 of 121 2300find (Properties, ClassLoader, URI) method: 2301Obtains an implementation of the SCAClientFactory interface. It discovers a provider's SCAClientFactory 2302implementation by referring to the following information in this order: 23031. The org.oasisopen.sca.client.SCAClientFactory property from the Properties specified on the 2304 newInstance() method call if specified 23052. The org.oasisopen.sca.client.SCAClientFactory property from the System Properties 23063. The META-INF/services/org.oasisopen.sca.client.SCAClientFactory file 2307Returns: 2308 SCAClientFactory implementation object 2309Parameters: 2310 properties - a set of Properties that can be used when creating the object which implements the 2311 SCAClientFactory interface. 2312 classLoader - a ClassLoader to use when creating the object which implements the 2313 SCAClientFactory interface. 2314 domainURI - a URI for the SCA Domain targeted by the SCAClientFactory 2315Exceptions: 2316 ServiceRuntimeException - if the SCAClientFactory implementation could not be found
2317 9.12 NoSuchDomainException 2318Figure 9-12 shows the NoSuchDomainException: 2319 2320 package org.oasisopen.sca; 2321 2322 public class NoSuchDomainException extends Exception { 2323 ... 2324 }
2325Figure 9-12: NoSuchDomainException Class 2326 2327This exception indicates that the Domain specified could not be found.
2328 9.13 NoSuchServiceException 2329Figure 9-13 shows the NoSuchServiceException: 2330 2331 package org.oasisopen.sca; 2332 2333 public class NoSuchServiceException extends Exception { 2334 ... 2335 }
2336Figure 9-13: NoSuchServiceException Class 2337 2338This exception indicates that the service specified could not be found.
113sca-javacaa-1.1-spec-csd06 15 August 2011 114Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 57 of 121 233910Java Annotations 2340This section provides definitions of all the Java annotations which apply to SCA. 2341This specification places constraints on some annotations that are not detectable by a Java compiler. For 2342example, the definition of the @Property and @Reference annotations indicate that they are allowed on 2343parameters, but the sections "@Property" and "@Reference" constrain those definitions to constructor 2344parameters. An SCA runtime MUST verify the proper use of all SCA annotations and if an annotation is 2345improperly used, the SCA runtime MUST NOT run the component which uses the invalid implementation 2346code. [JCA90001] 2347SCA annotations MUST NOT be used on static methods or on static fields. It is an error to use an SCA 2348annotation on a static method or a static field of an implementation class and the SCA runtime MUST 2349NOT instantiate such an implementation class. [JCA90002]
2350 10.1 @AllowsPassByReference 2351Figure 10-14 defines the @AllowsPassByReference annotation: 2352 2353 package org.oasisopen.sca.annotation; 2354 2355 import static java.lang.annotation.ElementType.FIELD; 2356 import static java.lang.annotation.ElementType.METHOD; 2357 import static java.lang.annotation.ElementType.PARAMETER; 2358 import static java.lang.annotation.ElementType.TYPE; 2359 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2360 import java.lang.annotation.Retention; 2361 import java.lang.annotation.Target; 2362 2363 @Target({TYPE, METHOD, FIELD, PARAMETER}) 2364 @Retention(RUNTIME) 2365 public @interface AllowsPassByReference { 2366 2367 boolean value() default true; 2368 }
2369Figure 10-14: AllowsPassByReference Annotation 2370 2371The @AllowsPassByReference annotation allows service method implementations and client references 2372to be marked as “allows pass by reference” to indicate that they use input parameters, return values and 2373exceptions in a manner that allows the SCA runtime to avoid the cost of copying mutable objects when a 2374remotable service is called locally within the same JVM. 2375The @AllowsPassByReference annotation has the attribute: 2376 value – specifies whether the “allows pass by reference” marker applies to the service 2377 implementation class, service implementation method, or client reference to which this annotation 2378 applies; if not specified, defaults to true. 2379 The @AllowsPassByReference annotation MUST only annotate the following locations: [JCA90052] 2380The “allows pass by reference” marking of a method implementation of a remotable service is determined 2381as follows: 23821. If the method has an @AllowsPassByReference annotation, the method is marked “allows pass by 2383 reference” if and only if the value of the method’s annotation is true. 23842. Otheriwse, if the class has an @AllowsPassByReference annotation, the method is marked “allows 2385 pass by reference” if and only if the value of the class’s annotation is true. 115sca-javacaa-1.1-spec-csd06 15 August 2011 116Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 58 of 121 23863. Otherwise, the method is not marked “allows pass by reference”. 2387The “allows pass by reference” marking of a reference for a remotable service is determined as follows: 23881. If the reference has an @AllowsPassByReference annotation, the reference is marked “allows pass 2389 by reference” if and only if the value of the reference’s annotation is true. 23902. Otherwise, if the service implementation class containing the reference has an 2391 @AllowsPassByReference annotation, the reference is marked “allows pass by reference” if and only 2392 if the value of the class’s annotation is true. 23933. Otherwise, the reference is not marked “allows pass by reference”. 2394Snippet 10-42 shows a sample where @AllowsPassByReference is defined for the implementation of a 2395service method on the Java component implementation class. 2396 2397 @AllowsPassByReference 2398 public String hello(String message) { 2399 … 2400 } 2401Snippet 10-42: Use of @AllowsPassByReference on a Method 2402 2403Snippet 10-43 shows a sample where @AllowsPassByReference is defined for a client reference of a 2404Java component implementation class. 2405 2406 @AllowsPassByReference 2407 @Reference 2408 private StockQuoteService stockQuote; 2409Snippet 10-43: Use of @AllowsPassByReference on a Reference
2410 10.2 @AsyncFault 2411Figure 10-15 defines the @AsyncFault annotation: 2412 2413 package org.oasisopen.sca.annotation; 2414 2415 import static java.lang.annotation.ElementType.METHOD; 2416 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2417 2418 import java.lang.annotation.Inherited; 2419 import java.lang.annotation.Retention; 2420 import java.lang.annotation.Target; 2421 2422 @Inherited 2423 @Target({METHOD}) 2424 @Retention(RUNTIME) 2425 public @interface AsyncFault { 2426 2427 Class[] value() default {}; 2428 2429 }
2430Figure 10-15: AsyncFault Annotation 2431 2432The @AsyncFault annotation is used to indicate the faults/exceptions which are returned by the 2433asynchronous service method which it annotates.
117sca-javacaa-1.1-spec-csd06 15 August 2011 118Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 59 of 121 2434 10.3 @AsyncInvocation 2435Figure 10-16 defines the @AsyncInvocation annotation, which is used to attach the "asyncInvocation" 2436policy intent to an interface or to a method: 2437 2438 package org.oasisopen.sca.annotation; 2439 2440 import static java.lang.annotation.ElementType.METHOD; 2441 import static java.lang.annotation.ElementType.TYPE; 2442 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2443 import static org.oasisopen.sca.Constants.SCA_PREFIX; 2444 2445 import java.lang.annotation.Inherited; 2446 import java.lang.annotation.Retention; 2447 import java.lang.annotation.Target; 2448 2449 @Inherited 2450 @Target({TYPE, METHOD}) 2451 @Retention(RUNTIME) 2452 @Intent(AsyncInvocation.ASYNCINVOCATION) 2453 public @interface AsyncInvocation { 2454 String ASYNCINVOCATION = SCA_PREFIX + "asyncInvocation"; 2455 2456 boolean value() default true; 2457 }
2458Figure 10-16: AsyncInvocation Annotation 2459 2460The @AsyncInvocation annotation is used to indicate that the operations of a Java interface uses the 2461long-running request-response pattern as described in the SCA Assembly specification.
2462 10.4 @Authentication 2463The following Java code defines the @Authentication annotation: 2464 2465 package org.oasisopen.sca.annotation; 2466 2467 import static java.lang.annotation.ElementType.FIELD; 2468 import static java.lang.annotation.ElementType.METHOD; 2469 import static java.lang.annotation.ElementType.PARAMETER; 2470 import static java.lang.annotation.ElementType.TYPE; 2471 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2472 import static org.oasisopen.sca.Constants.SCA_PREFIX; 2473 2474 import java.lang.annotation.Inherited; 2475 import java.lang.annotation.Retention; 2476 import java.lang.annotation.Target; 2477 2478 @Inherited 2479 @Target({TYPE, FIELD, METHOD, PARAMETER}) 2480 @Retention(RUNTIME) 2481 @Intent(Authentication.AUTHENTICATION) 2482 public @interface Authentication { 2483 String AUTHENTICATION = SCA_PREFIX + "authentication"; 2484 String AUTHENTICATION_MESSAGE = AUTHENTICATION + ".message"; 2485 String AUTHENTICATION_TRANSPORT = AUTHENTICATION + ".transport"; 2486 2487 /** 2488 * List of authentication qualifiers (such as "message"
119sca-javacaa-1.1-spec-csd06 15 August 2011 120Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 60 of 121 2489 * or "transport"). 2490 * 2491 * @return authentication qualifiers 2492 */ 2493 @Qualifier 2494 String[] value() default ""; 2495 }
2496Figure 10-17: Authentication Annotation 2497 2498The @Authentication annotation is used to indicate the need for authentication. See the SCA Policy 2499Framework Specification [POLICY] for details on the meaning of the intent. See the section on 2500Application of Intent Annotations for samples of how intent annotations are used in Java.
2501 10.5 @Authorization 2502Figure 10-18 defines the @Authorization annotation: 2503 2504 package org.oasisopen.sca.annotation; 2505 2506 import static java.lang.annotation.ElementType.FIELD; 2507 import static java.lang.annotation.ElementType.METHOD; 2508 import static java.lang.annotation.ElementType.PARAMETER; 2509 import static java.lang.annotation.ElementType.TYPE; 2510 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2511 import static org.oasisopen.sca.Constants.SCA_PREFIX; 2512 2513 import java.lang.annotation.Inherited; 2514 import java.lang.annotation.Retention; 2515 import java.lang.annotation.Target; 2516 2517 /** 2518 * The @Authorization annotation is used to indicate that 2519 * an authorization policy is required. 2520 */ 2521 @Inherited 2522 @Target({TYPE, FIELD, METHOD, PARAMETER}) 2523 @Retention(RUNTIME) 2524 @Intent(Authorization.AUTHORIZATION) 2525 public @interface Authorization { 2526 String AUTHORIZATION = SCA_PREFIX + "authorization"; 2527 }
2528Figure 10-18: Authorization Annotation 2529 2530The @Authorization annotation is used to indicate the need for an authorization policy. See the SCA 2531Policy Framework Specification [POLICY] for details on the meaning of the intent. See the section on 2532Application of Intent Annotations for samples of how intent annotations are used in Java.
2533 10.6 @Callback 2534Figure 10-19 defines the @Callback annotation: 2535 2536 package org.oasisopen.sca.annotation; 2537 2538 import static java.lang.annotation.ElementType.FIELD; 2539 import static java.lang.annotation.ElementType.METHOD;
121sca-javacaa-1.1-spec-csd06 15 August 2011 122Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 61 of 121 2540 import static java.lang.annotation.ElementType.TYPE; 2541 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2542 import java.lang.annotation.Retention; 2543 import java.lang.annotation.Target; 2544 2545 @Target({TYPE, METHOD, FIELD}) 2546 @Retention(RUNTIME) 2547 public @interface Callback { 2548 2549 Class value() default Void.class; 2550 }
2551Figure 10-19: Callback Annotation 2552 2553The @Callback annotation is used to annotate a service interface or to annotate a Java class (used to 2554define an interface) with a callback interface by specifying the Java class object of the callback interface 2555as an attribute. 2556The @Callback annotation has the attribute: 2557 value – the name of a Java class file containing the callback interface 2558The @Callback annotation can also be used to annotate a method or a field of an SCA implementation 2559class, in order to have a callback object injected. When used to annotate a method or a field of an 2560implementation class for injection of a callback object, the@Callback annotation MUST NOT specify any 2561attributes. [JCA90046] When used to annotate a method or a field of an implementation class for injection 2562of a callback object, the type of the method or field MUST be the callback interface of at least one 2563bidirectional service offered by the implementation class. [JCA90054] When used to annotate a setter 2564method or a field of an implementation class for injection of a callback object, the SCA runtime MUST 2565inject a callback reference proxy into that method or field when the Java class is initialized, if the 2566component is invoked via a service which has a callback interface and where the type of the setter 2567method or field corresponds to the type of the callback interface. [JCA90058] 2568The @Callback annotation MUST NOT appear on a setter method or a field of a Java implementation 2569class that has COMPOSITE scope. [JCA90057] 2570Snippet 10-44 shows an example use of the @Callback annotation to declare a callback interface. 2571 2572 package somepackage; 2573 import org.oasisopen.sca.annotation.Callback; 2574 import org.oasisopen.sca.annotation.Remotable; 2575 @Remotable 2576 @Callback(MyServiceCallback.class) 2577 public interface MyService { 2578 2579 void someMethod(String arg); 2580 } 2581 2582 @Remotable 2583 public interface MyServiceCallback { 2584 2585 void receiveResult(String result); 2586 } 2587Snippet 10-44: Use of @Callback 2588 2589The implied component type is for Snippet 10-44 is shown in Snippet 10-45. 2590 2591
123sca-javacaa-1.1-spec-csd06 15 August 2011 124Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 62 of 121 2593
2599 10.7 @ComponentName 2600Figure 10-20 defines the @ComponentName annotation: 2601 2602 package org.oasisopen.sca.annotation; 2603 2604 import static java.lang.annotation.ElementType.FIELD; 2605 import static java.lang.annotation.ElementType.METHOD; 2606 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2607 import java.lang.annotation.Retention; 2608 import java.lang.annotation.Target; 2609 2610 @Target({METHOD, FIELD}) 2611 @Retention(RUNTIME) 2612 public @interface ComponentName { 2613 2614 }
2615Figure 10-20: ComponentName Annotation 2616 2617The @ComponentName annotation is used to denote a Java class field or setter method that is used to 2618inject the component name. 2619Snippet 10-46 shows a component name field definition sample. 2620 2621 @ComponentName 2622 private String componentName; 2623Snippet 10-46: Use of @ComponentName on a Field 2624 2625Snippet 10-47 shows a component name setter method sample. 2626 2627 @ComponentName 2628 public void setComponentName(String name) { 2629 //… 2630 } 2631Snippet 10-47: Use of @ComponentName on a Setter
2632 10.8 @Confidentiality 2633Figure 10-21 defines the @Confidentiality annotation: 2634 2635 package org.oasisopen.sca.annotation; 2636 2637 import static java.lang.annotation.ElementType.FIELD; 2638 import static java.lang.annotation.ElementType.METHOD; 2639 import static java.lang.annotation.ElementType.PARAMETER; 2640 import static java.lang.annotation.ElementType.TYPE;
125sca-javacaa-1.1-spec-csd06 15 August 2011 126Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 63 of 121 2641 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2642 import static org.oasisopen.sca.Constants.SCA_PREFIX; 2643 2644 import java.lang.annotation.Inherited; 2645 import java.lang.annotation.Retention; 2646 import java.lang.annotation.Target; 2647 2648 @Inherited 2649 @Target({TYPE, FIELD, METHOD, PARAMETER}) 2650 @Retention(RUNTIME) 2651 @Intent(Confidentiality.CONFIDENTIALITY) 2652 public @interface Confidentiality { 2653 String CONFIDENTIALITY = SCA_PREFIX + "confidentiality"; 2654 String CONFIDENTIALITY_MESSAGE = CONFIDENTIALITY + ".message"; 2655 String CONFIDENTIALITY_TRANSPORT = CONFIDENTIALITY + ".transport"; 2656 2657 /** 2658 * List of confidentiality qualifiers such as "message" or 2659 * "transport". 2660 * 2661 * @return confidentiality qualifiers 2662 */ 2663 @Qualifier 2664 String[] value() default ""; 2665 }
2666Figure 10-21: Confidentiality Annotation 2667 2668The @Confidentiality annotation is used to indicate the need for confidentiality. See the SCA Policy 2669Framework Specification [POLICY] for details on the meaning of the intent. See the section on Application 2670of Intent Annotations for samples of how intent annotations are used in Java.
2671 10.9 @Constructor 2672Figure 10-22 defines the @Constructor annotation: 2673 2674 package org.oasisopen.sca.annotation; 2675 2676 import static java.lang.annotation.ElementType.CONSTRUCTOR; 2677 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2678 import java.lang.annotation.Retention; 2679 import java.lang.annotation.Target; 2680 2681 @Target(CONSTRUCTOR) 2682 @Retention(RUNTIME) 2683 public @interface Constructor { }
2684Figure 10-22: Constructor Annotation 2685 2686The @Constructor annotation is used to mark a particular constructor to use when instantiating a Java 2687component implementation. If a constructor of an implementation class is annotated with @Constructor 2688and the constructor has parameters, each of these parameters MUST have either a @Property 2689annotation or a @Reference annotation. [JCA90003] 2690Snippet 10-48 shows a sample for the @Constructor annotation. 2691
127sca-javacaa-1.1-spec-csd06 15 August 2011 128Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 64 of 121 2692 public class HelloServiceImpl implements HelloService { 2693 2694 public HelloServiceImpl(){ 2695 ... 2696 } 2697 2698 @Constructor 2699 public HelloServiceImpl(@Property(name="someProperty") 2700 String someProperty ){ 2701 ... 2702 } 2703 2704 public String hello(String message) { 2705 ... 2706 } 2707 } 2708Snippet 10-48: Use of @Constructor
2709 10.10 @Context 2710Figure 10-23 defines the @Context annotation: 2711 2712 package org.oasisopen.sca.annotation; 2713 2714 import static java.lang.annotation.ElementType.FIELD; 2715 import static java.lang.annotation.ElementType.METHOD; 2716 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2717 import java.lang.annotation.Retention; 2718 import java.lang.annotation.Target; 2719 2720 @Target({METHOD, FIELD}) 2721 @Retention(RUNTIME) 2722 public @interface Context { 2723 2724 }
2725Figure 10-23: Context Annotation 2726 2727The @Context annotation is used to denote a Java class field or a setter method that is used to inject a 2728composite context for the component. The type of context to be injected is defined by the type of the Java 2729class field or type of the setter method input argument; the type is either ComponentContext or 2730RequestContext. 2731The @Context annotation has no attributes. 2732Snippet 10-49 shows a ComponentContext field definition sample. 2733 2734 @Context 2735 protected ComponentContext context; 2736Snippet 10-49: Use of @Context for a ComponentContext 2737 2738Snippet 10-50 shows a RequestContext field definition sample. 2739 2740 @Context 2741 protected RequestContext context; 2742Snippet 10-50: Use of @Context for a RequestContext
129sca-javacaa-1.1-spec-csd06 15 August 2011 130Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 65 of 121 2743 10.11 @Destroy 2744Figure 10-24 defines the @Destroy annotation: 2745 2746 package org.oasisopen.sca.annotation; 2747 2748 import static java.lang.annotation.ElementType.METHOD; 2749 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2750 import java.lang.annotation.Retention; 2751 import java.lang.annotation.Target; 2752 2753 @Target(METHOD) 2754 @Retention(RUNTIME) 2755 public @interface Destroy { 2756 2757 }
2758Figure 10-24: Destroy Annotation 2759 2760The @Destroy annotation is used to denote a single Java class method that will be called when the scope 2761defined for the implementation class ends. A method annotated with @Destroy can have any access 2762modifier and MUST have a void return type and no arguments. [JCA90004] 2763If there is a method annotated with @Destroy that matches the criteria for the annotation, the SCA 2764runtime MUST call the annotated method when the scope defined for the implementation class ends. 2765[JCA90005] 2766Snippet 10-51 shows a sample for a destroy method definition. 2767 2768 @Destroy 2769 public void myDestroyMethod() { 2770 … 2771 } 2772Snippet 10-51: Use of @Destroy
2773 10.12 @EagerInit 2774Figure 10-25: EagerInit Annotation defines the @EagerInit annotation: 2775 2776 package org.oasisopen.sca.annotation; 2777 2778 import static java.lang.annotation.ElementType.TYPE; 2779 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2780 import java.lang.annotation.Retention; 2781 import java.lang.annotation.Target; 2782 2783 @Target(TYPE) 2784 @Retention(RUNTIME) 2785 public @interface EagerInit { 2786 2787 }
2788Figure 10-25: EagerInit Annotation 2789
131sca-javacaa-1.1-spec-csd06 15 August 2011 132Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 66 of 121 2790The @EagerInit annotation is used to mark the Java class of a COMPOSITE scoped implementation for 2791eager initialization. When marked for eager initialization with an @EagerInit annotation, the composite 2792scoped instance MUST be created when its containing component is started. [JCA90007]
2793 10.13 @Init 2794Figure 10-26: Init Annotation defines the @Init annotation: 2795 2796 package org.oasisopen.sca.annotation; 2797 2798 import static java.lang.annotation.ElementType.METHOD; 2799 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2800 import java.lang.annotation.Retention; 2801 import java.lang.annotation.Target; 2802 2803 @Target(METHOD) 2804 @Retention(RUNTIME) 2805 public @interface Init { 2806 2807 2808 }
2809Figure 10-26: Init Annotation 2810 2811The @Init annotation is used to denote a single Java class method that is called when the scope defined 2812for the implementation class starts. A method marked with the @Init annotation can have any access 2813modifier and MUST have a void return type and no arguments. [JCA90008] 2814If there is a method annotated with @Init that matches the criteria for the annotation, the SCA runtime 2815MUST call the annotated method after all property and reference injection is complete. [JCA90009] 2816Snippet 10-52 shows an example of an init method definition. 2817 2818 @Init 2819 public void myInitMethod() { 2820 … 2821 } 2822Snippet 10-52: Use of @Init
2823 10.14 @Integrity 2824Figure 10-27 defines the @Integrity annotation: 2825 2826 package org.oasisopen.sca.annotation; 2827 2828 import static java.lang.annotation.ElementType.FIELD; 2829 import static java.lang.annotation.ElementType.METHOD; 2830 import static java.lang.annotation.ElementType.PARAMETER; 2831 import static java.lang.annotation.ElementType.TYPE; 2832 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2833 import static org.oasisopen.sca.Constants.SCA_PREFIX; 2834 2835 import java.lang.annotation.Inherited; 2836 import java.lang.annotation.Retention; 2837 import java.lang.annotation.Target; 2838 2839 @Inherited
133sca-javacaa-1.1-spec-csd06 15 August 2011 134Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 67 of 121 2840 @Target({TYPE, FIELD, METHOD, PARAMETER}) 2841 @Retention(RUNTIME) 2842 @Intent(Integrity.INTEGRITY) 2843 public @interface Integrity { 2844 String INTEGRITY = SCA_PREFIX + "integrity"; 2845 String INTEGRITY_MESSAGE = INTEGRITY + ".message"; 2846 String INTEGRITY_TRANSPORT = INTEGRITY + ".transport"; 2847 2848 /** 2849 * List of integrity qualifiers (such as "message" or "transport"). 2850 * 2851 * @return integrity qualifiers 2852 */ 2853 @Qualifier 2854 String[] value() default ""; 2855 }
2856Figure 10-27: Integrity Annotation 2857 2858The @Integrity annotation is used to indicate that the invocation requires integrity (i.e. no tampering of 2859the messages between client and service). See the SCA Policy Framework Specification [POLICY] for 2860details on the meaning of the intent. See the section on Application of Intent Annotations for samples of 2861how intent annotations are used in Java.
2862 10.15 @Intent 2863Figure 10-28 defines the @Intent annotation: 2864 2865 package org.oasisopen.sca.annotation; 2866 2867 import static java.lang.annotation.ElementType.ANNOTATION_TYPE; 2868 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2869 import java.lang.annotation.Retention; 2870 import java.lang.annotation.Target; 2871 2872 @Target({ANNOTATION_TYPE}) 2873 @Retention(RUNTIME) 2874 public @interface Intent { 2875 /** 2876 * The qualified name of the intent, in the form defined by 2877 * {@link javax.xml.namespace.QName#toString}. 2878 * @return the qualified name of the intent 2879 */ 2880 String value() default ""; 2881 2882 /** 2883 * The XML namespace for the intent. 2884 * @return the XML namespace for the intent 2885 */ 2886 String targetNamespace() default ""; 2887 2888 /** 2889 * The name of the intent within its namespace. 2890 * @return name of the intent within its namespace 2891 */ 2892 String localPart() default ""; 2893 }
2894Figure 10-28: Intent Annotation 2895
135sca-javacaa-1.1-spec-csd06 15 August 2011 136Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 68 of 121 2896The @Intent annotation is used for the creation of new annotations for specific intents. It is not expected 2897that the @Intent annotation will be used in application code. 2898See the section "How to Create Specific Intent Annotations" for details and samples of how to define new 2899intent annotations.
2900 10.16 @ManagedSharedTransaction 2901Figure 10-29 defines the @ManagedSharedTransaction annotation: 2902 2903 package org.oasisopen.sca.annotation; 2904 2905 import static java.lang.annotation.ElementType.FIELD; 2906 import static java.lang.annotation.ElementType.METHOD; 2907 import static java.lang.annotation.ElementType.PARAMETER; 2908 import static java.lang.annotation.ElementType.TYPE; 2909 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2910 import static org.oasisopen.sca.Constants.SCA_PREFIX; 2911 2912 import java.lang.annotation.Inherited; 2913 import java.lang.annotation.Retention; 2914 import java.lang.annotation.Target; 2915 2916 /** 2917 * The @ManagedSharedTransaction annotation is used to indicate that 2918 * a distributed ACID transaction is required. 2919 */ 2920 @Inherited 2921 @Target({TYPE, FIELD, METHOD, PARAMETER}) 2922 @Retention(RUNTIME) 2923 @Intent(ManagedSharedTransaction.MANAGEDSHAREDTRANSACTION) 2924 public @interface ManagedSharedTransaction { 2925 String MANAGEDSHAREDTRANSACTION = SCA_PREFIX + "managedSharedTransaction"; 2926 }
2927Figure 10-29: ManagedSharedTransaction Annotation 2928 2929The @ManagedSharedTransaction annotation is used to indicate the need for a distributed and globally 2930coordinated ACID transaction. See the SCA Policy Framework Specification [POLICY] for details on the 2931meaning of the intent. See the section on Application of Intent Annotations for samples of how intent 2932annotations are used in Java.
2933 10.17 @ManagedTransaction 2934Figure 10-30 defines the @ManagedTransaction annotation: 2935 2936 import static java.lang.annotation.ElementType.FIELD; 2937 import static java.lang.annotation.ElementType.METHOD; 2938 import static java.lang.annotation.ElementType.PARAMETER; 2939 import static java.lang.annotation.ElementType.TYPE; 2940 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2941 import static org.oasisopen.sca.Constants.SCA_PREFIX; 2942 2943 import java.lang.annotation.Inherited; 2944 import java.lang.annotation.Retention; 2945 import java.lang.annotation.Target; 2946 2947 /** 2948 * The @ManagedTransaction annotation is used to indicate the
137sca-javacaa-1.1-spec-csd06 15 August 2011 138Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 69 of 121 2949 * need for an ACID transaction environment. 2950 */ 2951 @Inherited 2952 @Target({TYPE, FIELD, METHOD, PARAMETER}) 2953 @Retention(RUNTIME) 2954 @Intent(ManagedTransaction.MANAGEDTRANSACTION) 2955 public @interface ManagedTransaction { 2956 String MANAGEDTRANSACTION = SCA_PREFIX + "managedTransaction"; 2957 String MANAGEDTRANSACTION_LOCAL = MANAGEDTRANSACTION + ".local"; 2958 String MANAGEDTRANSACTION_GLOBAL = MANAGEDTRANSACTION + ".global"; 2959 2960 /** 2961 * List of managedTransaction qualifiers (such as "global" or "local"). 2962 * 2963 * @return managedTransaction qualifiers 2964 */ 2965 @Qualifier 2966 String[] value() default ""; 2967 }
2968Figure 10-30: ManagedTransaction Annotation 2969 2970The @ManagedTransaction annotation is used to indicate the need for an ACID transaction. See the 2971SCA Policy Framework Specification [POLICY] for details on the meaning of the intent. See the section 2972on Application of Intent Annotations for samples of how intent annotations are used in Java.
2973 10.18 @MutualAuthentication 2974Figure 10-31 defines the @MutualAuthentication annotation: 2975 2976 package org.oasisopen.sca.annotation; 2977 2978 import static java.lang.annotation.ElementType.FIELD; 2979 import static java.lang.annotation.ElementType.METHOD; 2980 import static java.lang.annotation.ElementType.PARAMETER; 2981 import static java.lang.annotation.ElementType.TYPE; 2982 import static java.lang.annotation.RetentionPolicy.RUNTIME; 2983 import static org.oasisopen.sca.Constants.SCA_PREFIX; 2984 2985 import java.lang.annotation.Inherited; 2986 import java.lang.annotation.Retention; 2987 import java.lang.annotation.Target; 2988 2989 /** 2990 * The @MutualAuthentication annotation is used to indicate that 2991 * a mutual authentication policy is needed. 2992 */ 2993 @Inherited 2994 @Target({TYPE, FIELD, METHOD, PARAMETER}) 2995 @Retention(RUNTIME) 2996 @Intent(MutualAuthentication.MUTUALAUTHENTICATION) 2997 public @interface MutualAuthentication { 2998 String MUTUALAUTHENTICATION = SCA_PREFIX + "mutualAuthentication"; 2999 }
3000Figure 10-31: MutualAuthentication Annotation 3001 3002The @MutualAuthentication annotation is used to indicate the need for mutual authentication between a 3003service consumer and a service provider. See the SCA Policy Framework Specification [POLICY] for
139sca-javacaa-1.1-spec-csd06 15 August 2011 140Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 70 of 121 3004details on the meaning of the intent. See the section on Application of Intent Annotations for samples of 3005how intent annotations are used in Java.
3006 10.19 @NoManagedTransaction 3007Figure 10-32 defines the @NoManagedTransaction annotation: 3008 3009 package org.oasisopen.sca.annotation; 3010 3011 import static java.lang.annotation.ElementType.FIELD; 3012 import static java.lang.annotation.ElementType.METHOD; 3013 import static java.lang.annotation.ElementType.PARAMETER; 3014 import static java.lang.annotation.ElementType.TYPE; 3015 import static java.lang.annotation.RetentionPolicy.RUNTIME; 3016 import static org.oasisopen.sca.Constants.SCA_PREFIX; 3017 3018 import java.lang.annotation.Inherited; 3019 import java.lang.annotation.Retention; 3020 import java.lang.annotation.Target; 3021 3022 /** 3023 * The @NoManagedTransaction annotation is used to indicate that 3024 * a non-transactional environment is needed. 3025 */ 3026 @Inherited 3027 @Target({TYPE, FIELD, METHOD, PARAMETER}) 3028 @Retention(RUNTIME) 3029 @Intent(NoManagedTransaction.NOMANAGEDTRANSACTION) 3030 public @interface NoManagedTransaction { 3031 String NOMANAGEDTRANSACTION = SCA_PREFIX + "noManagedTransaction"; 3032 }
3033Figure 10-32: NoManagedTransaction Annotation 3034 3035The @NoManagedTransaction annotation is used to indicate that the component does not want to run in 3036an ACID transaction. See the SCA Policy Framework Specification [POLICY] for details on the meaning 3037of the intent. See the section on Application of Intent Annotations for samples of how intent annotations 3038are used in Java.
3039 10.20 @OneWay 3040Figure 10-33 defines the @OneWay annotation: 3041 3042 package org.oasisopen.sca.annotation; 3043 3044 import static java.lang.annotation.ElementType.METHOD; 3045 import static java.lang.annotation.RetentionPolicy.RUNTIME; 3046 import java.lang.annotation.Retention; 3047 import java.lang.annotation.Target; 3048 3049 @Target(METHOD) 3050 @Retention(RUNTIME) 3051 public @interface OneWay { 3052 3053 3054 }
3055Figure 10-33: OneWay Annotation
141sca-javacaa-1.1-spec-csd06 15 August 2011 142Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 71 of 121 3056 3057A method annotated with @OneWay MUST have a void return type and MUST NOT have declared 3058checked exceptions. [JCA90055] 3059When a method of a Java interface is annotated with @OneWay, the SCA runtime MUST ensure that all 3060invocations of that method are executed in a non-blocking fashion, as described in the section on 3061Asynchronous Programming. [JCA90056] 3062The @OneWay annotation has no attributes. 3063Snippet 10-53 shows the use of the @OneWay annotation on an interface. 3064 3065 package services.hello; 3066 3067 import org.oasisopen.sca.annotation.OneWay; 3068 3069 public interface HelloService { 3070 @OneWay 3071 void hello(String name); 3072 } 3073Snippet 10-53: Use of @OneWay
3074 10.21 @PolicySets 3075Figure 10-34 defines the @PolicySets annotation: 3076 3077 package org.oasisopen.sca.annotation; 3078 3079 import static java.lang.annotation.ElementType.FIELD; 3080 import static java.lang.annotation.ElementType.METHOD; 3081 import static java.lang.annotation.ElementType.PARAMETER; 3082 import static java.lang.annotation.ElementType.TYPE; 3083 import static java.lang.annotation.RetentionPolicy.RUNTIME; 3084 3085 import java.lang.annotation.Retention; 3086 import java.lang.annotation.Target; 3087 3088 @Target({TYPE, FIELD, METHOD, PARAMETER}) 3089 @Retention(RUNTIME) 3090 public @interface PolicySets { 3091 /** 3092 * Returns the policy sets to be applied. 3093 * 3094 * @return the policy sets to be applied 3095 */ 3096 String[] value() default ""; 3097 }
3098Figure 10-34: PolicySets Annotation 3099 3100The @PolicySets annotation is used to attach one or more SCA Policy Sets to a Java implementation 3101class or to one of its subelements. 3102See the section "Policy Set Annotations" for details and samples.
3103 10.22 @Property 3104Figure 10-35 defines the @Property annotation: 3105
143sca-javacaa-1.1-spec-csd06 15 August 2011 144Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 72 of 121 3106 package org.oasisopen.sca.annotation; 3107 3108 import static java.lang.annotation.ElementType.FIELD; 3109 import static java.lang.annotation.ElementType.METHOD; 3110 import static java.lang.annotation.ElementType.PARAMETER; 3111 import static java.lang.annotation.RetentionPolicy.RUNTIME; 3112 import java.lang.annotation.Retention; 3113 import java.lang.annotation.Target; 3114 3115 @Target({METHOD, FIELD, PARAMETER}) 3116 @Retention(RUNTIME) 3117 public @interface Property { 3118 3119 String name() default ""; 3120 boolean required() default true; 3121 }
3122Figure 10-35: Property Annotation 3123 3124The @Property annotation is used to denote a Java class field, a setter method, or a constructor 3125parameter that is used to inject an SCA property value. The type of the property injected, which can be a 3126simple Java type or a complex Java type, is defined by the type of the Java class field or the type of the 3127input parameter of the setter method or constructor. 3128When the Java type of a field, setter method or constructor parameter with the @Property annotation is a 3129primitive type or a JAXB annotated class, the SCA runtime MUST convert a property value specified by 3130an SCA component definition into an instance of the Java type as defined by the XML to Java mapping in 3131the JAXB specification [JAXB] with XML schema validation enabled. [JCA90061] 3132When the Java type of a field, setter method or constructor parameter with the @Property annotation is 3133not a JAXB annotated class, the SCA runtime can use any XML to Java mapping when converting 3134property values into instances of the Java type. 3135The @Property annotation MUST NOT be used on a class field that is declared as final. [JCA90011] 3136Where there is both a setter method and a field for a property, the setter method is used. 3137The @Property annotation has the attributes: 3138 name (0..1) – the name of the property. For a field annotation, the default is the name of the field of 3139 the Java class. For a setter method annotation, the default is the JavaBeans property name 3140 [JAVABEANS] corresponding to the setter method name. For a @Property annotation applied to a 3141 constructor parameter, there is no default value for the name attribute and the name attribute MUST 3142 be present. [JCA90013] 3143 required (0..1) – a boolean value which specifies whether injection of the property value is required 3144 or not, where true means injection is required and false means injection is not required. Defaults to 3145 true. For a @Property annotation applied to a constructor parameter, the required attribute MUST 3146 NOT have the value false. [JCA90014] 3147} shows a property field definition sample. 3148 3149 @Property(name="currency", required=true) 3150 protected String currency; 3151 3152 The following snippet shows a property setter sample 3153 3154 @Property(name="currency", required=true) 3155 public void setCurrency( String theCurrency ) { 3156 .... 3157 } 3158Snippet 10-54: Use of @Property on a Field
145sca-javacaa-1.1-spec-csd06 15 August 2011 146Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 73 of 121 3159 3160For a @Property annotation, if the type of the Java class field or the type of the input parameter of the 3161setter method or constructor is defined as an array or as any type that extends or implements 3162java.util.Collection, then the SCA runtime MUST introspect the component type of the implementation 3163with a
3176 10.23 @Qualifier 3177Figure 10-36 defines the @Qualifier annotation: 3178 3179 package org.oasisopen.sca.annotation; 3180 3181 import static java.lang.annotation.ElementType.METHOD; 3182 import static java.lang.annotation.RetentionPolicy.RUNTIME; 3183 3184 import java.lang.annotation.Retention; 3185 import java.lang.annotation.Target; 3186 3187 @Target(METHOD) 3188 @Retention(RUNTIME) 3189 public @interface Qualifier { 3190 }
3191Figure 10-36: Qualifier Annotation 3192 3193The @Qualifier annotation is applied to an attribute of a specific intent annotation definition, defined using 3194the @Intent annotation, to indicate that the attribute provides qualifiers for the intent. The @Qualifier 3195annotation MUST be used in a specific intent annotation definition where the intent has qualifiers. 3196[JCA90015] 3197See the section "How to Create Specific Intent Annotations" for details and samples of how to define new 3198intent annotations.
3199 10.24 @Reference 3200Figure 10-37 defines the @Reference annotation: 3201 3202 package org.oasisopen.sca.annotation; 3203 3204 import static java.lang.annotation.ElementType.FIELD; 3205 import static java.lang.annotation.ElementType.METHOD; 3206 import static java.lang.annotation.ElementType.PARAMETER; 3207 import static java.lang.annotation.RetentionPolicy.RUNTIME; 3208 import java.lang.annotation.Retention;
147sca-javacaa-1.1-spec-csd06 15 August 2011 148Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 74 of 121 3209 import java.lang.annotation.Target; 3210 @Target({METHOD, FIELD, PARAMETER}) 3211 @Retention(RUNTIME) 3212 public @interface Reference { 3213 3214 String name() default ""; 3215 boolean required() default true; 3216 }
3217Figure 10-37: Reference Annotation 3218 3219The @Reference annotation type is used to annotate a Java class field, a setter method, or a constructor 3220parameter that is used to inject a service that resolves the reference. The interface of the service injected 3221is defined by the type of the Java class field or the type of the input parameter of the setter method or 3222constructor. 3223The @Reference annotation MUST NOT be used on a class field that is declared as final. [JCA90016] 3224Where there is both a setter method and a field for a reference, the setter method is used. 3225The @Reference annotation has the attributes: 3226 name : String (0..1) – the name of the reference. For a field annotation, the default is the name of the 3227 field of the Java class. For a setter method annotation, the default is the JavaBeans property name 3228 corresponding to the setter method name. For a @Reference annotation applied to a constructor 3229 parameter, there is no default for the name attribute and the name attribute MUST be present. 3230 [JCA90018] 3231 required (0..1) – a boolean value which specifies whether injection of the service reference is 3232 required or not, where true means injection is required and false means injection is not required. 3233 Defaults to true. For a @Reference annotation applied to a constructor parameter, the required 3234 attribute MUST have the value true. [JCA90019] 3235Snippet 10-56 shows a reference field definition sample. 3236 3237 @Reference(name="stockQuote", required=true) 3238 protected StockQuoteService stockQuote; 3239Snippet 10-56: Use of @Reference on a Field 3240 3241Snippet 10-57 shows a reference setter sample 3242 3243 @Reference(name="stockQuote", required=true) 3244 public void setStockQuote( StockQuoteService theSQService ) { 3245 ... 3246 } 3247Snippet 10-57: Use of @Reference on a Setter 3248 3249Snippet 10-58 shows a sample of a service reference using the @Reference annotation. The name of the 3250reference is “helloService” and its type is HelloService. The clientMethod() calls the “hello” operation of 3251the service referenced by the helloService reference. 3252 3253 package services.hello; 3254 3255 private HelloService helloService; 3256 3257 @Reference(name="helloService", required=true) 3258 public setHelloService(HelloService service) {
149sca-javacaa-1.1-spec-csd06 15 August 2011 150Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 75 of 121 3259 helloService = service; 3260 } 3261 3262 public void clientMethod() { 3263 String result = helloService.hello("Hello World!"); 3264 … 3265 } 3266Snippet 10-58: Use of @Reference and a ServiceReference 3267 3268The presence of a @Reference annotation is reflected in the componentType information that the runtime 3269generates through reflection on the implementation class. Snippet 10-59 shows the component type for 3270the component implementation fragment in Snippet 10-58. 3271 3272 3273
151sca-javacaa-1.1-spec-csd06 15 August 2011 152Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 76 of 121 3311Snippet 10-61 shows the XML representation of the component type reflected from for the former 3312component implementation fragment. There is no need to author this component type in this case since it 3313can be reflected from the Java class. 3314 3315 3316
3329 10.24.1 Reinjection 3330References can be reinjected by an SCA runtime after the initial creation of a component if the reference 3331target changes due to a change in wiring that has occurred since the component was initialized. 3332In order for reinjection to occur, the following need to be true: 3333 1. The component is not STATELESS scoped. 3334 2. The reference needs to use either field-based injection or setter injection. References that are 3335 injected through constructor injection cannot be changed. 3336Setter injection allows for code in the setter method to perform processing in reaction to a change. 3337If a reference target changes and the reference is not reinjected, the reference needs to continue to work 3338as if the reference target was not changed. 3339If an operation is called on a reference where the target of that reference has been undeployed, the SCA 3340runtime is advised throw an InvalidServiceException. Likewise, if an operation is called on a reference 3341where the target of the reference has become unavailable for some reason, the SCA runtime is advised 3342throw a ServiceUnavailableException. In general, if the target service of the reference is changed, the 3343reference either continues to work or throws an InvalidServiceException when it is invoked. 3344A ServiceReference that has been obtained from a reference by ComponentContext.cast() corresponds 3345to the reference that is passed as a parameter to cast(). If the reference is subsequently reinjected, it is 3346expecged that the ServiceReference obtained from the original reference continues to work as if the 3347reference target was not changed. If the target of a ServiceReference has been undeployed, the SCA 3348runtime is advised to throw a InvalidServiceException when an operation is invoked on the 3349ServiceReference. If the target of a ServiceReference has become unavailable, the SCA runtime is 3350advised to throw a ServiceUnavailableException when an operation is invoked on the ServiceReference. 3351If the target service of a ServiceReference is changed, the reference either continues to work or throws 3352an InvalidServiceException when it is invoked. 3353A reference or ServiceReference accessed through the component context by calling getService() or 3354getServiceReference() is expected to correspond to the current configuration of the domain. This applies 3355whether or not reinjection has taken place. If the target of a reference or ServiceReference accessed 3356through the component context by calling getService() or getServiceReference() has been undeployed or 3357has become unavailable, the result is expected to be a reference to the undeployed or unavailable 3358service, and attempts to call business methods throw an InvalidServiceException or a 3359ServiceUnavailableException. If the target service of a reference or ServiceReference accessed through 3360the component context by calling getService() or getServiceReference() has changed, the returned value 3361is expected be a reference to the changed service.
153sca-javacaa-1.1-spec-csd06 15 August 2011 154Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 77 of 121 3362The expected behaviour for reference reinjection also applies to references with a multiplicity of 0..n or 33631..n. This means that in the cases where reference reinjection is not allowed, the array or Collection for a 3364reference of multiplicity 0..n or multiplicity 1..n does change its contents when changes occur to the 3365reference wiring or to the targets of the wiring. In cases where the contents of a reference array or 3366collection change when the wiring changes or the targets change, then for references that use setter 3367injection, the SCA runtime is expected to call the setter method for any change to the contents. A 3368reinjected array or Collection for a reference is expected to be a different array or Collection object from 3369that previously injected to the component. 3370 3371 Effect on Change Injected Reference or Existing Subsequent invocations of event ServiceReference ServiceReference ComponentContext.getService Object** Reference() or getService() Change to can be reinjected (if continue to work as if the Result corresponds to the the target other conditions* apply). reference target was not current configuration of the of the If not reinjected, then it changed. domain. reference continues to work as if the reference target was not changed. Target Business methods throw Business methods throw Result is a reference to the service InvalidServiceException. InvalidServiceException. undeployed service. Business undeployed methods throw InvalidServiceException. Target Business methods throw Business methods throw Result is be a reference to the service ServiceUnavailableExce ServiceUnavailableExce unavailable service. Business becomes ption ption methods throw unavailable ServiceUnavailableException. Target might continue to work, might continue to work, Result is a reference to the service depending on the depending on the changed service. changed runtime and the type of runtime and the type of change that was made. change that was made. If it doesn't work, the If it doesn't work, the exception thrown will exception thrown will depend on the runtime depend on the runtime and the cause of the and the cause of the failure. failure. * Other conditions: The component cannot be STATELESS scoped. The reference has to use either field-based injection or setter injection. References that are injected through constructor injection cannot be changed. ** Result of invoking ComponentContext.cast() corresponds to the reference that is passed as a parameter to cast().
3372Table 10-2Reinjection Effects
3373 10.25 @Remotable 3374Figure 10-38 defines the @Remotable annotation: 3375 155sca-javacaa-1.1-spec-csd06 15 August 2011 156Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 78 of 121 3376 package org.oasisopen.sca.annotation; 3377 3378 import static java.lang.annotation.ElementType.TYPE; 3379 import static java.lang.annotation.RetentionPolicy.RUNTIME; 3380 import java.lang.annotation.Retention; 3381 import java.lang.annotation.Target; 3382 3383 3384 @Target(TYPE,METHOD,FIELD,PARAMETER) 3385 @Retention(RUNTIME) 3386 public @interface Remotable { 3387 3388 }
3389Figure 10-38: Remotable Annotation 3390 3391The @Remotable annotation is used to indicate that an SCA service interface is remotable. The 3392@Remotable annotation is valid only on a Java interface, a Java class, a field, a setter method, or a 3393constructor parameter. It MUST NOT appear anywhere else. [JCA90053] A remotable service can be 3394published externally as a service and MUST be translatable into a WSDL portType. [JCA90040] 3395The @Remotable annotation has no attributes. When placed on a Java service interface, it indicates that 3396the interface is remotable. When placed on a Java service implementation class, it indicates that all SCA 3397service interfaces provided by the class (including the class itself, if the class defines an SCA service 3398interface) are remotable. When placed on a service reference, it indicates that the interface for the 3399reference is remotable. 3400Snippet 10-62 shows the Java interface for a remotable service with its @Remotable annotation. 3401 3402 package services.hello; 3403 3404 import org.oasisopen.sca.annotation.*; 3405 3406 @Remotable 3407 public interface HelloService { 3408 3409 String hello(String message); 3410 } 3411Snippet 10-62: Use of @Remotable on an Interface 3412 3413The style of remotable interfaces is typically coarse grained and intended for loosely coupled 3414interactions. Remotable service interfaces are not allowed to make use of method overloading. 3415Complex data types exchanged via remotable service interfaces need to be compatible with the 3416marshalling technology used by the service binding. For example, if the service is going to be exposed 3417using the standard Web Service binding, then the parameters can be JAXB [JAX-B] types or they can be 3418Service Data Objects (SDOs) [SDO]. 3419Independent of whether the remotable service is called from outside of the composite that contains it or 3420from another component in the same composite, the data exchange semantics are by-value. 3421Implementations of remotable services can modify input data during or after an invocation and can modify 3422return data after the invocation. If a remotable service is called locally or remotely, the SCA container is 3423responsible for making sure that no modification of input data or post-invocation modifications to return 3424data are seen by the caller. 3425Snippet 10-63 shows how a Java service implementation class can use the @Remotable annotation to 3426define a remotable SCA service interface using a Java service interface that is not marked as remotable. 3427
157sca-javacaa-1.1-spec-csd06 15 August 2011 158Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 79 of 121 3428 package services.hello; 3429 3430 import org.oasisopen.sca.annotation.*; 3431 3432 public interface HelloService { 3433 3434 String hello(String message); 3435 } 3436 3437 package services.hello; 3438 3439 import org.oasisopen.sca.annotation.*; 3440 3441 @Remotable 3442 @Service(HelloService.class) 3443 public class HelloServiceImpl implements HelloService { 3444 3445 public String hello(String message) { 3446 ... 3447 } 3448 } 3449Snippet 10-63: Use of @Remotable on a Class 3450 3451Snippet 10-64 shows how a reference can use the @Remotable annotation to define a remotable SCA 3452service interface using a Java service interface that is not marked as remotable. 3453 3454 package services.hello; 3455 3456 import org.oasisopen.sca.annotation.*; 3457 3458 public interface HelloService { 3459 3460 String hello(String message); 3461 } 3462 3463 package services.hello; 3464 3465 import org.oasisopen.sca.annotation.*; 3466 3467 public class HelloClient { 3468 3469 @Remotable 3470 @Reference 3471 protected HelloService myHello; 3472 3473 public String greeting(String message) { 3474 return myHello.hello(message); 3475 } 3476 } 3477Snippet 10-64: Use of @Remotable on a Reference
3478 10.26 @Requires 3479Figure 10-39 defines the @Requires annotation: 3480 3481 package org.oasisopen.sca.annotation; 3482 3483 import static java.lang.annotation.ElementType.FIELD;
159sca-javacaa-1.1-spec-csd06 15 August 2011 160Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 80 of 121 3484 import static java.lang.annotation.ElementType.METHOD; 3485 import static java.lang.annotation.ElementType.PARAMETER; 3486 import static java.lang.annotation.ElementType.TYPE; 3487 import static java.lang.annotation.RetentionPolicy.RUNTIME; 3488 3489 import java.lang.annotation.Inherited; 3490 import java.lang.annotation.Retention; 3491 import java.lang.annotation.Target; 3492 3493 @Inherited 3494 @Retention(RUNTIME) 3495 @Target({TYPE, METHOD, FIELD, PARAMETER}) 3496 public @interface Requires { 3497 /** 3498 * Returns the attached intents. 3499 * 3500 * @return the attached intents 3501 */ 3502 String[] value() default ""; 3503 }
3504Figure 10-39: Requires Annotation
3505 3506The @Requires annotation supports general purpose intents specified as strings. Users can also define 3507specific intent annotations using the @Intent annotation. 3508See the section "General Intent Annotations" for details and samples.
3509 10.27 @Scope 3510Figure 10-40 defines the @Scope annotation: 3511 3512 package org.oasisopen.sca.annotation; 3513 3514 import static java.lang.annotation.ElementType.TYPE; 3515 import static java.lang.annotation.RetentionPolicy.RUNTIME; 3516 import java.lang.annotation.Retention; 3517 import java.lang.annotation.Target; 3518 3519 @Target(TYPE) 3520 @Retention(RUNTIME) 3521 public @interface Scope { 3522 3523 String value() default "STATELESS"; 3524 }
3525Figure 10-40: Scope Annotation 3526 3527The @Scope annotation MUST only be used on a service's implementation class. It is an error to use this 3528annotation on an interface. [JCA90041] 3529The @Scope annotation has the attribute: 3530 value – the name of the scope. 3531 SCA defines the following scope names, but others can be defined by particular Java-based 3532 implementation types 3533 STATELESS 3534 COMPOSITE
161sca-javacaa-1.1-spec-csd06 15 August 2011 162Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 81 of 121 3535 The default value is STATELESS. 3536Snippet 10-65 shows a sample for a COMPOSITE scoped service implementation: 3537 3538 package services.hello; 3539 3540 import org.oasisopen.sca.annotation.*; 3541 3542 @Service(HelloService.class) 3543 @Scope("COMPOSITE") 3544 public class HelloServiceImpl implements HelloService { 3545 3546 public String hello(String message) { 3547 ... 3548 } 3549 } 3550Snippet 10-65: Use of @Scope
3551 10.28 @Service 3552Figure 10-41 defines the @Service annotation: 3553 3554 package org.oasisopen.sca.annotation; 3555 3556 import static java.lang.annotation.ElementType.TYPE; 3557 import static java.lang.annotation.RetentionPolicy.RUNTIME; 3558 import java.lang.annotation.Retention; 3559 import java.lang.annotation.Target; 3560 3561 @Target(TYPE) 3562 @Retention(RUNTIME) 3563 public @interface Service { 3564 3565 Class[] value(); 3566 String[] names() default {}; 3567 }
3568Figure 10-41: Service Annotation 3569 3570The @Service annotation is used on a component implementation class to specify the SCA services 3571offered by the implementation. An implementation class need not be declared as implementing all of the 3572interfaces implied by the services declared in its @Service annotation, but all methods of all the declared 3573service interfaces MUST be present. [JCA90042] A class used as the implementation of a service is not 3574required to have a @Service annotation. If a class has no @Service annotation, then the rules 3575determining which services are offered and what interfaces those services have are determined by the 3576specific implementation type. 3577The @Service annotation has the attributes: 3578 value (1..1) – An array of interface or class objects that are exposed as services by this 3579 implementation. If the array is empty, no services are exposed. 3580 names (0..1) - An array of Strings which are used as the service names for each of the interfaces 3581 declared in the value array. The number of Strings in the names attribute array of the @Service 3582 annotation MUST match the number of elements in the value attribute array. [JCA90050] The value of 3583 each element in the @Service names array MUST be unique amongst all the other element values in 3584 the array. [JCA90060]
163sca-javacaa-1.1-spec-csd06 15 August 2011 164Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 82 of 121 3585The service name of an exposed service defaults to the name of its interface or class, without the 3586package name. If the names attribute is specified, the service name for each interface or class in the 3587value attribute array is the String declared in the corresponding position in the names attribute array. 3588If a component implementation has two services with the same Java simple name, the names attribute of 3589the @Service annotation MUST be specified. [JCA90045] If a Java implementation needs to realize two 3590services with the same Java simple name then this can be achieved through subclassing of the interface. 3591Snippet 10-66 shows an implementation of the HelloService marked with the @Service annotation. 3592 3593 package services.hello; 3594 3595 import org.oasisopen.sca.annotation.Service; 3596 3597 @Service(HelloService.class) 3598 public class HelloServiceImpl implements HelloService { 3599 3600 public void hello(String name) { 3601 System.out.println("Hello " + name); 3602 } 3603 } 3604Snippet 10-66: Use of @Service
165sca-javacaa-1.1-spec-csd06 15 August 2011 166Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 83 of 121 360511 WSDL to Java and Java to WSDL 3606This specification applies the WSDL to Java and Java to WSDL mapping rules as defined by the JAX-WS 36072.1 specification [JAX-WS] for generating remotable Java interfaces from WSDL portTypes and vice 3608versa. 3609SCA runtimes MUST support the JAX-WS 2.1 mappings from WSDL to Java and from Java to WSDL. 3610[JCA100022] For the purposes of the Java-to-WSDL mapping algorithm, the SCA runtime MUST treat a 3611Java interface as if it had a @WebService annotation on the class, even if it doesn't. [JCA100001] The 3612SCA runtime MUST treat an @org.oasisopen.sca.annotation.OneWay annotation as a synonym for the [email protected] annotation. [JCA100002] For the WSDL-to-Java mapping, the SCA runtime MUST 3614take the generated @WebService annotation to imply that the Java interface is @Remotable. 3615[JCA100003] 3616For the mapping from Java types to XML schema types, SCA permits both the JAXB 2.1 [JAX-B] mapping 3617and the SDO 2.1 [SDO] mapping. SCA runtimes MUST support the JAXB 2.1 mapping from XML Schema 3618to Java and from Java to XML Schema. [JCA100004] SCA runtimes MAY support the SDO 2.1 mapping 3619from XML schema types to Java and from Java to XML Schema. [JCA100005] Having a choice of binding 3620technologies is allowed, as noted in the first paragraph of section 5 of the JSR 181 (version 2) 3621specification, which is referenced by the JAX-WS specification.
3622 11.1 JAX-WS Annotations and SCA Interfaces 3623A Java class or interface used to define an SCA interface can contain JAX-WS annotations. In addition to 3624affecting the Java to WSDL mapping defined by the JAX-WS specification [JAX-WS] these annotations 3625can impact the SCA interface. An SCA runtime MUST apply the JAX-WS annotations as described in 3626Table 11-3 and Table 11-4 when introspecting a Java class or interface class. [JCA100011] This could 3627mean that the interface of a Java implementation is defined by a WSDL interface declaration. If the 3628services provided by an implementation class are explicitly identified by an @Service annotation, only the 3629identified classes define services of the implementation even if implemented interfaces that are not listed 3630in the @Service annotation contain @JAX-WS annotations. Annotation Property Impact to SCA Interface @WebService A Java interface or class annotated with @WebService
MUST be treated as if annotated with the SCA
@Remotable annotation [JCA100012] name The value of the name attribute of the @WebService
annotation, if present, MUST be used to define the
name of an SCA service when there is no @Service
annotation present in the SCA component
implementation. [JCA100023]
The value of the name attribute of the @WebService
annotation, if present, MUST be used to define the
name of an SCA service when the @Service annotation
167sca-javacaa-1.1-spec-csd06 15 August 2011 168Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 84 of 121 is present without the names attribute and indicates that
the Java interface or class annotated with the
@WebService annotation defines an SCA service
interface. [JCA100028] targetNamespace None serviceName None wsdlLocation A Java class annotated with the @WebService
annotation with its wsdlLocation attribute set MUST
have its interface defined by the referenced WSDL
definition instead of the annotated Java class.
[JCA100013] endpointInterface A Java class annotated with the @WebService
annotation with its endpointInterface attribute set MUST
have its interface defined by the referenced interface
instead of annotated Java class. [JCA100014] portName None @WebMethod operationName For a Java method annotated with the @WebMethod
annotation with the operationName set, an SCA
runtime MUST use the value of the operationName
attribute as the SCA operation name. [JCA100024] action None exclude An SCA runtime MUST NOT include a Java method
annotated with the @WebMethod annotation with
the exclude attribute set to true in an SCA interface.
[JCA100025] @OneWay The SCA runtime MUST treat an
@org.oasisopen.sca.annotation.OneWay annotation
as a synonym for the @javax.jws.OneWay
annotation.
169sca-javacaa-1.1-spec-csd06 15 August 2011 170Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 85 of 121 [JCA100002] @WebParam name Sets parameter name targetNamespace None mode For a Java parameter annotated with the
@WebParam annotation with the mode attribute set,
an SCA runtime MUST apply the value of the mode
attribute when comparing interfaces. [JCA100026] header A Java class or interface containing an @WebParam
annotation with its header attribute set to “true” MUST
be treated as if the SOAP intent is applied to the Java
class or interface. [JCA100015] partName Overrides name @WebResult name Sets parameter name targetNamespace None header A Java class or interface containing an @WebResult
annotation with its header attribute set to “true” MUST
be treated as if the SOAP intent is applied to the Java
class or interface. [JCA100016] partName Overrides name @SOAPBinding A Java class or interface containing an @SOAPBinding
annotation MUST be treated as if the SOAP intent is
applied to the Java class or interface. [JCA100021] style use parameterStyle @HandlerChain None file name
3631Table 11-3: JSR 181 Annotations and SCA Interfaces 3632 171sca-javacaa-1.1-spec-csd06 15 August 2011 172Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 86 of 121 Annotation Property Impact to SCA Interface @ServiceMode A Java class containing an @ServiceMode annotation
MUST be treated as if the SOAP intent is applied to the
Java class. [JCA100017] value @WebFault name None targetNamespace None faultBean None @RequestWrapper None localName targetNamespace className @ResponseWrapper None localName targetNamespace className @WebServiceClient An interface or class annotated with
@WebServiceClient MUST NOT be used to define an
SCA interface. [JCA100018] name targetNamespace wsdlLocation @WebEndpoint None name @WebServiceProvider A class annotated with @WebServiceProvider MUST be
treated as if annotated with the SCA @Remotable
annotation. [JCA100019] wsdlLocation A Java class annotated with the @WebServiceProvider
annotation with its wsdlLocation attribute set MUST
have its interface defined by the referenced WSDL
definition is used instead of the annotated Java class.
173sca-javacaa-1.1-spec-csd06 15 August 2011 174Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 87 of 121 Annotation Property Impact to SCA Interface [JCA100020] serviceName None portName None targetNamespace None @BindingType None value @WebServiceRef See JEE specification name wsdlLocation type value mappedName @WebServiceRefs See JEE specification value @Action None fault input output @FaultAction None value output
3633Table 11-4: JSR 224 Annotations and SCA Interfaces
3634 11.2 JAX-WS Client Asynchronous API for a Synchronous Service 3635The JAX-WS specification defines a mapping of a synchronous service invocation, which provides a client 3636application with a means of invoking that service asynchronously, so that the client can invoke a service 3637operation and proceed to do other work without waiting for the service operation to complete its 3638processing. The client application can retrieve the results of the service either through a polling 3639mechanism or via a callback method which is invoked when the operation completes. 3640For SCA service interfaces defined using interface.java, the Java interface MUST NOT contain the 3641additional client-side asynchronous polling and callback methods defined by JAX-WS. [JCA100006] For 3642SCA reference interfaces defined using interface.java, the SCA runtime MUST support a Java interface 3643which contains the additional client-side asynchronous polling and callback methods defined by JAX-WS. 3644[JCA100007] If the additional client-side asynchronous polling and callback methods defined by JAX-WS 3645are present in the interface which declares the type of a reference in the implementation, SCA Runtimes 3646MUST NOT include these methods in the SCA reference interface in the component type of the 3647implementation. [JCA100008] 3648The additional client-side asynchronous polling and callback methods defined by JAX-WS are recognized 3649in a Java interface according to the steps:
175sca-javacaa-1.1-spec-csd06 15 August 2011 176Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 88 of 121 3650For each method M in the interface, if another method P in the interface has 3651 a. a method name that is M's method name with the characters "Async" appended, and 3652 b. the same parameter signature as M, and 3653 c. a return type of Response
177sca-javacaa-1.1-spec-csd06 15 August 2011 178Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 89 of 121 3700SCA runtimes MUST support the use of the JAX-WS client asynchronous model. [JCA100009] If the 3701client implementation uses the asynchronous form of the interface, the two additional getPriceAsync() 3702methods can be used for polling and callbacks as defined by the JAX-WS specification.
3703 11.3 Treatment of SCA Asynchronous Service API 3704For SCA service interfaces defined using interface.java, the SCA runtime MUST support a Java interface 3705which contains the server-side asynchronous methods defined by SCA. [JCA100010] 3706Asynchronous service methods are identified as described in the section "Asynchronous handling of Long 3707Running Service Operations" and are mapped to WSDL in the same way as the equivalent synchronous 3708method described in that section. 3709Generating an asynchronous service method from a WSDL request/response operation follows the 3710algorithm described in the same section.
179sca-javacaa-1.1-spec-csd06 15 August 2011 180Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 90 of 121 371112 Conformance 3712The XML schema pointed to by the RDDL document at the namespace URI, defined by this specification, 3713are considered to be authoritative and take precedence over the XML schema defined in the appendix of 3714this document. 3715Normative code artifacts related to this specification are considered to be authoritative and take 3716precedence over specification text. 3717There are three categories of artifacts for which this specification defines conformance: 3718 a) SCA Java XML Document, 3719 b) SCA Java Class 3720 c) SCA Runtime.
3721 12.1 SCA Java XML Document 3722An SCA Java XML document is an SCA Composite Document, or an SCA ComponentType Document, 3723as defined by the SCA Assembly Model specification [ASSEMBLY], that uses the
3727 12.2 SCA Java Class 3728An SCA Java Class is a Java class or interface that complies with Java Standard Edition version 5.0 and 3729MAY include annotations and APIs defined in this specification. An SCA Java Class that uses annotations 3730and APIs defined in this specification MUST comply with the requirements specified in this specification 3731for those annotations and APIs.
3732 12.3 SCA Runtime 3733The APIs and annotations defined in this specification are meant to be used by Java-based component 3734implementation models in either partial or complete fashion. A Java-based component implementation 3735specification that uses this specification specifies which of the APIs and annotations defined here are 3736used. The APIs and annotations an SCA Runtime has to support depends on which Java-based 3737component implementation specification the runtime supports. For example, see the SCA POJO 3738Component Implementation Specification [JAVA_CI]. 3739An implementation that claims to conform to this specification MUST meet the following conditions: 37404. The implementation MUST meet all the conformance requirements defined by the SCA Assembly 3741 Model Specification [ASSEMBLY]. 37425. The implementation MUST support
181sca-javacaa-1.1-spec-csd06 15 August 2011 182Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 91 of 121 3747Appendix A. XML Schema: sca-interface-java-1.1.xsd
3748 3749 3751
183sca-javacaa-1.1-spec-csd06 15 August 2011 184Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 92 of 121 3776Appendix B. Java Classes and Interfaces
3777B.1 SCAClient Classes and Interfaces
3778B.1.1 SCAClientFactory Class 3779SCA provides an abstract base class SCAClientFactory. Vendors can provide subclasses of this class 3780which create objects that implement the SCAClientFactory class suitable for linking to services in their 3781SCA runtime. 3782 3783 /* 3784 * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. 3785 * OASIS trademark, IPR and other policies apply. 3786 */ 3787 package org.oasisopen.sca.client; 3788 3789 import java.net.URI; 3790 import java.util.Properties; 3791 3792 import org.oasisopen.sca.NoSuchDomainException; 3793 import org.oasisopen.sca.NoSuchServiceException; 3794 import org.oasisopen.sca.client.SCAClientFactoryFinder; 3795 import org.oasisopen.sca.client.impl.SCAClientFactoryFinderImpl; 3796 3797 /** 3798 * The SCAClientFactory can be used by non-SCA managed code to 3799 * lookup services that exist in a SCADomain. 3800 * 3801 * @see SCAClientFactoryFinderImpl 3802 * 3803 * @author OASIS Open 3804 */ 3805 3806 public abstract class SCAClientFactory { 3807 3808 /** 3809 * The SCAClientFactoryFinder. 3810 * Provides a means by which a provider of an SCAClientFactory 3811 * implementation can inject a factory finder implementation into 3812 * the abstract SCAClientFactory class - once this is done, future 3813 * invocations of the SCAClientFactory use the injected factory 3814 * finder to locate and return an instance of a subclass of 3815 * SCAClientFactory. 3816 */ 3817 protected static SCAClientFactoryFinder factoryFinder; 3818 /** 3819 * The Domain URI of the SCA Domain which is accessed by this 3820 * SCAClientFactory 3821 */ 3822 private URI domainURI; 3823 3824 /** 3825 * Prevent concrete subclasses from using the no-arg constructor 3826 */ 3827 private SCAClientFactory() { 3828 } 3829 3830 /** 3831 * Constructor used by concrete subclasses
185sca-javacaa-1.1-spec-csd06 15 August 2011 186Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 93 of 121 3832 * @param domainURI - The Domain URI of the Domain accessed via this 3833 * SCAClientFactory 3834 */ 3835 protected SCAClientFactory(URI domainURI) throws NoSuchDomainException { 3836 this.domainURI = domainURI; 3837 } 3838 3839 /** 3840 * Gets the Domain URI of the Domain accessed via this SCAClientFactory 3841 * @return - the URI for the Domain 3842 */ 3843 protected URI getDomainURI() { 3844 return domainURI; 3845 } 3846 3847 3848 /** 3849 * Creates a new instance of the SCAClientFactory that can be 3850 * used to lookup SCA Services. 3851 * 3852 * @param domainURI URI of the target domain for the SCAClientFactory 3853 * @return A new SCAClientFactory 3854 */ 3855 public static SCAClientFactory newInstance( URI domainURI ) 3856 throws NoSuchDomainException { 3857 return newInstance(null, null, domainURI); 3858 } 3859 3860 /** 3861 * Creates a new instance of the SCAClientFactory that can be 3862 * used to lookup SCA Services. 3863 * 3864 * @param properties Properties that may be used when 3865 * creating a new instance of the SCAClientFactory 3866 * @param domainURI URI of the target domain for the SCAClientFactory 3867 * @return A new SCAClientFactory instance 3868 */ 3869 public static SCAClientFactory newInstance(Properties properties, 3870 URI domainURI) 3871 throws NoSuchDomainException { 3872 return newInstance(properties, null, domainURI); 3873 } 3874 3875 /** 3876 * Creates a new instance of the SCAClientFactory that can be 3877 * used to lookup SCA Services. 3878 * 3879 * @param classLoader ClassLoader that may be used when 3880 * creating a new instance of the SCAClientFactory 3881 * @param domainURI URI of the target domain for the SCAClientFactory 3882 * @return A new SCAClientFactory instance 3883 */ 3884 public static SCAClientFactory newInstance(ClassLoader classLoader, 3885 URI domainURI) 3886 throws NoSuchDomainException { 3887 return newInstance(null, classLoader, domainURI); 3888 } 3889 3890 /** 3891 * Creates a new instance of the SCAClientFactory that can be 3892 * used to lookup SCA Services. 3893 * 3894 * @param properties Properties that may be used when 3895 * creating a new instance of the SCAClientFactory
187sca-javacaa-1.1-spec-csd06 15 August 2011 188Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 94 of 121 3896 * @param classLoader ClassLoader that may be used when 3897 * creating a new instance of the SCAClientFactory 3898 * @param domainURI URI of the target domain for the SCAClientFactory 3899 * @return A new SCAClientFactory instance 3900 */ 3901 public static SCAClientFactory newInstance(Properties properties, 3902 ClassLoader classLoader, 3903 URI domainURI) 3904 throws NoSuchDomainException { 3905 final SCAClientFactoryFinder finder = 3906 factoryFinder != null ? factoryFinder : 3907 new SCAClientFactoryFinderImpl(); 3908 final SCAClientFactory factory 3909 = finder.find(properties, classLoader, domainURI); 3910 return factory; 3911 } 3912 3913 /** 3914 * Returns a reference proxy that implements the business interface
3934B.1.2 SCAClientFactoryFinder interface 3935The SCAClientFactoryFinder interface is a Service Provider Interface representing a SCAClientFactory 3936finder. SCA provides a default reference implementation of this interface. SCA runtime vendors can 3937create alternative implementations of this interface that use different class loading or lookup mechanisms. 3938 3939 /* 3940 * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. 3941 * OASIS trademark, IPR and other policies apply. 3942 */ 3943 3944 package org.oasisopen.sca.client; 3945 3946 import java.net.URI; 3947 import java.util.Properties; 3948 3949 import org.oasisopen.sca.NoSuchDomainException; 3950 3951 /* A Service Provider Interface representing a SCAClientFactory finder. 3952 * SCA provides a default reference implementation of this interface. 3953 * SCA runtime vendors can create alternative implementations of this 3954 * interface that use different class loading or lookup mechanisms. 3955 */ 3956 public interface SCAClientFactoryFinder {
189sca-javacaa-1.1-spec-csd06 15 August 2011 190Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 95 of 121 3957 3958 /** 3959 * Method for finding the SCAClientFactory for a given Domain URI using 3960 * a specified set of properties and a a specified ClassLoader 3961 * @param properties - properties to use - may be null 3962 * @param classLoader - ClassLoader to use - may be null 3963 * @param domainURI - the Domain URI - must be a valid SCA Domain URI 3964 * @return - the SCAClientFactory or null if the factory could not be 3965 * @throws - NoSuchDomainException if the domainURI does not reference 3966 * a valid SCA Domain 3967 * found 3968 */ 3969 SCAClientFactory find(Properties properties, 3970 ClassLoader classLoader, 3971 URI domainURI ) 3972 throws NoSuchDomainException ; 3973 }
3974B.1.3 SCAClientFactoryFinderImpl class 3975This class provides a default implementation for finding a provider's SCAClientFactory implementation 3976class. It is used if the provider does not inject its SCAClientFactoryFinder implementation class into the 3977base SCAClientFactory class. 3978It discovers a provider's SCAClientFactory implementation by referring to the following information in this 3979order: 3980 1. The org.oasisopen.sca.client.SCAClientFactory property from the Properties specified on the 3981 newInstance() method call if specified 3982 2. The org.oasisopen.sca.client.SCAClientFactory property from the System Properties 3983 3. The META-INF/services/org.oasisopen.sca.client.SCAClientFactory file 3984 3985 /* 3986 * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. 3987 * OASIS trademark, IPR and other policies apply. 3988 */ 3989 package org.oasisopen.sca.client.impl; 3990 3991 import org.oasisopen.sca.client.SCAClientFactoryFinder; 3992 3993 import java.io.BufferedReader; 3994 import java.io.Closeable; 3995 import java.io.IOException; 3996 import java.io.InputStream; 3997 import java.io.InputStreamReader; 3998 import java.lang.reflect.Constructor; 3999 import java.net.URI; 4000 import java.net.URL; 4001 import java.util.Properties; 4002 4003 import org.oasisopen.sca.NoSuchDomainException; 4004 import org.oasisopen.sca.ServiceRuntimeException; 4005 import org.oasisopen.sca.client.SCAClientFactory; 4006 4007 /** 4008 * This is a default implementation of an SCAClientFactoryFinder which is 4009 * used to find an implementation of the SCAClientFactory interface. 4010 * 4011 * @see SCAClientFactoryFinder 4012 * @see SCAClientFactory 4013 * 4014 * @author OASIS Open 4015 */ 191sca-javacaa-1.1-spec-csd06 15 August 2011 192Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 96 of 121 4016 public class SCAClientFactoryFinderImpl implements SCAClientFactoryFinder { 4017 4018 /** 4019 * The name of the System Property used to determine the SPI 4020 * implementation to use for the SCAClientFactory. 4021 */ 4022 private static final String SCA_CLIENT_FACTORY_PROVIDER_KEY = 4023 SCAClientFactory.class.getName(); 4024 4025 /** 4026 * The name of the file loaded from the ClassPath to determine 4027 * the SPI implementation to use for the SCAClientFactory. 4028 */ 4029 private static final String SCA_CLIENT_FACTORY_PROVIDER_META_INF_SERVICE 4030 = "META-INF/services/" + SCA_CLIENT_FACTORY_PROVIDER_KEY; 4031 4032 /** 4033 * Public Constructor 4034 */ 4035 public SCAClientFactoryFinderImpl() { 4036 } 4037 4038 /** 4039 * Creates an instance of the SCAClientFactorySPI implementation. 4040 * This discovers the SCAClientFactorySPI Implementation and instantiates 4041 * the provider's implementation. 4042 * 4043 * @param properties Properties that may be used when creating a new 4044 * instance of the SCAClient 4045 * @param classLoader ClassLoader that may be used when creating a new 4046 * instance of the SCAClient 4047 * @return new instance of the SCAClientFactory 4048 * @throws ServiceRuntimeException Failed to create SCAClientFactory 4049 * Implementation. 4050 */ 4051 public SCAClientFactory find(Properties properties, 4052 ClassLoader classLoader, 4053 URI domainURI ) 4054 throws NoSuchDomainException, ServiceRuntimeException { 4055 if (classLoader == null) { 4056 classLoader = getThreadContextClassLoader (); 4057 } 4058 final String factoryImplClassName = 4059 discoverProviderFactoryImplClass(properties, classLoader); 4060 final Class factoryImplClass 4061 = loadProviderFactoryClass(factoryImplClassName, 4062 classLoader); 4063 final SCAClientFactory factory = 4064 instantiateSCAClientFactoryClass(factoryImplClass, 4065 domainURI, properties ); 4066 return factory; 4067 } 4068 4069 /** 4070 * Gets the Context ClassLoader for the current Thread. 4071 * 4072 * @return The Context ClassLoader for the current Thread. 4073 */ 4074 private static ClassLoader getThreadContextClassLoader () { 4075 return AccessController.doPrivileged( 4076 new PrivilegedAction
193sca-javacaa-1.1-spec-csd06 15 August 2011 194Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 97 of 121 4080 }); 4081 } 4082 4083 /** 4084 * Attempts to discover the class name for the SCAClientFactorySPI 4085 * implementation from the specified Properties, the System Properties 4086 * or the specified ClassLoader. 4087 * 4088 * @return The class name of the SCAClientFactorySPI implementation 4089 * @throw ServiceRuntimeException Failed to find implementation for 4090 * SCAClientFactorySPI. 4091 */ 4092 private static String 4093 discoverProviderFactoryImplClass(Properties properties, 4094 ClassLoader classLoader) 4095 throws ServiceRuntimeException { 4096 String providerClassName = 4097 checkPropertiesForSPIClassName(properties); 4098 if (providerClassName != null) { 4099 return providerClassName; 4100 } 4101 4102 providerClassName = 4103 checkPropertiesForSPIClassName(System.getProperties()); 4104 if (providerClassName != null) { 4105 return providerClassName; 4106 } 4107 4108 providerClassName = checkMETAINFServicesForSPIClassName(classLoader); 4109 if (providerClassName == null) { 4110 throw new ServiceRuntimeException( 4111 "Failed to find implementation for SCAClientFactory"); 4112 } 4113 4114 return providerClassName; 4115 } 4116 4117 /** 4118 * Attempts to find the class name for the SCAClientFactorySPI 4119 * implementation from the specified Properties. 4120 * 4121 * @return The class name for the SCAClientFactorySPI implementation 4122 * or null if not found. 4123 */ 4124 private static String 4125 checkPropertiesForSPIClassName(Properties properties) { 4126 if (properties == null) { 4127 return null; 4128 } 4129 4130 final String providerClassName = 4131 properties.getProperty(SCA_CLIENT_FACTORY_PROVIDER_KEY); 4132 if (providerClassName != null && providerClassName.length() > 0) { 4133 return providerClassName; 4134 } 4135 4136 return null; 4137 } 4138 4139 /** 4140 * Attempts to find the class name for the SCAClientFactorySPI 4141 * implementation from the META-INF/services directory 4142 * 4143 * @return The class name for the SCAClientFactorySPI implementation or
195sca-javacaa-1.1-spec-csd06 15 August 2011 196Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 98 of 121 4144 * null if not found. 4145 */ 4146 private static String checkMETAINFServicesForSPIClassName(ClassLoader cl) 4147 { 4148 final URL url = 4149 cl.getResource(SCA_CLIENT_FACTORY_PROVIDER_META_INF_SERVICE); 4150 if (url == null) { 4151 return null; 4152 } 4153 4154 InputStream in = null; 4155 try { 4156 in = url.openStream(); 4157 BufferedReader reader = null; 4158 try { 4159 reader = 4160 new BufferedReader(new InputStreamReader(in, "UTF-8")); 4161 4162 String line; 4163 while ((line = readNextLine(reader)) != null) { 4164 if (!line.startsWith("#") && line.length() > 0) { 4165 return line; 4166 } 4167 } 4168 4169 return null; 4170 } finally { 4171 closeStream(reader); 4172 } 4173 } catch (IOException ex) { 4174 throw new ServiceRuntimeException( 4175 "Failed to discover SCAClientFactory provider", ex); 4176 } finally { 4177 closeStream(in); 4178 } 4179 } 4180 4181 /** 4182 * Reads the next line from the reader and returns the trimmed version 4183 * of that line 4184 * 4185 * @param reader The reader from which to read the next line 4186 * @return The trimmed next line or null if the end of the 4187 * stream has been reached 4188 * @throws IOException I/O error occurred while reading from Reader 4189 */ 4190 private static String readNextLine(BufferedReader reader) 4191 throws IOException { 4192 4193 String line = reader.readLine(); 4194 if (line != null) { 4195 line = line.trim(); 4196 } 4197 return line; 4198 } 4199 4200 /** 4201 * Loads the specified SCAClientFactory Implementation class. 4202 * 4203 * @param factoryImplClassName The name of the SCAClientFactory 4204 * Implementation class to load 4205 * @return The specified SCAClientFactory Implementation class 4206 * @throws ServiceRuntimeException Failed to load the SCAClientFactory 4207 * Implementation class
197sca-javacaa-1.1-spec-csd06 15 August 2011 198Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 99 of 121 4208 */ 4209 private static Class 4210 loadProviderFactoryClass(String factoryImplClassName, 4211 ClassLoader classLoader) 4212 throws ServiceRuntimeException { 4213 4214 try { 4215 final Class providerClass = 4216 classLoader.loadClass(factoryImplClassName); 4217 final Class providerFactoryClass = 4218 providerClass.asSubclass(SCAClientFactory.class); 4219 return providerFactoryClass; 4220 } catch (ClassNotFoundException ex) { 4221 throw new ServiceRuntimeException( 4222 "Failed to load SCAClientFactory implementation class " 4223 + factoryImplClassName, ex); 4224 } catch (ClassCastException ex) { 4225 throw new ServiceRuntimeException( 4226 "Loaded SCAClientFactory implementation class " 4227 + factoryImplClassName 4228 + " is not a subclass of " 4229 + SCAClientFactory.class.getName() , ex); 4230 } 4231 } 4232 4233 /** 4234 * Instantiate an instance of the specified SCAClientFactorySPI 4235 * Implementation class. 4236 * 4237 * @param factoryImplClass The SCAClientFactorySPI Implementation 4238 * class to instantiate. 4239 * @return An instance of the SCAClientFactorySPI Implementation class 4240 * @throws ServiceRuntimeException Failed to instantiate the specified 4241 * specified SCAClientFactorySPI Implementation class 4242 */ 4243 private static SCAClientFactory instantiateSCAClientFactoryClass( 4244 Class factoryImplClass, 4245 URI domainURI, Properties properties) 4246 throws NoSuchDomainException, ServiceRuntimeException { 4247 4248 try { 4249 Constructor URIConstructor = 4250 factoryImplClass.getConstructor(URI.class, Properties.class); 4251 SCAClientFactory provider = 4252 URIConstructor.newInstance( domainURI, properties ); 4253 return provider; 4254 } catch (Throwable ex) { 4255 throw new ServiceRuntimeException( 4256 "Failed to instantiate SCAClientFactory implementation class " 4257 + factoryImplClass, ex); 4258 } 4259 } 4260 4261 /** 4262 * Utility method for closing Closeable Object. 4263 * 4264 * @param closeable The Object to close. 4265 */ 4266 private static void closeStream(Closeable closeable) { 4267 if (closeable != null) { 4268 try{ 4269 closeable.close(); 4270 } catch (IOException ex) { 4271 throw new ServiceRuntimeException("Failed to close stream",
199sca-javacaa-1.1-spec-csd06 15 August 2011 200Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 100 of 121 4272 ex); 4273 } 4274 } 4275 } 4276 }
4277B.1.4 SCAClient Classes and Interfaces - what does a vendor need to do? 4278The SCAClient classes and interfaces are designed so that vendors can provide their own implementation 4279suited to the needs of their SCA runtime. This section describes the tasks that a vendor needs to 4280consider in relation to the SCAClient classes and interfaces. 4281 Implement their SCAClientFactory implementation class 4282 Vendors need to provide a subclass of SCAClientFactory that is capable of looking up Services in 4283 their SCA Runtime. Vendors need to subclass SCAClientFactory and implement the getService() 4284 method so that it creates reference proxies to services in SCA Domains handled by their SCA 4285 runtime(s). 4286 Configure the Vendor SCAClientFactory implementation class so that it gets used 4287 Vendors have several options: 4288 Option 1: Set System Property to point to the Vendor’s implementation 4289 Vendors set the org.oasisopen.sca.client.SCAClientFactory System Property to point to their 4290 implementation class and use the reference implementation of SCAClientFactoryFinder 4291 Option 2: Provide a META-INF/services file 4292 Vendors provide a META-INF/services/org.oasisopen.sca.client.SCAClientFactory file that points 4293 to their implementation class and use the reference implementation of SCAClientFactoryFinder 4294 Option 3: Inject a vendor implementation of the SCAClientFactoryFinder interface into 4295 SCAClientFactory 4296 Vendors inject an instance of the vendor implementation of SCAClientFactoryFinder into the 4297 factoryFinder field of the SCAClientFactory abstract class. The reference implementation of 4298 SCAClientFactoryFinder is not used in this scenario. The vendor implementation of 4299 SCAClientFactoryFinder can find the vendor implementation(s) of SCAClientFactory by any 4300 means.
201sca-javacaa-1.1-spec-csd06 15 August 2011 202Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 101 of 121 4301Appendix C. Conformance Items
4302This section contains a list of conformance items for the SCA-J Common Annotations and APIs 4303specification. 4304 Conformance ID Description [JCA20001] Remotable Services MUST NOT make use of method overloading. [JCA20002] the SCA runtime MUST ensure that a stateless scoped implementation instance object is only ever dispatched on one thread at any one time. [JCA20003] within the SCA lifecycle of a stateless scoped implementation instance, the SCA runtime MUST only make a single invocation of one business method. [JCA20004] Where an implementation is used by a "domain level component", and the implementation is marked "Composite" scope, the SCA runtime MUST ensure that all consumers of the component appear to be interacting with a single runtime instance of the implementation. [JCA20005] When the implementation class is marked for eager initialization, the SCA runtime MUST create a composite scoped instance when its containing component is started. [JCA20006] If a method of an implementation class is marked with the @Init annotation, the SCA runtime MUST call that method when the implementation instance is created. [JCA20007] the SCA runtime MAY run multiple threads in a single composite scoped implementation instance object and the SCA runtime MUST NOT perform any synchronization. [JCA20008] Where an implementation is marked "Composite" scope and it is used by a component that is nested inside a composite that is used as the implementation of a higher level component, the SCA runtime MUST ensure that all consumers of the component appear to be interacting with a single runtime instance of the implementation. There can be multiple instances of the higher level component, each running on different nodes in a distributed SCA runtime.
[JCA20010] The SCA runtime MUST use by-value semantics when passing input parameters, return values and exceptions on calls to remotable services within the same JVM if the service method implementation is not marked “allows pass by reference” or the service proxy used by the client is not marked “allows pass by reference”. [JCA30001] The value of the @interface attribute MUST be the fully qualified name of a Java class [JCA30002] The value of the @callbackInterface attribute MUST be the fully qualified name of a Java interface used for callbacks [JCA30003] if the Java interface class identified by the @interface attribute does contain a Java @Callback annotation, then the Java interface class
203sca-javacaa-1.1-spec-csd06 15 August 2011 204Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 102 of 121 identified by the @callbackInterface attribute MUST be the same interface class. [JCA30004] The interface.java element MUST conform to the schema defined in the sca-interface-java.xsd schema. [JCA30005] The value of the @remotable attribute on the
205sca-javacaa-1.1-spec-csd06 15 August 2011 206Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 103 of 121 [JCA40005] When a component implementation instance is in the Injecting state, the SCA Runtime MUST first inject all field and setter properties that are present into the component implementation. [JCA40006] When a component implementation instance is in the Injecting state, the SCA Runtime MUST inject all field and setter references that are present into the component implementation, after all the properties have been injected. [JCA40007] The SCA Runtime MUST ensure that the correct synchronization model is used so that all injected properties and references are made visible to the component implementation without requiring the component implementation developer to do any specific synchronization. [JCA40008] The SCA Runtime MUST NOT invoke Service methods on the component implementation when the component implementation is in the Injecting state. [JCA40009] When the injection of properties and references completes successfully, the SCA Runtime MUST transition the component implementation to the Initializing state. [JCA40010] If an exception is thrown whilst injecting properties or references, the SCA Runtime MUST transition the component implementation to the Destroying state. [JCA40011] When the component implementation enters the Initializing State, the SCA Runtime MUST call the method annotated with @Init on the component implementation, if present. [JCA40012] If a component implementation invokes an operation on an injected reference that refers to a target that has not yet been initialized, the SCA Runtime MUST throw a ServiceUnavailableException. [JCA40013] The SCA Runtime MUST NOT invoke Service methods on the component implementation when the component implementation instance is in the Initializing state. [JCA40014] Once the method annotated with @Init completes successfully, the SCA Runtime MUST transition the component implementation to the Running state. [JCA40015] If an exception is thrown whilst initializing, the SCA Runtime MUST transition the component implementation to the Destroying state. [JCA40016] The SCA Runtime MUST invoke Service methods on a component implementation instance when the component implementation is in the Running state and a client invokes operations on a service offered by the component. [JCA40017] When the component implementation scope ends, the SCA Runtime MUST transition the component implementation to the Destroying state. [JCA40018] When a component implementation enters the Destroying state, the SCA Runtime MUST call the method annotated with @Destroy on the component implementation, if present. [JCA40019] If a component implementation invokes an operation on an injected reference that refers to a target that has been destroyed, the SCA
207sca-javacaa-1.1-spec-csd06 15 August 2011 208Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 104 of 121 Runtime MUST throw an InvalidServiceException. [JCA40020] The SCA Runtime MUST NOT invoke Service methods on the component implementation when the component implementation instance is in the Destroying state. [JCA40021] Once the method annotated with @Destroy completes successfully, the SCA Runtime MUST transition the component implementation to the Terminated state. [JCA40022] If an exception is thrown whilst destroying, the SCA Runtime MUST transition the component implementation to the Terminated state. [JCA40023] The SCA Runtime MUST NOT invoke Service methods on the component implementation when the component implementation instance is in the Terminated state. [JCA40024] If a property or reference is unable to be injected, the SCA Runtime MUST transition the component implementation to the Destroying state. [JCA60001] When a bidirectional service is invoked, the SCA runtime MUST inject a callback reference for the invoking service into all fields and setter methods of the service implementation class that are marked with a @Callback annotation and typed by the callback interface of the bidirectional service, and the SCA runtime MUST inject null into all other fields and setter methods of the service implementation class that are marked with a @Callback annotation. [JCA60002] When a non-bidirectional service is invoked, the SCA runtime MUST inject null into all fields and setter methods of the service implementation class that are marked with a @Callback annotation. [JCA60003] The SCA asynchronous service Java interface mapping of a WSDL request-response operation MUST appear as follows: The interface is annotated with the "asyncInvocation" intent. For each service operation in the WSDL, the Java interface contains an operation with – a name which is the JAX-WS mapping of the WSDL operation name, with the suffix "Async" added – a void return type – a set of input parameter(s) which match the JAX-WS mapping of the input parameter(s) of the WSDL operation plus an additional last parameter which is a ResponseDispatch object typed by the JAX-WS Response Bean mapping of the output parameter(s) of the WSDL operation, where ResponseDispatch is the type defined in the SCA Java Common Annotations and APIs specification. [JCA60004] An SCA Runtime MUST support the use of the SCA asynchronous service interface for the interface of an SCA service. [JCA60005] If the SCA asynchronous service interface ResponseDispatch handleResponse method is invoked more than once through either its sendResponse or its sendFault method, the SCA runtime MUST throw an IllegalStateException. [JCA60006] For the purposes of matching interfaces (when wiring between a
209sca-javacaa-1.1-spec-csd06 15 August 2011 210Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 105 of 121 reference and a service, or when using an implementation class by a component), an interface which has one or more methods which follow the SCA asynchronous service pattern MUST be treated as if those methods are mapped as the equivalent synchronous methods, as follows: Asynchronous service methods are characterized by: – void return type – a method name with the suffix "Async" – a last input parameter with a type of ResponseDispatch
211sca-javacaa-1.1-spec-csd06 15 August 2011 212Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 106 of 121 A service implementation class field that is not either annotated with @Reference or introspected as an SCA reference according to the rules in the appropriate Component Implementation specification A service implementation class constructor parameter that is not annotated with @Reference [JCA70006] If the @PolicySets annotation is specified on both an interface method and the method's declaring interface, the SCA runtime MUST compute the effective policy sets for the method by merging the policy sets from the method with the policy sets from the interface. [JCA80001] The ComponentContext.getService method MUST throw an IllegalArgumentException if the reference identified by the referenceName parameter has multiplicity of 0..n or 1..n. [JCA80002] The ComponentContext.getRequestContext method MUST return non- null when invoked during the execution of a Java business method for a service operation or a callback operation, on the same thread that the SCA runtime provided, and MUST return null in all other cases. [JCA80003] When invoked during the execution of a service operation, the RequestContext.getServiceReference method MUST return a ServiceReference that represents the service that was invoked. [JCA80004] The ComponentContext.getServiceReference method MUST throw an IllegalArgumentException if the reference named by the referenceName parameter has multiplicity greater than one. [JCA80005] The ComponentContext.getServiceReference method MUST throw an IllegalArgumentException if the reference named by the referenceName parameter does not have an interface of the type defined by the businessInterface parameter. [JCA80006] The ComponentContext.getServiceReference method MUST throw an IllegalArgumentException if the component does not have a reference with the name provided in the referenceName parameter. [JCA80007][JCA80007] The ComponentContext.getServiceReference method MUST return null if the multiplicity of the reference named by the referenceName parameter is 0..1 and the reference has no target service configured. [JCA80008] The ComponentContext.getURI method MUST return the structural URI of the component in the SCA Domain. [JCA80009] The ComponentContext.getService method MUST return the proxy object implementing the interface provided by the businessInterface parameter, for the reference named by the referenceName parameter with the interface defined by the businessInterface parameter when that reference has a target service configured. [JCA80010] The ComponentContext.getService method MUST return null if the multiplicity of the reference named by the referenceName parameter is 0..1 and the reference has no target service configured. [JCA80011] The ComponentContext.getService method MUST throw an IllegalArgumentException if the component does not have a reference with the name supplied in the referenceName parameter. [JCA80012] The ComponentContext.getService method MUST throw an
213sca-javacaa-1.1-spec-csd06 15 August 2011 214Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 107 of 121 IllegalArgumentException if the service reference with the name supplied in the referenceName does not have an interface compatible with the interface supplied in the businessInterface parameter. [JCA80013] The ComponentContext.getServiceReference method MUST return a ServiceReference object typed by the interface provided by the businessInterface parameter, for the reference named by the referenceName parameter with the interface defined by the businessInterface parameter when that reference has a target service configured. [JCA80014] The ComponentContext.getServices method MUST return a collection containing one proxy object implementing the interface provided by the businessInterface parameter for each of the target services configured on the reference identified by the referenceName parameter. [JCA80015] The ComponentContext.getServices method MUST return an empty collection if the service reference with the name supplied in the referenceName parameter is not wired to any target services. [JCA80016] The ComponentContext.getServices method MUST throw an IllegalArgumentException if the reference identified by the referenceName parameter has multiplicity of 0..1 or 1..1. [JCA80017] The ComponentContext.getServices method MUST throw an IllegalArgumentException if the component does not have a reference with the name supplied in the referenceName parameter. [JCA80018] The ComponentContext.getServices method MUST throw an IllegalArgumentException if the service reference with the name supplied in the referenceName does not have an interface compatible with the interface supplied in the businessInterface parameter. [JCA80019] The ComponentContext.getServiceReferences method MUST return a collection containing one ServiceReference object typed by the interface provided by the businessInterface parameter for each of the target services configured on the reference identified by the referenceName parameter. [JCA80020] The ComponentContext.getServiceReferences method MUST return an empty collection if the service reference with the name supplied in the referenceName parameter is not wired to any target services. [JCA80021] The ComponentContext.getServiceReferences method MUST throw an IllegalArgumentException if the reference identified by the referenceName parameter has multiplicity of 0..1 or 1..1. [JCA80022] The ComponentContext.getServiceReferences method MUST throw an IllegalArgumentException if the component does not have a reference with the name supplied in the referenceName parameter. [JCA80023] The ComponentContext.getServiceReferences method MUST throw an IllegalArgumentException if the service reference with the name supplied in the referenceName does not have an interface compatible with the interface supplied in the businessInterface parameter. [JCA80024] The ComponentContext.createSelfReference method MUST return a ServiceReference object typed by the interface defined by the businessInterface parameter for one of the services of the invoking component which has the interface defined by the businessInterface
215sca-javacaa-1.1-spec-csd06 15 August 2011 216Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 108 of 121 parameter. [JCA80025] The ComponentContext.getServiceReferences method MUST throw an IllegalArgumentException if the component does not have a service which implements the interface identified by the businessInterface parameter. [JCA80026] The ComponentContext.createSelfReference method MUST return a ServiceReference object typed by the interface defined by the businessInterface parameter for the service identified by the serviceName of the invoking component and which has the interface defined by the businessInterface parameter. [JCA80027] The ComponentContext.createSelfReference method MUST throw an IllegalArgumentException if the component does not have a service with the name identified by the serviceName parameter. [JCA80028] The ComponentContext.createSelfReference method MUST throw an IllegalArgumentException if the component service with the name identified by the serviceName parameter does not implement a business interface which is compatible with the supplied businessInterface parameter. [JCA80029] The ComponentContext.getProperty method MUST return an object of the type identified by the type parameter containing the value specified in the component configuration for the property named by the propertyName parameter or null if no value is specified in the configuration. [JCA80030] The ComponentContext.getProperty method MUST throw an IllegalArgumentException if the component does not have a property with the name identified by the propertyName parameter. [JCA80031] The ComponentContext.getProperty method MUST throw an IllegalArgumentException if the component property with the name identified by the propertyName parameter does not have a type which is compatible with the supplied type parameter. [JCA80032] The ComponentContext.cast method MUST return a ServiceReference object which is typed by the same business interface as specified by the reference proxy object supplied in the target parameter. [JCA80033] The ComponentContext.cast method MUST throw an IllegalArgumentException if the supplied target parameter is not an SCA reference proxy object. [JCA80034] The RequestContext.getSecuritySubject method MUST return the JAAS subject of the current request, or null if there is no subject or null if the method is invoked from code not processing a service request or callback request. [JCA80035] The RequestContext.getServiceName method MUST return the name of the service for which an operation is being processed, or null if invoked from a thread that is not processing a service operation or a callback operation. [JCA80036] The RequestContext.getCallbackReference method MUST return a ServiceReference object typed by the interface of the callback supplied by the client of the invoked service, or null if either the invoked service is not bidirectional or if the method is invoked from a thread that is not
217sca-javacaa-1.1-spec-csd06 15 August 2011 218Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 109 of 121 processing a service operation. [JCA80037] The RequestContext.getCallback method MUST return a reference proxy object typed by the interface of the callback supplied by the client of the invoked service, or null if either the invoked service is not bidirectional or if the method is invoked from a thread that is not processing a service operation. [JCA80038] When invoked during the execution of a callback operation, the RequestContext.getServiceReference method MUST return a ServiceReference that represents the callback that was invoked. [JCA80039] When invoked from a thread not involved in the execution of either a service operation or of a callback operation, the RequestContext.getServiceReference method MUST return null. [JCA80040] The ServiceReference.getService method MUST return a reference proxy object which can be used to invoke operations on the target service of the reference and which is typed with the business interface of the reference. [JCA80041] The ServiceReference.getBusinessInterface method MUST return a Class object representing the business interface of the reference. [JCA80042] The SCAClientFactory.newInstance( URI ) method MUST return an object which implements the SCAClientFactory class for the SCA Domain identified by the domainURI parameter. [JCA80043] The SCAClientFactory.newInstance( URI ) method MUST throw a NoSuchDomainException if the domainURI parameter does not identify a valid SCA Domain. [JCA80044] The SCAClientFactory.newInstance( Properties, URI ) method MUST return an object which implements the SCAClientFactory class for the SCA Domain identified by the domainURI parameter. [JCA80045] The SCAClientFactory.newInstance( Properties, URI ) method MUST throw a NoSuchDomainException if the domainURI parameter does not identify a valid SCA Domain. [JCA80046] The SCAClientFactory.newInstance( Classloader, URI ) method MUST return an object which implements the SCAClientFactory class for the SCA Domain identified by the domainURI parameter. [JCA80047] The SCAClientFactory.newInstance( Classloader, URI ) method MUST throw a NoSuchDomainException if the domainURI parameter does not identify a valid SCA Domain. [JCA80048] The SCAClientFactory.newInstance( Properties, Classloader, URI ) method MUST return an object which implements the SCAClientFactory class for the SCA Domain identified by the domainURI parameter. [JCA80049] The SCAClientFactory.newInstance( Properties, Classloader, URI ) MUST throw a NoSuchDomainException if the domainURI parameter does not identify a valid SCA Domain. [JCA80050] The SCAClientFactory.getService method MUST return a proxy object which implements the business interface defined by the interfaze parameter and which can be used to invoke operations on the service identified by the serviceURI parameter.
219sca-javacaa-1.1-spec-csd06 15 August 2011 220Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 110 of 121 [JCA80051] The SCAClientFactory.getService method MUST throw a NoSuchServiceException if a service with the relative URI serviceURI and a business interface which matches interfaze cannot be found in the SCA Domain targeted by the SCAClient object.
[JCA80053] The SCAClientFactory.getDomainURI method MUST return the SCA Domain URI of the Domain associated with the SCAClientFactory object. [JCA80055] The implementation of the SCAClientFactoryFinder.find method MUST return an object which is an implementation of the SCAClientFactory interface, for the SCA Domain represented by the doaminURI parameter, using the supplied properties and classloader. [JCA80056] The implementation of the SCAClientFactoryFinder.find method MUST throw a ServiceRuntimeException if the SCAClientFactory implementation could not be found. [JCA50057] The ResponseDispatch.sendResponse() method MUST send the response message to the client of an asynchronous service. [JCA80058] The ResponseDispatch.sendResponse() method MUST throw an InvalidStateException if either the sendResponse method or the sendFault method has already been called once. [JCA80059] The ResponseDispatch.sendFault() method MUST send the supplied fault to the client of an asynchronous service. [JCA80060] The ResponseDispatch.sendFault() method MUST throw an InvalidStateException if either the sendResponse method or the sendFault method has already been called once. [JCA90001] An SCA runtime MUST verify the proper use of all SCA annotations and if an annotation is improperly used, the SCA runtime MUST NOT run the component which uses the invalid implementation code. [JCA90001] SCA annotations MUST NOT be used on static methods or on static fields. It is an error to use an SCA annotation on a static method or a static field of an implementation class and the SCA runtime MUST NOT instantiate such an implementation class. [JCA90003] If a constructor of an implementation class is annotated with @Constructor and the constructor has parameters, each of these parameters MUST have either a @Property annotation or a @Reference annotation. [JCA90004] A method annotated with @Destroy can have any access modifier and MUST have a void return type and no arguments. [JCA90005] If there is a method annotated with @Destroy that matches the criteria for the annotation, the SCA runtime MUST call the annotated method when the scope defined for the implementation class ends. [JCA90007] When marked for eager initialization with an @EagerInit annotation, the composite scoped instance MUST be created when its containing component is started. [JCA90008] A method marked with the @Init annotation can have any access modifier and MUST have a void return type and no arguments.
221sca-javacaa-1.1-spec-csd06 15 August 2011 222Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 111 of 121 [JCA90009] If there is a method annotated with @Init that matches the criteria for the annotation, the SCA runtime MUST call the annotated method after all property and reference injection is complete. [JCA90011] The @Property annotation MUST NOT be used on a class field that is declared as final. [JCA90013] For a @Property annotation applied to a constructor parameter, there is no default value for the name attribute and the name attribute MUST be present. [JCA90014] For a @Property annotation applied to a constructor parameter, the required attribute MUST NOT have the value false. [JCA90015] The @Qualifier annotation MUST be used in a specific intent annotation definition where the intent has qualifiers. [JCA90016] The @Reference annotation MUST NOT be used on a class field that is declared as final. [JCA90018] For a @Reference annotation applied to a constructor parameter, there is no default for the name attribute and the name attribute MUST be present. [JCA90019] For a @Reference annotation applied to a constructor parameter, the required attribute MUST have the value true. [JCA90020] If the type of a reference is not an array or any type that extends or implements java.util.Collection, then the SCA runtime MUST introspect the component type of the implementation with a
223sca-javacaa-1.1-spec-csd06 15 August 2011 224Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 112 of 121 [JCA90040] A remotable service can be published externally as a service and MUST be translatable into a WSDL portType. [JCA90041] The @Scope annotation MUST only be used on a service's implementation class. It is an error to use this annotation on an interface. [JCA90042] An implementation class need not be declared as implementing all of the interfaces implied by the services declared in its @Service annotation, but all methods of all the declared service interfaces MUST be present. [JCA90045] If a component implementation has two services with the same Java simple name, the names attribute of the @Service annotation MUST be specified. [JCA90046] When used to annotate a method or a field of an implementation class for injection of a callback object, the@Callback annotation MUST NOT specify any attributes. [JCA90047] For a @Property annotation, if the type of the Java class field or the type of the input parameter of the setter method or constructor is defined as an array or as any type that extends or implements java.util.Collection, then the SCA runtime MUST introspect the component type of the implementation with a
225sca-javacaa-1.1-spec-csd06 15 August 2011 226Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 113 of 121 for injection of a callback object, the type of the method or field MUST be the callback interface of at least one bidirectional service offered by the implementation class. [JCA90055] A method annotated with @OneWay MUST have a void return type and MUST NOT have declared checked exceptions. [JCA90056] When a method of a Java interface is annotated with @OneWay, the SCA runtime MUST ensure that all invocations of that method are executed in a non-blocking fashion, as described in the section on Asynchronous Programming. [JCA90057] The @Callback annotation MUST NOT appear on a setter method or a field of a Java implementation class that has COMPOSITE scope. [JCA90058] When used to annotate a setter method or a field of an implementation class for injection of a callback object, the SCA runtime MUST inject a callback reference proxy into that method or field when the Java class is initialized, if the component is invoked via a service which has a callback interface and where the type of the setter method or field corresponds to the type of the callback interface. [JCA90060] The value of each element in the @Service names array MUST be unique amongst all the other element values in the array. [JCA90061] When the Java type of a field, setter method or constructor parameter with the @Property annotation is a primitive type or a JAXB annotated class, the SCA runtime MUST convert a property value specified by an SCA component definition into an instance of the Java type as defined by the XML to Java mapping in the JAXB specification [JAXB] with XML schema validation enabled. [JCA100001] For the purposes of the Java-to-WSDL mapping algorithm, the SCA runtime MUST treat a Java interface as if it had a @WebService annotation on the class, even if it doesn't. [JCA100002] The SCA runtime MUST treat an @org.oasisopen.sca.annotation.OneWay annotation as a synonym for the @javax.jws.OneWay annotation. [JCA100003] For the WSDL-to-Java mapping, the SCA runtime MUST take the generated @WebService annotation to imply that the Java interface is @Remotable. [JCA100004] SCA runtimes MUST support the JAXB 2.1 mapping from XML Schema to Java and from Java to XML Schema. [JCA100005] SCA runtimes MAY support the SDO 2.1 mapping from XML schema types to Java and from Java to XML Schema. [JCA100006] For SCA service interfaces defined using interface.java, the Java interface MUST NOT contain the additional client-side asynchronous polling and callback methods defined by JAX-WS. [JCA100007] For SCA reference interfaces defined using interface.java, the SCA runtime MUST support a Java interface which contains the additional client-side asynchronous polling and callback methods defined by JAX- WS. [JCA100008] If the additional client-side asynchronous polling and callback methods defined by JAX-WS are present in the interface which declares the type
227sca-javacaa-1.1-spec-csd06 15 August 2011 228Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 114 of 121 of a reference in the implementation, SCA Runtimes MUST NOT include these methods in the SCA reference interface in the component type of the implementation. [JCA100009] SCA runtimes MUST support the use of the JAX-WS client asynchronous model. [JCA100010] For SCA service interfaces defined using interface.java, the SCA runtime MUST support a Java interface which contains the server-side asynchronous methods defined by SCA. [JCA100011] An SCA runtime MUST apply the JAX-WS annotations as described in Table 11-3 and Table 11-4 when introspecting a Java class or interface class. [JCA100012] A Java interface or class annotated with @WebService MUST be treated as if annotated with the SCA @Remotable annotation [JCA100013] A Java class annotated with the @WebService annotation with its wsdlLocation attribute set MUST have its interface defined by the referenced WSDL definition instead of the annotated Java class. [JCA100014] A Java class annotated with the @WebService annotation with its endpointInterface attribute set MUST have its interface defined by the referenced interface instead of annotated Java class. [JCA100015] A Java class or interface containing an @WebParam annotation with its header attribute set to “true” MUST be treated as if the SOAP intent is applied to the Java class or interface. [JCA100016] A Java class or interface containing an @WebResult annotation with its header attribute set to “true” MUST be treated as if the SOAP intent is applied to the Java class or interface. [JCA100017] A Java class containing an @ServiceMode annotation MUST be treated as if the SOAP intent is applied to the Java class. [JCA100018] An interface or class annotated with @WebServiceClient MUST NOT be used to define an SCA interface. [JCA100019] A class annotated with @WebServiceProvider MUST be treated as if annotated with the SCA @Remotable annotation. [JCA100020] A Java class annotated with the @WebServiceProvider annotation with its wsdlLocation attribute set MUST have its interface defined by the referenced WSDL definition is used instead of the annotated Java class. [JCA100021] A Java class or interface containing an @SOAPBinding annotation MUST be treated as if the SOAP intent is applied to the Java class or interface. [JCA100022] SCA runtimes MUST support the JAX-WS 2.1 mappings from WSDL to Java and from Java to WSDL. [JCA100023] The value of the name attribute of the @WebService annotation, if present, MUST be used to define the name of an SCA service when there is no @Service annotation present in the SCA component implementation. [JCA100024] For a Java method annotated with the @WebMethod annotation with the operationName set, an SCA runtime MUST use the value of the 229sca-javacaa-1.1-spec-csd06 15 August 2011 230Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 115 of 121 operationName attribute as the SCA operation name. [JCA100025] An SCA runtime MUST NOT include a Java method annotated with the @WebMethod annotation with the exclude attribute set to true in an SCA interface. [JCA100026] For a Java parameter annotated with the @WebParam annotation with the mode attribute set, an SCA runtime MUST apply the value of the mode attribute when comparing interfaces. [JCA100028] The value of the name attribute of the @WebService annotation, if present, MUST be used to define the name of an SCA service when the @Service annotation is present without the names attribute and indicates that the Java interface or class annotated with the @WebService annotation defines an SCA service interface.
4305
231sca-javacaa-1.1-spec-csd06 15 August 2011 232Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 116 of 121 4306Appendix D. Acknowledgements
4307The following individuals have participated in the creation of this specification and are gratefully 4308acknowledged: 4309Participants: Participant Name Affiliation Bryan Aupperle IBM Ron Barack SAP AG* Mirza Begg Individual Michael Beisiegel IBM Henning Blohm SAP AG* David Booz IBM Martin Chapman Oracle Corporation Graham Charters IBM Shih-Chang Chen Oracle Corporation Chris Cheng Primeton Technologies, Inc. Vamsavardhana Reddy Chillakuru IBM Roberto Chinnici Sun Microsystems Pyounguk Cho Oracle Corporation Eric Clairambault IBM Mark Combellack Avaya, Inc. Jean-Sebastien Delfino IBM Derek Dougans Individual Mike Edwards IBM Ant Elder IBM Raymond Feng IBM Bo Ji Primeton Technologies, Inc. Uday Joshi Oracle Corporation Anish Karmarkar Oracle Corporation Khanderao Kand Oracle Corporation Michael Keith Oracle Corporation Rainer Kerth SAP AG* Meeraj Kunnumpurath Individual Simon Laws IBM Yang Lei IBM Mark Little Red Hat Ashok Malhotra Oracle Corporation Jim Marino Individual Jeff Mischkinsky Oracle Corporation Sriram Narasimhan TIBCO Software Inc. Simon Nash Individual Sanjay Patil SAP AG* Plamen Pavlov SAP AG* Peter Peshev SAP AG* Ramkumar Ramalingam IBM Luciano Resende IBM 233sca-javacaa-1.1-spec-csd06 15 August 2011 234Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 117 of 121 Michael Rowley Active Endpoints, Inc. Vladimir Savchenko SAP AG* Pradeep Simha TIBCO Software Inc. Raghav Srinivasan Oracle Corporation Scott Vorthmann TIBCO Software Inc. Feng Wang Primeton Technologies, Inc. Changfeng Open Standards Paul Yang Platform Software
235sca-javacaa-1.1-spec-csd06 15 August 2011 236Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 118 of 121 4310Appendix E. Revision History
4311 Revision Date Editor Changes Made 1 2007-09-26 Anish Karmarkar Applied the OASIS template + related changes to the Submission 2 2008-02-28 Anish Karmarkar Applied resolution of issues: 4, 11, and 26 3 2008-04-17 Mike Edwards Ed changes 4 2008-05-27 Anish Karmarkar Added InvalidServiceException in Section 7 David Booz Various editorial updates Mark Combellack WD04 2008-08-15 Anish Karmarkar * Applied resolution of issue 9 (it was applied before, not sure by whom, but it was applied incorrectly) * Applied resolution of issue 12, 22, 23, 29, 31, 35, 36, 37, 44, 45 * Note that issue 33 was applied, but not noted, in a previous version * Replaced the osoa.org NS with the oasis- open.org NS WD05 2008-10-03 Anish Karmarkar * Fixed the resolution of issue 37 but re-adding the sentence: "However, the @... annotation must be used in order to inject a property onto a non-public field. -- in the @Property and @Reference section * resolution of issue 9 was applied incorrectly. Fixed that -- removed the requirement for throwing an exception on ComponentContext.getServiceReferences() when multiplicity of references > 1 * minor ed changes cd01-rev1 2008-12-11 Anish Karmarkar * Fixed reference style to [RFC2119] instead of [1]. * Applied resolutions of issues 20, 21, 41, 42, 43, 47, 48, 49. cd01-rev2 2008-12-12 Anish Karmarkar * Applied resolutions of issues 61, 71, 72, 73, 79, 81, 82, 84, 112 cd01-rev3 2008-12-16 David Booz * Applied resolution of issues 56, 75, 111 cd01-rev4 2009-01-18 Anish Karmarkar * Applied resolutions of issues 28, 52, 94, 96, 99, 101 cd02 2009-01-26 Mike Edwards Minor editorial cleanup. All changes accepted.
237sca-javacaa-1.1-spec-csd06 15 August 2011 238Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 119 of 121 All comments removed. cd02-rev1 2009-02-03 Mike Edwards Issues 25+95 Issue 120 cd02-rev2 2009-02-08 Mike Edwards Merge annotation definitions contained in section 10 into section 8 Move remaining parts of section 10 to section 7. Accept all changes. cd02-rev3 2009-03-16 Mike Edwards Issue 104 - RFC2119 work and formal marking of all normative statements - all sections - Completion of Appendix B (list of all normative statements) Accept all changes cd02-rev4 2009-03-20 Mike Edwards Editorially removed sentence about componentType side files in Section1 Editorially changed package name to org.oasisopen from org.osoa in lines 291, 292 Issue 6 - add Section 2.3, modify section 9.1 Issue 30 - Section 2.2.2 Issue 76 - Section 6.2.4 Issue 27 - Section 7.6.2, 7.6.2.1 Issue 77 - Section 1.2 Issue 102 - Section 9.21 Issue 123 - conersations removed Issue 65 - Added a new Section 4 ** Causes renumbering of later sections ** ** NB new numbering is used below ** Issue 119 - Added a new section 12 Issue 125 - Section 3.1 Issue 130 - (new number) Section 8.6.2.1 Issue 132 - Section 1 Issue 133 - Section 10.15, Section 10.17 Issue 134 - Section 10.3, Section 10.18 Issue 135 - Section 10.21 Issue 138 - Section 11 Issue 141 - Section 9.1 Issue 142 - Section 10.17.1 cd02-rev5 2009-04-20 Mike Edwards Issue 154 - Appendix A Issue 129 - Section 8.3.1.1 cd02-rev6 2009-04-28 Mike Edwards Issue 148 - Section 3 Issue 98 - Section 8 cd02-rev7 2009-04-30 Mike Edwards Editorial cleanup throughout the spec
239sca-javacaa-1.1-spec-csd06 15 August 2011 240Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 120 of 121 cd02-rev8 2009-05-01 Mike Edwards Further extensive editorial cleanup throughout the spec Issue 160 - Section 8.6.2 & 8.6.2.1 removed cd02-rev8a 2009-05-03 Simon Nash Minor editorial cleanup cd03 2009-05-04 Anish Karmarkar Updated references and front page clean up cd03-rev1 2009-09-15 David Booz Applied Issues: 1,13,125,131,156,157,158,159,161,165,172,177 cd03-rev2 2010-01-19 David Booz Updated to current Assembly namespace Applied issues: 127,155,168,181,184,185,187,189,190,194 cd03-rev3 2010-02-01 Mike Edwards Applied issue 54. Editorial updates to code samples. cd03-rev4 2010-02-05 Bryan Aupperle, Editorial update for OASIS formatting Dave Booz CD04 2010-02-06 Dave Booz Editorial updates for Committee Draft 04 All changes accepted CD04-rev1 2010-07-13 Dave Booz Applied issues 199, 200 CD04-rev2 2010-10-19 Dave Booz Applied issues 201,212,213 CSD04-rev3 2010-11-05 Dave Booz Applied issue 216, ed. updates for CSD vote CSD05 2010-11-08 OASIS TC Admin Cleaned and published. WD051 2011-06-20 Mike Edwards Issues 240, 241, 242: 1) Made non-normative JCA90024 thru JCA90039 inclusive. Reword section 10.24.1 2) Made JCA20009 non-normative. Section 2.3.4 reworded. 3) Removed JCA80052 Issues 233 - updated frontmatter, added section 1.4 WD052 2011-07-18 Mike Edwards Issue 243: Changes to the Java Client API - all affect the SCAClientFactoryFinderImpl class in section B.1.3 Removed JCA80054 as part of JAVA-240 WD053 2011-08-08 Mike Edwards All changes accepted WD054 2011-08-15 Mike Edwards Issue 244 - reword [JCA30001] in Section 3.1 All changes accepted.
4312
241sca-javacaa-1.1-spec-csd06 15 August 2011 242Standards Track Work Product Copyright © OASIS Open 2011. All Rights Reserved. Page 121 of 121