SCA/Tuscany的一些使用心得(二) -DefaultSCADomain与组合构件(composite)

DefaultSCADomain是多数用于测试使用域,上回SCADomain的源码,默认就会走此实现,

此类针对贡献包,复合组件,组件进行初始化至内存之中;

 

SCADomain调用:

 

// 创建默认的实现

domain = new DefaultSCADomain(runtimeClassLoader, applicationClassLoader, domainURI, contributionLocation,composites);

// runtimeClassLoader - 域的classLoader(没用)

// applicationClassLoader - 应用的classLoader,主要使用此classLoader运行;

// domainURI - 默认是" http://localhost "

// contributionLocation - 贡献包路径,默认是"/"

// composites - 默认测试是只能编写一个composite配置文件,而DefaultSCADomain构造函数是多参的;

 

DefaultSCADomain:

本对象涉及SCANode和SCAClient,ComponentManager,这里一笔带过,后面会讲解,本次主要叙述本类层次的主流程,

话说回来,源码是要层层的看,当然这是要了解结构和生命周期的读法,debug还是定位到类去看,哈哈;

1.初始化所需的参数:

1.1 处理传参

this .uri = domainURI;

this .composites = composites;

this .applicationClassLoader = applicationClassLoader;

this .domainURI = domainURI;

this .composites = composites;

this .componentManager = new DefaultSCADomainComponentManager( this );

1.2 默认没有贡献包,创建一个贡献包URL集合

this .contributionURLs = new ArrayList < String > ();

if (contributionLocation != null && ! " / " .equals(contributionLocation)) { // 默认没有贡献包,创建;

this .contributionURLs.add(contributionLocation);

}

2.初始化环境:

2.1 创建SCANODE工厂

SCANodeFactory factory = SCANodeFactory.newInstance();

2.2 根据compusite创建SCANodeImp

规则 : 如果拥有多个composite时,将多个composite合并成一个composite;

List < SCAContribution > contributions = new ArrayList < SCAContribution > (); // 创建局部贡献包集合

// 容器内composite多于一个时

if (composites != null && composites.length > 1 ) {

// 将所有的composite转换至一个composite

String content = createDeploymentComposite(applicationClassLoader, composites);

// 创建贡献包

for (String location : contributionURLs) {

contributions.add( new SCAContribution(location, location));

}

node =

factory.createSCANode( " http://tuscany.apache.org/xmlns/sca/1.0/aggregated " , content, contributions

.toArray( new SCAContribution[contributions.size()]));

} else { // 只有一个或为null时

for (String location : contributionURLs) {

contributions.add( new SCAContribution(location, location));

}

// 如果只有一个Composite就获取,不然返回null

String composite = (composites != null && composites.length >= 1 ) ? composites[ 0 ] : null ;

// 创建NodeImpl

if ( ! contributions.isEmpty()) {

node =

factory.createSCANode(composite, contributions.toArray( new SCAContribution[contributions.size()]));

} else {

// 默认单个compusite

node = factory.createSCANodeFromClassLoader(composite, applicationClassLoader);

}

}

2.3 强转赋值SCA客户端

client = (SCAClient)node;

2.4 设置端口

setDefaultPort(); // 设置端口,没有就不设,默认不设置

2.5 启动节点

node.start(); // 节点启动

2.6 将所有组件添加至组件集合中

getComponents(compositeActivator.getDomainComposite());

3.获取服务

public < B > B getService(Class < B > businessInterface, String serviceName) {

return client.getService(businessInterface, serviceName);

}

源码:

public class DefaultSCADomain extends SCADomain {

private String uri; // 默认是"http://localhost"
private String[] composites; // composites配置文件
// private Composite domainComposite;
// private List<Contribution> contributions;
private Map<String, Component> components; // 组件对象集合
private ComponentManager componentManager;// 组件管理器
// private ClassLoader runtimeClassLoader;
private ClassLoader applicationClassLoader; // 应用ClassLoader
private String domainURI; // 原始domainURI
private List<String> contributionURLs; // 贡献包集合

private CompositeActivator compositeActivator;
private SCANode node;
private SCAClient client;

/**
*
* 创建默认SCA域对象
*
* @param runtimeClassLoader 域的classLoader(没用)
*
* @param applicationClassLoader 应用的classLoader,主要使用此classLoader运行;
*
* @param domainURI 默认是"http://localhost"
*
* @param contributionLocation 贡献包路径,默认是"/"
*
* @param composites 默认测试是只能编写一个composite配置文件,而DefaultSCADomain构造函数是多参的;
*
*/
public DefaultSCADomain(ClassLoader runtimeClassLoader,
ClassLoader applicationClassLoader,
String domainURI,
String contributionLocation,
String... composites) {
this.uri = domainURI;
this.composites = composites;
// this.runtimeClassLoader = runtimeClassLoader;
this.applicationClassLoader = applicationClassLoader;
this.domainURI = domainURI;
this.contributionURLs = new ArrayList<String>();
// 默认没有贡献包,创建;
if (contributionLocation != null && !"/".equals(contributionLocation)) {
this.contributionURLs.add(contributionLocation);
}
this.composites = composites;
// 初始化环境
init();

this.componentManager = new DefaultSCADomainComponentManager(this);

}

/**
* A hack to create an aggregated composite
* @param classLoader
* @param composites
* @return
*/
private String createDeploymentComposite(ClassLoader classLoader, String composites[]) {
//.......
}

public void init() {
// TODO 初始化运行环境

// 创建SCANODE工厂
SCANodeFactory factory = SCANodeFactory.newInstance();

List<SCAContribution> contributions = new ArrayList<SCAContribution>();
// 容器内composite多于一个时
if (composites != null && composites.length > 1) {
// 将所有的composite转换至一个composite
String content = createDeploymentComposite(applicationClassLoader, composites);
// 创建贡献包
for (String location : contributionURLs) {
contributions.add(new SCAContribution(location, location));
}
node =
factory.createSCANode("http://tuscany.apache.org/xmlns/sca/1.0/aggregated", content, contributions
.toArray(new SCAContribution[contributions.size()]));
} else {//只有一个或为null时
for (String location : contributionURLs) {
contributions.add(new SCAContribution(location, location));
}
// 如果只有一个Composite就获取,不然返回null
String composite = (composites != null && composites.length >= 1) ? composites[0] : null;
// 创建NodeImpl
if (!contributions.isEmpty()) {
node =
factory.createSCANode(composite, contributions.toArray(new SCAContribution[contributions.size()]));
} else {
node = factory.createSCANodeFromClassLoader(composite, applicationClassLoader);
}
}
client = (SCAClient)node;
compositeActivator = ((NodeImpl)node).getCompositeActivator();
components = new HashMap<String, Component>();

setDefaultPort();//设置端口,没有就不设,默认不设置

node.start();//节点启动
// 添加Component至Map<String, Component> components
getComponents(compositeActivator.getDomainComposite());
}
 

　　private void setDefaultPort() {
　　　　//..
　　}
　　 /**
* 获取服务
*/
public <B> B getService(Class<B> businessInterface, String serviceName) {
return client.getService(businessInterface, serviceName);
}

}

组合构件(composite)

组合构件(composite),是最小的独立部署单元,它是组件的容器,是组件、服务、引用以及内连它们的连线的集合体。

 

配合看源码 - DefaultSCADomain解析

样例:

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

< composite xmlns ="http://www.osoa.org/xmlns/sca/1.0"

xmlns:t ="http://tuscany.apache.org/xmlns/sca/1.0"

xmlns:c ="http://sample"

targetNamespace ="http://sample"

name ="echo" >

// targetNamespace - 工作空间名,后期发布绑定用

// name - composite的名字



< component name ="echoComponent" >

< implementation.java

class ="com.simple.echo.EchoImp" />

< service name ="Echo" >

< binding.ws uri ="http://localhost:8080/TrceanyMoudle/echoComponent" ></ binding.ws >

</ service >

< reference name ="reture" target ="EchoReture" />

</ component >



< component name ="EchoReture" >

< implementation.java class ="com.simple.Client.EchoRetureImp" />

</ component >

</ composite >

转载于:https://www.cnblogs.com/wangzhehan/archive/2011/05/28/2060419.html