プロトコルとかクラスとか

プロトコル

プロトコルを学ぶにあたって、なぜプロトコルが必要なのかを理解しておく必要がある。

これに関してはこちらの記事が大変参考になりました。

::: tip

「プロトコルはクラスや構造体が実装するプロパティとメソッドの最低限の決まり事を設定する機能」とおぼえておけば良い

:::

同様の機能としてスーパークラスというものがあるが、Swift の構造体にはスーパークラスという概念がない。そのため、代わりにプロトコルを使うというわけである。

プロトコルのメリット

参考文献を見ながら自分でも確認する感じで読みすすめていきました。

実装をあとから変更できる

プロトコルは定義（プロパティ名や型）だけを指定できるので、実際そこにどんな値を入れるかはクラスや構造体ごとに変えることができる。

構造体にもつかえる

先程も述べたように Swift では構造体に対して継承ができません。

が、プロトコルであればほとんど同じようなことができます。

複数継承できる

クラスは一つしか継承できませんが、プロトコルであれば複数適用することができます。

プロトコルを考える

API と通信を行なうためには以下のような情報が必要になります。

基本 URL
- API サーバの URL
- “https://tkgling.netlify.app/api/”
パス
- “session_token”
エンドポイント
- たたく API の URL
- 基本 URL とパスの組み合わせ
- “https://tkgling.netlify.app/api/session_token”
メソッド
- POST とか GET とか PUT とか
ヘッダー
- 認証情報を入れたりとか
エンコーディング方式
- URL エンコードか JSON エンコードかパラメータエンコードか
パラメータ
- Body に入れるデータ

なのでこれらを全部プロトコルで定義してしまえばいいような気がしますが、パラメータはメソッドが GET のときには不要ですし、ライブラリ化するときには一つの API サーバに対して通信することを想定しているのですから基本 URL も不要です。

パスと基本 URL があればいいのでエンドポイントも不要ですし、ヘッダーが常に認証情報しか保たないのであればこれもやはり不要です。エンコーディング方式も「POST と PUT 以外であれば URL エンコード」というような仕様になっていれば、実際に必要なのは次の三つの情報になります。

プロトコルを書いてみる

例えば以下のようなシンプルなものを考えてみます。

単純なプロトコルのみ

1
protocol RequestType {
2
    var method: String { get }
3
    var parameters: [String: Any]? { get }
4
    var path: String { get }
5
}
6

7
class Request: RequestType {
8
    var method: String // 必須
9
    var parameters: [String : Any]? // 必須
10
    var path: String // 必須
11

12
    init(method: String, path: String, paramaters: [String: Any]? = nil) {
13
        self.method = method
14
        self.parameters = paramaters
15
        self.path = path
16
    }
17
}

そして以下のように実行してみます。

POST という値でメソッドを初期化しているので、当然結果は POST が出力されます。

1
let request = Request(method: "POST", path: "session_token")
2
print(request.method) // POST
3
print((request as RequestType).method) // POST

Extension で拡張する

次に、Extension で拡張して既に定義されているプロパティに何らかの値を持たせてみます。

1
protocol RequestType {
2
    var method: String { get }
3
    var parameters: [String: Any]? { get }
4
    var path: String { get }
5
}
6

7
extension RequestType {
8
    var method: String { return "GET" }
9
}
10

11
class Request: RequestType {
12
    var method: String // 必須
13
    var parameters: [String : Any]? // 必須
14
    var path: String // 必須
15

16
    init(method: String, path: String, paramaters: [String: Any]? = nil) {
17
        self.method = method
18
        self.parameters = paramaters
19
        self.path = path
20
    }
21
}

するとこれも先程と同じくどちらも POST という値を返します。

どうやら、Extension で何らかの値を設定してもクラス側で上書きされる（または Extension の値よりもクラスの値が優先して呼び出される）ようです。

1
let request = Request(method: "POST", path: "session_token")
2
print(request.method) // POST
3
print((request as RequestType).method) // POST

パラメータを消してみる

Extension で定義しているのでプロトコルから method を取り除いてみます。

するとプロトコルを適用している Request は必ずしも method プロパティをもつ必要がなくなります。

