Module Dependencies and Services in Java

Master module dependencies, requires directive, exports directive, services, providers, consumers, and service-oriented architecture for the OCP 21 exam.

Table of Contents

• 1. Module Dependencies
• 2. requires Directive
• 3. exports Directive
• 4. Transitive Dependencies
• 5. Module Services
• 6. Service Providers and Consumers
• 7. Exam Key Points

1. Module Dependencies

Module dependencies define what other modules a module needs to function. Dependencies must be explicitly declared.

1.1 Dependency Types

• Standard Dependencies: Required at compile-time and runtime
• Optional Dependencies: Required only at compile-time
• Transitive Dependencies: Re-exported to dependent modules

2. requires Directive

The requires directive declares a dependency on another module.

2.1 Basic requires

Example:

module com.example.mymodule {
    requires java.sql;                    // Standard dependency
    requires com.example.othermodule;     // Application module dependency
    requires java.base;                   // Implicit, but can be explicit
}

2.2 requires static (Optional Dependency)

Example:

module com.example.mymodule {
    requires static com.example.optional;  // Optional - only needed at compile-time
    
    // Code can check if module is available at runtime
    if (ModuleLayer.boot().findModule("com.example.optional").isPresent()) {
        // Use optional module
    }
}

3. exports Directive

The exports directive makes packages accessible to other modules.

3.1 Basic exports

Example:

module com.example.mymodule {
    exports com.example.mymodule.api;           // Export to all modules
    exports com.example.mymodule.util;          // Export to all modules
    // com.example.mymodule.internal is NOT exported (encapsulated)
}

3.2 Qualified exports

Example:

module com.example.mymodule {
    // Export only to specific modules
    exports com.example.mymodule.internal to com.example.consumer;
    exports com.example.mymodule.config to com.example.framework, com.example.test;
}

4. Transitive Dependencies

The requires transitive directive makes a dependency available to modules that depend on the current module.

4.1 Transitive requires

Example:

// Module A
module com.example.moduleA {
    requires transitive com.example.moduleB;  // Re-exported
}

// Module B
module com.example.moduleB {
    exports com.example.moduleB.api;
}

// Module C - can access moduleB without explicit requires
module com.example.moduleC {
    requires com.example.moduleA;  // Automatically gets access to moduleB
    // Can use com.example.moduleB.api without requires com.example.moduleB
}

5. Module Services

Module services provide a way to decouple service interfaces from their implementations using the ServiceLoader mechanism.

5.1 Service Interface

Example:

// Service interface
package com.example.service;

public interface PaymentService {
    void processPayment(double amount);
}

// Service implementation 1
package com.example.impl;
public class CreditCardService implements PaymentService {
    public void processPayment(double amount) {
        System.out.println("Processing credit card payment: " + amount);
    }
}

// Service implementation 2
package com.example.impl;
public class PayPalService implements PaymentService {
    public void processPayment(double amount) {
        System.out.println("Processing PayPal payment: " + amount);
    }
}

6. Service Providers and Consumers

6.1 Provider Module

Example:

// Provider module
module com.example.payment.provider {
    requires com.example.service;  // Service interface module
    
    provides com.example.service.PaymentService 
        with com.example.impl.CreditCardService,
             com.example.impl.PayPalService;
}

6.2 Consumer Module

Example:

// Consumer module
module com.example.application {
    requires com.example.service;  // Service interface module
    
    uses com.example.service.PaymentService;
}

// Using the service
import com.example.service.PaymentService;
import java.util.ServiceLoader;

ServiceLoader<PaymentService> loader = ServiceLoader.load(PaymentService.class);
for (PaymentService service : loader) {
    service.processPayment(100.0);
}

7. Exam Key Points

Critical Concepts for OCP 21 Exam:

• requires: Declares dependency on another module
• requires static: Optional dependency (compile-time only)
• requires transitive: Re-exports dependency to dependent modules
• exports: Makes packages accessible to other modules
• exports to: Qualified export to specific modules
• uses: Declares use of a service interface
• provides: Provides service implementation
• ServiceLoader: Mechanism for loading service implementations
• Transitive Dependencies: Automatically available to dependent modules
• Service Architecture: Decouples interface from implementation