nanocontainer

Lets you configure aspects on components in a {@link org.picocontainer.PicoContainer}. Two kinds of advice are supported, interceptors and mixins. An interceptor is invoked around method calls. Interceptors implement the org.aopalliance.interceptor.MethodInterceptor interface. Mixins allow you to add new methods and behavior to an existing object. You can think of them as a way of dynamically providing multiple inheritance in java. Mixins can be any kind of object; they are not required to extend or implement anything. You can configure aspects in Java, or using groovy. Advice can be configured for all components in a container, using pointcuts, or advice can be applied to just one component. Advice objects may themselves have dependencies on other components, supplied by the container. Currently, dynaop is used to apply the aspects. Other backends may be supported in the future.

Configuring Aspects

    public class LoggingInterceptor implements org.aopalliance.intercept.MethodInterceptor {
        public Object invoke(MethodInvocation invocation) throws Throwable {
            System.out.println("start");
            Object result = invocation.proceed();
            System.out.println("end");
            return result;
        }
    }

Java Configuration

    AspectablePicoContainerFactory containerFactory = new DynaopAspectablePicoContainerFactory();
    AspectablePicoContainer pico = containerFactory.createContainer();
    PointcutsFactory cuts = pico.getPointcutsFactory();
    
    LoggingInterceptor logger = new LoggingInterceptor();
    pico.registerComponentImplementation(Dao.class, DaoImpl.class);
    pico.registerInterceptor(cuts.instancesOf(Dao.class), cuts.allMethods(), logger);

    Dao dao = (Dao) pico.getComponentInstance(Dao.class);
    dao.aMethod(); // will print 'startend'

If we wanted to apply our interceptor to just one component, we could do the following:

    pico.registerComponentImplementation("myDao", DaoImpl.class);
    pico.registerInterceptor(cuts.component("myDao"), cuts.allMethods(), logger);

Container Supplied Advice

    public class LoggingInterceptor {
        private final StringBuffer log;
        
        public LoggingInterceptor(StringBuffer log) {
            this.log = log;
        }
        
        public Object invoke(MethodInvocation invocation) throws Throwable {
            log.append("start");
            Object result = invocation.proceed();
            log.append("end");
            return result;
        }
    }

    // register dependency of LoggingInterceptor:
    pico.registerComponentInstance("log", StringBuffer.log); 
    
    pico.registerComponentImplementation("logger", LoggingInterceptor.class);
    pico.registerComponentImplementation("myDao", DaoImpl.class);

    // you can specify the component key of the advice object:
    pico.registerInterceptor(cuts.component("myDao"), cuts.allMethods(), "logger");

Mixins are a special case. While you can register a mixin as an explicit component in the container, you usually don't want to. Applying the same mixin instance as advice to multiple components would in effect mean that multiple components would share the same base class object - sharing the same instances variables, etc. This is usually not a good thing. However, you may specify a mixin class that has dependencies on components in the container. The container will instantiate a new mixin object for each component that it applies the mixin to, but will satisfy any dependencies the mixin has from components in the container, using constructor injection.

Pointcuts

Groovy Configuration

Limitations

This package contains Groovy scripting support for NanoContainer assembly.

More information about the groovy scripting language may be found at http://groovy.codehaus.org/

This package contains default builder nodes for NanoContainer Groovy script assembly. Each class represents one type of node that will be handled.

The following diagram shows the typical relations in the builder nodes.

In other words:

• GroovyNodeBuilder contains a Map of CustomGroovyNodes that are keyed by CustomGroovyNode.getNodeName(). It uses this map to locate handlers whenever a groovy script node is encountered.
• For each GroovyScriptNode encountered, an attempt to match on a handler is performed. If one is found, then it calls CustomGroovyNode.createNewNode().
• Most (if not all) of the groovy nodes derive from the AbstractCustomBuilderNode that provides services such as attribute placeholding, and default implementation of getNodeName().