TOC

Introdução aos microsserviços Java com MSF4J

Introdução aos microsserviços Java com MSF4J

1. Visão geral

Neste tutorial, mostraremosmicroservices development using the MSF4Jframework.

Essa é uma ferramenta leve que fornece uma maneira fácil de criar uma ampla variedade de serviços focados em alto desempenho.

2. Dependências do Maven

Precisamos de um pouco mais de configuração do Maven do que o habitual para criar um microsserviço baseado no MSF4J. A simplicidade e o poder desta estrutura têm um preço:basically, we need to define a parent artifact, assim como a classe principal: 


    org.wso2.msf4j
    msf4j-service
    2.6.0



    
        com.example.msf4j.Application

A versão mais recente demsf4j-service pode ser encontrada no Maven Central.

A seguir, mostraremos três cenários diferentes de microsserviços. Primeiro, um exemplo minimalista, depois uma API RESTful e, finalmente, uma amostra de integração do Spring.

3. Projeto Básico

3.1. API simples

Vamos publicar um recurso simples da web.

Este serviço é fornecido com uma classe usando algumas anotações em que cada método lida com uma solicitação. Por meio dessas anotações, definimos o método, o caminho e os parâmetros necessários para cada solicitação.

O tipo de conteúdo retornado é apenas texto simples: 

@Path("/")
public class SimpleService {

    @GET
    public String index() {
        return "Default content";
    }

    @GET
    @Path("/say/{name}")
    public String say(@PathParam("name") String name) {
        return "Hello " + name;
    }
}

E lembre-se de que todas as classes e anotações usadas são apenas elementosstandard JAX-RS, que já cobrimosin this article.

3.2. Inscrição

We can launch the microservice with this main class onde definimos, implantamos e executamos o serviço definido anteriormente: 

public class Application {
    public static void main(String[] args) {
        new MicroservicesRunner()
          .deploy(new SimpleService())
          .start();
    }
}

Se quisermos, podemos encadear chamadasdeploy aqui para executar vários serviços ao mesmo tempo: 

new MicroservicesRunner()
  .deploy(new SimpleService())
  .deploy(new ComplexService())
  .start()

3.3. Executando o microsserviço

Para executar o microsserviço MSF4J, temos algumas opções:

  1. Em um IDE, executando como um aplicativo Java

  2. Executando o pacote jar gerado

Uma vez iniciado, você pode ver o resultado emhttp://localhost:9090.

3.4. Configurações de inicialização

We can tweak the configuration de várias maneiras apenas adicionando algumas cláusulas ao código de inicialização.

Por exemplo, podemos adicionar qualquer tipo de interceptador para as solicitações: 

new MicroservicesRunner()
  .addInterceptor(new MetricsInterceptor())
  .deploy(new SimpleService())
  .start();

Ou, podemos adicionar um interceptador global, como um para autenticação: 

new MicroservicesRunner()
  .addGlobalRequestInterceptor(newUsernamePasswordSecurityInterceptor())
  .deploy(new SimpleService())
  .start();

Ou, se precisarmos de gerenciamento de sessões, podemos definir um gerenciador de sessões: 

new MicroservicesRunner()
  .deploy(new SimpleService())
  .setSessionManager(new PersistentSessionManager())
  .start();

Para mais detalhes sobre cada um desses cenários e para ver alguns exemplos de trabalho, verifique oofficial GitHub repo de MSF4J.

4. Construindo um microsserviço de API

Mostramos o exemplo mais simples possível. Agora vamos passar para um projeto mais realista.

Desta vez, mostramos como criar uma API com todas as operações CRUD típicas para gerenciar um repositório de refeições.

4.1. O Modelo

O modelo é apenas um POJO simples que representa uma refeição: 

public class Meal {
    private String name;
    private Float price;

    // getters and setters
}

4.2. A API

Criamos a API como um controlador da web. Usando anotações padrão, definimos cada função com o seguinte:

  • Caminho do URL

  • Método HTTP: GET, POST, etc.

  • tipo de conteúdo de entrada (@Consumes)

  • tipo de conteúdo de saída (@Produces)

Então, vamos criar um método para cada operação CRUD padrão: 

@Path("/menu")
public class MenuService {

    private List meals = new ArrayList();

    @GET
    @Path("/")
    @Produces({ "application/json" })
    public Response index() {
        return Response.ok()
          .entity(meals)
          .build();
    }

