别再误用requires了!requires transitive的正确打开方式曝光

第一章:模块化系统的基石——理解requires transitive的本质

在Java 9引入的模块系统中,requires transitive 是构建可维护、可扩展模块依赖关系的关键机制。它不仅声明了当前模块对另一模块的依赖,还将该依赖“暴露”给所有依赖当前模块的下游模块。

transitive关键字的作用

当一个模块使用 requires transitive 声明依赖时,任何读取该模块的其他模块将自动读取被标记为 transitive 的模块,无需显式声明。这种传递性在构建公共API层时尤为重要。 例如,假设模块 com.example.library 使用了 java.logging 并将其作为公共API的一部分暴露:

module com.example.library {
    requires transitive java.logging;
}
此时,若模块 com.example.application 依赖 com.example.library:

module com.example.application {
    requires com.example.library; // 自动获得对 java.logging 的读取权限
}

何时使用requires transitive

  • 当你的模块封装了一个API,并在公开方法签名中使用了依赖模块的类型
  • 当你希望下游模块无需重复声明基础公共依赖(如日志、序列化等)
  • 避免在多个层级重复编写相同的 requires 语句,提升模块复用性
场景应使用原因
内部工具类使用依赖requires不对外暴露类型,无需传递
公共接口返回第三方类型requires transitive调用方需理解返回类型
graph LR A[Module A] -->|requires transitive B| B[Module B] B --> C[Module C] D[Module D] --> A D --> B %% 因为A的transitive依赖,D自动读取B

第二章:requires transitive的核心机制解析

2.1 模块导出与依赖传递的底层原理

在现代构建系统中,模块导出不仅仅是暴露接口,更涉及依赖关系的精确传递。当一个模块声明导出时,构建工具会解析其依赖图谱,并将必要的编译信息嵌入元数据中。
依赖传递机制
模块间的依赖通过符号表进行映射,每个导出符号关联其依赖链。构建系统利用该信息按需加载并链接依赖项。
// 示例:Go 中的导出函数及其依赖
package mathutil

import "fmt"

func Add(a, b int) int {
    log(fmt.Sprintf("Add called with %d, %d", a, b))
    return a + b
}

func log(msg string) {
    fmt.Println("[LOG]", msg)
}
上述代码中,Add 是导出函数,依赖非导出函数 log 和外部包 fmt。构建系统在导出 Add 时,自动包含 fmt 的依赖信息,但不暴露 log。
依赖解析流程

源码 → 抽象语法树(AST) → 符号解析 → 依赖收集 → 元数据生成

阶段处理内容
符号解析识别导出标识符
依赖收集追踪 import 及内部调用

2.2 requires与requires transitive的语义差异剖析

在Java模块系统中,requires和requires transitive用于声明模块间的依赖关系,但语义存在关键区别。
基本语义对比
  • requires:当前模块使用另一个模块,但不对外暴露该依赖;
  • requires transitive:当前模块不仅使用该依赖,还将此依赖“传递”给所有依赖本模块的模块。
代码示例与分析
module library.api {
    requires java.logging;
    requires transitive com.fasterxml.jackson.core;
}
上述代码中,任何使用library.api的模块将自动可访问Jackson核心库(因transitive),但不会自动获得java.logging的访问权限。
依赖传递性对比表
指令本模块可访问下游模块可访问
requires M是否
requires transitive M是是

2.3 编译期与运行时的依赖可视性行为对比

在模块化开发中,编译期与运行时的依赖可视性存在本质差异。编译期依赖由编译器静态解析,决定了符号是否可访问;而运行时依赖则影响类加载和实例化过程。
编译期依赖示例

// 模块A声明依赖模块B
requires com.example.moduleB;
该语句在编译阶段启用对模块B中导出包的访问权限,若未声明,则无法通过编译。
运行时依赖行为
  • 即使模块在编译期可见,若运行时未提供对应模块,将抛出NoClassDefFoundError
  • 模块路径(--module-path)决定运行时可用模块集
关键区别总结
维度编译期运行时
依赖检查静态解析符号引用动态加载类与初始化
缺失后果编译失败运行时异常

2.4 使用javap和jdeps工具验证传递性依赖

