IOC and DI revisited with Nuun

IOC and DI revisited with
Epo Jemba – Kametic
@ejemba
#nuun on freenode https://github.com/nuun-io

IOC and DI revisited with Nuun
Tuesday, 27th june 2017
2/31
Epo Jemba, Freelance
● Software Architect, Developper
● 18 years designing clean softwares
● Fan of DDD and good practices
● Author of Nuun
● Co-Author of Seedstack
– Creator of the Business Framework
( Domain Driven Design with Java )

3/31
What is Nuun ?
● Nuun is a java micro-framework
– For designing enterprise class applications and software stacks
– Is based on the « Inversion of Control » Architectural Pattern
● Compatible with major Dependency Injection frameworks ( Spring, Guice, etc... )
● Nuun relies on standard and proven components
JSR 330 via Guice Dependency Injection
JDK ServiceLoader Discoverability
ronmamo/Reflections Classpath Scanning
All orchestrated by a unique Kernel/Plugin Protocol Extensibility, Uncoupling, Cohesion

4/31
Genesis of Nuun
● When elaborating a software stack for a major client, I found out that the
existing DI framework was limited :
– Lack of explicit Interface driven Injection
– Lack of means to create my own conventions
– … especially in automating binding definition creation,
– Error-prone, refactoring-adverse string identifiers
– Explicit configuration is XML and verbose
– Auto-wiring is concise but slow and not well suited to non-trivial applications
– Lack of Behaviour Delegation

5/31
Why Nuun ?
● We need
– a Clear & Typesafe definition of the « Object Graph » in term of Dependency Injection,
Aspect Oriented Programming, Properties management and more.
– New experience where developer don’t spend any time working on configuration but
applies conventions with sane defaults
– Applications are truly extensible, modules really discoverable,
● « Just add the dependency in the pom, and start working »
● And still understand why and how everything is working ( no magic ! )
– Clean integration of 3rd party framework
– Creation of a sane software ecosystem

6/31
What are Nuun building blocks ?
● a Runner that read Entrypoint class
● META-INF/scan file to easily configure packages to scan
● Two API to configure applications and modules
– Topology API : A nominal API for application developers
– Kernel/Plugin API : A more advanced API and SPI aiming enterprise stack
designers
● Nuun has been designed in enterprise context, thus the Enterprise
API has been designed first.

7/31
Runner Example
public static void main(String[] args) {
NuunRunner.entrypoint(Main.class).execute(args);
}

8/31
Entrypoint Example
// default scan path is the package of the entrypoint
// otherwise explicitely use “packageScan”
@Entrypoint
public class Main implements Runnable {
@Inject @Named("message") // from properties
String message;
@Inject
HelloWorldService helloWorldService;
@Override
public void run() {
System.out.println("inside Main sample message is :n" +
helloWorldService.say(message));
}
}

9/31
Topology API
● Topologies are declarative fragments of configuration in which
developers describe
– Binding Definition
– AOP Interceptor
– Properties handling
– And more
● Topologies are java interfaces, not classes (so no need to unit test)
● Can compare with Spring Config but « Leaner »

10/31
Topology simple example
@Topology(propertySources = "classpath:message.properties")
public interface SampleTopology {
// Definition of a simple constant
@Server // Server is a qualified annotation
String url = “http://nuun.io”;
// Definition of a simple binding Interface and Implementation
InternalHelloWorldService injects(HelloWorldService key);
// Definition of non trivial type as constants
Optional<TranslateService> translateService = Optional.empty();
}

11/31
Topology simple : resulted injections
// Injection of “http://nuun.io”
@Inject @Server
String myglobalUrl;
// Injection of an instance of InternalHelloWorldService
@Inject
HelloWorldService helloWorldService;
// Injection of Optional.empty()
@Inject
Optional<TranslateService> translateService ;

