A
Ajax
Aspect-Oriented
 
B
Bloggers
Build Systems
Business Intelligence
ByteCode
 
C
CMS
Cache Solutions
Charting & Reporting
Chat Servers
Code Analyzers
Code Beautifiers
Code Coverage
Collections
Command Line
Connection Pools
Crawlers
 
D
Databases
 
E
EJB Servers
ERP & CRM
ESB
Eclipse Plugins
Expression Languages
 
F
Financial Soft
Forum Soft
 
G
General Purpose
Geospatial
Groupware
 
H
HTML Parsers
 
I
IDEs
Installers
Inversion of Control
Issue Tracking
 
J
J2EE Frameworks
JDBC
JMS
JMX
JSP Tag Libraries
Job Schedulers
 
L
Localization
Logging Tools
 
M
Mail Clients
 
N
Network Clients
Network Servers
NoSQL Databases
 
O
Obfuscators
 
P
PDF Libraries
Parser Generators
Persistence
Portals
Profilers
Project Management
 
R
RSS & RDF Tools
Rule Engines
 
S
SQL Clients
Scripting Languages
Search Engines
Security
Source Control
Swing
 
T
Template Engines
Testing Tools
Text Processing
 
U
UML & Modeling
 
V
Validation
 
W
Web Frameworks
Web Mail
Web Servers
Web Services
Web Testing
Wiki Engines
Workflow Engines
 
X
XML Parsers
XML UI Toolkits
 

Open Source Inversion of Control Containers

PicoContainer

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

Go To PicoContainer

Avalon

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

Go To Avalon

NanoContainer

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

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

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

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

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

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

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

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

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

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

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

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

Google Guice

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

Plexus

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

OfficeFloor

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






Java is a trademark or registered trademark of Sun Microsystems, Inc. in the United States and other countries. This site is independent of Sun Microsystems, Inc.