Modular Java (JPMS)

// File: src/main/java/module-info.java
//
// A "named module" needs exactly ONE module-info.java in its source root.
// Once this file exists, 'public' is no longer enough to be visible —
// the module decides what leaves the building. That is the whole point.

module com.myapp.core {                         // the module's unique name

    // requires: declare a dependency on ANOTHER module.
    // Without this line, even built-in java.sql is invisible to you.
    requires java.sql;                           // now you can import java.sql.*
    requires java.net.http;                      // and java.net.http.*

    // requires transitive: anyone who requires YOU also gets this module
    // for free (it "leaks" through your public API). Use it when your
    // exported types mention types from another module.
    requires transitive java.logging;            // consumers see java.util.logging too

    // exports: make ONE package readable + compilable by other modules.
    // Only these two packages are part of your public API.
    exports com.myapp.core.api;                  // visible to every module
    exports com.myapp.core.model;

    // Qualified export: only THIS named module may read the package.
    exports com.myapp.core.internal.testing to com.myapp.tests;  // friend access

    // opens: allow DEEP REFLECTION at runtime (setAccessible(true)) but
    // NOT compile-time access. Frameworks (Jackson, Hibernate, Spring) need
    // this to read your private fields. 'exports' alone does not grant it.
    opens com.myapp.core.model to com.fasterxml.jackson.databind;

    // uses: "I will look up implementations of this service at runtime."
    uses com.myapp.spi.PaymentProcessor;         // ServiceLoader will find them

    // provides ... with: "Here is MY implementation of that service."
    provides com.myapp.spi.PaymentProcessor
        with com.myapp.core.payment.StripeProcessor;
}

// Anything NOT exported (e.g. com.myapp.core.internal) is completely hidden
// from other modules — even reflection cannot reach it without 'opens'.
// That guarantee is called STRONG ENCAPSULATION.

// ===============================================================
// 1) The SPI module — defines the contract everyone agrees on.
//    File: payment-spi/src/main/java/module-info.java
// ===============================================================
module com.myapp.spi {
    exports com.myapp.spi;                       // the interface must be public API
}

// File: payment-spi/src/main/java/com/myapp/spi/PaymentProcessor.java
package com.myapp.spi;

public interface PaymentProcessor {
    String name();
    boolean process(double amount);
}

// ===============================================================
// 2) A provider module — registers ITS implementation via 'provides'.
//    File: payment-stripe/src/main/java/module-info.java
// ===============================================================
module com.myapp.stripe {
    requires com.myapp.spi;
    provides com.myapp.spi.PaymentProcessor
        with com.myapp.stripe.StripeProcessor;   // wires impl to the service
}

// File: payment-stripe/src/main/java/com/myapp/stripe/StripeProcessor.java
package com.myapp.stripe;

import com.myapp.spi.PaymentProcessor;

public class StripeProcessor implements PaymentProcessor {
    @Override public String name() { return "Stripe"; }
    @Override public boolean process(double amount) {
        System.out.println("Charging $" + amount + " via Stripe");   // pretend gateway
        return true;
    }
}

// ===============================================================
// 3) The consumer module — declares 'uses' and asks ServiceLoader.
//    File: app/src/main/java/module-info.java
// ===============================================================
module com.myapp.app {
    requires com.myapp.spi;
    uses com.myapp.spi.PaymentProcessor;         // promise to discover providers
}

// File: app/src/main/java/com/myapp/app/Main.java
package com.myapp.app;

import com.myapp.spi.PaymentProcessor;
import java.util.ServiceLoader;

public class Main {
    public static void main(String[] args) {
        // ServiceLoader scans the module path for every 'provides' of this type.
        ServiceLoader<PaymentProcessor> loader = ServiceLoader.load(PaymentProcessor.class);
        for (PaymentProcessor p : loader) {
            System.out.println("Discovered provider: " + p.name());
            p.process(100.00);
        }
    }
}

Discovered provider: Stripe
Charging $100.0 via Stripe

// 🎯 YOUR TURN #1 — finish this module-info.java
//
// You are building a "com.shop.orders" module. It must:
//   * use the built-in java.sql module (for the database)
//   * expose ONLY its com.shop.orders.api package to other modules
//   * let Jackson reflect over com.shop.orders.model to serialize JSON
//
// File: src/main/java/module-info.java

