Java 9 新特性：模块化系统

于 2024-06-06 12:49:19 发布
阅读量1k 收藏 18
点赞数 40
分类专栏： Java新特性合集 文章标签： java python pycharm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33326733/article/details/139497205
版权

Java 9 引入的模块系统（Module System）是 Jigsaw 项目的一部分，旨在将模块化开发实践引入 Java 平台。这一特性带来了更好的代码重用性和维护性。本文将通过源码解读和示例讲解模块系统的核心概念、设计目的以及在动态模块加载和热部署中的应用。

什么是模块系统？

模块系统是一个唯一命名的、可重用的包集合，以及资源和模块描述文件（module-info.java）。任何一个 JAR 文件，只要加上一个模块描述文件（module-info.java），就可以升级为一个模块。

模块描述文件 module-info.java

模块描述文件 module-info.java 是定义模块的核心。它允许我们定义模块的名称、依赖项、导出的包等。下面是一个简单的模块描述文件示例：

java

module my.module {
    exports com.my.package.name;
}

在上面的代码中，exports 关键字用于公开指定包的所有公共成员。

模块化的设计目的

  1. 提高封装性：通过模块系统，可以控制哪些类可以对外开放使用，哪些类只能内部使用。
  2. 减少模块之间的耦合：通过模块化，可以减少系统中模块之间的依赖和耦合。
  3. 定制运行时环境：通过 jlink 工具，可以创建只包含所依赖的 JDK 模块的自定义运行时镜像，从而减少 Java 运行时环境的大小。

JDK 模块化

在引入了模块系统之后，JDK 被重新组织成 94 个模块。Java 应用可以通过新增的 jlink 工具创建出只包含所依赖的 JDK 模块的自定义运行时镜像。这样可以极大地减少 Java 运行时环境的大小。

exports 关键词

exports 关键字用于控制哪些包可以对外开放使用。我们还可以使用 exports ... to 语法来限制包的访问范围，例如：

java

module my.module {
    exports com.my.package.name to com.specific.package;
}

在上面的代码中，exports ... to 语法用于限制访问的成员范围，只有 com.specific.package 可以访问 com.my.package.name 包中的类。

示例：创建和使用模块

下面我们通过一个具体的示例来说明如何创建和使用模块。

创建模块 com.example.module

首先，我们创建一个模块 com.example.module，并在该模块中定义一个简单的类 HelloWorld：

java

// 文件路径：src/com.example.module/module-info.java
module com.example.module {
    exports com.example.module;
}

java

// 文件路径：src/com.example.module/com/example/module/HelloWorld.java
package com.example.module;

public class HelloWorld {
    public void sayHello() {
        System.out.println("Hello, Module System!");
    }
}

使用模块

接下来，我们创建一个新的模块 com.example.main 来使用 com.example.module 模块：

java

// 文件路径：src/com.example.main/module-info.java
module com.example.main {
    requires com.example.module;
}

java

// 文件路径：src/com.example.main/com/example/main/Main.java
package com.example.main;

import com.example.module.HelloWorld;

public class Main {
    public static void main(String[] args) {
        HelloWorld helloWorld = new HelloWorld();
        helloWorld.sayHello();
    }
}

编译和运行

编译和运行上述模块化应用程序：

  1. 编译模块 com.example.module：

    shell

    javac -d out/module --module-source-path src $(find src -name "*.java")

  2. 编译模块 com.example.main：

    shell

    javac -d out/main --module-path out/module --module-source-path src $(find src -name "*.java")

  3. 运行应用程序：

    shell

    java --module-path out -m com.example.main/com.example.main.Main

模块系统与传统的 JAR 包管理有什么本质区别？

模块系统与传统的 JAR 包管理有着显著的区别，它们在设计理念、依赖管理、封装性和运行时环境等方面存在本质上的不同。下面我们详细解析这些区别，并举例说明每种方法的具体应用场景。

1. 设计理念

传统的 JAR 包管理

传统的 JAR 包管理主要依赖于类路径（classpath）。所有的 JAR 文件都被放置在类路径中，JVM 会根据类路径加载相应的类和资源。

