[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]
Subject: JAVA-98: Examples for latest proposal
As requested, here are some examples showing how the various points of this proposal would work. It is assumed that @ManagedTransaction has been defined as a specific intent annotation for the SCA intent "managedTransaction". No examples are given for point C) because this delegates to the Policy spec and is not Java-specific. Example A1: In the following Java code, the intents on myref are "authentication" and "confidentiality.message". @Authentication @Requires(CONFIDENTIALITY) @Confidentiality("message") @Reference protected MyService myref; Example A2: The following Java code is in error because of contradictory mutually exclusive intents "managedTransaction" and "noManagedTransaction". @ManagedTransaction @Requires(SCA_PREFIX+"noManagedTransaction") @Reference protected MyService myref; Example A3: The following intents are legal: @Authentication public class MyService { @Confidentiality public void mymethod() {...} } Example A4: The following intents are legal: @Authentication public interface MyService { @Confidentiality public void mymethod(); } @Service(MyService.class) @ManagedTransaction public class MyServiceImpl { public void mymethod() {...} } Example A5: The following intents are legal: @Authentication public interface MyRefInt { @Integrity public void mymethod(); } @Service(MyService.class) public class MyServiceImpl { @Confidentiality @Reference protected MyRefInt myRef; } Example A6: The following intent is illegal: @Service(MyService.class) public class MyServiceImpl { @Authentication public void mymethod() {...} } Example B1: The effective intents for mymethod() are "authentication" and "confidentiality". @Authentication public interface MyService { @Confidentiality public void mymethod(); } Example B2: The effective intent for mymethod() is "confidentiality.message". @Confidentiality("message") public interface MyService { @Confidentiality public void mymethod(); } Example B3: The effective intent for mymethod1() is "managedTransaction" and the effective intent for mymethod2() is "noManagedTransaction". @ManagedTransaction public interface MyService { public void mymethod1(); @Requires(SCA_PREFIX+"noManagedTransaction") public void mymethod2(); } Example D1: For the following Java code: @Authentication public interface MyService { @Confidentiality public void mymethod(); } public interface MyRefInt { @Integrity public void mymethod1(); } @Service(MyService.class) @ManagedTransaction public class MyServiceImpl { @Confidentiality @Reference protected MyRefInt myRef; public void mymethod() {...} } the intropected componentType is: <componentType> <implementation.java class="MyServiceImpl" requires="managedTransaction"/> <service name="MyService" requires="managedTransaction"> <interface.java interface="MyService"/> </service> <reference name="myRef" requires="confidentiality"> <interface.java interface="MyRefInt"/> </reference> </componentType> Simon Simon Nash wrote: > Here is a simplified version of the proposal with the following changes > from the previous proposal: > 1. Disallow intents on implementation methods. > 2. Allow implementation intents on interface methods and interfaces. > > A) Specific intent annotations can appear together with @Requires > on the same Java program element. If they do, the annotations > contributed by specific intent annotations are merged with those > contributed by @Requires, following the policy rules for merging > intents at the same hierarchy level. > > Intents can be applied to a Java class or Java interface used as > an SCA service interface, a method of a Java class or Java interface > used as an SCA service interface, a Java class used as an > SCA service implementation, a Java reference, a Java interface for > a reference, or a method of a Java interface for a reference. It is > an error to apply an intent to a method of a Java class not used as > an SCA service interface. > > B) The effective intents for a method of an SCA interface defined by > <interface.java> are computed by the following algorithm: > 1. Use the rules in A) above to find the intents for the method > and the intents for its declaring class or interface. > 2. Use the policy rules for merging intents within a structural > hierarchy to merge the intents found in step 1 above, with the > method at the lower level and the method's declaring class or > interface at the higher level. > These rules are applied to the methods of a Java implementation > class or Java interface used to define an SCA service interface, > and to the methods of the Java interface for a reference. > > C) The effective intents for each method of an SCA service are computed > by applying the rules in the Policy specification to the intropected > component type implied by the rules in D) below, using the effective > intent computation rules in B) above. > > D) The componentType introspection rules for intents are as follows: > 1. Intents on the service implementation class are placed on the > <implementation.java> element in the componentType. > 2. For all SCA services defined using Java interfaces, intents on > the service implementation class are placed on the corresponding > <service> elements in the componentType. > 3. Intents on Java references are placed on the corresponding > <reference> elements in the componentType. > > Simon > > > --------------------------------------------------------------------- > To unsubscribe from this mail list, you must leave the OASIS TC that > generates this mail. Follow this link to all your TCs in OASIS at: > https://www.oasis-open.org/apps/org/workgroup/portal/my_workgroups.php > >
[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]