Java 9 modularity+
0 likes79 views
This document discusses Java 9 modules and modularity. It begins by defining what a module is - a deployable, manageable, reusable unit of software with a concise interface. Modules must adhere to strong encapsulation, well-defined interfaces, and explicit dependencies. It then compares modules to microservices, noting advantages and disadvantages of each approach. The document outlines problems with monolithic Java applications and how modules address issues like classpath hell, version conflicts, and security. It provides examples of module systems like OSGi and Java 9's Project Jigsaw. Finally, it explains the new modular structure of the JDK/JRE in Java 9 and key aspects of module definition like requires, exports, and provides.
![Module Definition
<open> module <module-name> {
[export <java package> [to <module name>]
[requires [transitive] <module-name>]
[opens <module name> [to <module name]]
[provides <interface> with <implementation>]
[uses <interface>]
}](https://image.slidesharecdn.com/java9modularity-190428163233/85/Java-9-modularity-17-320.jpg)
Java 9 modularity+
- 1. Java 9 Modularity + Ivelin Yanev
- 2. What is modular architecture? https://www.nasa.gov/mission_pages/station/structure/elements/space-station-assembly
- 3. What is a module? “deployable, manageable, natively reusable, composable, stateless unit of software that provides a concise interface to consumers” - Kirkk Knoerchild https://en.wikipedia.org/wiki/Harmony_(ISS_module)
- 4. Modules must adhere to three core tenets ● Strong encapsulation - encapsulated code may change freely without affecting users of the module. ● Well-defined interfaces - modules have to work together. ● Explicit dependencies - it provides the basis for a reliable configuration of modules.
- 5. Modules vs. microservices “Microservices are small, autonomous services that work together” Advantages: ❏ Independent development ❏ Failure isolation ❏ Independent choice of technology ❏ Ease of deployment ❏ Easy to understand ❏ ……….
- 6. Modules vs. microservices Disadvantages: ❏ Testing problem ❏ Network communication can affect stability ❏ Refactoring is not easy ❏ Difficult to find systematic problems ❏ Service synchronization ❏ Complexity of managing a large number of services
- 8. Problem with monolithic Java http://openjdk.java.net/projects/jigsaw/doc/jdk-modularization.htm
- 9. Problem with monolithic Java ● The first major release of the JDK had a little over 500 public classes. ● JDK 8 has 4,200 public classes and over 20,000 total files. ● rt.jar is more than 60 megabytes. “Java on small devices”
- 10. Classpath Hell ● Unexpressed Dependencies ● Version Conflicts ● Complex Class Loading
- 11. More problems... ● Internal APIs - sun.* and jdk.internal.* ● Cyclic dependencies ● Legacy classes - CORBA ● Startup Performance ● Security
- 12. Module systems ● OSGi - Open Services Gateway initiative ● Java 9 - Project Jigsaw(JPMS) Strong encapsulation Well-defined interfaces Explicit dependencies
- 13. Module systems
- 15. Change Of JDK/JRE Binary Structure In Java 8 the rt.jar measures close to 60 MB in size https://www.developer.com/java/java-9-structural-changes-in-the-jdk-a nd-jre.html
- 16. The java.base module java.base java.lang java.io java.net java.util com.sun.crypto.provider sun.nio.ch sun.reflect.annotation sun.security.provider ● Exports: the list of all the packages exported by the module ● Contains: this is the list of internal packages ● Requires: this is the list of modules that a given module requires
- 17. Module Definition <open> module <module-name> { [export <java package> [to <module name>] [requires [transitive] <module-name>] [opens <module name> [to <module name]] [provides <interface> with <implementation>] [uses <interface>] }
- 18. Module Meta Data ● Module names must be unique ● Requires- indicates that this module depends on another module
- 19. Module Meta Data ● Requires Static - this is an optional dependency. The module is needed at compile time, but not at runtime.
- 20. Module Meta Data ● Requires Transitive - this means that any module that reads your module implicitly also reads the transitive module.
- 21. Module Meta Data ● Exports - by default, a module doesn’t expose any of its API to other modules. ● Exports …. To - we can restrict which modules have access to our APIs.
- 22. Module Meta Data ● Uses - our module consumes the current service. ● Provides … With
- 23. The problem of coupling Service Registry Provider Module Consumer Module Register Service LookUp Service Return Service Instance
- 24. Demo