User Documentation

One minute description
Two minute tutorial
Five minute introduction
Advanced Topics
FAQ
Container
Components
Terminology
Mock Objects
Inversion of Control Types

Patterns

Inversion of Control 
Dependency Injection 
Constructor Injection 
Setter Injection 
Interface Implementation Separation 
Lifecycle 
Antipatterns

Developer Documentation

 Current build status
How To Contribute
Relative Volunteering
Release Process

Project Information

Slogan
Mailing lists
Source Repositories
Open Issues
Blog entries 
Statistics
Team
Sister Projects
TShirts

Miscellaneous

Differentiators
Nirvana

Full Sitemap

Feeds


Site
News
Two minute tutorial

Authors: Jon Tirsen

This very short tutorial should get you up to speed with PicoContainer in 2 minutes. It does not go into why you should do it, read the Five minute introduction for that.

Download and install

Download the jar file and include it in your classpath.

Write two simple components

public class Boy {
    public void kiss(Object kisser) {
        System.out.println("I was kissed by " + kisser);
    }
}
public class Girl {
    Boy boy;

    public Girl(Boy boy) {
        this.boy = boy;
    }

    public void kissSomeone() {
        boy.kiss(this);
    }
}

Assemble components

MutablePicoContainer pico = new DefaultPicoContainer();
pico.registerComponentImplementation(Boy.class);
pico.registerComponentImplementation(Girl.class);
 MutablePicoContainer API

Instantiate and use component

Girl girl = (Girl) pico.getComponentInstance(Girl.class);
girl.kissSomeone();
getComponentInstance will look at the Girl class and determine that it needs to create a Boy instance and pass that into the constructor to create a Girl. The Boy is created and then the Girl.

 PicoContainer API

The Girl does not reach out to find herself a Boy but instead is provided one by the container. This is called the Hollywood Principle or "Don't call us we'll call you".

Introduce an interface for the dependency

Change the Boy class to implement a Kissable interface and change the Girl class to depend on Kissable instead.

public interface Kissable {
    void kiss(Object kisser);
}
public class Boy implements Kissable {
    public void kiss(Object kisser) {
        System.out.println("I was kissed by " + kisser);
    }
}


public class Girl {
    Kissable kissable;

    public Girl(Kissable kissable) {
        this.kissable = kissable;
    }

    public void kissSomeone() {
        kissable.kiss(this);
    }
}

Assemble and use components just as before:

MutablePicoContainer pico = new DefaultPicoContainer();
pico.registerComponentImplementation(Boy.class);
pico.registerComponentImplementation(Girl.class);
Now run:
Girl girl = (Girl) pico.getComponentInstance(Girl.class);
girl.kissSomeone();

The Girl will be given a Boy, because PicoContainer understands that it is a Kissable

The Girl and the Boy no longer depend on each other, this is called the Dependency Inversion Principle since both components depend on the interface and no longer directly on each other.

Use simple lifecycle

Change the Girl class to implement the simple default lifecycle and do it's kissing when the container is started.

public class Girl implements Startable {
    Kissable kissable;

    public Girl(Kissable kissable) {
        this.kissable = kissable;
    }

    public void start() {
        kissable.kiss(this);
    }

    public void stop() {
    }
}

Assemble container as before but instead of calling the Girl directly just start the container like this:

pico.start();

This will instantiate all components that implement Startable and call the start method on each of them. To stop and dispose the container do as follows:

pico.stop();
pico.dispose();
Startable API

Disposable API

Next: Five minute introduction