1
protocol RequestType {
2
    // methodを削除
3
    var parameters: [String: Any]? { get }
4
    var path: String { get }
5
}
6

7
extension RequestType {
8
    var method: String { return "GET" }
9
}
10

11
class Request: RequestType {
12
    var method: String // 必須ではない
13
    var parameters: [String : Any]? // 必須
14
    var path: String // 必須
15

16
    init(method: String, path: String, paramaters: [String: Any]? = nil) {
17
        self.method = method
18
        self.parameters = paramaters
19
        self.path = path
20
    }
21
}

この状態で同じように実行してみるとなんと結果が変わってしまいました。

1
let request = Request(method: "POST", path: "session_token")
2
print(request.method) // POST
3
print((request as RequestType).method) // GET

クラスからも消してみる

1
protocol RequestType {
2
    var parameters: [String: Any]? { get }
3
    var path: String { get }
4
}
5

6
extension RequestType {
7
    var method: String { return "GET" }
8
}
9

10
class Request: RequestType {
11
    var parameters: [String : Any]?
12
    var path: String
13

14
    init(path: String, paramaters: [String: Any]? = nil) {
15
        self.parameters = paramaters
16
        self.path = path
17
    }
18
}

クラスからもプロパティを消してrequest.methodが呼び出すことができるのかどうかは気になるところなのですが、Request クラスは RequestType を継承しているため問題なく呼び出すことができます。

そして、このときは（当たり前ですが）Extension 側のプロパティが呼ばれるということです。

1
let request = Request(path: "session_token")
2
print(request.method) // GET
3
print((request as RequestType).method) // GET

ここまでをまとめるとこうなります。

つまり、プロトコルには宣言されていないが Extension で宣言したプロパティは、静的型付けをして呼び出すと Extension 側の値が呼び出されるということになります。

プロトコル宣言	Extension	クラス宣言	メソッド	値
あり	あり	必須	静的/動的	クラス
あり	なし	必須	静的/動的	クラス
なし	あり	あり	静的	Extension
なし	あり	あり	動的	クラス
なし	あり	なし	静的/動的	Extension

この仕様を利用する

この仕様を利用すれば必須パラメータはプロトコルに直接書き、オプショナルなパラメータは Extension に書いてそのプロトコルを継承したクラスを書くのがスマートな方法になりそうです。

1
protocol RequestType {
2
    var method: String { get }
3
    var parameters: [String: Any]? { get }
4
    var path: String { get }
5
}
6

7
extension RequestType {
8
    var baseURL: String { "https://tkgling.netlify.app/api/" }
9
    var headers: [String: String]? { nil }
10
    var encoding: ParameterEncoding { URLEncoding.default }
11
}
12

13
class Request: RequestType {
14
    var method: String // 必須
15
    var parameters: [String : Any]? // 必須
16
    var path: String // 必須
17

18
    init(method: String, path: String, paramaters: [String: Any]? = nil) {
19
        self.method = method
20
        self.parameters = paramaters
21
        self.path = path
22
    }
23
}

このデータに対しては以下のようにアクセスできる。Request クラスで定義しておらず、必須でないプロパティにアクセスできるのは便利な気がしている。

もしもユーザがそれらのプロパティが必要だと思えば、クラスに書いてしまえばいいのである。

1
// 型はRequestでなくRequestTypeにすること
2
func remote(request: RequestType) -> Void {
3
    print(request.method) // Request
4
    print(request.parameters) // Request
5
    print(request.path) // Request
6
    print(request.headers) // RequestType
7
    print(request.baseURL) // RequestType
8
    print(request.encoding) // RequestType
9
    // すべてのデータにアクセスできる！！
10
}
11

12
let request = Request(method: "POST", path: "token")
13
remote(request: request)

計算プロパティにしてみる

現在の Extension はこの様になっているが、エンコーディングの部分はメソッドの値によって動的に切り替えたいわけである。

1
extension RequestType {
2
    var baseURL: String { "https://tkgling.netlify.app/api/" }
3
    var headers: [String: String]? { nil }
4
    var encoding: ParameterEncoding { URLEncoding.default }
5
}