在Java模块化开发中,准确识别类路径上的依赖关系至关重要。`javap`和`jdeps`是JDK自带的静态分析工具,可用于深入剖析字节码和依赖结构。
使用 javap 查看类的依赖信息
通过`javap -verbose`可查看类的常量池与引用类型,识别直接依赖:
javap -verbose com.example.ServiceClass
输出中`Constant pool`部分会列出所有被引用的类,包括来自第三方库的类型,有助于发现隐式依赖。
使用 jdeps 分析传递性依赖
`jdeps`能扫描JAR文件并展示包级依赖关系:
jdeps myapp.jar
其输出会明确区分内部与外部依赖,并标注哪些依赖是通过传递引入的。例如:
类依赖包来源
com.Aorg.apache.commons.lang传递依赖
com.Bjava.base系统模块
结合两者,可有效验证模块间依赖是否符合设计预期,避免运行时ClassNotFoundException。

2.5 模块图构建中的传递路径分析

在模块化系统设计中,传递路径分析用于识别组件间的依赖流向与数据传播路径。通过分析调用链与接口暴露关系,可有效降低耦合度。
路径追踪示例
// TracePath 记录从源模块到目标模块的传递路径
func TracePath(source, target string, graph map[string][]string) [][]string {
    var result [][]string
    var path []string
    visited := make(map[string]bool)

    var dfs func(node string)
    dfs = func(node string) {
        if visited[node] {
            return
        }
        visited[node] = true
        path = append(path, node)
        if node == target {
            result = append(result, append([]string{}, path...))
        } else {
            for _, neighbor := range graph[node] {
                dfs(neighbor)
            }
        }
        path = path[:len(path)-1]
        delete(visited, node)
    }
    dfs(source)
    return result
}
该函数实现深度优先搜索,参数 graph 表示模块依赖图,source 与 target 为起止节点。返回所有可能的调用路径。
关键路径指标
指标说明
路径长度经过的模块数量
调用频次路径被触发的频率

第三章:典型应用场景实战

3.1 构建可复用的基础模块库的实践策略

在大型系统开发中,构建可复用的基础模块库是提升开发效率和代码质量的关键。通过抽象通用功能,如日志处理、网络请求封装和错误处理机制,可以显著降低重复代码量。
模块化设计原则
遵循单一职责与高内聚低耦合原则,将功能拆分为独立模块。例如,Go语言中可通过包(package)组织代码:

package utils

// Retry executes a function with exponential backoff
func Retry(attempts int, sleep time.Duration, fn func() error) error {
    for i := 0; i < attempts; i++ {
        err := fn()
        if err == nil {
            return nil
        }
        time.Sleep(sleep)
        sleep *= 2
    }
    return fmt.Errorf("failed after %d attempts", attempts)
}
该重友试例函数封装了常见的容错逻辑,参数attempts控制最大尝试次数,sleep定义初始间隔,适用于网络调用等不稳定操作。
版本管理与文档规范
使用语义化版本(SemVer)控制模块迭代,并配合清晰的API文档和示例代码,确保团队成员能快速理解与集成。

3.2 API层与实现层分离时的模块设计模式

在现代软件架构中,将API层与实现层解耦是提升系统可维护性与扩展性的关键实践。通过定义清晰的接口契约,API层仅负责请求的接收与响应封装,而具体业务逻辑交由独立的实现层处理。
接口与实现分离的基本结构
采用依赖倒置原则,API层依赖于抽象接口,而非具体实现。例如在Go语言中:
type UserService interface {
    GetUser(id int) (*User, error)
}

type userHandler struct {
    service UserService
}
上述代码中,userHandler 仅持有 UserService 接口引用,实现类通过依赖注入赋值,从而实现运行时动态绑定。
模块间依赖管理策略
  • API模块不应导入实现模块包
  • 实现模块实现接口并注册到容器
  • 通过工厂或DI框架完成实例化绑定
该模式显著降低编译依赖,支持多实现热插拔。

3.3 第三方库整合中避免依赖泄漏的正确方式

在集成第三方库时,防止其内部实现细节渗透到公共接口至关重要。应通过抽象层隔离外部依赖,仅暴露必要功能。
使用接口抽象外部依赖
定义清晰的接口,将第三方库封装在模块内部:
type PaymentGateway interface {
    Charge(amount float64) error
}

type StripeAdapter struct {
    client *stripe.Client
}

func (s *StripeAdapter) Charge(amount float64) error {
    // 调用 stripe SDK
    return s.client.Charge(amount)
}
上述代码中,PaymentGateway 接口屏蔽了 StripeAdapter 的具体实现,上层逻辑不感知 Stripe 存在。
依赖注入与模块化设计
通过构造函数注入依赖,避免全局变量或硬编码初始化:
  • 所有第三方客户端应在初始化阶段传入
  • 使用工厂模式统一创建适配器实例
  • 结合 Go Modules 管理版本,防止间接依赖污染主项目