12/31
Topology advanced example
// Definition of a list of string as a constant
List<String> genericList = new ArrayList<>(); // generics
// Definition of constants a qualified constant
@Server
Long port = 8080l;
// Definition of a qualified key for a service
MyService2Impl injectsTwo (@Named("two") MyService key);
// Definition of JSR330 Provider on a MyService2
MyService2Provider provides(MyService2 key);
// Definition of an interceptor using 2 predicates (on class and method)
MyMethodInterceptor intercepts(ClassePredicate pc, MethodPredicateMethodPredicate pm);

13/31
Topology advanced : resulted injections
//new ArrayList<>() will be injected
@Inject
List<String> genericList;
// 8080L will be injected
@Inject @Server
Long port;
// result of the MyService2Provider.get() will be injected
@Inject @Named("two")
MyService key;

14/31
META-INF/scan
● META-INF/scan contains a list of java package to scan.
● We can have many in the classpath, one by jar file
● META-INF/scan is nuun standardization attempt to uncouple
configuration from classpath scan directive.
● In your reusable component, you can define your configuration
in one topology and use META-INF/scan to indicate the kernel
which package to scan.

15/31
Kernel/Plugin API

16/31
Kernel/Plugin API
● The kernel is in charge of providing the object graph of the
application
● For this it relies on plugins by aggregating their configuration
fragments into a global configuration
● The configuration is therefore always dependent on the
application environment

17/31
Kernel/Plugin API

18/31
Kernel usage
//
Kernel kernel = NuunCore.createKernel(
NuunCore.newKernelConfiguration()
.rootPackages(rootFromEntryPoint));
kernel.init(); // creating configuration initializing plugins
kernel.start(); // starting kernel from the configuration just created
// use your application vi the object graph
Injector injector = kernel.objectGraph().as(Injector.class)
// Stopping the kernel to free resources, stop daemons, etc ...
kernel.stop();

19/31
Kernel/Plugin Protocol
Kernel Loading from the
classpath

20/31
Kernel/Plugin
Protocol
Kernel loads plugins via
ServiceLoader

21/31
Kernel/Plugin
Protocol
Plugins send their
requests to the kernel

22/31
Kernel/Plugin
Protocol
Kernel scans classpath
according to plugins
requests

23/31
Kernel/Plugin
Protocol
Kernel returns its
results to each plugin

24/31
Kernel/Plugin
Protocol
From its result each
plugin build its dynamic
configuration

25/31
Kernel/Plugin
Protocol
Each plugin returns its
created configuration to
the kernel

26/31
Kernel/Plugin
Protocol
Kernel builds the Global
Configuration and create
the associated injector

27/31
Kernel/Plugin
Protocol
The resulting injector
is then tailored for the
application object
graph.

28/31
Deterministic Runtime Algorithm
● This process occurs at the beginning of the application only
once and lasts less than 200 ms
● Plugins can communicate and may have dependencies. The
resulting global configuration is of the most adapted
● This protocol brings an adaptive, resilient configuration system

29/31
Enterprise API
● API
– Kernel Lifecycle
– Kernel parameters
– Kernel Listener
– Plugin Lifecycle
– Request API
– Plugin Dependencies
– Integration Tests
– Etc …
–
● SPI
– Plugin Definition
– Dependency Inject° Providers
– Concerns
– Multi-Round initialization
– Kernel Extensions
– Kernel params aliases
– Etc …

30/31
Roadmap : Toward 1.0
● First github commit was in november 2012
● 10 Milestones Version
● Nuun is used by Seedstack
● Nuun is stable and used in production since 2013.
● 2017 : Nuun is a OW2 Project o/
● Toward 1.0
– Finalizing « Topology API »
– Finalizing « Request API »
– Finalizing « Concern API »
– Documentation, Blogs & Samples on http://nuun.io

31/31
Questions [and Demo]
● Thank you for your attention !
● https://github.com/nuun-io/kernel
● http://nuun.io
● Professional support on nuun and seedstack
– epo.jemba@kametic.com

IOC and DI revisited with Nuun

Recommended

Recommended

More Related Content

Similar to IOC and DI revisited with Nuun

Similar to IOC and DI revisited with Nuun (20)

Recently uploaded

Recently uploaded (20)

IOC and DI revisited with Nuun