sparkjava: i percorsi devono essere nel metodo principale?

Question

Sono nuovo di sparkjava e mi piace in generale. Tuttavia, i nuovi percorsi/endpoint devono essere definiti nel metodo principale? Per qualsiasi applicazione Web significativa, ciò comporterà un metodo main molto lungo o ho bisogno di avere più metodi principali (e quindi dividere le risorse del server tra più istanze).

Queste due pagine di documentazione di sparkjava sembrano definire percorsi nel metodo principale: http://sparkjava.com/documentation.html#routes e qui http://sparkjava.com/documentation.html#getting-started.

C'è un altro modo per farlo che non vedo? Superficiale google ricerca non mi ha mostrato un modo migliore ...

=========

Ecco la soluzione completa ho basa sulla risposta da Andrew. A mio parere, l'aggiunta di punti finali al di fuori del metodo principale dovrebbe essere parte della pagina di documentazione sparkjava:

Metodo principale:

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()); 
} 

mia risorsa:

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()); 
    } 
} 

Il mio servizio:

public class Service { 

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

    public Object findAll() { 
     return null; 
    } 
} 

My JsonTransformer:

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

Answer 1

È possibile impostare percorsi in cui si desidera. Hai solo bisogno del metodo di configurazione della chiamata nella discussione principale. per esempio.

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

È inoltre possibile integrare Spring nell'applicazione Spark. Ecco come ho configurato i miei percorsi.

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

Ciò consente di evitare la fase di chiamata di configurazione nel metodo Main di SparkApp.

Answer 3

Ecco un idea di design è possibile utilizzare quando ci sono più endpoint per configurare:

In primo luogo, creare un Interface Builder:

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

Ora, diciamo che dispone di una delle molte altre risorse endpoint di riposo da configurare:

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"; 
     }); 
    } 
} 

Infine, creare una classe RestContext che conterrà l'istanza di accensione e vi permetterà di configurare qualunque percorsi che si desidera:

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."); 
    } 
} 

Si dovrebbe essere in grado di utilizzare questa classe contesto nel metodo principale (e facoltativamente nelle vostre classi di test):

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, scintilla Java supporta più istanze attraverso il Servizio .ignite() api.