第四章:常见误区与最佳实践

4.1 错误使用transitive导致的循环依赖问题

在构建大型Java项目时,transitive依赖管理若使用不当,极易引发模块间的循环依赖。Maven和Gradle默认启用传递性依赖,当模块A依赖B,B又间接引入A时,便形成闭环。
典型场景示例

// 模块A的build.gradle
implementation 'com.example:module-b:1.0'

// 模块B的build.gradle
implementation 'com.example:module-a:1.0' // 错误:反向引用A
上述配置将导致编译失败或类加载冲突。根本原因在于transitive=true使依赖链自动延伸,未显式排除时会继承不必要甚至危险的传递路径。
解决方案对比
方法说明
exclude声明显式排除特定传递依赖
依赖重构提取公共模块打破环路
合理设计模块边界并审慎控制transitive行为,是避免此类问题的关键。

4.2 过度暴露内部模块引发的安全与维护风险

当系统内部模块过度暴露时,不仅增加攻击面,还显著提升维护复杂度。本节探讨由此引发的核心问题及应对策略。
安全边界模糊带来的威胁
将本应封装的模块直接暴露,使恶意用户可能绕过权限校验,直接调用敏感接口。例如,前端意外暴露后端管理API路径:

// 错误示例:在前端代码中硬编码内部服务接口
const internalAPI = "http://backend-service/admin/deleteUser";
fetch(internalAPI, { method: 'POST', body: JSON.stringify({id: 123}) });
该代码将管理员接口暴露于客户端,任何用户均可发起请求,导致数据泄露或删除。
维护成本上升
外部依赖内部实现细节后,一旦模块重构,所有耦合方必须同步修改。使用接口抽象可缓解此问题:
  • 定义清晰的服务契约
  • 通过网关统一暴露必要接口
  • 内部通信采用私有协议或认证机制

4.3 版本兼容性管理中的传递依赖陷阱

在现代软件开发中,依赖管理工具虽简化了库的集成,却也引入了传递依赖的隐性风险。当项目直接依赖的库又依赖于其他版本冲突的组件时,可能导致运行时异常或功能失效。
依赖冲突的典型场景
例如,项目显式引入了库 A v1.2,而其依赖的库 B 却要求 A v1.0,构建工具可能默认保留较新版本,造成库 B 运行时调用不存在的 API。
可视化依赖树分析
使用 Maven 或 Gradle 可查看完整依赖图:

./gradlew dependencies --configuration compileClasspath
该命令输出项目依赖树,帮助识别冗余或冲突路径。
解决方案与最佳实践
  • 显式声明关键依赖版本,避免版本漂移
  • 利用 dependencyManagement 统一版本控制
  • 定期执行依赖审计:npm audit 或 mvn versions:display-dependency-updates

4.4 模块封装性优化建议与重构案例

封装原则的实践应用
良好的模块封装应遵循单一职责与信息隐藏原则。通过限制对外暴露的接口,降低系统耦合度。
  • 仅导出必要的结构和方法
  • 使用小写标识符实现包内私有化
  • 通过接口定义行为契约
重构前后对比示例

// 重构前:数据暴露
type UserManager struct {
    Users map[string]*User
}

// 重构后:封装增强
type userManager struct {
    users map[string]*User
}
func NewUserManager() *userManager {
    return &userManager{users: make(map[string]*User)}
}
func (m *userManager) AddUser(u *User) error {
    if m.users[u.ID] != nil {
        return ErrUserExists
    }
    m.users[u.ID] = u
    return nil
}
上述代码中,userManager 改为小写避免外部直接实例化,AddUser 方法封装了添加逻辑并提供错误反馈,提升安全性与可维护性。

第五章:结语——通往高效模块化架构的关键一步

在现代软件工程中,模块化不再是一种选择,而是应对复杂系统演进的必要策略。通过合理划分职责边界,团队能够实现并行开发、独立部署与精准维护。
实践中的模块通信设计
微服务架构下,模块间通信常采用事件驱动模式。以下是一个基于 Go 的简单事件发布示例:

type Event struct {
    Type string
    Data []byte
}

type EventBus interface {
    Publish(event Event)
    Subscribe(eventType string, handler func(Event))
}

