osgi

12 Dec 09

04 Dec 09

IBM is Bringing OSGi to Enterprise Developers | Javalobby

java.dzone.com/...ibm-bringing-osgi-enterprise - Preview

ibm osgi websphere applicationServer

02 Oct 09

Potomac - Bringing OSGi Modularity to Flex - InsideRIA

www.insideria.com/...ac---bringing-osgi-modula.html - Preview

flex overview framework potomac osgi modules

It’s possible to use the Flex module system to develop similar applications, but it’s not easy. For one, we must avoid using ModuleLoader. ModuleLoader is used when a module only defines one UI component. In these complex applications, modules never define just one UI component. Instead we need to use ModuleManager to load our modules. This seems easy enough until we start to dig into when and where we need to load our modules. If a module contains 10 or 20 UI components, we’ll need to ensure the module is loaded before the user opens any of those 10 to 20 screens. Now multiply that by 10 or more modules that might exist in a medium sized modular application. We can quickly see that our code will be littered with calls to ModuleManager and IModuleInfo#load(). And this doesn’t take into account the complex dependency structure that OSGi enables. We also don’t want to think about all the asynchronous code that will be necessary as each module load is an asynchronous call. These problems make us cry out for a modular framework that takes care of these details for us - something the Eclipse platform has been doing very successfully for OSGi.
19 more annotations...
- This Flex Builder plug-in adds new capabilities to Flex Builder that, first and foremost, allows a developer to create modules in separate module projects.
- A Potomac bundle, using the OSGi term for module, is created within a Flex Library Project. After the Potomac Flex Builder plug-in is installed, a new right-click menu option is available: “Add Potomac Bundle Nature”. When this is chosen, a regular Flex Library Project is morphed into a Potomac bundle project. The following new capabilities are added to the project:
  A new automatic project builder that automatically compiles a Flex module SWF file in /bin.
  A new bundle.xml file that contains all the metadata for the module.
  A new metadata compiler that checks and marks errors in custom metadata declared by Potomac and by other bundles.
