Java9新特性中的模块化详解

目录
  • 模块化是什么?
  • 那么,模块化怎么用呢?
  • 为什么要用模块化
    • 显式管理依赖:
    • 强封装性:
    • 安全性:
    • 规范性:
    • 自定义最小运行时映像:
    • 孵化器模块的支持:

Java9中的一个重大特性是增加了一种新型的程序设计组件 - 模块。

官方对模块的定义为:一个被命名的,代码和数据的自描述集合。( the module, which is a named, self-describing collection of code and data)。

这个在Java7的时候就已经被提出,但由于其复杂性,不断跳票Java7、Java8,直到Java9才姗姗来迟的模块化,到底是什么,在实际coding中又有什么用呢?

我们主要从以下三个方面来分析:

  1. What 模块化是什么
  2. How 模块化怎么用

Why 为什么要用模块化

模块化是什么?

模块是Java9中新增的一个组件,可以简单理解为是package的上级容器,是多个package的集合,一个jar可以有多个module,一个module可以有多个package。从代码结构上看,jar > module > package > class, interface。

Java9的模块通过requires和exports关键字,对自身所依赖(requires)的模块和自身暴露(exports)出去的内容(package)进行了声明。本模块只能使用其他模块暴露(exports)出来的内容(package),其他模块也只能使用本模块暴露(exports)出去的内容(package)。

Java9的模块化和Maven的区别在于Maven管理的是整个jar的依赖,关注的是整体。而模块化管理的是这个jar中的模块需要对外暴露的内容和对外依赖的模块,关注的是细节。maven的依赖是将整个jar都给你了,哪怕你仅仅只需要其中的一个类。模块化的依赖则是更细粒度的package的管理,你只能使用你依赖的模块下被暴露出来的package。

那么,模块化怎么用呢?

我们搭建一个简单的modular-demo项目,分为modular-common,modular-persistent,modular-service,modular-web 4个子项目。

4个子项目的定位为:

modular-common:通用层,主要提供常量类、工具类、枚举类等通用代码。

modular-persistent:持久层,主要提供数据库领域实体domain类,数据操作接口dao。

modular-service:service层,主要提供业务逻辑处理的service及其实现类。

modular-web:web层,主要对外提供api接口,视图渲染,输入输出数据处理等功能。

4个子项目的maven依赖关系为:

modular-persistent依赖modular-common

modular-service依赖modular-persistent

modular-web依赖modular-service

每个项目的代码大致如下:

与传统Maven项目不同的是,每个子项目下面都有着自己的module-info.java,里面声明了项目中的模块暴露出去的包和需要依赖的模块。

注意:我们提到的模块均是指Java9中的模块,不是指maven中的模块,maven中的模块是指可以构建为一个jar或者war的项目,本质是一个项目,所以我们用子项目来表示maven中的模块。每个子项目可以有多个模块,demo中每个子项目只包含了一个模块,但不代表只能有一个模块。

common模块的module-info.java

module modular.demo.common {
    // 声明自己对外暴露的包名
    exports com.hanmc.example.modulardemo.common;
}

module 后面的modular.demo.common声明了本模块的模块名,是本模块的唯一标识,其它模块可以通过这个标识来声明对这个模块的依赖。

exports com.hanmc.example.modulardemo.common 声明了本模块暴露出去的package,如果所有package都没有暴露,那么其他模块即使依赖了这个模块,也依然无法使用此模块中的代码。

persistent模块的module-info.java

module modular.demo.persistent {
    exports com.hanmc.example.modulardemo.persistent.domain;
    exports com.hanmc.example.modulardemo.persistent.dao;
    //声明需要依赖的模块
    requires modular.demo.common;
    requires mybatis.plus;
    requires mybatis.plus.core;
    requires mybatis.plus.annotation;
}

将domain和dao两个package暴露出去,同时声明了对modular-common和mybatis-plus框架中的模块的依赖。

service模块的module-info.java