// 实现发布逻辑,可集成 Kafka 或 NATS
func (e *NATSEventBus) Publish(event Event) {
    e.conn.Publish(event.Type, event.Data)
}
模块依赖管理建议
良好的依赖管理是稳定性的基石。推荐使用如下策略:
  • 通过接口定义跨模块契约,避免具体实现耦合
  • 采用版本化 API 路径(如 /api/v1/users)保障兼容性
  • 定期执行依赖扫描,识别过期或存在漏洞的组件
真实案例:电商平台的模块拆分
某电商平台将单体应用重构为订单、库存、支付三个核心模块。拆分后,各团队独立迭代,发布周期从每两周缩短至每日多次。关键指标变化如下:
指标拆分前拆分后
平均部署时长45 分钟8 分钟
故障隔离率32%89%
CI/CD 触发频率每天 2 次每天 27 次
深入探索Java 9的根模块机制 在JDK 9中,根模块是一种特殊的模块,它们只包含文件,而不包含任何包或Java代码。这些模块的唯一目的是要求其他模块(称为根模块),并使它们在外部可见。java.se就是这样一个模块。// 更多依赖... 阅读详情

相关推荐

深入理解Java模块系统中的requires transitive

本文探讨了Java模块系统中的requires transitive关键字,通过示例展示了其如何使模块依赖关系更加清晰和高效。介绍了如何通过使用requires transitive来优化模块依赖,避免冗余,并通过命令行工具了解和操作模块。

weixin_30653091的博客 338

Java 9 模块化

Java 9 模块化 Java 9 引入模块(JPMS,Java Platform Module System), 其是在包上增加了新的抽象级别。本文主要介绍JPMS并讨论它的多个方面内容。 1. 模块概述 首先,在学习如何使用模块之前需先理解模块是什么?模块是一组紧密相关的包、资源以及模块描述文件。也就是说,它是"Java包的包"抽象,增强代码可重用性。 模块中的包与Java诞生以来一直使用的包...

neweastsun的专栏 1370

frontend-design skills

frontend-design skills

Java SE 9 模块化示例

Java SE 9引入了模块系统,模块就是代码和数据的封装体。模块的代码被组织成多个包,每个包中包含Java类和接口;模块的数据则包括资源文件和其他静态信息。

guanshengg的博客 463

用于计算系统状态的卡尔曼最优增益和最小均方误差(MMSE)估计研究(Matlab代码实现)

内容概要:本文围绕用于计算系统状态的卡尔曼最优增益和最小均方误差(MMSE)估计展开研究,深入探讨了卡尔曼滤波在动态系统状态估计中的核心作用。文章系统阐述了卡尔曼滤波的数学基础,包括状态空间模型的建立、先验与后验状态估计、协方差矩阵的递推更新,以及最优增益矩阵的推导过程,确保在高斯白噪声环境下实现对系统状态的最小均方误差估计。结合Matlab代码实现,完整展示了算法从理论建模到仿真实验的全流程,涵盖系统建模、噪声设置、滤波迭代、状态更新与误差分析等环节,并通过仿真实验验证了算法在噪声干扰下对系统真实状态的高精度跟踪能力。该研究为控制工程、导航系统、信号处理及自动化领域中的状态估计问题提供了坚实的理论依据与高效的数值实现方案。; 适合人群:具备一定控制理论、概率统计基础和Matlab编程能力,从事自动化、电子信息、航空航天、机器人、导航定位等相关领域的科研人员、工程技术人员及高校研究生。; 使用场景及目标:①掌握卡尔曼滤波的基本原理及其在状态估计中的数学推导过程;②学习如何利用Matlab实现卡尔曼滤波算法并进行系统仿真与性能评估;③应用于目标跟踪、传感器融合、惯性导航、故障诊断、时间序列预测等实际工程中的动态状态估计问题。; 阅读建议:建议读者结合文中提供的Matlab代码进行动手实践,通过调整系统模型参数、过程噪声与观测噪声强度,观察滤波效果的变化,深入理解卡尔曼增益的自适应调节机制与MMSE估计的收敛特性。同时可进一步拓展学习扩展卡尔曼滤波(EKF)、无迹卡尔曼滤波(UKF)等非线性滤波方法,以应对更复杂的非线性系统状态估计挑战。

Yocto下载加速秘籍:用清华镜像+PREMIRRORS配置让构建速度翻倍

本文详细解析了如何通过配置Yocto的PREMIRRORS优先级策略,并利用清华大学等国内镜像源,显著加速构建过程中的源码下载。文章提供了具体的配置示例和验证方法,帮助开发者解决网络瓶颈,实现构建速度翻倍,提升开发效率。

