|
|
Open Source Inversion of Control Containers
| PicoContainer is a lightweight embeddable container for components that honour Dependency Injection. |
Go To PicoContainer
| Avalon consists of a number of products and sub-projects supporting service and component management. |
Go To Avalon
| NanoContainer is a Dependency Injection (DI) container that manages trees of PicoContainers. NanoContainer adds the following features to PicoContainer:
* classloader (classpath) management
* class name based composition (via reflection)
* Scripting language support |
Go To NanoContainer
| Peapod is a lightweight container. Peapod lets you take a plain Java class, an interface and a small fragment of XML metadata and hand off responsibility to a host. The combination of an interface, and implementing class and the metadata is a component; the host is Peapod. The responsibilities the host can take over are many. Here are some that Peapod handles:
* hot-deploy and undeploy of JARs: just drop in a directory or remove a file to install or uninstall a component
* intelligent dependency management: components are active only when all their declared dependencies have been satisfied--remove a component and all its dependents gracefully shut down; re-add it and they wake up
* code versioning: declare you require version 1.0 and seamlessly receive a access to facilities provided by a 1.1 implementation--you can even have both versions running in the same container
* combining the above three you get hot upgrades: undeploy a component, thus putting the dependents to sleep, deploy a newer version and not have to restart at all, enabling very high uptimes with a single lightweight server
* external configuration by metadata
* declarative aspect-oriented programming: use metadata to select code to insert at runtime between method calls made to an interface or even to a single method--tracing, security, transactions, single-threading, and more; the container includes several useful aspects you can use out of the box |
Go To Peapod
| Carbon is a light-weight component model and services framework providing enterprise quality services. Carbon is built on the following principles:
* Create a more flexible architecture via a decoupled, metadata-centric system
* Reduce complexity by providing access to services as small replaceable components
* Encourage the separation of concerns, resulting in code assets that are easier to maintain, adapt and reuse in a complex and dynamic operating environment
* Improve quality with highly documented, fully tested code |
Go To Carbon
| Excalibur is an open source software project of The Apache Software Foundation that contains a lightweight, embeddable Inversion of Control container named Fortress that is written in java. |
Go To Excalibur
| Gravity is a dependency and configuration management framework that allows multiple forms of configuration via a plugin model with a primary focus on the Dependency Injection / Inversion of Control (IoC) design pattern. The framework comes with a default BeanShell plugin for configuring the components. |
Go To Gravity
| Soto is a lightweight, non intrusive service framework relying on a powerful configuration format based on Java's introspection capabilities.
The framework implements neat ideas such as conditional instantiation, resource resolving and layers. It comes with JMX and AOP functionality. |
Go To Soto
| JICE is an XML-based tool for constructing and configuring Java applications.
JICE specifies an XML-vocabulary for configuring the object in a Java application and provides tools for processing the XML-data into Java instances.
JICE supports Inversion of Control (IoC) / Dependency Injection: it can provide constructor parameters for objects and set the properties of the objects.
However, JICE is more than just an IoC container - in addition to setter methods, it can call any method of an object during initialization. JICE is capable of constructing complex object graphs, it is not limited in initializing beans.
the XML format especially is very compact and nice. |
Go To JICE
| HiveMind is a services and configuration microkernel:
Services: HiveMind services are POJOs (Plain Old Java Objects) that can be easily accessed and combined. Each service defines a Java interface it implements. HiveMind takes care of instantiating and configuring each service just as necessary. HiveMind lets services collaborate with each other via dependency injection.
Configuration: HiveMind allows you to provide complex configuration data to your services in a format you define. HiveMind will integrate the contributions of such data from multiple modules and convert it all into data objects for you. HiveMind configurations allow for powerful, data-driven solutions which combine seemlessly with the service architecture.
Microkernel: HiveMind is a framework for creating applications, not an application, or even an application server, itself. The 'core' of HiveMind is the startup logic that knows how to parse and understand the module deployment descriptors, and use that information to instantiate and initialize all those services and configurations.
In HiveMind, a service is an implementation of a Java interface. Unlike other SOAs (Service Oriented Architectures, such as a SOAP, or EJBs), HiveMind is explicitly about combining Java code within a single JVM. HiveMind uses a descriptor to describe different services, their lifecycles, and how they are combined. HiveMind takes care of thread-safe, just-in-time creation of singleton service objects so your code doesn't have to. |
Go To HiveMind
| DNA is a lightweight Inversion of Control (IOC) framework. DNA components have associated metadata that declares what resources they need to be provided and what resources they are capable of providing to other components. |
Go To DNA
| Loom is a micro-kernel designed and implemented on top of the DNA framework. It supports components developed using the Avalon framework. In the future Loom will also support DNA and Pico components. |
Go To Loom
| Spice is a repository of Components which support Component Oriented Programming (COP) paradigms - in particular, the Inversion of Control (IoC) design pattern. |
Go To Spice
| Yan container stands for Yet Another Non-intrusive container for object dependency injection.
The core of Yan is a compact Java API with no dependency to any other lib.
Around the tiny core, are services such as component monitoring, life cycle management, xml configuration etc. |
Go To Yan
| Guice is a dependency injection container that wholly embraces annotations and generics, thereby enabling you to wire together and test objects with less effort than ever before. Annotations finally free you from error-prone, refactoring-adverse string identifiers. |
Go To Google Guice
| OfficeFloor is an Inversion of Control implementation that focuses on dependency injection into methods rather than into objects and improves on existing dependency injection frameworks by letting you specify the Thread to execute the method - thereby really adhering to the \"Hollywood Principle\" (don't call us, we \"really\" will call you).
Features:
* Multi-threaded Java framework providing for thread safe execution of your methods (with ability to specify differing thread pools to execute particular methods)
* Dependency injection of objects as parameters to the executed methods
* Provides both auto-wiring of dependencies and manual graphical configuration
* Abstraction of plug-ins to enable more course grained integration than individual classes (allows easier assembly and management of applications)
* Existing plug-ins to build web based applications
* JEE Servlet integration for web based components (currently under development)
* Spring plug-in to enable re-use of your existing Spring beans
OfficeFloor is freely distributed under GPL. |
Go To OfficeFloor
| The Plexus project provides a full software stack for creating and executing software projects. Based on the Plexus container, the applications can utilise component-oriented programming to build modular, reusable components that can easily be assembled and reused.
While Plexus is similar to other inversion-of-control (IoC) or dependency injection frameworks such as the Spring Framework, it is a full-fledged container that supports many more features such as:
Component lifecycles
Component instantiation strategies
Nested containers
Component configuration
Auto-wiring
Component dependencies, and
Various dependency injection techniques including constructor injection, setter injection, and private field injection. |
Go To Plexus
|
|
