手順

1. dev.snowdrop:snowdrop-dependencies アーティファクトをプロジェクトの pom.xml の <dependencyManagement> セクションに追加し、<type> 属性値および <scope> 属性値を指定します。

   <project>
     ...
     <dependencyManagement>
       <dependencies>
         <dependency>
           <groupId>dev.snowdrop</groupId>
           <artifactId>snowdrop-dependencies</artifactId>
           <version>2.2.11.SP1-redhat-00001</version>
           <type>pom</type>
           <scope>import</scope>
         </dependency>
       </dependencies>
     </dependencyManagement>
     ...
   </project>

2. 以下のプロパティーを追加して、使用している Spring Boot Maven プラグインのバージョンを追跡します。

   <project>
     ...
     <properties>
       <spring-boot-maven-plugin.version>2.2.11.RELEASE</spring-boot-maven-plugin.version>
     </properties>
     ...
   </project>

3. BOM およびサポートされる Spring Boot Starters および Spring Boot Maven プラグインを含むリポジトリーの名前と URL を指定します。

     <!-- Specify the repositories containing Spring Boot artifacts. -->
     <repositories>
       <repository>
         <id>redhat-ga</id>
         <name>Red Hat GA Repository</name>
         <url>https://maven.repository.redhat.com/ga/</url>
       </repository>
     </repositories>
   
     <!-- Specify the repositories containing the plugins used to execute the build of your application. -->
     <pluginRepositories>
       <pluginRepository>
         <id>redhat-ga</id>
         <name>Red Hat GA Repository</name>
         <url>https://maven.repository.redhat.com/ga/</url>
       </pluginRepository>
     </pluginRepositories>

4. spring-boot-maven-plugin を Maven がアプリケーションのパッケージ化に使用するプラグインとして追加します。

   <project>
     ...
     <build>
        ...
       <plugins>
           ...
           <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
             <version>${spring-boot-maven-plugin.version}</version>
             <executions>
               <execution>
                   <goals>
                       <goal>repackage</goal>
                   </goals>
               </execution>
             </executions>
               <configuration>
                 <redeploy>true</redeploy>
               </configuration>
         </plugin>
         ...
       </plugins>
      ...
     </build>
     ...
   </project>

手順

1. dev.snowdrop:snowdrop-dependencies アーティファクトを pom.xml の <parent> セクションに追加します。

   <project>
     ...
     <parent>
       <groupId>dev.snowdrop</groupId>
       <artifactId>snowdrop-dependencies</artifactId>
       <version>2.2.11.SP1-redhat-00001</version>
     </parent>
     ...
   </project>

2. spring-boot-maven-plugin を Maven がアプリケーションを pom.xml の <build> セクションにパッケージ化するために使用するプラグインとして追加します。プラグインバージョンは、親 BOM により自動的に管理されます。

   <project>
     ...
     <build>
        ...
       <plugins>
           ...
         <plugin>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-maven-plugin</artifactId>
           <executions>
               <execution>
                   <goals>
                       <goal>repackage</goal>
                   </goals>
               </execution>
           </executions>
           <configuration>
               <redeploy>true</redeploy>
           </configuration>
         </plugin>
         ...
       </plugins>
      ...
     </build>
     ...
   </project>

手順

1. Developer Launcher (developers.redhat.com/launch) に移動します。
2. Start をクリックします。
3. Deploy an Example Application をクリックします。
4. Select an Example をクリックし、ランタイムで使用できるサンプルアプリケーションの一覧を表示します。
5. ランタイムを選択します。

6. サンプルアプリケーションを選択します。

   注記

   複数のランタイムで利用できるアプリケーションの例もあります。前の手順でランタイムを選択していない場合は、サンプルアプリケーションで利用できるランタイムの一覧からランタイムを選択できます。

7. ランタイムのリリースバージョンを選択します。ランタイムに一覧表示されているコミュニティーまたは製品リリースから選択できます。
8. Save をクリックします。

9. Download をクリックして、サンプルアプリケーションをダウンロードします。

   ソースおよびドキュメントファイルを含む ZIP ファイルがダウンロードされます。

手順

1. サンプルアプリケーションをダウンロードします。

2. oc コマンドラインクライアントを使用して、サンプルアプリケーションを OpenShift Container Platform または CDK (Minishift) にデプロイできます。

   Web コンソールによって提供されるトークンを使用してクライアントを認証する必要があります。アプリケーションをデプロイする場所に応じて、OpenShift Container Platform Web コンソールまたは CDK (Minishift) Web コンソールを使用します。以下の手順を実行してクライアントの認証を取得します。

   1. Web コンソールにログインします。
   2. Web コンソールの右上隅にあるクエスチョンマークアイコンをクリックします。
   3. 一覧から Command Line Tools を選択します。
   4. oc login コマンドをコピーします。

   5. ターミナルにコマンドを貼り付け、CLI クライアント oc をアカウントで認証します。

      $ oc login OPENSHIFT_URL --token=MYTOKEN

3. ZIP ファイルの内容を展開します。

   $ unzip MY_APPLICATION_NAME.zip

4. OpenShift で新規プロジェクトを作成します。

   $ oc new-project MY_PROJECT_NAME

5. MY_APPLICATION_NAME の root ディレクトリーに移動します。

6. Maven を使用してサンプルアプリケーションをデプロイします。

   $ mvn clean fabric8:deploy -Popenshift

   注記: アプリケーションの例によっては、追加の設定が必要になる場合があります。サンプルアプリケーションをビルドおよびデプロイするには、README ファイルに記載されている手順に従います。

7. アプリケーションのステータスを確認し、Pod が実行していることを確認します。

   $ oc get pods -w
   NAME                             READY     STATUS      RESTARTS   AGE
   MY_APP_NAME-1-aaaaa               1/1       Running     0          58s
   MY_APP_NAME-s2i-1-build           0/1       Completed   0          2m

   MY_APP_NAME-1-aaaaa Pod は完全にデプロイされ起動すると Running ステータスになります。アプリケーションの Pod 名は異なる場合があります。Pod 名の数値は、新しいビルドごとに増加します。末尾の文字は、Pod の作成時に生成されます。

8. アプリケーションのサンプルをデプロイして起動すると、そのルートを決定します。

   ルート情報の例

   $ oc get routes
   NAME                 HOST/PORT                                                     PATH      SERVICES        PORT      TERMINATION
   MY_APP_NAME         MY_APP_NAME-MY_PROJECT_NAME.OPENSHIFT_HOSTNAME      MY_APP_NAME      8080

   Pod のルート情報は、アクセスできるベース URL を提供します。この例では、http://MY_APP_NAME-MY_PROJECT_NAME.OPENSHIFT_HOSTNAME をベース URL として使用し、アプリケーションにアクセスできます。

手順

1. myApp ディレクトリーを新規作成し、そのディレクトリーに移動します。

   $ mkdir myApp
   $ cd myApp

   これは、アプリケーションのルートディレクトリーです。

2. ルートディレクトリーにディレクトリー構造 src/main/java/com/example/ を作成し、これに移動します。

   $ mkdir -p src/main/java/com/example/
   $ cd src/main/java/com/example/

3. アプリケーションコードを含む Java クラスファイル MyApp.java を作成します。

   package com.example;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.ResponseBody;
   import org.springframework.web.bind.annotation.RestController;
   
   @SpringBootApplication
   @RestController
   public class MyApp {
   
       public static void main(String[] args) {
           SpringApplication.run(MyApp.class, args);
       }
   
       @RequestMapping("/")
       @ResponseBody
       public Message displayMessage() {
           return new Message();
       }
   
       static class Message {
           private String content = "Greetings!";
   
           public String getContent() {
               return content;
           }
   
           public void setContent(String content) {
               this.content = content;
           }
       }
   }

4. 以下の内容を含むアプリケーションルートディレクトリー myApp に pom.xml ファイルを作成します。

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
   
     <groupId>com.example</groupId>
     <artifactId>my-app</artifactId>
     <version>1.0.0-SNAPSHOT</version>
   
     <name>MyApp</name>
     <description>My Application</description>
   
     <!-- Specify the JDK builder image used to build your application. -->
     <!-- Use OpenJDK 8 and OpenJDK 11-based images. OracleJDK-based images are not supported. -->
     <properties>
       <fabric8.generator.from>registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift:latest</fabric8.generator.from>
     </properties>
   
     <!-- Import dependencies from the Spring Boot BOM. -->
     <dependencyManagement>
       <dependencies>
         <dependency>
           <groupId>dev.snowdrop</groupId>
           <artifactId>snowdrop-dependencies</artifactId>
           <version>2.2.11.SP1-redhat-00001</version>
           <type>pom</type>
           <scope>import</scope>
         </dependency>
       </dependencies>
     </dependencyManagement>
   
     <dependencies>
         <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-tomcat</artifactId>
         </dependency>
         <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-actuator</artifactId>
         </dependency>
         <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
     </dependencies>
   
     <build>
       <plugins>
         <plugin>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-maven-plugin</artifactId>
           <version>2.2.11.RELEASE</version>
         </plugin>
       </plugins>
     </build>
   
     <!-- Specify the repositories containing Spring Boot artifacts -->
     <repositories>
       <repository>
         <id>redhat-ga</id>
         <name>Red Hat GA Repository</name>
         <url>https://maven.repository.redhat.com/ga/</url>
       </repository>
     </repositories>
   
     <pluginRepositories>
       <pluginRepository>
         <id>redhat-ga</id>
         <name>Red Hat GA Repository</name>
         <url>https://maven.repository.redhat.com/ga/</url>
       </pluginRepository>
     </pluginRepositories>
   
   </project>

5. アプリケーションのルートディレクトリーから Maven を使用してアプリケーションをビルドします。

   $ mvn spring-boot:run

6. アプリケーションが実行していることを確認します。

   curl またはブラウザーを使用して、アプリケーションが http://localhost:8080 で稼働していることを確認します。

   $ curl http://localhost:8080
   {"content":"Greetings!"}

手順

1. vertx-spring-boot-starter-http をプロジェクトの pom.xml ファイルに依存関係として追加します。

   pom.xml

   <project>
   ...
     <dependencies>
     ...
       <dependency>
         <groupId>dev.snowdrop</groupId>
         <artifactId>vertx-spring-boot-starter-http</artifactId>
       </dependency>
     ...
     <dependencies>
   ...
   </project>

2. アプリケーションのメインクラスを作成し、ルーターおよびハンドラーメソッドを定義します。

   HttpSampleApplication.java

   package dev.snowdrop.vertx.sample.http;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.context.annotation.Bean;
   import org.springframework.web.reactive.function.server.RouterFunction;
   import org.springframework.web.reactive.function.server.ServerRequest;
   import org.springframework.web.reactive.function.server.ServerResponse;
   import reactor.core.publisher.Mono;
   
   import static org.springframework.web.reactive.function.BodyInserters.fromObject;
   import static org.springframework.web.reactive.function.server.RouterFunctions.route;
   import static org.springframework.web.reactive.function.server.ServerResponse.ok;
   
   @SpringBootApplication
   public class HttpSampleApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(HttpSampleApplication.class, args);
       }
   
       @Bean
       public RouterFunction<ServerResponse> helloRouter() {
           return route()
               .GET("/hello", this::helloHandler)
               .build();
       }
   
       private Mono<ServerResponse> helloHandler(ServerRequest request) {
           String name = request
               .queryParam("name")
               .orElse("World");
           String message = String.format("Hello, %s!", name);
   
           return ok()
               .body(fromObject(message));
       }
   }

3. オプション: アプリケーションをローカルで実行し、テストします。

   1. Maven プロジェクトのルートディレクトリーへ移動します。

      $ cd myApp

   2. アプリケーションをパッケージ化します。

      $ mvn clean package

   3. コマンドラインからアプリケーションを起動します。

      $ java -jar target/vertx-spring-boot-sample-http.jar

   4. 新しいターミナルウィンドウで、/hello エンドポイントで HTTP 要求を発行します。

      $ curl localhost:8080/hello
      Hello, World!

   5. カスタム名と、パーソナルな応答を取得するために要求を指定します。

      $ curl http://localhost:8080/hello?name=John
      Hello, John!

手順

1. vertx-spring-boot-starter-http および spring-boot-starter-security をプロジェクトの pom.xml ファイルに依存関係として追加します。

   pom.xml

   <project>
   ...
     <dependencies>
     ...
       <dependency>
         <groupId>dev.snowdrop</groupId>
         <artifactId>vertx-spring-boot-starter-http</artifactId>
       </dependency>
       <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-security</artifactId>
       </dependency>
     ...
     <dependencies>
   ...
   </project>

2. アプリケーションのエンドポイントコントローラークラスを作成します。

   HelloController.java

   package dev.snowdrop.vertx.sample.http.security;
   
   import java.security.Principal;
   
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   import reactor.core.publisher.Mono;
   
   @RestController
   public class HelloController {
   
       @GetMapping("/")
       public Mono<String> hello(Mono<Principal> principal) {
           return principal
               .map(Principal::getName)
               .map(this::helloMessage);
       }
   
       private String helloMessage(String username) {
           return "Hello, " + username + "!";
       }
   }

3. アプリケーションのメインクラスを作成します。

   HttpSecuritySampleApplication.java

   package dev.snowdrop.vertx.sample.http.security;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class HttpSecuritySampleApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(HttpSecuritySampleApplication.class, args);
       }
   }

4. /hello エンドポイントにアクセスするためのユーザー認証情報を格納する SecurityConfiguration クラスを作成します。

   SecurityConfiguration.java

   package dev.snowdrop.vertx.sample.http.security;
   
   import org.springframework.context.annotation.Bean;
   import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
   import org.springframework.security.core.userdetails.MapReactiveUserDetailsService;
   import org.springframework.security.core.userdetails.User;
   import org.springframework.security.core.userdetails.UserDetails;
   
   @EnableWebFluxSecurity
   public class SecurityConfiguration {
   
       @Bean
       public MapReactiveUserDetailsService userDetailsService() {
           UserDetails user = User.withDefaultPasswordEncoder()
               .username("user")
               .password("user")
               .roles("USER")
               .build();
   
           return new MapReactiveUserDetailsService(user);
       }
   }

5. オプション: アプリケーションをローカルで実行し、テストします。

   1. Maven プロジェクトのルートディレクトリーへ移動します。

      $ cd myApp

   2. アプリケーションをパッケージ化します。

      $ mvn clean package

   3. コマンドラインからアプリケーションを起動します。

      $ java -jar target/vertx-spring-boot-sample-http-security.jar

   4. ブラウザーを使用して http://localhost:8080 に移動し、ログイン画面にアクセスします。

   5. 以下の認証情報を使用してログインします。

      • username: user
      • password: user

      以下のログイン時に、カスタマイズされた挨拶文を受け取ります。

      Hello, user!

   6. Web ブラウザーを使用して http://localhost:8080/logout に移動し、Log out ボタンを使用してアプリケーションからログアウトします。

   7. または、ターミナルを使用して localhost:8080 で認証されていない HTTP 要求を実行します。アプリケーションから HTTP 401 Unauthorized 応答を受信します。

      $ curl -I http://localhost:8080
      HTTP/1.1 401 Unauthorized
      WWW-Authenticate: Basic realm="Realm"
      Cache-Control: no-cache, no-store, max-age=0, must-revalidate
      Pragma: no-cache
      Expires: 0
      X-Content-Type-Options: nosniff
      X-Frame-Options: DENY
      X-XSS-Protection: 1 ; mode=block
      Referrer-Policy: no-referrer

   8. サンプルユーザー認証情報を使用して認証された要求を発行します。パーソナルな応答を受け取ります。

      $ curl -u user:user http://localhost:8080
      Hello, user!

手順

1. Github アカウントに 新規 OAuth 2 アプリケーションを登録 します。登録フォームに以下の値を指定するようにしてください。

   • ホームページ URL: http://localhost:8080

   • 承認コールバック URL: http://localhost:8080/login/oauth2/code/github

     登録が完了したら、クライアント ID とクライアントシークレットを保存します。

2. プロジェクトの pom.xml ファイルに以下の依存関係を追加します。

   • vertx-spring-boot-starter-http
   • spring-boot-starter-security
   • spring-boot-starter-oauth2-client

   • reactor-netty

     spring-boot-starter-oauth2-client が適切に動作するには、reactor-netty クライアントが必要です。

     pom.xml

     <project>
     ...
       <dependencies>
       ...
         <dependency>
           <groupId>dev.snowdrop</groupId>
           <artifactId>vertx-spring-boot-starter-http</artifactId>
         </dependency>
         <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-security</artifactId>
         </dependency>
         <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-oauth2-client</artifactId>
         </dependency>
         <!-- Spring OAuth2 client only works with Reactor Netty client -->
         <dependency>
           <groupId>io.projectreactor.netty</groupId>
           <artifactId>reactor-netty</artifactId>
         </dependency>
       ...
       <dependencies>
     ...
     </project>

3. アプリケーションのエンドポイントコントローラークラスを作成します。

   HelloController.java

   package dev.snowdrop.vertx.sample.http.oauth;
   
   import org.springframework.security.core.annotation.AuthenticationPrincipal;
   import org.springframework.security.oauth2.core.user.OAuth2User;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   import reactor.core.publisher.Mono;
   
   @RestController
   public class HelloController {
   
       @GetMapping
       public Mono<String> hello(@AuthenticationPrincipal OAuth2User oauth2User) {
           return Mono.just("Hello, " + oauth2User.getAttributes().get("name") + "!");
       }
   }

4. アプリケーションのメインクラスを作成します。

   OAuthSampleApplication.java

   package dev.snowdrop.vertx.sample.http.oauth;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class OAuthSampleApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(OAuthSampleApplication.class, args);
       }
   }

5. YAML 設定ファイルを作成して、アプリケーション登録時に GitHub から受け取った OAuth2 クライアント ID およびクライアントシークレットを保存します。

   src/main/resources/application.yml

   spring:
     security:
       oauth2:
         client:
           registration:
             github:
               client-id: YOUR_GITHUB_CLIENT_ID
               client-secret: YOUR_GITHUB_CLIENT_SECRET

6. オプション: アプリケーションをローカルで実行し、テストします。

   1. Maven プロジェクトのルートディレクトリーへ移動します。

      $ cd myApp

   2. アプリケーションをパッケージ化します。

      $ mvn clean package

   3. コマンドラインからアプリケーションを起動します。

      $ java -jar target/vertx-spring-boot-sample-http-oauth.jar

   4. Web ブラウザーを使用して http://localhost:8080 に移動します。GitHub の OAuth2 アプリケーション認可画面にリダイレクトされます。プロンプトが表示されたら、GitHub アカウントの認証情報を使用してログインします。
   5. Authorize をクリックして確定します。パーソナライズされたグリーティングメッセージを示す画面にリダイレクトされます。

手順

1. vertx-spring-boot-starter-http および vertx-spring-boot-starter-mail をプロジェクトの pom.xml ファイルに依存関係として追加します。

   pom.xml

   <project>
   ...
     <dependencies>
     ...
       <dependency>
         <groupId>dev.snowdrop</groupId>
         <artifactId>vertx-spring-boot-starter-http</artifactId>
       </dependency>
       <dependency>
         <groupId>dev.snowdrop</groupId>
         <artifactId>vertx-spring-boot-starter-mail</artifactId>
       </dependency>
     ...
     <dependencies>
   ...
   </project>

2. アプリケーションのメールハンドラークラスを作成します。

   MailHandler.java

   package dev.snowdrop.vertx.sample.mail;
   
   import dev.snowdrop.vertx.mail.MailClient;
   import dev.snowdrop.vertx.mail.MailMessage;
   import dev.snowdrop.vertx.mail.SimpleMailMessage;
   import org.springframework.stereotype.Component;
   import org.springframework.util.MultiValueMap;
   import org.springframework.web.reactive.function.server.ServerRequest;
   import org.springframework.web.reactive.function.server.ServerResponse;
   import reactor.core.publisher.Mono;
   
   import static org.springframework.web.reactive.function.server.ServerResponse.noContent;
   
   @Component
   public class MailHandler {
   
       private final MailClient mailClient;
   
       public MailHandler(MailClient mailClient) {
           this.mailClient = mailClient;
       }
   
       public Mono<ServerResponse> send(ServerRequest request) {
           return request.formData()
               .log()
               .map(this::formToMessage)
               .flatMap(mailClient::send)
               .flatMap(result -> noContent().build());
       }
   
       private MailMessage formToMessage(MultiValueMap<String, String> form) {
           return new SimpleMailMessage()
               .setFrom(form.getFirst("from"))
               .setTo(form.get("to"))
               .setSubject(form.getFirst("subject"))
               .setText(form.getFirst("text"));
       }
   
   }

3. アプリケーションのメインクラスを作成します。

   MailSampleApplication.java

   package dev.snowdrop.vertx.sample.mail;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.context.annotation.Bean;
   import org.springframework.core.io.ClassPathResource;
   import org.springframework.web.reactive.function.server.RouterFunction;
   import org.springframework.web.reactive.function.server.ServerResponse;
   
   import static org.springframework.http.MediaType.APPLICATION_FORM_URLENCODED;
   import static org.springframework.web.reactive.function.server.RequestPredicates.accept;
   import static org.springframework.web.reactive.function.server.RouterFunctions.resources;
   import static org.springframework.web.reactive.function.server.RouterFunctions.route;
   
   @SpringBootApplication
   public class MailSampleApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(MailSampleApplication.class, args);
       }
   
       @Bean
       public RouterFunction<ServerResponse> mailRouter(MailHandler mailHandler) {
           return route()
                   .POST("/mail", accept(APPLICATION_FORM_URLENCODED), mailHandler::send)
                   .build();
       }
   
       @Bean
       public RouterFunction<ServerResponse> staticResourceRouter() {
           return resources("/**", new ClassPathResource("static/"));
       }
   
   }

4. application.properties ファイルを作成して、SMTP サーバー認証情報を保存します。

   application.properties

   vertx.mail.host=YOUR_SMTP_SERVER_HOSTNAME
   vertx.mail.username=YOUR_SMTP_SERVER_USERNAME
   vertx.mail.password=YOUR_SMTP_SERVER_PASSWORD

5. アプリケーションのフロントエンドとして機能する src/main/resources/static/index.html ファイルを作成します。または、この手順で使用できる HTML メールフォームの例 を使用してください。

6. オプション: アプリケーションをローカルで実行し、テストします。

   1. Maven プロジェクトのルートディレクトリーへ移動します。

      $ cd myApp

   2. アプリケーションをパッケージ化します。

      $ mvn clean package

   3. コマンドラインからアプリケーションを起動します。

      $ java -jar target/vertx-spring-boot-sample-mail.jar

   4. Web ブラウザーを使用して http://localhost:8080/index.html に移動し、メールフォームにアクセスします。

手順

1. vertx-spring-boot-starter-http をプロジェクトの pom.xml ファイルに依存関係として追加します。

   pom.xml

   <project>
   ...
     <dependencies>
     ...
       <dependency>
         <groupId>dev.snowdrop</groupId>
         <artifactId>vertx-spring-boot-starter-http</artifactId>
       </dependency>
     ...
     <dependencies>
   ...
   </project>

2. アプリケーションのメインクラスを作成します。

   SseExampleApplication.java

   package dev.snowdrop.vertx.sample.sse;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class SseSampleApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(SseSampleApplication.class, args);
       }
   }

3. アプリケーションのサーバー送信イベントコントローラークラスを作成します。この例では、クラスはランダムな整数のストリームを生成し、それらをターミナルアプリケーションに出力します。

   SseController.java

   package dev.snowdrop.vertx.sample.sse;
   
   import java.time.Duration;
   import java.util.Random;
   
   import org.springframework.http.MediaType;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   import reactor.core.publisher.Flux;
   
   @RestController
   public class SseController {
   
       @GetMapping(produces = MediaType.TEXT_EVENT_STREAM_VALUE)
       public Flux<Integer> getRandomNumberStream() {
           Random random = new Random();
   
           return Flux.interval(Duration.ofSeconds(1))
               .map(i -> random.nextInt())
               .log();
       }
   }

4. オプション: アプリケーションをローカルで実行し、テストします。

   1. Maven プロジェクトのルートディレクトリーへ移動します。

      $ cd myApp

   2. アプリケーションをパッケージ化します。

      $ mvn clean package

   3. コマンドラインからアプリケーションを起動します。

      $ java -jar target/vertx-spring-boot-sample-sse.jar

   4. 新しいターミナルウィンドウで、HTTP 要求を localhost に発行します。サーバーから送信されたイベントコントローラーからランダムな整数の連続ストリームの受信を開始します。

      $ curl localhost:8080
      data:-2126721954
      
      data:-573499422
      
      data:1404187823
      
      data:1338766210
      
      data:-666543077
      ...

      Ctrl+C を押して HTTP 要求をキャンセルし、応答のストリームを終了します。

手順：

1. vertx-spring-boot-starter-http をアプリケーションプロジェクトの pom.xml ファイルに依存関係として追加します。

   pom.xml

   ...
   <dependencies>
     ...
      <dependency>
         <groupId>dev.snowdrop</groupId>
         <artifactId>vertx-spring-boot-starter-http</artifactId>
      </dependency>
     ...
   </dependencies>
   ...

2. バックエンドアプリケーションコードが含まれるクラスファイルを作成します。

   /src/main/java/webSocketSampleApplication.java

   package dev.snowdrop.WebSocketSampleApplication;
   
   import java.util.Collections;
   import java.util.Map;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.context.annotation.Bean;
   import org.springframework.web.reactive.HandlerMapping;
   import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
   import org.springframework.web.reactive.socket.WebSocketHandler;
   import org.springframework.web.reactive.socket.WebSocketMessage;
   import org.springframework.web.reactive.socket.WebSocketSession;
   
   import reactor.core.publisher.Flux;
   import reactor.core.publisher.Mono;
   
   @SpringBootApplication
   public class WebSocketSampleApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(WebSocketSampleApplication.class, args);
       }
   
       @Bean
       public HandlerMapping handlerMapping() {
           // Define URL mapping for the socket handlers
           Map<String, WebSocketHandler> handlers = Collections.singletonMap("/echo-upper", this::toUppercaseHandler);
   
           SimpleUrlHandlerMapping handlerMapping = new SimpleUrlHandlerMapping();
           handlerMapping.setUrlMap(handlers);
           // Set a higher precedence than annotated controllers (smaller value means higher precedence)
           handlerMapping.setOrder(-1);
   
           return handlerMapping;
       }
   
       private Mono<Void> toUppercaseHandler(WebSocketSession session) {
           Flux<WebSocketMessage> messages = session.receive() // Get incoming messages stream
               .filter(message -> message.getType() == WebSocketMessage.Type.TEXT) // Filter out non-text messages
               .map(message -> message.getPayloadAsText().toUpperCase()) // Execute service logic
               .map(session::textMessage); // Create a response message
   
           return session.send(messages); // Send response messages
       }
   }

3. アプリケーションのフロントエンドとして機能する HTML ドキュメントを作成します。以下の例の <script> 要素には、アプリケーションのバックエンドとの通信を処理する JavaScript コードが含まれます。

   /src/main/resources/static/index.html

   <!doctype html>
   <html>
   <head>
     <meta charset="utf-8"/>
     <title>WebSocket Example</title>
     <script>
     const socket = new WebSocket("ws://localhost:8080/echo-upper");
   
     socket.onmessage = function(e) {
       console.log("Received a value: " + e.data);
       const messages = document.getElementById("messages");
       const message = document.createElement("li");
       message.innerHTML = e.data;
       messages.append(message);
     }
   
     window.onbeforeunload = function(e) {
       console.log("Closing socket");
       socket.close();
     }
   
     function send(event) {
       event.preventDefault();
   
       const value = document.getElementById("value-to-send").value.trim();
       if (value.length > 0) {
         console.log("Sending value to socket: " + value);
         socket.send(value);
       }
     }
     </script>
   </head>
   <body>
   <div>
     <h1>Vert.x Spring Boot WebSocket example</h1>
     <p>
       Enter a value to the form below and click submit. The value will be sent via socket to a backend service.
       The service will then uppercase the value and send it back via the same socket.
     </p>
   </div>
   <div>
     <form onsubmit="send(event)">
       <input type="text" id="value-to-send" placeholder="A value to be sent"/>
       <input type="submit"/>
     </form>
   </div>
   <div>
     <ol id="messages"></ol>
   </div>
   </body>
   </html>

4. オプション: アプリケーションをローカルで実行し、テストします。

   1. Maven プロジェクトのルートディレクトリーへ移動します。

      $ cd myApp

   2. アプリケーションをパッケージ化します。

      $ mvn clean package

   3. コマンドラインからアプリケーションを起動します。

      $ java -jar target/vertx-spring-boot-sample-websocket.jar

   4. Web ブラウザーを使用して http://localhost:8080/index.html に移動します。Web サイトには、次を含む Web インターフェイスが表示されます。

      • 入力テキストボックス
      • 処理された結果のリスト
      • Submit ボタン。
5. テキストボックスに文字列値を入力して Submit を選択します。
6. 入力テキストボックスの配下にあるリストで大文字でレンダリングされた値を確認します。

1. フロントエンドサービスは、リクエストのペイロードとして文字列を含む HTTP POST リクエストを HTTP コントローラーに送信します。
2. リクエストは、AMQP ブローカーへメッセージをルーティングするメッセージングマネージャーによって選択されます。
3. ブローカーはメッセージをテキスト文字列プロセッサーサービスにルーティングします。テキストプロセッサーサービスがリクエストを取得できない場合には、このようなインスタンスが利用可能な場合、ブローカーはメッセージを次の利用可能なプロセッサーインスタンスにルーティングします。または、ブローカーは、再度利用可能になったときに、同じインスタンスにリクエストを再送信するまで待機します。
4. テキスト文字列プロセッサーサービスはメッセージを取得して、文字列の文字を大文字に変換します。プロセッサーサービスは処理済みのリクエストを大文字で AMQP ブローカーに送信します。
5. AMQP ブローカーは、処理された結果とともにリクエストをメッセージングマネージャーにルーティングします。
6. メッセージングマネージャーは、処理済みのリクエストを、フロントエンドサービスがアクセスできる送信キューに格納します。

1. フロントエンドサービスは、HTTP GET リクエストを Spring Boot HTTP Starter によって提供される HTTP コントローラーに送信します。
2. HTTP コントローラーはリクエストをメッセージングマネージャーにルーティングします。
3. フロントエンドによって以前に送信されたリクエストが処理の準備ができ、送信キューで利用可能な場合、メッセージングマネージャーは結果を HTTP GET リクエストとして HTTP コントローラーに送信します。
4. HTTP コントローラーは、応答をフロントエンドサービスにルーティングし、結果を表示します。

手順

1. 以下の依存関係をアプリケーションプロジェクトの pom.xml ファイルに追加します。

   pom.xml

   ...
   <dependencies>
     ...
      <dependency>
         <groupId>dev.snowdrop</groupId>
         <artifactId>vertx-spring-boot-starter-http</artifactId>
      </dependency>
      <dependency>
          <groupId>dev.snowdrop</groupId>
          <artifactId>vertx-spring-boot-starter-amqp</artifactId>
      </dependency>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-artemis</artifactId>
      </dependency>
      <dependency>
          <groupId>org.apache.activemq</groupId>
          <artifactId>artemis-jms-server</artifactId>
      </dependency>
      <dependency>
          <groupId>org.apache.activemq</groupId>
          <artifactId>artemis-amqp-protocol</artifactId>
        <exclusions>
          <exclusion>
            <groupId>org.apache.qpid</groupId>
            <artifactId>proton-j</artifactId>
          </exclusion>
        </exclusions>
      </dependency>
     ...
   </dependencies>
   ...

2. サンプルアプリケーションのメインクラスファイルを作成します。このクラスには、要求と結果に対応する処理キューを定義するメソッドが含まれています。

   /src/main/java/AmqpExampleApplication.java

   package dev.snowdrop.AmqpExampleApplication.java;
   
   import java.util.HashMap;
   import java.util.Map;
   
   import dev.snowdrop.vertx.amqp.AmqpProperties;
   import org.apache.activemq.artemis.api.core.TransportConfiguration;
   import org.apache.activemq.artemis.core.remoting.impl.netty.NettyAcceptorFactory;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.boot.autoconfigure.jms.artemis.ArtemisConfigurationCustomizer;
   import org.springframework.context.annotation.Bean;
   
   @SpringBootApplication
   public class AmqpExampleApplication {
   
       final static String PROCESSING_REQUESTS_QUEUE = "processing-requests";
   
       final static String PROCESSING_RESULTS_QUEUE = "processing-results";
   
       public static void main(String[] args) {
           SpringApplication.run(AmqpExampleApplication.class, args);
       }
   
       /**
        * Add Netty acceptor to the embedded Artemis server.
        */
       @Bean
       public ArtemisConfigurationCustomizer artemisConfigurationCustomizer(AmqpProperties properties) {
           Map<String, Object> params = new HashMap<>();
           params.put("host", properties.getHost());
           params.put("port", properties.getPort());
   
           return configuration -> configuration
               .addAcceptorConfiguration(new TransportConfiguration(NettyAcceptorFactory.class.getName(), params));
       }
   }

3. GET および POST リクエストを処理する REST エンドポイントを公開して、要求キューと応答キューを管理する HTTP REST コントローラーのコードを含むクラスファイルを作成します。

   /src/main/java/Controller.java

   package dev.snowdrop.vertx.sample.amqp;
   
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.PostMapping;
   import org.springframework.web.bind.annotation.RequestBody;
   import org.springframework.web.bind.annotation.RestController;
   import reactor.core.publisher.Flux;
   import reactor.core.publisher.Mono;
   
   import static org.springframework.http.MediaType.TEXT_EVENT_STREAM_VALUE;
   
   /**
    * Rest controller exposing GET and POST resources to receive processed messages and submit messages for processing.
    */
   @RestController
   public class Controller {
   
       private final MessagesManager messagesManager;
   
       public Controller(MessagesManager messagesManager) {
           this.messagesManager = messagesManager;
       }
   
       /**
        * Get a flux of messages processed up to this point.
        */
       @GetMapping(produces = TEXT_EVENT_STREAM_VALUE)
       public Flux<String> getProcessedMessages() {
           return Flux.fromIterable(messagesManager.getProcessedMessages());
       }
   
       /**
        * Submit a message for processing by publishing it to a processing requests queue.
        */
       @PostMapping
       public Mono<Void> submitMessageForProcessing(@RequestBody String body) {
           return messagesManager.processMessage(body.trim());
       }
   }

4. メッセージングマネージャーを含むクラスファイルを作成します。Manager は、アプリケーションコンポーネントがリクエストキューにリクエストを公開する方法を制御し、その後に応答キューにサブスクライブして処理された結果を取得します。

   /src/main/java/MessagesManager.java:

   package dev.snowdrop.vertx.sample.amqp;
   
   import java.util.List;
   import java.util.concurrent.CopyOnWriteArrayList;
   
   import dev.snowdrop.vertx.amqp.AmqpClient;
   import dev.snowdrop.vertx.amqp.AmqpMessage;
   import dev.snowdrop.vertx.amqp.AmqpSender;
   import org.apache.activemq.artemis.core.server.embedded.EmbeddedActiveMQ;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.DisposableBean;
   import org.springframework.beans.factory.InitializingBean;
   import org.springframework.stereotype.Component;
   import reactor.core.Disposable;
   import reactor.core.publisher.Mono;
   
   import static dev.snowdrop.vertx.sample.amqp.AmqpSampleApplication.PROCESSING_REQUESTS_QUEUE;
   import static dev.snowdrop.vertx.sample.amqp.AmqpSampleApplication.PROCESSING_RESULTS_QUEUE;
   
   /**
    * Processor client submits messages to the requests queue and subscribes to the results queue for processed messages.
    */
   @Component
   public class MessagesManager implements InitializingBean, DisposableBean {
   
       private final Logger logger = LoggerFactory.getLogger(MessagesManager.class);
   
       private final List<String> processedMessages = new CopyOnWriteArrayList<>();
   
       private final AmqpClient client;
   
       private Disposable receiverDisposer;
   
       // Injecting EmbeddedActiveMQ to make sure it has started before creating this component.
       public MessagesManager(AmqpClient client, EmbeddedActiveMQ server) {
           this.client = client;
       }
   
       /**
        * Create a processed messages receiver and subscribe to its messages publisher.
        */
       @Override
       public void afterPropertiesSet() {
           receiverDisposer = client.createReceiver(PROCESSING_RESULTS_QUEUE)
               .flatMapMany(receiver -> receiver.flux()
                   .doOnCancel(() -> receiver.close().block())) // Close the receiver once subscription is disposed
               .subscribe(this::handleMessage);
       }
   
       /**
        * Cancel processed messages publisher subscription.
        */
       @Override
       public void destroy() {
           if (receiverDisposer != null) {
               receiverDisposer.dispose();
           }
       }
   
       /**
        * Get messages which were processed up to this moment.
        *
        * @return List of processed messages.
        */
       public List<String> getProcessedMessages() {
           return processedMessages;
       }
   
       /**
        * Submit a message for processing by publishing it to a processing requests queue.
        *
        * @param body Message body to be processed.
        * @return Mono which is completed once the message is sent.
        */
       public Mono<Void> processMessage(String body) {
           logger.info("Sending message '{}' for processing", body);
   
           AmqpMessage message = AmqpMessage.create()
               .withBody(body)
               .build();
   
           return client.createSender(PROCESSING_REQUESTS_QUEUE)
               .map(sender -> sender.send(message))
               .flatMap(AmqpSender::close);
       }
   
       private void handleMessage(AmqpMessage message) {
           String body = message.bodyAsString();
   
           logger.info("Received processed message '{}'", body);
           processedMessages.add(body);
       }
   }

5. 要求キューからテキスト文字列を受け取る大文字プロセッサーを含むクラスファイルを作成し、それを大文字に変換します。その後、プロセッサーは結果を応答キューに公開します。

   /src/main/java/UppercaseProcessor.java

   package dev.snowdrop.vertx.sample.amqp;
   
   import dev.snowdrop.vertx.amqp.AmqpClient;
   import dev.snowdrop.vertx.amqp.AmqpMessage;
   import dev.snowdrop.vertx.amqp.AmqpSender;
   import org.apache.activemq.artemis.core.server.embedded.EmbeddedActiveMQ;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.DisposableBean;
   import org.springframework.beans.factory.InitializingBean;
   import org.springframework.stereotype.Component;
   import reactor.core.Disposable;
   import reactor.core.publisher.Mono;
   
   import static dev.snowdrop.vertx.sample.amqp.AmqpSampleApplication.PROCESSING_REQUESTS_QUEUE;
   import static dev.snowdrop.vertx.sample.amqp.AmqpSampleApplication.PROCESSING_RESULTS_QUEUE;
   
   /**
    * Uppercase processor subscribes to the requests queue, converts each received message to uppercase and send it to the
    * results queue.
    */
   @Component
   public class UppercaseProcessor implements InitializingBean, DisposableBean {
   
       private final Logger logger = LoggerFactory.getLogger(UppercaseProcessor.class);
   
       private final AmqpClient client;
   
       private Disposable receiverDisposer;
   
       // Injecting EmbeddedActiveMQ to make sure it has started before creating this component.
       public UppercaseProcessor(AmqpClient client, EmbeddedActiveMQ server) {
           this.client = client;
       }
   
       /**
        * Create a processing requests receiver and subscribe to its messages publisher.
        */
       @Override
       public void afterPropertiesSet() {
           receiverDisposer = client.createReceiver(PROCESSING_REQUESTS_QUEUE)
               .flatMapMany(receiver -> receiver.flux()
                   .doOnCancel(() -> receiver.close().block())) // Close the receiver once subscription is disposed
               .flatMap(this::handleMessage)
               .subscribe();
       }
   
       /**
        * Cancel processing requests publisher subscription.
        */
       @Override
       public void destroy() {
           if (receiverDisposer != null) {
               receiverDisposer.dispose();
           }
       }
   
       /**
        * Convert the message body to uppercase and send it to the results queue.
        */
       private Mono<Void> handleMessage(AmqpMessage originalMessage) {
           logger.info("Processing '{}'", originalMessage.bodyAsString());
   
           AmqpMessage processedMessage = AmqpMessage.create()
               .withBody(originalMessage.bodyAsString().toUpperCase())
               .build();
   
           return client.createSender(PROCESSING_RESULTS_QUEUE)
               .map(sender -> sender.send(processedMessage))
               .flatMap(AmqpSender::close);
       }
   }

6. オプション: アプリケーションをローカルで実行し、テストします。

   1. Maven プロジェクトのルートディレクトリーへ移動します。

      $ cd myApp

   2. アプリケーションをパッケージ化します。

      $ mvn clean package

   3. コマンドラインからアプリケーションを起動します。

      $ java -jar target/vertx-spring-boot-sample-amqp.jar

   4. 新しいターミナルウィンドウで、localhost へ処理されるテキスト文字列が含まれる HTTP POST リクエストを多数送信します。

      $ curl -H "Content-Type: text/plain" -d 'Hello, World' -X POST http://localhost:8080
      $ curl -H "Content-Type: text/plain" -d 'Hello again' -X POST http://localhost:8080

   5. HTTP GET 要求を localhost に送信します。文字列を大文字で HTTP 応答を受け取ります。

      $ curl http://localhost:8080
      HTTP/1.1 200 OK
      Content-Type: text/event-stream;charset=UTF-8
      transfer-encoding: chunked
      
      data:HELLO, WORLD
      
      data:HELLO AGAIN

1. ログメッセージをペイロードとして使用して、サンプルアプリケーションに対して HTTP POST 要求を実行します。
2. HTTP コントローラーはメッセージを公開するのに使用される REST エンドポイントにルーティングし、そのメッセージをロガーインスタンスに渡します。
3. HTTP コントローラーは、受け取ったメッセージを Kafka の log トピックに公開します。
4. KafkaLog インスタンスは、Kafka トピックからログメッセージを受け取ります。

1. HTTP GET リクエストをサンプルアプリケーション URL に送信します。
2. コントローラーは KafkaLog インスタンスからメッセージを取得し、HTTP 応答のボディーとして返します。

