Download document

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


@Conversational, @EndsConversation



Deals with conversational services
More on this later
@OneWay



Defines a service that may be visible across process
boundaries
Denotes a non-blocking operation
More on this later
@Callback

Defines callback interface and injection
Metadata for defining
component type information

@Service


@Property



Identifies a component type property
Setter-based, ctor-based and field-based injection
supported
@Reference



Defines services offered by an implementation
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


@Scope




Per-class or per-operation
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();
@OneWay
void increment();
@EndsConversation
int 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 {
@Callback
public void setCallback(MyCallback callback){
//...
}
//...
}
Stateful Callbacks

LoanShark service
Conversational
@Callback(Borrower.class)
public interface LoanShark {
void borrow(double amount);
@EndsConversation
void payback();
@OneWay
void delay();
}
public interface Borrower {
warn();
breakArm();
@EndsConversation
kill();
}
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
www.oasis-open.org
SCA - Spring Integration
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 Service
SCA
Reference
implementation.spring
www.oasis-open.org
SCA - Java EE Integration
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 Bindings
Binding.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:
Contribution is JEE Archive:
Sample Assembly I
module.jar
Composite with a session bean component
RemotableAccountingBean
sample:beancomposite
<?xml version="1.0" encoding="UTF-8"?>
org.sample.Accounting
<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>
Contribution is JEE Archive:
Sample Assembly II
App1
module.jar
Including it into the domain
Declare sample:beancomposite as
Deployment Composite in
In META-INF/sca-contribution.xml:
RemotableAccountingBean
sample:beancomposite
org.sample.Accounting
<?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>
org.sample.Accounting
domain composite
Contribution containing a
Java EE archive
a non-Java EE
contribution
Contribution
application.ear
module.jar
RemotableBean
accounting_application
binding.ws
beancomponent
some other composite
some_component
a component using
<implementation.jee archive=“application.ear“/>
othercomponent
Open Questions


What is the componentType of an
unmodified EAR (ie, one with no
application.composite)?
Can ejb-ref‘s be rewired by SCA?