<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by riki on Medium]]></title>
        <description><![CDATA[Stories by riki on Medium]]></description>
        <link>https://medium.com/@rikii?source=rss-cc897b3f3db2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*JqtIFMdyKU-qgQxualAxcQ.jpeg</url>
            <title>Stories by riki on Medium</title>
            <link>https://medium.com/@rikii?source=rss-cc897b3f3db2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 16:04:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rikii/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[【Go】gorrila/muxでミドルウェア管理してみる]]></title>
            <link>https://medium.com/eureka-engineering/gomiddleware-4097686ed54d?source=rss-cc897b3f3db2------2</link>
            <guid isPermaLink="false">https://medium.com/p/4097686ed54d</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[riki]]></dc:creator>
            <pubDate>Fri, 29 Mar 2019 03:35:15 GMT</pubDate>
            <atom:updated>2019-03-29T05:07:21.091Z</atom:updated>
            <content:encoded><![CDATA[<h3>【Go】gorilla/muxでミドルウェア管理してみる</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*DIO1MNkD2Op7WyTNwVrLIA.png" /><figcaption>オリジナルの<a href="http://blog.golang.org/gopher">The Go gopher</a>（Gopherくん）は、<a href="http://reneefrench.blogspot.com/">Renée French</a>によってデザインされました。</figcaption></figure><p>こんにちは！eurekaのAPIチームでエンジニアをやっているrikiiです。</p><p>今回はGoのWebアプリケーションのミドルウェア管理について紹介したいと思います。</p><h3>そもそもミドルウェアとは？</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/1*ROWs4MPqS_PfAPPYH1F5UA.png" /></figure><blockquote><a href="https://mattstauffer.com/blog/laravel-5.0-middleware-filter-style/#what-is-middleware">https://mattstauffer.com/blog/laravel-5.0-middleware-filter-style/#what-is-middleware</a></blockquote><p>ミドルウェアは様々な意味があると思いますが、ここで紹介しているのは、Webアプリケーションフレームワークなどに搭載されているような、アプリケーションの処理の前後でなんらかの処理をする機構のことです。例えばSession管理や認証処理などです。</p><p>Goでは<a href="https://github.com/gin-gonic/gin"><strong>gin</strong></a>などのWebアプリケーションフレームワークや、<a href="https://github.com/urfave/negroni/blob/master/translations/README_ja_JP.md"><strong>negroni</strong></a>のようなミドルウェア専用のライブラリなどミドルウェアを管理するものはたくさんありますが、ルーティングには<a href="https://github.com/gorilla"><strong>gorilla</strong></a><a href="https://github.com/gorilla/mux"><strong>/mux</strong></a>を使う方も多いと思うので、ここでは<a href="https://github.com/gorilla"><strong>gorilla</strong></a>で簡単にミドルウェア管理する方法を紹介します。</p><h3><a href="https://github.com/gorilla">gorilla</a><a href="https://github.com/gorilla/csrf">/csrf</a>を使ってCSRF対策をしてみる</h3><p>例えば、WebAPIでCSRF対策をしたい場合があるかと思います。対策方法は様々ありますが、ここでは一般的なCSRFトークンを利用して対策してみようと思います。</p><p><a href="https://github.com/gorilla/csrf">gorilla/csrf</a>パッケージを使用すると割と簡単に対策が可能だったのでこちらを紹介します。例では gorrila/mux を使っていますが、他にも大体のフレームワークや<a href="https://github.com/urfave/negroni/blob/master/translations/README_ja_JP.md"><strong>negroni</strong></a>等でも使えます。</p><p>例: Get localhost:3001/user のAPIが叩かれた場合</p><pre>func main() {<br>   r := mux.NewRouter()<br><strong>   csrfMiddleware := csrf.Protect([]byte(&quot;32-byte-long-auth-key&quot;))<br>   r.Use(csrfMiddleware)</strong></pre><pre>c := &amp;controllers.UserController{}<br>   r.HandleFunc(&quot;/&quot;, c.Get).Methods(&quot;GET&quot;)<br>   http.ListenAndServe(&quot;:3001&quot;, r)<br>}</pre><pre>type UserController struct {}</pre><pre>func (c *UserController) Get(w http.ResponseWriter, r *http.Request) {<br><strong>   w.Header().Set(&quot;X-CSRF-Token&quot;, csrf.Token(r))<br></strong>   w.WriteHeader(200)<br>}</pre><p>これだけで、レスポンスのヘッダーにCSRFトークンが入ります。</p><p>あとはクライアント側で、受け取ったリクエストヘッダーの X-CSRF-Token をレスポンスヘッダーの X-CSRF-Token にセットして送ってもらえば、トークン認証もしてくれます。</p><p>また、 Useメソッドは下記のような実装になっており、ミドルウェアを複数渡すことも可能です。</p><pre>type <strong>MiddlewareFunc</strong> func(http.Handler) http.Handler</pre><pre>func (r *Router) <strong>Use</strong>(mwf ...MiddlewareFunc) {<strong><br></strong>   for _, fn := range mwf {<br>      r.middlewares = append(r.middlewares, fn)<br>   }<br>}</pre><p>使いたいミドルウェアを処理したい順番にr.Use() の引数に渡すだけで順次実行されます。</p><p>このように簡単にミドルウェアを管理することができます。</p><p>次は自作ミドルウェアの例を紹介します。</p><h3>自作ミドルウェアを作ってみる</h3><pre>type MiddlewareFunc func(http.Handler) http.Handler</pre><p>先程の Useメソッドを見返すと MiddlewareFunc型の関数を用意すればいいことがわかるかと思います。</p><p>例えば、簡単なCORSに対応した、Access-Control-Allow-Origin ヘッダーに適当なURLを入れるだけの簡単なミドルウェアを作ってみたいと思います。</p><pre>func <strong>CORSMiddleware</strong>(next http.Handler) http.Handler {<br>   return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {<br>      origin := &quot;localhost:3001&quot;<br>      w.Header().Set(&quot;Access-Control-Allow-Origin&quot;, origin)<br>      next.ServeHTTP(w, r)<br>   })<br>}</pre><pre>func main() {<br>   r := mux.NewRouter()<br><strong><em>   r.Use(CORSMiddleware)<br>   </em></strong>csrfMiddleware := csrf.Protect([]byte(&quot;32-byte-long-auth-key&quot;))<br>   r.Use(csrfMiddleware)</pre><pre>c := &amp;controllers.UserController{}<br>   r.HandleFunc(&quot;/&quot;, c.Get).Methods(&quot;GET&quot;)<br>   http.ListenAndServe(&quot;:3001&quot;, r)<br>}</pre><p>これでレスポンスヘッダーに Access-Control-Allow-Origin に値を入れることができます。</p><p>渡した順番に実行されるので、↓の順番で実行されます。</p><pre>1. CORSMiddleware<br>2. csrfMiddleware</pre><p>処理される順番が結構重要になってくるので少し実装を見てみたいと思います。</p><pre>func CORSMiddleware(next http.Handler) http.Handler {<br>   return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {<br>      origin := &quot;localhost:3001&quot;<br>      w.Header().Set(&quot;Access-Control-Allow-Origin&quot;, origin)<br>      next.ServeHTTP(w, r)<br>   })<br>}</pre><p>引数の next http.Handlerは次に実行予定のミドルウェアの関数が入ってきます。</p><pre>r.Use(CORSMiddleware)<strong><em><br></em></strong>csrfMiddleware := csrf.Protect([]byte(&quot;32-byte-long-auth-key&quot;))<br>r.Use(csrfMiddleware)</pre><p>↑の順番で渡したので、今回の例でいうとcsrfMiddleware が入ります。</p><pre>next.ServeHTTP(w, r)</pre><p>実際には↑の処理で、<a href="https://github.com/gorilla/csrf/blob/master/csrf.go#L179">csrfMiddlewareのServeHTTP</a>が実行されています。</p><p>少しわかりにくいですが、middleware1(middleware2(middleware3(...))) のように入れ子のような形で引数の next.ServeHTTP メソッドが実行されて、順次レスポンスに書き込む処理が実行されています。</p><p>なので next.ServeHTTP(w,r) を呼ばないと次以降のミドルウェアが実行されなくなってしまうので、必ず忘れずに呼ぶ必要があります。</p><h3>まとめ</h3><p>外部パッケージ（<a href="https://github.com/gorilla">gorilla</a>/csrf）と自作のミドルウェアを管理する方法を見てきました。</p><p>どちらも簡単に管理できたのは、 gorilla/muxのミドルウェア管理（他のフレームワークもですが）が全てhttp.Handler interface依存になっており汎用的に使える設計になっているからです。</p><p>今回はGoでのミドルウェア管理を少しみてきましたが、他の言語のWebアプリケーションフレームワークやライブラリでもほぼ同じ仕組みで動いているので知っておくとよいかと思います。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4097686ed54d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/eureka-engineering/gomiddleware-4097686ed54d">【Go】gorrila/muxでミドルウェア管理してみる</a> was originally published in <a href="https://medium.com/eureka-engineering">Pairs Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【Go言語】簡単なLinuxコマンド実装で学ぶioパッケージ]]></title>
            <link>https://medium.com/eureka-engineering/go-io-package-77a25a90355d?source=rss-cc897b3f3db2------2</link>
            <guid isPermaLink="false">https://medium.com/p/77a25a90355d</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[riki]]></dc:creator>
            <pubDate>Tue, 04 Dec 2018 08:01:01 GMT</pubDate>
            <atom:updated>2018-12-05T01:27:22.844Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pigU9Lg2Il0BKmGDgIEXww.jpeg" /></figure><p>この記事は <a href="https://qiita.com/advent-calendar/2018/eureka">eureka Advent Calendar 2018</a> 4日目の記事です。</p><p>こんにちは！eurekaのAPIチームでエンジニアをやっているrikiiです。</p><p>最近ついにAPIチームでモブプロを始めました。前は設計や実装について一人で悩んでたりした部分が、すぐ議論できたりホワイトボードに図で書いて理解を深めたりして、問題が素早く解決できてすごくいい感じで進んでいます。</p><h4>はじめに</h4><p>初級者向けです。<br>Go言語にはOSレベルの低レイヤーを扱うにあたって非常に便利な io.Writer と io.Reader というインターフェースがioパッケージの内部に定義されています。</p><p>今回はこのインターフェースを用いてLinuxコマンドを実装してみることで、利便性を紹介しようと思います。</p><h4>io.Writer, io.Readerとは？</h4><p>以下のようにどちらもインターフェース型で定義されています。</p><pre>type Writer interface {<br>    Write(p []byte) (n int, err error)<br>}</pre><pre>type Reader interface {<br>    Read(p []byte) (n int, err error)<br>}</pre><p><a href="https://github.com/golang/go/blob/1adbb2bb9b256907eaf3f012d7f818765e6e2a2b/src/io/io.go#L77">golang/go</a></p><p>どちらもbyte型を引数にして、int型(size)とerror型を返しています。このインターフェースを満たしていればどんな型でもio.Writer, io.Readerとして扱うことができます。</p><h4>copyコマンドを実装してみる</h4><p>お馴染みのLinuxのcopyコマンドをGoで実装してみたいと思います。</p><p>cp test.txt copy.txt -&gt; go run xxx.go test.txt copy.txt でコピー可能です。</p><pre>package main</pre><pre>import (<br>   &quot;io&quot;<br>   &quot;os&quot;<br>)</pre><pre>func <strong>main</strong>() {<br>   originName := os.Args[1]<br>   copyName := os.Args[2]</pre><pre>   f, err := os.Open(originName)<br>   defer f.Close()</pre><pre>   if err != nil {<br>      panic(err)<br>   }</pre><pre>   cf, err := os.Create(copyName)<br>   if err != nil {<br>      panic(err)<br>   }<br>   byteFile, _ := ioutil.ReadAll(f)<br>   cf.Write(byteFile)<br>}</pre><p>まずはファイルの名前の引数を os.Args で受け取ります。</p><p>次に os.Open でコピー元のファイル名を渡し os.File型で受け取り、コピー先のファイル名を os.Createに渡し os.File型で受け取ります。</p><p>ioutil.ReadAll() という関数が出てきました。</p><p>ioutil.ReadAll() は、引数に取った File 型のファイルのすべてのデータを []byte で返してくれます。</p><p>最後に、 cf, err := os.Create(copyName) で作成した File に対してWriteメソッドを呼ぶことで実現できます</p><p>これで、渡されたファイルが画像であろうが文字列であろうがコピーが完了します。</p><p>また io.Copy という関数もあり、こちらを使えば以下のように1行でできます。</p><pre>io.Copy(cf, f) // io.Writerとio.Readerが引数</pre><p>割と簡単に実装できました。</p><p>もちろん、 os.File 型の Write メソッドが、内部では最終的には writeシステムコールが実行したりと複雑な処理を実行しています。</p><p>ここまでは何が便利なのかよくわからないと思いますので次にいきます。</p><h4>zipコマンドを実装してみる</h4><p>次はzipコマンド を実装してみます。</p><p>zip test.zip test.png -&gt; go run xxx.go test.zip test.png</p><pre>package main</pre><pre>import (<br>   &quot;archive/zip&quot;<br>   &quot;io&quot;<br>   &quot;os&quot;<br>)</pre><pre>func <strong>main</strong>() {<br>   zipName := os.Args[1]<br>   fileName := os.Args[2]</pre><pre>   f, err := os.Create(zipName)<br>   if err != nil {<br>      panic(err)<br>   }<br>   defer f.Close()</pre><pre>   cpFile, err := os.Open(fileName)<br>   if err != nil {<br>      panic(err)<br>   }<br>   defer cpFile.Close()</pre><pre>   zipWriter := zip.NewWriter(f)<br>   writer, err := zipWriter.Create(fileName)<br>   if err != nil {<br>      panic(err)<br>   }<br>   defer zipWriter.Close()<br>   io.Copy(writer, cpFile)<br>}</pre><p>先程のCopyコマンドとほぼ同じような実装になっていることがわかるかと思います。</p><p>違いがあるとしたら、今回は io.Copy に渡している Writer が os.File 型ではなく、 zip.Writer 型になっていることぐらいです。</p><p>io.Copy の実装を少しみてみます。</p><pre>func <strong>Copy</strong>(dst Writer, src Reader) (written int64, err error) {<br>   return copyBuffer(dst, src, nil)<br>}</pre><p><a href="https://github.com/golang/go/blob/1adbb2bb9b256907eaf3f012d7f818765e6e2a2b/src/io/io.go#L363">golang/go</a></p><p>引数が io.Writer と io.Reader になっています。</p><p>つまり、下記のメソッドを持つ構造体であればなんでも使用可能です。</p><pre>type Writer interface {<br>    Write(p []byte) (n int, err error)<br>}</pre><pre>type Reader interface {<br>    Read(p []byte) (n int, err error)<br>}</pre><p>copy コマンドの場合は os.File 型。</p><p>zip コマンドの場合は zip.Writer 型で異なる型ですが、</p><p>io.Writer と io.Reader のInterfaceを満たしているためどちらも使用できるというメリットが生まれました。</p><p>このように Writer と Reader の型が異なっていても、 io.Writer と io.Reader を使えばとてもシンプルな実装で様々な読み書きが実現が可能となります。</p><h4>zip番外編</h4><p>今回の趣旨とは関係ないですが、zipコマンド実装してて、少し本家っぽい感じにしたいなーと思い、 recursive オプションだけ対応してみました。</p><p>エラー処理などかなり雑なところ多いですが、ご容赦ください。。。</p><p>オプション引数を処理する場合、flagパッケージを使うと簡単に作れて便利です。</p><pre>package main</pre><pre>import (<br>   &quot;archive/zip&quot;<br>   &quot;flag&quot;<br>   &quot;io&quot;<br>   &quot;io/ioutil&quot;<br>   &quot;os&quot;<br>)</pre><pre>const ExitOK = 0</pre><pre>func <strong>main</strong>() {<br>   os.Exit(Run(os.Args))<br>}</pre><pre>func Run(args []string) int {<br>   fileName := args[1]<br>   copyFileName := args[2]<br>   var (<br>      r = flag.Bool(&quot;bool&quot;, false, &quot;recurse into directories&quot;)<br>   )</pre><pre>   flag.Parse()</pre><pre>   cpFileInfo, err := os.Stat(copyFileName)<br>   if err != nil {<br>      panic(err)<br>   }</pre><pre>   f, err := os.Create(fileName)<br>   if err != nil {<br>      panic(err)<br>   }<br>   zipWriter := zip.NewWriter(f)<br>   defer zipWriter.Close()</pre><pre>   recursiveOptFunc := func(name string) int {<br>      files, err := ioutil.ReadDir(copyFileName)<br>      if err != nil {<br>         panic(err)<br>      }<br>      for _, f := range files {<br>         writer, err := zipWriter.Create(f.Name())<br>         if err != nil {<br>            panic(err)<br>         }<br>         f, err := os.Open(copyFileName + &quot;/&quot; + f.Name())<br>         defer f.Close()<br>         if err != nil {<br>            panic(err)<br>         }<br>         io.Copy(writer, f)<br>      }<br>      return ExitOK<br>   }</pre><pre>   if *r {<br>      return recursiveOptFunc(copyFileName)<br>   }</pre><pre>   // ディレクトリの場合、オプションが無くても実行<br>   if cpFileInfo.IsDir() {<br>      return recursiveOptFunc(copyFileName)<br>   }</pre><pre>cpFile, err := os.Open(copyFileName)<br>   defer cpFile.Close()<br>   if err != nil {<br>      panic(err)<br>   }</pre><pre>writer, err := zipWriter.Create(copyFileName)<br>   if err != nil {<br>      panic(err)<br>   }<br>   io.Copy(writer, cpFile)<br>   return ExitOK<br>}</pre><h4>まとめ</h4><p>copyコマンドとzipコマンドを実装することによって io.Reader, io.Writerについてみてきました。</p><p>他にもネットワーク系であれば、 net.Conn インターフェースを使って同様のことが可能です。( net.Conn インターフェースが Read, Write メソッドを持っている）</p><p><a href="https://golang.org/doc/faq">公式のFAQ</a>をみると、Goは、Googleで行っていた作業のための既存の言語と環境の不満から生まれたことがわかります。</p><blockquote>Why did you create a new language?<br>Go was born out of frustration with existing languages and environments for the work we were doing at Google. Programming had become too difficult and the choice of languages was partly to blame. One had to choose either efficient compilation, efficient execution, or ease of programming; all three were not available in the same mainstream language. Programmers who could were choosing ease over safety and efficiency by moving to dynamically typed languages such as Python and JavaScript rather than C++ or, to a lesser extent, Java.</blockquote><p>Googleは様々なプラットフォームのソフトウェアを扱っているため、既存の言語ではあまりに複雑になりすぎ、その問題解決として、Goという言語を作ったそうです。</p><p>なので、OSに近い低レイヤーの処理が簡潔に書けるように設計されており、CLIの実装等には非常に向いていると思います。</p><p>簡単な内容ではありましたが参考にしていただけると幸いです。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=77a25a90355d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/eureka-engineering/go-io-package-77a25a90355d">【Go言語】簡単なLinuxコマンド実装で学ぶioパッケージ</a> was originally published in <a href="https://medium.com/eureka-engineering">Pairs Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[依存関係逆転の原則の重要性について]]></title>
            <link>https://medium.com/eureka-engineering/go-dependency-inversion-principle-8ffaf7854a55?source=rss-cc897b3f3db2------2</link>
            <guid isPermaLink="false">https://medium.com/p/8ffaf7854a55</guid>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[riki]]></dc:creator>
            <pubDate>Fri, 30 Nov 2018 08:23:12 GMT</pubDate>
            <atom:updated>2018-11-30T10:01:24.724Z</atom:updated>
            <content:encoded><![CDATA[<p>こんにちは！eurekaのAPIチームでエンジニアをやっているrikiiです。</p><p>最近ついにAPIチームでモブプロを始めました。前は設計や実装について一人で悩んでたりした部分が、すぐ議論できたりホワイトボードに図で書いて理解を深めたりして、問題が素早く解決できてすごくいい感じで進んでいます。<br>さて、今回も前回の続きでSOLID原則の1つのDIP（依存関係逆転の原則）について書こうと思います。 eurekaではgo言語を使っているので、goを使ったコード例とともに説明していきたいと思います。<br>ちなみに依存関係逆転の原則とはSOLID原則と呼ばれるオブジェクト指向設計原則のうちのひとつです。</p><h3>SOLID原則とは？</h3><p>下記5つの原則の頭文字を取ってまとめた、オブジェクト指向設計原則のことです。<br><strong>・</strong>S : The Single Responsibility Principle（単一責任の原則）<br><strong>・</strong>O : The Open Closed Principle（オープン・クローズドの原則）<br><strong>・</strong>L : The Liskov Substitution Principle（リスコフの置換原則）<br><strong>・</strong>I : The Interface Segregation Principle（インターフェース分離の原則）<br><strong>・</strong>D : The Dependency Inversion Principle（依存性逆転の原則）</p><h3>依存関係逆転の原則(DIP)</h3><blockquote>上位のモジュールは下位のモジュールに依存してはならない。どちらのモジュールも「抽象」に依存すべきである 「抽象」は実装の詳細に依存してはならない。実装の詳細が「抽象」に依存すべきである</blockquote><p>最初は上位レイヤが下位レイヤに依存するのは当然だし、、、なんのこっちゃと思っていました。</p><p>DIPを一言でまとめれば、「<strong>抽象に依存せよ</strong>」ということらしいです。<br>通常の実装だと、上位のレイヤが下位のレイヤの実体を持つようになりがちかと思います。<br>例えば、ServiceがRepositoryの実体に依存するなどです。<br>しかし、Repositoryに大きな修正が発生すると、依存している全てのServiceに影響が出てしまう可能性があります。<br>本来、アプリケーションの存在意義を決めているのは上位のレイヤなので、下位レイヤの修正が上位レイヤに影響を及ぼしてしまうことは避けなければいけません。<br>その解決方法として、上位レイヤは下位レイヤの実体に依存するのではなく、上位レイヤで宣言した抽象に依存するようにしましょうというのがDIPです。<br>これだけではよくわからないので、具体例で、</p><ul><li>どういう場合に困るのか？</li><li>どういうメリットがあるのか？</li></ul><p>の2つについて説明していきたいと思います。</p><h3>要件例</h3><p>例えば、Pairsのようなマッチングサービスを新たに開発することになったとします。<br>マッチングサービスにはいいねという機能があり、いいねを送ると相手に通知がいき、相手がいいねを返すとマッチングが成立します。<br>なので、誰が誰にいいねを送ったかを保存しておく必要があります。<br>最初は、この保存場所をMysqlの user_like テーブルに保存していたとします。</p><p>いいねのアクションで、UserControllerがUserLikeServiceを呼び出し、UserLikeServiceがUserLikeRepositoryを呼び出して、いいね情報を取得するロジックを例に説明したいと思います。</p><p>アーキテクチャに関してはわかりやすいように、お馴染みのMVCにService層を組み込んだシステムを想定します。(MがRepository)</p><h3>最初の実装(DIPに従わない例)</h3><p>図1–1</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/167/1*48vqrZPbKGuHqVbQIq6vNQ.png" /></figure><pre>type UserController struct {<br>   service UserLikeService<br> }<br> <br> func (c UserController) Get {<br>   // 本来はリクエストから受け取る<br>   userID := 1<br>   c.service = NewUserLikeService()<br>   userLike := c.service.Fetch(userID)<br>   // 後続処理<br> }<br> type UserLikeService struct {}<br> <br> func NewUserLikeService() UserLikeService {<br>     return UserLikeService{}<br> }<br> <br> func (s UserLikeService) Fetch(userID int) *UserLike {<br>     repo := NewUserLikeRepository()<br>     return repo.FetchByUserID(userID)<br> }<br> <br> type UserLikeRepository struct {}<br> <br> func NewUserLikeRepository() UserLikeRepository {<br>     return UserLikeRepository{}<br> }<br> <br> func (r UserLikeRepository) FetchByUserID(userID int) *UserLike {<br>     db, err := sql.Open(&quot;mysql&quot;, &quot;root:@/sample?parseTime=true&quot;)<br>     if err != nil {<br>         panic(err.Error())<br>     }<br>     defer db.Close()<br>     // 以降、UserLikeに詰め替える処理<br>     // サンプルなのでモックを返します<br>     u := UserLike{1, 2}<br>     return &amp;u<br> }<br> <br> type UserLike struct {<br>     UserID    int<br>     PartnerID int<br> }</pre><p>ControllerがServiceに、ServiceがRepositoryに依存しています。</p><h4>どういう場合に困るのか？</h4><p>前提として、UserControllerの他にも複数のControllerで、UserLikeServiceを使用していると仮定します。<br>例えば、実際あるかはわかりませんが、特定のリクエスト(UserController)の読み込みに関しては、他のスキーマ(例:DynamoDB)で持つ修正が必要になったとします。<br>そうするとService層またはRepository層への修正が必要になります。 雑に実装しますがこんな感じになるでしょうか。</p><pre>func (s UserLikeService) Fetch(userID int, type string) *UserLike {<br>  if (/* 受け取ったtypeで制御条件 */) {<br>    repo := NewUserLikeRepository()<br>    return repo.FetchByUserID(userID)<br>  } else {<br>    repo := NewUserLikeDynamoDBRepository()<br>    return repo.FetchByUserID(userID)<br>  }<br>}</pre><p>この修正が入ると、引数が変更になり、UserLikeServiceを呼び出している箇所全ての修正が必要になってしまいます。</p><h3>DIPに従った実装</h3><p>図1–2</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/603/1*unKTIGRnRszZjFWFJa715A.png" /></figure><pre>// controller package<br>type UserController struct {<br>  service UserServiceInterface<br>}<br> <br>type UserServiceInterface interface {<br>  Fetch(int) *UserLike<br>}<br> <br>func (c UserController) Get {<br>  // 本来はリクエストから受け取る<br>  userID := 1<br>  // c.serviceにはControllerを呼び出す処理が実体を入れる<br>  userLike := c.service.Fetch(userID)<br>  // 後続処理<br> <br>// service package<br>type UserLikeService struct {<br>    repo UserLikeFetcherInterface<br>}<br> <br>type UserLikeFetcherInterface interface {<br>    FetchByUserID(int) *UserLike<br>}<br> <br>func NewUserLikeService() UserLikeService {<br>    return UserLikeService{<br>        repo: NewUserLikeRepository(),<br>    }<br>}<br> <br>func NewUserLikeDynamoDBService() UserLikeService {<br>    return UserLikeService{<br>        repo: NewUserLikeDynamoDBRepository(),<br>    }<br>}<br> <br>func (s UserLikeService) Fetch(userID int) *UserLike {<br>    return s.repo.FetchByUserID(userID)<br>}<br> <br>// repository package<br>type UserLikeDynamoDBRepository struct{}<br> <br>func NewUserLikeDynamoDBRepository() UserLikeDynamoDBRepository {<br>    return UserLikeDynamoDBRepository{}<br>}<br> <br>func (r UserLikeDynamoDBRepository) FetchByUserID(userID int) *UserLike {<br>    u := UserLike{1, 2}<br>    return &amp;u<br>}<br> <br>type UserLike struct {<br>    UserID    int<br>    PartnerID int<br>}</pre><p>上位レベルの各レイヤでは抽象インターフェースを宣言しています。<br>下位レベルのレイヤはこれらの抽象インターフェースを実装するようになったため、上位が下位に依存しなくなりました。<br>このインターフェースを満たすモジュールであればどんなものでも使用できるため、上位レイヤが使いたい下位レイヤのモジュールを選択できます。</p><p>具体的には、UserContorller側でNewUserLikeDynamoDBServiceを呼び出すようにしておけば、Service層またはRepository層に手を加えずに要件を満たすことが可能になりました。</p><h3>まとめ</h3><p>DIPは抽象に依存することで、オブジェクトの再利用、保守、柔軟性のメリットが受けられます<br>前回のオープン・クローズドの原則もそうでしたが、Webサービスの運用は変更が生まれやすいので、場合によってはDIPを使用して変更に耐えられる設計にしておくことが重要だと思います。<br>逆にこの原則はほとんど変更が加わらないオブジェクトでは使う必要は無いかと思います</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8ffaf7854a55" width="1" height="1" alt=""><hr><p><a href="https://medium.com/eureka-engineering/go-dependency-inversion-principle-8ffaf7854a55">依存関係逆転の原則の重要性について</a> was originally published in <a href="https://medium.com/eureka-engineering">Pairs Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[オープン・クローズドの原則の重要性について]]></title>
            <link>https://medium.com/eureka-engineering/go-open-closed-principle-977f1b5d3db0?source=rss-cc897b3f3db2------2</link>
            <guid isPermaLink="false">https://medium.com/p/977f1b5d3db0</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[riki]]></dc:creator>
            <pubDate>Tue, 18 Sep 2018 05:23:55 GMT</pubDate>
            <atom:updated>2018-09-18T09:45:57.076Z</atom:updated>
            <content:encoded><![CDATA[<p>こんにちは！eurekaのAPIチームでエンジニアをやっている@rikiiです。</p><p>少し前に発売された<a href="https://tatsu-zine.com/books/clean-architecture">clean Architecture 達人に学ぶソフトウェアの構造と設計</a>を買ったのですが、本で紹介されてるSOLID原則について改めて復習しておこうと思い、今回はその1つであるオープン・クローズドの原則についてまとめてみようと思います。</p><p>eurekaではgo言語を使っているので、goを使ったコード例とともにオープン・クローズドの原則の重要性について説明していきたいと思います。<br>ちなみにオープン・クローズドの原則とはSOLID原則と呼ばれるオブジェクト指向設計原則のうちのひとつです。</p><h3>SOLID原則とは？</h3><p>下記5つの原則の頭文字を取ってまとめた、オブジェクト指向設計原則のことです。<br><strong>・</strong>S : The Single Responsibility Principle（単一責任の原則）<br><strong>・</strong>O : The Open Closed Principle（オープン・クローズドの原則）<br><strong>・</strong>L : The Liskov Substitution Principle（リスコフの置換原則）<br><strong>・</strong>I : The Interface Segregation Principle（インターフェース分離の原則）<br><strong>・</strong>D : The Dependency Inversion Principle（依存性逆転の原則）</p><h3>オープン・クローズドの原則(OCP)</h3><blockquote>ソフトウェアの構成要素（クラス、モジュール、関数など）は拡張のために開いていて、修正のために閉じていなければならない。</blockquote><p>言い換えると、<strong>変更が発生した場合に既存のコードには修正を加えずに、新しくコードを追加する</strong>だけで対応しましょう！ということです。<br>今回は、GoでOCP違反の例をStrategyパターンを使って解決することにより、何のメリットが生まれるのか？をみていきたいと思います。</p><h3>例</h3><p>例えば、自分が担当しているアプリが定額課金を始めることになり、決済処理の実装が必要になったとします。<br>決済方法としては、<br><strong>・</strong>カード決済<br><strong>・</strong>あとでアプリ決済もやるし、Paypalやら色々増えるかもしれない</p><p>という内容だったとします。とりあえずファーストスコープとしてカード決済だけ実装してみるとします。<br>わかりやすいように、お馴染みのMVCにService層を組み込んだシステムを想定します。</p><h3>OCPに違反した実装</h3><p>図1–1 CardModuleの実体に依存</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/288/1*nNjMTYH_Y61MEBWtn0GIWw.png" /></figure><pre>type PaymentService struct {<br>    // PaymentServiceがCardModuleの実体を持っている<br>    cardModule CardModule<br> }<br> <br> func (s *PaymentService) Subscribe() {<br>     // 事前処理<br>     err := s.cardModule.Pay()<br>     if err ! = nil {<br>        // エラー処理<br>     }<br>     // 事後処理<br> }</pre><p>図1–1をみると、<br> PaymentService(Controllerから呼ばれる想定)がCardModuleの実体に依存しています。(-&gt;は使用)<br>OCPは<strong><em>変更が発生した場合に既存のコードには修正を加えずに、新しくコードを追加するだけで対応する</em></strong>原則でした。<br>しかし、このコードでは、例えばApple決済が増えた（変更が発生した）場合に、Subscribeメソッドを修正する必要があります。</p><p>雑に実装しますが多分こんな感じになるかと思います。</p><pre>type PaymentService struct {<br>    cardModule CardModule<br>    appleModule AppleModule<br> }<br> <br> func (s *PaymentService) Subscribe(PaymentMethod string) {<br>     // 事前処理<br>     switch paymentMethod {<br>     case &quot;card&quot;:<br>        err := s.cardModule.Pay()<br>     case &quot;apple&quot;:<br>        err := s.appleModule.Pay()<br>     }<br>     if err ! = nil {<br>        // エラー処理<br>     }<br>     // 事後処理<br> }</pre><p>この修正方法だと決済方法が増えてきた際に分岐が複雑になり、決済方法の追加が既存の決済方法に影響を及ぼす可能性も増えてしまいます。</p><h3>OCPに準拠した実装</h3><p>図1.2 OCPに準じた例 : strategyパターン</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/378/1*R9gekr2n8DCsnDxYxWHABA.png" /></figure><p><strong>変更点</strong><br><strong>・</strong>PaymentServiceがPaymentInterfaceに依存するようになった<br><strong>・</strong>各ModuleがPaymentInterfaceを実装している</p><p><strong>実装</strong></p><p>payment_service</p><pre>type PaymentInterface interface {<br>      Pay() error <br>  }<br> <br>  type PaymentService struct {<br>      paymentModule PaymentInterface<br>  }<br> <br>  type NewCardPaymentService() PaymentService {<br>      paymentModule : CardModule{}, <br>  }<br> <br>  type NewApplePaymentService() PaymentService {<br>      paymentModule : AppleModule{}, <br>  }<br> <br>  func (s *PaymentService) Subscribe() {<br>    // 事前処理<br>    err := s.paymentModule.Pay()<br>    if err ! = nil {<br>       // エラー処理<br>    }<br>    // 事後処理<br>  }</pre><p>card_module</p><pre>type CardModule struct {}<br> <br>  func (m CardModule) Pay() {<br>      //Card固有の決済処理<br>  }</pre><p>apple_module</p><pre>type AppleModule struct {}<br> <br> func (m AppleModule) Pay() {<br>     //Apple固有の決済処理<br> }</pre><h4>OCPに準拠したことによるメリット</h4><p>CardModuleをInterfaceにしたことにより、CardModuleの処理内容が実体に依存しなくなりました。</p><p><strong>・</strong>これによって各決済方法を個別に実装する事が可能になり(Open)、各決済方法同士の修正が影響をうけることがなくなりました。(Closed)<br><strong>・</strong>利用側から実際に決済方法を分けて使うための実装方法としては、外部からfactoryMethodなどをもちいて依存性を注入するなどがよいかなと思います。</p><p><strong>factoryMethodの例</strong></p><pre>func NewPaymentService(PaymentMethod string) PaymentService {<br>    switch PaymentMethod {<br>    case &quot;card&quot;:<br>        return NewCardPaymentService()<br>    case &quot;apple&quot;:<br>        return NewApplePaymentService()<br>    // 続き<br>    }<br>}</pre><h3>まとめ</h3><p>OCPはオブジェクト指向設計の核心で、再利用、保守、柔軟性のメリットが受けられます。<br>特にWebサービスの運用は変更が生まれやすいので、変更に耐えられる設計にしておくことが重要だと思います。<br>ただし、闇雲に抽象化してしまうと、ソースコードは増えるし、複雑になったりするので、個人的には必要なときに使えばいいかなと思います。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=977f1b5d3db0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/eureka-engineering/go-open-closed-principle-977f1b5d3db0">オープン・クローズドの原則の重要性について</a> was originally published in <a href="https://medium.com/eureka-engineering">Pairs Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>