game4的博客 278

简单说说 java中的 模块系统

java中一般的包和类的封装系统已经不能满足我们对访问的控制。 因此有了Java9有了模块系统,有以下2个优点: 1.强封装性:我们可以控制哪些包是可访问的,并且无需区维护那些我们不想公开给大众的代码 2.可靠的配置:我们可以避免类重复或类丢失,这类常见的路径问题 对模块命名 模块是包的集合 ,并且模块名可以和包名重复。 模块名只模块声明中。在java类源文件中,永远不应该引用模块名 使用模块 模块文件在项目的根目录,模块文件叫 **module-info.java **。 如果我们编

cz2423415723的博客 1150

【TCAX相关】Python 官方手册下载页面(中文+英文)

Python 官方手册下载页面(中文+英文) 中文: https://docs.python.org/zh-cn/3.8/archives/ https://docs.python.org/zh-cn/3.6/archives/ 英文: https://www.python.org/doc/versions/ https://docs.python.org/3/archives/ https://www.python.org/ftp/python/doc/ ...

Seekladoom的博客 1013

Java 模块化

Java 模块化的设计目标是提供一种更好的项目组织和管理方式,解决依赖管理、可重用性、可扩展性和安全性等方面的问题,使得开发者能够更有效地构建和维护大型和复杂的 Java 应用程序。其实 Java 官方发布这个特性至今为止很少有人用到 Java 原生的模块系统,取而代之的是各种包管理工具提供的类似的特性。例如 Maven、Ant 或者 Gradle 这些包管理器都提供了类似的概念,而且到 Java 17 为止这个特性确实没有很出色的表现(至少作者没有看到)。但既然作为新特性,我们仍然有学习的必要。

a1518967800的博客 1016

PLC1200使用CB1241RS485通讯模块做从站进行Modbus Rtu通信

添加新设备(PLC)->设备和网络管理->点击PLC->看到硬件目录选择通信板->点到点->CB1241(RS485)->看到6ES7241-1CH30-1XB0选择添加,如图。指向Modbus保持寄存器数据块的指针 我这里指向了自定义的DB块数据中一个INT数组。在通信->通信处理模块->MODBUS(选择不带RTU的通信指令块)注意:接线时,TRA接485调试模块的B- TRB接调试模块的A+组态后的硬件标识符 270 对应自己组态后自动生成的。1:事务完成,且无任何错误。波特率对应自己使用的。

swmyaopeng的博客 2万+

配置oem 13c以监控管理数据库

使用oem13c监控数据库

雅冰石的专栏 1814

java模块化学习_Java9模块化学习

1. 什么是模块化本质上,模块化就是将系统分解成独立且相互连接的模块的行为。java9模块除了包含代码外,一个重要特征是增加了描述模块的文件:module-info.javaQ:为什么这么做?-- 减少复杂性Project JigsawJigsaw 项目从2008就开始对JDk模块化进行探索,2014年开始进行设计和实现。2. 模块化JDKJDK由90个左右的平台模块组成,每个模块都是一个定义好的...

weixin_29196613的博客 752

别再怕无霍尔BLDC了!手把手教你用反电动势过零检测搞定电机换向(附STM32代码片段)

本文详细介绍了无霍尔传感器BLDC电机的驱动方法,重点讲解反电动势过零检测技术及其在STM32上的实现。通过硬件电路设计、信号调理和软件算法优化,手把手教你完成电机换向控制,并提供实用的调试技巧和代码片段,帮助开发者快速掌握无霍尔BLDC驱动技术。

weixin_42522575的博客 495

你真的懂模块可见性吗?requires transitive传递性原理深度剖析

掌握Java 9模块化设计难题?深入解析requires transitive传递性原理,阐明模块间可见性控制机制,适用于多层架构依赖管理,提升封装性与维护性。理解transitive的适用场景与优势,构建高效模块系统,值得收藏。

DevPath的博客 782

易灵思FPGA-软件Efinity和Modelsim联仿设置

文章目录前言一、modelsim破解过程二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智

qq_35221855的博客 5373

大模型之Spring AI实战系列(二十六):Spring Boot + DeepSeek 实战指南:构建AI聊天应用