手順

1. WebFlux HTTP Starter および Apache Kafka Starter をアプリケーションプロジェクトの pom.xml ファイルに依存関係として追加します。

   pom.xml

   ...
   <dependencies>
     ...
     <!-- Vert.x WebFlux starter used to handle HTTP requests -->
     <dependency>
       <groupId>dev.snowdrop</groupId>
       <artifactId>vertx-spring-boot-starter-http</artifactId>
     </dependency>
     <!-- Vert.x Kafka starter used to send and receive messages to/from Kafka cluster -->
     <dependency>
       <groupId>dev.snowdrop</groupId>
       <artifactId>vertx-spring-boot-starter-kafka</artifactId>
     </dependency>
     ...
   </dependencies>
   ...

1. KafkaLogger クラスを作成します。このクラスはプロデューサーと sendas メッセージを機能させます。KafkaLogger クラスは、Producer がメッセージ (別名レコード) をトピックに公開する方法を定義します。

   /src/main/java/KafkaLogger.java

   ...
   final class KafkaLogger {
   
       private final KafkaProducer<String, String> producer;
   
       KafkaLogger(KafkaProducer<String, String> producer) {
           this.producer = producer;
       }
   
       public Mono<Void> logMessage(String body) {
           // Generic key and value types can be inferred if both key and value are used to create a builder
           ProducerRecord<String, String> record = ProducerRecord.<String, String>builder(LOG_TOPIC, body).build();
   
           return producer.send(record)
               .log("Kafka logger producer")
               .then();
       }
   }
   ...

2. KafkaLog クラスを作成します。このクラスは、kafka メッセージのコンシューマーとして機能します。KafkaLog は、トピックからメッセージを取得してターミナルに表示されるメッセージを取得します。

   /src/main/java/KafkaLog.java

   ...
   final class KafkaLog implements InitializingBean, DisposableBean {
   
       private final List<String> messages = new CopyOnWriteArrayList<>();
   
       private final KafkaConsumer<String, String> consumer;
   
       private Disposable consumerDisposer;
   
       KafkaLog(KafkaConsumer<String, String> consumer) {
           this.consumer = consumer;
       }
   
       @Override
       public void afterPropertiesSet() {
           consumerDisposer = consumer.subscribe(LOG_TOPIC)
               .thenMany(consumer.flux())
               .log("Kafka log consumer")
               .map(ConsumerRecord::value)
               .subscribe(messages::add);
       }
   
       @Override
       public void destroy() {
           if (consumerDisposer != null) {
               consumerDisposer.dispose();
           }
           consumer.unsubscribe()
               .block(Duration.ofSeconds(2));
       }
   
       public List<String> getMessages() {
           return messages;
       }
   }
   ...

3. HTTP REST コントローラーが含まれるクラスファイルを作成します。アプリケーションがメッセージのロギングや読み取りを処理するために使用する REST リソースを公開するコントローラー。

   /src/main/java/Controller.java

   package dev.snowdrop.vertx.sample.kafka;
   
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.PostMapping;
   import org.springframework.web.bind.annotation.RequestBody;
   import org.springframework.web.bind.annotation.RestController;
   import reactor.core.publisher.Flux;
   import reactor.core.publisher.Mono;
   
   import static org.springframework.http.MediaType.TEXT_EVENT_STREAM_VALUE;
   
   /**
    * HTTP controller exposes GET and POST resources to log messages and to receive the previously logged ones.
    */
   @RestController
   public class Controller {
   
       private final KafkaLogger logger;
   
       private final KafkaLog log;
   
       public Controller(KafkaLogger logger, KafkaLog log) {
           this.logger = logger;
           this.log = log;
       }
   
       /**
        * Get a Flux of previously logged messages.
        */
       @GetMapping(produces = TEXT_EVENT_STREAM_VALUE)
       public Flux<String> getMessages() {
           return Flux.fromIterable(log.getMessages());
       }
   
       /**
        * Log a message.
        */
       @PostMapping
       public Mono<Void> logMessage(@RequestBody String body) {
           return logger.logMessage(body.trim());
       }
   }

4. Apache Kafka Cluster のプロデューサーおよびコンシューマーが使用する URL が含まれる YAML テンプレートを作成して、メッセージのログおよび読み取りを行います。この例では、Apache Kafka Cluster のコンシューマーおよびプロデューサーは、デフォルトで localhost でポート 9092 を使用して通信します。以下の例に示すように、プロデューサーとコンシューマーを個別に設定する必要があります。

   /src/main/resources/application.yml

   vertx:
     kafka:
       producer:
         bootstrap:
            # The producer in your cluster uses this URL to publish messages to the log.
           servers: localhost:9092
         key:
             # This class assigns the mandatory key attribute that is assigned to each message.
           serializer: org.apache.kafka.common.serialization.StringSerializer
         value:
             # This class assigns the mandatory value attribute that is assigned to each message.
           serializer: org.apache.kafka.common.serialization.StringSerializer
       consumer:
         bootstrap:
           servers: localhost:9092 # The consumer in your cluster uses this URL to read messages from the log.
         group:
           id: log # The consumer group IDs used to define a group of consumers that subscribe to the same topic. In this example, all consumers belong in the same consumer group.
         key:
           deserializer: org.apache.kafka.common.serialization.StringDeserializer # This class generates the mandatory key attribute that is assigned to each message.
         value:
           deserializer: org.apache.kafka.common.serialization.StringDeserializer # This class generates the mandatory value attribute that is assigned to each message.

5. オプション: アプリケーションをローカルで実行し、テストします。

   1. Maven プロジェクトのルートディレクトリーへ移動します。

      $ cd vertx-spring-boot-sample-kafka

   2. アプリケーションをパッケージ化します。

      $ mvn clean package

   3. コマンドラインからアプリケーションを起動します。

      $ java -jar target/vertx-spring-boot-sample-kafka.jar

   4. 新しいターミナルウィンドウで、テキスト文字列としてフォーマットされたメッセージが含まれる HTTP POST リクエストを localhost に送信します。メッセージはすべて log トピックに公開されます。

      $ curl -H "Content-Type: text/plain" -d 'Hello, World' -X POST http://localhost:8080
      $ curl -H "Content-Type: text/plain" -d 'Hello again' -X POST http://localhost:8080
      ...

   5. HTTP GET 要求を localhost に送信します。コンシューマーがサブスクライブするトピック内の全メッセージが含まれる HTTP 応答を受け取ります。

      $ curl http://localhost:8080
      HTTP/1.1 200 OK
      Content-Type: text/event-stream;charset=UTF-8
      transfer-encoding: chunked
      
      data:Hello, World
      
      data:Hello, again
      ...

手順

1. OpenShift アノテーション Starter をアプリケーションの pom.xml ファイルに追加します。

   <project>
     ...
     <dependencies>
        ...
       <dependency>
         <groupId>io.dekorate</groupId>
         <artifactId>openshift-annotations</artifactId>
       </dependency>
       <dependency>
         <groupId>io.dekorate</groupId>
         <artifactId>openshift-spring-starter</artifactId>
       </dependency>
       ...
     </dependencies>
   ...
   <project>

