SCA Java implementation.spring (TUSCANY) edited by Ramkumar Ramalingam
Page:
http://cwiki.apache.org/confluence/display/TUSCANY/SCA+Java+implementation.spring
Changes:
http://cwiki.apache.org/confluence/pages/diffpagesbyversion.action?pageId=66253&originalVersion=5&revisedVersion=6
Content:
---------------------------------------------------------------------
{section:border=false}
{column:width=15%}
{include: SCA Java Subproject Menu}
{include: Java SCA Menu New}
{column}
{column:width=85%}
h2. <implementation.spring>
The Tuscany Java SCA runtime supports components implemented with Spring
Framework by using the <implementation.spring> SCDL extension.
The [Spring specification|
http://www.osoa.org/download/attachments/35/SCA_SpringComponentImplementationSpecification-V100.pdf?version=1]
defines how Spring and SCA work with one another. The Spring Component
implementation is one of the SCA extensions which is being formalized in the
OASIS Open Composite Services Architecture with a published [specifications
|http://www.oasis-opencsa.org/sca-spring] document.
(on) In [Spring Framework|
http://static.springframework.org/spring/docs/2.0.x/reference/index.html] an
ApplicationContext is the main interface to the Spring IoC container. It is
used to look up objects. It can be viewed as the Java object representation of
the application-Context.xml file that contains the bean definitions.
The integration with Spring will be at the SCA Composite level, where a Spring
application context provides a complete composite, exposing services and using
references via SCA. This means that a Spring application context defines the
internal structure of a SCA composite implementation.
(on) Tuscany uses Spring Framework 2.5.5 (requires Java 1.4+)
h3. How Spring Application Context is used as SCA Composite Implementation?
* A Spring Application Context is used as an implementation within an SCA
composite component.
* A component that uses Spring for an implementation can wire SCA services and
references without introducing SCA metadata into the Spring configuration. The
Spring context knows very little about the SCA environment.
* SCA runtime enforces SCA policies and Spring Application Context is unaware
of it.
* It should be possible to generate an SCA Composite from any Spring context
and use that composite within an SCA assembly. _This feature is under review by
the OASIS Specs Team, yet to be implemented in Tuscany_
h3. How to Use Spring Component Implementation?
The Spring component implementation SCDL has the following format:
{code}
<implementation.spring location="targetURI" />
{code}
Where the location attribute of that element specifies the target uri of an
archive file or directory or the fully qualified path that contains the Spring
application context files.
An example of all the three ways of specifying the target uri in the location
attribute is shown below
a) Specifying Fully Qualified Path:
{code}
<implementation.spring location="./spring/application-context.xml" />
{code}
b) Specifying a Directory:
{code}
<implementation.spring location="./spring" />
{code}
Here the target uri specifies the resource as a directory named "spring", where
all the spring related files are available.
c) Specifying an Archive file:
{code}
<implementation.spring location="./spring.jar" />
{code}
Here the target uri specifies the resource as an archive file name
"spring.jar", where all the spring related files are available.
(on) In case of b) and c), If the resource identified by the location attribute
is an archive file then the file META-INF/MANIFEST.MF is read from the archive.
If the location URI identifies a directory, then META-INF/MANIFEST.MF must
exist underneath that directory.
If the manifest file contains a header "Spring-Context" of the format:
+Spring-Context ::= path ( ';' path )*+
Where path is a relative path with respect to the location URI, then the set of
paths specified in the header identify the context configuration files. If
there is no MANIFEST.MF file or no Spring-Context header within that file, then
the default behavior is to build an application context using
application-context.xml file in the META-INF/spring directory.
h3. How Spring Application Context is Aware of Beans used in SCA composition?
Your existing Spring Application context should define the
[http://www.springframework.org/schema/sca] namespace in order to make the
Spring aware of the SCA related beans. This is shown below.
{code}
<beans xmlns="http://www.springframework.org/schema/beans";
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";
xmlns:sca="http://www.springframework.org/schema/sca";
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/sca
http://www.osoa.org/xmlns/sca/1.0/spring-sca.xsd";>
<sca:service name="StockQuoteService"
type="bigbank.stockquote.StockQuoteService"
target="StockQuoteServiceBean"/>
<bean id="StockQuoteServiceBean" class="bigbank.stockquote.StockQuoteImpl">
</bean>
</beans>
{code}
h3. Handling multiple Spring Application Contexts
Tuscany supports the following configurations to handle multiple Spring
Application Context XML files.
h4. Using <import> Element:
Each import element points to an application context xml file.
{code}
<beans>
<import resource="services.xml"/>
<import resource="resources/messageSource.xml"/>
<import resource="/resources/themeSource.xml"/>
<bean id="bean1" class="..."/>
<bean id="bean2" class="..."/>
</beans>
{code}
h4. Using ClassPathXmlApplicationContext Bean Definition:
Each list value points to an application context xml file.
{code}
<bean id="beanRefFactory"
class="org.springframework.context.support.ClassPathXmlApplicationContext">
<constructor-arg>
<list>
<value>services.xml</value>
<value>resources/messageSource.xml</value>
</list>
</constructor-arg>
</bean>
{code}
h3. Some Examples:
h4. Spring BigBank Sample
The spring-bigbank sample demonstrates most of the functionality that is
specified in the [specifications |http://www.oasis-opencsa.org/sca-spring].
See the [simple-bigbank-spring
|http://svn.apache.org/repos/asf/tuscany/java/sca/samples/simple-bigbank-spring/]
sample for a complete example.
h4. Direct use of SCA references within a Spring configuration
See the [spring-bigbank-calculator
|http://svn.apache.org/repos/asf/tuscany/java/sca/samples/spring-bigbank-calculator/]
sample for a complete example of using direct SCA references within Spring
configuration.
The properties like addService, subtractService, multiplyService and
divideService defined in the Spring configuration as shown below
{code}
<beans>
<sca:service name="CalculatorService"
type="bigbank.calculator.CalculatorService"
target="CalculatorServiceBean"/>
<bean id="CalculatorServiceBean"
class="bigbank.calculator.CalculatorServiceImpl">
<!-- Here are some implicit references - a property with a ref not
satisifed within the
* Spring application context.
-->
<property name="addService" ref="addService"/>
<property name="subtractService" ref="subtractService"/>
<property name="multiplyService" ref="multiplyService"/>
<property name="divideService" ref="divideService"/>
</bean>
</beans>
{code}
are the direct representation of the SCA references defined in the composite
file.
h4. Explicit declaration of SCA related beans inside a Spring Application
Context
It is also possible to explicitly declare SCA-related beans inside a Spring
configuration to proxy SCA references. The primary reason you may do this is to
enable the Spring container to decorate the bean (using Spring AOP for example).
The properties checkingAccountService, calculatorService and stockQuoteService
defined in the Spring configuration as shown below
{code}
<beans>
<bean id="AccountServiceBean" class="bigbank.account.AccountServiceImpl">
<property name="calculatorService" ref="calculatorService"/>
<property name="stockQuoteService" ref="stockQuoteService"/>
<property name="checkingAccountService" ref="checkingAccountService"/>
<!-- Here are some implicit references & properties - a property with a
ref not satisifed
* within the Spring application context.
-->
<property name="savingsAccountService" ref="savingsAccountService"/>
<property name="stockAccountService" ref="stockAccountService"/>
<property name="currency" value="EURO"/>
</bean>
<sca:reference name="checkingAccountService"
type="bigbank.account.checking.CheckingAccountService"/>
<sca:reference name="calculatorService"
type="bigbank.calculator.CalculatorService"/>
<sca:reference name="stockQuoteService"
type="bigbank.stockquote.StockQuoteService"/>
</beans>
{code}
can be declared explicit as SCA beans in Spring Application Context using the
<sca:reference> element.
See the [simple-bigbank-spring
|http://svn.apache.org/repos/asf/tuscany/java/sca/samples/simple-bigbank-spring/]
sample for a complete example of using explicit declaration of SCA related
beans.
h4. Using SCA Bindings for Spring Implementation
We know that a component that uses Spring for an implementation can wire SCA
services and references without introducing SCA metadata into the Spring
configuration. The Spring context knows very little about the SCA environment.
Hence the SpringComponent implementation remains the same as shown from some of
the examples above but different bindings are chosen at the SCA Composite level
as shown below.
(on) All kind of bindings supported by SCA can be used for Spring
Implementation as the bindings are independent of Spring context. Few examples
can be seen below.
h5. Working with SCA WebServices Binding
Declaring Service
{code}
<composite name="StockQuote">
<service name="StockQuoteService" promote="StockQuoteServiceComponent">
<interface.java interface="bigbank.stockquote.StockQuoteService"/>
<binding.ws uri="http://localhost:8081/services/StockQuoteWebService"/>
</service>
<component name="StockQuoteServiceComponent">
<implementation.spring
location="META-INF/spring/StockQuoteService-context.xml"/>
</component>
</composite>
{code}
Declaring Reference in a component which consumes the Service declared above
{code}
<component name="AccountServiceComponent">
<implementation.spring
location="spring-context/Account-spring-context.xml"/>
<reference name="stockQuoteService">
<binding.ws uri="http://localhost:8081/services/StockQuoteWebService"/>
</reference>
</component>
{code}
See the [spring-bigbank-stockquote |
http://svn.apache.org/repos/asf/tuscany/java/sca/samples/spring-bigbank-stockquote/]
sample for a complete example of using SCA Web Service binding.
h5. Working with SCA RMI Binding
See the [spring-bigbank-calculator
|http://svn.apache.org/repos/asf/tuscany/java/sca/samples/spring-bigbank-calculator/]
sample for a complete example of using SCA RMI binding.
h3. Access the Spring-ApplicationContext from everywhere in your Application
Tuscany creates an custom Application context with an implementation logic for
all SCA related beans like <sca:service>, <sca:reference> and <sca:properties>
available in the Spring Application Context.
To access the application context in your application we recommend to use the
suggested approach in this article.
[http://blog.jdevelop.eu/2008/07/06/access-the-spring-applicationcontext-from-everywhere-in-your-application/]
h3. Non-Supported Implicit SCA References & Properties in Spring Context
Currently Tuscany does not support implicit SCA references and properties for
the following scenarios in spring context as shown below.
h5. Scenario 1:
{code}
<constructor-arg><ref bean="mySCAService1"/></constructor-arg>
<constructor-arg><ref bean="mySCAService2"/></constructor-arg>
{code}
In the above scenario, implicit references will be supported only when the
contructor-arg element specifies the type of the service
that its trying to consume, by specifying a type attribute in the
contructor-arg.
h5. Scenario 2:
{code}
<bean id="moreComplexObject" class="example.ComplexObject">
<!-- results in a setSomeList(java.util.List) call -->
<property name="someList">
<list>
<value>a list element followed by a reference</value>
<ref bean="mySCAService1" />
</list>
</property>
<!-- results in a setSomeMap(java.util.Map) call -->
<property name="someMap">
<map>
<entry>
<key>
<value>an entry</value>
</key>
<value>just some string</value>
</entry>
<entry>
<key>
<value>a ref</value>
</key>
<ref bean="mySCAService2" />
</entry>
</map>
</property>
<!-- results in a setSomeSet(java.util.Set) call -->
<property name="someSet">
<set>
<value>just some string</value>
<ref bean="mySCAService3" />
</set>
</property>
</bean>
{code}
h3. Spring SCA Namespace schema
The spring-sca.xsd can be found at the following location:
[http://www.osoa.org/xmlns/sca/1.0/spring-sca.xsd]
h3. References
Spring Framework -
http://static.springframework.org/spring/docs/2.0.x/reference/index.html
{column}
{section}
---------------------------------------------------------------------
CONFLUENCE INFORMATION
This message is automatically generated by Confluence
Unsubscribe or edit your notifications preferences
http://cwiki.apache.org/confluence/users/viewnotifications.action
If you think it was sent incorrectly contact one of the administrators
http://cwiki.apache.org/confluence/administrators.action
If you want more information on Confluence, or have a bug to report see
http://www.atlassian.com/software/confluence
