Javalin with Java Platform Module System (JPMS) and Gradle

package org.example.api;

public class MyAPI {
    public static void main(String[] args) {
        System.out.println("API's kind of alive already :-)");
    }
}

package org.example.models;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package org.example.services.api;

import org.example.models.Person;

import java.util.List;

public interface PersonReader {
    List<Person> getAll();
}

package org.example.services.inmemory;

import org.example.models.Person;
import org.example.services.api.PersonReader;

import java.util.List;

public class InMemoryPersonReader implements PersonReader {
    @Override
    public List<Person> getAll() {
        return List.of(
            new Person("Vincent Vega", 73),
            new Person("Jules Winnfield", 12)
        );
    }
}

package org.example.api;

import com.fasterxml.jackson.databind.ObjectMapper;
import io.javalin.Javalin;
import org.example.services.inmemory.InMemoryPersonReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyAPI {
    private static Logger logger = LoggerFactory.getLogger(MyAPI.class);
    private static short port = 7312;

    public static void main(String[] args) {
        var personReader = new InMemoryPersonReader();
        var objMapper = new ObjectMapper();
        var result = objMapper.valueToTree(personReader.getAll());

        logger.info("API: found {} people.", personReader.getAll().size());

        var app = Javalin.create().start(port);
        app.get("/ping", ctx -> ctx.result("pong"));
        app.get("/persons", ctx -> ctx.json(result));

        logger.info("API's alive for real :-)))");
    }
}

module org.example.models {
    // We're exporting the only package we have in this subproject
    exports org.example.models;
}

module org.example.services {
    // Export both packages api and inmemory for now
    exports org.example.services.api;
    exports org.example.services.inmemory;

    // Since we're using the Person class we're requiring the org.example.models module
    requires org.example.models;}

module org.example.api {
    // For Javalin, the ObjectMapper and the Logger & LoggerFactory to work we need to add these require statements
    requires io.javalin;
    requires com.fasterxml.jackson.databind;
    requires org.slf4j;

    // And since we're working with the InMemoryPersonReader we have to add this require statement as well
    requires org.example.services;
}

import org.example.services.api.PersonReader;
import org.example.services.inmemory.InMemoryPersonReader;

module org.example.services {
    exports org.example.services.api;

    requires org.example.models;

    // We're telling the ServiceLoader that the InMemoryPersonReader provides the implementation for the PersonReader interface
    provides PersonReader with InMemoryPersonReader;
}

package org.example.api;

import com.fasterxml.jackson.databind.ObjectMapper;
import io.javalin.Javalin;
import org.example.services.api.PersonReader;        // <-- this is one is new, and we're no longer importing the InMemoryPersonReader
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ServiceLoader;                      // <-- importing the ServiceLoader

public class MyAPI {
    private static Logger logger = LoggerFactory.getLogger(MyAPI.class);
    private static short port = 7312;

    public static void main(String[] args) {
        var personReader = ServiceLoader.load(PersonReader.class).findFirst().get();     // <-- Getting an implementation for the PersonReader interface from the ServiceLoader
        var objMapper = new ObjectMapper();
        var result = objMapper.valueToTree(personReader.getAll());

        logger.info("API: found {} people.", personReader.getAll().size());

        var app = Javalin.create().start(port);
        app.get("/ping", ctx -> ctx.result("pong"));
        app.get("/persons", ctx -> ctx.json(result));

        logger.info("API's alive for real :-)))");
    }
}

module org.example.api {
    requires io.javalin;
    requires com.fasterxml.jackson.databind;
    requires org.slf4j;

    requires org.example.services;

    uses org.example.services.api.PersonReader;    // <-- add this line
}

module org.example.api {
    requires io.javalin;
    requires com.fasterxml.jackson.databind;
    requires org.slf4j;
    requires kotlin.stdlib;                // <-- add this line

    requires org.example.services;

    uses org.example.services.api.PersonReader;
}

package org.example.services.api;

import org.example.models.Person;

public interface PersonFilter {
    boolean filter(Person p);
}

package org.example.services.filter;

import org.example.models.Person;
import org.example.services.api.PersonFilter;

public class AtLeastEighteenFilter implements PersonFilter {
    @Override
    public boolean filter(Person p) {
        return p.getAge() >= 18;
    }
}

package org.example.services.inmemory;

import org.example.models.Person;
import org.example.services.api.PersonFilter;
import org.example.services.api.PersonReader;

import java.util.List;
import java.util.ServiceLoader;

public class InMemoryPersonReader implements PersonReader {

    private PersonFilter filter;

    // Note the injected filter in our constructor which is stored in our privat member
    public InMemoryPersonReader(PersonFilter filter) {
        this.filter = filter;
    }

    @Override
    public List<Person> getAll() {
        return List.of(
            new Person("Vincent Vega", 73),
            new Person("Jules Winnfield", 12)
        );
        ).stream().filter(this.filter::filter).toList(); // And here we apply the filter
    }
}

import org.example.services.api.PersonFilter;
import org.example.services.api.PersonReader;
import org.example.services.filter.AtLeastEighteenFilter;
import org.example.services.inmemory.InMemoryPersonReader;

module org.example.services {
    exports org.example.services.api;

    requires org.example.models;

    provides PersonReader with InMemoryPersonReader;

    // Let's register our implementation with the following line
    provides PersonFilter with AtLeastEighteenFilter;

    // And we also have to state that our services module uses a service of type PersonFilter. 
    // You still have to do this even though the service itself is defined in our own module.
    uses PersonFilter;
}

package org.example.services.inmemory;

import org.example.models.Person;
import org.example.services.api.PersonFilter;
import org.example.services.api.PersonReader;

import java.util.List;
import java.util.ServiceLoader;

public class InMemoryPersonReader implements PersonReader {

    private PersonFilter filter;

    public InMemoryPersonReader(PersonFilter filter) {
        this.filter = filter;
    }

    @Override
    public List<Person> getAll() {
        return List.of(
            new Person("Vincent Vega", 73),
            new Person("Jules Winnfield", 12)
        );
        ).stream().filter(this.filter::filter).toList();
    }

    // See the provider method in action: static method named "provider" not having any formal parameters
    public static PersonReader provider() {
        return new InMemoryPersonReader(            // We need to instantiate the implementation ourselves                                     
            ServiceLoader.load(PersonFilter.class)  // and we also have to resolve the dependencies ourselves via the ServiceLoader
                .findFirst()
                .get()                              // For the sake of completeness: in some real code cater for resolving errors :-)
        );
    }
}

// Dedicated class only container the provider method
public class PersonReaderProvider {
    public static PersonReader provider() {
        return new InMemoryPersonReader(
                ServiceLoader.load(PersonFilter.class).findFirst().get()
        );

    }
}

module org.example.services {
    ...

    // Comment this one out since we have our dedicated provider now
    // provides PersonReader with InMemoryPersonReader;

    // And tell the module system to use our dedicated provider to get an instance of our service provider
    provides PersonReader with PersonReaderProvider;

    ...
}