You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 7 Next »

Apache Tuscany SCA Java Architecture

This page is work in progress. Thanks for your contribution (smile)

What is an extension?

How to add a new component implementation?

How to add a new binding?

How to add a new databinding?

General guide for developing extensions

  • Familiarize yourself with SCA 1.0 Assembly and the SCA Java 1.0 programming model. Specifications can be found at www.osoa.org.
  • Never reference any classes in core. These classes are implementation-specific and subject to change; they are not part of the public SPI contract.
  • Use autowire when assembling extension components.
  • Do not play with classloaders such as setting the current context classloader unless it is absolutely necessary, i.e. a library used by an extension makes assumptions about context classloaders. Ideally the library can be refactored to not make these assumptions. If not, make sure the extension properly resets the current context classloader.

Detail on extension architecture

The ExtensionPointRegistry

package org.apache.tuscany.core;

/**
 * The registry for the Tuscany core extension points.
 *
 * @version $Rev: 529327 $ $Date: 2007-04-16 10:10:43 -0700 (Mon, 16 Apr 2007) $
 */
public interface ExtensionPointRegistry {

    /**
     * Add an extension point to the registry
     * @param <T>
     * @param extensionPointType The interface of the extension point
     * @param extensionPoint The instance of the extension point
     */
    <T> void addExtensionPoint(Class<T> extensionPointType, T extensionPoint);

    /**
     * Get the extension point by the interface
     * @param <T>
     * @param extensionPointType
     * @return
     */
    <T> T getExtensionPoint(Class<T> extensionPointType);

    /**
     * Remove an extension point
     * @param extensionPoint
     */
    void removeExtensionPoint(Class extensionPoint);
}

The ModuleActivator 

package org.apache.tuscany.core;

import java.util.Map;

/**
 * ModuleActivator represents a module that plugs into the Tuscany system. Each module should
 * provide an implementation of this interface and registry the implementation class by defining 
 * a file named as "META-INF/services/org.apache.tuscany.spi.bootstrp.ModuleActivator". The
 * content of the file is the class name of the implementation. The implementation class must
 * have a no-arg constructor. The same instance will be used to invoke all the methods during
 * different phases of the module activation.
 * 
 * @version $Rev: 529327 $ $Date: 2007-04-16 10:10:43 -0700 (Mon, 16 Apr 2007) $
 */
public interface ModuleActivator {
    /**
     * Get a map of the extension points defined by this module. The key is the
     * java interface to represent the extension point and the the value is the
     * instance of the implementation of the interface.
     * 
     * @return All the extension points defined by this module
     */
    Map<Class, Object> getExtensionPoints();

    /**
     * This method is invoked when the module is started by the Tuscany system.
     * It can be used by this module to registr extensions against extension
     * points.
     * 
     * @param registry The extension point registry
     */
    void start(ExtensionPointRegistry registry);

    /**
     * This method is invoked when the module is stopped by the Tuscany system.
     * It can be used by this module to unregister extensions against the
     * extension points.
     * 
     * @param registry The extension point registry
     */
    void stop(ExtensionPointRegistry registry);
}

The ModuleActivator represents a module that plugs into the Tuscany system.
Each module should provide an implementation 3 of this interface and
registry the implementation class by defining a file named as
"META-INF/services/org.apache.tuscany.spi.bootstrp.ModuleActivator" 4. The
content of the file is the class name of the implementation. The
implementation class must have a no-arg constructor. The same instance will
be used to invoke all the methods during different phases of the module
activation.

During bootstraping, the following sequence will happen:

1) All the module activators will be discovered by the presence of
META-INF/services/org.apache.tuscany.spi.bootstrp.ModuleActivator
2) The activator class is instantiated using the no-arg constructor.
3) ModuleActivator.getExtensionPoints() is invoked for all modules and the
extension points contributed by each module are added to the
ExtensionRegistry.
4) ModuleActivator.start(ExtensionRegistry) is invoked for all the modules.
The module can then get interested extension points and contribute
extensions to them. The contract bwteen the extension and extension point is
private to the extension point. The extension point can follow similar
patterns such as Registry. If it happens that one extension point has a
dependency on another extension point, they can linked at this phase.

During shutting down, the stop() method is invoked for all the modules to
perform cleanups. A module can choose to unregister the extension from the
extension points.

  • No labels