Modularity is the art of breaking a large system into parts that are easier to understand than the ‘monolithic’ whole. Failing to achieve the right degree of modularity may lead to development of code that is hard to reuse and to maintain, and when you are working in a team this has a bigger impact on the costs. The complexity of dealing successfully with modularity is mostly addressed during design, when understanding and planning the dependencies and the behavior of a module, but a good application framework can influence positively toward the right direction by providing a natural environment where to apply good architecture modularity patterns. And OSGi, with its service oriented philosophy and the ecosystem of related tools, where the modules have clear boundaries which coincide with those of ‘Bundles’, it provides such inspiring environment. During the talk we will illustrate a concrete example of an OSGi project, built with Maven and M2E and running into Apache Karaf. Rather than focusing on the details of technologies, we will put emphasis on the experience of Java modularity so to give a feel of how this platform can help, and allow you to evaluate if this platform can be helpful for your next project and ambitions.

1. Modular Java
with OSGi and Karaf
by Cristiano Costantini and Giuseppe Gerla

2. Modularity

3. What does “module” means?
“A software module is a deployable,
manageable, natively reusable, composable,
stateless unit of software that provides a
concise interface to consumers”
Deployable: modules are unit of deployment.
Manageable: modules are unit of management.
Natively Reusable: modules are a unit of intraprocess reuse.
Composable: modules are a unit of composition.
Stateless: modules are stateless (*running software from a module has a state).
Testability: modules are a unit of testability.
uhm… the JAR file!
3

4. Where to find modularity?
4
There are two facets of Modularity
x Development
Model
x Runtime
Model

5. Why modularity?
“Modularity is the best hope to
reduce the costs of changes due to
architectural decisions”
5
“to tame complexity”

6. 6

7. 7

8. Modularity in Java
8

9. Modularity Patterns
9

10. Modularity Patterns
10
Base Patterns
Base patterns advise to
design and manage
relationships between
modules, that you have
to emphasize
reusability at software
module level, and that
modules shall be
cohesive and have a
behavior that serves a
singular purpose.

11. Modularity Patterns
11
Dependency Patterns
Dependency patterns
teach you that there must
be no cycles between
modules, that should be
organized in levels and
in physical layers. And
that a module should be
independent from the
runtime container and
deployable
independently from
other modules.

12. Modularity Patterns
12
Dependency Patterns: NO CYCLES!
NO CYCLES!

13. Modularity Patterns
13
Usability, Extensibility, Utility Patterns
The modules shall have a
public interface that is well
known.
Modules are configured
externally.
For improving usability,
create a façade serving as a
coarse-grained entry point
to another fine-grained
module.
Restricted dependency to theabstract elements of the moduleso to improve extensibility andreduce the number of
dependencies.
Rely heavily on the use of
implementation factories anddependencies injection
framework.
Separate abstractions from theclasses that implement them inseparate modules, so to helpeliminate module relationships.
Perform a levelized build,
repeatable build of the
modules. This has positive
effect on the lifecycle of
software development as a
levelized build integrate
testing that require to
integrate early and often,
which guarantees a system
health always in a good
status.
Modules should have a test
module.

14. Let’s open pack 1:
14
Development Model
x Development
Model

15. Let’s open pack 1:
15
Development Model

16. Let’s open pack 2:
16
Runtime Model
x Runtime
Model

17. Let’s open pack 2:
17
Runtime Model

18. Karaf

19. Karaf: an OSGi container
Karaf is a small OSGi based runtime which provides a
lightweight container onto which various components and
applications can be deployed.
19
Apache Karaf can trace it's origins back to the Apache
ServiceMix project's Kernel.

20. Karaf: what is it in detail?
Karaf is a platform that
allow you to deploy your
application.
You can install/uninstall/
start/stop your application
in several easy way.
You can replace/update it
and you can change its
configuration on the fly.
20

21. Karaf: what is an application?
An application is a
composition of
modules.
Each module can
depend from other
modules of
application or from
other module of the
container.
21

22. Karaf: what is a module?
A module is a bundle
Bundle is a Jar with a
Manifest richer than that one
We can develop a bundle
using Eclipse and Maven
22

23. Karaf: how a bundle interact?
Each bundle can registers one or more service.
Each service can be retrieved by other bundle.
Each service can obtain the reference of other services.
23

24. Karaf: What is a service?
We can define a service using the SOA definition.
“A Service is a self-contained unit of
functionality”
Caution: service in OSGi is NOT a WebService but it is an
intra-JVM service.
24

25. No WebServices?
Don’t worry: using Camel you can extend an OSGi service
with a WebService and more (as we’ll see later).
25

26. Karaf & Spring
Karaf has its own Dependency Injection API: Blueprint
Blueprint is a standard defined in OSGi that allow bean
definition, service definition and dependency injection
Using Spring Dynamic Module we can also use Spring in
Karaf.
SpringDM explores bundles and load Spring xml files
Spring DM allows you to interact with the world without using
OSGi API in our code: in this way the code is cleaner and
classes that we write (our modules) can be reused on other
platforms.
26

27. Karaf + Camel = ServiceMix
27
+ =

28. Karaf & Web
28
Pax Web allows Karaf to support web. Using integrated Web
Server Jetty, it implements:
-HTTP Service API defined in OSGi
-Web Application API defined in OSGi Enterprise
Like Spring DM, Pax Web explores Bundles installed in Karaf
to find web.xml files.
When it finds ithe filet, Pax Web starts application by creating
servlets,filters and initializing servlet context defined in web
deployment descriptor.

29. SensorMix
An example of a Java Modular Application

30. SensorMix
30
External Architecture

31. SensorMix
31
Internal Architecture

32. SensorMix
32
Canonical Data Model Bundle

33. SensorMix
33
Integration Bundle: Camel routes for sensors’ samples

34. SensorMix
34
Data Service Bundle: persistence of data

35. SensorMix
Slides:
http://cristcost.github.io/sensormix/
Sensormix:
https://github.com/cristcost/sensormix/
Sensormix Android:
https://github.com/cristcost/sensormix-android/
Sensormix Arduino:
https://github.com/michelefi/sensormix-arduino/
35
Links:

36. Conclusions

37. Books
• “Java Application Architecture: Modularity Patterns with
Examples Using OSGi”, Kirk Knoernschild - Prentice Hall
• “Spring DM in Action”, A. Cogoluègnes, T. Templier, A.
Piper - Manning
• “OSGi in Action”, R. S. Hall, K. Pauls, S. McCulloch, D.
Savage - Manning
• “OSGi In depth”, Alexandre de Castro Alves - Manning
• “Enterprise Integration Patterns”, G. Hohpe, B. Woolf -
Addison Wesley
• “Camel in Action”, C. Ibsen, J. Anstey - Manning
37

38. Modularity is good
Follow Modular Patterns
Build modular java software with Maven
Run modular java software with Karaf
Check SensorMix for an example
lesson learnt:

39. Giuseppe Gerla
giuseppe.gerla@gmail.com
Cristiano Costantini
cristiano.costantini@gmail.com