- The automatic module compiler is one of the pieces that enable modules to be reused. Specifically, the compiler will include all classes selected for the library SWC into the module SWF. This differs from normal module compilation which only includes classes that are used by the module but not included in the main application SWF. This is a useful optimization but prevents a module from being used in applications other than the one it was compiled for. Generally speaking, the static linking that Flex Builder favors (the “Merge into code” link option) is diametrically opposed to a modular architecture. This is great to keep SWF file sizes as small as possible, but it sacrifices reusability.
- The new bundle.xml file in a Potomac bundle contains the bundle’s metadata. Most importantly, it maintains the list of bundle to bundle dependencies. The Potomac Flex Builder plug-in includes a form editor to make modifying the bundle.xml easier.
- When bundles are added to the dependency list, Potomac takes care of adding all the necessary entries to the build path. By adding a bundle dependency, a developer can immediately start making references to classes from that bundle.
- The other data contained in the bundle.xml is the extension and extension point metadata. The extension and extension point mechanism is a way for bundles to ‘plug in’ to specific features in a very loosely coupled way. For example, if our application is broken down into a set of screens, we might create a screen extension point and a screen extension for each screen in the application. Extension points are a key component of the Eclipse platform and Potomac draws heavily from Eclipse, yet the extension mechanism in Potomac is quite different.
- To plug in to the UI framework, you simply use some new metadata tags. To request dependency injection you use an [Inject] tag. In fact, to do almost anything in Potomac, you use metadata tags. The reason for this is because extensions and extension points in Potomac are defined via metadata tags. Declaring a new extension point via [ExtensionPoint] actually creates a new metadata tag. For example, declaring [ExtensionPoint(id=”Screen”)] Potomac allows developers to provide extensions to this extension point via [Screen] tags.
- This feature is so powerful that it’s become more than just an extension point mechanism as known in Eclipse. Metadata tags can be declared on classes, methods, or variables. The Potomac Flex Builder plug-in will do syntax and property checking on the metadata tags, and not just ones that are part of Potomac but also any custom metadata tags you define. Along with the compile-time checking, developers are also able to use the full reflection API that Potomac provides at runtime. Need to know where a tag was defined on a method or on top of a class? Need to know the function’s signature or the field’s datatype? All these details are available via the Extension class. It’s no longer necessary for developers to call the describeType() method and parse the returned xml.
- These features have made the extension mechanism so broadly applicable that it powers features beyond the use-cases normally expected of extension points. Instead of just allowing developers to provide UI contributions, it can be used to provide all types of metadata processing. In fact, Potomac uses extension points to power some of the more generic metadata tags like [Inject] and [Handles].
- As alluded to in the previous section, dependency injection is fulfilled via the [Inject] tag. Injection is provided on constructors, methods, and fields. Importantly, injection and class creation managed by the dependency injector is bundle-aware. In other words, a request to inject or create a class in another bundle will cause that bundle (and any of its dependencies) to be loaded. This is critical to how Potomac works and is an important difference from OSGi. OSGi uses Java’s customizable class loading mechanism to load bundles when a class from that bundle is referenced. Flex, or more appropriately, the underlying Flash player doesn’t support similar class loading customization. And even if it did, loading modules in Flex must be done asynchronously. There’s no way to interrupt a standard “new MyClass()” operation to wait for a module to be loaded. Therefore Potomac uses dependency injection as its ‘hook’ for loading bundles.
- This might be starting to sound fairly complicated. But for typical development, these details are hidden from the developer. Developers simply annotate their constructor, method, or variable with [Inject] and it just works.
- The UI framework uses extension points and dependency injection to take component contributions from multiple bundles to form the final cohesive application. In order to make this possible, Potomac breaks down applications into 4 main abstractions that are then made available as extension points. Those abstractions are templates, pages, folders, and parts.
- A template defines the applications overall frame, branding, and navigation structure. An applications template is selected in the Application Manifest Editor. Today Potomac ships with one template though more will follow. You can also create your own if you wish. Ultimately we hope to have a community of third party templates similar to the prevalence of custom themes for web platforms like WordPress or Drupal.
- A page is a primary subsection of an application. In an email application for example, we might break it down into multiple pages: one for email, one for the calendar, one for tasks, etc. How a user navigates to a page depends on the template. A template might choose to arrange pages in tab navigator or perhaps it might only show one page at a time with a button to move between pages. Some templates might define transition effects from one page to the next, others may be more Spartan.
- A folder is a viewport or area within a page. Folders contain one or more parts. A folder can be represented by a set of tabs, an accordion, or practically any Flex container widget. When a page has multiple folders, they are separated by drag-able splitters.
- A part is a UI component, typically extending from Canvas. There are no special requirements for what constitutes a part other than providing the one [Part] metadata tag, but parts can have quite complex features. For example, many parts may represent UI forms used to edit a specific object. Those parts may have a save lifecycle which can be managed by Potomac.
- Among the key features of the UI framework is how it displays UI features like pages and parts before their bundles are loaded. Potomac uses the information declared in the metadata tag to show the part’s selector. For example, if the part is in a tab folder then the tab button is populated with the icon and title text from the [Part] tag. Only when the tab is selected will Potomac will load the necessary bundles and display the part. In practice this ensures bundles are loaded as lazily as possible. And this happens automatically, a developer building on Potomac doesn’t need to know the details. This same lazy loading approach is taken with all the different UI components including pages, parts, and high level menu actions. Nothing is loaded until absolutely necessary. Instead of a developer having to think and focus on the modularity plumbing in a complex application, he or she can just focus on the actual business problems and let Potomac take care of the rest.
- One last significant feature of the UI framework is its customizability. It was already mentioned that you can create your own templates, but you can also create your own folders and page types. Ultimately, every piece of UI shown to the user can be swapped in or out with whatever best suits your application and your look and feel.
- in the weeks and months ahead more features will be added such as preference UI, a security subsystem, and other features for enterprise business applications.