module modular.demo.service {
    exports com.hanmc.example.modulardemo.service;
    exports com.hanmc.example.modulardemo.service.impl;
    requires modular.demo.persistent;
    requires spring.context;
    requires spring.beans;
}

将service这个package暴露出去,同时声明了对modular-persistent和spring框架中模块的依赖。

注意:modular-service模块只暴露了com.hanmc.example.modulardemo.service这个package,并没有暴露com.hanmc.example.modulardemo.service.impl这个包,所以外部是无法使用service接口的实现类的,只能通过service接口来调用,对于使用者来说隐藏了具体的实现。

web模块的module-info.java

module modular.demo.web {
    requires spring.web;
    requires spring.beans;
    requires spring.boot;
    requires modular.demo.service;
    requires modular.demo.persistent;
    requires modular.demo.common;
    requires org.mybatis.spring;
    requires spring.boot.autoconfigure;
    //声明com.hanmc.example.modulardemo包对spring开放,允许spring在运行期间通过反射机制访问其代码
    opens com.hanmc.example.modulardemo to spring.core, spring.beans, spring.boot, spring.context, spring.web;
}

声明了对spring框架和modular-common、modular-persistent、modular-service的模块的依赖。同时将com.hanmc.example.modulardemo的package开放给spring的模块使用,以便spring在启动时通过反射机制访问项目中的代码来初始化容器。

注意: exports和opens的区别在于,exports导出的包可以在编译和runtime期间访问其public成员。opens声明的包,则还可以在运行期间通过反射来访问其public和private成员。

为什么要用模块化

那么,为什么要用模块化呢,使用模块化有什么好处呢?看起来代码的编写反而更为复杂了!

显式管理依赖:

每个模块需要显式声明自己需暴露的包,而自己所依赖的和自己内部使用的包,则不会暴露,也不会被外部引用到。这种机制彻底的杜绝了Java9以前Jar包依赖买一送一堆的场景,大大的减少Jar包冲突的情况。

场景:比如我的项目中本身已经依赖了hibernate-validator用来做参数校验,在后续的开发中由于加解密需要又引入了一个提供了加解密api的第三方的jar,这个第三方jar也依赖了另外一个版本hibernate-validator,那么在项目中就存在了两个不同版本的hibernate-validator,这个时候就会出现jar包冲突。这个时候模块化就可以完美解决这个问题,这个第三方加解密的jar可以在module-info.java中只exports出本身加解密功能的部分package,而不会exports出这个jar本身所依赖的其他jar包。

强封装性:

模块显式的选择向其他模块只暴露需要的类或接口,而完美的隐藏了内部实现的细节及其他内部成员,实现了真正的封装。

场景:比如下图module-common中的枚举类DefaultResponseEnum,定义了系统内置的几种默认响应码,因为被定义在了inner包中,而inner包又没有被声明exports,所以这个枚举类只能在module-common内部使用,避免了被其他模块直接使用。

安全性:

显式依赖管理及强封装性,大大的减少了程序运行时不必要模块的加载,减少了Java运行期间的被攻击面。代码真正意义上可以按照作者的设计思路进行公开和隐藏,限制了反射的滥用,更好的保护了那些不建议被外部直接使用或过时的内部类。

规范性:

显示的声明暴露的内容,可以让第三方库的开发者更好的管理自己的内部实现逻辑和内部类。第三方库作者可以更轻松的管理自己的内部类的访问权限和反射调用权限,避免了出现sun.misc.BASE64Encoder这些内部类在已经被官方声明了过时和不建议使用的前提下,仍有大量的开发者去随意使用的情况。因为在Java9之前,JDK开发者只能建议,而无法实现强制约束。

场景:比如我们提倡的面向接口编程,要求在controller中只能注入service层的接口,而不能直接注入其实现类,但是这个要求只是个规范,无法强制约束,Java9以前,我们仍然可以在直接注入service层的实现类,代码仍然可以照常运行,只是没那么规范而已。但是在Java9以后,我们可以在service的模块中只exports出接口,这样controller就无法直接注入实现类,在编译期就会报错,实现了强约束。

