SpringBoot-クイックガイド

Spring Bootは、マイクロサービスの作成に使用されるオープンソースのJavaベースのフレームワークです。これはPivotalTeamによって開発され、スタンドアロンで本番環境に対応したSpringアプリケーションを構築するために使用されます。この章では、Spring Bootの概要を説明し、その基本的な概念を理解します。

マイクロサービスとは何ですか?

マイクロサービスは、開発者がサービスを独立して開発およびデプロイできるようにするアーキテクチャです。実行中の各サービスには独自のプロセスがあり、これによりビジネスアプリケーションをサポートする軽量モデルが実現されます。

利点

マイクロサービスは、開発者に次の利点を提供します-

  • 簡単な導入
  • シンプルなスケーラビリティ
  • コンテナとの互換性
  • 最小構成
  • 短い生産時間

Spring Bootとは何ですか?

Spring Bootは、Java開発者がスタンドアロンの本番環境グレードのSpringアプリケーションを開発するための優れたプラットフォームを提供します。 just run。Spring構成全体のセットアップを必要とせずに、最小限の構成で開始できます。

利点

Spring Bootは、開発者に次の利点を提供します-

  • スプリングアプリケーションの理解と開発が容易
  • 生産性を向上させます
  • 開発時間を短縮します

目標

Spring Bootは、次の目標を持って設計されています-

  • Springでの複雑なXML構成を回避するには
  • より簡単な方法で本番環境に対応したSpringアプリケーションを開発する
  • 開発時間を短縮し、アプリケーションを独立して実行するには
  • アプリケーションを開始するためのより簡単な方法を提供する

なぜSpringBootなのか?

ここに示されているように、Spring Bootが提供する機能と利点のために、SpringBootを選択できます-

  • これは、Java Bean、XML構成、およびデータベーストランザクションを構成するための柔軟な方法を提供します。

  • 強力なバッチ処理を提供し、RESTエンドポイントを管理します。

  • Spring Bootでは、すべてが自動構成されます。手動で構成する必要はありません。

  • アノテーションベースのSpringアプリケーションを提供します

  • 依存関係の管理を容易にします

  • 組み込みサーブレットコンテナが含まれています

それはどのように機能しますか?

Spring Bootは、を使用してプロジェクトに追加した依存関係に基づいて、アプリケーションを自動的に構成します。 @EnableAutoConfiguration注釈。たとえば、MySQLデータベースがクラスパス上にあるが、データベース接続を構成していない場合、SpringBootはインメモリデータベースを自動構成します。

スプリングブートアプリケーションのエントリポイントは、クラスに含まれています @SpringBootApplication アノテーションとメインメソッド。

Spring Bootは、を使用してプロジェクトに含まれるすべてのコンポーネントを自動的にスキャンします @ComponentScan 注釈。

SpringBootスターター

依存関係管理の処理は、大規模なプロジェクトにとって難しい作業です。Spring Bootは、開発者の便宜のために一連の依存関係を提供することにより、この問題を解決します。

たとえば、データベースアクセスにSpringとJPAを使用する場合は、を含めると十分です。 spring-boot-starter-data-jpa プロジェクトの依存関係。

すべてのSpringBootスターターは同じ命名パターンに従うことに注意してください spring-boot-starter- *、ここで*は、それがアプリケーションのタイプであることを示します。

理解を深めるために、以下で説明する次のSpringBootスターターを見てください。

Spring Boot Starter Actuator dependencyアプリケーションを監視および管理するために使用されます。そのコードを以下に示します-

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Spring Boot Starter Security dependencySpringSecurityに使用されます。そのコードを以下に示します-

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Spring Boot Starter web dependencyレストエンドポイントを作成するために使用されます。そのコードを以下に示します-

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Spring Boot Starter Thyme Leaf dependencyWebアプリケーションを作成するために使用されます。そのコードを以下に示します-

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Spring Boot Starter Test dependencyテストケースの作成に使用されます。そのコードを以下に示します-

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
</dependency>

自動設定

Spring Boot Auto Configurationは、プロジェクトに追加したJAR依存関係に基づいてSpringアプリケーションを自動的に構成します。たとえば、MySQLデータベースがクラスパス上にあるが、データベース接続を構成していない場合、SpringBootはインメモリデータベースを自動構成します。

この目的のために、あなたは追加する必要があります @EnableAutoConfiguration 注釈または @SpringBootApplicationメインクラスファイルへの注釈。次に、SpringBootアプリケーションが自動的に構成されます。

理解を深めるために、次のコードを確認してください。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

@EnableAutoConfiguration
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

SpringBootアプリケーション

Spring Bootアプリケーションのエントリポイントは、次のクラスが含まれていることです。 @SpringBootApplication注釈。このクラスには、SpringBootアプリケーションを実行するためのmainメソッドが必要です。@SpringBootApplication 注釈には、自動構成、コンポーネントスキャン、およびSpringBoot構成が含まれます。

追加した場合 @SpringBootApplication クラスへの注釈。追加する必要はありません。 @EnableAutoConfiguration, @ComponentScan そして @SpringBootConfiguration注釈。ザ・@SpringBootApplication 注釈には、他のすべての注釈が含まれます。

理解を深めるために、次のコードを確認してください。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

コンポーネントスキャン

Spring Bootアプリケーションは、アプリケーションの初期化時にすべてのBeanとパッケージ宣言をスキャンします。追加する必要があります@ComponentScan プロジェクトに追加されたコンポーネントをスキャンするためのクラスファイルの注釈。

理解を深めるために、次のコードを確認してください。

import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

この章では、MavenとGradleを使用してSpringBootアプリケーションを作成する方法を説明します。

前提条件

Spring Bootアプリケーションを作成するには、システムに次の最小要件が必要です。

  • Java 7
  • Maven 3.2
  • Gradle 2.5

Spring Boot CLI

Spring Boot CLIはコマンドラインツールであり、Groovyスクリプトを実行できます。これは、SpringBootコマンドラインインターフェイスを使用してSpringBootアプリケーションを作成する最も簡単な方法です。コマンドプロンプト自体でアプリケーションを作成、実行、およびテストできます。

このセクションでは、Spring BootCLIの手動インストールに関連する手順について説明します。さらにヘルプが必要な場合は、次のリンクを使用できます。https://docs.spring.io/springboot/ docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-installing-springboot

Spring CLIディストリビューションは、次のSpringSoftwareリポジトリからダウンロードすることもできます。 https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-manual-cli-installation

手動インストールの場合、次の2つのフォルダを使用する必要があります-

  • spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.zip

  • spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.tar.gz

ダウンロード後、アーカイブファイルを解凍し、install.txtファイルに記載されている手順に従います。環境設定が不要というわけではありません。

Windowsでは、Spring BootCLIに移動します bin コマンドプロンプトでディレクトリを作成し、コマンドを実行します spring –-versionSpringCLIが正しくインストールされていることを確認します。コマンドを実行すると、次のようなSpringCLIバージョンが表示されます。

GroovyでHelloWorldを実行する

Rest Endpointスクリプトを含む単純なGroovyファイルを作成し、Spring BootCLIを使用してGroovyファイルを実行します。この目的のためにここに示されているコードを観察してください-

@Controller
class Example {
   @RequestMapping("/")
   @ResponseBody
   public String hello() {
      "Hello Spring Boot"
   }
}

ここで、Groovyファイルを名前で保存します hello.groovy。この例では、Spring BootCLI内にgroovyファイルを保存したことに注意してください。binディレクトリ。コマンドを使用してアプリケーションを実行しますspring run hello.groovy 以下のスクリーンショットに示すように-

groovyファイルを実行すると、必要な依存関係が自動的にダウンロードされ、以下のスクリーンショットに示すように、Tomcat8080ポートでアプリケーションが起動します-

Tomcatが起動したら、Webブラウザに移動してURLを押します http://localhost:8080/ 示されているように出力を見ることができます。

この章では、SpringBootアプリケーションでブートストラップを実行する方法について説明します。

SpringInitializer

Spring Bootアプリケーションをブートストラップする方法の1つは、SpringInitializerを使用することです。これを行うには、Spring InitializerのWebページwww.start.spring.ioにアクセスして、ビルド、Spring Bootバージョン、およびプラットフォームを選択する必要があります。また、アプリケーションを実行するには、グループ、アーティファクト、および必要な依存関係を提供する必要があります。

追加した例を示す次のスクリーンショットを確認してください。 spring-boot-starter-web RESTエンドポイントを書き込むための依存関係。

グループ、アーティファクト、依存関係、ビルドプロジェクト、プラットフォーム、バージョンを指定したら、をクリックします Generate Projectボタン。zipファイルがダウンロードされ、ファイルが抽出されます。

このセクションでは、MavenとGradleの両方を使用した例について説明します。

Maven

プロジェクトをダウンロードしたら、ファイルを解凍します。今、あなたの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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle

プロジェクトをダウンロードしたら、ファイルを解凍します。今あなたのbuild.gradle ファイルは次のようになります-

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

クラスパスの依存関係

SpringBootは多くの Startersクラスパスにjarを追加します。たとえば、RESTエンドポイントを作成するには、spring-boot-starter-webクラスパスの依存関係。理解を深めるために、以下に示すコードを確認してください。

Mavenの依存関係

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>

Gradleの依存関係

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

主な方法

主なメソッドは、Spring BootApplicationクラスを作成することです。このクラスには注釈を付ける必要があります@SpringBootApplication。これは、開始するSpringBootアプリケーションのエントリポイントです。メインクラスファイルは下にありますsrc/java/main デフォルトパッケージのディレクトリ。

この例では、メインクラスファイルは次の場所にあります。 src/java/main デフォルトパッケージのディレクトリ com.tutorialspoint.demo。理解を深めるために、ここに示されているコードを観察してください。

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

残りのエンドポイントを書く

Spring BootApplicationメインクラスファイル自体に単純なHelloWorld Restエンドポイントを書き込むには、以下に示す手順に従います。

  • まず、を追加します @RestController クラスの上部にある注釈。

  • 次に、リクエストURIメソッドを次のように記述します。 @RequestMapping 注釈。

  • 次に、RequestURIメソッドは Hello World ストリング。

これで、メインのSpring BootApplicationクラスファイルは次のコードのようになります。

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController

public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World";
   }
}

実行可能JARを作成する

以下に示すように、コマンドプロンプトでMavenコマンドとGradleコマンドを使用して、SpringBootアプリケーションを実行するための実行可能JARファイルを作成しましょう。

以下に示すように、Mavenコマンドmvn cleaninstallを使用します-

コマンドを実行すると、 BUILD SUCCESS 以下に示すようなコマンドプロンプトでのメッセージ-

Gradleコマンドを使用する gradle clean build 以下に示すように-

コマンドを実行すると、 BUILD SUCCESSFUL 以下に示すようなコマンドプロンプトのメッセージ-

JavaでHelloWorldを実行する

実行可能なJARファイルを作成すると、次のディレクトリにあります。

Mavenの場合、JARファイルは以下に示すようにターゲットディレクトリの下にあります-

Gradleの場合、JARファイルは build/libs 以下に示すディレクトリ-

次に、コマンドを使用してJARファイルを実行します java –jar <JARFILE>。上記の例では、JARファイルの名前がdemo-0.0.1-SNAPSHOT.jar

jarファイルを実行すると、以下に示すようにコンソールウィンドウに出力が表示されます。

ここで、コンソールを見てください。Tomcatはポート8080(http)で起動しました。次に、Webブラウザーにアクセスして、URLを押します。http://localhost:8080/ 以下に示すような出力を見ることができます-

Spring Bootアプリケーションを使用することで、Webサーバーにデプロイするwarファイルを作成できます。この章では、WARファイルを作成し、TomcatWebサーバーにSpringBootアプリケーションをデプロイする方法を学習します。

SpringBootサーブレット初期化子

従来のデプロイ方法は、SpringBootアプリケーションを作成することです。 @SpringBootApplication クラス拡張 SpringBootServletInitializerクラス。Spring Boot Servlet Initializerクラスファイルを使用すると、サーブレットコンテナを使用してアプリケーションを起動するときにアプリケーションを構成できます。

JARファイルデプロイメント用のSpringBootApplicationクラスファイルのコードを以下に示します。

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

クラスを拡張する必要があります SpringBootServletInitializerWARファイルのデプロイメントをサポートします。Spring BootApplicationクラスファイルのコードを以下に示します-

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

メインクラスの設定

Spring Bootでは、ビルドファイルで開始する必要があるメインクラスについて言及する必要があります。この目的のために、次のコードを使用できます-

Mavenの場合、開始クラスをに追加します pom.xml 以下に示すプロパティ-

<start-class>com.tutorialspoint.demo.DemoApplication</start-class>

Gradleの場合、以下に示すように、build.gradleにメインクラス名を追加します-

mainClassName="com.tutorialspoint.demo.DemoApplication"

パッケージングJARをWARに更新します

次のコードを使用して、パッケージングJARをWARに更新する必要があります-

Mavenの場合、パッケージをWARとして追加します。 pom.xml 以下に示すように-

<packaging>war</packaging>

Gradleの場合、アプリケーションプラグインとwarプラグインをに追加します build.gradle 以下に示すように-

apply plugin: ‘war’
apply plugin: ‘application’

ここで、文字列「Hello WorldfromTomcat」を返す単純なRESTエンドポイントを作成しましょう。Restエンドポイントを作成するには、Spring BootWebスターターの依存関係をビルドファイルに追加する必要があります。

Mavenの場合、以下に示すコードを使用して、pom.xmlにSpringBootスターターの依存関係を追加します-

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Gradleの場合、SpringBootスターターの依存関係をに追加します build.gradle 以下に示すコードを使用する-

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

次に、以下に示すコードを使用して、Spring BootApplicationクラスファイルに単純なRESTエンドポイントを記述します。

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

アプリケーションのパッケージ化

次に、以下に示すように、MavenコマンドとGradleコマンドを使用してアプリケーションをパッケージ化することにより、TomcatサーバーにデプロイするWARファイルを作成します。

Mavenの場合、コマンドを使用します mvn packageアプリケーションをパッケージ化するため。次に、WARファイルが作成され、以下のスクリーンショットに示すように、ターゲットディレクトリにあります。

Gradleの場合、コマンドを使用します gradle clean buildアプリケーションをパッケージ化するため。次に、WARファイルが作成され、下にあります。build/libsディレクトリ。理解を深めるために、ここに示されているスクリーンショットを観察してください-

Tomcatにデプロイする

ここで、Tomcatサーバーを実行し、WARファイルを webappsディレクトリ。理解を深めるために、ここに示されているスクリーンショットを観察してください-

展開が成功したら、WebブラウザでURLを押します http://localhost:8080/demo-0.0.1-SNAPSHOT/ 以下のスクリーンショットに示すように出力が表示されることを確認します-

この目的のための完全なコードを以下に示します。

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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>war</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <start-class>com.tutorialspoint.demo.DemoApplication</start-class>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'war'
apply plugin: 'application'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
mainClassName = "com.tutorialspoint.demo.DemoApplication"

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

メインのSpringBootアプリケーションクラスファイルのコードを以下に示します-

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

Spring Bootでは、ビルドシステムの選択は重要なタスクです。依存関係の管理を適切にサポートするMavenまたはGradleをお勧めします。Springは他のビルドシステムを十分にサポートしていません。

依存関係の管理

Spring Bootチームは、すべてのリリースでSpringBootバージョンをサポートするための依存関係のリストを提供します。ビルド構成ファイルで依存関係のバージョンを指定する必要はありません。Spring Bootは、リリースに基づいて依存関係のバージョンを自動的に構成します。Spring Bootバージョンをアップグレードすると、依存関係も自動的にアップグレードされることに注意してください。

Note−依存関係のバージョンを指定する場合は、構成ファイルで指定できます。ただし、Spring Bootチームは、依存関係のバージョンを指定する必要がないことを強くお勧めします。

Mavenの依存関係

Maven構成の場合、Spring Boot Starterの依存関係を管理するには、Spring BootStarterの親プロジェクトを継承する必要があります。このために、単純にスターターの親を継承できますpom.xml 以下に示すようにファイルします。

<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>1.5.8.RELEASE</version>
</parent>

Spring Boot ParentStarter依存関係のバージョン番号を指定する必要があります。次に、他のスターター依存関係については、SpringBootのバージョン番号を指定する必要はありません。以下のコードを確認してください-

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>

Gradleの依存関係

Spring BootStartersの依存関係をに直接インポートできます build.gradleファイル。Maven forGradleのようなSpringBoot startParent依存関係は必要ありません。以下のコードを確認してください-

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

同様に、Gradleでは、依存関係のSpringBootバージョン番号を指定する必要はありません。Spring Bootは、バージョンに基づいて依存関係を自動的に構成します。

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Spring Bootには、使用できるコードレイアウトがありません。ただし、役立つベストプラクティスがいくつかあります。この章では、それらについて詳しく説明します。

デフォルトパッケージ

パッケージ宣言がないクラスは、 default package。通常、デフォルトのパッケージ宣言は推奨されないことに注意してください。デフォルトのパッケージを使用すると、SpringBootによって自動構成やコンポーネントスキャンの誤動作などの問題が発生します。

Note−パッケージ宣言にJavaが推奨する命名規則は、逆ドメイン名です。例-com.tutorialspoint.myproject

典型的なレイアウト

SpringBootアプリケーションの典型的なレイアウトを以下の画像に示します-

Application.javaファイルは、@ SpringBootApplicationとともにmainメソッドを宣言する必要があります。理解を深めるために、以下のコードを確認してください。

package com.tutorialspoint.myproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Spring Bootでは、Spring Frameworkを使用して、Beanとその依存性注入を定義できます。ザ・@ComponentScan アノテーションはBeanを検索するために使用され、対応する @Autowired 注釈。

Spring Bootの一般的なレイアウトに従っている場合は、引数を指定する必要はありません。 @ComponentScan注釈。すべてのコンポーネントクラスファイルは、SpringBeansに自動的に登録されます。

次の例は、RestTemplateオブジェクトの自動配線と同じBeanの作成に関するアイデアを提供します-

@Bean
public RestTemplate getRestTemplate() {
   return new RestTemplate();
}

次のコードは、メインのSpring BootApplicationクラスファイル内の自動配線されたRESTテンプレートオブジェクトとBean作成オブジェクトのコードを示しています。

package com.tutorialspoint.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class DemoApplication {
@Autowired
   RestTemplate restTemplate;
   
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public RestTemplate getRestTemplate() {
      return new RestTemplate();   
   }
}

ApplicationRunnerおよびCommandLine Runnerインターフェイスを使用すると、SpringBootアプリケーションの起動後にコードを実行できます。これらのインターフェースを使用して、アプリケーションの開始直後に任意のアクションを実行できます。この章では、それらについて詳しく説明します。

アプリケーションランナー

Application Runnerは、SpringBootアプリケーションの開始後にコードを実行するために使用されるインターフェイスです。以下の例は、メインクラスファイルにApplicationRunnerインターフェイスを実装する方法を示しています。

package com.tutorialspoint.demo;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements ApplicationRunner {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      System.out.println("Hello World from Application Runner");
   }
}

さて、下のコンソールウィンドウを観察すると Hello World from Application Runner、printlnステートメントは、Tomcatの起動後に実行されます。次のスクリーンショットは関連性がありますか?

コマンドラインランナー

コマンドラインランナーはインターフェイスです。SpringBootアプリケーションの起動後にコードを実行するために使用されます。以下の例は、メインクラスファイルにコマンドラインランナーインターフェイスを実装する方法を示しています。

package com.tutorialspoint.demo;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Override
   public void run(String... arg0) throws Exception {
      System.out.println("Hello world from Command Line Runner");
   }
}

下のコンソールウィンドウを見てください。「コマンドラインランナーからのHelloworld」printlnステートメントは、Tomcatの起動後に実行されます。

アプリケーションプロパティは、さまざまな環境での作業をサポートします。この章では、SpringBootアプリケーションのプロパティを構成および指定する方法を学習します。

コマンドラインプロパティ

Spring Bootアプリケーションは、コマンドラインプロパティをSpringBoot環境プロパティに変換します。コマンドラインプロパティは、他のプロパティソースよりも優先されます。デフォルトでは、SpringBootは8080ポート番号を使用してTomcatを起動します。コマンドラインプロパティを使用してポート番号を変更する方法を学びましょう。

Step 1 −実行可能JARファイルを作成したら、コマンドを使用して実行します java –jar <JARFILE>

Step 2 −以下のスクリーンショットに示されているコマンドを使用して、コマンドラインプロパティを使用してSpringBootアプリケーションのポート番号を変更します。

Note −区切り文字を使用して、複数のアプリケーションプロパティを提供できます。

プロパティファイル

プロパティファイルは、別の環境でアプリケーションを実行するために、1つのファイルに「N」個のプロパティを保持するために使用されます。Spring Bootでは、プロパティはapplication.properties クラスパスの下のファイル。

application.propertiesファイルはにあります src/main/resourcesディレクトリ。サンプルのコードapplication.properties ファイルを以下に示します-

server.port = 9090
spring.application.name = demoservice

上記のコードでは、SpringBootアプリケーションのデモサービスがポート9090で開始されることに注意してください。

YAMLファイル

Spring Bootは、アプリケーションを実行するためのYAMLベースのプロパティ構成をサポートしています。の代わりにapplication.properties、使用できます application.ymlファイル。このYAMLファイルもクラスパス内に保持する必要があります。標本、見本application.yml ファイルを以下に示します-

spring:
   application:
      name: demoservice
   server:
port: 9090

外部化されたプロパティ

プロパティファイルをクラスパスの下に保持する代わりに、プロパティを別の場所またはパスに保持できます。JARファイルの実行中に、プロパティファイルのパスを指定できます。次のコマンドを使用して、JARの実行中にプロパティファイルの場所を指定できます。

-Dspring.config.location = C:\application.properties

@Valueアノテーションの使用

@Valueアノテーションは、Javaコードで環境またはアプリケーションのプロパティ値を読み取るために使用されます。プロパティ値を読み取るための構文を以下に示します-

@Value("${property_key_name}")

を読むための構文を示す次の例を見てください。 spring.application.name @Valueアノテーションを使用したJava変数のプロパティ値。

