Introduction to Java Microservices with MSF4J – 使用MSF4J的Java微服务介绍

最后修改: 2018年 5月 23日

中文/混合/英文(键盘快捷键：t)

1. Overview

1.概述

In this tutorial, we’ll showcase microservices development using the MSF4J framework.

在本教程中，我们将展示使用MSF4J的微服务开发框架。

This is a lightweight tool which provides an easy way to build a wide variety of services focused on high performance.

这是一个轻量级的工具，它提供了一个简单的方法来构建各种专注于高性能的服务。

2. Maven Dependencies

2.Maven的依赖性

We’ll need a bit more Maven configuration than usual to build an MSF4J-based microservice. The simplicity and the power of this framework do come at a price: basically, we need to define a parent artifact, as well as the main class:

构建基于MSF4J的微服务，我们需要比平时多一点Maven配置。这个框架的简单性和强大性是有代价的。基本上，我们需要定义一个父神器，以及主类。

<parent>
    <groupId>org.wso2.msf4j</groupId>
    <artifactId>msf4j-service</artifactId>
    <version>2.6.0</version>
</parent>

<properties>
    <microservice.mainClass>
        com.baeldung.msf4j.Application
    </microservice.mainClass>
</properties>

The latest version of msf4j-service can be found on Maven Central.

msf4j-service的最新版本可以在Maven中心找到。

Next, we’ll show three different microservices scenarios. First a minimalistic example, then a RESTful API, and finally a Spring integration sample.

接下来，我们将展示三个不同的微服务场景。首先是一个最小化的例子，然后是一个RESTful API，最后是一个Spring集成样本。

3. Basic Project

3.基本项目

3.1. Simple API

3.1.简单的API

We’re going to publish a simple web resource.

我们要发布一个简单的网络资源。

This service is provided with a class using some annotations where each method handles a request. Through these annotations, we set the method, the path, and the parameters required for each request.

这个服务是通过一个使用一些注解的类来提供的，每个方法都处理一个请求。通过这些注解，我们设置了每个请求的方法、路径和所需的参数。

The returned content type is just plain text:

返回的内容类型只是纯文本。

@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;
    }
}

And remember that all classes and annotations used are just standard JAX-RS elements, which we already covered in this article.

并且记住，所有使用的类和注解都只是标准的JAX-RS元素，我们在本文中已经介绍了。

3.2. Application

3.2.应用

We can launch the microservice with this main class where we set, deploy and run the service defined earlier:

我们可以通过这个主类启动微服务，在这里我们设置、部署和运行之前定义的服务。

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

If we want, we can chain deploy calls here to run several services at once:

如果我们愿意，我们可以在这里连锁调用deploy，以一次运行几个服务。

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

3.3. Running the Microservice

3.3.运行微服务

To run the MSF4J microservice, we have a couple of options:

为了运行MSF4J微服务，我们有几个选择。

  1. On an IDE, running as a Java application
  2. Running the generated jar package

Once started, you can see the result at http://localhost:9090.

一旦开始，你可以在http://localhost:9090看到结果。

3.4. Startup Configurations

3.4.启动配置

We can tweak the configuration in a lot of ways just by adding some clauses to the startup code.

我们可以在很多方面调整配置，只需在启动代码中添加一些条款。

For example, we can add any kind of interceptor for the requests:

例如，我们可以为请求添加任何种类的拦截器。

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

Or, we can add a global interceptor, like one for authentication:

或者，我们可以添加一个全局拦截器，比如用于认证的拦截器。

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

Or, if we need session management, we can set a session manager:

或者，如果我们需要会话管理，我们可以设置一个会话管理器。

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

For more details about each of this scenarios and to see some working samples, check out MSF4J’s official GitHub repo.

有关每个方案的更多细节，以及查看一些工作样本，请查看MSF4J的官方GitHub repo。

4. Building an API Microservice

4.构建一个API微服务

We’ve shown the simplest example possible. Now we’ll move to a more realistic project.

我们已经展示了最简单的例子。现在我们将转到一个更现实的项目。

This time, we show how to build an API with all the typical CRUD operations to manage a repository of meals.

这一次，我们展示了如何建立一个具有所有典型CRUD操作的API来管理一个膳食库。

4.1. The Model

4.1.该模型

The model is just a simple POJO representing a meal:

该模型只是一个简单的POJO，代表了一顿饭。

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

    // getters and setters
}

4.2. The API

4.2.API

We build the API as a web controller. Using standard annotations, we set each function with the following:

我们将API构建为一个网络控制器。使用标准注解，我们为每个函数设置了以下内容。

  • URL path
  • HTTP method: GET, POST, etc.
  • input (@Consumes) content type
  • output (@Produces) content type

So, let’s create a method for each standard CRUD operation:

因此，让我们为每个标准的CRUD操作创建一个方法。

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

    private List<Meal> meals = new ArrayList<Meal>();

    @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. Data Conversion Features

4.3.数据转换功能

MSF4J offers support for different data conversion libraries such as GSON (which comes by default) and Jackson (through the msf4j-feature dependency). For example, we can use GSON explicitly:

MSF4J提供了对不同数据转换库的支持，如GSON（默认情况下带有）和Jackson（通过msf4j-feature依赖）。例如，我们可以明确地使用GSON。

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

In passing, note that we’ve used curly braces in both @Consumes and @Produces annotation so we can set more than one mime type.

顺带一提，注意我们在@Consumes和@Produces注解中都使用了大括号，所以我们可以设置一个以上的mime类型。

4.4. Running the API Microservice

4.4.运行API微服务

We run the microservice just as we did in the previous example, through an Application class that publishes the MenuService.

我们就像在前面的例子中一样，通过一个发布MenuService的Application类来运行微服务。

Once started, you can see the result at http://localhost:9090/menu.

一旦开始，你可以看到结果，http://localhost:9090/menu。

5. MSF4J and Spring

5.MSF4J和Spring

We can also apply Spring in our MSF4J based microservices, from which we’ll get its dependency injection features.

我们也可以在基于MSF4J的微服务中应用Spring，我们将从中获得其依赖注入功能。

5.1. Maven Dependencies

5.1.Maven的依赖性

We’ll have to add the appropriate dependencies to the previous Maven configuration to add Spring and Mustache support:

我们要在之前的Maven配置中添加相应的依赖项，以增加对Spring和Mustache的支持。

<dependencies>
    <dependency>
        <groupId>org.wso2.msf4j</groupId>
        <artifactId>msf4j-spring</artifactId>
        <version>2.6.1</version>
    </dependency>
    <dependency>
        <groupId>org.wso2.msf4j</groupId>
        <artifactId>msf4j-mustache-template</artifactId>
        <version>2.6.1</version>
    </dependency>
</dependencies>

The latest version of msf4j-spring and msf4j-mustache-template can be found on Maven Central.

最新版本的msf4j-spring和msf4j-mustache-template可以在Maven中心找到。

5.2. Meal API

5.2.膳食API

This API is just a simple service, using a mock meal repository. Notice how we use Spring annotations for auto-wiring and to set this class as a Spring service component.

这个API只是一个简单的服务，使用的是一个模拟的膳食库。注意到我们是如何使用Spring注解进行自动连接的，并将这个类设置为Spring服务组件。

@Service
public class MealService {
 
    @Autowired
    private MealRepository mealRepository;

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

    public List<Meal> findAll() {
        return mealRepository.findAll();
    }

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

5.3. Controller

5.3.控制器

We declare the controller as a component and Spring provides the service through auto-wiring. The first method shows how to serve a Mustache template and the second a JSON resource:

我们将控制器声明为一个组件，Spring通过自动连接提供服务。第一个方法展示了如何为Mustache模板服务，第二个方法展示了如何为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. Main Program

5.4.主程序

In the Spring scenario, this is how we get the microservice started:

在Spring场景中，这就是我们启动微服务的方式。

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. The default port differs in Spring projects, but we can set it to whatever port we want.

一旦启动，我们可以在http://localhost:8080/meals。默认端口在Spring项目中有所不同，但我们可以将其设置为我们想要的任何端口。

5.5. Configuration Beans

5.5.配置Bean

To enable specific settings, including interceptors and session management, we can add configuration beans.

为了启用特定的设置，包括拦截器和会话管理，我们可以添加配置Bean。

For example, this one changes the default port for the microservice:

例如，这个人改变了微服务的默认端口。

@Configuration
public class PortConfiguration {

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

}

6. Conclusion

6.结论

In this article, we’ve introduced the MSF4J framework, applying different scenarios to build Java-based microservices.

在这篇文章中，我们已经介绍了MSF4J框架，应用不同的场景来构建基于Java的微服务。

There is a lot of buzz around this concept, but some theoretical background has been already set, and MSF4J provides a convenient and standardized way to apply this pattern.

围绕着这个概念有很多议论，但是已经设定了一些理论背景，MSF4J提供了一个方便和标准化的方法来应用这个模式。

Also, for some further reading, take a look at building Microservices with Eclipse Microprofile, and of course our guide on Spring Microservices with Spring Boot and Spring Cloud.

此外，如需进一步阅读，请看使用Eclipse Microprofile构建微服务，当然还有我们关于Spring Microservices with Spring Boot and Spring Cloud的指南。

And finally, all the examples here can be found in the GitHub repo.

最后，这里的所有例子都可以在GitHub repo中找到。