2. @Dekorate アノテーションをアプリケーションプロジェクトのソースファイルに追加します。

   package org.acme;
   
   import io.dekorate.annotation.Dekorate;
   
   @Dekorate
   public class Application {
   }

3. アプリケーションをパッケージ化します。

   mvn clean package

4. 生成されたアプリケーションテンプレートファイルを含む target/classes/META-INF/dekorate ディレクトリーに移動します。

手順

1. Dekorate OpenShift Annotations モジュールを、アプリケーションの pom.xml ファイルの依存関係として追加します。

   <project>
     ...
     <dependencies>
        ...
       <dependency>
         <groupId>io.dekorate</groupId>
         <artifactId>openshift-annotations</artifactId>
       </dependency>
       ...
     </dependencies>
   ...
   <project>

2. OpenShift へのデプロイ時に、アプリケーションが開始するデフォルトのレプリカ数を設定します。

   1. @OpenshiftApplication アノテーションをアプリケーションのメインソースファイルに追加し、レプリカの数を 2 に指定します。

      package org.acme;
      
      import io.dekorate.openshift.annotation.OpenshiftApplication;
      
      // include the parameter for the number of replicas to
      @OpenshiftApplication(replicas=2)
      public class Application {
      }

   2. または、アプリケーションの application.properties ファイルに dekorate.openshift.replicas=2 プロパティーを設定します。

      /src/main/resources/application.properties

      dekorate.openshift.replicas=2

3. アプリケーションをパッケージ化します。

   mvn clean package

4. target/classes/META-INF/dekorate に移動して、Dekorate によって生成されたテンプレートを表示します。デプロイメント設定 YAML テンプレートのレプリカ数は 2 に設定されます。

   ...
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: acme
   ...

手順

1. アプリケーションの pom.xml ファイルに以下の依存関係を追加します。

   <project>
     ...
     <dependencies>
       ...
       <!-- The OpenShift Spring Starter automatically adds "io.dekorate:openshift-annotations" as a transitive dependency -->
       <dependency>
         <groupId>io.dekorate</groupId>
         <artifactId>openshfit-spring-starter</artifactId>
       </dependency>
       ...
     </dependencies>
   ...
   <project>

2. Dekorate 設定プロパティーをプロジェクトの application.properties ファイルまたは application.yml ファイルに追加します。Dekorate プロパティーアノテーションをソースファイルに追加する必要はありません。ソースファイルのアノテーションを使用できますが、これを行う場合は、アノテーションで提供されるパラメーターを application.properties ファイルまたは application.yml ファイルにあるパラメーターで上書きします。

3. アプリケーションをパッケージ化します。

   mvn clean package

   アプリケーションの Dekorate をビルドすると、アプリケーションプロジェクト内の以下のリソースの設定が解析されます。設定リソースは優先順に解析されます。つまり、異なるタイプの 2 つの異なるリソースが同じ設定パラメーターに異なる値を持っている場合、Dekorate は優先度のリストにあるリソースから取得した値を使用します。たとえば、ソースのアノテーションでパラメーター値が指定されていても、application.yml の同じパラメーターに別の値が指定されている場合、Dekorate は application.yml の取得形式を使用します。Dekorate は、以下の優先順位でプロジェクトリソースを解析します。

   1. アノテーション
   2. application.properties
   3. application.yaml
   4. application.yml
4. 生成された application.json または application.yml マニフェストファイルを含む target/classes/META-INF/dekorate ディレクトリーに移動します。

手順

1. Dekorate OpenShift Annotations モジュールを依存関係としてアプリケーションの pom.xml ファイルに追加します。このモジュールは、すべての Dekorate Starters の推移的な依存関係として含まれています。

   <project>
     ...
     <dependencies>
        ...
       <dependency>
         <groupId>io.dekorate</groupId>
         <artifactId>openshift-annotations</artifactId>
       </dependency>
       ...
     </dependencies>
   ...
   <project>

2. アプリケーションをビルドしてデプロイします。Maven がアプリケーションをコンパイルした後にコンテナーイメージビルドを実行するための -Ddekorate.build=true プロパティーを含めます。Source-to-Image ビルドを自動的に実行する機能は テクノロジープレビュー として提供されることに注意してください。

   $ mvn clean install -Ddekorate.build=true

   Maven でアプリケーションをコンパイルした後に、コマンドラインから Source-to-image ビルドを手動で実行することもできます。

   # Process your application YAML template that is generated by Dekorate:
   $ oc apply -f target/classes/META-INF/dekorate/openshift.yml
   # Execute the Source-to-image build and deploy your application to the OpenShift cluster:
   $ oc start-build example --from-dir=./target --follow

1. アプリケーションで openshift-spring-stater を使用できます。
2. Dekorate は、アプリケーションのタイプを自動的に識別し、OpenShift サービスルートおよびプローブを随時設定できます。
3. Maven がアプリケーションをコンパイルした後に、source-to-image ビルドをトリガーするようにアプリケーションを設定できます。

4. 前提条件

   • Spring Boot および Dekorate を使用するよう設定された Maven ベースのアプリケーションプロジェクト
   • @SpringBootApplication アノテーションがプロジェクトのソースファイルに追加されました。
   • Java JDK 8 または JDK 11 がインストールされている。
   • Maven がインストールされている。
   • oc コマンドラインツールがインストールされている
   • oc コマンドラインツールを使用して OpenShift クラスターにログインしている。

手順

1. Dekorate Spring Starter は、アプリケーションプロジェクトの pom.xml ファイルの依存関係として追加します。

   pom.xml

   <project>
     ...
     <dependencies>
        ...
       <dependency>
         <groupId>io.dekorate</groupId>
         <artifactId>openshift-spring-starter</artifactId>
       </dependency>
       ...
     </dependencies>
   ...
   <project>

2. Main.java クラスファイルに @OpenShiftApplication アノテーションを付けます。これにより、アプリケーションをコンパイルする際に Source-to-Image ビルドを起動できます。

   /src/main/java/io/dekorate/example/sbonopenshift/Main.java

   package io.dekorate.example.sbonopenshift;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @OpenShiftApplication
   @SpringBootApplication
   public class Main {
   
     public static void main(String[] args) {
       SpringApplication.run(Main.class, args);
     }
   
   }

3. Rest コントローラーをアプリケーションに追加します。

   /src/main/java/io/dekorate/example/sbonopenshift/Controller.java

   package io.dekorate.example.sbonopenshift;
   
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class Controller {
   
     @RequestMapping("/")
     public String hello() {
       return "Hello world";
     }
   }

   Dekorate Spring スターターによって提供される Spring アプリケーションプロセッサーは Rest コントローラーを自動的に検出し、アプリケーションタイプを Web アプリケーションとして識別します。Web アプリケーションの場合、Dekorate は OpenShift アプリケーションテンプレートを自動的に生成し、以下を設定します。

   • アプリケーションの OpenShift Service ルート
   • アプリケーションのルートでサービスを公開します。
   • Liveness および Readiness プローブの設定
4. アプリケーションをビルドしてデプロイします。Maven がアプリケーションをコンパイルした後に source-to-image ビルドを自動的に実行するには、-Ddekorate.deploy=true プロパティーを含めます。