IOC (Inversion of Control)

 

Excalibur
Excalibur is an open source software project of The Apache Software Foundation that contains a lightweight, embeddable Inversion of Software Foundation that contains a lightweight, embeddable Inversion of Control container named Fortress that is written in java.

HiveMind
HiveMind is a services and configuration microkernel: Services: HiveMind services are POJOs (Plain Old Java Objects) that can be easily 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 doesnt have to.

Avalon
Avalon consists of a number of products and sub-projects supporting service and component management. supporting service and component management.

PicoContainer
PicoContainer is a lightweight embeddable container for components that honour Dependency Injection. components that honour Dependency Injection.

Loom
Loom is a micro-kernel designed and implemented on top of the DNA framework. It supports components developed using the Avalon framework. framework. It supports components developed using the Avalon framework. In the future Loom will also support DNA and Pico components.

Google Guice
Guice is a dependency injection container that wholly embraces annotations and generics, thereby enabling you to wire together and test 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.

NanoContainer
NanoContainer is a Dependency Injection (DI) container that manages trees of PicoContainers. NanoContainer adds the following manages trees of PicoContainers. NanoContainer adds the following features to PicoContainer: * classloader (classpath) management * classloader (classpath) management * class name based composition (via reflection) * Scripting language support

DNA
DNA is a lightweight Inversion of Control (IOC) framework. DNA components have associated metadata that declares what resources they components have associated metadata that declares what resources they need to be provided and what resources they are capable of providing to other components.

Spice
Spice is a repository of Components which support Component Oriented Programming (COP) paradigms - in particular, the Inversion of Oriented Programming (COP) paradigms - in particular, the Inversion of Control (IoC) design pattern.

Yan
Yan container stands for Yet Another Non-intrusive container for object dependency injection. The core of Yan is a compact Java API with 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.

Gravity
Gravity is a dependency and configuration management framework that allows multiple forms of configuration via a plugin model with a 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.

Carbon
Carbon is a light-weight component model and services framework providing enterprise quality services. Carbon is built on the following providing enterprise quality services. Carbon is built on the following principles: * Create a more flexible architecture via a decoupled, * 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

JICE
JICE is an XML-based tool for constructing and configuring Java applications. JICE specifies an XML-vocabulary for configuring the 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.

PeaPod
Peapod is a lightweight container. Peapod lets you take a plain Java class, an interface and a small fragment of XML metadata and hand 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 * 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

Who's new

  • admin

Who's online

There are currently 0 users online.