    @GET
    @Path("/{id}")
    @Produces({ "application/json" })
    public Response meal(@PathParam("id") int id) {
        return Response.ok()
          .entity(meals.get(id))
          .build();
    }

    @POST
    @Path("/")
    @Consumes("application/json")
    @Produces({ "application/json" })
    public Response create(Meal meal) {
        meals.add(meal);
        return Response.ok()
          .entity(meal)
          .build();
    }

    // ... other CRUD operations
}

4.3. Recursos de conversão de dados

MSF4J offers support for different data conversion libraries, como GSON (que vem por padrão) e Jackson (por meio da dependênciamsf4j-feature). Por exemplo, podemos usar o GSON explicitamente: 

@GET
@Path("/{id}")
@Produces({ "application/json" })
public String meal(@PathParam("id") int id) {
    Gson gson = new Gson();
    return gson.toJson(meals.get(id));
}

De passagem, observe que usamos chaves nas anotações@Consumese@Produces para que possamos definir mais de um tipo MIME.

4.4. Executando o microsserviço da API

Executamos o microsserviço da mesma forma que fizemos no exemplo anterior, por meio de uma classeApplication que publicaMenuService.

Uma vez iniciado, você pode ver o resultado emhttp://localhost:9090/menu.

5. MSF4J e Spring

We can also apply Spring in our MSF4J based microservices, a partir do qual obteremos seus recursos de injeção de dependência.

5.1. Dependências do Maven

Teremos que adicionar as dependências apropriadas à configuração anterior do Maven para adicionar suporte a Spring e Mustache: 


    
        org.wso2.msf4j
        msf4j-spring
        2.6.1
    
    
        org.wso2.msf4j
        msf4j-mustache-template
        2.6.1

A versão mais recente demsf4j-springemsf4j-mustache-template pode ser encontrada no Maven Central.

5.2. API refeição

Essa API é apenas um serviço simples, usando um repositório de refeições simulado. Notice how we use Spring annotations for auto-wiring e para definir esta classe como um componente de serviço Spring. 

@Service
public class MealService {

    @Autowired
    private MealRepository mealRepository;

    public Meal find(int id) {
        return mealRepository.find(id);
    }

    public List findAll() {
        return mealRepository.findAll();
    }

    public void create(Meal meal) {
        mealRepository.create(meal);
    }
}

5.3. Controlador

Declaramos o controlador como um componente e a Spring fornece o serviço através da fiação automática. O primeiro método mostra como servir um modelo de bigode e o segundo um recurso JSON: 

@Component
@Path("/meal")
public class MealResource {

    @Autowired
    private MealService mealService;

    @GET
    @Path("/")
    public Response all() {
        Map map = Collections.singletonMap("meals", mealService.findAll());
        String html = MustacheTemplateEngine.instance()
          .render("meals.mustache", map);
        return Response.ok()
          .type(MediaType.TEXT_HTML)
          .entity(html)
          .build();
    }

    @GET
    @Path("/{id}")
    @Produces({ "application/json" })
    public Response meal(@PathParam("id") int id) {
        return Response.ok()
          .entity(mealService.find(id))
          .build();
    }

}

5.4. Programa principal

No cenário do Spring, é assim que começamos o microsserviço: 

public class Application {

    public static void main(String[] args) {
        MSF4JSpringApplication.run(Application.class, args);
    }
}

Once started, we can see the result at http://localhost:8080/meals. A porta padrão difere em projetos Spring, mas podemos configurá-la para qualquer porta que quisermos.

5.5. Beans de configuração

Para habilitar configurações específicas, incluindo interceptores e gerenciamento de sessões, podemos adicionar beans de configuração.

Por exemplo, este altera a porta padrão para o microsserviço: 

@Configuration
public class PortConfiguration {

    @Bean
    public HTTPTransportConfig http() {
        return new HTTPTransportConfig(9090);
    }

}

6. Conclusion

Neste artigo, apresentamos a estrutura MSF4J, aplicando diferentes cenários para construir microsserviços baseados em Java.

Há muito buzz em torno desse conceito, massome theoretical background has been already set e MSF4J fornecem uma maneira conveniente e padronizada de aplicar esse padrão.

Além disso, para mais leitura, dê uma olhada embuilding Microservices with Eclipse Microprofile e, claro, nosso guia emSpring Microservices with Spring Boot and Spring Cloud.

E, finalmente, todos os exemplos aqui podem ser encontradosin the GitHub repo.

Related