Pregunta sparkjava: ¿Las rutas tienen que estar en el método principal?


Soy nuevo en sparkjava y me gusta en general. Sin embargo, ¿se deben definir nuevas rutas / puntos finales en el método principal? Para cualquier aplicación web significativa, esto resultará en un método principal muy largo o necesito tener múltiples métodos principales (y por lo tanto dividir los recursos del servidor entre varias instancias).

Estas dos páginas de documentación de sparkjava parecen definir rutas en el método principal: http://sparkjava.com/documentation.html#routes y aquí http://sparkjava.com/documentation.html#getting-started.

¿Hay otra manera de hacer esto que no estoy viendo? La búsqueda de Google en cursores no me ha mostrado una mejor manera ...

=========

Aquí está la solución completa que hice basada en la respuesta de Andrew. En mi opinión, agregar puntos finales fuera del método principal debería formar parte de la página de documentación de sparkjava:

Método principal:

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

Mi recurso:

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

Mi servicio:

public class Service {

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

    public Object findAll() {
        return null;
    }
}

Mi JsonTransformer:

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

5
2018-01-24 13:38


origen


Respuestas:


Puedes establecer rutas donde quieras. Solo necesitas el método de configuración de llamadas en el hilo principal. p.ej.

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

7
2018-01-24 21:40



Aquí hay una idea de diseño que puede usar cuando hay varios puntos finales para configurar:

Primero, crea una interfaz de generador:

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

Ahora, supongamos que tiene uno de muchos otros recursos de puntos finales de descanso para configurar:

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

Finalmente, cree una clase RestContext que contendrá la instancia de chispa y le permitirá configurar las rutas que desee:

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

Debería poder usar esta clase de contexto en su método principal (y opcionalmente en sus clases de prueba):

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 .: Desde la versión 2.5, spark java admite múltiples instancias a través del Service.ignite () Api.


7
2018-05-17 11:30



También puede integrar Spring en su aplicación Spark. Así es como he configurado mis rutas.

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

Esto me permite evitar el paso de invocación de configuración en el método principal de SparkApp.


3
2018-02-06 20:00



Preguntas populares