sparkjava: Müssen Routen in der Hauptmethode sein?

Question

Ich bin neu bei sparkjava und mag es insgesamt. Müssen jedoch neue Routen/Endpunkte in der Hauptmethode definiert werden? Für jede signifikante Webanwendung führt dies zu einer sehr langen Hauptmethode, oder ich benötige mehrere Hauptmethoden (und teile daher Serverressourcen auf mehrere Instanzen auf).

Diese beiden Dokumentationsseiten von sparkjava scheinen Routen in der Hauptmethode zu definieren: http://sparkjava.com/documentation.html#routes und hier http://sparkjava.com/documentation.html#getting-started.

Gibt es eine andere Möglichkeit, dies zu tun, die ich nicht sehe? Flüchtige Google-Suche hat mir keinen besseren Weg gezeigt ...

=========

Hier ist die vollständige Lösung, die ich auf die Antwort von Andrew basiert hat.

Haupt Methode:

public static void main(String[] args) { 
    //Do I need to do something more with the Resource instance so that sparkjava notices it and/or reads the routes? 
    Resource resource= new Resource(new Service()); 
} 

Meine Ressource:

import static spark.Spark.*; 
class Resource{ 

    private Service service; 

    Resource(Service service){ 
     this.service = service; 
     setupEndpoints(); 
    } 

    private void setupEndpoints() { 

     get("/user/:id", "application/json",(request, response) 
       -> service.find(request.params(":id")), new JsonTransformer()); 

     get("/users", "application/json", (request, response) 
       -> service.findAll(), new JsonTransformer()); 
    } 
} 

Mein Service:

Meiner Meinung nach ist das Hinzufügen Endpunkte außerhalb des Hauptverfahrens sollte ein Teil der sparkjava Dokumentation Seite sein

public class Service { 

    public Object find(String id) { 
     return null; 
    } 

    public Object findAll() { 
     return null; 
    } 
} 

Mein JsonTransformer:

import spark.ResponseTransformer; 
public class JsonTransformer implements ResponseTransformer { 
    @Override 
    public String render(Object model) throws Exception { 
     return null; 
    } 
} 

Answer 1

Sie können Routen festlegen, wo Sie möchten. Sie brauchen nur Call-Setup-Methode im Haupt-Thread. z.B.

public static void main(String[] args){ 
    Resource resource= new Resource(new Service()); 
} 

class Resource{ 

    private Service service; 

    Resource(Service service){ 
     this.service = service; 
     setupEndpoints(); 
    } 

    private void setupEndpoints() { 

     get("/user/:id", "application/json",(request, response) 
      -> service.find(request.params(":id")), new JsonTransformer()); 

     get("/users", "application/json", (request, response) 
      -> service.findAll(), new JsonTransformer()); 
    } 
} 

Answer 2

Sie können Spring auch in Ihre Spark-Anwendung integrieren. So habe ich meine Routen konfiguriert.

@Configuration 
public class RoutesConfiguration { 
    RoutesConfiguration() { 
     get("/hello", (req, res) -> "Hello World!"); 
    } 
} 

Dadurch kann ich den Setup-Aufruf Schritt in der Main-Methode der SparkApp vermeiden.

Answer 3

Hier ist eine Design-Idee Sie verwenden können, wenn es mehrere Endpunkte konfigurieren:

zunächst eine Builder-Schnittstelle erstellen:

public interface EndpointBuilder { 
    void configure(Service spark, String basePath); 
} 

Nun lassen Sie uns sagen, dass Sie eine der vielen anderen Rest Endpunkte Ressourcen einzurichten:

public class CustomerEndpoint implements EndpointBuilder { 

    private final CustomerService customerService; 

    public CustomerEndpoint(CustomerService service) { 
     this.customerService = service; 
    } 

    @Override 
    public void configure(Service spark, String basePath) { 

     spark.get(basePath + "/customer", (req, res) -> { 
      return "hello"; 
     }); 
    } 
} 

Schließlich erstellen Sie eine RestContext Klasse, die die Funken Instanz halten und ermöglicht es Ihnen, zu konfigurieren, was Routen, die Sie wünschen:

public class RestContext { 

    private static final Logger logger = LoggerFactory.getLogger(RestContext.class); 

    private final Service spark; 

    private final String basePath; 

    public RestContext(int port, String basePath) { 
     this.basePath = basePath; 
     spark = Service.ignite().port(port); // import spark.Service; 
    } 

    public void addEndpoint(EndpointBuilder endpoint) { 

     endpoint.configure(spark, basePath); 
     logger.info("REST endpoints registered for {}.", endpoint.getClass().getSimpleName()); 
    } 

    // Then you can even have some fun: 
    public void enableCors() { 

     spark.before((request, response) -> { 
      response.header("Access-Control-Allow-Origin", "*"); 
      response.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS"); 
      response.header("Access-Control-Allow-Headers", "Content-Type, api_key, Authorization"); 
     }); 

     logger.info("CORS support enabled."); 
    } 
} 

Sie sollten in der Lage sein, diese Kontextklasse in der Hauptmethode zu verwenden (und optional in Ihrer Testklasse):

public static void main(String... args) { 

    RestContext context = new RestContext(8080, "/api"); 

    context.addEndpoint(new CustomerEndpoint(new CustomerService())); 
    context.addEndpoint(new AnotherEndpoint()); // you can add or remove as many as you want. 

    context.enableCors(); 
} 

Obs .: Since version 2.5 unterstützt Funken Java mehrere Instanzen durch den Dienst .ignite() api.