data classとは

data classはKotlin特有の仕様で、データを保持するだけのクラスはdataマークをつけることで定義されます。

data classとは特に何かしらの処理を行うわけではないが、データだけ持っているクラスを作ることができます。つまり、データだけを持ったクラスが生成できます。

data classとして成り立たせるには、最低1つのプライマリコンストラクタ引数を持たせる必要があります。

data class hoge()

// Data class must have at least one primary constructor parameter

また、valやvarでイミュータブルかどうかを明示すること、抽象クラスやopenクラス、sealedクラスやinnerクラスでないことが必要です。

data classの実装

data classは、dataという修飾子をclassの前につけるだけでdata classとして扱われます。

data class User(val userId: number, val name: String)

data classとclassの違い

data classとclassの違いは、data classの方はデータを扱うのに便利なメソッドが自動で実装されます。

元々全クラスの継承元、Anyクラスが持つ

• toString: 型名とプロパティ名、値を文字列として返す
• hashCode: プロパティの値に基づくハッシュ値を返す
• equals: オブジェクトの同値性を調べ、Booleanを返す

data classは上記に加え、以下が実装されています。

• copy: オブジェクトのコピーを返す
• componentN: N番目のプロパティの値を返す

data classで使えるcopyメソッドとcomponentNメソッド

copyメソッド

copyメソッドを使うことで同値の別インスタンスを生成できます。その際プロパティの値を変更することができます。

「プロパティの一部だけ値を変更して、新たなオブジェクトを作る」といった場合はcopyを使うと、全てのプロパティを入力せずに済みます。

例としてcopyメソッドを使って、nameプロパティのみ変更したインスタンスを作成します。

data class Department(val name: String, val address: String, val phoneNumber: String)

val department = Department("品質管理", ”東京都”, “090-1111-2222”)
val changedDepartment = department.copy(name = "生産管理")

println(changedDepartment.name)
// 生産管理

println(changedDepartment.address)
// 東京都

componentNメソッド

クラスに宣言したプロパティにcomponent1、component2…でアクセスすることができます。

data class Department(val name: String, val address: String, val phoneNumber: String)

val department = Department("品質管理", ”東京都”, “090-1111-2222”)

val first = department.component1()
val second = department.component2()

println(first)
// 品質管理

println(second)
// 東京都

Factoryメソッドとは

Factoryメソッドとはデザインパターンの1つで、より柔軟にオブジェクトを生成することを目的とするものです。

インスタンスの作り方をスーパークラスで定め、具体的な処理をサブクラスで行います。

KotlinでFactoryメソッドを実装する方法

Factoryメソッドを実装する方法はいくつかありますが、以下のcompanion objectを使用した方法が推奨されています。

メソッド名としては以下が慣例的によく使われるため、以下のメソッド名を使うのが良さそうです。

• from: 返り値がその型そのものの場合
• of: 複数引数を受け取りそれらを集約するものを返す場合

data class User(val id: Int, val Name: String) {
  companion object {
    fun from(userId: number, name: String): User {
      return User(userId, name)
    }
  }
}

使うときは以下のようにFactoryメソッドを呼び出してインスタンスを生成します。

val userId = 1
val name = “hoge”
val user = User.from(userId, name)

companion objectとは

ちょっと寄り道ですが、companion objectについて説明します。

companion objectはクラス内に作成されるSingletonのことです。Singletonとは、生成するインスタンスの数を1つに制限するデザインパターンです。

Kotlinでは、classの代わりに objectキーワードを使用するだけでSingletonが作成でき、objectキーワードの前にcompanion修飾子を付与することでクラスに属するSingletonが作成できます。

これをcompanion objectと呼び、companion objectは1クラス内に1つだけ宣言可能です。

Kotlinにはstatic修飾子がないので、companion objectはstaticなフィールドやメソッドが必要なときの代替手段として利用されることがあります。

なぜコンストラクタよりFactoryメソッドの方が良いのか

オブジェクトを生成するのになぜコンストラクタよりFactoryメソッドが良いのか、いくつかその理由を挙げていきます。

Factoryメソッドにすることでメソッド名がつけられる

先ほど紹介したように、Factoryメソッドならメソッド名をつけられるため、生成方法ごとにわかりやすい名前をつけられます。

data class User(val id: Int, val Name: String) {
  companion object {
    fun from(userId: number, name: String): User {
      return User(userId, name)
    }
  }
}

返り値にサブタイプを指定できる

以下の例のように、listOfメソッドの返り値はList型になっており、Listはinterfaceであるため、Listのサブタイプを返すことができます。

val hogeList: List<int> = listOf(1, 2, 3)

コンストラクタと異なる引数を渡すことができる

Factoryメソッドならコンストラクタと異なる引数を渡すことができます。

data class User(val id: Int, val Name: String) {
  companion object {
    fun of(userId: number, config: Config): User {
      return User(userId, config.defaultName)
    }
  }
}