java -cp lib/* com.example.Main
模块系统

模块系统引入了模块描述文件 module-info.java，每个模块都有明确的边界和依赖关系。模块系统通过模块路径（module path）管理模块，取代了传统的类路径。

java

module com.example.module {
    exports com.example.module;
}

2. 封装性

传统的 JAR 包管理

在传统的 JAR 包管理中，所有类都是公开的，只要类路径中有该 JAR 文件，任何其他类都可以访问其中的公共类和方法。这种方式缺乏对内部实现细节的封装控制。

模块系统

模块系统通过 exports 关键字控制包的可见性，只有显式导出的包中的公共类和方法才能被外部访问。其他包中的类和方法默认是隐藏的。

java

module com.example.module {
    exports com.example.module;
}

3. 依赖管理

传统的 JAR 包管理

在传统的 JAR 包管理中，依赖关系是通过手动管理的，所有依赖的 JAR 文件都需要被添加到类路径中。这种方式容易导致类路径的冲突和依赖地狱（Jar Hell）。

shell

java -cp lib/dependency1.jar:lib/dependency2.jar com.example.Main
模块系统

模块系统通过 requires 关键字明确声明模块依赖关系，JVM 在启动时会根据模块描述文件自动解析和加载依赖模块。

java

module com.example.main {
    requires com.example.module;
}

4. 运行时环境

传统的 JAR 包管理

在传统的 JAR 包管理中，JVM 会加载所有类路径中的 JAR 文件，这可能会导致冗余和不必要的资源占用。

模块系统

模块系统通过 jlink 工具可以创建自定义的运行时环境，只包含所需的模块。这不仅减少了运行时环境的大小，还提升了性能和安全性。

shell

jlink --module-path $JAVA_HOME/jmods --add-modules com.example.module --output custom-runtime

实例对比

传统的 JAR 包管理实例

假设我们有一个简单的项目 example.jar，并且它依赖于 commons-lang3-3.12.0.jar。

  1. 创建项目结构：

txt

example/
├── lib/
│   └── commons-lang3-3.12.0.jar
├── src/
│   └── com/example/Main.java
└── example.jar
  1. 编写 Main.java：

java

package com.example;

import org.apache.commons.lang3.StringUtils;

public class Main {
    public static void main(String[] args) {
        System.out.println(StringUtils.capitalize("hello world"));
    }
}
  1. 编译和运行：

shell

javac -d out -cp lib/commons-lang3-3.12.0.jar src/com/example/Main.java
jar --create --file example.jar --main-class com.example.Main -C out/ .
java -cp lib/commons-lang3-3.12.0.jar:example.jar com.example.Main
模块系统实例

假设我们有相同的项目，但我们将其模块化。

  1. 创建模块结构：

txt

example/
├── lib/
│   └── commons-lang3-3.12.0.jar
├── src/
│   ├── com.example.main/
│   │   └── module-info.java
│   └── com.example.main/com/example/Main.java
└── example.jar
  1. 编写 module-info.java：

java

module com.example.main {
    requires org.apache.commons.lang3;
}
  1. 编写 Main.java：

java

package com.example;

import org.apache.commons.lang3.StringUtils;

public class Main {
    public static void main(String[] args) {
        System.out.println(StringUtils.capitalize("hello world"));
    }
}
  1. 编译和运行：

shell

javac -d out --module-path lib --module-source-path src $(find src -name "*.java")
jar --create --file example.jar --main-class com.example.Main -C out/ .
java --module-path lib:example.jar --module com.example.main/com.example.Main

在动态模块加载和热部署场景中，模块化系统有哪些注意事项和最佳实践？

在现代软件开发中，动态模块加载和热部署是非常重要的需求，特别是在需要高可用性和快速迭代的应用中。Java 9 引入的模块系统带来了一些新的挑战和机会，使得动态模块加载和热部署变得更加复杂但也更加可控。下面我们详细讨论在动态模块加载和热部署场景中，模块化系统的注意事项和最佳实践。

1. 动态模块加载的基础

传统的类加载机制

在传统的 Java 应用中，动态加载类通常通过 ClassLoader 来实现。例如，可以使用 URLClassLoader 动态加载 JAR 文件：

java

URL[] urls = {new URL("file:///path/to/your.jar")};
URLClassLoader classLoader = new URLClassLoader(urls);
Class<?> clazz = classLoader.loadClass("com.example.YourClass");
Object instance = clazz.newInstance();
模块化系统中的动态加载

在模块化系统中，动态加载模块变得更加复杂。Java 9 引入了 Layer 和 ModuleFinder，可以用于动态加载模块。以下是一个基本的示例：

java

// 找到模块路径
Path modulePath = Paths.get("/path/to/your/modules");

// 创建模块查找器
ModuleFinder finder = ModuleFinder.of(modulePath);

// 创建模块图
Configuration configuration = ModuleLayer.boot().configuration()
    .resolve(finder, ModuleFinder.of(), Set.of("your.module"));

// 创建新的模块层
ModuleLayer layer = ModuleLayer.boot().defineModulesWithOneLoader(configuration, ClassLoader.getSystemClassLoader());

// 加载模块中的类
Class<?> clazz = layer.findLoader("your.module").loadClass("com.example.YourClass");
Object instance = clazz.newInstance();

2. 热部署的基础

传统的热部署

传统的热部署通常依赖于应用服务器（如 Tomcat、Jetty）或第三方工具（如 JRebel）来实现。这些工具通过监控文件系统的变化，重新加载修改过的类和资源。

模块化系统中的热部署

在模块化系统中，实现热部署需要更多的控制和管理。以下是一些常见的策略：

  1. 使用 OSGi：OSGi 是一种动态模块系统，可以与 Java 模块系统结合使用，提供动态加载、卸载和更新模块的功能。
  2. 自定义类加载器：通过自定义类加载器，管理模块的加载和卸载。
  3. 服务提供者接口（SPI）：通过 SPI 机制，可以动态发现和加载模块中的服务。

3. 注意事项和最佳实践

注意事项
  1. 模块版本控制：确保模块的版本控制和依赖管理清晰，避免版本冲突。
  2. 模块依赖：在动态加载模块时，确保所有依赖模块都已加载。
  3. 资源管理：注意模块的资源管理，特别是文件句柄和网络连接等资源的释放。
最佳实践

  1. 使用服务提供者接口（SPI）：
    通过 SPI，可以在模块间定义和发现服务，便于动态加载和替换模块中的实现。

    java

    // 定义服务接口
public interface GreetingService {
    void greet(String name);
}

// 实现服务接口
public class GreetingServiceImpl implements GreetingService {
    @Override
    public void greet(String name) {
        System.out.println("Hello, " + name);
    }
}

// 使用服务加载器加载服务
ServiceLoader<GreetingService> loader = ServiceLoader.load(GreetingService.class);
for (GreetingService service : loader) {
    service.greet("World");
}

  2. 模块化设计：
    在设计模块时，尽量保持模块的独立性和低耦合，便于动态加载和卸载。

  3. 使用 OSGi：
    OSGi 提供了丰富的动态模块管理功能，可以与 Java 模块系统结合使用，实现更灵活的动态加载和热部署。

  4. 监控和日志：
    实施详细的监控和日志记录，及时发现和处理动态加载和热部署中的问题。

  5. 测试自动化：
    编写自动化测试，确保动态加载和热部署功能的稳定性和可靠性。

示例：使用 OSGi 实现动态模块管理

以下是一个使用 OSGi 动态加载和卸载模块的完整示例。

步骤 1：设置 OSGi 环境

首先，需要添加 OSGi 依赖。可以使用 Maven 或 Gradle 来管理这些依赖。

xml

<!-- Maven 依赖 -->
<dependency>
    <groupId>org.osgi</groupId>
    <artifactId>org.osgi.core</artifactId>
    <version>6.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.felix</groupId>
    <artifactId>org.apache.felix.framework</artifactId>
    <version>6.0.3</version>
</dependency>
<dependency>
    <groupId>org.apache.felix</groupId>
    <artifactId>org.apache.felix.main</artifactId>
    <version>6.0.3</version>
</dependency>
步骤 2：创建 OSGi 模块（Bundle）

创建一个简单的 OSGi 模块，包含一个服务。

com.example.hello 模块
META-INF/MANIFEST.MF

plaintext

Bundle-ManifestVersion: 2
Bundle-Name: Hello Bundle
Bundle-SymbolicName: com.example.hello
Bundle-Version: 1.0.0
Export-Package: com.example.hello
src/main/java/com/example/hello/HelloService.java

java

package com.example.hello;

public class HelloService {
    public void sayHello() {
        System.out.println("Hello, OSGi!");
    }
}
步骤 3：创建 OSGi 框架启动器

编写一个 OSGi 框架启动器，用于加载和卸载模块。

java

import org.apache.felix.framework.Felix;
import org.apache.felix.main.AutoProcessor;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;
import org.osgi.framework.launch.Framework;
import org.osgi.framework.launch.FrameworkFactory;

import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.ServiceLoader;

public class OSGiLauncher {
    private Framework framework;

    public void startFramework() throws BundleException {
        Map<String, String> config = new HashMap<>();
        config.put("org.osgi.framework.storage.clean", "onFirstInit");

        FrameworkFactory factory = ServiceLoader.load(FrameworkFactory.class).iterator().next();
        framework = factory.newFramework(config);
        framework.init();

        AutoProcessor.process(config, framework.getBundleContext());
        framework.start();
    }

    public void stopFramework() throws BundleException {
        if (framework != null) {
            framework.stop();
            framework.waitForStop(0);
        }
    }

    public Bundle installBundle(String bundlePath) throws BundleException {
        BundleContext context = framework.getBundleContext();
        return context.installBundle(new File(bundlePath).toURI().toString());
    }

    public void uninstallBundle(Bundle bundle) throws BundleException {
        if (bundle != null) {
            bundle.uninstall();
        }
    }

    public static void main(String[] args) throws Exception {
        OSGiLauncher launcher = new OSGiLauncher();
        launcher.startFramework();

        // 安装并启动 bundle
        Bundle bundle = launcher.installBundle("path/to/hello-bundle.jar");
        bundle.start();

        // 使用 bundle 中的服务
        Class<?> helloServiceClass = bundle.loadClass("com.example.hello.HelloService");
        Object helloService = helloServiceClass.getDeclaredConstructor().newInstance();
        helloServiceClass.getMethod("sayHello").invoke(helloService);

        // 卸载 bundle
        launcher.uninstallBundle(bundle);

        launcher.stopFramework();
    }
}

4. 自定义类加载器实现动态卸载

如果不使用 OSGi，我们还可以通过自定义类加载器实现动态卸载和资源释放。这种方法虽然没有 OSGi 那么强大，但在一些简单的场景中也能奏效。

示例：自定义类加载器
步骤 1：创建自定义类加载器

java

import java.net.URL;
import java.net.URLClassLoader;
import java.util.HashMap;
import java.util.Map;

public class DynamicClassLoader extends URLClassLoader {
    private Map<String, Class<?>> loadedClasses = new HashMap<>();

    public DynamicClassLoader(URL[] urls) {
        super(urls);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        if (loadedClasses.containsKey(name)) {
            return loadedClasses.get(name);
        }
        Class<?> clazz = super.findClass(name);
        loadedClasses.put(name, clazz);
        return clazz;
    }

    public void unloadClass(String name) {
        loadedClasses.remove(name);
    }
}
步骤 2：加载和卸载类

java

import java.net.URL;

public class DynamicModuleManager {
    private DynamicClassLoader classLoader;

    public DynamicModuleManager(String modulePath) throws Exception {
        URL[] urls = {new URL("file://" + modulePath)};
        classLoader = new DynamicClassLoader(urls);
    }

    public Class<?> loadClass(String className) throws ClassNotFoundException {
        return classLoader.loadClass(className);
    }

    public void unloadClass(String className) {
        classLoader.unloadClass(className);
    }

    public void close() throws Exception {
        classLoader.close();
    }

    public static void main(String[] args) throws Exception {
        DynamicModuleManager manager = new DynamicModuleManager("/path/to/your/module");

        // 加载类
        Class<?> clazz = manager.loadClass("com.example.YourClass");
        Object instance = clazz.getDeclaredConstructor().newInstance();
        clazz.getMethod("yourMethod").invoke(instance);

        // 卸载类
        manager.unloadClass("com.example.YourClass");
        manager.close();
    }
}

5. 资源管理和释放

无论使用哪种方法，资源管理和释放都是动态卸载模块中的重要部分。确保在卸载模块时释放所有占用的资源（如文件句柄、网络连接等）是至关重要的。

示例：资源释放
步骤 1：创建 ResourceHandler 类

java

import java.io.Closeable;
import java.io.IOException;

public class ResourceHandler implements Closeable {
    private boolean isResourceOpen;

    public void openResource() {
        isResourceOpen = true;
        System.out.println("Resource opened.");
    }

    public void useResource() {
        if (isResourceOpen) {
            System.out.println("Using resource.");
        } else {
            System.out.println("Resource is not open.");
        }
    }

    @Override
    public void close() throws IOException {
        if (isResourceOpen) {
            isResourceOpen = false;
            System.out.println("Resource closed.");
        }
    }
}
步骤 2：在模块中使用 ResourceHandler

java

package com.example.resource;

import java.io.IOException;

public class ResourceModule {
    private ResourceHandler resourceHandler;

    public ResourceModule() {
        resourceHandler = new ResourceHandler();
        resourceHandler.openResource();
    }

    public void performTask() {
        resourceHandler.useResource();
    }

    public void releaseResources() throws IOException {
        resourceHandler.close();
    }
}
步骤 3：动态加载和卸载模块时释放资源

在动态加载和卸载模块时，我们需要确保正确调用资源释放方法。

java

import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;

public class ResourceModuleManager {
    private URLClassLoader classLoader;
    private Object resourceModuleInstance;

    public void loadModule(String modulePath) throws Exception {
        URL[] urls = {new URL("file://" + modulePath)};
        classLoader = new URLClassLoader(urls);

        Class<?> moduleClass = classLoader.loadClass("com.example.resource.ResourceModule");
        resourceModuleInstance = moduleClass.getDeclaredConstructor().newInstance();
        moduleClass.getMethod("performTask").invoke(resourceModuleInstance);
    }

    public void unloadModule() throws Exception {
        if (resourceModuleInstance != null) {
            resourceModuleInstance.getClass().getMethod("releaseResources").invoke(resourceModuleInstance);
            resourceModuleInstance = null;
        }
        if (classLoader != null) {
            classLoader.close();
            classLoader = null;
        }
    }

    public static void main(String[] args) throws Exception {
        ResourceModuleManager manager = new ResourceModuleManager();
        manager.loadModule("/path/to/your/module");

        // Perform some operations
        // ...

        // Unload module and release resources
        manager.unloadModule();
    }
}

在上述示例中，我们定义了一个 ResourceHandler 类来管理资源。在 ResourceModuleManager 类中，我们动态加载 ResourceModule 模块，并在卸载模块时调用 releaseResources 方法以释放资源。

6. 使用 ServiceLoader 动态发现和加载服务

Java 平台提供了 ServiceLoader 机制，可以在运行时动态发现和加载实现了特定接口的服务。这种方式可以用于动态加载和替换模块中的实现。

示例：使用 ServiceLoader 动态加载服务
步骤 1：定义服务接口

java

package com.example.service;

public interface GreetingService {
    void greet(String name);
}
步骤 2：实现服务接口

java

package com.example.service.impl;

import com.example.service.GreetingService;

public class GreetingServiceImpl implements GreetingService {
    @Override
    public void greet(String name) {
        System.out.println("Hello, " + name);
    }
}
步骤 3：创建服务提供者配置文件

在模块的资源目录中创建 META-INF/services/com.example.service.GreetingService 文件，内容为实现类的全限定名：

txt

com.example.service.impl.GreetingServiceImpl
步骤 4：使用 ServiceLoader 加载服务

java

import com.example.service.GreetingService;

import java.util.ServiceLoader;

public class ServiceLoaderExample {
    public static void main(String[] args) {
        ServiceLoader<GreetingService> loader = ServiceLoader.load(GreetingService.class);
        for (GreetingService service : loader) {
            service.greet("World");
        }
    }
}

 

在上述示例中，我们定义了 GreetingService 接口，并实现了该接口。通过 ServiceLoader，我们可以在运行时动态加载和使用服务实现。这种机制特别适用于需要动态发现和加载插件的场景。

实现动态模块卸载和资源释放的最佳实践

1. 确保资源的正确释放

在卸载模块时，确保所有占用的资源（如文件句柄、网络连接、线程等）都被正确释放，避免资源泄漏。可以通过实现 AutoCloseable 或 Closeable 接口来确保资源释放的逻辑清晰和统一。

2. 使用弱引用防止内存泄漏

在动态加载和卸载模块时，使用弱引用（WeakReference）可以帮助防止内存泄漏。弱引用允许垃圾回收器回收不再使用的对象，从而避免内存泄漏。

3. 模块间的解耦

设计模块时，尽量使模块之间的依赖关系松散，避免强耦合。可以使用依赖注入（DI）或服务提供者接口（SPI）来实现模块间的解耦。

4. 使用 OSGi 框架

OSGi 框架提供了强大的动态模块管理功能，可以轻松实现模块的动态加载、卸载和更新。OSGi 框架还提供了模块生命周期管理、版本控制和依赖管理等功能，适合复杂的动态模块管理需求。

5. 详细的监控和日志记录

在动态模块加载和卸载过程中，详细的监控和日志记录可以帮助及时发现和解决问题。可以记录模块的加载、卸载、资源使用情况等信息，以便在出现问题时进行快速诊断。

实例：综合示例

以下是一个综合示例，展示了如何实现动态模块加载、卸载和资源释放。

步骤 1：创建模块 com.example.resource

java

// 文件路径：src/com.example.resource/module-info.java
module com.example.resource {
    exports com.example.resource;
}

java

// 文件路径：src/com.example.resource/com/example/resource/ResourceHandler.java
package com.example.resource;

import java.io.Closeable;
import java.io.IOException;

public class ResourceHandler implements Closeable {
    private boolean isResourceOpen;

    public void openResource() {
        isResourceOpen = true;
        System.out.println("Resource opened.");
    }

    public void useResource() {
        if (isResourceOpen) {
            System.out.println("Using resource.");
        } else {
            System.out.println("Resource is not open.");
        }
    }

    @Override
    public void close() throws IOException {
        if (isResourceOpen) {
            isResourceOpen = false;
            System.out.println("Resource closed.");
        }
    }
}
步骤 2：创建模块 com.example.main

java

// 文件路径：src/com.example.main/module-info.java
module com.example.main {
    requires com.example.resource;
}

java

// 文件路径：src/com.example.main/com/example/main/Main.java
package com.example.main;

import com.example.resource.ResourceHandler;

import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        ResourceHandler resourceHandler = new ResourceHandler();
        resourceHandler.openResource();
        resourceHandler.useResource();
        
        try {
            resourceHandler.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
步骤 3：编译和运行

编译和运行上述模块化应用程序：

  1. 编译模块 com.example.resource 和 com.example.main：

    shell

    javac -d out --module-source-path src $(find src -name "*.java")

  2. 运行应用程序：

    shell

    java --module-path out -m com.example.main/com.example.main.Main

在上述示例中，我们定义了 ResourceHandler 类来管理资源，并在 Main 类中动态加载和使用该资源。在卸载模块时，通过调用 close 方法来释放资源。

总结

模块化系统为 Java 带来了更高的封装性和依赖管理能力，但也引入了一些新的复杂性。在动态模块加载和热部署场景中，实现模块的动态卸载和资源释放需要仔细设计和管理。通过使用 OSGi 框架、自定义类加载器和 ServiceLoader 机制，可以有效地实现模块的动态加载、卸载和资源释放。确保在卸载模块时正确释放所有占用的资源是至关重要的，以避免资源泄漏和潜在的问题。

qq_33326733
关注
  • 40
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【java9】java9新特性之模块化
morris
04-30 1万+
Java9模块化是Java9版本中引入的一个重要特性，通过Java Platform Module System (JPMS)实现。这个特性允许开发者将大型应用程序拆分成相互独立的模块，每个模块包含一组相关的功能和资源。
java 模块化系统_Java 模块化系统初探
weixin_42608299的博客
02-13 110
Java 模块化系统自提出以来经历了很长的时间，直到 2014 年晚些时候才最终以 JSR(JSR-376) 定稿，而且这个部分有可能在 Java 9 中出现。但是一直以来都没有可以使用的原型。9 月 11 日，OpenJDK 发布的早期构建版本终于包含了 Jigsaw 项目。昨天，我和同事 Paul Bakker 在 JavaZone 上对于 Java 模块化系统进行了讨论。整个讨论都建立在JS...
java9学习之模块化
weixin_33806914的博客
04-18 248
　　截止到目前JDK的版本已经更新到10了，虽然java9的生命周期才半年，但是我认为这个版本带来的变革是不可磨灭的，它是第一次深层次的针对架构以及依赖上的革新。下面我们就来学习一下。 一、模块化项目构建 　　其实模块化本身不难理解，我们先前使用maven或者gradle就构建过多模块的项目。那么我们在java9里依然可以照猫画虎来构建一下我们的模块化项...
java9 模块化系统
清风不灭的博客
01-21 644
为什么要引入java模块化系统 Java 运行环境的膨胀和臃肿。 每次 JVM 启动的时候，至少会有 30 ～ 60MB 的内存加载，主要原因是 JVM 需要加载 rt.jar ，不管其中的类是否被 classloader 加载，第一步整个 jar 都会被 JVM 加载到内存当中去（而模块化可以根据模块的需要加载程序运行需要的 class ）。 当代码库越来越大，创建复杂，这些...
Java9模块化简明例子
Zebe
09-14 1960
个人对Java9的模块化的理解 个人对Java9模块化的简单理解是：模块是 package 的容器，是 package 的上一层。在模块里，可以输出（管理）当前模块哪些包是对外暴露（exports）的。同样的，当前模块需要别的模块，就要引用（requires）进来。 Java9模块化的例子 使用Idea创建一个项目 java-9-module-demo，添加两个模块： - module...
Java9_模块化
HealerJean梦想博客
10-10 2249
前言 1、必须是java文件夹下面才可以创建module-info.java，添加两个maven。module项目。分别为one和two module one { } module two { } 2、设置模块的依赖和权限 2.1、设置modulej级别为9（我的idea初始为5） 2.2、one中创建两个包和方法 package com.hlj.java9.can; ...
尚硅谷Java9新特性视频
03-20
主要包含：模块化系统，REPL工具：jshell命令，多版本兼容jar包，语法的新变化：接口私有方法、异常处理、钻石操作符、String存储结构变化等，新增API：Stream、List、Set、图像处理等。可以说java 9 的更新是一个...
Java9模块化开发核心原则与实践
07-07
总结，Java9的模块化系统是Java发展的一个重要里程碑，它带来了代码组织的新方式和更高效的运行时环境。理解并熟练掌握Java9的模块化开发，对于提升软件质量和开发效率具有重要意义。开发者应积极探索这一新特性，...
Java9的14个新特性总结
02-25
Java9中主要的变化是已经实现的模块化系统。模块化的引入使得JDK可以在更小的设备中使用。采用模块化系统的应用程序只需要这些应用程序所需的那部分JDK模块，而非是整个JDK框架了。模块化系统也可以将公共的类封装到...
Java9模块化demo
09-10
总的来说，Java 9 的模块化系统提供了一种更加有序、可维护的方式来组织和管理大型项目，降低了类路径冲突的风险，提升了程序的性能和安全性。通过理解和实践 `java9test` 中的示例，开发者可以更好地掌握这一关键...
Java9-模块化系统
Snakewood的博客
05-12 394
Java9模块化系统 笔记参考：https://www.bilibili.com/video/BV184411x7XA?p=31 首先新建一个Java9及以上的项目，之后再在项目中新建一个Module（同样要求Java9及以上），并在项目和Module中各自新建一个module-info.java文件（在src上右键->new->module-info.java） 建好后项目结构如下： 在项目java91011中新建一个Person类 package com.test; public c
Java中的模块化系统（如Jigsaw）
编程小弟的博客
04-12 682
Java的模块化系统，特别是通过Project Jigsaw引入的模块化系统，是Java平台的一个重要更新，它显著改变了Java代码的组织、封装和依赖管理方式。是Java模块化系统的主要项目，它的主要目标是提供更强的封装和更好的依赖管理。requires。
Java 9模块化系统：构建可扩展的应用程序
qq_38766930的博客
07-17 761
Java 9引入了模块化系统，也称为Jigsaw项目。模块化系统旨在解决Java应用程序的可扩展性和维护性问题。它引入了模块的概念，将代码组织为模块，提供了更好的封装和依赖管理机制。本教程将介绍Java 9模块化系统的基本概念、语法和用法。
java9模块化demo
哒哒的博客
10-31 748
1.关于java9模块化的认识 http://zhuanlan.51cto.com/art/201803/568615.htm 2.demo github地址https://github.com/zhangzhuo233/BigDataPractice.git demo路径ModuleTest 参考http://www.zebe.me/java-9-module-demo/ 2.1demo目录结构...
JAVA9新特性-模块化
Code Writers
12-29 668
模块是代码和数据集合。它可以包含Java代码和本地代码。Java代码被组织为一组包含诸如类，接口，枚举和注解等类型的类。数据可以包括诸如图像文件和配置文件的资源。一个模块不仅仅是一个包的容器。除了其名称，模块定义包含以下内容：所需的其他模块（或依赖于）的列表导出的软件包列表（其公共API），其他模块可以使用开放的软件包（其整个API，公共和私有）到其他反射访问模块的列表使用的服务列表（或使用java.util.ServiceLoader类发现和加载）提供的服务的实现列表。
java9新特性之模块化
魑魅魍魉
11-27 420
为了提高可靠的配置性和强大的封装性，我们将模块化看作是java程序组件的一个基本的新特性，这样它对开发者和可支持的工具更加友好。一个模块是一个被命名的，代码和数据的自描述的集合。它的代码有一系列包含类型的包组成，例如：java的类和接口。它的数据包括资源文件（resources）和一些其他的静态信息。 在idea新建一个java项目，再在这个java项目下创建两个module，如下图所示 然后在java9demo中创建两个类 在java9index中创建一个测试类Demo 此时在当前测.
Java模块化系统：引领代码革命与性能飞跃
最新发布
果子爸聊技术
05-02 1063
其实做过开发的都会想的到，模块化相当于要从整体上重构整个系统，结构调整巨大，对于整个系统考验是很大的，这可能也是JPMS从Java7开始准备，直到Java9才发布的原因。在说Java模块化系统之前，先来说说Java9之前的JDK在工程结构上的问题，从JDK本身的问题说起，Java从1996年发布第一版到2017年发布Java9，中间经历了近20年的时间，在这期间发布了无数个大大小小的版本用来支撑新的特性。类和包可以被模块化，只有模块之间声明的接口是对外可见的，提高了代码的封装性，减少了不必要的耦合。
【项目实战】Java9的新特性模块化（Module）
本本本添哥
01-15 1380
Java 9引入了模块化系统，称为"Java Platform Module System"（JPMS）这个系统允许将Java程序分成模块，每个模块都有自己的规范，可以明确地声明它依赖于哪些其他模块，并且只能访问被其所依赖的模块暴露的API。这样可以模块化就是增加了更高级别的聚合，是Package的封装体。Package是一些类路径名字的约定，而模块是一个或多个Package组成的封装体。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值