@Value("${spring.application.name}")

理解を深めるために、以下のコードを確認してください。

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {
   @Value("${spring.application.name}")
   private String name;
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String name() {
      return name;
   }
}

Note −アプリケーションの実行中にプロパティが見つからない場合、SpringBootはIllegalArgument例外を次のようにスローします。 Could not resolve placeholder 'spring.application.name' in value "${spring.application.name}"

プレースホルダーの問題を解決するために、以下の構文を使用してプロパティのデフォルト値を設定できます-

@Value("${property_key_name:default_value}")

@Value("${spring.application.name:demoservice}")

SpringBootアクティブプロファイル

Spring Bootは、Springアクティブプロファイルに基づいてさまざまなプロパティをサポートします。たとえば、Spring Bootアプリケーションを実行するために、開発用と本番用に2つの別々のファイルを保持できます。

application.propertiesのSpringアクティブプロファイル

application.propertiesでSpringアクティブプロファイルを作成する方法を理解しましょう。デフォルトでは、アプリケーション。プロパティは、SpringBootアプリケーションを実行するために使用されます。プロファイルベースのプロパティを使用する場合は、以下に示すように、プロファイルごとに個別のプロパティファイルを保持できます。

application.properties

server.port = 8080
spring.application.name = demoservice

application-dev.properties

server.port = 9090
spring.application.name = demoservice

application-prod.properties

server.port = 4431
spring.application.name = demoservice

JARファイルの実行中に、各プロパティファイルに基づいてスプリングアクティブプロファイルを指定する必要があります。デフォルトでは、SpringBootアプリケーションはapplication.propertiesファイルを使用します。スプリングアクティブプロファイルを設定するコマンドを以下に示します-

以下に示すように、コンソールログにア​​クティブなプロファイル名が表示されます。

2017-11-26 08:13:16.322  INFO 14028 --- [           
   main] com.tutorialspoint.demo.DemoApplication  :
   The following profiles are active: dev

これで、Tomcatは以下に示すようにポート9090(http)で起動しました-

2017-11-26 08:13:20.185  INFO 14028 --- [           
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 9090 (http)

以下に示すように、本番アクティブプロファイルを設定できます。

以下に示すように、コンソールログにア​​クティブなプロファイル名が表示されます。

2017-11-26 08:13:16.322  INFO 14028 --- [           
   main] com.tutorialspoint.demo.DemoApplication  :
   The following profiles are active: prod

これで、Tomcatは以下に示すようにポート4431(http)で起動しました-

2017-11-26 08:13:20.185  INFO 14028 --- [          
   main] s.b.c.e.t.TomcatEmbeddedServletContainer :
   Tomcat started on port(s): 4431 (http)

application.ymlのSpringアクティブプロファイル

application.ymlのSpringアクティブプロファイルを維持する方法を理解しましょう。Springのアクティブプロファイルプロパティを1つにまとめることができますapplication.ymlファイル。application.propertiesのような別のファイルを使用する必要はありません。

以下は、Springのアクティブなプロファイルをapplication.ymlファイルに保持するためのサンプルコードです。区切り文字(---)は、application.ymlファイル内の各プロファイルを区切るために使用されることに注意してください。

spring:
   application:
      name: demoservice
server:
   port: 8080

---
spring:
   profiles: dev
   application:
      name: demoservice
server:
   port: 9090

---
spring: 
   profiles: prod
   application:
      name: demoservice
server: 
   port: 4431

開発アクティブプロファイルを設定するコマンドを以下に示します-

以下に示すように、コンソールログにア​​クティブなプロファイル名が表示されます。

2017-11-26 08:41:37.202  INFO 14104 --- [           
   main] com.tutorialspoint.demo.DemoApplication  : 
   The following profiles are active: dev

これで、Tomcatは以下に示すようにポート9090(http)で起動しました-

2017-11-26 08:41:46.650  INFO 14104 --- [           
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 9090 (http)

本番アクティブプロファイルを設定するコマンドを以下に示します-

以下に示すように、コンソールログにア​​クティブなプロファイル名が表示されます。

2017-11-26 08:43:10.743  INFO 13400 --- [    
   main] com.tutorialspoint.demo.DemoApplication  : 
   The following profiles are active: prod

これにより、以下に示すように、ポート4431(http)でTomcatが起動します。

2017-11-26 08:43:14.473  INFO 13400 --- [     
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 4431 (http)

Spring Bootは、すべての内部ロギングにApacheCommonsロギングを使用します。Spring Bootのデフォルト構成は、Java Util Logging、Log4j2、およびLogbackの使用をサポートします。これらを使用して、コンソールログとファイルログを構成できます。

Spring Boot Startersを使用している場合、Logbackはロギングの優れたサポートを提供します。さらに、Logbackは、Common Logging、Util Logging、Log4J、およびSLF4Jの優れたサポートの使用も提供します。

ログ形式

デフォルトのSpringBoot Log形式は、以下のスクリーンショットに示されています。

これはあなたに次の情報を与えます-

  • Date そして Time ログの日付と時刻を示します

  • Log level INFO、ERROR、またはWARNを表示します

  • Process ID

  • ---セパレーターです

  • Thread name 角括弧[]で囲まれています

  • Logger Name ソースクラス名を示しています

  • ログメッセージ

コンソールログ出力

デフォルトのログメッセージがコンソールウィンドウに出力されます。デフォルトでは、「INFO」、「ERROR」、および「WARN」のログメッセージがログファイルに出力されます。

デバッグレベルのログを有効にする必要がある場合は、以下に示すコマンドを使用して、アプリケーションの起動時にデバッグフラグを追加します。

java –jar demo.jar --debug

次に示すように、application.propertiesファイルにデバッグモードを追加することもできます。

debug = true

ファイルログ出力

デフォルトでは、すべてのログはファイルではなくコンソールウィンドウに印刷されます。ログをファイルに出力する場合は、プロパティを設定する必要がありますlogging.file または logging.path application.propertiesファイル内。

以下に示すプロパティを使用して、ログファイルのパスを指定できます。ログファイル名はspring.logであることに注意してください。

logging.path = /var/tmp/

以下に示すプロパティを使用して、独自のログファイル名を指定できます-

logging.file = /var/tmp/mylog.log

Note −ファイルはサイズ10MBに達すると自動的に回転します。

ログレベル

Spring Bootは、「TRACE」、「DEBUG」、「INFO」、「WARN」、「ERROR」、「FATAL」、「OFF」などのすべてのロガーレベルをサポートします。以下に示すように、application.propertiesファイルでルートロガーを定義できます。

logging.level.root = WARN

Note−ログバックは「FATAL」レベルのログをサポートしていません。「ERROR」レベルのログにマップされます。

ログバックを構成する

Logbackは、Spring BootLog構成を処理するためのXMLベースの構成をサポートします。ロギング構成の詳細は、logback.xmlファイル。logback.xmlファイルはクラスパスの下に配置する必要があります。

以下のコードを使用して、Logback.xmlファイルでROOTレベルのログを構成できます。

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <root level = "INFO">
   </root>
</configuration>

以下に示すLogback.xmlファイルでコンソールアペンダーを構成できます。

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "STDOUT" class = "ch.qos.logback.core.ConsoleAppender"></appender>
   <root level = "INFO">
      <appender-ref ref = "STDOUT"/> 
   </root>
</configuration>

以下のコードを使用して、Logback.xmlファイルでファイルアペンダーを構成できます。ファイルアペンダー内でログファイルパスを指定する必要があることに注意してください。

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "FILE" class = "ch.qos.logback.core.FileAppender">
      <File>/var/tmp/mylog.log</File>
   </appender>   
   <root level = "INFO">
      <appender-ref ref = "FILE"/>
   </root>
</configuration>

ログパターンはで定義できます logback.xml以下のコードを使用してファイルします。以下のコードを使用して、コンソールまたはファイルログアペンダー内でサポートされているログパターンのセットを定義することもできます。

<pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>

完全なlogback.xmlファイルのコードを以下に示します。これをクラスパスに配置する必要があります。

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "STDOUT" class = "ch.qos.logback.core.ConsoleAppender">
      <encoder>
         <pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
      </encoder>
   </appender>
   
   <appender name = "FILE" class = "ch.qos.logback.core.FileAppender">
      <File>/var/tmp/mylog.log</File>
      <encoder>
         <pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
      </encoder>
   </appender>
   
   <root level = "INFO">
      <appender-ref ref = "FILE"/>
      <appender-ref ref = "STDOUT"/> 
   </root>
</configuration>

以下のコードは、SpringBootメインクラスファイルにslf4jロガーを追加する方法を示しています。

package com.tutorialspoint.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);
   
   public static void main(String[] args) {
      logger.info("this is a info message");
      logger.warn("this is a warn message");
      logger.error("this is a error message");
      SpringApplication.run(DemoApplication.class, args);
   }
}

コンソールウィンドウに表示される出力を次に示します-

ログファイルで確認できる出力を次に示します-

Spring Bootは、エンタープライズアプリケーション向けのRESTfulWebサービスの構築に非常に優れたサポートを提供します。この章では、SpringBootを使用したRESTfulWebサービスの構築について詳しく説明します。

Note − RESTful Webサービスをビルドするには、Spring Boot StarterWeb依存関係をビルド構成ファイルに追加する必要があります。

Mavenユーザーの場合は、次のコードを使用して、以下の依存関係をに追加します。 pom.xml ファイル-

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>    
</dependency>

Gradleユーザーの場合は、次のコードを使用して、以下の依存関係をに追加します build.gradle ファイル。

compile('org.springframework.boot:spring-boot-starter-web')

完全なビルド構成ファイルのコード Maven build – 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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>
   
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>
   
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

完全なビルド構成ファイルのコード Gradle Build – build.gradle 以下に示します-

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

RESTful Webサービスの構築に進む前に、次のアノテーションについての知識があることをお勧めします-

Restコントローラー

@RestControllerアノテーションは、RESTfulWebサービスを定義するために使用されます。JSON、XML、カスタム応答を提供します。その構文を以下に示します-

@RestController
public class ProductServiceController { 
}

マッピングのリクエスト

@RequestMappingアノテーションは、RESTエンドポイントにアクセスするためのリクエストURIを定義するために使用されます。オブジェクトを消費および生成するRequestメソッドを定義できます。デフォルトのリクエストメソッドはGETです。

@RequestMapping(value = "/products")
public ResponseEntity<Object> getProducts() { }

リクエストボディ

@RequestBodyアノテーションは、リクエスト本文のコンテンツタイプを定義するために使用されます。

public ResponseEntity<Object> createProduct(@RequestBody Product product) {
}

パス変数

@PathVariableアノテーションは、カスタムまたは動的リクエストURIを定義するために使用されます。リクエストURIのPath変数は、以下に示すように中括弧{}として定義されます-

public ResponseEntity<Object> updateProduct(@PathVariable("id") String id) {
}

リクエストパラメータ

@RequestParamアノテーションは、リクエストURLからリクエストパラメータを読み取るために使用されます。デフォルトでは、これは必須パラメーターです。次に示すように、リクエストパラメータのデフォルト値を設定することもできます-

public ResponseEntity<Object> getProduct(
   @RequestParam(value = "name", required = false, defaultValue = "honey") String name) {
}

GET API

デフォルトのHTTPリクエストメソッドはGETです。このメソッドはリクエストボディを必要としません。リクエストパラメータとパス変数を送信して、カスタムURLまたは動的URLを定義できます。

HTTPGETリクエストメソッドを定義するためのサンプルコードを以下に示します。この例では、HashMapを使用して製品を保存しました。保存する製品としてPOJOクラスを使用したことに注意してください。

ここで、リクエストURIは /productsそして、HashMapリポジトリから製品のリストを返します。GETメソッドRESTエンドポイントを含むコントローラークラスファイルを以下に示します。

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

POST API

HTTP POSTリクエストは、リソースを作成するために使用されます。このメソッドにはリクエストボディが含まれています。リクエストパラメータとパス変数を送信して、カスタムURLまたは動的URLを定義できます。

次の例は、HTTPPOSTリクエストメソッドを定義するためのサンプルコードを示しています。この例では、HashMapを使用してProductを格納しました。ここで、productはPOJOクラスです。

ここで、リクエストURIは /products、および製品をHashMapリポジトリに保存した後、文字列を返します。

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productRepo.put(product.getId(), product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
}

PUT API

HTTP PUTリクエストは、既存のリソースを更新するために使用されます。このメソッドにはリクエストボディが含まれています。リクエストパラメータとパス変数を送信して、カスタムURLまたは動的URLを定義できます。

以下の例は、HTTPPUT要求メソッドを定義する方法を示しています。この例では、HashMapを使用して、製品がPOJOクラスである既存の製品を更新しました。

ここでリクエストURIは /products/{id}これは、製品の後の文字列をHashMapリポジトリに返します。Path変数を使用したことに注意してください{id} これは、更新が必要な製品IDを定義します。

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }   
}

DELETE API

HTTP削除要求は、既存のリソースを削除するために使用されます。このメソッドにはリクエストボディは含まれていません。リクエストパラメータとパス変数を送信して、カスタムURLまたは動的URLを定義できます。

以下の例は、HTTPDELETE要求メソッドを定義する方法を示しています。この例では、HashMapを使用して、POJOクラスである既存の製品を削除しました。

リクエストURIは /products/{id}HashMapリポジトリから製品を削除した後、文字列を返します。Path変数を使用しました{id} これは、削除する必要のある製品IDを定義します。

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) { 
      productRepo.remove(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
}

このセクションでは、ソースコードの完全なセットを提供します。それぞれの機能について、次のコードを確認してください-

The Spring Boot main application class – DemoApplication.java

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

The POJO class – Product.java

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

The Rest Controller class – ProductServiceController.java

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) { 
      productRepo.remove(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }
   
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productRepo.put(product.getId(), product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
   
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

以下に示すように、実行可能なJARファイルを作成し、以下のMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、以下に示すコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下に示すコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

以下に示すコマンドを使用して、JARファイルを実行できます。

java –jar <JARFILE>

これにより、以下に示すように、Tomcatポート8080でアプリケーションが起動します。

次に、POSTMANアプリケーションで以下に示すURLをヒットし、出力を確認します。

GET APIURLは次のとおりです。 http://localhost:8080/products

POST APIURLは次のとおりです。 http://localhost:8080/products

PUT APIURLは次のとおりです。 http://localhost:8080/products/3

DELETE APIURLは次のとおりです。 http://localhost:8080/products/3

APIで例外やエラーを処理し、クライアントに適切な応答を送信することは、エンタープライズアプリケーションに適しています。この章では、SpringBootで例外を処理する方法を学習します。

例外処理に進む前に、次のアノテーションについて理解しましょう。

コントローラーのアドバイス

@ControllerAdviceは、例外をグローバルに処理するためのアノテーションです。

例外ハンドラ

@ExceptionHandlerは、特定の例外を処理し、カスタム応答をクライアントに送信するために使用されるアノテーションです。

次のコードを使用して@ControllerAdviceクラスを作成し、例外をグローバルに処理できます。

package com.tutorialspoint.demo.exception;

import org.springframework.web.bind.annotation.ControllerAdvice;

@ControllerAdvice
   public class ProductExceptionController {
}

RuntimeExceptionクラスを拡張するクラスを定義します。

package com.tutorialspoint.demo.exception;

public class ProductNotfoundException extends RuntimeException {
   private static final long serialVersionUID = 1L;
}

示されているように、@ ExceptionHandlerメソッドを定義して例外を処理できます。このメソッドは、ControllerAdviceクラスファイルの書き込みに使用する必要があります。

@ExceptionHandler(value = ProductNotfoundException.class)

public ResponseEntity<Object> exception(ProductNotfoundException exception) {
}

次に、以下のコードを使用して、APIから例外をスローします。

@RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
public ResponseEntity<Object> updateProduct() { 
   throw new ProductNotfoundException();
}

例外を処理するための完全なコードを以下に示します。この例では、PUTAPIを使用して製品を更新しました。ここで、製品の更新中に製品が見つからない場合は、「製品が見つかりません」という応答エラーメッセージを返します。注意してくださいProductNotFoundException 例外クラスは拡張する必要があります RuntimeException

package com.tutorialspoint.demo.exception;
public class ProductNotfoundException extends RuntimeException {
   private static final long serialVersionUID = 1L;
}

例外をグローバルに処理するためのControllerAdviceクラスを以下に示します。このクラスファイルでは、任意の例外ハンドラメソッドを定義できます。

package com.tutorialspoint.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class ProductExceptionController {
   @ExceptionHandler(value = ProductNotfoundException.class)
   public ResponseEntity<Object> exception(ProductNotfoundException exception) {
      return new ResponseEntity<>("Product not found", HttpStatus.NOT_FOUND);
   }
}

製品を更新するためのProductServiceAPIコントローラーファイルを以下に示します。製品が見つからない場合は、ProductNotFoundException クラス。

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      if(!productRepo.containsKey(id))throw new ProductNotfoundException();
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successfully", HttpStatus.OK);
   }
}

メインのSpringBootアプリケーションクラスファイルのコードを以下に示します-

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

のコード POJO class 製品の場合は以下のとおりです-

package com.tutorialspoint.demo.model;
public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

のコード Maven build – 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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

のコード Gradle Build – build.gradle 以下に示します-

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

実行可能なJARファイルを作成し、MavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます-

Mavenの場合、次のコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次のコマンドを使用して、JARファイルを実行できます-

java –jar <JARFILE>

これにより、以下に示すように、Tomcatポート8080でアプリケーションが起動します。

POSTMANアプリケーションで以下のURLを押すと、以下のような出力が表示されます-

更新URL:http:// localhost:8080 / products / 3

Spring Bootのインターセプターを使用して、次の状況で操作を実行できます。

  • コントローラにリクエストを送信する前に

  • クライアントに応答を送信する前

たとえば、インターセプターを使用して、コントローラーに要求を送信する前に要求ヘッダーを追加し、クライアントに応答を送信する前に応答ヘッダーを追加できます。

インターセプターを使用するには、作成する必要があります @Component それをサポートするクラスであり、実装する必要があります HandlerInterceptor インターフェース。

以下は、インターセプターで作業するときに知っておくべき3つの方法です。

  • preHandle()メソッド-これは、コントローラーに要求を送信する前に操作を実行するために使用されます。クライアントに応答を返すには、このメソッドはtrueを返す必要があります。

  • postHandle() メソッド-これは、クライアントに応答を送信する前に操作を実行するために使用されます。

  • afterCompletion() メソッド-これは、要求と応答を完了した後に操作を実行するために使用されます。

理解を深めるために、次のコードを確認してください。

@Component
public class ProductServiceInterceptor implements HandlerInterceptor {
   @Override
   public boolean preHandle(
      HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      
      return true;
   }
   @Override
   public void postHandle(
      HttpServletRequest request, HttpServletResponse response, Object handler, 
      ModelAndView modelAndView) throws Exception {}
   
   @Override
   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
      Object handler, Exception exception) throws Exception {}
}

このインターセプターをに登録する必要があります InterceptorRegistry を使用して WebMvcConfigurerAdapter 以下に示すように-

@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
   @Autowired
   ProductServiceInterceptor productServiceInterceptor;

   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(productServiceInterceptor);
   }
}

以下の例では、以下のように出力を提供するGET productsAPIをヒットします。

InterceptorクラスProductServiceInterceptor.javaのコードを以下に示します-

package com.tutorialspoint.demo.interceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

@Component
public class ProductServiceInterceptor implements HandlerInterceptor {
   @Override
   public boolean preHandle
      (HttpServletRequest request, HttpServletResponse response, Object handler) 
      throws Exception {
      
      System.out.println("Pre Handle method is Calling");
      return true;
   }
   @Override
   public void postHandle(HttpServletRequest request, HttpServletResponse response, 
      Object handler, ModelAndView modelAndView) throws Exception {
      
      System.out.println("Post Handle method is Calling");
   }
   @Override
   public void afterCompletion
      (HttpServletRequest request, HttpServletResponse response, Object 
      handler, Exception exception) throws Exception {
      
      System.out.println("Request and Response is completed");
   }
}

インターセプターをインターセプターレジストリに登録するためのアプリケーション構成クラスファイルのコード–ProductServiceInterceptorAppConfig.javaを以下に示します。

package com.tutorialspoint.demo.interceptor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
   @Autowired
   ProductServiceInterceptor productServiceInterceptor;

   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(productServiceInterceptor);
   }
}

コントローラクラスファイルProductServiceController.javaのコードを以下に示します-

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.demo.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();   
   static {      
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);      
   }
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

Product.javaのPOJOクラスのコードを以下に示します-

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

メインのSpringBootアプリケーションクラスファイルのコード DemoApplication.java 以下に示します-

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);   
   }
}

Mavenビルドのコード– 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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradleビルドのコード build.gradle ここに示されています-

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

以下のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、以下に示すコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下に示すコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次のコマンドを使用して、JARファイルを実行できます-

java –jar <JARFILE>

これで、以下に示すように、アプリケーションがTomcatポート8080で起動しました。

POSTMANアプリケーションで以下のURLを押すと、-の下に示すような出力が表示されます。

GET API: http://localhost:8080/products

以下のスクリーンショットに示すように、コンソールウィンドウで、インターセプターに追加されたSystem.out.printlnステートメントを確認できます。

フィルタは、アプリケーションのHTTP要求と応答をインターセプトするために使用されるオブジェクトです。フィルタを使用することにより、2つのインスタンスで2つの操作を実行できます-

  • コントローラにリクエストを送信する前に
  • クライアントに応答を送信する前。

次のコードは、@ Componentアノテーションが付いたサーブレットフィルター実装クラスのサンプルコードを示しています。

@Component
public class SimpleFilter implements Filter {
   @Override
   public void destroy() {}

   @Override
   public void doFilter
      (ServletRequest request, ServletResponse response, FilterChain filterchain) 
      throws IOException, ServletException {}

   @Override
   public void init(FilterConfig filterconfig) throws ServletException {}
}

次の例は、要求をコントローラーに送信する前に、ServletRequestオブジェクトからリモートホストとリモートアドレスを読み取るためのコードを示しています。

doFilter()メソッドに、リモートホストとリモートアドレスを出力するSystem.out.printlnステートメントを追加しました。

package com.tutorialspoint.demo;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.springframework.stereotype.Component;

@Component
public class SimpleFilter implements Filter {
   @Override
   public void destroy() {}

   @Override
   public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterchain) 
      throws IOException, ServletException {
      
      System.out.println("Remote Host:"+request.getRemoteHost());
      System.out.println("Remote Address:"+request.getRemoteAddr());
      filterchain.doFilter(request, response);
   }

   @Override
   public void init(FilterConfig filterconfig) throws ServletException {}
}

Spring Bootメインアプリケーションクラスファイルに、「HelloWorld」文字列を返す単純なRESTエンドポイントを追加しました。

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World";
   }
}

Mavenビルドのコード– 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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradleビルドのコード–build.gradleを以下に示します-

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

以下に示すMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、以下に示すコマンドを使用します-

mvn clean install

BUILD SUCCESSの後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下に示すコマンドを使用します-

gradle clean build

BUILD SUCCESSFULの後、build / libsディレクトリの下にJARファイルがあります。

次に、次のコマンドを使用してJARファイルを実行します。

java –jar <JARFILE>

アプリケーションがTomcatポート8080で起動したことがわかります。

今URLを打つ http://localhost:8080/出力HelloWorldを参照してください。以下のようになります-

次に、以下に示すように、コンソールログにリモートホストとリモートアドレスを確認できます。

Spring Bootを使用すると、同じアプリケーションを異なるポート番号で複数回実行できます。この章では、これについて詳しく学習します。デフォルトのポート番号8080に注意してください。

カスタムポート

の中に application.properties ファイルの場合、プロパティserver.portのカスタムポート番号を設定できます

server.port = 9090

の中に application.yml ファイル、あなたは次のように見つけることができます-

server: 
   port: 9090

ランダムポート

の中に application.properties ファイルの場合、プロパティserver.portにランダムなポート番号を設定できます

server.port = 0

の中に application.yml ファイル、あなたは次のように見つけることができます-

server: 
   port: 0

Note −もし server.port Spring Bootアプリケーションの起動中の番号は0で、Tomcatはランダムなポート番号を使用します。

Restテンプレートは、RESTfulWebサービスを使用するアプリケーションを作成するために使用されます。あなたは使用することができますexchange()すべてのHTTPメソッドのWebサービスを利用するメソッド。以下のコードは、RESTテンプレートオブジェクトを自動配線するためのRESTテンプレート用Beanを作成する方法を示しています。

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public RestTemplate getRestTemplate() {
      return new RestTemplate();
   }
}

取得する

Consuming the GET API by using RestTemplate - exchange() method

このURLを想定 http://localhost:8080/products 次のJSONを返し、次のコードを使用してRESTテンプレートを使用してこのAPI応答を使用します-

[
   {
      "id": "1",
      "name": "Honey"
   },
   {
      "id": "2",
      "name": "Almond"
   }
]

APIを使用するには、指定されたポイントに従う必要があります-

  • Restテンプレートオブジェクトを自動配線しました。
  • HttpHeadersを使用してリクエストヘッダーを設定します。
  • HttpEntityを使用して、リクエストオブジェクトをラップします。
  • Exchange()メソッドのURL、HttpMethod、および戻り値の型を指定します。
@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products")
   public String getProductList() {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity <String> entity = new HttpEntity<String>(headers);
      
      return restTemplate.exchange("
         http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
   }
}

役職

Consuming POST API by using RestTemplate - exchange() method

このURLを想定 http://localhost:8080/products 以下に示す応答を返します。Restテンプレートを使用してこのAPI応答を使用します。

以下のコードはリクエスト本文です-

{
   "id":"3",
   "name":"Ginger"
}

以下のコードは応答本文です-

Product is created successfully

APIを使用するには、以下のポイントに従う必要があります-

  • Restテンプレートオブジェクトを自動配線しました。

  • HttpHeadersを使用して、リクエストヘッダーを設定します。

  • HttpEntityを使用して、リクエストオブジェクトをラップします。ここでは、Productオブジェクトをラップして、リクエストの本文に送信します。

  • exchange()メソッドのURL、HttpMethod、および戻り値の型を指定します。

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products", method = RequestMethod.POST)
   public String createProducts(@RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
   }
}

プット

Consuming PUT API by using RestTemplate - exchange() method

このURLを想定 http://localhost:8080/products/3 以下の応答を返します。RESTテンプレートを使用してこのAPI応答を使用します。

以下のコードはリクエスト本文です-

{
   "name":"Indian Ginger"
}

以下のコードは応答本文です-

Product is updated successfully

APIを使用するには、以下のポイントに従う必要があります-

  • Restテンプレートオブジェクトを自動配線しました。

  • HttpHeadersを使用してリクエストヘッダーを設定します。

  • HttpEntityを使用して、リクエストオブジェクトをラップします。ここでは、Productオブジェクトをラップして、リクエストの本文に送信します。

  • exchange()メソッドのURL、HttpMethod、および戻り値の型を指定します。

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
   public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
   }
}

削除

Consuming DELETE API by using RestTemplate - exchange() method

このURLを想定 http://localhost:8080/products/3 以下に示す応答を返します。RESTテンプレートを使用してこのAPI応答を使用します。

以下に示すこのコード行は、応答の本文です。

Product is deleted successfully

APIを利用するには、以下のポイントに従う必要があります-

  • Restテンプレートオブジェクトを自動配線しました。

  • HttpHeadersを使用してリクエストヘッダーを設定します。

  • HttpEntityを使用して、リクエストオブジェクトをラップします。

  • exchange()メソッドのURL、HttpMethod、および戻り値の型を指定します。

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
   public String deleteProduct(@PathVariable("id") String id) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
   }
}

完全なRestTemplateControllerクラスファイルを以下に示します-

package com.tutorialspoint.demo.controller;

import java.util.Arrays;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products")
   public String getProductList() {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<String> entity = new HttpEntity<String>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products", method = RequestMethod.POST)
   public String createProducts(@RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
   public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
   public String deleteProduct(@PathVariable("id") String id) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
   }
}

Spring Bootアプリケーションクラス–DemoApplication.javaのコードを以下に示します-

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Mavenビルドのコード–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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradleビルドのコード–build.gradleを以下に示します-

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、以下のコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下に示すコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで、次のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、アプリケーションはTomcatポート8080で起動しました。

POSTMANアプリケーションで以下のURLを押すと、出力が表示されます。

Restテンプレートで製品を入手- http://localhost:8080/template/products

製品の作成POST- http://localhost:8080/template/products

製品PUTの更新- http://localhost:8080/template/products/3

製品の削除- http://localhost:8080/template/products/3

この章では、Webサービスを使用してファイルをアップロードおよびダウンロードする方法を学習します。

ファイルのアップロード

ファイルのアップロードには、 MultipartFileリクエストパラメータとして、このAPIはマルチパートフォームのデータ値を消費する必要があります。以下のコードを確認してください-

@RequestMapping(value = "/upload", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)

public String fileUpload(@RequestParam("file") MultipartFile file) {
   return null;
}

同じための完全なコードを以下に示します-

package com.tutorialspoint.demo.controller;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class FileUploadController {
   @RequestMapping(value = "/upload", method = RequestMethod.POST, 
      consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
   
   public String fileUpload(@RequestParam("file") MultipartFile file) throws IOException {
      File convertFile = new File("/var/tmp/"+file.getOriginalFilename());
      convertFile.createNewFile();
      FileOutputStream fout = new FileOutputStream(convertFile);
      fout.write(file.getBytes());
      fout.close();
      return "File is upload successfully";
   }
}

ファイルのダウンロード

ファイルのダウンロードには、InputStreamResourceを使用してファイルをダウンロードする必要があります。HttpHeaderを設定する必要がありますContent-Disposition 応答で、アプリケーションの応答メディアタイプを指定する必要があります。

Note −次の例では、ファイルは、アプリケーションが実行されている指定されたパスで使用可能である必要があります。

@RequestMapping(value = "/download", method = RequestMethod.GET) 
public ResponseEntity<Object> downloadFile() throws IOException  {
   String filename = "/var/tmp/mysql.png";
   File file = new File(filename);
   InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
   HttpHeaders headers = new HttpHeaders();
      
   headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", file.getName()));
   headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
   headers.add("Pragma", "no-cache");
   headers.add("Expires", "0");
      
   ResponseEntity<Object> 
   responseEntity = ResponseEntity.ok().headers(headers).contentLength(file.length()).contentType(
      MediaType.parseMediaType("application/txt")).body(resource);
      
   return responseEntity;
}

同じための完全なコードを以下に示します-

package com.tutorialspoint.demo.controller;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.springframework.core.io.InputStreamResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class FileDownloadController {
   @RequestMapping(value = "/download", method = RequestMethod.GET) 
   public ResponseEntity<Object> downloadFile() throws IOException  {
      String filename = "/var/tmp/mysql.png";
      File file = new File(filename);
      InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
      HttpHeaders headers = new HttpHeaders();
      
      headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", file.getName()));
      headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
      headers.add("Pragma", "no-cache");
      headers.add("Expires", "0");
      
      ResponseEntity<Object> 
      responseEntity = ResponseEntity.ok().headers(headers).contentLength(
         file.length()).contentType(MediaType.parseMediaType("application/txt")).body(resource);
      
      return responseEntity;
   }
}

主なSpringBootアプリケーションを以下に示します-

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Mavenビルドのコード–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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradleビルドのコード–build.gradleを以下に示します-

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

これで、実行可能なJARファイルを作成し、以下に示すMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、以下のコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下に示すコマンドを使用できます-

sgradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで、次のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これにより、以下に示すように、Tomcatポート8080でアプリケーションが起動します。

POSTMANアプリケーションで以下のURLにアクセスすると、以下のような出力が表示されます。

ファイルのアップロード- http://localhost:8080/upload

ファイルのダウンロード- http://localhost:8080/upload

サービスコンポーネントは、@ Serviceアノテーションを含むクラスファイルです。これらのクラスファイルは、@ RestControllerクラスファイルとは別に、別のレイヤーにビジネスロジックを書き込むために使用されます。サービスコンポーネントクラスファイルを作成するためのロジックを次に示します-

public interface ProductService {
}

@Serviceアノテーション付きのインターフェースを実装するクラスは次のとおりです-

@Service
public class ProductServiceImpl implements ProductService {
}

このチュートリアルでは、使用していることに注意してください Product Service API(s)製品を保存、取得、更新、および削除します。@RestControllerクラスファイル自体にビジネスロジックを記述しました。次に、ビジネスロジックコードをコントローラーからサービスコンポーネントに移動します。

以下に示すコードを使用して、add、edit、get、およびdeleteメソッドを含むインターフェイスを作成できます。

package com.tutorialspoint.demo.service;

import java.util.Collection;
import com.tutorialspoint.demo.model.Product;

public interface ProductService {
   public abstract void createProduct(Product product);
   public abstract void updateProduct(String id, Product product);
   public abstract void deleteProduct(String id);
   public abstract Collection<Product> getProducts();
}

次のコードを使用すると、@ Serviceアノテーションを使用してProductServiceインターフェイスを実装するクラスを作成し、製品を格納、取得、削除、および更新するためのビジネスロジックを記述できます。

package com.tutorialspoint.demo.service;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.tutorialspoint.demo.model.Product;

@Service
public class ProductServiceImpl implements ProductService {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);

      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   @Override
   public void createProduct(Product product) {
      productRepo.put(product.getId(), product);
   }
   @Override
   public void updateProduct(String id, Product product) {
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
   }
   @Override
   public void deleteProduct(String id) {
      productRepo.remove(id);

   }
   @Override
   public Collection<Product> getProducts() {
      return productRepo.values();
   }
}

ここのコードは、Rest Controllerクラスファイルを示しています。ここでは、ProductServiceインターフェイスを@Autowiredし、メソッドを呼び出しました。

package com.tutorialspoint.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;
import com.tutorialspoint.demo.service.ProductService;

@RestController
public class ProductServiceController {
   @Autowired
   ProductService productService;

   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productService.getProducts(), HttpStatus.OK);
   }
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> 
      updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      
      productService.updateProduct(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) {
      productService.deleteProduct(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productService.createProduct(product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
}

POJOクラスのコード–Product.javaを次に示します-

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

主なSpringBootアプリケーションを以下に示します-

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Mavenビルドのコード–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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>

</project>

Gradleビルドのコード–build.gradleを以下に示します-

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

実行可能なJARファイルを作成し、以下に示すMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、以下に示すコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下に示すコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

以下のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、以下の画像に示すように、アプリケーションがTomcatポート8080で起動しました。

POSTMANアプリケーションで以下のURLにアクセスすると、以下のような出力が表示されます。

GET APIURLは- http://localhost:8080/products

POST APIURLは- http://localhost:8080/products

PUT APIURLは- http://localhost:8080/products/3

DELETE APIURLは- http://localhost:8080/products/3

Thymeleafは、Webアプリケーションの作成に使用されるJavaベースのライブラリです。これは、WebアプリケーションでXHTML / HTML5を提供するための優れたサポートを提供します。この章では、Thymeleafについて詳しく学習します。

Thymeleafテンプレート

Thymeleafは、ファイルを整形式のXMLファイルに変換します。以下の6種類のテンプレートが含まれています-

  • XML
  • 有効なXML
  • XHTML
  • 有効なXHTML
  • HTML5
  • レガシーHTML5

レガシーHTML5を除くすべてのテンプレートは、整形式の有効なXMLファイルを参照しています。レガシーHTML5を使用すると、閉じていないタグを含むHTML5タグをWebページにレンダリングできます。

ウェブアプリケーション

Thymeleafテンプレートを使用して、SpringBootでWebアプリケーションを作成できます。Thymeleafを使用してSpringBootでWebアプリケーションを作成するには、以下の手順に従う必要があります。

次のコードを使用して@Controllerクラスファイルを作成し、リクエストURIをHTMLファイルにリダイレクトします-

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class WebController {
   @RequestMapping(value = "/index")
   public String index() {
      return "index";
   }
}

上記の例では、リクエストURIは /index、およびコントロールはindex.htmlファイルにリダイレクトされます。index.htmlファイルはtemplatesディレクトリの下に配置する必要があり、すべてのJSファイルとCSSファイルはクラスパスの静的ディレクトリの下に配置する必要があることに注意してください。示されている例では、CSSファイルを使用してテキストの色を変更しました。

次のコードを使用して、別のフォルダーにCSSファイルを作成できます css ファイルにstyles.css−という名前を付けます。

h4 {
   color: red;
}

index.htmlファイルのコードを以下に示します-

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1" />
      <link href = "css/styles.css" rel = "stylesheet"/>
      <title>Spring Boot Application</title>
   </head>
   <body>
      <h4>Welcome to Thymeleaf Spring Boot web application</h4>
   </body>
</html>

プロジェクトエクスプローラーは、以下のスクリーンショットに示されています-

次に、ビルド構成ファイルにSpring Boot StarterThymeleaf依存関係を追加する必要があります。

Mavenユーザーは、次の依存関係をpom.xmlファイルに追加できます-

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます-

compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

メインのSpringBootアプリケーションクラスファイルのコードを以下に示します-

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Mavenのコード–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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle –build.gradleのコードを以下に示します-

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、以下に示すコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下に示すコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで指定されたコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、以下に示すように、アプリケーションがTomcatポート8080で起動しました。

次に、WebブラウザでURLを押すと、次のような出力が表示されます-

http://localhost:8080/index

この章では、jQueryAJAXを使用してRESTfulWebサービスを利用する方法について詳しく説明します。

単純なSpringBoot Webアプリケーションを作成し、RESTfulWebサービスを利用するためにHTMLファイルにリダイレクトするために使用されるコントローラークラスファイルを記述します。

SpringBootスターターのThymeleafとWebの依存関係をビルド構成ファイルに追加する必要があります。

Mavenユーザーの場合、pom.xmlファイルに以下の依存関係を追加します。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Gradleユーザーの場合、以下の依存関係をbuild.gradleファイルに追加します-

compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
compile(‘org.springframework.boot:spring-boot-starter-web’)

@Controllerクラスファイルのコードを以下に示します-

@Controller
public class ViewController {
}

以下に示すように、HTMLファイルにリダイレクトするRequestURIメソッドを定義できます。

@RequestMapping(“/view-products”)
public String viewProducts() {
   return “view-products”;
}
@RequestMapping(“/add-products”)
public String addProducts() {
   return “add-products”;
}

このAPI http://localhost:9090/products 以下に示すように、応答として以下のJSONを返す必要があります-

[
   {
      "id": "1",
      "name": "Honey"
   },
   {
      "id": "2",
      "name": "Almond"
   }
]

次に、クラスパスのtemplatesディレクトリの下にview-products.htmlファイルを作成します。

HTMLファイルに、jQueryライブラリを追加し、ページの読み込み時にRESTfulWebサービスを使用するコードを記述しました。

<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>

<script>
$(document).ready(function(){
   $.getJSON("http://localhost:9090/products", function(result){ $.each(result, function(key,value) {
         $("#productsJson").append(value.id+" "+value.name+" ");
      }); 
   });
});
</script>

POSTメソッドとこのURL http://localhost:9090/products 以下のリクエストボディとレスポンスボディが含まれている必要があります。

リクエスト本文のコードを以下に示します-

{
   "id":"3",
   "name":"Ginger"
}

応答本文のコードを以下に示します-

Product is created successfully

次に、クラスパスのtemplatesディレクトリの下にadd-products.htmlファイルを作成します。

HTMLファイルに、jQueryライブラリを追加し、ボタンをクリックするとフォームをRESTfulWebサービスに送信するコードを記述しました。

<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
<script>
   $(document).ready(function() {
      $("button").click(function() { var productmodel = { id : "3", name : "Ginger" }; var requestJSON = JSON.stringify(productmodel); $.ajax({
            type : "POST",
            url : "http://localhost:9090/products",
            headers : {
               "Content-Type" : "application/json"
            },
            data : requestJSON,
            success : function(data) {
               alert(data);
            },
            error : function(data) {
            }
         });
      });
   });
</script>

完全なコードを以下に示します。

Maven –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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle –build.gradleのコードを以下に示します-

buildscript {
   ext {
      springBootVersion = ‘1.5.8.RELEASE’
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: ‘java’
apply plugin: ‘eclipse’
apply plugin: ‘org.springframework.boot’

group = ‘com.tutorialspoint’
version = ‘0.0.1-SNAPSHOT’
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}

dependencies {
   compile(‘org.springframework.boot:spring-boot-starter-web’)
   compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
   testCompile(‘org.springframework.boot:spring-boot-starter-test’)
}

以下に示すコントローラークラスファイル–ViewController.javaを以下に示します-

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping(“/view-products”)
   public String viewProducts() {
      return “view-products”;
   }
   @RequestMapping(“/add-products”)
   public String addProducts() {
      return “add-products”;   
   }   
}

view-products.htmlファイルを以下に示します-

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1"/>
      <title>View Products</title>
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
      
      <script>
         $(document).ready(function(){
            $.getJSON("http://localhost:9090/products", function(result){ $.each(result, function(key,value) {
                  $("#productsJson").append(value.id+" "+value.name+" ");
               }); 
            });
         });
      </script>
   </head>
   
   <body>
      <div id = "productsJson"> </div>
   </body>
</html>

add-products.htmlファイルを以下に示します-

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1" />
      <title>Add Products</title>
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
      
      <script>
         $(document).ready(function() {
            $("button").click(function() { var productmodel = { id : "3", name : "Ginger" }; var requestJSON = JSON.stringify(productmodel); $.ajax({
                  type : "POST",
                  url : "http://localhost:9090/products",
                  headers : {
                     "Content-Type" : "application/json"
                  },
                  data : requestJSON,
                  success : function(data) {
                     alert(data);
                  },
                  error : function(data) {
                  }
               });
            });
         });
      </script>
   </head>
   
   <body>
      <button>Click here to submit the form</button>
   </body>
</html>

主なSpringBootApplicationクラスファイルを以下に示します-

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

これで、実行可能なJARファイルを作成し、次のMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、以下のコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下のコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、アプリケーションはTomcatポート8080で起動しました。

次に、WebブラウザでURLを押すと、次のような出力が表示されます-

http:// localhost:8080 / view-products

http:// localhost:8080 / add-products

次に、ボタンをクリックします Click here to submit the form そして、あなたは示されているように結果を見ることができます-

次に、製品の表示URLを押して、作成された製品を確認します。

http://localhost:8080/view-products

Angular JS

Angular JSを使用してAPIを使用するには、以下の例を使用できます-

次のコードを使用して、GETAPIを使用するAngularJSコントローラーを作成します- http://localhost:9090/products

angular.module('demo', [])
.controller('Hello', function($scope, $http) {
   $http.get('http://localhost:9090/products'). then(function(response) { $scope.products = response.data;
   });
});

次のコードを使用して、POSTAPIを使用するAngularJSコントローラーを作成します- http://localhost:9090/products

angular.module('demo', [])
.controller('Hello', function($scope, $http) {
   $http.post('http://localhost:9090/products',data).
   then(function(response) {
      console.log("Product created successfully");
   });
});

Note − Postメソッドデータは、製品を作成するためのリクエスト本文をJSON形式で表します。

クロスオリジンリソースシェアリング(CORS)は、Webブラウザーに実装されるリソースを制限できるセキュリティの概念です。これにより、JavaScriptコードが異なるオリジンに対してリクエストを生成または消費するのを防ぎます。

たとえば、Webアプリケーションが8080ポートで実行されており、JavaScriptを使用して、9090ポートからRESTfulWebサービスを利用しようとしています。このような状況では、Webブラウザでクロスオリジンリソースシェアリングのセキュリティ問題が発生します。

この問題を処理するには、2つの要件が必要です-

  • RESTful Webサービスは、クロスオリジンリソースシェアリングをサポートする必要があります。

  • RESTful Webサービスアプリケーションは、8080ポートからAPIへのアクセスを許可する必要があります。

この章では、RESTfulWebサービスアプリケーションのクロスオリジンリクエストを有効にする方法について詳しく学習します。

コントローラメソッドでCORSを有効にする

を使用してRESTfulWebサービスのオリジンを設定する必要があります @CrossOriginコントローラメソッドのアノテーション。この@CrossOriginアノテーションは、アプリケーション全体ではなく、特定のRESTAPIをサポートします。

@RequestMapping(value = "/products")
@CrossOrigin(origins = "http://localhost:8080")

public ResponseEntity<Object> getProduct() {
   return null;
}

グローバルCORS構成

表示されている@Bean構成を定義して、CORS構成サポートをSpringBootアプリケーションにグローバルに設定する必要があります。

@Bean
public WebMvcConfigurer corsConfigurer() {
   return new WebMvcConfigurerAdapter() {
      @Override
      public void addCorsMappings(CorsRegistry registry) {
         registry.addMapping("/products").allowedOrigins("http://localhost:9000");
      }    
   };
}

メインのSpringBootアプリケーションでCORS構成をグローバルに設定するようにコーディングする方法を以下に示します。

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public WebMvcConfigurer corsConfigurer() {
      return new WebMvcConfigurerAdapter() {
         @Override
         public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/products").allowedOrigins("http://localhost:8080");
         }
      };
   }
}

これで、8080ポートで実行できるSpring Boot Webアプリケーションと、9090ポートで実行できるRESTfulWebサービスアプリケーションを作成できます。RESTful Webサービスの実装の詳細については、「RESTfulWebサービス」というタイトルの章を参照してください。Consuming RESTful Web Services このチュートリアルの。

国際化は、ソースコードをエンジニアリング的に変更することなく、アプリケーションをさまざまな言語や地域に適応させるプロセスです。つまり、国際化はローカリゼーションの準備ができているということです。

この章では、SpringBootで国際化を実装する方法について詳しく学習します。

依存関係

Spring BootでWebアプリケーションを開発するには、Spring Boot StarterWebとSpringBoot StarterThymeleafの依存関係が必要です。

Maven

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Gradle

compile('org.springframework.boot:spring-boot-starter-web')
compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

LocaleResolver

アプリケーションのデフォルトのロケールを決定する必要があります。SpringBootアプリケーションにLocaleResolverBeanを追加する必要があります。

@Bean
public LocaleResolver localeResolver() {
   SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
   sessionLocaleResolver.setDefaultLocale(Locale.US);
   return sessionLocaleResolver;
}

LocaleChangeInterceptor

LocaleChangeInterceptorは、リクエストに追加された言語パラメータの値に基づいて新しいロケールを変更するために使用されます。

@Bean
public LocaleChangeInterceptor localeChangeInterceptor() {
   LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
   localeChangeInterceptor.setParamName("language");
   return localeChangeInterceptor;
}

この効果を得るには、LocaleChangeInterceptorをアプリケーションのレジストリインターセプターに追加する必要があります。構成クラスは、WebMvcConfigurerAdapterクラスを拡張し、addInterceptors()メソッドをオーバーライドする必要があります。

@Override
public void addInterceptors(InterceptorRegistry registry) {
   registry.addInterceptor(localeChangeInterceptor());
}

メッセージソース

Spring Bootアプリケーションは、デフォルトでメッセージソースを src/main/resourcesクラスパスの下のフォルダ。デフォルトのロケールメッセージファイル名は次のようになりますmessage.properties 各ロケールのファイルには、次の名前を付ける必要があります messages_XX.properties。「XX」はロケールコードを表します。

すべてのメッセージプロパティは、キーペア値として使用する必要があります。ロケールでプロパティが見つからない場合、アプリケーションはmessages.propertiesファイルのデフォルトのプロパティを使用します。

デフォルトのmessages.propertiesは次のようになります-

welcome.text=Hi Welcome to Everyone

フランス語のmessages_fr.propertiesは次のようになります-

welcome.text=Salut Bienvenue à tous

Note −メッセージソースファイルは「UTF-8」ファイル形式で保存する必要があります。

HTMLファイル

HTMLファイルで、構文を使用します #{key} プロパティファイルからのメッセージを表示します。

<h1 th:text = "#{welcome.text}"></h1>

完全なコードを以下に示します

Maven – 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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

主なSpringBootアプリケーションクラスファイルを以下に示します-

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

コントローラクラスファイルを以下に示します-

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping("/locale")
   public String locale() {
      return "locale";
   }
}

国際化をサポートするための構成クラス

package com.tutorialspoint.demo;

import java.util.Locale;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;

@Configuration
public class Internationalization extends WebMvcConfigurerAdapter {
   @Bean
   public LocaleResolver localeResolver() {
      SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
      sessionLocaleResolver.setDefaultLocale(Locale.US);
      return sessionLocaleResolver;
   }
   @Bean
   public LocaleChangeInterceptor localeChangeInterceptor() {
      LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
      localeChangeInterceptor.setParamName("language");
      return localeChangeInterceptor;
   }
   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(localeChangeInterceptor());
   }
}

メッセージソース–messages.propertiesは次のとおりです-

welcome.text = Hi Welcome to Everyone

メッセージソース–message_fr.propertiesは次のとおりです-

welcome.text = Salut Bienvenue à tous

HTMLファイルlocale.htmlは、次のようにクラスパスのテンプレートディレクトリの下に配置する必要があります-

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1"/>
      <title>Internationalization</title>
   </head>
   <body>
      <h1 th:text = "#{welcome.text}"></h1>
   </body>
</html>

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、Springブートアプリケーションを実行できます。

Mavenの場合、次のコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次に、次のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

アプリケーションがTomcatポート8080で開始されていることがわかります。

今URLを打つ http://localhost:8080/locale Webブラウザーで、次の出力を確認できます-

URL http://localhost:8080/locale?language=fr 示されているような出力が得られます-

スケジューリングは、特定の期間にタスクを実行するプロセスです。Spring Bootは、Springアプリケーションでスケジューラーを作成するための優れたサポートを提供します。

JavaCron式

Java Cron式は、org.quartz.TriggerのサブクラスであるCronTriggerのインスタンスを構成するために使用されます。Java cron式の詳細については、このリンクを参照してください-

https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.htm

@EnableSchedulingアノテーションは、アプリケーションのスケジューラーを有効にするために使用されます。このアノテーションは、メインのSpringBootアプリケーションクラスファイルに追加する必要があります。

@SpringBootApplication
@EnableScheduling

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

@Scheduledアノテーションは、特定の期間、スケジューラーをトリガーするために使用されます。

@Scheduled(cron = "0 * 9 * * ?")
public void cronJobSch() throws Exception {
}

以下は、毎日午前9時から午前9時59分まで、毎分タスクを実行する方法を示すサンプルコードです。

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(cron = "0 * 9 * * ?")
   public void cronJobSch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Java cron job expression:: " + strDate);
   }
}

次のスクリーンショットは、アプリケーションが09:03:23に開始され、その時点から1分ごとにcronジョブスケジューラタスクが実行されたことを示しています。

固定金利

固定レートスケジューラは、特定の時間にタスクを実行するために使用されます。前のタスクの完了を待ちません。値はミリ秒単位である必要があります。サンプルコードをここに示します-

@Scheduled(fixedRate = 1000)
public void fixedRateSch() { 
}

アプリケーションの起動から毎秒タスクを実行するためのサンプルコードを次に示します-

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(fixedRate = 1000)
   public void fixedRateSch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Fixed Rate scheduler:: " + strDate);
   }
}

09:12:00に開始され、その後は1つおきの固定レートスケジューラタスクが実行されたアプリケーションを示す次のスクリーンショットを確認してください。

固定遅延

固定遅延スケジューラは、特定の時間にタスクを実行するために使用されます。前のタスクの完了を待つ必要があります。値はミリ秒単位である必要があります。サンプルコードをここに示します-

@Scheduled(fixedDelay = 1000, initialDelay = 1000)
public void fixedDelaySch() {
}

ここで、initialDelayは、初期遅延値の後にタスクが最初に実行されるまでの時間です。

アプリケーションの起動から3秒が経過した後、毎秒タスクを実行する例を以下に示します。

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(fixedDelay = 1000, initialDelay = 3000)
   public void fixedDelaySch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Fixed Delay scheduler:: " + strDate);
   }
}

09:18:39に開始され、3秒ごとに、固定遅延スケジューラタスクが毎秒実行されたアプリケーションを示す次のスクリーンショットを確認してください。

デフォルトでは、SpringBootアプリケーションはアプリケーションの起動時にHTTP8080ポートを使用します。

Spring BootアプリケーションでHTTPSとポート443を構成するには、以下の手順に従う必要があります。

  • SSL証明書を取得する–自己署名証明書を作成するか、認証局から証明書を取得します

  • HTTPSと443ポートを有効にする

自己署名証明書

自己署名証明書を作成するために、Javaランタイム環境には証明書管理ユーティリティキーツールがバンドルされています。このユーティリティツールは、自己署名証明書を作成するために使用されます。ここに示されているコードに示されています-

keytool -genkey -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650
Enter keystore password:
   Re-enter new password:
   What is your first and last name?
   [Unknown]:
   What is the name of your organizational unit?
   [Unknown]:
   What is the name of your organization?
   [Unknown]:
   What is the name of your City or Locality?
   [Unknown]:
   What is the name of your State or Province?
   [Unknown]:
   What is the two-letter country code for this unit?
   [Unknown]:
   Is CN = Unknown, OU=Unknown, O = Unknown, L = Unknown, ST = Unknown, C = Unknown correct?
   [no]: yes

このコードは、keystore.p12という名前のPKCS12キーストアファイルを生成し、証明書のエイリアス名はtomcatです。

HTTPSを構成する

application.propertiesファイルに、サーバーポートを443、キーストアファイルパス、キーストアパスワード、キーストアタイプ、およびキーエイリアス名として指定する必要があります。ここに記載されているコードを確認してください-

server.port: 443
server.ssl.key-store: keystore.p12
server.ssl.key-store-password: springboot
server.ssl.keyStoreType: PKCS12
server.ssl.keyAlias: tomcat

YAMLプロパティを使用している場合は、以下のapplication.yml −を使用して次のコードを使用できます。

server:
   port: 443
   ssl:
      key-store: keystore.p12
      key-store-password: springboot
      keyStoreType: PKCS12
      keyAlias: tomcat

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、次のコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、コマンドを使用できます

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで、次のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、アプリケーションは、示されているようにhttpsを使用してTomcatポート443で起動しました。

Eureka Serverは、すべてのクライアントサービスアプリケーションに関する情報を保持するアプリケーションです。すべてのマイクロサービスはEurekaサーバーに登録され、Eurekaサーバーは各ポートとIPアドレスで実行されているすべてのクライアントアプリケーションを認識しています。EurekaサーバーはDiscoveryServerとも呼ばれます。

この章では、Eurekaサーバーの構築方法について詳しく学習します。

Eurekaサーバーの構築

Eureka Serverには、SpringCloudのバンドルが付属しています。このためには、Eurekaサーバーを開発し、デフォルトのポート8761で実行する必要があります。

SpringInitializerのホームページにアクセス https://start.spring.io/Eurekaサーバーに依存するSpringBootプロジェクトをダウンロードします。以下のスクリーンショットに示されています-

プロジェクトをメインのSpringBoot Applicationクラスファイルにダウンロードした後、@ EnableEurekaServerアノテーションを追加する必要があります。@EnableEurekaServerアノテーションは、SpringBootアプリケーションをEurekaサーバーとして機能させるために使用されます。

メインのSpringBootアプリケーションクラスファイルのコードは次のとおりです。

package com.tutorialspoint.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaserverApplication.class, args);
   }
}

SpringクラウドのEurekaサーバーの依存関係がビルド構成ファイルに追加されていることを確認してください。

Mavenユーザー依存関係のコードを以下に示します-

<dependency>
<groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>

Gradleユーザー依存関係のコードを以下に示します-

compile('org.springframework.cloud:spring-cloud-starter-eureka-server')

完全なビルド構成ファイルを以下に示します-

Maven 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.tutorialspoint</groupId>
   <artifactId>eurekaserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>eurekaserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka-server</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-eureka-server')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

デフォルトでは、Eurekaサーバーはそれ自体をディスカバリーに登録します。以下の構成をapplication.propertiesファイルまたはapplication.ymlファイルに追加する必要があります。

application.propertiesファイルを以下に示します-

eureka.client.registerWithEureka = false
eureka.client.fetchRegistry = false
server.port = 8761

application.ymlファイルを以下に示します-

eureka:
   client:
      registerWithEureka: false
      fetchRegistry: false
server:
   port: 8761

これで、実行可能なJARファイルを作成し、以下に示すMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、以下に示すコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下に示すコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで、次のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

以下に示すように、アプリケーションがTomcatポート8761で開始されていることがわかります。

今、URLを打つ http://localhost:8761/ Webブラウザーで、以下に示すように、ポート8761で実行されているEurekaサーバーを見つけることができます。

この章では、Spring BootMicroサービスアプリケーションをEurekaサーバーに登録する方法について詳しく学習します。アプリケーションを登録する前に、Eurekaサーバーがポート8761で実行されていることを確認するか、最初にEurekaサーバーをビルドして実行してください。Eurekaサーバーの構築の詳細については、前の章を参照してください。

まず、マイクロサービスをEurekaサーバーに登録するために、ビルド構成ファイルに次の依存関係を追加する必要があります。

Mavenユーザーは、次の依存関係をに追加できます。 pom.xml ファイル-

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>

Gradleユーザーは、次の依存関係をに追加できます。 build.gradle ファイル-

compile('org.springframework.cloud:spring-cloud-starter-eureka')

次に、メインのSpringBootアプリケーションクラスファイルに@EnableEurekaClientアノテーションを追加する必要があります。@EnableEurekaClientアノテーションにより、SpringBootアプリケーションがEurekaクライアントとして機能します。

主なSpringBootアプリケーションは次のとおりです-

package com.tutorialspoint.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class EurekaclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaclientApplication.class, args);
   }
}

SpringBootアプリケーションをEurekaServerに登録するには、application.propertiesファイルまたはapplication.ymlファイルに次の構成を追加し、構成でEurekaサーバーのURLを指定する必要があります。

application.ymlファイルのコードを以下に示します-

eureka:
   client:
      serviceUrl:
         defaultZone: http://localhost:8761/eureka
      instance:
      preferIpAddress: true
spring:
   application:
      name: eurekaclient

application.propertiesファイルのコードを以下に示します-

eureka.client.serviceUrl.defaultZone  = http://localhost:8761/eureka
eureka.client.instance.preferIpAddress = true
spring.application.name = eurekaclient

次に、Rest Endpointを追加して、メインのSpringBootアプリケーションでStringを返し、ビルド構成ファイルでSpring Boot StarterWeb依存関係を返します。以下のコードを確認してください-

package com.tutorialspoint.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableEurekaClient
@RestController
public class EurekaclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaclientApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String home() {
      return "Eureka Client application";
   }
}

構成ファイル全体を以下に示します。

For Maven user - 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.tutorialspoint</groupId>
   <artifactId>eurekaclient</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>eurekaclient</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>   
   </build>
   
</projecta>

For Gradle user – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('org.springframework.cloud:spring-cloud-starter-eureka') testCompile('org.springframework.boot:spring-boot-starter-test') compile('org.springframework.boot:spring-boot-starter-web') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、次のコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次に、次のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、アプリケーションはTomcatポート8080で起動し、Eurekaクライアントアプリケーションは以下に示すようにEurekaサーバーに登録されます。

WebブラウザでURLhttp:// localhost:8761 /を押すと、EurekaクライアントアプリケーションがEurekaサーバーに登録されていることがわかります。

今URLを打つ http://localhost:8080/ Webブラウザーで、RestEndpointの出力を確認します。

Zuul Serverは、すべてのリクエストを処理し、マイクロサービスアプリケーションの動的ルーティングを行うゲートウェイアプリケーションです。Zuulサーバーはエッジサーバーとも呼ばれます。

例えば、 /api/user はユーザーサービスにマップされ、/ api / productsは製品サービスにマップされ、Zuulサーバーはリクエストをそれぞれのバックエンドアプリケーションに動的にルーティングします。

この章では、SpringBootでZuulServerアプリケーションを作成する方法について詳しく説明します。

Zuulサーバーアプリケーションの作成

ZuulサーバーはSpringCloudの依存関係にバンドルされています。SpringBootプロジェクトはSpringInitializerページからダウンロードできます。https://start.spring.io/ Zuulサーバーの依存関係を選択します。

メインのSpringBootアプリケーションに@EnableZuulProxyアノテーションを追加します。@EnableZuulProxyアノテーションは、SpringBootアプリケーションをZuulプロキシサーバーとして機能させるために使用されます。

package com.tutorialspoint.zuulserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication
@EnableZuulProxy
public class ZuulserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(ZuulserverApplication.class, args);
   }
}

ビルド構成ファイルにSpringCloud StarterZuul依存関係を追加する必要があります。

Mavenユーザーは、次の依存関係をに追加する必要があります pom.xml ファイル-

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>

Gradleユーザーの場合、build.gradleファイルに以下の依存関係を追加します

compile('org.springframework.cloud:spring-cloud-starter-zuul')

Zuulルーティングの場合、application.propertiesファイルまたはapplication.ymlファイルに以下のプロパティを追加します。