参考

https://qiita.com/doyaaaaaken/items/0c99da9efa7d724a0d80

https://qiita.com/tkhs0604/items/261e94a42b7097dfd204

Kotlin+Spring Bootで簡単なAPIをClean Architectureで実装してみた

Kotlin + Spring Bootを触ってみたので、Clean Archi…

mintaku-blog.net

前回スタブで取得していたデータをちゃんとセットアップしてDBから取得できるようにします。またTODOアプリっぽいAPIを実装し、CRUD操作できるようにします。

DockerでMySQL導入し、Spring BootからDB接続できるようにする

まずは既存のAPIにMySQLを導入します。今回はDockerでMySQLを選択しました。

M1 Macで起動するためにplatform: linux/x86_64を追加しています。volumesでコンテナ起動時のデータセットアップとMySQLの設定ファイルを読み込んでいます。

・docker-compose.yml

version: '3'
services:
  mysql:
    platform: linux/x86_64
    image: mysql:5.7
    container_name: mysql_sample
    environment:
      MYSQL_ROOT_PASSWORD: mysql
      MYSQL_DATABASE: sample
      MYSQL_USER: docker
      MYSQL_PASSWORD: docker
    volumes:
      - ./initdb.d:/docker-entrypoint-initdb.d
      - ./my.cnf:/etc/mysql/conf.d/my.cnf
    ports:
      - 3306:3306

my.cnfでMySQLの設定を行います。my.cnfにcharacter-setを追加しているのはMySQLに日本語のデータを追加した際に文字化けになったのでその対応です。

参考：https://qiita.com/Asaiii12/items/69e4420d06d91374428a

・my.cnf

[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_general_ci
explicit-defaults-for-timestamp=1
general-log=1
general-log-file=/var/log/mysql/mysqld.log

[client]
default-character-set=utf8mb4

init.sqlではコンテナ作成時にテーブルの作成とデータ投入をしています。volumsで./initdb.d:/docker-entrypoint-initdb.dを指定すると、指定ディレクトリ配下のSQLが実行されるようになっています。

・initdb.d/init.sql

USE sample;
DROP TABLE IF EXISTS tasks;
CREATE TABLE tasks
(
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `title` varchar(100) NULL,
  `content` varchar(500) NULL,
  PRIMARY KEY (id)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

INSERT INTO tasks (id, title, content) VALUES (1, "タイトル1", "内容1"), (2, "タイトル2", "内容2");

全て完了したらDockerを立ち上げます。

$ docker compose up

以下のコマンドで立ち上げたMySQLに接続し、実際にDBやテーブルが作成できるかを確認します。

$ mysql -h 0.0.0.0 -u docker -p

アプリケーションからDB接続できるようにするためにapplication.propertiesにDB接続情報を追加します。

・src/main/resources/application.properties

spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://0.0.0.0:3306/sample
spring.datasource.username=docker
spring.datasource.password=docker

Spring JPAの導入

Spring JPAを導入するためbuild.gradle.ktsのdependenciesに以下を追加し、Gradleをリビルドします。

・build.gradle.kts

dependencies {
  ...

  implementation("org.springframework.boot:spring-boot-starter-data-jpa")
}

Entityの作成

Entityで定義されたテーブル情報が、自動インサートの対象になります。今回はTODOリストを意識しているのでidとtitle、contentのカラムを定義しています。

・entity/Task.kt

package com.example.entity

import javax.persistence.*

@Entity
@Table(name = "tasks")
data class Task (
  @Id
  @GeneratedValue
  val id: Long = 0,

  @Column(name = "title", length = 100, nullable = false)
  val title: String = "",

  @Column(name = "content", length = 500)
  val content: String? = null,
)

Repositoryの作成

JPA用のインターフェースを定義します。今回はそれぞれSQLを書いて定義しています。

・repository/TaskRepository.kt

package com.example.repository

import com.example.entity.Task
import org.apache.ibatis.annotations.*
import org.springframework.stereotype.Repository

@Mapper
@Repository
interface TaskRepository {
  @Select("SELECT * FROM tasks;")
  fun findAll(): List<Task>

  @Select("SELECT * FROM tasks where id = #{id};")
  fun findById(id: Long): Task

  @Insert("INSERT INTO tasks(title, content) values(#{title}, #{content});")
  fun insertTask(title: String, content: String?): Int

  @Update("UPDATE tasks SET title=#{title}, content=#{content} WHERE id=#{id}")
  fun updateTask(id: Long, title: String, content: String?): Int

  @Delete("DELETE FROM tasks WHERE id=#{id}")
  fun deleteTask(@Param("id") id: Long): Int
}

DriverでRepositoryで定義したメソッドを呼び出す

DriverでRepositoryで定義したメソッドを呼び出し、実際にDB操作します。curlなどで確認しCRUDできていることが確認できれば完了です。

・driver/TaskDriver.kt

package com.example.driver

import com.example.repository.TaskRepository
import com.fasterxml.jackson.annotation.JsonCreator
import org.springframework.stereotype.Component

@Component
class TaskDriver(private val taskRepository: TaskRepository) {
  fun getTasks(): TasksJson {
    return taskRepository.findAll().map {
      TaskJson(it.id, it.title, it.content)
    }.let(::TasksJson)
  }

  fun getTask(taskId: Long): TaskJson {
    return taskRepository.findById(taskId)?.let {
      TaskJson(it.id, it.title, it.content)
    }
  }

  fun createTask(title: String, content: String?): Int {
    return taskRepository.insertTask(title, content)
  }

  fun updateTask(taskJson: TaskJson): Int {
    return taskRepository.updateTask(taskJson.id, taskJson.title, taskJson.content)
  }

  fun deleteTask(taskId: Long): Int {
    return taskRepository.deleteTask(taskId)
  }
}

data class TasksJson @JsonCreator constructor(
  val list: List<TaskJson>
)

data class TaskJson @JsonCreator constructor(
  val id: Long,
  val title: String,
  val content: String?
)

JUnit

JUnitとはJavaで開発されたプログラムにおいてユニットテストの自動化を行うためのフレームワークです。

よく使いそうなアノテーション

@Test

メソッドに付与することでJUnitにテストメソッドであることを認識します。

@DisplayName

テストの表示名を設定できます。

@BeforeEach

付与されたメソッドは、各テストメソッド実行前に@BeforeEachアノテーションがついたメソッドが実行されます。JUnit 4の@Beforeと同じです。

@Disabled

@Disabled はクラスまたはメソッドに付与してテストを実行させないようにすることができます。JUnit4における@Ignoreに相当します

JUnit5のアノテーション一覧は以下の公式で見ることができます。

MockK

MockKとは Kotlin用のモックライブラリです。

MockK | mocking library for Kotlin

Provides DSL to mock behavior. Built fro…

mockk.io

every

everyを使うと特定のモックインスタンスが呼ばれた時に指定した値を返却します。

verify

verifyを使うとメソッドが指定した引数で呼び出されたかを確認できます。

よく使いそうなアノテーション

@MockK

モックインスタンスとしてインジェクションしたい場合に使用します。

@SpyK

Spy用のインスタンスとしてインジェクションしたい場合に使用します。

Spyはオブジェクトを実際のコードで動かしつつ、メソッドの引数や呼び出し回数、戻り値などを検証するために使用します。

注意点としては、アノテーションを利用して初期化する際には@Spyk var hoge = Hoge()のようにvarかつインスタンス生成する必要があります。

@InjectMockKs

該当オブジェクトのもつ属性に対してインジェクトしたい場合に使用します。

ControllerのUnitテスト

@ExtendWith(SpringExtension::class)でSpring拡張機能をインクルードしていましたが、調べたら@SpringBootTestアノテーションを使用している場合は@ExtendWith(SpringExtension::class)を付与する必要はなくなったようです。

参考：https://github.com/spring-projects/spring-boot/issues/13739

・TaskControllerTest.kt

package com.example.controller

import com.example.domain.*
import com.example.usecase.TaskUseCase
import io.mockk.every
import io.mockk.impl.annotations.InjectMockKs
import io.mockk.impl.annotations.MockK
import io.mockk.mockk
import io.mockk.verify
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.http.MediaType
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.get
import org.springframework.test.web.servlet.setup.MockMvcBuilders

@SpringBootTest
class TaskControllerTest {
  @InjectMockKs
  private lateinit var taskController: TaskController

  @MockK
  private lateinit var taskUseCase: TaskUseCase

  private lateinit var mockTaskController: MockMvc

  @BeforeEach
  fun setup() {
    mockTaskController = MockMvcBuilders.standaloneSetup(taskController).build()
  }

  @Test
  @DisplayName("TasksをTasksJsonに変換する")
  fun convertTasksJsonTest() {
    val target = Tasks(listOf(Task(Title("title"), Content("content")), Task(Title("title2"), Content("content2"))))
    val expected = TasksJson(listOf(TaskJson("title", "content"), TaskJson("title2", "content2")))

    assertEquals(expected, target.toJson())
  }

  @Test
  @DisplayName("TaskをTaskJsonに変換する")
  fun convertTaskJsonTest() {
    val target = Task(Title("title"), Content("content"))
    val expected = TaskJson("title", "content")

    assertEquals(expected, target.toJson())
  }

  @Test
  @DisplayName("task一覧を取得する")
  fun getTasksTest() {
    val tasks = Tasks(listOf(Task(Title("title"), Content("content")), Task(Title("title2"), Content("content2"))))
    every { taskUseCase.getTasks() } returns tasks

    mockTaskController.get("/api/tasks").andExpect {
      status { isOk() }
      content {
        contentType(MediaType.APPLICATION_JSON)
        json("""{"tasks":[{"title":"title","content":"content"},{"title":"title2","content":"content2"}]}""")
      }
    }

    verify { taskUseCase.getTasks() }
  }

  @Test
  @DisplayName("taskを1つ取得する")
  fun getTaskTest() {
    val taskId = TaskId(1)
    val task = Task(Title("title"), Content("content"))
    every { taskUseCase.getTask(taskId) } returns task

    mockTaskController.get("/api/tasks/1").andExpect {
      status { isOk() }
      content {
        contentType(MediaType.APPLICATION_JSON)
        json("""{"title":"title","content":"content"}""")
      }
    }

    verify { taskUseCase.getTask(taskId) }
  }
}

HTTPメソッドへのテスト

MockMvcBuilders.standaloneSetup()でControllerの動作を再現するための準備をします。

参考：https://terasolunaorg.github.io/guideline/5.4.1.RELEASE/ja/UnitTest/ImplementsOfUnitTest/UsageOfLibraryForTest.html#mockmvc

@BeforeEachアノテーションを付けて、全ての@Testの前に実行させます。以降、このmockMvcインスタンスを利用して、仮想のリクエストを発生させテストを実行します。

今回はテスト対象のTaskControllerを指定して、mockMvcを生成しています。

@InjectMockKs

private lateinit var taskController: TaskController

@MockK
private lateinit var taskUseCase: TaskUseCase

…

@BeforeEach
fun setup() {
  mockTaskController = MockMvcBuilders.standaloneSetup(taskController).build()
}

テストしたいPath(今回の場合はGET /api/tasks)を指定し、andExceptメソッドでレスポンスのテストを行います。

今回はHTTPステータスコードのテストなのでstatus()を使います。ステータスコード200はstatus().isOkでテストできます。代表的なステータスコードは以下の通りです。

• 200: status().isOk()
• 308: status().isPermanentRedirect()
• 404: status().isNotFound()
• 403: status().isForbidden()
• 503: status().isServiceUnavailable()

あとはcontent()でレスポンスの形と中身を見ています。今回はREST APIなのでJSON形式であることJSONの中身が正しいことをアサートしています。

また、Controllerないのメソッドにおいて、該当のuseCaseメソッドが呼ばれたこともテストしています。

fun getTasksTest() {
  val tasks = Tasks(listOf(Task(Title("title"), Content("content")), Task(Title("title2"), Content("content2"))))
  every { taskUseCase.getTasks() } returns tasks

  mockTaskController.get("/api/tasks").andExpect {
    status { isOk() }
    content {
      contentType(MediaType.APPLICATION_JSON)
      json("""{"tasks":[{"title":"title","content":"content"},{"title":"title2","content":"content2"}]}""")
    }
  }

  verify { taskUseCase.getTasks() }
}

ドメインからJSONへの変換テスト

ControllerではUseCaseから返ってきたドメインをレスポンスの形であるJSONに変換しているため、そのテストも行っています。

今回は各ドメインにtoJson()というメソッドを生やしているので、そのメソッドを実行してちゃんとドメインからJSONに変換されているかをアサートしています。

assertEquals()で値が等しいかを確認しています。左が期待値で右が実測値を入れます。

fun convertTasksJsonTest() {
  val target = Tasks(listOf(Task(Title("title"), Content("content")), Task(Title("title2"), Content("content2"))))
  val expected = TasksJson(listOf(TaskJson("title", "content"), TaskJson("title2", "content2")))

  assertEquals(expected, target.toJson())
}

UseCaseのUnitテスト

UseCaseのテストではPortのメソッドを呼び出して、その返り値が正しいかをアサートしています。今回は簡素なAPIなので特にUseCaseでロジック挟んでおらず、シンプルなUnitテストになっています。

・TaskUseCaseTest.kt

package com.example.usecase

import com.example.domain.Task
import com.example.domain.TaskId
import com.example.domain.Tasks
import com.example.port.TaskPort
import io.mockk.every
import io.mockk.impl.annotations.InjectMockKs
import io.mockk.impl.annotations.MockK
import io.mockk.mockk
import io.mockk.verify
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals
import org.springframework.boot.test.context.SpringBootTest

@SpringBootTest
class TaskUseCaseTest {
  @InjectMockKs
  private lateinit var target: TaskUseCase

  @MockK
  lateinit var taskPort: TaskPort

  @Test
  @DisplayName("task一覧を取得する")
  fun getTasksTest() {
    val expected = mockk<Tasks>()

    every { taskPort.getTasks() } returns expected

    assertEquals(expected, target.getTasks())

    verify { taskPort.getTasks() }
  }

  @Test
  @DisplayName("taskを1つ取得する")
  fun getTaskTest() {
    val taskId = mockk<TaskId>()
    val expected = mockk<Task>()

    every { taskPort.getTask(taskId) } returns expected

    assertEquals(expected, target.getTask(taskId))

    verify { taskPort.getTask(taskId) }
  }
}

GatewayのUnitテスト

GatewayではDriverメソッドを呼び出し、その返り値をアサートしています。またGatewayではDriverで受け取ったプリミティブなJSONオブジェクトをドメインに変換する処理をしているため、変換メソッドのテストも追加しています。

・TaskGatewayTest.kt

package com.example.gateway

import com.example.domain.*
import com.example.driver.TaskDriver
import com.example.driver.TaskJson
import com.example.driver.TasksJson
import io.mockk.every
import io.mockk.impl.annotations.InjectMockKs
import io.mockk.impl.annotations.MockK
import io.mockk.verify
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest

@SpringBootTest
class TaskGatewayTest {
  @InjectMockKs
  private lateinit var target: TaskGateway

  @MockK
  lateinit var taskDriver: TaskDriver

  @Test
  @DisplayName("task一覧を取得する")
  fun getTasksTest() {
    val tasksJson = TasksJson(listOf(TaskJson("title", "content"), TaskJson("title2", "content2")))
    val expected = Tasks(listOf(Task(Title("title"), Content("content")), Task(Title("title2"), Content("content2"))))

    every { taskDriver.getTasks() } returns tasksJson

    assertEquals(expected, target.getTasks())

    verify { taskDriver.getTasks() }
  }

  @Test
  @DisplayName("TasksJsonをTasksに変換する")
  fun convertToTasks() {
    val target = TasksJson(listOf(TaskJson("title", "content"), TaskJson("title2", "content2")))
    val expected = Tasks(listOf(Task(Title("title"), Content("content")), Task(Title("title2"), Content("content2"))))

    assertEquals(expected, target.toTasks())
  }

  @Test
  @DisplayName("taskを1つ取得する")
  fun getTaskTest() {
    val taskJson = TaskJson("title", "content")
    val taskId = TaskId(1)
    val expected = Task(Title("title"), Content("content"))

    every { taskDriver.getTask(taskId.value) } returns taskJson

    assertEquals(expected, target.getTask(taskId))

    verify { taskDriver.getTask(taskId.value) }
  }

  @Test
  @DisplayName("TaskJsonをTaskに変換する")
  fun convertToTask() {
    val target = TaskJson("title", "content")
    val expected = Task(Title("title"), Content("content"))

    assertEquals(expected, target.toTask())
  }
}

MockKでlateinitプロパティが初期化されない問題

springのMockKだとうまくいくのにMockKだと以下のエラーが出る問題がありました。

kotlin.UninitializedPropertyAccessException: lateinit property hoge has not been initialized

調べてみるとinitメソッドで解決できそうでしたので、実際やってみたらうまくいきました。

参考：https://github.com/mockk/mockk/issues/546

以下のように@BeforeEachを追加するだけです。テスト実行前にMockKAnnotations.initでモックインスタンスをインジェクションすることで解決できます。

@BeforeEach
  fun init() {
  MockKAnnotations.init(this)
}

• Kotlin: 1.6.10
• SpringBoot: 2.4.4

Spring BootでのDI

そもそもDIとはDependeny Injectionの略で依存性の注入という意味です。DIはオブジェクト間に生じる依存関係をオブジェクト内のコードに直接記述せず、外部から何らかの形で与えるようにする手法です。

@Component

クラスにComponentアノテーションを付与するとDIの対象であることを表します。
そのクラスをDIコンテナが管理してくれるようになります。

他にも@Controllerや@Serviceがありますが、以下の使い分けをします。

• @Controller： MVCでコントローラー層のクラスに付与
• @Service： MVCでサービス層のクラスに付与
• @Repository： MVCでデータ層のクラスに付与
• @Component： MVCに限らず、DIで利用したいクラスへ付与する

@Bean

付与した関数で返却したインスタンスがDIコンテナに登録され、そのインスタンスをDIで使用できるようになります。

@Componentと@Beanの使い分けは以下の記事が参考になりました。

Spring Bootの@Componentと@Beanの違い - grep Tips *

まずは結論から SpringのDIコンテナに管理してもらいたいクラスが、自分で作…

www.greptips.com

@Autowired

注入されるフィールドに付けます。

DIコンテナはAutowiredアノテーションを付けたフィールドに対して、合致するオブジェクトを探してインジェクションします。

lateinit var

このフィールドへのインジェクションは変数の読み込みと同時に初期化されるのではなく、後からインジェクションされるためvar定義しておく必要があります。

Clean ArchitectureでTODOアプリを意識したAPIを実装してみる

Clean ArchitectureでTODOアプリを意識したAPIを実装してみました。といってもDBも用意せずスタブみたいな感じにしています。メソッドもgetTasks()とgetTask()だけでちょっとしたAPIとなっています。

Enterprise Business Rules

Enterprise Business Rulesではアプリケーション全体の最重要ビジネスルールをカプセル化したドメインを格納しています。

今回はTODOアプリを意識しているので、タスクIDとタイトル、コンテンツを含むTaskドメインとListとで持つTasksドメインを作っています。

・Task.kt

package com.example.domain

data class TaskId(val value: Int)

data class Title(val value: String)

data class Content(val value: String)

data class Task(val title: Title, val content: Content)

data class Tasks(val list: List<Task>)

Application Business Rules

Application Business Rulesではアプリケーション固有のビジネスルールが含まれ、入出力するデータの流れを調整します。

TaskPortにインターフェイスを定義し、TaskGatewayで具象クラスを実装するようにしています。TaskUseCaseではTaskPortを呼び出すように実装しています。

・TaskPort.kt

package com.example.port

import com.example.domain.Task
import com.example.domain.TaskId
import com.example.domain.Tasks

interface TaskPort {
  fun getTasks(): Tasks
  fun getTask(taskId: TaskId): Task
}

・TaskUseCase.kt

package com.example.usecase

import com.example.domain.Task
import com.example.domain.TaskId
import com.example.port.TaskPort
import com.example.domain.Tasks
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Component

@Component
class TaskUseCase() {
  @Autowired
  lateinit var taskPort: TaskPort

  fun getTasks(): Tasks {
    return taskPort.getTasks()
  }

  fun getTask(taskId: TaskId): Task {
    return taskPort.getTask(taskId)
  }

}

Interface & Adapter

Interface & Adapterではドメインやユースケースに便利な形式からDBに便利な形式にデータを変換します。

TaskGatewayはTaskPortで定義したinterfaceを実装しています。またTaskDriverで取得したJSONをドメインに変換する処理をしています。

TaskControllerでは逆にドメインをレスポンスの形に変換する処理をしています。

・TaskGateway.kt

package com.example.gateway

import com.example.domain.*
import com.example.driver.TaskDriver
import com.example.driver.TaskJson
import com.example.driver.TasksJson
import com.example.port.TaskPort
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Component

@Component
class TaskGateway: TaskPort {
  @Autowired
  lateinit var taskDriver: TaskDriver

  override fun getTasks(): Tasks {
    val tasksJson: TasksJson = taskDriver.getTasks()
    return tasksJson.toTasks()
  }

  override fun getTask(taskId: TaskId): Task {
    val taskJson: TaskJson = taskDriver.getTask(taskId.value)
    return taskJson.toTask()
  }
}

fun TasksJson.toTasks(): Tasks {
  return this.list.map {
    Task(Title(it.title), Content(it.content))
  }.let(::Tasks)
}

fun TaskJson.toTask(): Task {
  return Task(Title(this.title), Content(this.content))
}

・TaskController.kt

package com.example.controller

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.RestController
import com.example.usecase.TaskUseCase
import com.example.domain.Tasks
import com.example.domain.Task
import com.example.domain.TaskId
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PathVariable

@RestController
class TaskController {
  @Autowired
  lateinit var taskUseCase: TaskUseCase

  @GetMapping(value = ["/api/tasks"])
    fun getTasks(): ResponseEntity<TasksJson> {
    return ResponseEntity.ok(taskUseCase.getTasks().toJson())
  }

  @GetMapping(value = ["/api/tasks/{taskId}"])
  fun getTask(
    @PathVariable(value = "taskId", required = true) taskId: Int
  ): ResponseEntity<TaskJson> {
    return ResponseEntity.ok(taskUseCase.getTask(TaskId(taskId)).toJson())
  }
}

data class TaskJson(val title: String, val content: String)
data class TasksJson(val tasks: List<TaskJson>)

fun Tasks.toJson() = this.list.map { it.toJson() }.let(::TasksJson)
fun Task.toJson() = TaskJson(this.title.value, this.content.value)

Framework & Driver

Framework & Driverはフレームワークやツールで構成されています。

今回はスタブでJSON形式の値を返すようにしていますが、本来ならDB操作やAPIリクエストを行う想定です。

・TaskDriver.kt

package com.example.driver

import com.fasterxml.jackson.annotation.JsonCreator
import org.springframework.stereotype.Component

@Component
class TaskDriver() {
  fun getTasks(): TasksJson {
    return TasksJson(listOf(TaskJson("title", "content"), TaskJson("title2", "content2")))
  }

  fun getTask(taskId: Int): TaskJson {
    return TaskJson("title", "content")
  }
}

data class TasksJson @JsonCreator constructor(
  val list: List<TaskJson>
)

data class TaskJson @JsonCreator constructor(
  val title: String,
  val content: String
)

コレクション

コレクションはたくさんの値をまとめて管理するための仕組みで、いくつかの専用の値が用意されています。

配列

arrayOf(value1, value2, …)

配列は多数の値を保管する場所が用意されており、そこに1つ1つ値が保管されます。

保管されている場所にはインデックスと呼ばれる番号が付与され、これは0から順に割り振られます。また、配列の変数の後に.sizeをつけると要素数が取得できます。

配列の問題点

配列の欠点として型の異なる値を保管できないことが挙げられます。

また、配列は基本的に最初に用意した要素しか使えないようになっています。以下の例のように配列に新しい要素を追加することは基本的にできません。

ex)
var sampleArray = arrayOf(1, 2, 3, 4, 5)
sampleArray[5] = 6 // エラー

リスト

異なる値をひとまとめたり、要素を追加や削除をするにはリストを使います。

リストは配列と同じように多数の値を1つにまとめ、インデックスで整理します。このリストには「List」と「MutableList」の2種類があります。

ListとMutableListの違いは、リストの書き換えが可能かどうかの違いです。

Mutableとは「可変な」という意味で、MutableListは要素の追加や削除、入れ替えなどができます。一方、Listは読み取り専用で要素を変更することができません。

Listの作成

listOf(value1, value2, …)

MutableListの作成

mutableListOf(value1, value2, …)

マップ

マップは保管する値にキーというラベルをつけて保管します。このマップもリストと同様、値の変更ができない定数扱いの「Map」と変更できる「MutableMap」が用意されています。

マップにはインデックスがないため、リストのように作成した順番に値を取り出すということができません。

Mapの作成

mapOf(key1 to valu1, key1 to value2, …)

MutableMapの作成

mutableMapOf(key1 to valu1, key1 to value2, …)

セット

セットは集合を扱う値で、集合のため同じ値は複数存在できません。また、値に順番などもありません。

これも変更できない定数としての「Set」と変更可能な「MutableSet」が用意されています。

Setの作成

setOf(valu1, value2, …)

MutableSetの作成

mutableSetOf(value1, value2, …)

ジェネリック(総称型)

コレクション関係の値を用意する際に、この方の値だけ入れられるということを設定できる仕組みがジェネリックと呼ばれるものです。

これは、値を作成する際に<>記号を使って型を指定します。以下のように<型>とつけることで、そのコレクション内に指定された型の値しか保管できなくなります。

変数 = listOf<型>()

クラスのコンストラクタ

プライマリコンストラクタ

インスタンスを作成する際に使用する引数は、クラス定義に引数を用意しておくことで利用できるようになります。この引数はプライマリコンストラクタと呼ばれ、その名の通りインスタンスをコンストラクタするためのものです。

class 名前 (arg1, arg2, …)

initメソッド

initメソッドでクラスに初期化処理を用意して処理させることができます。このinit内で、クラスの引数に用意された値などを元に初期化の処理をします。

init { 初期化処理 }

ex)

class Person(name: String=”no name”, address: String=”no address”) {
  var name: String
  var address: String

  init {
    this.name = name
    this.address = address
  }

  fun say() = “Name: ” + name + “, Address: “ + address
}

プライマリコンストラクタの引数をプロパティに代入するだけならinitメソッドを使わなくとも行うことができます。値をプロパティに代入するだけで他に何も処理を行わないなら以下のように直接代入した方が簡単にできます。

ex)

class Person(name: String=”no name”, address: String=”no address”) {
  var name = name
  var address = address

  fun say() = “Name: ” + name + “, Address: “ + address
}

constructorメソッド(セカンダリコンストラクタ)

プライマリコンストラクタよりもっと柔軟に引数を用意できる仕組みがconstructorメソッドです。このconstructorはセカンダリコンストラクタと呼ばれ、使用するにはプライマリコンストラクタ(クラス宣言の引数とinit)は使えません。

constructor(args) { … }

ex)
class Person {
  var name: String
  var address: String

  constructor(name: String=”no name”, address: String=”no address”) {
    this.name = name
    this.address = address
  }

  constructor(arr: Map<String, String>) {
    this.name = arr[“name”] ?: “no name”
    this.address = arr[“address”] ?: “no address”
  }

  fun say() = “Name: ” + name + “, Address: “ + address
}

事前準備

• VSCodeのインストール
• JDKのインストール

Kotlinとは

Kotlinは、Javaの統合開発環境であるIntelliJ IDEAで有名なJetBrainsが開発したオブジェクト指向プログラミング言語です。言語構文自体はJavaとは互換性がない独自方式ですが、コンパイルされたコードはJava VM（仮想マシン）上で動作します。

2017年にAndroid公式開発言語に追加されたことで、知名度が上がりました。

Kotlinの特徴

Javaと互換性がある

KotlinとはJavaと互換性があり、KotlinからJavaを呼び出すことも、JavaからKotlinを呼び出すこともできます。

汎用性

Kotlinは、Javaをより安全に記述できることを目的として改良されており、高い汎用性をがある言語です。

またJavaを簡潔に記述できるようにコードがシンプルになっているため、短いコードで記述でき、開発時の負担が軽減されています。

安全性

もともと産業利用を目的とした汎用言語として開発された言語なので、コードが簡潔でバグを発生させにくい構造になっています。

また、KotlinにはNull Safetyがあり、Javaの場合に発生しがちなNull参照を原因とする実行時エラーを防ぐことができるため、安全なシステム開発ができます。

Spring Bootとは

Spring BootはJavaによるWebアプリ開発を迅速かつ効率的にする仕組みを備えたフレームワークのことです。

Spring Frameworkとの関係

Spring Frameworkは現在に至るまで様々な機能拡張がされており、豊富な機能が充実する一方で、組み合わせて使うには煩雑な設定とノウハウが必要という課題も指摘されるようになりました。

この課題に取り組み、最小限の設定とより少ないコード量でアプリケーションを作成して、すぐに実行できる仕組みを実装したのがSpring Bootです。

そのため、Spring BootもSpring Frameworkをベースとするフレームワークの1つです。

JVMとは

KotlinはJVM言語ですが、そもそもJVMについて何なのか整理します。

JVMとは「Java Virtual Machine」の略でJavaで作成されたアプリケーションを各OSで動かすために必要となるアプリケーションです。Java仮想マシンなどとも呼ばれます。

Javaで作成したプログラムをコンパイルすると中間コードと呼ばれるJavaクラスファイルを出力します。JavaクラスファイルはどのOS上でコンパイルしても同じものが生成され、実行したいOSにインストールされているJVM上で実行されます。

JavaクラスファイルがOSに関わらず共通なのに、それぞれのOSで問題なく動さするのはそれぞれのOS用のJVMがJavaクラスファイルを対象のOSで動作するように変換して実行してくれるからです。

JDKとは

JDKとははJVM・Javaコンパイラ・ライブラリ等のJavaの開発に必要な物のセットです。Java開発環境などと呼ばれます。

Kotlinのコードだけを実行するだけなら、KotlinのコンパイラとJVMがあれば動きますが、Javaのライブラリを使ったりすることがあるため、JDKを入れておくと良いでしょう。

jarファイルとは

jarとはJava Archiveの略です。その名の通りJavaのファイルがひとつにまとめられ、アプリケーションとして使えるようになったファイルのことです。

コンパイルされた複数のclassファイルやプログラムが使用する画像などはすべてjarファイルの中に入っています。複数のjavaファイルが圧縮されてひとまとめになったものをjarファイルといいます。

Gradleとは

javaのビルドツールで jarファイルへのビルドをしてくれます。mavenと違い設定ファイルはgrovyという言語で書きます。

Spring Bootのプロジェクト作成

以下の2つの方法でSpring Bootのプロジェクトテンプレートを作成できます。

1. https://start.spring.io/
2. VSCodeの拡張機能を使う

今回はspring initializerを使って作成しました。以下のように設定し「GENERATE」を押すことでテンプレートを生成できます。

Dependenciesは以下の2つを選択しました。

1. Spring Web: Webアプリ作成に必要な依存関係定義のセット
2. Thymleaf: テンプレートエンジン

VSCodeで生成したテンプレートを開きます。

タスクの実行をするため、.vscode/tasks.jsonを生成し、以下を貼り付けます。

・tasks.json

<code>{
  // See https://go.microsoft.com/fwlink/?LinkId=733558
  // for the documentation about the tasks.json format
  "version": "2.0.0",
  "tasks": [
    {
      "label": "build",
      "type": "shell",
      "command": "./gradlew build"
    },
    {
      "label": "run",
      "type": "shell",
      "command": "./gradlew bootRun",
    },
    {
      "label": "clean",
      "type": "shell",
      "command": "./gradlew clean"
    },
    {
      "label": "check",
      "type": "shell",
      "command": "./gradlew check"
    }
  ]
}</code>

「ターミナル」→「タスクの実行」から「Run」を選択します。以下のように正常に起動すれば完了です。

<code>&gt; Executing task: ./gradlew bootRun &lt;

&gt; Task :bootRun

. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.5.2)</code>

build.gradleがある階層でこのコマンドを実行するとbuildが実行され、build/libs/の下にjarファイルが生成されます。

$ gradlew build

生成されたファイルを以下のコマンドで実行すると、localhost:8080でページにアクセスすることができます。

$ java -jar build/libs/hoge-0.0.1-SNAPSHOT.jar

Hello Worldしてみる

HelloWorld.ktを作成し、localhost:8080にきたら「Hello World」と表示するようにします。「GetMapping」や「RestController」を使うにはSpring WebをDependenciesで選択しておく必要があります。

・HelloWorld.kt

import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController

@RestController
  class HelloController {
  @GetMapping("/")
  fun helloWorld(): String {
    return "Hello World"
  }
}

サーバを起動させてlocalhost:8080にアクセスし、「Hello World」と表示されれば成功です。