在人工智能技术飞速发展的今天,大型语言模型已经成为了推动技术创新的重要力量。DeepSeek作为国内领先的大型语言模型提供商,其推出的DeepSeek系列模型在多个领域都展现出了卓越的性能。本文将详细介绍如何使用Spring Boot框架集成DeepSeek API,构建一个简单的AI聊天应用。我们将实现两个核心功能:普通文本生成和流式文本生成。

寻道AI,探索AI无限可能! 2268

JDK之模块化

Java模块化是JVM核心项目之一,从JDK9开始商业化运作,简称是JPMS(Java 9 Platform Module System),这项技术当时被认为是Java技术最重要的软件工程新技术。模块化项目的发展源自于Project Jigsaw,该项目能帮助开发者从更多层次上、更具创造性地、更具可维护性地构建与演进软件工程,特别适用于大型软件项目工程...

wys的专栏 2145

清华源pip install出现ERROR: Could not find a version that satisfies the requirement的解决方案

本文主要介绍了清华源pip install出现ERROR: Could not find a version that satisfies the requirement的解决方案,希望能对学习python的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案

weixin_43178406的博客 8万+

JAVA9新特性(一)

JAVA9新特性(一) JAVA9于北京时间2017年9月22日(当地9.21)正式发布,可以在官网上下载到最新的jdk9,但是目前只支持64位操作系统。 所有特性目录:http://blog.youkuaiyun.com/diehuang3426/article/details/79233952 知乎有个问题描述的也不错:https://www.zhihu.com/question/65683103/...

编程之路 1336

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

初探Java 9 的的模块化

Java 9中最重要的功能,毫无疑问就是模块化(Module),它将自己长期依赖JRE的结构,转变成以Module为基础的组件,当然这在使用Java 9 开发也和以前有着很大的不同。 Java8或更加早期的系统的问题 Jar文件,像rt.jar等jar文件太大的以至于不能使用在小设备和应用中。 因为JDK是太大的,我们的应用或设备不能支持更好的平台. 由于修饰符是public的缘故,每个人都可以...

weixin_30294295的博客 261

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

JLS9学习之模块声明

想了解一下java9 module的语法,找到JLS(Java Language Specification),直奔7.7章节Module Declarations。 7.7 模块声明 模块的声明定义了一个已命名模块(还有一种unnamed module,未命名模块,见7.7.5)。已命名模块中指明了本模块依赖哪些其他模块,即本模块的代码能用到哪些其他模块中的类和接口;还指明了本模块中的哪些包是导出的或开放的,从而指明了本模块中的哪些类和接口是依赖本模块的模块可以用的。 requires命令表达的

veritasw的博客 1134

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

java语言详解,JAVA语言之详解java9学习笔记之模块化

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

weixin_29189003的博客 314

java9学习之模块化

  截止到目前JDK的版本已经更新到10了,虽然java9的生命周期才半年,但是我认为这个版本带来的变革是不可磨灭的,它是第一次深层次的针对架构以及依赖上的革新。下面我们就来学习一下。 一、模块化项目构建   其实模块化本身不难理解,我们先前使用maven或者gradle就构建过多模块的项目。那么我们在java9里依然可以照猫画虎来构建一下我们的模块化项...

weixin_33806914的博客 374

用自己的话总结@Transactional中的REQUIRED方法和REQUIRES_NEW的区别

用自己的话总结@Transactional中的REQUIRED方法和REQUIRES_NEW的区别 ①事务的传播行为:当事务方法被另一个事务方法调用时,必须指定事务应该如何传播。 ②REQUIRED(系统默认):如果有事务在运行,当前的方法就在这个事务内运行,否则,就启动一个新的事务,并在自己的事务内运行 REQUIRES_NEW:当前的方法必须启动新的事务,并在它自己的事务内运行,如果有事务正在...

qq_45610112的博客 2933

java模块化编程的理解即学习笔记

一、java模块化概述 1.jar 为什么引入模块化,因为jdk8以前开发模式都是jar: 简介: 缺点: 2.java模块化系统 2.1模块化的三个原则: 强封装性:一个模块必须能够对其他模块隐藏其部分代码 定义好良好的接口:模块必须向其他模块公开定义良好且稳定的接口 显式依赖:明确一个模块需要哪些模块的支持才能完成工作。 2.2java9引入新的模块化系统 Jig...

weixin_43698704的博客 3446
上一篇: 从入门到精通:Flask蓝图url_prefix嵌套配置的7种最佳实践
下一篇: 【Spring Boot整合Elasticsearch高亮实战】:手把手教你实现搜索结果精准高亮
LogicGap
博客等级 码龄1年 148粉丝 1987原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值