自定义最小运行时映像:

Java因为其向后兼容的原则,不会轻易对其内容进行删除,包含的陈旧过时的技术也越来越多,导致JDK变得越来越臃肿。而Java9的显示依赖管理使得加载最小所需模块成为了可能,我们可以选择只加载必须的JDK模块,抛弃如java.awt, javax.swing, java.applet等这些用不到的模块。这种机制,大大的减少了运行Java环境所需要的内存资源,在对于嵌入式系统开发或其他硬件资源受限的场景下的开发非常有用。

孵化器模块的支持:

Java9中,引入了孵化器模块,使用了固定的前缀jdk. incubator。孵化器模块是一种提供实验API的机制,相当于是beta版,其中的内容在后续的版本中可能会被改动或删除。这个机制的存在,可以让开发者在明确的知道其不稳定性的同时,如果感兴趣的话,可以尝试提前接触和使用这些实验性的功能,使得这个新功能可以在真实环境中不断打磨完善。

场景:如Java9中提供的jdk. incubator.httpclient模块,提供了一个全新的HttpClient API,并且在Java11中孵化为正式模式 java.net.http,提供了高性能的异步非阻塞调用支持。

到此这篇关于Java9新特性中的模块化到底是什么的文章就介绍到这了,更多相关Java9模块化内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java9新特性Module模块化编程示例演绎

    目录 一.什么是Javamodule? 二.模块导出package 三.模块导入package 四.Javamodule的意义 五.实例 第一个模块 第二个模块 尝试使用未被exports的package代码 我计划在后续的一段时间内,写一系列关于java 9的文章,虽然java 9 不像Java 8或者Java 11那样的核心java版本,但是还是有很多的特性值得关注.期待您能关注我,我将把java 9 写成一系列的文章,大概十篇左右,本文是第8篇. 在Java 9版本中Java 语言引入了一

  • java9学习笔记之模块化详解

    前言 截止到目前JDK的版本已经更新到10了,虽然java9的生命周期才半年,但是我认为这个版本带来的变革是不可磨灭的,它是第一次深层次的针对架构以及依赖上的革新.下面我们就来学习一下. 模块化的功能有几个目的: 让Java的SE程序更加容易轻量级部署 改进组件间的依赖管理,引入比Jar粒度更大的Module 改进性能和安全性 如果用更加简单解释,那就是"解决Classpath地狱问题,改进部署能力".Module的内容比较多,为了由浅入深,我按照一些问题和我的理解来介绍模块化. 一.

  • Java9新特性中的模块化详解

    目录 模块化是什么? 那么,模块化怎么用呢? 为什么要用模块化 显式管理依赖: 强封装性: 安全性: 规范性: 自定义最小运行时映像: 孵化器模块的支持: Java9中的一个重大特性是增加了一种新型的程序设计组件 - 模块. 官方对模块的定义为:一个被命名的,代码和数据的自描述集合.( the module, which is a named, self-describing collection of code and data). 这个在Java7的时候就已经被提出,但由于其复杂性,不断跳票

  • Java8新特性Stream流实例详解

    什么是Stream流? Stream流是数据渠道,用于操作数据源(集合.数组等)所生成的元素序列. Stream的优点:声明性,可复合,可并行.这三个特性使得stream操作更简洁,更灵活,更高效. Stream的操作有两个特点:可以多个操作链接起来运行,内部迭代. Stream可分为并行流与串行流,Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换.串行流就不必再细说了,并行流主要是为了为了适应目前多核机器的时代,提高系统CP

  • Java8 新特性Lambda表达式实例详解

    Java8 新特性Lambda表达式实例详解 在介绍Lambda表达式之前,我们先来看只有单个方法的Interface(通常我们称之为回调接口): public interface OnClickListener { void onClick(View v); } 我们是这样使用它的: button.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { v.setText("

  • C#语法新特性之元组实例详解

    1.元组(Tuple) 元组(Tuple)在4.0 的时候就有了,但元组也有些缺点,如: 1)Tuple 会影响代码的可读性,因为它的属性名都是:Item1,Item2.. . 2)Tuple 还不够轻量级,因为它是引用类型(Class),对于一个变量要使用一个类型,有点太没必要了. 源代码如下: // 摘要: // 提供用于创造元组对象的静态方法.若要浏览此类型的.NET Framework 源代码,请参阅 Reference Source. public static class Tuple

  • c++11 新特性——智能指针使用详解

    c++11添加了新的智能指针,unique_ptr.shared_ptr和weak_ptr,同时也将auto_ptr置为废弃(deprecated). 但是在实际的使用过程中,很多人都会有这样的问题: 不知道三种智能指针的具体使用场景 无脑只使用shared_ptr 认为应该禁用raw pointer(裸指针,即Widget*这种形式),全部使用智能指针 初始化方法 class A { public: A(int size){ this->size = size; } A(){} void Sh

  • ES9的新特性之正则表达式RegExp详解

    简介 正则表达式是我们做数据匹配的时候常用的一种工具,虽然正则表达式的语法并不复杂,但是如果多种语法组合起来会给人一种无从下手的感觉. 于是正则表达式成了程序员的噩梦.今天我们来看一下如何在ES9中玩转正则表达式. Numbered capture groups 我们知道正则表达式可以分组,分组是用括号来表示的,如果想要获取到分组的值,那么就叫做capture groups. 通常来说,我们是通过序号来访问capture groups的,这叫做Numbered capture groups. 举

  • Go1.18新特性对泛型支持详解

    目录 1.泛型是什么 2.泛型类型的定义 2.1.声明一个自定义类型 2.2.内置的泛型类型any和comparable 2.3.泛型中的~符号是什么 1.泛型是什么 Go1.18增加了对泛型的支持,泛型是一种独立于使用的特定类型编写代码的方式.现在可以编写函数和类型适用于一组类型集合的任何一种.泛型生命周期只在编译期,旨在开发中减少重复代码的编写. 由于go属于静态强类型语言,例如在比较两个数的大小时,没有泛型的时候,仅仅只是传入类型不一样,我们就要再复制一份一样的函数,如果有了泛型就可以减少

  • Java8新特性之Stream API详解

    一.前言 StreamAPI在Java8版本中使用,关注的是对数据的筛选.查找.存储等 它可以做的事情有:过滤.排序.映射.归约 二.使用流程 Stream实例化中间操作(过滤.排序.映射.规约)终止操作(匹配查找.归约.收集) 三.案例演示 public class EmployeeData { public static List<Employee> getEmployees(){ List<Employee> list = new ArrayList<>(); l

  • Java 8 新特性终极版指南详解

    前言: Java 8已经公布有一段时间了,种种迹象表明Java 8是一个有重大改变的发行版.在Java Code Geeks上已经有很多介绍Java 8新特性的文章,例如Playing with Java 8 – Lambdas and Concurrency.Java 8 Date Time API Tutorial : LocalDateTime和Abstract Class Versus Interface in the JDK 8 Era.本文还参考了一些其他资料,例如:15 Must

  • Java 8新特性 内建函数式接口详解

    Java 8新特性内建函数式接口 在之前的一片博文 Lambda 表达式,提到过Java 8提供的函数式接口.在此文中,将介绍一下Java 8四个最基本的函数式接口 对于方法的引用,严格来讲都需要定义一个接口.不管我们如何操作实际上有可能操作的接口只有四种. Java 8 提供了函数式接口包java.util.function.*,在该包下有许多Java 8内建的函数式接口.不过基本上分为四种基本的: 功能型接口 (Function) 将 T 作为输入,返回 R 作为输出,他还包含了和其他函数组

随机推荐