単純にself.methodで切り替えるようにすると後で上書きしたときに（今回の場合は get しか method に設定されていないので上書きされることはないが）データを正しくとってくることができなくなってしまう。

よって、encoding の値を参照する度に毎回 method の値を調べ、その値によって変わるような仕組みにしたいのである。

これは計算プロパティで簡単に実装できる。つまり、以下のように書けば良い。

1
extension RequestType {
2
    var baseURL: String { "https://tkgling.netlify.app/api/" }
3
    var headers: [String: String]? { nil }
4
    var encoding: ParameterEncoding {
5
        get {
6
            switch self.method {
7
                case .post:
8
                    return JSONEncoding.default
9
                case .put:
10
                    return JSONEncoding.default
11
                default:
12
                    return URLEncoding.default
13
            }
14
        }
15
     }
16
}

これの良いところは全ての設定を RequestType プロトコルで行なうことで、実際に Request クラスを書くユーザに対しては秘匿になっている点である。

要するに、コードを書く人間はエンコーディング方式を全く気にせず Request クラス（ないしは RequestType プロトコルを適用したクラス）を書くことができるわけである。

そして、デフォルトでは POST リクエストであれば自動的に JSONEncoding.default が使われてしまうのだが、もしもあるリクエストは POST メソッドなのだが JSONEncoding.default とは違うエンコーディングが使いたければ、

1
class Request: RequestType {
2
    // Extensionの値が上書きされる！
3
    var encoding: ParameterEncoding = JSONEncoding.queryString
4
}

勝手に自分でエンコーディングを設定すればよいのである。

ただし、これは Request クラスのプロパティとして設定されているので RequestType プロトコルで呼び出したメソッドに対してはそのままrequest.encodingと呼び出すと予期しない値を参照してしまう。

1
// RequestTypeプロトコルとして呼び出す
2
func remote(request: RequestType) -> Void {
3
    print(request.encoding) // RequsetType -> URLEncoding
4
    print((request as! Request).encoding) // Request -> JSONEncoding.queryString
5
}
6

7
// Requestクラスとして呼び出す
8
func remote(request: Request) -> Void {
9
    print(request.encoding) // Request -> JSONEncoding.queryString
10
    print((request as! Request).encoding) // Request -> JSONEncoding.queryString
11
}

ただ、下の Request クラスとして呼び出すメソッドは書きたくない。これだとたった一つの Request クラスでしか引数にできない。

ライブラリとしては個別の RequestType プロトコルの適用クラスではなく、引数は常に RequestType プロトコル準拠の全てのクラスというようにしたいのである。

読み込み側で対応してみる

ジェネリクスで対応できないかとやってみた。

1
protocol RequestType {
2
    var method: String { get }
3
    var parameters: [String: Any]? { get }
4
    var path: String { get }
5

6
    init(method: String, path: String, parameters: [String: Any]?)
7
}
8

9
extension RequestType {
10
    var baseURL: String { "https://tkgling.netlify.app/api/" }
11
    var headers: [String: String]? { nil }
12
    var encoding: ParameterEncoding { URLEncoding.default }
13
}
14

15
class Request: RequestType {
16
    var method: String
17
    var parameters: [String : Any]?
18
    var path: String
19

20
    required init(method: String, path: String, parameters: [String: Any]? = nil) {
21
        self.method = method
22
        self.parameters = parameters
23
        self.path = path
24
        self.encoding = JSONEncoding.queryString
25
    }
26
}
27

28
// この三つは同値と思われる
29
func remote(request: RequestType) -> Void {
30
}
31

32
func remote<T>(request: T) where T: RequestType -> Void {
33
    print((request as! T).encoding) // RequsetType -> URLEncoding
34
}
35

36
func remote<T: RequestType>(request: T) -> Void {
37
    print((request as! T).encoding) // RequsetType -> URLEncoding
38
}

すると読み込み時ではちゃんと Request 型としているのに、encodingのプロパティを参照すると何故か RequestType の Extension の値の方が参照されてしまう。

しかしどうもクラスのプロパティを参照することはできないみたいなのでこちらの方向は諦めた。上手いこと RequestType プロトコルの値を変えてしまうほうが楽そうだ。