Petite

Petite is one great little IoC container and components manager. Petite is easy to use since it requires no external configuration; it is incredibly fast, lightweight and super-small; so anyone can quickly grasp how it works. Petite is quite extensible and open for customization; and non-invasive.

Quick Overview

The following bean shows some basic Petite usage:

    @PetiteBean
    public class Foo {

        // dependency injected in the ctor
        @PetiteInject
        public Foo(ServiceOne one) {...}

        // dependency injected in a field
        @PetiteInject("serviceTwo")
        ServiceTwo two;

        // dependency injected with the method
        @PetiteInject
        public void injectService(ServiceThree three) {...}

        // dependency injected with the method
        public void injectService(
            @PetiteInject ServiceFour four) {...}

        // initialization method
        @PetiteInitMethod
        public void init() {...}

        public void foo() {
        }
    }

Foo is Petite bean that defines several injection points, for different depending services from the container. Put this bean in the classpath and let PetiteContainer find it and register as a bean. Or register it manually if you like that way more.

Why should I use it?

Petite is one of the lightest Java DI container around. Still, it supports sufficient most of features offered by other containers.

Here are the key features:

• property, method and constructor injection points.
• Instance life-cycle management, ordered initialization methods.
• Adding external objects to container.
• Wiring external objects with container's context.
• Creating objects by container.
• Automatic registration: no XML or code needed, just annotations.
• Programmatic configuration: using plain Java.
• Scopes: Prototype, Singleton and custom scopes.
• Thread local scope for thread singletons.
• HTTP session scope for session singletons.
• Designed to be extended.