SCA and Java SCA provides support for multiple Java-based

component implementation types Java POJOs (implementation.java) Spring Beans (implementation.spring) EJB (implementation.ejb)

Common annotations and API May be used by all Java-based implementations Metadata service contracts based on Java interfaces Metadata component type information Metadata container-component implementation

contract Asynchronous interactions and callbacks APIs (few) for accessing assembly information

An example Java implementation type Just Java with a few (optional)

annotations

public class LoanServiceImpl implements LoanService {private CreditService creditService;public LoanServiceImpl(@Reference CreditService creditService) {

this.creditService = creditService;}

public void apply(Application application) {String id = application.getCustomerID();int rating =

creditService.getCreditScore(id);}

}

Key Principles Simplify component development

Use POJOs Minimal container coupling to

implementations Achieved through Inversion of Control or IoC

Simplify reuse through service-based design

Strongly defined contracts that pass data Remove need to interact directly with binding

protocols and transports most of the time Focus on loosely-coupled interactions

Metadata for Service Contracts @Remotable

Defines a service that may be visible across process boundaries

@Conversational, @EndsConversation Deals with conversational services More on this later

@OneWay Denotes a non-blocking operation More on this later

@Callback Defines callback interface and injection

Metadata for defining component type information @Service

Defines services offered by an implementation @Property

Identifies a component type property Setter-based, ctor-based and field-based injection

supported @Reference

Identifies a component type reference Setter-based, ctor-based and field-based injection

supported SCA defines heuristics for unannotated POJOs

as well

Container-Component Implementation Contract Metadata @AllowsPassByReference

Per-class or per-operation @Scope

Specifies visibility and lifecycle contract STATELESS (default), REQUEST,

CONVERSATION, COMPOSITE Containers may also add custom scopes

Conversation semantics Always between two parties May be long-running

Asynchronous Interactions @OneWay

Indicate a non-blocking call on an interface

public interface Counter {int getCount();

@OneWayvoid increment();

@EndsConversationint reset();

}

Callbacks Stateful and stateless Non-blocking or blocking

@Callback(MyCallback.class)public interface MyService {

void call();}

public interface MyCallback {void call();

}

public class MyServiceImpl {

@Callbackpublic void setCallback(MyCallback callback){

//...}//...

}

Stateful Callbacks LoanShark service

Conversational@Callback(Borrower.class)public interface LoanShark {

void borrow(double amount);

@EndsConversationvoid payback();

@OneWayvoid delay();

}

public interface Borrower {

warn();breakArm();

@EndsConversationkill();

}

APIs

Only a few, deal with specific use cases, e.g.

Component context, name Request contexts Service references (may be passed) Conversation id Set callback

SCA - Spring IntegrationSCA - Spring Integration

www.oasis-open.org

Spring Spring application contexts can be used as

component implementations Spring beans can be wired to SCA or external

services services Spring beans can have services exposed

Other SCA components may be wired to them Beans may be bound using an SCA binding

Spring Beans

SCA Reference

SCA Service

implementation.spring

SCA - Java EE IntegrationSCA - Java EE Integration

www.oasis-open.org

www.oasis-open.org

Why SCA With Java EE Platform?Java EE gets Additional implementation types and bindings on the

application level: BPEL, Spring,... More to expect: For example ESB style interactions

Move protocol specifics to configuration via bindings Cross-Application Assembly

Domain assembly extends Enterprise App Assembly to the cross-app level

SCA gets Reuse of existing assets, know-how, tooling.

www.oasis-open.org

Types of Integration Bindings

JMS, Session Beans, JCA Implementation Types

Java EE Components (SessionBeans, WebComponents, etc) as implementation types.

Java EE Archives (EARs, WARs, EJB-JARs) as implementation types.

www.oasis-open.org

Use Cases for BindingsBinding.ejb Consume session beans from service

components Expose SCA services as session beans, so that

they can be consumed by unmodified Java EE components

Binding.jms, Binding.jca Several other binding types relate to Java EE, but

are the focus of other working groups.

www.oasis-open.org

Use Cases for Java EE Components as Implementation Types

Java EE components use SCA‘s programming model to consume SCA-exposed services.

Use session beans as Service Component Implementations that may be consumed by other SCA components.

Use recursive SCA assembly in enterprise applications.

Deploy SCA Components as a part of a Java EE application

SCA is the Scale-Out model for Java EE

www.oasis-open.org

Use Cases for Java EE Applications as Implementation Types

Use Java EE applications as Service Component Implementations

Modified Unmodified

Allow unmodified Java EE applications to be rewired by SCA.

Exposure of Java EE services at any level of recursive assembly.

SCA is the level of assembly above Java EE

Programming Model in JEE Components Will be shown during demo:

sample:beancomposite

org.sample.Accounting

module.jar

RemotableAccountingBeanComposite with a session bean component

Contribution is JEE Archive:Sample Assembly I

<?xml version="1.0" encoding="UTF-8"?><composite name="beancomposite"

targetNamespace="http://www.sample.org" xmlns="http://www.osoa.org/xmlns/sca/1.0">

<component name="org.sample.Accounting"> <implementation.ejb

ejb-link="module.jar#RemotableAccountingBean"/> </component></composite>

domain composite

App1

sample:beancomposite

org.sample.Accounting

module.jar

RemotableAccountingBean

org.sample.Accounting

Including it into the domain

<?xml version="1.0" encoding="UTF-8"?><contribution

xmlns="http://www.osoa.org/xmlns/sca/1.0"xmlns:sample="http://www.sample.org" >

<deployable composite=“sample:beancomposite"/></contribution>

Declare sample:beancomposite as Deployment Composite inIn META-INF/sca-contribution.xml:

Contribution is JEE Archive:Sample Assembly II

Contribution containing a Java EE archive

Contribution

some other composite

application.ear

module.jar

accounting_application

beancomponent

RemotableBean

binding.wsothercomponent

some_component

a non-Java EE contribution

a component using <implementation.jee archive=“application.ear“/>

Open Questions

What is the componentType of an unmodified EAR (ie, one with no application.composite)?

Can ejb-ref‘s be rewired by SCA?