module com.shop.orders {

    // 1) Depend on the built-in SQL module
    ___ java.sql;                 // 👉 which directive declares a dependency?

    // 2) Publish the public API package (and ONLY that one)
    ___ com.shop.orders.api;      // 👉 which directive makes a package visible?

    // 3) Allow runtime reflection into the model package for Jackson
    ___ com.shop.orders.model to com.fasterxml.jackson.databind;
    //  👆 which directive grants reflection without compile-time access?
}

// ✅ Expected: line 1 = requires, line 2 = exports, line 3 = opens.
//    com.shop.orders.internal stays hidden because it is never exported.

// 🎯 YOUR TURN #2 — register a second payment provider
//
// You wrote a PayPalProcessor that implements com.myapp.spi.PaymentProcessor.
// Make ServiceLoader discover it WITHOUT touching the consumer's code.
//
// File: payment-paypal/src/main/java/module-info.java

module com.myapp.paypal {

    // 1) You need the interface, so depend on the SPI module
    requires ___;                                 // 👉 the module that exports the interface

    // 2) Announce your implementation to ServiceLoader
    provides com.myapp.spi.PaymentProcessor
        ___ com.myapp.paypal.PayPalProcessor;     // 👉 keyword that links service to impl
}

// ✅ Expected: requires com.myapp.spi;  and  provides ... WITH ...
//    Drop this module on the path and Main prints BOTH:
//    Discovered provider: Stripe
//    Discovered provider: PayPal

# --- Compile and run on the MODULE PATH (not the classpath) ---

# Compile all modules at once. --module-source-path teaches javac the layout.
$ javac --module-source-path src --module com.myapp.app -d out

# Run by naming module/MainClass. -p (= --module-path) replaces -cp.
$ java -p out -m com.myapp.app/com.myapp.app.Main
Discovered provider: Stripe
Charging $100.0 via Stripe

# --module classpath vs --module-path, side by side:
#   java -cp app.jar:lib.jar  com.myapp.app.Main   <-- classpath: flat, no encapsulation
#   java -p  out -m com.myapp.app/...Main          <-- module path: enforced boundaries

# --- jlink: build a CUSTOM RUNTIME with only the modules you use ---

# 1. Ask jdeps exactly which modules app.jar needs — no more, no less.
$ jdeps --print-module-deps --ignore-missing-deps app.jar
java.base,java.logging,java.net.http,java.sql

# 2. jlink stitches those modules into a self-contained runtime image.
$ jlink \
    --module-path "$JAVA_HOME/jmods:out" \
    --add-modules com.myapp.app \
    --launcher myapp=com.myapp.app/com.myapp.app.Main \
    --strip-debug --no-header-files --no-man-pages \
    --compress=zip-9 \
    --output dist/myapp-runtime

# 3. Run it on a machine with NO JDK installed — the runtime is bundled.
$ dist/myapp-runtime/bin/myapp
Discovered provider: Stripe
Charging $100.0 via Stripe

# 4. Typical size win (why this matters for Docker images):
#    Full JDK 21      ~ 320 MB
#    jlink runtime    ~  45 MB   <-- ships ONLY your modules + their deps

// 🎯 MINI-CHALLENGE: a "greeter" plugin system
//
// Build THREE tiny modules so a new greeting can be added by dropping a JAR:
//
//  1. com.greet.spi
//       - exports com.greet.spi
//       - contains  interface Greeter { String greet(String name); }
//
//  2. com.greet.formal  (a provider)
//       - requires com.greet.spi
//       - provides Greeter with a class that returns "Good day, <name>."
//
//  3. com.greet.app  (the consumer)
//       - requires com.greet.spi
//       - uses com.greet.spi.Greeter
//       - main(): ServiceLoader.load(Greeter.class), call greet("Sam") on each
//
//  Then ADD com.greet.casual (returns "Hey <name>!") with NO change to the app.
//
// ✅ Expected output once BOTH providers are on the module path:
//    Good day, Sam.
//    Hey Sam!
//
// Write the three module-info.java files and the classes here: