ReactとKotlin/JSでWebアプリケーションを構築する — チュートリアル
このチュートリアルでは、Kotlin/JSとReactフレームワークを使用してブラウザアプリケーションを構築する方法を学びます。内容は以下の通りです:
- 一般的なReactアプリケーションの構築に伴う典型的なタスクを完了する。
- 可読性を損なうことなく概念を簡潔かつ統一的に表現できるKotlinのDSLの活用法を探究し、完全にKotlinだけで本格的なアプリケーションを作成できるようにする。
- 既存のnpmコンポーネントの利用方法、外部ライブラリの使い方、そして完成したアプリケーションの公開方法を学ぶ。
成果物は、KotlinConfカンファレンスのトークへのリンクを備えた専用のWebアプリ「KotlinConf Explorer」です。ユーザーは1つのページですべてのトークを視聴し、視聴済みか未視聴かをマークできます。
このチュートリアルは、Kotlinの既有知識、およびHTMLとCSSの基本的な知識があることを前提としています。Reactの基本概念を理解していると一部のサンプルコードを理解しやすくなりますが、必須ではありません。
完成したアプリケーションはこちらから入手できます。
始める前に
最新バージョンのIntelliJ IDEAをダウンロードしてインストールします。
プロジェクトテンプレートをクローンし、IntelliJ IDEAで開きます。テンプレートには、必要なすべての設定と依存関係が含まれた基本的なKotlin Multiplatform Gradleプロジェクトが含まれています。
build.gradle.ktsファイル内の依存関係とタスク:
kotlindependencies { // React, React DOM + Wrappers implementation(enforcedPlatform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:1.0.0-pre.430")) implementation("org.jetbrains.kotlin-wrappers:kotlin-react") implementation("org.jetbrains.kotlin-wrappers:kotlin-react-dom") // Kotlin React Emotion (CSS) implementation("org.jetbrains.kotlin-wrappers:kotlin-emotion") // Video Player implementation(npm("react-player", "^2.12.0")) // Share Buttons implementation(npm("react-share", "^4.4.1")) // Coroutines & serialization implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4") implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0") }- このチュートリアルで使用するJavaScriptコードを挿入するための、
src/jsMain/resources/index.htmlにあるHTMLテンプレートページ:
html<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Hello, Kotlin/JS!</title> </head> <body> <div id="root"></div> <script src="confexplorer.js"></script> </body> </html>Kotlin/JSプロジェクトをビルドすると、すべてのコードとその依存関係が、プロジェクトと同じ名前を持つ単一のJavaScriptファイル(
confexplorer.js)に自動的にバンドルされます。一般的なJavaScriptの慣例に従い、スクリプトの前にブラウザがすべてのページ要素を読み込めるよう、bodyのコンテンツ(rootdivを含む)が最初に読み込まれます。
src/jsMain/kotlin/Main.ktのコードスニペット:kotlinimport kotlinx.browser.document fun main() { document.bgColor = "red" }
開発サーバーの実行
デフォルトで、Kotlin Multiplatform Gradleプラグインには組み込みのwebpack-dev-serverのサポートが付属しているため、サーバーを手動で設定することなくIDEからアプリケーションを実行できます。
プログラムがブラウザで正常に動作することをテストするには、IntelliJ IDEA内のGradleツールウィンドウからrunまたはbrowserDevelopmentRunタスク(otherまたはkotlin browserディレクトリ内にあります)を呼び出して開発サーバーを起動します:

ターミナルからプログラムを実行する場合は、代わりに./gradlew runを使用します。
プロジェクトがコンパイルおよびバンドルされると、ブラウザウィンドウに空白の赤いページが表示されます:

ホットリロード/継続モードの有効化
変更を加えるたびに手動でプロジェクトをコンパイルして実行しなくても済むように、_継続的コンパイル(continuous compilation)_モードを設定します。作業を進める前に、実行中の開発サーバーインスタンスをすべて停止してください。
初回にGradleの
runタスクを実行した後にIntelliJ IDEAが自動生成した実行構成(Run configuration)を編集します:
Run/Debug Configurationsダイアログで、実行構成の引数(arguments)に
--continuousオプションを追加します:
変更を適用した後、IntelliJ IDEA内のRunボタンを使用して開発サーバーを再起動できます。ターミナルから継続的なGradleビルドを実行する場合は、代わりに
./gradlew run --continuousを使用します。この機能をテストするために、Gradleタスクが実行されている状態で
Main.ktファイル内のページの色を青に変更します:kotlindocument.bgColor = "blue"プロジェクトが再コンパイルされ、リロード後にブラウザページが新しい色になります。
開発プロセス中は、開発サーバーを継続モードで実行したままにしておくことができます。変更を加えると、自動的にページがリビルドおよびリロードされます。
この時点のプロジェクトの状態は、masterブランチのこちらで確認できます。
Webアプリの下書きを作成する
Reactで最初の静的ページを追加する
アプリにシンプルなメッセージを表示させるには、Main.ktファイルのコードを以下のように置き換えます:
import kotlinx.browser.document
import react.*
import emotion.react.css
import csstype.Position
import csstype.px
import react.dom.html.ReactHTML.h1
import react.dom.html.ReactHTML.h3
import react.dom.html.ReactHTML.div
import react.dom.html.ReactHTML.p
import react.dom.html.ReactHTML.img
import react.dom.client.createRoot
import kotlinx.serialization.Serializable
fun main() {
val container = document.getElementById("root") ?: error("Couldn't find root container!")
createRoot(container).render(Fragment.create {
h1 {
+"Hello, React+Kotlin/JS!"
}
})
}render()関数は、kotlin-react-domに対して、フラグメント(fragment)内の最初のHTML要素をroot要素にレンダリングするよう指示します。この要素は、テンプレートに含まれているsrc/jsMain/resources/index.htmlで定義されたコンテナです。- コンテンツは
<h1>ヘッダーであり、HTMLをレンダリングするために型安全なDSLを使用しています。 h1はラムダパラメータを受け取る関数です。文字列リテラルの前に+記号を追加すると、実際には演算子オーバーロードを使用してunaryPlus()関数が呼び出されます。これにより、囲んでいるHTML要素に文字列が追加されます。
プロジェクトが再コンパイルされると、ブラウザに次のHTMLページが表示されます:

HTMLをKotlinの型安全なHTML DSLに変換する
React用のKotlin ラッパー(wrappers)には、純粋なKotlinコードでHTMLを記述できるようにするドメイン特化言語(DSL)が付属しています。この点において、JavaScriptのJSXに似ています。ただし、マークアップがKotlinであるため、自動補完や型チェックなど、静的型付け言語のすべての利点が得られます。
将来のWebアプリ用のクラシックなHTMLコードと、それに対応するKotlinの型安全なバリアントを比較してみてください:
<h1>KotlinConf Explorer</h1>
<div>
<h3>Videos to watch</h3>
<p>John Doe: Building and breaking things</p>
<p>Jane Smith: The development process</p>
<p>Matt Miller: The Web 7.0</p>
<h3>Videos watched</h3>
<p>Tom Jerry: Mouseless development</p>
</div>
<div>
<h3>John Doe: Building and breaking things</h3>
<img src="https://via.placeholder.com/640x360.png?text=Video+Player+Placeholder">
</div>h1 {
+"KotlinConf Explorer"
}
div {
h3 {
+"Videos to watch"
}
p {
+ "John Doe: Building and breaking things"
}
p {
+"Jane Smith: The development process"
}
p {
+"Matt Miller: The Web 7.0"
}
h3 {
+"Videos watched"
}
p {
+"Tom Jerry: Mouseless development"
}
}
div {
h3 {
+"John Doe: Building and breaking things"
}
img {
src = "https://via.placeholder.com/640x360.png?text=Video+Player+Placeholder"
}
}Kotlinコードをコピーし、main()関数内のFragment.create()関数呼び出しを更新して、先ほどのh1タグを置き換えます。
ブラウザがリロードされるのを待ちます。ページは以下のようになるはずです:

マークアップ内でKotlin構文を使用して動画を追加する
このDSLを使用してKotlinでHTMLを記述することには、いくつかの利点があります。ループ、条件分岐、コレクション、文字列補間などの通常のKotlin構文を使用してアプリを操作できます。
これで、ハードコードされた動画リストをKotlinオブジェクトのリストに置き換えることができます:
Main.ktに、すべての動画属性を1か所に保持するためのVideoデータクラスを作成します:kotlindata class Video( val id: Int, val title: String, val speaker: String, val videoUrl: String )未視聴の動画用と視聴済みの動画用の2つのリストをそれぞれ作成します。
Main.ktのファイルレベルにこれらの宣言を追加します:kotlinval unwatchedVideos = listOf( Video(1, "Opening Keynote", "Andrey Breslav", "https://youtu.be/PsaFVLr8t4E"), Video(2, "Dissecting the stdlib", "Huyen Tue Dao", "https://youtu.be/Fzt_9I733Yg"), Video(3, "Kotlin and Spring Boot", "Nicolas Frankel", "https://youtu.be/pSiZVAeReeg") ) val watchedVideos = listOf( Video(4, "Creating Internal DSLs in Kotlin", "Venkat Subramaniam", "https://youtu.be/JzTeAM8N1-o") )ページ上でこれらの動画を使用するために、Kotlinの
forループを記述して未視聴のVideoオブジェクトのコレクションを反復処理します。「Videos to watch」の下にある3つのpタグを次のスニペットに置き換えます:kotlinfor (video in unwatchedVideos) { p { +"${video.speaker}: ${video.title}" } }同様の手順で、「Videos watched」に続く単一のタグのコードも変更します:
kotlinfor (video in watchedVideos) { p { +"${video.speaker}: ${video.title}" } }
ブラウザがリロードされるのを待ちます。レイアウトは以前と同じままのはずです。リストに動画をさらに追加して、ループが機能していることを確認できます。
型安全なCSSでスタイルを追加する
Emotionライブラリ用のkotlin-emotionラッパーを使用すると、HTMLとJavaScriptのすぐ隣でCSS属性(動的な属性も含む)を指定できます。概念的には、CSS-in-JSのKotlin版のようなものです。DSLを使用する利点は、Kotlinコードの構文を使用してフォーマットルールを表現できる点です。
このチュートリアルのテンプレートプロジェクトには、kotlin-emotionを使用するために必要な依存関係がすでに含まれています:
dependencies {
// ...
// Kotlin React Emotion (CSS) (chapter 3)
implementation("org.jetbrains.kotlin-wrappers:kotlin-emotion")
// ...
}kotlin-emotionを使用すると、HTML要素のdivやh3の中にcssブロックを指定し、そこでスタイルを定義できます。
動画プレーヤーをページの右上隅に移動するには、CSSを使用して動画プレーヤーのコード(スニペット内の最後のdiv)を調整します:
div {
css {
position = Position.absolute
top = 10.px
right = 10.px
}
h3 {
+"John Doe: Building and breaking things"
}
img {
src = "https://via.placeholder.com/640x360.png?text=Video+Player+Placeholder"
}
}他のスタイルも自由に試してみてください。例えば、fontFamilyを変更したり、UIにcolorを追加したりできます。
アプリコンポーネントを設計する
Reactの基本的な構成要素は_コンポーネント(components)_と呼ばれます。コンポーネント自体を他のより小さなコンポーネントで構成することもできます。コンポーネントを組み合わせることで、アプリケーションを構築します。汎用的で再利用可能なようにコンポーネントを構造化すれば、コードやロジックを重複させることなく、アプリの複数の部分でそれらを再利用できます。
通常、render()関数の内容は基本的なコンポーネントを表します。現在のアプリケーションのレイアウトは次のようになっています:

アプリケーションを個別のコンポーネントに分解すると、各コンポーネントが自身の責任を処理する、より構造化されたレイアウトになります:

コンポーネントは特定の機能をカプセル化します。コンポーネントを使用することでソースコードが短くなり、読みやすく理解しやすくなります。
メインコンポーネントを追加する
アプリケーションの構造を作成し始めるために、まずはroot要素にレンダリングするためのメインコンポーネントであるAppを明示的に指定します:
src/jsMain/kotlinフォルダに新しいApp.ktファイルを作成します。このファイル内に次のスニペットを追加し、
Main.ktから型安全なHTMLをその中に移動します:kotlinimport kotlinx.coroutines.async import react.* import react.dom.* import kotlinx.browser.window import kotlinx.coroutines.* import kotlinx.serialization.decodeFromString import kotlinx.serialization.json.Json import emotion.react.css import csstype.Position import csstype.px import react.dom.html.ReactHTML.h1 import react.dom.html.ReactHTML.h3 import react.dom.html.ReactHTML.div import react.dom.html.ReactHTML.p import react.dom.html.ReactHTML.img val App = FC<Props> { // 最初のh1タグから始まる型安全なHTMLをここに配置します! }FC関数は関数コンポーネント(function component)を作成します。Main.ktファイルで、main()関数を以下のように更新します:kotlinfun main() { val container = document.getElementById("root") ?: error("Couldn't find root container!") createRoot(container).render(App.create()) }これで、プログラムは
Appコンポーネントのインスタンスを作成し、指定されたコンテナにレンダリングします。
Reactの概念の詳細については、ドキュメントとガイドを参照してください。
リストコンポーネントを抽出する
watchedVideosとunwatchedVideosのリストにはそれぞれ動画のリストが含まれているため、単一の再利用可能なコンポーネントを作成し、リストに表示されるコンテンツのみを調整するのが合理的です。
VideoListコンポーネントはAppコンポーネントと同じパターンに従います。FCビルダー関数を使用し、unwatchedVideosリストのコードを含めます。
src/jsMain/kotlinフォルダに新しいVideoList.ktファイルを作成し、次のコードを追加します:kotlinimport kotlinx.browser.window import react.* import react.dom.* import react.dom.html.ReactHTML.p val VideoList = FC<Props> { for (video in unwatchedVideos) { p { +"${video.speaker}: ${video.title}" } } }App.ktで、パラメータなしで呼び出すことでVideoListコンポーネントを使用します:kotlin// . . . div { h3 { +"Videos to watch" } VideoList() h3 { +"Videos watched" } VideoList() } // . . .現時点では、
AppコンポーネントはVideoListコンポーネントによって表示されるコンテンツを制御できません。ハードコードされているため、同じリストが2回表示されます。
コンポーネント間でデータを渡すためのpropsを追加する
VideoListコンポーネントを再利用するため、異なるコンテンツを渡せるようにする必要があります。コンポーネントへの属性としてアイテムのリストを渡す機能を追加できます。Reactでは、これらの属性は_props_と呼ばれます。Reactでコンポーネントのpropsが変更されると、フレームワークは自動的にそのコンポーネントを再レンダリングします。
VideoListには、表示する動画のリストを含むpropが必要です。VideoListコンポーネントに渡すことができるすべてのpropsを保持するインターフェースを定義します:
VideoList.ktファイルに次の定義を追加します:kotlinexternal interface VideoListProps : Props { var videos: List<Video> }external修飾子は、インターフェースの実装が外部から提供されることをコンパイラに伝えるため、宣言からJavaScriptコードを生成しようとしません。
FCブロックにパラメータとして渡されるpropsを使用するように、VideoListのクラス定義を調整します:kotlinval VideoList = FC<VideoListProps> { props -> for (video in props.videos) { p { key = video.id.toString() +"${video.speaker}: ${video.title}" } } }key属性は、props.videosの値が変更されたときに何をすべきかをReactレンダラーが判断するのに役立ちます。リストのどの部分を更新する必要があり、どの部分がそのまま残るかを決定するためにキーを使用します。リストとキーの詳細については、Reactガイドを参照してください。Appコンポーネントで、子コンポーネントが適切な属性でインスタンス化されていることを確認します。App.ktで、h3要素の下にある2つのループを、unwatchedVideosおよびwatchedVideosの属性を付けたVideoListの呼び出しに置き換えます。 Kotlin DSLでは、VideoListコンポーネントに属するブロック内でそれらを割り当てます:kotlinh3 { +"Videos to watch" } VideoList { videos = unwatchedVideos } h3 { +"Videos watched" } VideoList { videos = watchedVideos }
リロード後、ブラウザでリストが正しくレンダリングされていることが確認できます。
リストに対話性を持たせる
まず、ユーザーがリストのエントリをクリックしたときにポップアップするアラートメッセージを追加します。VideoList.ktで、現在の動画でアラートをトリガーするonClickハンドラー関数を追加します:
// . . .
p {
key = video.id.toString()
onClick = {
window.alert("Clicked $video!")
}
+"${video.speaker}: ${video.title}"
}
// . . .ブラウザウィンドウでリストアイテムの1つをクリックすると、次のようなアラートウィンドウで動画に関する情報が表示されます:

onClick関数をラムダとして直接定義することは簡潔であり、プロトタイピングに非常に便利です。ただし、Kotlin/JSにおける同等性(equality)の現在の仕組みのため、パフォーマンスの観点からはクリックハンドラーを渡す最適な方法ではありません。レンダリングパフォーマンスを最適化したい場合は、関数を変数に格納して渡すことを検討してください。
値を保持するためのstateを追加する
単にユーザーにアラートを出すだけでなく、選択された動画を▶の三角形でハイライトする機能を追加できます。それを行うには、このコンポーネント固有の_state(状態)_を導入します。
StateはReactのコアコンセプトの1つです。モダンReact(いわゆる_Hooks API_を使用するもの)では、stateはuseStateフックを使用して表現されます。
VideoListの宣言の先頭に次のコードを追加します:kotlinval VideoList = FC<VideoListProps> { props -> var selectedVideo: Video? by useState(null) // . . .VideoList関数コンポーネントはstate(現在の関数呼び出しから独立した値)を保持します。Stateはnull許容であり、Video?型を持ちます。デフォルト値はnullです。- Reactの
useState()関数は、関数の複数の呼び出しにわたってstateを追跡するようフレームワークに指示します。例えば、デフォルト値を指定した場合でも、Reactはそのデフォルト値が最初にのみ割り当てられるようにします。stateが変化すると、コンポーネントは新しいstateに基づいて再レンダリングされます。 byキーワードは、useState()が委譲プロパティ(delegated property)として機能することを示します。他の変数と同様に、値の読み取りと書き込みが可能です。useState()の背後にある実装が、stateを機能させるために必要な仕組みを処理します。
Stateフックの詳細については、Reactドキュメントを確認してください。
VideoListコンポーネント内のonClickハンドラーとテキストを次のように変更します:kotlinval VideoList = FC<VideoListProps> { props -> var selectedVideo: Video? by useState(null) for (video in props.videos) { p { key = video.id.toString() onClick = { selectedVideo = video } if (video == selectedVideo) { +"▶ " } +"${video.speaker}: ${video.title}" } } }- ユーザーが動画をクリックすると、その値が
selectedVideo変数に割り当てられます。 - 選択されたリストエントリがレンダリングされる際、先頭に三角形が付加されます。
- ユーザーが動画をクリックすると、その値が
状態管理の詳細については、React FAQを参照してください。
ブラウザを確認し、リスト内のアイテムをクリックして、すべてが正しく機能していることを確認します。
コンポーネントを合成する
現在のところ、2つの動画リストはそれぞれ独立して動作しており、各リストが選択された動画を追跡しています。プレーヤーは1つしかないにもかかわらず、未視聴リストで1つ、視聴済みリストで1つの計2つの動画を選択できてしまいます:

リスト自身の中と兄弟(sibling)リストの中の両方でどの動画が選択されているかを、単一のリスト側で追跡することはできません。選択された動画は_リスト_のstateではなく、_アプリケーション_のstateの一部であるためです。つまり、個々のコンポーネントからstateを_リフトアップ(引き上げ)_する必要があります。
Stateのリフトアップ
Reactでは、propsは親コンポーネントからその子コンポーネントにのみ渡せるようになっています。これにより、コンポーネント同士が密結合することを防ぎます。
コンポーネントが兄弟コンポーネントのstateを変更したい場合は、親コンポーネントを経由して行う必要があります。その時点で、stateはいずれの子コンポーネントにも属さず、それらを統括する親コンポーネントに属するようになります。
コンポーネントからその親へとstateを移行するプロセスは、_stateのリフトアップ(lifting state / 状態の引き上げ)_と呼ばれます。このアプリのために、AppコンポーネントにstateとしてcurrentVideoを追加します:
App.ktで、Appコンポーネントの定義の先頭に以下を追加します:kotlinval App = FC<Props> { var currentVideo: Video? by useState(null) // . . . }VideoListコンポーネントは、stateを追跡する必要がなくなりました。代わりに現在の動画をpropとして受け取ります。VideoList.kt内のuseState()呼び出しを削除します。VideoListコンポーネントが選択された動画をpropとして受け取れるように準備します。そのために、VideoListPropsインターフェースを拡張してselectedVideoを含めます:kotlinexternal interface VideoListProps : Props { var videos: List<Video> var selectedVideo: Video? }三角形の条件を変更し、
stateの代わりにpropsを使用するようにします:kotlinif (video == props.selectedVideo) { +"▶ " }
ハンドラーを渡す
現時点ではpropに値を代入する方法がないため、onClick関数は現在の設定のままでは機能しません。親コンポーネントのstateを変更するには、再度stateをリフトアップする必要があります。
Reactでは、stateは常に親から子へと流れます。そのため、子コンポーネントの1つから_アプリケーション_のstateを変更するには、ユーザー操作を処理するロジックを親コンポーネントに移動し、そのロジックをpropとして渡す必要があります。Kotlinでは、変数が関数型を持つことができることを思い出してください。
VideoListPropsインターフェースを再度拡張し、Videoを受け取ってUnitを返す関数である変数onSelectVideoを含めます:kotlinexternal interface VideoListProps : Props { // ... var onSelectVideo: (Video) -> Unit }VideoListコンポーネントで、onClickハンドラー内で新しいpropを使用します:kotlinonClick = { props.onSelectVideo(video) }これで、
VideoListコンポーネントからselectedVideo変数を削除できます。Appコンポーネントに戻り、2つの動画リストのそれぞれに対してselectedVideoとonSelectVideoのハンドラーを渡します:kotlinVideoList { videos = unwatchedVideos // および watchedVideos selectedVideo = currentVideo onSelectVideo = { video -> currentVideo = video } }視聴済み動画リストに対しても前の手順を繰り返します。
ブラウザに戻り、動画を選択したときに、選択が重複することなく2つのリスト間を移動することを確認します。
コンポーネントを追加する
動画プレーヤーコンポーネントを抽出する
これで、現在はプレースホルダー画像となっている動画プレーヤーという、別の自己完結型コンポーネントを作成できます。動画プレーヤーは、トークのタイトル、トークの著者、および動画へのリンクを把握する必要があります。この情報は各Videoオブジェクトにすでに含まれているため、propとして渡してその属性にアクセスできます。
新しい
VideoPlayer.ktファイルを作成し、VideoPlayerコンポーネントの次の実装を追加します:kotlinimport csstype.* import react.* import emotion.react.css import react.dom.html.ReactHTML.button import react.dom.html.ReactHTML.div import react.dom.html.ReactHTML.h3 import react.dom.html.ReactHTML.img external interface VideoPlayerProps : Props { var video: Video } val VideoPlayer = FC<VideoPlayerProps> { props -> div { css { position = Position.absolute top = 10.px right = 10.px } h3 { +"${props.video.speaker}: ${props.video.title}" } img { src = "https://via.placeholder.com/640x360.png?text=Video+Player+Placeholder" } } }VideoPlayerPropsインターフェースはVideoPlayerコンポーネントがnull非許容のVideoを受け取ることを指定しているため、Appコンポーネントでこれに応じた処理を行うようにします。App.ktで、動画プレーヤー用の以前のdivスニペットを次のように置き換えます:kotlincurrentVideo?.let { curr -> VideoPlayer { video = curr } }letスコープ関数により、state.currentVideoがnullでない場合にのみVideoPlayerコンポーネントが追加されるようになります。
これで、リスト内のエントリをクリックすると動画プレーヤーが表示され、クリックされたエントリの情報が設定されます。
ボタンを追加して接続する
ユーザーが動画を視聴済みまたは未視聴としてマークし、2つのリスト間で移動できるようにするために、VideoPlayerコンポーネントにボタンを追加します。
このボタンは2つの異なるリスト間で動画を移動させるため、状態変更を処理するロジックをVideoPlayerから_リフトアップ_し、親からpropとして渡す必要があります。動画が視聴済みかどうかに基づいてボタンの見た目を変える必要があります。これもpropとして渡す必要がある情報です。
VideoPlayer.ktのVideoPlayerPropsインターフェースを拡張して、これら2つのケース用のプロパティを含めます:kotlinexternal interface VideoPlayerProps : Props { var video: Video var onWatchedButtonPressed: (Video) -> Unit var unwatchedVideo: Boolean }これで、実際のコンポーネントにボタンを追加できます。
VideoPlayerコンポーネントの本文(body)のh3タグとimgタグの間に、次のスニペットをコピーします:kotlinbutton { css { display = Display.block backgroundColor = if (props.unwatchedVideo) NamedColor.lightgreen else NamedColor.red } onClick = { props.onWatchedButtonPressed(props.video) } if (props.unwatchedVideo) { +"Mark as watched" } else { +"Mark as unwatched" } }スタイルを動的に変更できるKotlin CSS DSLを利用して、基本的なKotlinの
if式を使用することでボタンの色を変更できます。
動画リストをアプリケーションのstateに移動する
次に、AppコンポーネントにおけるVideoPlayerの使用箇所を調整します。ボタンがクリックされたら、未視聴リストから視聴済みリストへ、またはその逆へと動画を移動させる必要があります。これらのリストが実際に変更可能になったため、それらをアプリケーションのstateに移動します:
App.ktで、Appコンポーネントの先頭にuseState()呼び出しを含む以下のプロパティを追加します:kotlinval App = FC<Props> { var currentVideo: Video? by useState(null) var unwatchedVideos: List<Video> by useState(listOf( Video(1, "Opening Keynote", "Andrey Breslav", "https://youtu.be/PsaFVLr8t4E"), Video(2, "Dissecting the stdlib", "Huyen Tue Dao", "https://youtu.be/Fzt_9I733Yg"), Video(3, "Kotlin and Spring Boot", "Nicolas Frankel", "https://youtu.be/pSiZVAeReeg") )) var watchedVideos: List<Video> by useState(listOf( Video(4, "Creating Internal DSLs in Kotlin", "Venkat Subramaniam", "https://youtu.be/JzTeAM8N1-o") )) // . . . }すべてのデモデータが
watchedVideosおよびunwatchedVideosのデフォルト値に直接含まれるようになったため、ファイルレベルの宣言は不要になりました。Main.ktから、watchedVideosおよびunwatchedVideosの宣言を削除します。動画プレーヤーに属する
Appコンポーネント内のVideoPlayerの呼び出し箇所を次のように変更します:kotlinVideoPlayer { video = curr unwatchedVideo = curr in unwatchedVideos onWatchedButtonPressed = { if (video in unwatchedVideos) { unwatchedVideos = unwatchedVideos - video watchedVideos = watchedVideos + video } else { watchedVideos = watchedVideos - video unwatchedVideos = unwatchedVideos + video } } }
ブラウザに戻り、動画を選択してボタンを数回押してみてください。動画が2つのリスト間を行き来します。
npmパッケージを使用する
アプリを実用的なものにするには、実際に動画を再生する動画プレーヤーと、コンテンツを共有するためのボタンがまだ必要です。
Reactには豊富なエコシステムがあり、この機能を自作する代わりに使用できる既製のコンポーネントが多数存在します。
動画プレーヤーコンポーネントを追加する
プレースホルダーの動画コンポーネントを実際のYouTubeプレーヤーに置き換えるには、npmのreact-playerパッケージを使用します。動画を再生でき、プレーヤーの外観を制御できます。
コンポーネントのドキュメントとAPIの説明については、GitHubのREADMEを参照してください。
build.gradle.ktsファイルを確認します。react-playerパッケージはすでに含まれているはずです:kotlindependencies { // ... // Video Player implementation(npm("react-player", "^2.12.0")) // ... }このように、ビルドファイルの
dependenciesブロックでnpm()関数を使用することにより、Kotlin/JSプロジェクトにnpm依存関係を追加できます。その後、Gradleプラグインがこれらの依存関係のダウンロードとインストールを自動的に処理します。その際、バンドルされている独自のYarnパッケージマネージャーのインストール環境が使用されます。Reactアプリケーション内からJavaScriptパッケージを使用するには、外部宣言(external declarations)を提供して、コンパイラに何を期待すべきかを伝える必要があります。
新しい
ReactYouTube.ktファイルを作成し、次のコンテンツを追加します:kotlin@file:JsModule("react-player") @file:JsNonModule import react.* @JsName("default") external val ReactPlayer: ComponentClass<dynamic>コンパイラは
ReactPlayerのような外部宣言を見つけると、対応するクラスの実装が依存関係によって提供されていると見なし、そのためのコードを生成しません。最後の2行は、JavaScriptの
require("react-player").default;のようなインポートと同等です。これらは、コンポーネントが実行時にComponentClass<dynamic>に適合することを確信しているとコンパイラに伝えます。
ただし、この構成では、ReactPlayerが受け入れるpropsのジェネリック型がdynamicに設定されています。これは、コンパイラがあらゆるコードを受け入れることを意味し、実行時にエラーが発生するリスクがあります。
より良い代替手段は、この外部コンポーネントのpropsにどのようなプロパティが属するかを指定するexternal interfaceを作成することです。propsのインターフェースについては、コンポーネントのREADMEで確認できます。この場合、urlとcontrolsプロパティを使用します:
ReactYouTube.ktの内容を調整し、dynamicを外部インターフェースに置き換えます:kotlin@file:JsModule("react-player") @file:JsNonModule import react.* @JsName("default") external val ReactPlayer: ComponentClass<ReactPlayerProps> external interface ReactPlayerProps : Props { var url: String var controls: Boolean }これで、新しい
ReactPlayerを使用してVideoPlayerコンポーネント内の灰色のプレースホルダーの長方形を置き換えることができます。VideoPlayer.ktで、imgタグを次のスニペットに置き換えます:kotlinReactPlayer { url = props.video.videoUrl controls = true }
ソーシャル共有ボタンを追加する
アプリケーションのコンテンツを簡単に共有する方法は、メッセンジャーやメール用のソーシャル共有ボタンを配置することです。これにも既製のReactコンポーネント(例えばreact-shareなど)を使用できます:
build.gradle.ktsファイルを確認します。このnpmライブラリはすでに含まれているはずです:kotlindependencies { // ... // Share Buttons implementation(npm("react-share", "^4.4.1")) // ... }Kotlinから
react-shareを使用するには、さらに基本的な外部宣言を記述する必要があります。GitHub上のサンプルを見ると、共有ボタンは例えばEmailShareButtonとEmailIconという2つのReactコンポーネントで構成されていることがわかります。異なる種類の共有ボタンとアイコンも、すべて同じ種類のインターフェースを持っています。 動画プレーヤーに対して既に行ったのと同様の方法で、各コンポーネントの外部宣言を作成します。新しい
ReactShare.ktファイルに次のコードを追加します:kotlin@file:JsModule("react-share") @file:JsNonModule import react.ComponentClass import react.Props @JsName("EmailIcon") external val EmailIcon: ComponentClass<IconProps> @JsName("EmailShareButton") external val EmailShareButton: ComponentClass<ShareButtonProps> @JsName("TelegramIcon") external val TelegramIcon: ComponentClass<IconProps> @JsName("TelegramShareButton") external val TelegramShareButton: ComponentClass<ShareButtonProps> external interface ShareButtonProps : Props { var url: String } external interface IconProps : Props { var size: Int var round: Boolean }アプリケーションのユーザーインターフェースに新しいコンポーネントを追加します。
VideoPlayer.ktで、ReactPlayerの使用箇所のすぐ上にあるdiv内に2つの共有ボタンを追加します:kotlin// . . . div { css { position = Position.absolute top = 10.px right = 10.px } EmailShareButton { url = props.video.videoUrl EmailIcon { size = 32 round = true } } TelegramShareButton { url = props.video.videoUrl TelegramIcon { size = 32 round = true } } } // . . .
これでブラウザを確認し、ボタンが実際に機能するかどうかを確認できます。ボタンをクリックすると、動画のURLを含む_共有ウィンドウ_が表示されるはずです。ボタンが表示されない、または機能しない場合は、広告ブロッカーやソーシャルメディアブロッカーを無効にする必要があるかもしれません。

react-shareで利用可能な他のソーシャルネットワーク用の共有ボタンを使って、この手順を自由に試してみてください。
外部のREST APIを使用する
これで、アプリ内のハードコードされたデモデータをREST APIからの実際のデータに置き換えることができます。
このチュートリアル用には、小規模なAPIが用意されています。このAPIは単一のエンドポイントvideosのみを提供し、数値パラメータを受け取ってリストから要素にアクセスします。ブラウザでこのAPIにアクセスすると、APIから返されるオブジェクトがVideoオブジェクトと同じ構造を持っていることがわかります。
KotlinからJS機能を使用する
ブラウザには、すでに多様なWeb APIが備わっています。Kotlin/JSにはこれらのAPI用のラッパーが標準で含まれているため、Kotlin/JSからも使用できます。一例として、HTTPリクエストを行うために使用されるfetch APIがあります。
最初の潜在的な問題は、fetch()のようなブラウザAPIがノンブロッキング処理を実行するためにコールバック(callbacks)を使用することです。複数のコールバックを連続して実行する必要がある場合、それらをネストする必要があります。当然ながらコードのインデントが深くなり、機能が互いに積み重なっていくため、可読性が低下します。
これを克服するために、このような機能に対するより優れたアプローチであるKotlinのコルーチンを使用できます。
2つ目の問題は、JavaScriptの動的型付けの性質から生じます。外部APIから返されるデータの型については何の保証もありません。これを解決するために、kotlinx.serializationライブラリを使用できます。
build.gradle.ktsファイルを確認します。関連するスニペットはすでに存在するはずです:
dependencies {
// . . .
// Coroutines & serialization
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
}シリアライズの追加
外部APIを呼び出すと、JSON形式のテキストが返されますが、これを操作可能なKotlinオブジェクトに変換する必要があります。
kotlinx.serializationは、JSON文字列からKotlinオブジェクトへのこのような変換を記述できるようにするライブラリです。
build.gradle.ktsファイルを確認します。対応するスニペットはすでに存在するはずです:kotlinplugins { // . . . kotlin("plugin.serialization") version "2.4.21" } dependencies { // . . . // Serialization implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0") }最初の動画を取得するための準備として、シリアライズライブラリに
Videoクラスについて認識させる必要があります。Main.ktで、その定義に@Serializableアノテーションを追加します:kotlin@Serializable data class Video( val id: Int, val title: String, val speaker: String, val videoUrl: String )
動画の取得
APIから動画を取得するには、App.kt(または新しいファイル)に次の関数を追加します:
suspend fun fetchVideo(id: Int): Video {
val response = window
.fetch("https://my-json-server.typicode.com/kotlin-hands-on/kotlinconf-json/videos/$id")
.await()
.text()
.await()
return Json.decodeFromString(response)
}- _中断関数(Suspending function)_である
fetch()は、APIから特定のidを持つ動画を取得します。このレスポンスには時間がかかる可能性があるため、結果をawait()します。次に、コールバックを使用するtext()がレスポンスから本文を読み取ります。その後、その完了をawait()します。 - 関数の値を返す前に、それを
kotlinx.coroutinesの関数であるJson.decodeFromStringに渡します。これにより、リクエストから受け取ったJSONテキストが適切なフィールドを持つKotlinオブジェクトに変換されます。 window.fetch関数の呼び出しはPromiseオブジェクトを返します。通常であれば、Promiseが解決(resolve)されて結果が利用可能になった時点で呼び出されるコールバックハンドラーを定義する必要があります。しかし、コルーチンを使用すれば、それらのPromiseをawait()できます。await()のような関数が呼び出されると、メソッドはその実行を一時停止(中断)します。Promiseが解決されると、実行が再開されます。
ユーザーに動画の選択肢を提供するために、上記と同じAPIから25本の動画を取得するfetchVideos()関数を定義します。すべてのリクエストを並行して実行するために、Kotlinのコルーチンによって提供されるasync機能を使用します:
App.ktに次の実装を追加します:kotlinsuspend fun fetchVideos(): List<Video> = coroutineScope { (1..25).map { id -> async { fetchVideo(id) } }.awaitAll() }構造化並行性(structured concurrency)の原則に従い、実装は
coroutineScope内にラップされています。これにより、25個の非同期タスク(リクエストごとに1つ)を開始し、それらすべてが完了するのを待機できます。これで、アプリケーションにデータを追加できるようになりました。
mainScopeの定義を追加し、次のスニペットで始まるようにAppコンポーネントを変更します。デモ値をemptyList()インスタンスに置き換えることも忘れないでください:kotlinval mainScope = MainScope() val App = FC<Props> { var currentVideo: Video? by useState(null) var unwatchedVideos: List<Video> by useState(emptyList()) var watchedVideos: List<Video> by useState(emptyList()) useEffectOnce { mainScope.launch { unwatchedVideos = fetchVideos() } } // . . .MainScope()はKotlinの構造化並行性モデルの一部であり、非同期タスクを実行するためのスコープを作成します。useEffectOnceは別のReact _フック(hook)_です(具体的には、useEffectフックの簡略版です)。これは、コンポーネントが_副作用(side effect)_を実行することを示します。自身をレンダリングするだけでなく、ネットワーク経由の通信も行います。
ブラウザを確認します。アプリケーションに実際のデータが表示されているはずです:

ページを読み込むと:
Appコンポーネントのコードが呼び出されます。これにより、useEffectOnceブロック内のコードが開始されます。Appコンポーネントは、視聴済みおよび未視聴の動画用の空のリストでレンダリングされます。- APIリクエストが完了すると、
useEffectOnceブロックがそれをAppコンポーネントのstateに割り当てます。これにより、再レンダリングがトリガーされます。 Appコンポーネントのコードが再度呼び出されますが、useEffectOnceブロックは2回目は実行_されません_。
コルーチンの仕組みについて深く理解したい場合は、こちらのコルーチンに関するチュートリアルを参照してください。
本番環境およびクラウドへのデプロイ
いよいよアプリケーションをクラウドに公開し、他のユーザーがアクセスできるようにします。
本番ビルドのパッケージ化
本番モードですべてのアセットをパッケージ化するには、IntelliJ IDEAのツールウィンドウから、または./gradlew buildを実行して、Gradleのbuildタスクを実行します。これにより、DCE(デッドコード削除)などのさまざまな改善が適用され、最適化されたプロジェクトビルドが生成されます。
ビルドが完了すると、デプロイに必要なすべてのファイルが/build/distに見つかります。これらには、アプリケーションの実行に必要なJavaScriptファイル、HTMLファイル、およびその他のリソースが含まれています。これらを静的HTTPサーバーに配置したり、GitHub Pagesを使用して配信したり、好みのクラウドプロバイダーでホストしたりできます。
Herokuへのデプロイ
Herokuを使用すると、独自のドメインでアクセス可能なアプリケーションを非常に簡単に立ち上げることができます。開発目的であれば、無料枠で十分です。
アカウントを作成します。
プロジェクトのルートディレクトリでターミナルから次のコマンドを実行して、Gitリポジトリを作成し、Herokuアプリを紐付けます:
bashgit init heroku create git add . git commit -m "initial commit"Heroku上で動作する通常のJVMアプリケーション(例えばKtorやSpring Bootで書かれたものなど)とは異なり、このアプリは適切に配信される必要がある静的HTMLページとJavaScriptファイルを生成します。プログラムを適切に配信するために、必要なbuildpackを調整できます:
bashheroku buildpacks:set heroku/gradle heroku buildpacks:add https://github.com/heroku/heroku-buildpack-static.githeroku/gradlebuildpackが正常に実行されるためには、build.gradle.ktsファイル内にstageタスクが存在する必要があります。このタスクはbuildタスクと同等であり、対応するエイリアスがすでにファイルの末尾に含まれています:kotlin// Heroku Deployment tasks.register("stage") { dependsOn("build") }プロジェクトルートに新しい
static.jsonファイルを追加して、buildpack-staticを設定します。ファイル内に
rootプロパティを追加します:xml{ "root": "build/distributions" }これで、例えば次のコマンドを実行してデプロイをトリガーできます:
bashgit add -A git commit -m "add stage task and static content root configuration" git push heroku master
main以外のブランチからプッシュする場合は、git push heroku feature-branch:mainのように、mainリモートへプッシュするようにコマンドを調整してください。
デプロイが成功すると、インターネット上でアプリケーションにアクセスするためのURLが表示されます。

この時点のプロジェクトの状態は、finishedブランチのこちらで確認できます。
次のステップ
さらなる機能の追加
完成したアプリを出発点として、React、Kotlin/JSなどの領域におけるより高度なトピックを探求できます。
- 検索。検索フィールドを追加して、タイトルや著者などでトークのリストを絞り込めるようにします。ReactでのHTMLフォーム要素の動作について学びましょう。
- 永続化。現在のところ、ページがリロードされるたびにアプリケーションは視聴者のウォッチリストを見失ってしまいます。Kotlinで利用可能なWebフレームワーク(Ktorなど)の1つを使用して、独自のバックエンドを構築することを検討してみてください。あるいは、クライアント側に情報を保存する方法を調べてみてください。
- 複雑なAPI。多数のデータセットやAPIが利用可能です。あらゆる種類のデータをアプリケーションに取り込むことができます。例えば、猫の写真のビジュアライザーや、ロイヤリティフリーのストックフォトAPIを構築できます。
スタイルの改善:レスポンシブとグリッド
アプリケーションのデザインはまだ非常にシンプルで、モバイルデバイスや狭いウィンドウでは見栄えが良くありません。CSS DSLをさらに探求して、アプリのアクセシビリティを向上させてみてください。
コミュニティに参加してサポートを受ける
問題を報告したり支援を受けたりするための最良の方法は、kotlin-wrappers課題トラッカーです。問題に関するチケットが見つからない場合は、お気軽に新しいチケットを作成してください。また、公式のKotlin Slackに参加することもできます。#javascriptや#reactのチャンネルがあります。
コルーチンについて詳しく学ぶ
並行コードの作成方法について詳しく知りたい場合は、コルーチンに関するチュートリアルを参照してください。
Reactについて詳しく学ぶ
基本的なReactの概念と、それらがKotlinにどのように変換されるかを理解したところで、Reactのドキュメントで説明されている他の概念をKotlinに置き換えて試してみることができます。
