ishowcode.eth

SpringBoot の基礎#

1. SpringBoot の紹介#

1.1. Spring Boot とは#

Spring Boot は Spring プロジェクトのサブプロジェクトであり、私たちがよく知っている Spring-framework と同じく Spring の製品です:

一般的に Spring Boot はプログラムのスキャフォールディング、または Spring に基づくプロジェクトの便利なスキャフォールディングと呼ばれます。その主な目的は、開発者が大規模な Spring プロジェクトを迅速に構築し、可能な限りすべての XML 設定を削減し、すぐに使える状態にし、開発者が設定ではなくビジネスに集中できるようにすることです。

1.2. なぜ Spring Boot を学ぶ必要があるのか#

Java は常に肥大化し、面倒であると批判されています。その理由は主に 2 つです：

複雑な設定

プロジェクトのさまざまな設定は実際には開発時のコストであり、Spring の特性設定とビジネス問題の解決の間で思考を切り替える必要があるため、設定を書くことがアプリケーションロジックを書く時間を圧迫します。

混乱した依存関係管理

プロジェクトの依存関係管理も手間がかかる問題です。プロジェクトで使用するライブラリを決定するだけでも頭が痛いのに、これらのライブラリのどのバージョンが他のライブラリと衝突しないかを知る必要があります。この難題は非常に厄介です。また、依存関係管理もコストの一種であり、依存関係を追加することはアプリケーションコードを書くことではありません。一度依存関係のバージョンを間違えると、続いて発生する互換性の問題は間違いなく生産性の殺し屋になります。

しかし、Spring Boot はこれを過去のものにしました！

Spring BootはSpringに基づくアプリケーション開発を簡素化し、「run」と入力するだけで独立した生産レベルのSpringアプリケーションを作成できます。Spring BootはSpringプラットフォームとサードパーティライブラリに対してすぐに使える設定を提供します（デフォルト設定を提供し、デフォルト設定を格納するパッケージはスターターと呼ばれます）。これにより、私たちは簡単に始めることができます。ほとんどのSpring Bootアプリケーションは非常に少ないSpring設定しか必要ありません。

私たちは Spring Boot を使用して Java アプリケーションを作成し、java –jar で起動することで生産レベルの Web プロジェクトを得ることができます。

1.3. Spring Boot の特徴#

1.3.1 Spring Boot の特徴#

• Spring に基づく開発のためのより迅速な入門体験を提供
• すぐに使える、コード生成も XML 設定も不要です。同時に、特定のニーズを満たすためにデフォルト値を変更することもできます
• 埋め込みサーバー、安全性、指標、健康チェック、外部設定など、大規模プロジェクトで一般的な非機能的特性を提供します。Spring Boot は Spring の機能を強化するのではなく、Spring を迅速に使用する方法を提供します。

2. SpringBoot の迅速な入門#

次に、Spring Boot を使用して Web プロジェクトを構築し、Spring Boot の魅力を体験してみましょう！

2.1 Maven プロジェクトの作成#

IDEA ツールを使用して Maven プロジェクトを作成します。このプロジェクトは通常の Java プロジェクトで構いません。

2.2 Spring Boot のスターター依存関係を追加#

ここで多くの学生が疑問を持つかもしれません。前述の伝統的な開発の問題の 1 つは依存関係管理の混乱であると言ったのに、どうしてここで依存関係を管理する必要があるのでしょうか？Spring Boot は私たちを管理してくれないのでしょうか？
心配しないでください。現在、私たちのプロジェクトは Spring Boot とはまだ何の関係もありません。Spring Boot は spring-boot-starter-parent という名前のプロジェクトを提供しており、その中でさまざまな一般的な依存関係（すべてではありません）のバージョンを管理しています。私たちのプロジェクトはこのプロジェクトを親プロジェクトとして使用する必要があり、これにより依存関係のバージョンの問題を心配する必要がなくなります。必要な依存関係は、座標を直接引き入れるだけです。

2.2.1. 親プロジェクトの座標を追加#

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐parent</artifactId>
<version>2.1.5.RELEASE</version>
</parent>

2.2.2. Web スターターを追加#

Spring Boot にさまざまな自動設定を完了させるために、Spring Boot が提供する自動設定依存関係を引き入れる必要があります。これをスターターと呼びます。私たちは Web プロジェクトなので、ここで Web スターターを引き入れ、pom.xml ファイルに次の依存関係を追加します：

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

注意が必要なのは、ここでバージョン情報を指定していないことです。なぜなら、Spring Boot の親プロジェクトがすでにバージョンを管理しているからです。この時点で、プロジェクトには大量の依存関係が追加されていることに気づくでしょう。それらの依存関係はすべて Spring Boot が spring-boot-starter-web という依存関係に基づいて自動的に引き入れたものであり、すべてのバージョンがすでに管理されているため、衝突は発生しません。

2.3 Spring Boot の起動クラスと Controller の作成#

Spring Boot が提供する起動クラスを通じて Spring Boot を開始する必要があります。

package com.summer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MySpringBootApplication {
    public static void main(String[] args) {
SpringApplication.run(MySpringBootApplication.class);
}
}

起動クラス MySpringBootApplication と同じパッケージまたはサブパッケージ内に QuickStartController を作成します。

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class QuickController {
@RequestMapping("/quick")
@ResponseBody
public String quick(){
return "springboot アクセス成功!";
}
}

@ResponseBodyアノテーションの役割は、実際にはJavaオブジェクトをJSON形式のデータとしてクライアントに応答することです。返り値が文字列の場合、文字列をそのままクライアントに書き込みます。

2.4 テストの開始#

Spring Boot の起動クラスのメインメソッドを実行すると、コンソールに次のようなログが表示されます：

ログを通じて、Tomcat がポート 8080（http）で起動し、コンテキストパスが '' であることがわかります。Tomcat は起動し、ポート 8080 をリッスンしており、Web アプリケーションの仮想プロジェクト名は空です。ブラウザを開いて URL アドレスにアクセスします：http://localhost:8080/quick

2.5 Spring Boot プロジェクトのホットデプロイ#

開発中にクラスやページなどのリソースを繰り返し修正する場合、毎回修正後に再起動する必要があり、毎回の起動が非常に面倒で、大量の時間を浪費します。コードを修正した後、再起動せずに有効にすることができるように、pom.xml に次の設定を追加することでこの機能を実現できます。これをホットデプロイと呼びます。

<!‐‐ホットデプロイ設定‐‐>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐devtools</artifactId>
</dependency>

注意：IDEA で Spring Boot のホットデプロイが失敗する理由
このような状況が発生する場合、ホットデプロイの設定の問題ではなく、根本的な原因は Intellij IDEA がデフォルトで自動コンパイルを行わないためです。IDEA の自動コンパイル設定を行う必要があります。以下のように設定します：

次に Shift+Ctrl+Alt+/ を押して、Registry を選択します。

2.6 IDEA を使用して Spring Boot プロジェクトを迅速に作成#

IDEA を使用して迅速に作成した Spring Boot プロジェクトの pom.xml には、選択した Web のスターター依存関係の座標がすでにインポートされています。

クイックスタートの方法を使用して Controller を作成してアクセスすることができます。ここでは詳しく説明しません。

3. Java 設定アプリケーション#

入門ケースでは、何の設定もなく SpringMVC プロジェクトを実現できました。迅速で効率的です！しかし、設定が全くない場合、Bean を設定するにはどうすればよいのでしょうか？たとえば、データベース接続プールを設定する必要がある場合、以前は次のように設定していました：

<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>

3.1. Spring 設定の歴史#

実際、Spring 3.0 から、Spring 公式は従来の XML 設定に代わって Java 設定を使用することを推奨しています。Spring の歴史を振り返ってみましょう：

• Spring 1.0 時代
  この時期は jdk 1.5 が登場したばかりで、アノテーション開発は普及していなかったため、すべての Spring 設定は XML 形式でした。すべての Bean が XML で設定されていることを想像すると、非常に恐ろしいです。その時代のプログラマーに 2 秒間同情します。

• Spring 2.0 時代
  Spring はアノテーション開発を導入しましたが、まだ不完全であったため、XML を完全に置き換えることはありませんでした。この時期のプログラマーは XML とアノテーションを組み合わせて使用することが多かったようです。

• Spring 3.0 以降
  3.0 以降、Spring のアノテーションは非常に充実しており、Spring は皆に完全な Java 設定を使用することを推奨しましたが、国内ではあまり普及しませんでした。そして、Spring Boot が登場したとき、人々は徐々に Java 設定の優雅さを認識し始めました。

• 古い言葉に「変化を受け入れ、未来を受け入れよう」とあります。私たちも時代の流れに従い、ファッショナブルな潮流に乗り、Java 設定の使い方を学びましょう。

3.2. Java 設定を試す#

Java 設定は主に Java クラスといくつかのアノテーションに依存しています。一般的に使用されるアノテーションは次のとおりです：

• @Configuration：クラスを設定クラスとして宣言し、XML ファイルの代わりにします。
• @Bean：メソッド上で宣言し、メソッドの戻り値を Bean コンテナに追加します。タグの代わりにします。
• @Value：プロパティの注入
• @PropertySource：外部プロパティファイルを読み込みます。

次に、Java 設定を使用して接続プールの設定を試みます：

1. pom.xml ファイルに Druid 接続プールの依存関係を次のように追加します。

<!‐‐ Druid接続プール ‐‐>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>

2. jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

3. 設定クラス

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
@Value("${jdbc.url}")
String url;
@Value("${jdbc.driverClassName}")
String driverClassName;
@Value("${jdbc.username}")
String username;
@Value("${jdbc.password}")
String password;
@Bean
public DataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(driverClassName);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
}

• 解説：
• @Configuration：JdbcConfig が設定クラスであることを宣言します。
• @PropertySource：プロパティファイルのパスを指定します：classpath.properties
• @Value を使用してプロパティに値を注入します。
• @Bean を使用して dataSource () メソッドを登録 Bean のメソッドとして宣言し、Spring は自動的にこのメソッドを呼び出し、メソッドの戻り値を Spring コンテナに追加します。
  これにより、任意の場所で @Autowired を使用して DataSource を注入できるようになります！

4. テスト

@Controller
public class QuickController {
@Autowired
private DataSource dataSource;
@RequestMapping("/quick")
@ResponseBody
public String hello() {
System.out.println("dataSource = " + dataSource);
return "こんにちは、Spring Boot!";
}
}

3.3. Spring Boot のプロパティ注入#

上記のケースでは、Java 設定方式を実験しました。しかし、プロパティ注入には @Value アノテーションを使用しました。この方法は機能しますが、基本的な型の値しか注入できないため、あまり強力ではありません。
Spring Boot では、新しいプロパティ注入方法が提供されており、さまざまな Java 基本データ型や複雑な型の注入をサポートしています。プロパティファイルの名前には変更があり、デフォルトのファイル名は次のようにする必要があります：

application.propertiesまたはapplication.yml

@ConfigurationProperties(prefix ="jdbc")
public class JdbcProperties {
private String driverClassName;
private String url;
private String username;
private String password;
// ... 略
// ゲッターとセッター
}

• クラスに @ConfigurationProperties アノテーションを使用して、現在のクラスをプロパティ読み取りクラスとして宣言します。
• prefix="jdbc" は、プロパティファイル内の jdbc というプレフィックスを持つ値を読み取ります。
• クラスに各プロパティを定義し、名前はプロパティファイル内の jdbc. の後の部分と一致する必要があります。
• ここでプロパティファイルのアドレスを指定していないため、jdbc.properties の名前を application.properties に変更する必要があります。これは Spring Boot がデフォルトで読み取るプロパティファイル名です。
  【注意】次のような警告が表示されても、プロジェクトは実行できます；

上記の警告を取り除くには、pom.xml ファイルに次の依存関係を追加します：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐configuration‐processor</artifactId>
<!‐‐伝播しない依存関係‐‐>
<optional>true</optional>
</dependency>

優雅な注入

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {
@Bean
public DataSource dataSource(JdbcProperties jdbc) {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUrl(jdbc.getUrl());
dataSource.setDriverClassName(jdbc.getDriverClassName());
dataSource.setUsername(jdbc.getUsername());
dataSource.setPassword(jdbc.getPassword());
return dataSource;
}
}

さらに優雅な注入
実際、あるプロパティが 1 つの Bean でのみ使用される場合、そのプロパティを JdbcProperties というクラスに注入する必要はありません（そのクラス上のすべてのアノテーションを削除します）。必要な場所で直接宣言できます。JdbcConfig クラスを次のように変更します：

@Configuration
public class JdbcConfig {
@Bean
@ConfigurationProperties(prefix = "jdbc")
public DataSource dataSource() {
return new DruidDataSource();
}
}

3.4 Yaml 設定ファイル#

設定ファイルは application.properties 形式だけでなく、拡張子が.yml または.yaml の形式でも使用できます。つまり、application.yml または application.yaml です。
yaml と properties 設定ファイルは表示形式が異なるだけで、他の機能や効果は同じです。プロジェクト内の元の読み取り方法は変更する必要はありません。
yml 設定ファイルの特徴：

1. ツリー状の階層構造で設定項目を表示します。
2. 設定項目間に関係がある場合は、行を分けて 2 つのスペースを空ける必要があります。
3. 設定項目に値がある場合、: の後に 1 つのスペースを空けてから設定項目の値を書きます。

基本形式：

jdbc:
driverClassName : com.mysql.jdbc.Driver
url : jdbc:mysql://localhost:3306/kw
username : root
password : root

application.properties を application.yml に変更してテストします。

4. 自動設定原理の解析#

Spring Boot を使用すると、SpringMVC を統合した WEB プロジェクトの開発が非常に簡単になり、複雑な設定がすべて消えます。これはどのように実現されるのでしょうか？
すべての魔法の始まりは、私たちの main 関数から始まります。したがって、起動クラスを再度見てみましょう：
Ctrl を押しながら、起動クラスMySpringBootApplicationのアノテーション @SpringBootApplication をクリックして確認します。

//Spring Bootプロジェクトの起動クラス、プロジェクトのエントリポイント
//現在のクラスが属するパッケージとそのサブパッケージを自動的にスキャンします
@SpringBootApplication
public class MySpringBootApplication {
public static void main(String[] args) {
//Spring Bootアプリケーションを実行します
SpringApplication.run(MySpringBootApplication.class,args);
}
}

アノテーション @SpringBootApplication のソースコード

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
/**
* 特定の自動構成クラスを除外し、それらが適用されないようにします。
* @return 除外するクラス
*/
@AliasFor(annotation = EnableAutoConfiguration.class)
Class<?>[] exclude() default {};
    ... ... ...
}

ここでの重要なアノテーションは 3 つです：

• @SpringBootConfiguration：@Configuration と同等であり、このクラスが Spring の設定クラスであることを示します。
• @EnableAutoConfiguration：Spring Boot の自動設定機能を有効にします。
• Ctrl を押しながら、アノテーション @EnableAutoConfiguration をクリックして確認します。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
... ... ...
}

@EnableAutoConfiguration の役割は、META-INF/spring.factories ファイルから自動設定に関する設定情報を読み取ることです。

spring.factories ファイルにおける自動設定に関する設定情報は次のとおりです：

上記の設定ファイルには、AutoConfiguration で終わるクラス名が大量に存在します。これらのクラスは自動設定情報を持つクラスであり、SpringApplication はこれらのクラス名を取得してから読み込みます。
ServletWebServerFactoryAutoConfiguration を例にとってソースコードを分析します：

@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
... ... ...
}

ここで、
@EnableConfigurationProperties (ServerProperties.class) は ServerProperties サーバー設定プロパティクラスを読み込むことを示します。この方法は私たちが経験したことがあります。
ServerProperties.class のソースコードは次のとおりです：

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {
/**
* サーバーのHTTPポート。
*/
private Integer port;
/**
* サーバーがバインドすべきネットワークアドレス。
*/
private InetAddress address;
    ... ... ...
}

ここで、
prefix = "server" は、Spring Boot が設定ファイル内の server で始まるプロパティをこのクラスのフィールドにマッピングすることを示します。マッピング関係は次のとおりです：

• @ComponentScan

コンポーネントスキャンの指示を設定します。<context:component-scan>タグと同様の機能を提供します。
basePackageClassesまたはbasePackages属性を使用してスキャンするパッケージを指定します。これらの属性が指定されていない場合、アノテーションが宣言されたクラスが属するパッケージからスキャンが開始されます。

私たちの @SpringBootApplication アノテーションが宣言されたクラスは main 関数がある起動クラスであるため、スキャンされるパッケージはそのクラスが属するパッケージとそのサブパッケージです。
したがって、一般的に起動クラスは比較的前のパッケージディレクトリに配置されます。

5. Spring Boot と他の技術の統合#

5.1 SpringMVC の統合#

デフォルトの設定で SpringMVC を使用できますが、時にはカスタム設定が必要です。

5.1.1. ポートの変更#

Spring Boot の全体的なプロパティを確認すると、ポートは次の方法で設定できます：

server:
port: 80

5.2.2. 静的リソースへのアクセス#

現在、私たちのプロジェクトは JAR プロジェクトであるため、webapp はなく、静的リソースはどこに置くべきでしょうか？

上記のソースコードを振り返ると、ResourceProperties というクラスがあり、その中で静的リソースのデフォルトの検索パスが定義されています。

• デフォルトの静的リソースパスは次のとおりです：
• classpath:/META-INF/resources/
• classpath:/resources/
• classpath:/static/
• classpath:/public

注意：画像にアクセスする際に表示されない場合は、プロジェクトをクリーンしてから起動するか、publicまたはresourcesフォルダーを作成し、画像をpublicまたはresourcesに配置してください。

5.2. JDBC とトランザクションの統合#

Spring における JDBC 接続とトランザクションは設定の重要な部分です。Spring Boot ではどのように処理されるのでしょうか？
答えは、処理する必要がなく、Spring Boot が提供するスターターを見つけるだけです。pom.xml ファイルに次の依存関係を追加します：

<!‐‐JDBCとトランザクションの統合‐‐>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐jdbc</artifactId>
</dependency>

もちろん、データベースドライバーを忘れないでください。Spring Boot は私たちが使用するデータベースを知りません。ここでは MySQL を選択します。同様に、pom.xml ファイルに次の依存関係を追加します：

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql‐connector‐java</artifactId>
</dependency>

トランザクションについては、Spring Boot ではアノテーションを使用して制御します。これは私たちがよく知っている @Transactional であり、使用する際には対応するクラスまたはメソッドに設定するだけです。

5.3 接続プールの統合#

実際、先ほど JDBC スターターを引き入れたとき、Spring Boot はすでに自動的に接続プールを引き入れています：

HikariCP は現在最も高速な接続プールであると思われます。HikariCP と c3p0 の比較を見てみましょう：

したがって、接続プールのパラメータを指定するだけで済みます。application.yml を開いて、次のように設定を変更します：

spring:
datasource:
driver‐class‐name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF‐8&serverTimezone=UTC
username: root
password: root

5.4 Spring Boot と Mybatis の統合#

Mybatis のスターター依存関係を追加します。
Spring Boot 公式は Mybatis のスターターを提供していませんが、Mybatis の公式が独自に実装しました。プロジェクトの pom.xml ファイルに次の依存関係を追加します：

<!‐‐Mybatisスターター依存関係‐‐>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis‐spring‐boot‐starter</artifactId>
<version>2.1.2</version>
</dependency>

データベースドライバーの座標を追加します。

<!‐‐ MySQL接続ドライバー ‐‐>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql‐connector‐java</artifactId>
</dependency>

application.yml を設定し、一般的な設定は次のとおりです：

#Mybatis設定
mybatis:
type‐aliases‐package: com.bailiban.domain
mapper‐locations: classpath:com/bailiban/mapper/*Mapper.xml
configuration:
log‐impl: org.apache.ibatis.logging.stdout.StdOutImpl

Mapper スキャンの設定
注意が必要なのは、ここで Mapper インターフェースのスキャンパッケージを設定していないため、各 Mapper インターフェースに @Mapper アノテーションを追加する必要があります。

@Mapper
public interface UserMapper {
}

または、起動クラスにスキャンパッケージアノテーションを追加することもできます（推奨）：

@SpringBootApplication
@MapperScan("com.bailiban.mapper")
public class MySpringBootApplication {
public static void main(String[] args) {
SpringApplication.run(MySpringBootApplication.class);
}
}

5.4.1 user テーブルの作成#

test データベースに user テーブルを作成します。

DROP table if EXISTS user;
##ユーザー
CREATE TABLE `user` (
`uid` INT AUTO_INCREMENT ,
`username` VARCHAR(20) DEFAULT NULL,
`password` VARCHAR(20) DEFAULT NULL,
`realname` VARCHAR(20) DEFAULT NULL,
`email` VARCHAR(30) DEFAULT NULL,
`telephone` VARCHAR(20) DEFAULT NULL,
PRIMARY KEY (`uid`)
);
INSERT INTO `user` VALUES (NULL,'wc001','888888','旺財','[email protected]','15723689921'),
(NULL,'xq001','888888','小強','[email protected]','15723689922'),
(NULL,'xb001','888888','小宝','[email protected]','15723689923');

5.4.2 エンティティ Bean の作成#

package com.bailiban.domain;
public class User {
private int uid;//ユーザー番号
private String username;//ユーザー名
private String password;//パスワード
private String realname;//本名
private String email;//メール
private String telephone;//電話
//省略 setter getterメソッド
}

5.4.3 Mapper の作成#

@Mapper
public interface UserMapper {
public List<User> queryUserList();
}

注意：@Mapper はこのクラスが Mybatis の Mapper インターフェースであることを示し、Spring Boot が自動的に Spring コンテキストにスキャンできるようにします。

5.4.4 Mapper マッピングファイルの設定#

src/main/resources/com/bailiban/mapper パスに UserMapper.xml 設定ファイルを追加します。

<
?xml version="1.0" encoding="utf‐8" ?>
<!DOCTYPE mapper PUBLIC "‐//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis‐3‐mapper.dtd" >
<mapper namespace="com.bailiban.mapper.UserMapper">
<select id="queryUserList" resultType="user">
select * from user
</select>
</mapper>

5.4.5 application.yml に Mybatis の情報を追加#

#Mybatis設定
mybatis:
type‐aliases‐package: com.bailiban.domain
mapper‐locations: classpath:com/bailiban/mapper/*Mapper.xml
configuration:
log‐impl: org.apache.ibatis.logging.stdout.StdOutImpl

5.4.6 テスト Controller の作成#

@Controller
public class MapperController {
@Autowired
private UserMapper userMapper;
@RequestMapping("/queryUser")
@ResponseBody
public List<User> queryUser(){
List<User> users = userMapper.queryUserList();
return users;
}
}

5.5 Junit テスト#

1. Spring Boot プロジェクトで Junit を使用して単体テストを行う場合、次のスターターを追加する必要があります：

   Copy

   <!‐‐単体テストスターター‐‐>
   <dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis‐spring‐starter‐test</artifactId>
   </dependency>
   

2. テストパッケージにテストクラスを作成します。
   テストクラスの上に @SpringBootTest アノテーションを追加する必要があります。

import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {
@Autowired
private UserService userService;
@Test
public void test1(){
List<User> users = userService.selectAll();
System.out.println(users);
}
}

5.6 Redis の統合#

概念：Redis は高性能な NOSQL シリーズの非関係型データベースです。

5.6.1 NOSQL とは#

NoSQL（NoSQL = Not Only SQL）は「SQL だけではない」という意味であり、新しいデータベースの理念を指し、非関係型データベースを広く指します。
インターネットの Web2.0 サイトの台頭に伴い、従来の関係データベースは Web2.0 サイト、特に超大規模で高並行な SNS タイプの Web2.0 純動的サイトに対応するのが難しく、多くの克服しがたい問題が露呈しました。一方、非関係型データベースはその特性から非常に迅速に発展しました。NoSQL データベースの出現は、大規模データセットの多様なデータタイプによる課題、特にビッグデータアプリケーションの問題を解決するためのものです。

5.6.2 NOSQL と関係型データベースの比較#

利点：

1. コスト：NoSQL データベースは簡単に展開でき、ほとんどがオープンソースソフトウェアであり、Oracle のように大量のコストをかけて購入する必要がなく、関係型データベースに比べて価格が安いです。

2. クエリ速度：NoSQL データベースはデータをキャッシュに保存し、関係型データベースはデータをハードディスクに保存するため、クエリ速度は NoSQL データベースに比べて遅くなります。

3. データの保存形式：NoSQL の保存形式は key,value 形式、ドキュメント形式、画像形式など多様であり、基本型やオブジェクト、集合などさまざまな形式を保存できますが、関係型データベースは基本型のみをサポートします。

4. 拡張性：関係型データベースは join のような多テーブルクエリメカニズムの制限により、拡張が非常に困難です。
   欠点：

5. メンテナンスツールと資料が限られているため、NoSQL は新しい技術に属し、関係型データベースの 10 年以上の技術と同じレベルではありません。

6. SQL のような業界標準をサポートしないため、一定のユーザーの学習と使用コストが発生します。

7. 関係型データベースのトランザクション処理を提供しません。

   まとめ：
   関係型データベースと NoSQL データベースは対立するのではなく、補完的な関係にあります。通常は関係型データベースを使用し、NoSQL が適している場合には NoSQL データベースを使用し、NoSQL データベースが関係型データベースの不足を補うようにします。
   一般的には、データを関係型データベースに保存し、NoSQL データベースに関係型データベースのデータをバックアップ保存します。

5.6.3 主流の NOSQL 製品#

関連製品：Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB
典型的なアプリケーション：コンテンツキャッシュ、主に大量データの高アクセス負荷を処理するために使用されます。
データモデル：一連のキーと値のペア
利点：迅速なクエリ
欠点：保存されたデータは構造化されていない
ドキュメント型データベース
関連製品：CouchDB、MongoDB
典型的なアプリケーション：Web アプリケーション（Key-Value に似ており、Value は構造化されています）
データモデル：一連のキーと値のペア
利点：データ構造の要件が厳しくない
欠点：クエリ性能が高くなく、統一されたクエリ構文が欠けています

5.6.4 Redis とは#

Redis は C 言語で開発されたオープンソースの高性能キーと値の（key-value）データベースであり、公式にテストデータを提供しています。50 の同時実行で 100000 のリクエストを実行した場合、読み取り速度は 110000 回 /s、書き込み速度は 81000 回 /s です。また、Redis はさまざまなキーと値のデータ型を提供して、さまざまなシーンでの保存ニーズに適応しています。現在、Redis がサポートしているキーと値のデータ型は次のとおりです：

1. 文字列型 string
2. ハッシュ型 hash
3. リスト型 list
4. セット型 set
5. ソートされたセット型 sortedset

5.6.5 Redis の適用シーン#

• キャッシュ（データクエリ、短接続、ニュースコンテンツ、商品コンテンツなど）
• チャットルームのオンライン友達リスト
• タスクキュー（秒殺、購入、12306 など）
• アプリケーションランキング
• ウェブサイトのアクセス統計
• データの期限切れ処理（ミリ秒単位で正確に処理可能）
• 分散型クラスタアーキテクチャにおけるセッションの分離

5.6.6 統合#

pom.xml ファイルに次の依存関係を追加します。

<!‐‐Redis‐‐>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐data‐redis</artifactId>
</dependency>

application.yml ファイルを設定します。

spring:
redis:
host: localhost
port: 6379

テストコード

package com.summer.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.*;
@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTest {
@Autowired
private RedisTemplate redisTemplate;
@Test
public void test1() {
//文字列を保存します。最も一般的です。
redisTemplate.opsForValue().set("hello", "哈哈");
//取得
String hello = (String) redisTemplate.opsForValue().get("hello");
System.out.println(hello);
//セットを保存して取得
redisTemplate.opsForSet().add("s_key", "a", "b", "c");
Set set = redisTemplate.opsForSet().members("s_key");
System.out.println("set集合"+set);
//リストを保存して取得
List<String> list = Arrays.asList("a", "b", "c");
redisTemplate.opsForList().leftPush("l_key", list);
//取得
List<String> list1 = (List<String>) redisTemplate.opsForList().leftPop("l_key");
System.out.println("list集合"+list1);
//マップ集合を保存して取得
Map<String, String> map = new HashMap<>();
map.put("name", "旺財");
map.put("age", "18");
redisTemplate.opsForHash().putAll("h_key", map);
//マップを取得
Map<String, String> map1 = redisTemplate.opsForHash().entries("h_key");
//キーの集合を取得
Set key_set = redisTemplate.opsForHash().keys("h_key");
//値の集合を取得
List value_list = redisTemplate.opsForHash().values("h_key");
System.out.println("keyの集合:"+key_set);
System.out.println("valueの集合:"+value_list);
System.out.println("map集合:"+map1);
//ソートされたセットを保存
redisTemplate.opsForZSet().add("z_key","a",10);
redisTemplate.opsForZSet().add("z_key","b",20);
redisTemplate.opsForZSet().add("z_key","c",30);
//取得
Set z_set = redisTemplate.opsForZSet().range("z_key", 0, -1);
System.out.println("ソートされたset"+z_set);
}
}