modular java with osgi and karaf
DESCRIPTION
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.TRANSCRIPT
Modular Java with OSGi and Karafby Cristiano Costantini and Giuseppe Gerla
Modularity
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
Where to find modularity?
4
There are two facets of Modularity
x Development Model
x Runtime Model
Why modularity?
“Modularity is the best hope to reduce the costs of changes due to
architectural decisions”
5
“to tame complexity”
6
7
Modularity in Java
8
Modularity Patterns
9
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.
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.
Modularity Patterns
12
Dependency Patterns: NO CYCLES!
NO CYCLES!
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 the abstract elements of the module so to improve extensibility and reduce the number of dependencies.
Rely heavily on the use of implementation factories and dependencies injection framework.
Separate abstractions from the classes that implement them in separate modules, so to help eliminate 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.
Let’s open pack 1:
14
Development Model
x Development Model
Let’s open pack 1:
15
Development Model
Let’s open pack 2:
16
Runtime Model
x Runtime Model
Let’s open pack 2:
17
Runtime Model
Karaf
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.
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
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
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
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
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
No WebServices?
Don’t worry: using Camel you can extend an OSGi service with a WebService and more (as we’ll see later).
25
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
Karaf + Camel = ServiceMix
27
+ =
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.
SensorMixAn example of a Java Modular Application
SensorMix
30
External Architecture
SensorMix
31
Internal Architecture
SensorMix
32
Canonical Data Model Bundle
SensorMix
33
Integration Bundle: Camel routes for sensors’ samples
SensorMix
34
Data Service Bundle: persistence of data
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:
Conclusions
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
Modularity is goodFollow Modular PatternsBuild modular java software with MavenRun modular java software with KarafCheck SensorMix for an example
lesson learnt:
