Sua tentativa de adicionar src/main/resourcesao caminho do módulo não funcionará conforme o esperado. Simplesmente adicionar diretórios ao caminho do módulo não torna o conteúdo deles parte do seu módulo. Você precisa:

1. Tenha as classes e os recursos no mesmo local, seja um diretório ou um arquivo JAR. Isso torna os recursos parte do módulo. E observe que é por isso que seu arquivo JAR funciona conforme o esperado, porque você empacotou as classes e os recursos no mesmo arquivo JAR.

   Essa abordagem é essencialmente como "deveria ser feita".

2. Use --patch-moduleem tempo de execução. Observe que esta abordagem não requer a movimentação dos arquivos de recursos para qualquer lugar.

   Além disso, você usaria esse argumento em tempo de compilação se estivesse tentando opensum pacote somente de recursos; caso contrário, será emitido um aviso informando que o pacote não existe. Embora, se bem me lembro, você receberá um erro em tempo de execução neste cenário (onde um opens pacote não é inerentemente parte do módulo), mesmo com um --patch-moduleargumento.

Dito isso, recomendo usar uma ferramenta de construção (por exemplo, Maven, Gradle, etc.) para projetos Java não triviais. Eles normalmente cuidarão de tudo isso para você.

Exemplo

Aqui está um exemplo de ambas as abordagens discutidas acima. Observe que todos os comandos foram executados no diretório do projeto no Windows 10 usando PowerShell Core 7.2.13 e Java 20.0.1.

Embora a saída abaixo liste diretórios de recursos , bem como recursos reais, isso não é garantido. Na verdade, se não me engano, esses mesmos diretórios não serão listados quando o módulo for empacotado em uma imagem de tempo de execução (via / jlink) jpackage.

Código fonte

O código-fonte é o mesmo em ambas as abordagens.

informações do módulo

module app {}

amostra.Principal

package sample;

public class Main {

    public static void main(String[] args) throws Exception {
        var module = Main.class.getModule();
        var reference = module.getLayer()     // ModuleLayer
                .configuration()              // Configuration
                .findModule(module.getName()) // Optional<ResolvedModule>
                .orElseThrow()                // ResolvedModule
                .reference();                 // ModuleReference
        try (var reader = reference.open()) {
            reader.list().forEach(System.out::println);
        }
    }
}

Estrutura de diretório

<PROJECT-DIR>
|
\---src
    \---main
        +---java
        |   \---app
        |       |   module-info.java
        |       |
        |       \---sample
        |               Main.java
        |
        \---resources
            \---app
                \---foo
                        res.txt

Observe que adicionei um app"diretório de módulo" src/main/resourcessimplesmente para espelhar o que foi feito src/main/java(o que é necessário se você quiser usar --module-source-pathe --modulecom javac). Isso não é necessário, embora não fosse necessário alterar ligeiramente os comandos usados ​​​​abaixo (apenas alterações nos caminhos).

Abordagem 1 – Mesclar Classes e Recursos

Comandos

& javac --module-source-path src\main\java --module app -d build\classes
& robocopy src\main\resources build\classes /S > NUL
& java --module-path build\classes --module app/sample.Main

Saída

foo/
foo/res.txt      
module-info.class
sample/
sample/Main.class

Como você pode ver, o recurso foo/res.txt(e até mesmo o diretório foo/) foi listado.

Estrutura de diretório (após executar comandos)

<PROJECT-DIR>
|
+---build
|   \---classes
|       \---app
|           |   module-info.class   
|           |
|           +---foo
|           |       res.txt
|           |
|           \---sample
|                   Main.class      
|
\---src
    \---main
        +---java
        |   \---app
        |       |   module-info.java
        |       |
        |       \---sample
        |               Main.java   
        |
        \---resources
            \---app
                \---foo
                        res.txt 

Abordagem 2 - Uso--patch-module

Comandos

& javac --module-source-path src\main\java --module app -d build\classes
& java --module-path build\classes --patch-module app=src\main\resources\app --module app/sample.Main

Saída

module-info.class
sample/
sample/Main.class
foo/
foo/res.txt

Novamente, você pode ver que o recurso foo/res.txt(e o diretório foo/) foi listado.

Estrutura de diretório (após executar comandos)

<PROJECT-DIR>
|
+---build
|   \---classes
|       \---app
|           |   module-info.class
|           |
|           \---sample
|                   Main.class
|
\---src
    \---main
        +---java
        |   \---app
        |       |   module-info.java
        |       |
        |       \---sample
        |               Main.java
        |
        \---resources
            \---app
                \---foo
                        res.txt