spring.application.name = zuulserver
zuul.routes.products.path = /api/demo/**
zuul.routes.products.url = http://localhost:8080/
server.port = 8111

これは、httpが /api/demo/製品サービスに転送されます。例えば、/api/demo/products に転送されます /products

yamlファイルのユーザーは以下に示すapplication.ymlファイルを使用できます-

server:
   port: 8111
spring:
   application:  
      name: zuulserver
zuul:

routes:
   products:
      path: /api/demo/**
      url: http://localhost:8080/

Notehttp://localhost:8080/ Zuulプロキシ経由でルーティングする前に、アプリケーションがすでに実行されている必要があります。

完全なビルド構成ファイルを以下に示します。

Mavenユーザーは以下の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.tutorialspoint</groupId>
   <artifactId>zuulserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>zuulserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-zuul</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

Gradleユーザーは、以下のbuild.gradleファイルを使用できます-

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-zuul')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

実行可能なJARファイルを作成し、以下に示すMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、以下のコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下のコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次に、以下に示すコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

ここに示すように、アプリケーションがTomcatポート8111で開始されていることがわかります。

今、URLを打つ http://localhost:8111/api/demo/products あなたのウェブブラウザであなたはの出力を見ることができます /products 以下に示すRESTエンドポイント-

Spring Cloud Configuration Serverは、アプリケーションに関連するすべての構成プロパティを管理する一元化されたアプリケーションです。この章では、SpringCloud構成サーバーを作成する方法について詳しく学習します。

SpringCloud構成サーバーの作成

まず、SpringInitializerページからSpringBootプロジェクトをダウンロードし、Spring Cloud ConfigServerの依存関係を選択します。以下のスクリーンショットをご覧ください-

次に、以下で説明するように、ビルド構成ファイルにSpring CloudConfigサーバーの依存関係を追加します-

Mavenユーザーは、以下の依存関係をpom.xmlファイルに追加できます。

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-config-server</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに以下の依存関係を追加できます。

compile('org.springframework.cloud:spring-cloud-config-server')

次に、メインのSpringBootアプリケーションクラスファイルに@EnableConfigServerアノテーションを追加します。@EnableConfigServerアノテーションにより、SpringBootアプリケーションが構成サーバーとして機能します。

主なSpringBootアプリケーションクラスファイルを以下に示します-

package com.tutorialspoint.configserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer
public class ConfigserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(ConfigserverApplication.class, args);
   }
}

次に、以下の構成をプロパティファイルに追加し、application.propertiesファイルをbootstrap.propertiesファイルに置き換えます。以下のコードを確認してください-

server.port = 8888
spring.cloud.config.server.native.searchLocations=file:///C:/configprop/
SPRING_PROFILES_ACTIVE=native

構成サーバーはTomcatポート8888で実行され、アプリケーション構成プロパティはネイティブ検索場所からロードされます。

file:///C:/configprop/、クライアントアプリケーションを配置します--application.propertiesファイル。たとえば、クライアントアプリケーション名は次のとおりです。config-client、次にapplication.propertiesファイルの名前を次のように変更します config-client.properties プロパティファイルをパスに配置します file:///C:/configprop/

config-clientプロパティファイルのコードを以下に示します-

welcome.message = Welcome to Spring cloud config server

完全なビルド構成ファイルを以下に示します-

Mavenユーザーは使用できます 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.tutorialspoint</groupId>
   <artifactId>configserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>configserver</name>
   <description>Demo project for Spring Boot</description>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-config-server</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradleユーザーは、以下のbuild.gradleファイルを使用できます-

<scope>import</scope>
</dependency>
</dependencies>
buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('org.springframework.cloud:spring-cloud-config-server') testCompile('org.springframework.boot:spring-boot-starter-test') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

次に、実行可能JARファイルを作成し、次のMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行します-

Mavenの場合、以下のコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下のコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、アプリケーションは、ここに示すように、Tomcatポート8888で起動しました-

今URLを打つ http://localhost:8888/config-client/default/master Webブラウザーで、ここに示すようにconfig-clientアプリケーションの構成プロパティを確認できます。

一部のアプリケーションでは、変更が必要な構成プロパティが必要な場合があり、開発者はこれを実行するためにそれらを削除するか、アプリケーションを再起動する必要があります。ただし、これにより、本番環境でダウンタイムが発生し、アプリケーションを再起動する必要が生じる可能性があります。Spring Cloud Configuration Serverを使用すると、開発者はアプリケーションを再起動したり、ダウンタイムを発生させたりすることなく、新しい構成プロパティをロードできます。

SpringCloud構成サーバーの操作

まず、SpringBootプロジェクトをからダウンロードします https://start.spring.io/そして、Spring CloudConfigクライアントの依存関係を選択します。次に、ビルド構成ファイルにSpring Cloud StarterConfigの依存関係を追加します。

Mavenユーザーは、次の依存関係をpom.xmlファイルに追加できます。

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

Gradleユーザーは、次の依存関係をに追加できます build.gradle ファイル。

compile('org.springframework.cloud:spring-cloud-starter-config')

次に、@ RefreshScopeアノテーションをメインのSpringBootアプリケーションに追加する必要があります。@RefreshScopeアノテーションは、構成サーバーから構成プロパティ値をロードするために使用されます。

package com.example.configclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;

@SpringBootApplication
@RefreshScope
public class ConfigclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(ConfigclientApplication.class, args);
   }
}

次に、構成サーバーのURLをapplication.propertiesファイルに追加し、アプリケーション名を指定します。

Note −構成クライアントアプリケーションを起動する前に、http:// localhost:8888構成サーバーを実行する必要があります。

spring.application.name = config-client
spring.cloud.config.uri = http://localhost:8888

構成サーバーからウェルカムメッセージを読み取るための単純なRESTエンドポイントを作成するためのコードを以下に示します。

package com.example.configclient;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RefreshScope
@RestController
public class ConfigclientApplication {
   @Value("${welcome.message}")
   String welcomeText;
   
   public static void main(String[] args) {
      SpringApplication.run(ConfigclientApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String welcomeText() {
      return welcomeText;
   }
}

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、以下に示すコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下に示すコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次に、次のコマンドを使用してJARファイルを実行します。

java –jar <JARFILE>

これで、アプリケーションは、ここに示すように、Tomcatポート8080で起動しました-

ログインコンソールウィンドウを見ることができます。config-clientアプリケーションはから構成をフェッチしていますhttps://localhost:8888

2017-12-08 12:41:57.682  INFO 1104 --- [           
   main] c.c.c.ConfigServicePropertySourceLocator : 
   Fetching config from server at: http://localhost:8888

今すぐURLを押してください http://localhost:8080/ ウェルカムメッセージは構成サーバーからロードされます。

次に、構成サーバーのプロパティ値を変更して、アクチュエーターのエンドポイントPOSTURLを押します。 http://localhost:8080/refresh URLの新しい構成プロパティ値を確認してください http://localhost:8080/

Spring Boot Actuatorは、SpringBootアプリケーションを監視および管理するための安全なエンドポイントを提供します。デフォルトでは、すべてのアクチュエータエンドポイントが保護されています。この章では、アプリケーションでSpringBootアクチュエーターを有効にする方法について詳しく学習します。

Spring BootActuatorの有効化

SpringBootアクチュエーターエンドポイントをSpringBootアプリケーションで有効にするには、ビルド構成ファイルにSpring BootStarterアクチュエーターの依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに以下の依存関係を追加できます。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに以下の依存関係を追加できます。

compile group: 'org.springframework.boot', name: 'spring-boot-starter-actuator'

application.propertiesファイルで、アクチュエータエンドポイントのセキュリティを無効にする必要があります。

management.security.enabled = false

YAMLファイルのユーザーは、application.ymlファイルに次のプロパティを追加できます。

management:
   security:
      enabled: false

Springブートアクチュエーターエンドポイントへのアクセスに別のポート番号を使用する場合は、application.propertiesファイルに管理ポート番号を追加します。

management.port = 9000

YAMLファイルのユーザーは、application.ymlファイルに次のプロパティを追加できます。

management:
   port: 9000

これで、実行可能なJARファイルを作成し、次のMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、次のコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

これで、次のコマンドを使用してJARファイルを実行できます-

java –jar <JARFILE>

これで、アプリケーションはTomcatポート8080で起動しました。管理ポート番号を指定した場合、同じアプリケーションが2つの異なるポート番号で実行されていることに注意してください。

いくつかの重要なSpringBootActuatorエンドポイントを以下に示します。それらをWebブラウザーに入力して、アプリケーションの動作を監視できます。

エンドポイント 使用法
/ metrics 使用メモリ、空きメモリ、スレッド、クラス、システム稼働時間などのアプリケーションメトリックを表示します。
/ env アプリケーションで使用される環境変数のリストを表示します。
/豆 Spring Beanとそのタイプ、スコープ、および依存関係を表示します。
/健康 アプリケーションの状態を表示するには
/ info SpringBootアプリケーションに関する情報を表示します。
/痕跡 Restエンドポイントのトレースのリストを表示します。

Spring Boot ActuatorEndpointを使用してアプリケーションを監視することは少し難しいです。'n'個のアプリケーションがある場合、すべてのアプリケーションに個別のアクチュエータエンドポイントがあり、監視が困難になるためです。Spring Boot Admin Serverは、マイクロサービスアプリケーションを管理および監視するために使用されるアプリケーションです。

このような状況に対処するために、CodeCentricTeamはSpringBoot管理UIを提供して、すべてのSpringBootアプリケーションアクチュエータエンドポイントを1か所で管理および監視します。

Spring Boot管理サーバーをビルドするには、ビルド構成ファイルに以下の依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに以下の依存関係を追加できます-

<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-server</artifactId>
   <version>1.5.5</version>
</dependency>
<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-server-ui</artifactId>
   <version>1.5.5</version>
</dependency>

Gradleユーザーは、build.gradleファイルに以下の依存関係を追加できます-

compile group: 'de.codecentric', name: 'spring-boot-admin-server', version: '1.5.5'
compile group: 'de.codecentric', name: 'spring-boot-admin-server-ui', version: '1.5.5'

メインのSpringBootアプリケーションクラスファイルに@EnableAdminServerアノテーションを追加します。@EnableAdminServerアノテーションは、管理サーバーとして他のすべてのマイクロサービスを監視するために使用されます。

package com.tutorialspoint.adminserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import de.codecentric.boot.admin.config.EnableAdminServer;

@SpringBootApplication
@EnableAdminServer
public class AdminserverApplication {   
   public static void main(String[] args) {
      SpringApplication.run(AdminserverApplication.class, args);
   }
}

次に、以下に示すapplication.propertiesファイルでserver.portとアプリケーション名を定義します。

server.port = 9090
spring.application.name = adminserver

YAMLユーザーの場合、次のプロパティを使用して、application.ymlファイルでポート番号とアプリケーション名を定義します。

server:
   port: 9090
spring:
   application:
      name: adminserver

ビルド構成ファイルを以下に示します。

For Maven users – 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.tutorialspoint</groupId>
   <artifactId>adminserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>adminserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>

      <dependency>
         <groupId>de.codecentric</groupId>
         <artifactId>spring-boot-admin-server</artifactId>
         <version>1.5.5</version>
      </dependency>
      
      <dependency>
         <groupId>de.codecentric</groupId>
         <artifactId>spring-boot-admin-server-ui</artifactId>
         <version>1.5.5</version>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

For Gradle users – build.gradle file

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
repositories {   
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'de.codecentric', name: 'spring-boot-admin-server', version: '1.5.5'
   compile group: 'de.codecentric', name: 'spring-boot-admin-server-ui', version: '1.5.5'   
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、ここに示すコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、ここに示すコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次に、以下のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、アプリケーションは、ここに示すように、Tomcatポート9090で起動しました-

次に、Webブラウザから以下のURLにアクセスして、管理サーバーのUIを確認します。

http://localhost:9090/

Spring Boot Admin Serverを介してマイクロサービスアプリケーションを監視および管理するには、Spring Boot Adminスタータークライアントの依存関係を追加し、Admin ServerURIをアプリケーションプロパティファイルに指定する必要があります。

Note −アプリケーションを監視するには、マイクロサービスアプリケーションのSpring Boot ActuatorEndpointsを有効にする必要があります。

まず、ビルド構成ファイルに次のSpring BootAdminスタータークライアント依存関係とSpringBootスターターアクチュエーター依存関係を追加します。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます-

<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-starter-client</artifactId>
   <version>1.5.5</version>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile group: 'de.codecentric', name: 'spring-boot-admin-starter-client', version: '1.5.5'
compile('org.springframework.boot:spring-boot-starter-actuator')

次に、SpringBoot管理サーバーのURLをアプリケーションのプロパティファイルに追加します。

プロパティファイルのユーザーの場合、application.propertiesファイルに次のプロパティを追加します。

spring.boot.admin.url = http://localhost:9090/

YAMLユーザーの場合、application.ymlファイルに次のプロパティを追加します。

spring:
   boot:
      admin:
         url: http://localhost:9000/

次に、実行可能JARファイルを作成し、次のMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行します。

Mavenの場合、次のようにコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のようにコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次に、示されているコマンドを使用してJARファイルを実行します。

java –jar <JARFILE>

これで、アプリケーションは次のようにTomcatポート9090で起動しました-

次に、Webブラウザーから次のURLを押して、SpringBootアプリケーションがSpringBoot管理サーバーに登録されていることを確認します。

http://localhost:9090/

次に、をクリックします Details ボタンをクリックして、管理サーバーUIでアクチュエータのエンドポイントを確認します。

Swagger2は、RESTfulWebサービスのRESTAPIドキュメントを生成するために使用されるオープンソースプロジェクトです。Webブラウザを介してRESTfulWebサービスにアクセスするためのユーザーインターフェイスを提供します。

Spring BootアプリケーションでSwagger2を有効にするには、ビルド構成ファイルに次の依存関係を追加する必要があります。

<dependency>
   <groupId>io.springfox</groupId>
   <artifactId>springfox-swagger2</artifactId>
   <version>2.7.0</version>
</dependency>
<dependency>
   <groupId>io.springfox</groupId>
   <artifactId>springfox-swagger-ui</artifactId>
   <version>2.7.0</version>
</dependency>

Gradleユーザーの場合、build.gradleファイルに次の依存関係を追加します。

compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'

次に、メインのSpringBootアプリケーションに@ EnableSwagger2アノテーションを追加します。@ EnableSwagger2アノテーションは、SpringBootアプリケーションでSwagger2を有効にするために使用されます。

メインのSpringBootアプリケーションのコードを以下に示します-

package com.tutorialspoint.swaggerdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
@EnableSwagger2
public class SwaggerDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SwaggerDemoApplication.class, args);
   }
}

次に、Docket Beanを作成して、SpringBootアプリケーション用にSwagger2を構成します。Swagger2のRESTAPIを構成するには、基本パッケージを定義する必要があります。

@Bean
   public Docket productApi() {
      return new Docket(DocumentationType.SWAGGER_2).select()
         .apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
   }

ここで、このBeanをメインのSpring Bootアプリケーションクラスファイル自体に追加すると、メインのSpringBootアプリケーションクラスは次のようになります。

package com.tutorialspoint.swaggerdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
@EnableSwagger2
public class SwaggerDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SwaggerDemoApplication.class, args);
   }
   @Bean
   public Docket productApi() {
      return new Docket(DocumentationType.SWAGGER_2).select()
         .apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
   }
}

次に、ビルド構成ファイルに以下のSpring Boot Starter Web依存関係を追加して、以下に示すようにRESTエンドポイントを記述します。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます-

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます-

compile('org.springframework.boot:spring-boot-starter-web')

ここで、RESTコントローラーファイルに2つの単純なRESTfulWebサービスGETとPOSTを構築するコードを示します。

package com.tutorialspoint.swaggerdemo;

import java.util.ArrayList;
import java.util.List;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SwaggerAPIController {
   @RequestMapping(value = "/products", method = RequestMethod.GET)
   public List<String> getProducts() {
      List<String> productsList = new ArrayList<>();
      productsList.add("Honey");
      productsList.add("Almond");
      return productsList;
   }
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public String createProduct() {
      return "Product is saved successfully";
   }
}

完全なビルド構成ファイルを以下に示します-

Maven – 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.tutorialspoint</groupId>
   <artifactId>swagger-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>swagger-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger2</artifactId>
         <version>2.7.0</version>
      </dependency>

      <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger-ui</artifactId>
         <version>2.7.0</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
} dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
   compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'
}

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、ここに示すコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のようにコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで、ここに示すコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、アプリケーションは次のようにTomcatポート8080で起動します-

次に、WebブラウザーでURLを押して、SwaggerAPIの機能を確認します。

http://localhost:8080/swagger-ui.html

Dockerは、ビルドとデプロイを容易にするコンテナー管理サービスです。Dockerの初心者の方は、このリンクで詳細を確認できます-https://www.tutorialspoint.com/docker/index.htm

この章では、SpringBootアプリケーションにMavenとGradleの依存関係を使用してDockerイメージを作成する方法を説明します。

Dockerfileを作成する

まず、名前のファイルを作成します Dockerfile ディレクトリの下 src/main/docker以下の内容で。このファイルは、Dockerイメージを作成するために重要であることに注意してください。

FROM java:8
VOLUME /tmp
ADD dockerapp-0.0.1-SNAPSHOT.jar app.jar
RUN bash -c 'touch /app.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

Maven

Mavenの場合、DockerMavenプラグインをビルド構成ファイルに追加します pom.xml

<properties>
   <docker.image.prefix>spring-boot-tutorialspoint</docker.image.prefix>
</properties>

<build>
   <plugins>
      <plugin>
         <groupId>com.spotify</groupId>
         <artifactId>docker-maven-plugin</artifactId>
         <version>1.0.0</version>
         
         <configuration>
            <imageName>${docker.image.prefix}/${project.artifactId}</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <directory>${project.build.directory}</directory>
                  <include>${project.build.finalName}.jar</include>
               </resource>
            </resources>
         </configuration>
      </plugin>
      
      <plugin>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
   </plugins>
   
</build>

完全な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.tutorialspoint</groupId>
   <artifactId>dockerapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>dockerapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <docker.image.prefix>spring-boot-tutorialspoint</docker.image.prefix>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>1.0.0</version>
            
            <configuration>
               <imageName>${docker.image.prefix}/${project.artifactId}</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <directory>${project.build.directory}</directory>
                     <include>${project.build.finalName}.jar</include>
                  </resource>
               </resources>
            </configuration>
         </plugin>
         
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

これで、Mavenコマンドを使用してアプリケーションを実行できます mvn package docker:build

Note −でExposeデーモンを有効にします tcp://localhost:2375 TLSなし。

ビルドが成功すると、以下に示すようにコンソールに出力が表示されます。

ここで、docker imagesを使用してコマンドでDockerイメージを表示し、コンソールでイメージ情報を表示します。

Gradle

Gradleビルド構成を使用してDockerイメージをビルドするには、を追加する必要があります docker プラグインとタスクを書く必要があります buildDocker Dockerイメージを作成します。

GradleDocker構成のコードを以下に示します。

buildscript {
   .....
   dependencies {
      .....
      classpath('se.transmode.gradle:gradle-docker:1.2')
   }
}

group = 'spring-boot-tutorialspoint'

.....
apply plugin: 'docker'

task buildDocker(type: Docker, dependsOn: build) {
   applicationName = jar.baseName
   dockerfile = file('src/main/docker/Dockerfile')
   doFirst {
      copy {
         from jar
         into stageDir
      }
   }
}

完全なbuild.gradleファイルを以下に示します。

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
      classpath('se.transmode.gradle:gradle-docker:1.2')
   }
}

group = 'spring-boot-tutorialspoint'

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'docker'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
task buildDocker(type: Docker, dependsOn: build) {
   applicationName = jar.baseName
   dockerfile = file('src/main/docker/Dockerfile')
   doFirst {
      copy {
         from jar
         into stageDir
      }
   }
}

次に、以下に示すコマンドを使用してDockerイメージを作成します-

gradle build buildDocker

コマンドを実行すると、コンソールウィンドウにBUILDSUCCESSFULログが表示されます。

ここで、を使用したコマンドでDockerイメージを表示します。 docker images コンソールで画像の情報を確認します。

ほとんどの開発者は、問題が発生した場合にログを追跡するのが困難になります。これは、Spring CloudSleuthおよびSpringBootアプリケーション用のZipKinサーバーによって解決できます。

Spring Cloud Sleuth

Spring cloudSleuthログは次の形式で印刷されます-

[application-name,traceid,spanid,zipkin-export]

どこ、

  • アプリケーション名=アプリケーションの名前

  • Traceid =同じサービスまたは1つのサービスを別のサービスに呼び出す場合、各要求と応答のtraceidは同じです。

  • Spanid = SpanIdはTraceIdと一緒に印刷されます。スパンIDは、あるサービスを別のサービスに呼び出す要求と応答ごとに異なります。

  • Zipkin-export =デフォルトではfalseです。trueの場合、ログはZipkinサーバーにエクスポートされます。

ここで、次のようにビルド構成ファイルにSpring Cloud StarterSleuth依存関係を追加します-

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます-

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます-

compile('org.springframework.cloud:spring-cloud-starter-sleuth')

次に、次に示すように、ログをSpringBootアプリケーションのRestControllerクラスファイルに追加します。

package com.tutorialspoint.sleuthapp;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SleuthappApplication {
   private static final Logger LOG = Logger.getLogger(SleuthappApplication.class.getName());
   public static void main(String[] args) {
      SpringApplication.run(SleuthappApplication.class, args);
   }
   @RequestMapping("/")
   public String index() {
      LOG.log(Level.INFO, "Index API is calling");
      return "Welcome Sleuth!";
   }
}

次に、図のようにapplication.propertiesファイルにアプリケーション名を追加します-

spring.application.name = tracinglogs

ビルド構成ファイルの完全なコードを以下に示します-

Maven – 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.tutorialspoint</groupId>
   <artifactId>sleuthapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>sleuthapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-sleuth</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-sleuth')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、次のコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで、ここに示すコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、アプリケーションはTomcatポート8080で起動しました。

次に、WebブラウザでURLを押して、コンソールログの出力を確認します。

http://localhost:8080/

コンソールウィンドウに次のログが表示されます。ログが次の形式で出力されることを確認します[application-name、traceid、spanid、zipkin-export]

Zipkinサーバー

Zipkinは、SpringBootアプリケーションのSpringCloudSleuthログを監視および管理するアプリケーションです。Zipkinサーバーをビルドするには、ビルド構成ファイルにZipkinUIとZipkinサーバーの依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます-

<dependency>
   <groupId>io.zipkin.java</groupId>
   <artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
   <groupId>io.zipkin.java</groupId>
   <artifactId>zipkin-autoconfigure-ui</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに以下の依存関係を追加できます-

compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')

次に、アプリケーションプロパティファイルでserver.port = 9411を構成します。

プロパティファイルのユーザーの場合、application.propertiesファイルに以下のプロパティを追加します。

server.port = 9411

YAMLユーザーの場合、application.ymlファイルに以下のプロパティを追加します。

server:
   port: 9411

メインのSpringBootアプリケーションクラスファイルに@EnableZipkinServerアノテーションを追加します。@EnableZipkinServerアノテーションは、アプリケーションがZipkinサーバーとして機能できるようにするために使用されます。

package com.tutorialspoint.zipkinapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin.server.EnableZipkinServer;

@SpringBootApplication
@EnableZipkinServer
public class ZipkinappApplication {
   public static void main(String[] args) {
      SpringApplication.run(ZipkinappApplication.class, args);
   }
}

完全なビルド構成ファイルのコードを以下に示します。

Maven – 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.tutorialspoint</groupId>
   <artifactId>zipkinapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>zipkinapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>io.zipkin.java</groupId>
         <artifactId>zipkin-server</artifactId>
      </dependency>
      <dependency>
         <groupId>io.zipkin.java</groupId>
         <artifactId>zipkin-autoconfigure-ui</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('io.zipkin.java:zipkin-autoconfigure-ui') compile('io.zipkin.java:zipkin-server') testCompile('org.springframework.boot:spring-boot-starter-test') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

以下のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、以下のコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、以下のコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

示されているコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、以下に示すように、アプリケーションがTomcatポート9411で起動しました。

次に、以下のURLを押して、ZipkinサーバーのUIを確認します。

http://localhost:9411/zipkin/

次に、クライアントサービスアプリケーションに次の依存関係を追加し、ZipkinサーバーのURLを指定して、ZipkinUIを介してマイクロサービスログをトレースします。

次に、図のように、ビルド構成ファイルにSpring Cloud StarterZipkin依存関係を追加します-

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます-

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに以下の依存関係を追加できます-

compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')

ここで、 Always Sampler Bean Spring Bootアプリケーションで、ログをZipkinサーバーにエクスポートします。

@Bean
public AlwaysSampler defaultSampler() {
   return new AlwaysSampler();
}

AlwaysSampler Beanを追加すると、Spring Sleuth ZipkinExportオプションが自動的にfalseからtrueに変更されます。

次に、クライアントサービスのapplication.propertiesファイルでZipkinサーバーのベースURLを構成します。

spring.zipkin.baseUrl = http://localhost:9411/zipkin/

次に、トレースIDを指定し、ZipkinUIでトレースを見つけます。

http://localhost:9411/zipkin/traces/{traceid}/

Flywayは、すべてのインスタンスにわたってデータベーススキーマを簡単かつ確実に進化させるためのバージョン管理アプリケーションです。Flywayの詳細については、リンクを使用できます-www.flywaydb.org

多くのソフトウェアプロジェクトはリレーショナルデータベースを使用しています。これには、データベース移行(スキーマ移行とも呼ばれる)の処理が必要です。

この章では、SpringBootアプリケーションでFlywayデータベースを構成する方法について詳しく学習します。

Flywayデータベースの構成

まず、SpringInitializerページwww.start.spring.ioからSpringBootプロジェクトをダウンロードし、次の依存関係を選択します-

  • Spring Boot Starter Web
  • Flyway
  • MySQL
  • JDBC

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます。

<dependency>
   <groupId>org.flywaydb</groupId>
   <artifactId>flyway-core</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile('org.flywaydb:flyway-core')
compile('org.springframework.boot:spring-boot-starter-jdbc')
compile('org.springframework.boot:spring-boot-starter-web')
compile('mysql:mysql-connector-java')

アプリケーションプロパティでは、データソースを作成するためのデータベースプロパティと、アプリケーションプロパティで構成する必要のあるフライウェイプロパティを構成する必要があります。

プロパティファイルのユーザーの場合、application.propertiesファイルに以下のプロパティを追加します。

spring.application.name = flywayapp  

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000

flyway.url = jdbc:mysql://localhost:3306/mysql
flyway.schemas = USERSERVICE
flyway.user = root
flyway.password = root

YAMLユーザーは、application.ymlファイルに次のプロパティを追加できます。

spring:
   application:
      name: flywayapp  
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000
flyway:
   url: jdbc:mysql://localhost:3306/mysql
   schemas: USERSERVICE
   user: "root"
   password: "root"

次に、下にSQLファイルを作成します。 src/main/resources/db/migrationディレクトリ。SQLファイルに「V1__Initial.sql」という名前を付けます

CREATE TABLE USERS (ID INT AUTO_INCREMENT PRIMARY KEY, USERID VARCHAR(45));
INSERT INTO USERS (ID, USERID) VALUES (1, 'tutorialspoint.com');

主なSpringBootアプリケーションクラスファイルコードを以下に示します-

package com.tutorialspoint.flywayapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class FlywayappApplication {
   public static void main(String[] args) {
      SpringApplication.run(FlywayappApplication.class, args);
   }
}

完全なビルド構成ファイルを以下に示します。

Maven – 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.tutorialspoint</groupId>
   <artifactId>flywayapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>flywayapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.flywaydb</groupId>
         <artifactId>flyway-core</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.flywaydb:flyway-core')
   compile('org.springframework.boot:spring-boot-starter-jdbc')
   compile('org.springframework.boot:spring-boot-starter-web')
   compile('mysql:mysql-connector-java')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

実行可能なJARファイルを作成し、以下に示すMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、ここに示すコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、ここに示すコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで、次のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、Tomcatはポート8080で起動し、コンソールウィンドウに、次のようにフライウェイデータベースのログが表示されます。

これで、データベースに移動して、selectクエリを実行できます。

Spring Boot RESTful Webサービスを使用すると、Gmailトランスポート層セキュリティを使用してメールを送信できます。この章では、この機能の使用方法について詳しく理解しましょう。

まず、ビルド構成ファイルにSpring Boot StarterMailの依存関係を追加する必要があります。

Mavenユーザーは、次の依存関係をpom.xmlファイルに追加できます。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile('org.springframework.boot:spring-boot-starter-mail')

メインのSpringBootアプリケーションクラスファイルのコードを以下に示します-

package com.tutorialspoint.emailapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class EmailappApplication {
   public static void main(String[] args) {
      SpringApplication.run(EmailappApplication.class, args);
   }
}

図のように、RestControllerクラスファイルで電子メールに送信する簡単なRestAPIを作成できます。

package com.tutorialspoint.emailapp;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EmailController {
   @RequestMapping(value = "/sendemail")
   public String sendEmail() {
      return "Email sent successfully";
   }   
}

添付ファイル付きのメールを送信するメソッドを作成できます。mail.smtpプロパティを定義し、PasswordAuthenticationを使用します。

private void sendmail() throws AddressException, MessagingException, IOException {
   Properties props = new Properties();
   props.put("mail.smtp.auth", "true");
   props.put("mail.smtp.starttls.enable", "true");
   props.put("mail.smtp.host", "smtp.gmail.com");
   props.put("mail.smtp.port", "587");
   
   Session session = Session.getInstance(props, new javax.mail.Authenticator() {
      protected PasswordAuthentication getPasswordAuthentication() {
         return new PasswordAuthentication("[email protected]", "<your password>");
      }
   });
   Message msg = new MimeMessage(session);
   msg.setFrom(new InternetAddress("[email protected]", false));

   msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse("[email protected]"));
   msg.setSubject("Tutorials point email");
   msg.setContent("Tutorials point email", "text/html");
   msg.setSentDate(new Date());

   MimeBodyPart messageBodyPart = new MimeBodyPart();
   messageBodyPart.setContent("Tutorials point email", "text/html");

   Multipart multipart = new MimeMultipart();
   multipart.addBodyPart(messageBodyPart);
   MimeBodyPart attachPart = new MimeBodyPart();

   attachPart.attachFile("/var/tmp/image19.png");
   multipart.addBodyPart(attachPart);
   msg.setContent(multipart);
   Transport.send(msg);   
}

次に、次に示すように、Rest APIから上記のsendmail()メソッドを呼び出します-

@RequestMapping(value = "/sendemail")
public String sendEmail() throws AddressException, MessagingException, IOException {
   sendmail();
   return "Email sent successfully";   
}

Note −メールを送信する前に、Gmailアカウント設定で安全性の低いアプリを許可するようにオンにしてください。

完全なビルド構成ファイルを以下に示します。

Maven – 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.tutorialspoint</groupId>
   <artifactId>emailapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>emailapp</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
   <java.version>1.8</java.version>
   </properties>
   
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-mail</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build> 
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile('org.springframework.boot:spring-boot-starter-mail')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

これで、実行可能なJARファイルを作成し、以下に示すMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、次のようにコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のようにコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次に、以下のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

アプリケーションがTomcatポート8080で開始されていることがわかります。

Webブラウザから次のURLを押すと、メールが届きます。

http://localhost:8080/sendemail

HystrixはNetflixのライブラリです。Hystrixは、サービス間のアクセスポイントを分離し、サービス間のカスケード障害を停止し、フォールバックオプションを提供します。

たとえば、サードパーティのアプリケーションを呼び出す場合、応答の送信に時間がかかります。そのため、その時点で、コントロールはフォールバックメソッドに移動し、アプリケーションにカスタム応答を返します。

この章では、SpringBootアプリケーションにHystrixを実装する方法を説明します。

まず、ビルド構成ファイルにSpring Cloud StarterHystrixの依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます-

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます-

compile('org.springframework.cloud:spring-cloud-starter-hystrix')

次に、@ EnableHystrixアノテーションをメインのSpringBootアプリケーションクラスファイルに追加します。@EnableHystrixアノテーションは、SpringBootアプリケーションでHystrix機能を有効にするために使用されます。

主なSpringBootアプリケーションクラスファイルコードを以下に示します-

package com.tutorialspoint.hystrixapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;

@SpringBootApplication
@EnableHystrix
public class HystrixappApplication {
   public static void main(String[] args) {
      SpringApplication.run(HystrixappApplication.class, args);
   }
}

次に、要求された時刻から3秒後に文字列を返すように単純なRESTコントローラーを記述します。

@RequestMapping(value = "/")
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}

ここで、Rest APIに@Hystrixコマンドと@HystrixPropertyを追加し、タイムアウトをミリ秒単位で定義します。

@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})

次に、リクエストの応答に時間がかかる場合は、フォールバックメソッドfallback_hello()を定義します。

private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

RESTAPIとHystrixプロパティを含む完全なRestControllerクラスファイルを次に示します-

@RequestMapping(value = "/")
@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}
private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

この例では、メインのSpringBootアプリケーションクラスファイル自体に記述されたRESTAPIです。

package com.tutorialspoint.hystrixapp;

import org.springframework.boot.SpringApplication;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;

@SpringBootApplication
@EnableHystrix
@RestController
public class HystrixappApplication {
   public static void main(String[] args) {
      SpringApplication.run(HystrixappApplication.class, args);
   }
   @RequestMapping(value = "/")
   @HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
      @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
   })
   public String hello() throws InterruptedException {
      Thread.sleep(3000);
      return "Welcome Hystrix";
   }
   private String fallback_hello() {
      return "Request fails. It takes long time to response";
   }
}

完全なビルド構成ファイルを以下に示します。

Maven – pom.xml file

<?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.tutorialspoint</groupId>
   <artifactId>hystrixapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>hystrixapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-hystrix</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-hystrix')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、次のようにコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のようにコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次に、以下のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これにより、以下に示すように、Tomcatポート8080でアプリケーションが起動します。

今、URLを打つ http://localhost:8080/Webブラウザーから、Hystrixの応答を確認します。APIの応答には3秒かかりますが、Hystrixのタイムアウトは1秒です。

この章では、WebソケットでSpringBootを使用してインタラクティブなWebアプリケーションを構築する方法を理解しましょう。

Spring BootでWebソケットを使用してインタラクティブなWebアプリケーションを構築するには、次の依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加する必要があります。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>webjars-locator</artifactId>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>sockjs-client</artifactId>
   <version>1.0.2</version>
</dependency>

<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>stomp-websocket</artifactId>
   <version>2.3.3</version>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>bootstrap</artifactId>
   <version>3.3.7</version>        </dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>jquery</artifactId>
   <version>3.1.0</version>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます-

compile("org.springframework.boot:spring-boot-starter-websocket")
compile("org.webjars:webjars-locator")
compile("org.webjars:sockjs-client:1.0.2")
compile("org.webjars:stomp-websocket:2.3.3")
compile("org.webjars:bootstrap:3.3.7")
compile("org.webjars:jquery:3.1.0")

STOMPメッセージングを操作するメッセージ処理コントローラーを作成しましょう。STOMPメッセージは、@ Controllerクラスファイルにルーティングできます。たとえば、GreetingControllerは、宛先「/ hello」へのメッセージを処理するようにマップされます。

package com.tutorialspoint.websocketapp;

import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;

@Controller
public class GreetingController {
   @MessageMapping("/hello")
   @SendTo("/topic/greetings")
   public Greeting greeting(HelloMessage message) throws Exception {
      Thread.sleep(1000); // simulated delay
      return new Greeting("Hello, " + message.getName() + "!");
   }
}

次に、STOMPメッセージング用にSpringを構成します。以下に示すように、AbstractWebSocketMessageBrokerConfigurerクラスを拡張するWebSocketConfigクラスファイルを記述します。

package com.tutorialspoint.websocketapp;

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
   @Override
   public void configureMessageBroker(MessageBrokerRegistry config) {
      config.enableSimpleBroker("/topic");
      config.setApplicationDestinationPrefixes("/app");
   }
   @Override
   public void registerStompEndpoints(StompEndpointRegistry registry) {
      registry.addEndpoint("/tutorialspoint-websocket").withSockJS();
   }
}

@EnableWebSocketMessageBrokerアノテーションは、STOMPエンドポイントを作成するようにWebソケットメッセージブローカーを構成するために使用されます。

図のように、src / main / resources / static /index.htmlの下にブラウザクライアントファイルを作成できます。

<!DOCTYPE html>
<html>
   <head>
      <title>Hello WebSocket</title>
      <link href = "/webjars/bootstrap/css/bootstrap.min.css" rel = "stylesheet">
      <link href = "/main.css" rel = "stylesheet">
      <script src = "/webjars/jquery/jquery.min.js"></script>
      <script src = "/webjars/sockjs-client/sockjs.min.js"></script>
      <script src = "/webjars/stomp-websocket/stomp.min.js"></script>
      <script src = "/app.js"></script>
   </head>
   
   <body>
      <noscript>
         <h2 style = "color: #ff0000">
            Seems your browser doesn't support Javascript! Websocket relies on Javascript being
            enabled. Please enable Javascript and reload this page!
         </h2>
      </noscript>
      <div id = "main-content" class = "container">
         <div class = "row">
            <div class = "col-md-6">
               <form class = "form-inline">
                  <div class = "form-group">
                     <label for = "connect">WebSocket connection:</label>
                     <button id = "connect" class = "btn btn-default" type = "submit">Connect</button>
                     <button id = "disconnect" class = "btn btn-default" type = "submit" disabled = "disabled">Disconnect
                     </button>
                  </div>
               </form>
            </div>
            
            <div class = "col-md-6">
               <form class = "form-inline">
                  <div class = "form-group">
                     <label for = "name">What is your name?</label>
                     <input type = "text" id = "name" class = "form-control" placeholder = "Your name here...">
                  </div>
                  <button id = "send" class = "btn btn-default" type = "submit">Send</button>
               </form>
            </div>
         </div>
         
         <div class  =  "row">
            <div class  =  "col-md-12">
               <table id  =  "conversation" class = "table table-striped">
                  <thead>
                     <tr>
                        <th>Greetings</th>
                     </tr>
                  </thead>
                  <tbody id  =  "greetings"></tbody>
               </table>
            </div>
         </div>
      </div>
   </body>
</html>

STOMPを使用してメッセージを消費および生成するためのapp.jsファイルを作成しましょう。

var stompClient = null;

function setConnected(connected) {
   $("#connect").prop("disabled", connected);
   $("#disconnect").prop("disabled", !connected); if (connected) { $("#conversation").show();
   } else {
      $("#conversation").hide(); } $("#greetings").html("");
}

function connect() {
   var socket = new SockJS('/tutorialspoint-websocket');
   stompClient = Stomp.over(socket);
   stompClient.connect({}, function (frame) {
      setConnected(true);
      console.log('Connected: ' + frame);
      stompClient.subscribe('/topic/greetings', function (greeting) {
         showGreeting(JSON.parse(greeting.body).content);
      });
   });
}
function disconnect() {
   if (stompClient !== null) {
      stompClient.disconnect();
   }
   setConnected(false);
   console.log("Disconnected");
}
function sendName() {
   stompClient.send("/app/hello", {}, JSON.stringify({'name': $("#name").val()})); } function showGreeting(message) { $("#greetings").append("<tr><td>" + message + "</td></tr>");
}
$(function () { $( "form" ).on('submit', function (e) {e.preventDefault();});
   $( "#connect" ).click(function() { connect(); }); $( "#disconnect" ).click(function() { disconnect(); });
   $( "#send" ).click(function() { sendName(); });
});

メインのSpringBootアプリケーションのコードを以下に示します。

package com.tutorialspoint.websocketapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class WebsocketappApplication {
   public static void main(String[] args) {
      SpringApplication.run(WebsocketappApplication.class, args);
   }  
}

完全なビルド構成ファイルを以下に示します。

Maven – 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.tutorialspoint</groupId>
   <artifactId>websocketapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websocketapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
   </parent>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-websocket</artifactId>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>webjars-locator</artifactId>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>sockjs-client</artifactId>
         <version>1.0.2</version>
      </dependency>
      
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>stomp-websocket</artifactId>
         <version>2.3.3</version>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>bootstrap</artifactId>
         <version>3.3.7</version>
      </dependency>
      
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>jquery</artifactId>
         <version>3.1.0</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <properties>
      <java.version>1.8</java.version>
   </properties>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:1.5.9.RELEASE")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

jar {
   baseName = 'websocketapp'
   version =  '0.1.0'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile("org.springframework.boot:spring-boot-starter-websocket")
   compile("org.webjars:webjars-locator")
   compile("org.webjars:sockjs-client:1.0.2")
   compile("org.webjars:stomp-websocket:2.3.3")
   compile("org.webjars:bootstrap:3.3.7")
   compile("org.webjars:jquery:3.1.0")

   testCompile("org.springframework.boot:spring-boot-starter-test")
}

以下に示すように、実行可能なJARファイルを作成し、MavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、以下のコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のようにコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで指定されたコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、示されているように、アプリケーションがTomcatポート8080で開始されました。

今、URLを打つ http://localhost:8080/ WebブラウザでWebソケットに接続し、挨拶を送信してメッセージを受信します。

バッチサービスは、1つのタスクで複数のコマンドを実行するプロセスです。この章では、SpringBootアプリケーションでバッチサービスを作成する方法を学習します。

CSVファイルのコンテンツをHSQLDBに保存する例を考えてみましょう。

バッチサービスプログラムを作成するには、ビルド構成ファイルにSpring Boot StarterBatch依存関係とHSQLDB依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-batch</artifactId>
</dependency>
<dependency>
   <groupId>org.hsqldb</groupId>
   <artifactId>hsqldb</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile("org.springframework.boot:spring-boot-starter-batch")
compile("org.hsqldb:hsqldb")

次に、クラスパスリソースの下に単純なCSVデータファイル(src / main / resources)を追加し、図のようにファイルにfile.csvという名前を付けます。

William,John
Mike, Sebastian
Lawarance, Lime

次に、HSQLDBのSQLスクリプトをクラスパスリソースディレクトリの下に記述します。 request_fail_hystrix_timeout

DROP TABLE USERS IF EXISTS;
CREATE TABLE USERS  (
   user_id BIGINT IDENTITY NOT NULL PRIMARY KEY,
   first_name VARCHAR(20),
   last_name VARCHAR(20)
);

図のように、USERSモデルのPOJOクラスを作成します-

package com.tutorialspoint.batchservicedemo;
public class User {
   private String lastName;
   private String firstName;

   public User() {
   }
   public User(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }
   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }
   public String getFirstName() {
      return firstName;
   }
   public String getLastName() {
      return lastName;
   }
   public void setLastName(String lastName) {
      this.lastName = lastName;
   }

   @Override
   public String toString() {
      return "firstName: " + firstName + ", lastName: " + lastName;
   }   
}

ここで、CSVファイルからデータを読み取った後、データをSQLに書き込む前に、操作を実行する中間プロセッサを作成します。

package com.tutorialspoint.batchservicedemo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.item.ItemProcessor;

public class UserItemProcessor implements ItemProcessor<User, User> {
   private static final Logger log = LoggerFactory.getLogger(UserItemProcessor.class);

   @Override
   public User process(final User user) throws Exception {
      final String firstName = user.getFirstName().toUpperCase();
      final String lastName = user.getLastName().toUpperCase();
      final User transformedPerson = new User(firstName, lastName);

      log.info("Converting (" + user + ") into (" + transformedPerson + ")");
      return transformedPerson;
   }
}

以下に示すように、CSVからデータを読み取り、SQLファイルに書き込むためのバッチ構成ファイルを作成しましょう。構成クラスファイルに@EnableBatchProcessingアノテーションを追加する必要があります。@EnableBatchProcessingアノテーションは、SpringBootアプリケーションのバッチ操作を有効にするために使用されます。

package com.tutorialspoint.batchservicedemo;

import javax.sql.DataSource;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;

import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;
import org.springframework.batch.item.file.mapping.DefaultLineMapper;
import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

@Configuration
@EnableBatchProcessing
public class BatchConfiguration {
   @Autowired
   public JobBuilderFactory jobBuilderFactory;

   @Autowired
   public StepBuilderFactory stepBuilderFactory;

   @Autowired
   public DataSource dataSource;

   @Bean
   public FlatFileItemReader<User> reader() {
      FlatFileItemReader<User> reader = new FlatFileItemReader<User>();
      reader.setResource(new ClassPathResource("file.csv"));
      reader.setLineMapper(new DefaultLineMapper<User>() {
         {
            setLineTokenizer(new DelimitedLineTokenizer() {
               {
                  setNames(new String[] { "firstName", "lastName" });
               }
            });
            setFieldSetMapper(new BeanWrapperFieldSetMapper<User>() {
               {
                  setTargetType(User.class);
               }
            });
         }
      });
      return reader;
   }
   @Bean
   public UserItemProcessor processor() {
      return new UserItemProcessor();
   }
   @Bean
   public JdbcBatchItemWriter<User> writer() {
      JdbcBatchItemWriter<User> writer = new JdbcBatchItemWriter<User>();
      writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<User>());
      writer.setSql("INSERT INTO USERS (first_name, last_name) VALUES (:firstName, :lastName)");
      writer.setDataSource(dataSource);
      return writer;
   }
   @Bean
   public Job importUserJob(JobCompletionNotificationListener listener) {
      return jobBuilderFactory.get("importUserJob").incrementer(
         new RunIdIncrementer()).listener(listener).flow(step1()).end().build();
   }
   @Bean
   public Step step1() {
      return stepBuilderFactory.get("step1").<User, User>chunk(10).reader(reader()).processor(processor()).writer(writer()).build();
   }
}

ザ・ reader() メソッドはCSVファイルからデータを読み取るために使用され、writer()メソッドはSQLにデータを書き込むために使用されます。

次に、ジョブ完了通知リスナークラスを作成する必要があります。これは、ジョブ完了後に通知するために使用されます。

package com.tutorialspoint.batchservicedemo;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;

@Component
public class JobCompletionNotificationListener extends JobExecutionListenerSupport {
   private static final Logger log = LoggerFactory.getLogger(JobCompletionNotificationListener.class);
   private final JdbcTemplate jdbcTemplate;

   @Autowired
   public JobCompletionNotificationListener(JdbcTemplate jdbcTemplate) {
      this.jdbcTemplate = jdbcTemplate;
   }
   @Override
   public void afterJob(JobExecution jobExecution) {
      if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
         log.info("!!! JOB FINISHED !! It's time to verify the results!!");

         List<User> results = jdbcTemplate.query(
            "SELECT first_name, last_name FROM USERS", new RowMapper<User>() {
            
            @Override
            public User mapRow(ResultSet rs, int row) throws SQLException {
               return new User(rs.getString(1), rs.getString(2));
            }
         });

         for (User person : results) {
            log.info("Found <" + person + "> in the database.");
         }
      }
   }
}

次に、実行可能JARファイルを作成し、次のMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行します。

Mavenの場合、次のようにコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のようにコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで指定されたコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

次のようにコンソールウィンドウに出力が表示されます-

Apache Kafkaは、フォールトトレラントメッセージングシステムに基づいてメッセージをパブリッシュおよびサブスクライブするために使用されるオープンソースプロジェクトです。高速でスケーラブルであり、設計により配布されます。Kafkaの初心者である場合、またはKafkaについてより深く理解したい場合は、このリンクを参照してください-www.tutorialspoint.com/apache_kafka/

この章では、SpringBootアプリケーションにApacheKafkaを実装する方法を説明します。

まず、ビルド構成ファイルにSpringKafkaの依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます。

<dependency>
   <groupId>org.springframework.kafka</groupId>
   <artifactId>spring-kafka</artifactId>
   <version>2.1.0.RELEASE</version>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'

メッセージの作成

Apache Kafkaにメッセージを生成するには、次のようにProducer構成のConfigurationクラスを定義する必要があります-

package com.tutorialspoint.kafkademo;

import java.util.HashMap;
import java.util.Map;

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

@Configuration
public class KafkaProducerConfig {
   @Bean
   public ProducerFactory<String, String> producerFactory() {
      Map<String, Object> configProps = new HashMap<>();
      configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
      configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
      configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
      return new DefaultKafkaProducerFactory<>(configProps);
   }
   @Bean
   public KafkaTemplate<String, String> kafkaTemplate() {
      return new KafkaTemplate<>(producerFactory());
   }
}

メッセージを公開するには、Kafka Templateオブジェクトを自動配線し、図のようにメッセージを生成します。

@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
 
public void sendMessage(String msg) {
   kafkaTemplate.send(topicName, msg);
}

メッセージの消費

メッセージを消費するには、以下に示すようにコンシューマー構成クラスファイルを作成する必要があります。

package com.tutorialspoint.kafkademo;

import java.util.HashMap;
import java.util.Map;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;

@EnableKafka
@Configuration
public class KafkaConsumerConfig {
   @Bean
   public ConsumerFactory<String, String> consumerFactory() {
      Map<String, Object> props = new HashMap<>();
      props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:2181");
      props.put(ConsumerConfig.GROUP_ID_CONFIG, "group-id");
      props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
      props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
      return new DefaultKafkaConsumerFactory<>(props);
   }
   @Bean
   public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
      ConcurrentKafkaListenerContainerFactory<String, String> 
      factory = new ConcurrentKafkaListenerContainerFactory<>();
      factory.setConsumerFactory(consumerFactory());
      return factory;
   }
}

次に、メッセージをリッスンするリスナーを作成します。

@KafkaListener(topics = "tutorialspoint", groupId = "group-id")
public void listen(String message) {
   System.out.println("Received Messasge in group - group-id: " + message);
}

メインのSpringBootアプリケーションクラスファイルからApplicationRunnerクラスrunメソッドからsendMessage()メソッドを呼び出し、同じクラスファイルからメッセージを消費してみましょう。

主なSpringBootアプリケーションクラスファイルコードを以下に示します-

package com.tutorialspoint.kafkademo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;

@SpringBootApplication
public class KafkaDemoApplication implements ApplicationRunner {
   @Autowired
   private KafkaTemplate<String, String> kafkaTemplate;

   public void sendMessage(String msg) {
      kafkaTemplate.send("tutorialspoint", msg);
   }
   public static void main(String[] args) {
      SpringApplication.run(KafkaDemoApplication.class, args);
   }
   @KafkaListener(topics = "tutorialspoint", groupId = "group-id")
   public void listen(String message) {
      System.out.println("Received Messasge in group - group-id: " + message);
   }
   @Override
   public void run(ApplicationArguments args) throws Exception {
      sendMessage("Hi Welcome to Spring For Apache Kafka");
   }
}

完全なビルド構成ファイルのコードを以下に示します。

Maven – 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.tutorialspoint</groupId>
   <artifactId>kafka-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>kafka-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.kafka</groupId>
         <artifactId>spring-kafka</artifactId>
         <version>2.1.0.RELEASE</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

次に、実行可能なJARファイルを作成し、以下に示すようにMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行します。

Mavenの場合、次のようにコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のようにコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで指定されたコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

出力はコンソールウィンドウで確認できます。

Twilioは、SMSを送信し、アプリケーションから音声通話を行うために使用されるサードパーティのアプリケーションです。これにより、SMSを送信し、プログラムで音声通話を行うことができます。

この章では、TwilioでSpring Bootを使用して、SMSの送信と音声通話を実装する方法を学習します。

Note− TwilioのTrailアカウントを使用して、SMSの送信と音声通話を行いました。Twilioの詳細については、www.twilio.comをご覧ください。

まず、ビルド構成ファイルにTwilio依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます。

<dependency>
   <groupId>com.twilio.sdk</groupId>
   <artifactId>twilio</artifactId>
   <version>7.16.1</version>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile group: "com.twilio.sdk", name:"twilio", version: "7.16.1"

次に、図のように静的ブロックでACCOUNT_SIDとAUTH_IDを使用してTwilioアカウントを初期化します-

static {
   Twilio.init(ACCOUNT_SID, AUTH_ID);
}

SMSの送信

SMSを送信するには、Message.create()メソッドに開始番号と終了番号を指定する必要があります。メッセージ本文のコンテンツも、示されているようにメソッドMessage.creator()を提供する必要があります-

Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
   "Message from Spring Boot Application").create();

メインのSpringBootアプリケーションクラスファイルは次のとおりです。

package com.tutorialspoint.smsdemo;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Message;
import com.twilio.type.PhoneNumber;

@SpringBootApplication
public class SmsdemoApplication implements ApplicationRunner {
   private final static String ACCOUNT_SID = "<your-account-sid>";
   private final static String AUTH_ID = "<your-auth-id>";

   static {
      Twilio.init(ACCOUNT_SID, AUTH_ID);
   }
   public static void main(String[] args) {
      SpringApplication.run(SmsdemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
         "Message from Spring Boot Application").create();
   }
}

構成ファイルをビルドするための完全なコードを以下に示します-

Maven – 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.tutorialspoint</groupId>
   <artifactId>smsdemo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>smsdemo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>com.twilio.sdk</groupId>
         <artifactId>twilio</artifactId>
         <version>7.16.1</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: "com.twilio.sdk", name:"twilio", version: "7.11.+"   
}

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、次のようにコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のようにコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

以下のコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、「to-number」へのSMSが届きます。

「to-number」に受信したメッセージ。

Sent from your Twilio trail account
- Message from Spring Boot Application

Note−この例では、Trailアカウントを使用しました。したがって、SMSを送信する前に番号を確認する必要があります。

音声通話

Twilioを使用して音声通話を行うには、Call.creator()メソッドを呼び出す必要があります。この方法では、ここに示すように、to-number、from-number、および音声メモを提供する必要があります。

Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
   new URI("http://demo.twilio.com/docs/voice.xml")).create();

メインのSpringBootアプリケーションクラスファイルのコードを以下に示します。

package com.tutorialspoint.smsdemo; 

import java.net.URI;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Call;
import com.twilio.type.PhoneNumber;

@SpringBootApplication
public class SmsdemoApplication implements ApplicationRunner {
   private final static String ACCOUNT_SID = "<ACCOUNT-SID>";
   private final static String AUTH_ID = "AUTH-ID";

   static {
      Twilio.init(ACCOUNT_SID, AUTH_ID);
   }
   public static void main(String[] args) {
      SpringApplication.run(SmsdemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
         new URI("http://demo.twilio.com/docs/voice.xml")).create();
   }
}

完全なビルド構成ファイルのコードを以下に示します-

Maven – 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.tutorialspoint</groupId>
   <artifactId>smsdemo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>smsdemo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>com.twilio.sdk</groupId>
         <artifactId>twilio</artifactId>
         <version>7.16.1</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: "com.twilio.sdk", name:"twilio", version: "7.11.+"   
}

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、次のようにコマンドを使用します-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のようにコマンドを使用します-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで、ここで指定されたコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

これで、Twilioから「to-number」への通話が届きます。

通話に参加した後、任意のキーを押すと、からの音声メモが聞こえます https://demo.twilio.com/docs/voice.xml

Note−この例では、Trailアカウントを使用しました。したがって、電話をかける前に番号を確認する必要があります。

ユニットテストは、個々のユニットまたはコンポーネントの機能が正常に機能していることを確認するために開発者が行うテストの1つです。

このチュートリアルでは、MockitoとWebControllerを使用して単体テストケースを作成する方法を説明します。

モッキート

MockitoMocksをSpringBeansに注入するには、ビルド構成ファイルにMockito-core依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます。

<dependency>
   <groupId>org.mockito</groupId>
   <artifactId>mockito-core</artifactId>
   <version>2.13.0</version>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
testCompile('org.springframework.boot:spring-boot-starter-test')

String値を返すメソッドを含むServiceクラスを作成するためのコードをここに示します。

package com.tutorialspoint.mockitodemo;

import org.springframework.stereotype.Service;

@Service
public class ProductService {
   public String getProductName() {
      return "Honey";
   } 
}

次に、図のように、ProductServiceクラスを別のServiceクラスファイルに挿入します。

package com.tutorialspoint.mockitodemo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
   @Autowired
   ProductService productService;

   public OrderService(ProductService productService) {
      this.productService = productService;
   }
   public String getProductName() {
      return productService.getProductName();
   }
}

主なSpringBootアプリケーションクラスファイルを以下に示します-

package com.tutorialspoint.mockitodemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MockitoDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(MockitoDemoApplication.class, args);
   }
}

次に、テストのアプリケーションコンテキストを構成します。@Profile(“ test”)アノテーションは、テストケースの実行時にクラスを構成するために使用されます。

package com.tutorialspoint.mockitodemo;

import org.mockito.Mockito;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;

@Profile("test")
@Configuration
public class ProductServiceTestConfiguration {
   @Bean
   @Primary
   public ProductService productService() {
      return Mockito.mock(ProductService.class);
   }
}

これで、注文サービスのユニットテストケースを src/test/resources パッケージ。

package com.tutorialspoint.mockitodemo;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@SpringBootTest
@ActiveProfiles("test")
@RunWith(SpringJUnit4ClassRunner.class)
public class MockitoDemoApplicationTests {
   @Autowired
   private OrderService orderService;
   
   @Autowired
   private ProductService productService;

   @Test
   public void whenUserIdIsProvided_thenRetrievedNameIsCorrect() {
      Mockito.when(productService.getProductName()).thenReturn("Mock Product Name");
      String testName = orderService.getProductName();
      Assert.assertEquals("Mock Product Name", testName);
   }
}

ビルド構成ファイルの完全なコードを以下に示します。

Maven – 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.tutorialspoint</groupId>
   <artifactId>mockito-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>mockito-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.mockito</groupId>
         <artifactId>mockito-core</artifactId>
         <version>2.13.0</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

次のMavenまたはGradle1コマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、次のようにコマンドを使用できます-

mvn clean install

テスト結果はコンソールウィンドウで確認できます。

Gradleの場合、次のようにコマンドを使用できます-

gradle clean build

残りの結果はコンソールウィンドウで確認できます。

Spring Bootは、RESTコントローラーファイルの単体テストを作成する簡単な方法を提供します。SpringJUnit4ClassRunnerとMockMvcの助けを借りて、RESTコントローラーファイルの単体テストを作成するためのWebアプリケーションコンテキストを作成できます。

ユニットテストは、 src/test/java テストを作成するためのディレクトリおよびクラスパスリソースは、 src/test/resources ディレクトリ。

単体テストを作成するには、以下に示すように、ビルド構成ファイルにSpring Boot StarterTestの依存関係を追加する必要があります。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

testCompile('org.springframework.boot:spring-boot-starter-test')

テストケースを作成する前に、まずRESTfulWebサービスを構築する必要があります。RESTful Webサービスの構築の詳細については、このチュートリアルに記載されている同じ章を参照してください。

RESTコントローラーの単体テストの作成

このセクションでは、RESTコントローラーの単体テストを作成する方法を見てみましょう。

まず、MockMvcを使用してWebアプリケーションコンテキストの作成に使用する抽象クラスファイルを作成し、mapToJson()メソッドとmapFromJson()メソッドを定義してJavaオブジェクトをJSON文字列に変換し、JSON文字列をJavaオブジェクトに変換する必要があります。

package com.tutorialspoint.demo;

import java.io.IOException;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = DemoApplication.class)
@WebAppConfiguration
public abstract class AbstractTest {
   protected MockMvc mvc;
   @Autowired
   WebApplicationContext webApplicationContext;

   protected void setUp() {
      mvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
   }
   protected String mapToJson(Object obj) throws JsonProcessingException {
      ObjectMapper objectMapper = new ObjectMapper();
      return objectMapper.writeValueAsString(obj);
   }
   protected <T> T mapFromJson(String json, Class<T> clazz)
      throws JsonParseException, JsonMappingException, IOException {
      
      ObjectMapper objectMapper = new ObjectMapper();
      return objectMapper.readValue(json, clazz);
   }
}

次に、AbstractTestクラスを拡張するクラスファイルを記述し、GET、POST、PUT、DELETEなどの各メソッドの単体テストを記述します。

GETAPIテストケースのコードを以下に示します。このAPIは、製品のリストを表示するためのものです。

@Test
public void getProductsList() throws Exception {
   String uri = "/products";
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.get(uri)
      .accept(MediaType.APPLICATION_JSON_VALUE)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   Product[] productlist = super.mapFromJson(content, Product[].class);
   assertTrue(productlist.length > 0);
}

POSTAPIテストケースのコードを以下に示します。このAPIは製品を作成するためのものです。

@Test
public void createProduct() throws Exception {
   String uri = "/products";
   Product product = new Product();
   product.setId("3");
   product.setName("Ginger");
   
   String inputJson = super.mapToJson(product);
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.post(uri)
      .contentType(MediaType.APPLICATION_JSON_VALUE).content(inputJson)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(201, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is created successfully");
}

PUTAPIテストケースのコードを以下に示します。このAPIは、既存の製品を更新するためのものです。

@Test
public void updateProduct() throws Exception {
   String uri = "/products/2";
   Product product = new Product();
   product.setName("Lemon");
   
   String inputJson = super.mapToJson(product);
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.put(uri)
      .contentType(MediaType.APPLICATION_JSON_VALUE).content(inputJson)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is updated successsfully");
}

DeleteAPIテストケースのコードを以下に示します。このAPIは既存の製品を削除します。

@Test
public void deleteProduct() throws Exception {
   String uri = "/products/2";
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.delete(uri)).andReturn();
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is deleted successsfully");
}

完全なControllerTestクラスファイルを以下に示します-

package com.tutorialspoint.demo;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import org.junit.Before;
import org.junit.Test;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

import com.tutorialspoint.demo.model.Product;

public class ProductServiceControllerTest extends AbstractTest {
   @Override
   @Before
   public void setUp() {
      super.setUp();
   }
   @Test
   public void getProductsList() throws Exception {
      String uri = "/products";
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.get(uri)
         .accept(MediaType.APPLICATION_JSON_VALUE)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      Product[] productlist = super.mapFromJson(content, Product[].class);
      assertTrue(productlist.length > 0);
   }
   @Test
   public void createProduct() throws Exception {
      String uri = "/products";
      Product product = new Product();
      product.setId("3");
      product.setName("Ginger");
      String inputJson = super.mapToJson(product);
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.post(uri)
         .contentType(MediaType.APPLICATION_JSON_VALUE)
         .content(inputJson)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(201, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is created successfully");
   }
   @Test
   public void updateProduct() throws Exception {
      String uri = "/products/2";
      Product product = new Product();
      product.setName("Lemon");
      String inputJson = super.mapToJson(product);
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.put(uri)
         .contentType(MediaType.APPLICATION_JSON_VALUE)
         .content(inputJson)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is updated successsfully");
   }
   @Test
   public void deleteProduct() throws Exception {
      String uri = "/products/2";
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.delete(uri)).andReturn();
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is deleted successsfully");
   }
}

実行可能なJARファイルを作成し、以下に示すMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Mavenの場合、以下のコマンドを使用できます-

mvn clean install

これで、コンソールウィンドウにテスト結果が表示されます。

Gradleの場合、以下に示すコマンドを使用できます-

gradle clean build

以下に示すように、残りの結果をコンソールウィンドウで確認できます。

Spring Bootは、データベースのデータソースを作成するための非常に優れたサポートを提供します。SpringBootでデータソースを作成するために追加のコードを記述する必要はありません。依存関係を追加して構成の詳細を実行するだけで、データソースを作成してデータベースに接続できます。

この章では、Spring BootJDBCドライバー接続を使用してデータベースに接続します。

まず、ビルド構成ファイルにSpring Boot StarterJDBC依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile('org.springframework.boot:spring-boot-starter-jdbc')

H2データベースに接続します

H2データベースに接続するには、ビルド構成ファイルにH2データベースの依存関係を追加する必要があります。

Mavenユーザーの場合、pom.xmlファイルに以下の依存関係を追加します。

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

Gradleユーザーの場合、build.gradleファイルに以下の依存関係を追加します。

compile('com.h2database:h2')

H2データベースに接続するには、classpath src / main / resourcesディレクトリの下にschema.sqlファイルとdata.sqlファイルを作成する必要があります。

schema.sqlファイルを以下に示します。

CREATE TABLE PRODUCT (ID INT PRIMARY KEY, PRODUCT_NAME VARCHAR(25));

data.sqlファイルを以下に示します。

INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (1,'Honey');
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (2,'Almond');

MySQLを接続する

MySQLデータベースに接続するには、MySQLの依存関係をビルド構成ファイルに追加する必要があります。

Mavenユーザーの場合、pom.xmlファイルに次の依存関係を追加します。

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

Gradleユーザーの場合、build.gradleファイルに次の依存関係を追加します。

compile('mysql:mysql-connector-java')

次に、図のようにMySQLでデータベースとテーブルを作成します-

プロパティファイルのユーザーの場合、application.propertiesファイルに次のプロパティを追加します。

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000

YAMLユーザーの場合、application.ymlファイルに次のプロパティを追加します。

spring:
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
      username: "root"
      password: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000

Redisを接続する

Redisは、メモリ内のデータ構造を格納するために使用されるオープンソースデータベースです。Spring BootアプリケーションでRedisデータベースに接続するには、ビルド構成ファイルにRedis依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加する必要があります。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-redis</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加する必要があります。

compile('org.springframework.boot:spring-boot-starter-data-redis')

Redis接続の場合、RedisTemplateを使用する必要があります。RedisTemplateの場合、JedisConnectionFactoryの詳細を提供する必要があります。

@Bean
JedisConnectionFactory jedisConnectionFactory() {
   JedisConnectionFactory jedisConFactory = new JedisConnectionFactory();
   jedisConFactory.setHostName("localhost");
   jedisConFactory.setPort(6000);
   jedisConFactory.setUsePool(true);
   return jedisConFactory;
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
   RedisTemplate<String, Object> template = new RedisTemplate<>();
   template.setConnectionFactory(jedisConnectionFactory());
   template.setKeySerializer(new StringRedisSerializer());
   template.setHashKeySerializer(new StringRedisSerializer());
   template.setHashValueSerializer(new StringRedisSerializer());
   template.setValueSerializer(new StringRedisSerializer());
   return template;
}

ここで、RedisTemplateクラスを自動配線し、Redisデータベースのデータにアクセスします。

@Autowired

RedisTemplate<String, Object> redis;
Map<Object,Object> datalist = redis.opsForHash().entries(“Redis_code_index_key”);

JDBCTemplate

Spring BootアプリケーションでJdbcTemplateを使用してリレーショナルデータベースにアクセスするには、ビルド構成ファイルにSpring Boot StarterJDBC依存関係を追加する必要があります。

次に、JdbcTemplateクラスを@Autowiredすると、Spring Bootは自動的にデータベースに接続し、JdbcTemplateオブジェクトのデータソースを設定します。

@Autowired
JdbcTemplate jdbcTemplate;
Collection<Map<String, Object>> rows = jdbc.queryForList("SELECT QUERY");

@Repositoryアノテーションをクラスファイルに追加する必要があります。@Repositoryアノテーションは、SpringBootアプリケーションのデータベースリポジトリを作成するために使用されます。

@Repository
public class ProductServiceDAO {
}

複数のデータソース

単一のSpringBootアプリケーションに「n」個のデータソースを保持できます。ここに示す例は、SpringBootアプリケーションで複数のデータソースを作成する方法を示しています。次に、2つのデータソース構成の詳細をアプリケーションプロパティファイルに追加します。

プロパティファイルユーザーの場合、次のプロパティをapplication.propertiesファイルに追加します。

spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.dbProductService.username = root
spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000

spring.dbUserService.driverClassName = com.mysql.jdbc.Driver
spring.dbUserService.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect = true
spring.dbUserService.username = root
spring.dbUserService.password = root
spring.dbUserService.testOnBorrow = true
spring.dbUserService.testWhileIdle = true
spring.dbUserService.timeBetweenEvictionRunsMillis = 60000
spring.dbUserService.minEvictableIdleTimeMillis = 30000
spring.dbUserService.validationQuery = SELECT 1
spring.dbUserService.max-active = 15
spring.dbUserService.max-idle = 10
spring.dbUserService.max-wait = 8000

Yamlユーザーは、application.ymlファイルに次のプロパティを追加する必要があります。

spring:
   dbProductService: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000
   dbUserService: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1    
      max-active: 15
      max-idle: 10
      max-wait: 8000

次に、Configurationクラスを作成して、複数のデータソースのDataSourceとJdbcTemplateを作成します。

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

@Configuration
public class DatabaseConfig {
   @Bean(name = "dbProductService")
   @ConfigurationProperties(prefix = "spring.dbProductService")
   @Primary
   public DataSource createProductServiceDataSource() {
      return DataSourceBuilder.create().build();
   }
   @Bean(name = "dbUserService")
   @ConfigurationProperties(prefix = "spring.dbUserService")
   public DataSource createUserServiceDataSource() {
      return DataSourceBuilder.create().build();
   }
   @Bean(name = "jdbcProductService")
   @Autowired
   public JdbcTemplate createJdbcTemplate_ProductService(@Qualifier("dbProductService") DataSource productServiceDS) {
      return new JdbcTemplate(productServiceDS);
   }
   @Bean(name = "jdbcUserService")
   @Autowired
   public JdbcTemplate createJdbcTemplate_UserService(@Qualifier("dbUserService") DataSource userServiceDS) {
      return new JdbcTemplate(userServiceDS);
   }
}

次に、@ Qualifierアノテーションを使用してJDBCTemplateオブジェクトを自動配線します。

@Qualifier("jdbcProductService")
@Autowired
JdbcTemplate jdbcTemplate;

@Qualifier("jdbcUserService")
@Autowired
JdbcTemplate jdbcTemplate;

Spring Boot Securityの依存関係がクラスパスに追加された場合、SpringBootアプリケーションはすべてのHTTPエンドポイントの基本認証を自動的に要求します。エンドポイント「/」および「/ home」は認証を必要としません。他のすべてのエンドポイントには認証が必要です。

SpringBootアプリケーションにSpringBoot Securityを追加するには、ビルド構成ファイルにSpring Boot StarterSecurityの依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile("org.springframework.boot:spring-boot-starter-security")

Webアプリケーションの保護

まず、Thymeleafテンプレートを使用して安全でないWebアプリケーションを作成します。

次に、下にhome.htmlファイルを作成します src/main/resources/templates ディレクトリ。

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Spring Security Example</title>
   </head>
   <body>
      <h1>Welcome!</h1>
      <p>Click <a th:href = "@{/hello}">here</a> to see a greeting.</p>
   </body>
   
</html>

シンプルなビュー /hello Thymeleafテンプレートを使用してHTMLファイルで定義されます。

次に、下にhello.htmlを作成します src/main/resources/templates ディレクトリ。

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Hello World!</title>
   </head>
   <body>
      <h1>Hello world!</h1>
   </body>
   
</html>

次に、Spring MVC –ホームビューとハロービュー用のビューコントローラーをセットアップする必要があります。

このために、WebMvcConfigurerAdapterを拡張するMVC構成ファイルを作成します。

package com.tutorialspoint.websecuritydemo;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class MvcConfig extends WebMvcConfigurerAdapter {
   @Override
   public void addViewControllers(ViewControllerRegistry registry) {
      registry.addViewController("/home").setViewName("home");
      registry.addViewController("/").setViewName("home");
      registry.addViewController("/hello").setViewName("hello");
      registry.addViewController("/login").setViewName("login");
   }
}

次に、Spring BootStarterのセキュリティ依存関係をビルド構成ファイルに追加します。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile("org.springframework.boot:spring-boot-starter-security")

次に、基本認証を使用してHTTPエンドポイントにアクセスするようにアプリケーションを保護するために使用されるWebセキュリティ構成ファイルを作成します。

package com.tutorialspoint.websecuritydemo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http
         .authorizeRequests()
            .antMatchers("/", "/home").permitAll()
            .anyRequest().authenticated()
            .and()
         .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
   }
   @Autowired
   public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
      auth
         .inMemoryAuthentication()
         .withUser("user").password("password").roles("USER");
   }
}

次に、login.htmlファイルを src/main/resources ユーザーがログイン画面を介してHTTPエンドポイントにアクセスできるようにするディレクトリ。

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:th = "http://www.thymeleaf.org"
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Spring Security Example </title>
   </head>
   <body>
      <div th:if = "${param.error}">
         Invalid username and password.
      </div>
      <div th:if = "${param.logout}">
         You have been logged out.
      </div>
      
      <form th:action = "@{/login}" method = "post">
         <div>
            <label> User Name : <input type = "text" name = "username"/> </label>
         </div>
         <div>
            <label> Password: <input type = "password" name = "password"/> </label>
         </div>
         <div>
            <input type = "submit" value = "Sign In"/>
         </div>
      </form>
      
   </body>
</html>

最後に、hello.htmlファイルを更新します–ユーザーがアプリケーションからサインアウトし、以下に示すように現在のユーザー名を表示できるようにします–

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Hello World!</title>
   </head>
   <body>
      <h1 th:inline = "text">Hello [[${#httpServletRequest.remoteUser}]]!</h1>
      <form th:action = "@{/logout}" method = "post">
         <input type = "submit" value = "Sign Out"/>
      </form>
   </body>
   
</html>

メインのSpringBootアプリケーションのコードを以下に示します-

package com.tutorialspoint.websecuritydemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class WebsecurityDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(WebsecurityDemoApplication.class, args);
   }
}

ビルド構成ファイルの完全なコードを以下に示します。

Maven – 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.tutorialspoint</groupId>
   <artifactId>websecurity-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websecurity-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-security</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-security')
   compile('org.springframework.boot:spring-boot-starter-thymeleaf')
   compile('org.springframework.boot:spring-boot-starter-web')
   
   testCompile('org.springframework.boot:spring-boot-starter-test')
   testCompile('org.springframework.security:spring-security-test')
}

次に、実行可能JARファイルを作成し、次のMavenまたはGradleコマンドを使用してSpringBootアプリケーションを実行します。

Mavenユーザーは、以下のコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleユーザーは、次のようにコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

次に、以下に示すコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

URLをヒット http://localhost:8080/Webブラウザで。図のように出力を確認できます。

この章では、Spring BootSecurityメカニズムとJWTを使用したOAuth2について詳しく学習します。

承認サーバー

Authorization Serverは、WebAPIセキュリティの最高のアーキテクチャコンポーネントです。承認サーバーは、アプリとHTTPエンドポイントがアプリケーションの機能を識別できるようにする一元化承認ポイントとして機能します。

リソースサーバー

Resource Serverは、Resource ServerHTTPエンドポイントにアクセスするためのアクセストークンをクライアントに提供するアプリケーションです。これは、HTTPエンドポイント、静的リソース、および動的Webページを含むライブラリのコレクションです。

OAuth2

OAuth2は、アプリケーションWebセキュリティがクライアントからリソースにアクセスできるようにする承認フレームワークです。OAuth2アプリケーションを構築するには、付与タイプ(認証コード)、クライアントID、およびクライアントシークレットに焦点を当てる必要があります。

JWTトークン

JWTトークンはJSONWebトークンであり、2者間で保護されたクレームを表すために使用されます。JWTトークンの詳細については、www.jwt.io /をご覧ください。

次に、JWTトークンを使用してAuthorization Server、ResourceServerの使用を可能にするOAuth2アプリケーションを構築します。

次の手順を使用して、データベースにアクセスすることにより、JWTトークンを使用したSpring BootSecurityを実装できます。

まず、ビルド構成ファイルに次の依存関係を追加する必要があります。

Mavenユーザーは、pom.xmlファイルに次の依存関係を追加できます。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</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-web</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.security.oauth</groupId>
   <artifactId>spring-security-oauth2</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-jwt</artifactId>
</dependency>

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-test</artifactId>
   <scope>test</scope>
</dependency>

Gradleユーザーは、build.gradleファイルに次の依存関係を追加できます。

compile('org.springframework.boot:spring-boot-starter-security')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
testCompile('org.springframework.security:spring-security-test')

compile("org.springframework.security.oauth:spring-security-oauth2")
compile('org.springframework.security:spring-security-jwt')
compile("org.springframework.boot:spring-boot-starter-jdbc")
compile("com.h2database:h2:1.4.191")

どこ、

  • Spring Boot Starter Security − SpringSecurityを実装します

  • Spring Security OAuth2 − OAUTH2構造を実装して、承認サーバーとリソースサーバーを有効にします。

  • Spring Security JWT −Webセキュリティ用のJWTトークンを生成します

  • Spring Boot Starter JDBC −データベースにアクセスして、ユーザーが対応可能かどうかを確認します。

  • Spring Boot Starter Web −HTTPエンドポイントを書き込みます。

  • H2 Database −認証と承認のためにユーザー情報を保存します。

完全なビルド構成ファイルを以下に示します。

<?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.tutorialspoint</groupId>
   <artifactId>websecurityapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websecurityapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</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-web</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security.oauth</groupId>
         <artifactId>spring-security-oauth2</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-jwt</artifactId>
      </dependency>
      
      <dependency>
         <groupId>com.h2database</groupId>
         <artifactId>h2</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}

dependencies {
   compile('org.springframework.boot:spring-boot-starter-security')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   testCompile('org.springframework.security:spring-security-test')
   compile("org.springframework.security.oauth:spring-security-oauth2")
   compile('org.springframework.security:spring-security-jwt')
   compile("org.springframework.boot:spring-boot-starter-jdbc")
   compile("com.h2database:h2:1.4.191")  
}

ここで、メインのSpring Bootアプリケーションで、@ EnableAuthorizationServerアノテーションと@EnableResourceServerアノテーションを追加して、同じアプリケーションで認証サーバーとリソースサーバーとして機能します。

また、次のコードを使用して、JWTトークンを使用してSpringSecurityでAPIにアクセスするための単純なHTTPエンドポイントを記述できます。

package com.tutorialspoint.websecurityapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableAuthorizationServer
@EnableResourceServer
@RestController
public class WebsecurityappApplication {
   public static void main(String[] args) {
      SpringApplication.run(WebsecurityappApplication.class, args);
   }
   @RequestMapping(value = "/products")
   public String getProductName() {
      return "Honey";   
   }
}

次のコードを使用して、認証用のユーザー情報を格納するPOJOクラスを定義します。

package com.tutorialspoint.websecurityapp;

import java.util.ArrayList;
import java.util.Collection;
import org.springframework.security.core.GrantedAuthority;

public class UserEntity {
   private String username;
   private String password;
   private Collection<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();
   
   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public Collection<GrantedAuthority> getGrantedAuthoritiesList() {
      return grantedAuthoritiesList;
   }
   public void setGrantedAuthoritiesList(Collection<GrantedAuthority> grantedAuthoritiesList) {
      this.grantedAuthoritiesList = grantedAuthoritiesList;
   }
   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }
}

ここで、次のコードを使用して、SpringBoot認証用にorg.springframework.security.core.userdetails.Userクラスを拡張するCustomUserクラスを定義します。

package com.tutorialspoint.websecurityapp;

import org.springframework.security.core.userdetails.User;

public class CustomUser extends User {
   private static final long serialVersionUID = 1L;
   public CustomUser(UserEntity user) {
      super(user.getUsername(), user.getPassword(), user.getGrantedAuthoritiesList());
   }
}

@Repositoryクラスを作成して、データベースからユーザー情報を読み取り、それをカスタムユーザーサービスに送信し、付与された権限「ROLE_SYSTEMADMIN」を追加することもできます。

package com.tutorialspoint.websecurityapp;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Repository;

@Repository
public class OAuthDao {
   @Autowired
   private JdbcTemplate jdbcTemplate;

   public UserEntity getUserDetails(String username) {
      Collection<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();
      String userSQLQuery = "SELECT * FROM USERS WHERE USERNAME=?";
      List<UserEntity> list = jdbcTemplate.query(userSQLQuery, new String[] { username },
         (ResultSet rs, int rowNum) -> {
         
         UserEntity user = new UserEntity();
         user.setUsername(username);
         user.setPassword(rs.getString("PASSWORD"));
         return user;
      });
      if (list.size() > 0) {
         GrantedAuthority grantedAuthority = new SimpleGrantedAuthority("ROLE_SYSTEMADMIN");
         grantedAuthoritiesList.add(grantedAuthority);
         list.get(0).setGrantedAuthoritiesList(grantedAuthoritiesList);
         return list.get(0);
      }
      return null;
   }
}

図のように、org.springframework.security.core.userdetails.UserDetailsS​​erviceを拡張してDAOリポジトリクラスを呼び出すカスタムユーザー詳細サービスクラスを作成できます。

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class CustomDetailsService implements UserDetailsService {
   @Autowired
   OAuthDao oauthDao;

   @Override
   public CustomUser loadUserByUsername(final String username) throws UsernameNotFoundException {
      UserEntity userEntity = null;
      try {
         userEntity = oauthDao.getUserDetails(username);
         CustomUser customUser = new CustomUser(userEntity);
         return customUser;
      } catch (Exception e) {
         e.printStackTrace();
         throw new UsernameNotFoundException("User " + username + " was not found in the database");
      }
   }
}

次に、@ configurationクラスを作成して、Webセキュリティを有効にし、パスワードエンコーダー(BCryptPasswordEncoder)を定義し、AuthenticationManagerBeanを定義します。Security構成クラスは、WebSecurityConfigurerAdapterクラスを拡張する必要があります。

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
   @Autowired
   private CustomDetailsService customDetailsService;

   @Bean
   public PasswordEncoder encoder() {
      return new BCryptPasswordEncoder();
   }
   @Override
   @Autowired
   protected void configure(AuthenticationManagerBuilder auth) throws Exception {
      auth.userDetailsService(customDetailsService).passwordEncoder(encoder());
   }
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http.authorizeRequests().anyRequest().authenticated().and().sessionManagement()
         .sessionCreationPolicy(SessionCreationPolicy.NEVER);
   }
   @Override
   public void configure(WebSecurity web) throws Exception {
      web.ignoring();
   }
   @Override
   @Bean
   public AuthenticationManager authenticationManagerBean() throws Exception {
      return super.authenticationManagerBean();
   }
}

次に、OAuth2構成クラスを定義して、クライアントID、クライアントシークレットを追加し、トークン署名者キーと検証者キーのJwtAccessTokenConverter、秘密キー、公開キーを定義し、スコープを使用してトークンの有効性についてClientDetailsS​​erviceConfigurerを構成します。

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;

@Configuration
public class OAuth2Config extends AuthorizationServerConfigurerAdapter {
   private String clientid = "tutorialspoint";
   private String clientSecret = "my-secret-key";
   private String privateKey = "private key";
   private String publicKey = "public key";

   @Autowired
   @Qualifier("authenticationManagerBean")
   private AuthenticationManager authenticationManager;
   
   @Bean
   public JwtAccessTokenConverter tokenEnhancer() {
      JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
      converter.setSigningKey(privateKey);
      converter.setVerifierKey(publicKey);
      return converter;
   }
   @Bean
   public JwtTokenStore tokenStore() {
      return new JwtTokenStore(tokenEnhancer());
   }
   @Override
   public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
      endpoints.authenticationManager(authenticationManager).tokenStore(tokenStore())
      .accessTokenConverter(tokenEnhancer());
   }
   @Override
   public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
      security.tokenKeyAccess("permitAll()").checkTokenAccess("isAuthenticated()");
   }
   @Override
   public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
      clients.inMemory().withClient(clientid).secret(clientSecret).scopes("read", "write")
         .authorizedGrantTypes("password", "refresh_token").accessTokenValiditySeconds(20000)
         .refreshTokenValiditySeconds(20000);

   }
}

次に、opensslを使用して秘密鍵と公開鍵を作成します。

秘密鍵を生成するには、次のコマンドを使用できます。

openssl genrsa -out jwt.pem 2048
openssl rsa -in jwt.pem

公開鍵の生成には、以下のコマンドを使用できます。

openssl rsa -in jwt.pem -pubout

1.5リリースより後のバージョンのSpringBootの場合、以下のプロパティをapplication.propertiesファイルに追加して、OAuth2リソースフィルターの順序を定義します。

security.oauth2.resource.filter-order=3

YAMLファイルのユーザーは、YAMLファイルに以下のプロパティを追加できます。

security:
   oauth2:
      resource:
         filter-order: 3

次に、クラスパスリソースの下にschema.sqlファイルとdata.sqlファイルを作成します src/main/resources/directory アプリケーションをH2データベースに接続します。

schema.sqlファイルは次のとおりです-

CREATE TABLE USERS (ID INT PRIMARY KEY, USERNAME VARCHAR(45), PASSWORD VARCHAR(60));

data.sqlファイルは次のとおりです-

INSERT INTO USERS (ID, USERNAME,PASSWORD) VALUES (
   1, '[email protected]','$2a$08$fL7u5xcvsZl78su29x1ti.dxI.9rYO8t0q5wk2ROJ.1cdR53bmaVG'); INSERT INTO USERS (ID, USERNAME,PASSWORD) VALUES ( 2, '[email protected]','$2a$08$fL7u5xcvsZl78su29x1ti.dxI.9rYO8t0q5wk2ROJ.1cdR53bmaVG');

Note −パスワードは、データベーステーブルにBcryptエンコーダの形式で保存する必要があります。

次のMavenまたはGradleコマンドを使用して、実行可能なJARファイルを作成し、SpringBootアプリケーションを実行できます。

Mavenの場合、以下のコマンドを使用できます-

mvn clean install

「BUILDSUCCESS」の後、JARファイルはターゲットディレクトリの下にあります。

Gradleの場合、次のようにコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

ここで、ここに示すコマンドを使用してJARファイルを実行します-

java –jar <JARFILE>

アプリケーションはTomcatポート8080で起動されます。

次に、POSTMANを介してPOSTメソッドのURLをヒットし、OAUTH2トークンを取得します。

http://localhost:8080/oauth/token

ここで、次のようにリクエストヘッダーを追加します-

  • Authorization −クライアントIDとクライアントシークレットを使用した基本認証。

  • Content Type − application / x-www-form-urlencoded

ここで、次のようにリクエストパラメータを追加します-

  • grant_type =パスワード
  • ユーザー名=あなたのユーザー名
  • パスワード=あなたのパスワード

ここで、APIをヒットし、図のようにaccess_tokenを取得します-

次に、図のように、リクエストヘッダーのベアラーアクセストークンでResource ServerAPIをヒットします。

次に、以下に示すような出力を確認できます。

Google Cloud Platformは、クラウド環境でSpringBootアプリケーションを実行するクラウドコンピューティングサービスを提供します。この章では、GCPアプリエンジンプラットフォームにSpringBootアプリケーションをデプロイする方法を説明します。

まず、SpringInitializerページwww.start.spring.ioからGradleビルドSpringBootアプリケーションをダウンロードします。次のスクリーンショットを確認してください。

次に、build.gradleファイルに、Google Cloudappengineプラグインとappengineクラスパスの依存関係を追加します。

build.gradleファイルのコードを以下に示します-

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
      classpath 'com.google.cloud.tools:appengine-gradle-plugin:1.3.3'
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'com.google.cloud.tools.appengine'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

ここで、単純なHTTPエンドポイントを作成すると、次のように文字列の成功が返されます。

package com.tutorialspoint.appenginedemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class AppengineDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(AppengineDemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String success() {
      return "APP Engine deployment success";
   }
}

次に、図のようにsrc / main / appengineディレクトリの下にapp.ymlファイルを追加します-

runtime: java
env: flex

handlers:
- url: /.*
   script: this field is required, but ignored

次に、Google Cloudコンソールに移動し、ページの上部にある[Activate Google CloudShell]をクリックします。

次に、Google Cloud Shellを使用して、ソースファイルとGradleファイルをGoogle CloudMachineのホームディレクトリに移動します。

ここで、コマンドgradle appengineDeployを実行すると、アプリケーションがGoogle Cloudappengineにデプロイされます。

Note − GCPで課金が有効になっている必要があり、アプリケーションをappengineにデプロイする前に、GCPでappengineプラットフォームを作成する必要があります。

アプリケーションをGCPappengineプラットフォームにデプロイするのに数分かかります。

ビルドが成功すると、コンソールウィンドウにサービスURLが表示されます。

次に、サービスURLを押して、出力を確認します。

Google Cloud SQL

Google CloudSQLをSpringBootアプリケーションに接続するには、次のプロパティをapplication.propertiesファイルに追加する必要があります。

JDBCURL形式

jdbc:mysql://google/<DATABASE-NAME>?cloudSqlInstance = <GOOGLE_CLOUD_SQL_INSTANCE_NAME> &socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = <USERNAME>&password = <PASSWORD>

Note − SpringBootアプリケーションとGoogleCloudSQLは同じGCPプロジェクトに含まれている必要があります。

application.propertiesファイルを以下に示します。

spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://google/PRODUCTSERVICE?cloudSqlInstance = springboot-gcp-cloudsql:asia-northeast1:springboot-gcp-cloudsql-instance&socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = root&password = rootspring.dbProductService.username = root

spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000

YAMLファイルのユーザーは、以下のプロパティをapplication.ymlファイルに追加できます。

spring:
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://google/PRODUCTSERVICE?cloudSqlInstance=springboot-gcp-cloudsql:asia-northeast1:springboot-gcp-cloudsql-instance&socketFactory=com.google.cloud.sql.mysql.SocketFactory&user=root&password=root"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      validationQuery: SELECT 1
      
      max-active: 15
      max-idle: 10
      max-wait: 8000

この章では、GradleビルドでSpringBootアプリケーションを使用してGoogleOAuth2サインインを追加する方法を説明します。

まず、ビルド構成ファイルにSpring Boot OAuth2セキュリティ依存関係を追加します。ビルド構成ファイルは、以下のとおりです。

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint.projects'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile('org.springframework.security.oauth:spring-security-oauth2')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

次に、以下に示すように、メインのSpringBootアプリケーションクラスファイルでSpringBootを介して認証した後、HTTPエンドポイントを追加してGoogleからユーザープリンシパルを読み取ります。

package com.tutorialspoint.projects.googleservice;

import java.security.Principal;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class GoogleserviceApplication {
   public static void main(String[] args) {
      SpringApplication.run(GoogleserviceApplication.class, args);
   }
   @RequestMapping(value = "/user")
   public Principal user(Principal principal) {
      return principal;
   }
}

次に、構成ファイルを作成して、WebセキュリティのOAuth2SSOを有効にし、次に示すようにindex.htmlファイルの認証を削除します。

package com.tutorialspoint.projects.googleservice;

import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableOAuth2Sso
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http
         .csrf()
         .disable()
         .antMatcher("/**")
         .authorizeRequests()
         .antMatchers("/", "/index.html")
         .permitAll()
         .anyRequest()
         .authenticated();
   }
}

次に、静的リソースの下にindex.htmlファイルを追加し、ユーザーHTTPエンドポイントにリダイレクトするリンクを追加して、以下に示すようにGoogleユーザープリンシパルを読み取ります。

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1">
      <title>Insert title here</title>
   </head>
   <body>
      <a href = "user">Click here to Google Login</a>
   </body>
</html>

Note − Google Cloudコンソールで-Gmailサービス、分析サービス、およびGoogle+サービスAPIを有効にします。

次に、[認証情報]セクションに移動して認証情報を作成し、[OAuthクライアントID]を選択します。

次に、OAuth2同意画面で製品名を入力します。

次に、アプリケーションタイプを「Webアプリケーション」として選択し、承認されたJavaScriptオリジンと承認されたリダイレクトURIを指定します。

これで、OAuth2クライアントIDとクライアントシークレットが作成されました。

次に、アプリケーションのプロパティファイルにクライアントIDとクライアントシークレットを追加します。

security.oauth2.client.clientId = <CLIENT_ID>
security.oauth2.client.clientSecret = <CLIENT_SECRET>
security.oauth2.client.accessTokenUri  =  https://www.googleapis.com/oauth2/v3/token
security.oauth2.client.userAuthorizationUri  =  https://accounts.google.com/o/oauth2/auth
security.oauth2.client.tokenName = oauth_token
security.oauth2.client.authenticationScheme = query
security.oauth2.client.clientAuthenticationScheme = form
security.oauth2.client.scope = profile email

security.oauth2.resource.userInfoUri  =  https://www.googleapis.com/userinfo/v2/me
security.oauth2.resource.preferTokenInfo = false

これで、実行可能なJARファイルを作成し、次のGradleコマンドを使用してSpringBootアプリケーションを実行できます。

Gradleの場合、次のようにコマンドを使用できます-

gradle clean build

「BUILDSUCCESSFUL」の後、build / libsディレクトリの下にJARファイルがあります。

コマンドjava–jar <JARFILE>を使用してJARファイルを実行すると、Tomcatポート8080でアプリケーションが開始されます。

今URLを打つ http://localhost:8080/ Googleログインリンクをクリックします。

Googleのログイン画面にリダイレクトされ、Gmailのログインの詳細が表示されます。

ログインに成功すると、Gmailユーザーのプリンシパルオブジェクトを受け取ります。