<?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 Kenny Chen on Medium]]></title>
        <description><![CDATA[Stories by Kenny Chen on Medium]]></description>
        <link>https://medium.com/@kennychenblog?source=rss-e4adaf5f8fe7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*XwwxrPcaHDDrf2PRslIlaQ.jpeg</url>
            <title>Stories by Kenny Chen on Medium</title>
            <link>https://medium.com/@kennychenblog?source=rss-e4adaf5f8fe7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 22:38:07 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kennychenblog/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[Golang —  JSON Web Tokens(JWT)示範]]></title>
            <link>https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/golang-json-web-tokens-jwt-olang-json-web-tokens-jwt-%E7%A4%BA%E7%AF%84-225b377e0f79?source=rss-e4adaf5f8fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/225b377e0f79</guid>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[jwt]]></category>
            <category><![CDATA[back-end-development]]></category>
            <dc:creator><![CDATA[Kenny Chen]]></dc:creator>
            <pubDate>Mon, 10 Feb 2020 02:16:05 GMT</pubDate>
            <atom:updated>2020-02-11T13:08:21.902Z</atom:updated>
            <content:encoded><![CDATA[<h3>Golang — JSON Web Tokens(JWT)示範</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*30aoNxlSnaYrLhBT0O1lzw.png" /></figure><p>首先對於我的文章感興趣的，可以參考我個人部落格：</p><p><a href="https://kennychen-blog.herokuapp.com/">Kenny&#39;s Blog</a></p><p>裡面有更多文章內容，感謝！</p><p>上次寫了<a href="https://kennychen-blog.herokuapp.com/2019/12/14/JWT-JSON-Web-Tokens-%E5%8E%9F%E7%90%86%E4%BB%8B%E7%B4%B9/">JWT原理介紹</a>，這次我們實際用Golang來試試JWT。基本上每個程式語言裡面都會有許多開源的JWT程式庫，雖然JWT的原理並不難理解，實作起來是需要考慮許多細節的，所以通常如果有好的輪子，建議就是用輪子，然後再好好閱讀輪子的原始碼，讓使用上可以更順手。</p><h3>如何選擇好的JWT程式庫？</h3><p>事實上，JWT官網首頁就有提供許多程式語言開源的JWT程式庫，還很貼心地列出該程式庫有提供哪些功能，例如實作了哪些JWT加密演算法及在驗證JWT上有提供哪些檢查。此外，還提供了GitHub網址及Star數量，畢竟開源庫的Star數量可以保證一定的品質。</p><p>今天的JWT示範用Golang程式語言，因此我們看到：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/371/1*E5N6m1i3lwuz6fMnbEzcuw.jpeg" /></figure><p>這是一個比較知名的golang JWT庫，在上面可以看到它提供了哪些演算法跟check的支援。此次示範就使用該程式庫。</p><h3>jwt-go 程式庫示範</h3><p>這次示範用RESTful API的方式來呈現。</p><p>專案名稱：ginJWT</p><p>此次專案用到的Web框架是gin，這是Golang中我最喜歡的Web框架，有機會在寫文章介紹。並且使用Go Modules的方式來管理第三方套件，如果不知道GOPATH、Go Modules差別的話，{% post_link Golang-GOROOT、GOPATH、Go-Modules-三者的關係介紹 請點擊這裡 %}</p><p>建立一個main.go，直接來看我寫的程式碼：</p><pre>package main<br> ​<br> import (<br>     &quot;fmt&quot;<br>     &quot;github.com/dgrijalva/jwt-go&quot;<br>     &quot;github.com/gin-gonic/gin&quot;<br>     &quot;net/http&quot;<br>     &quot;strconv&quot;<br>     &quot;strings&quot;<br>     &quot;time&quot;<br> )<br> ​<br> // custom claims<br> type Claims struct {<br>     Account string      `json:&quot;account&quot;`<br>     Role string         `json:&quot;role&quot;`<br>     jwt.StandardClaims<br> }<br> ​<br> // jwt secret key<br> var jwtSecret = []byte(&quot;secret&quot;)<br> ​<br> func main() {<br>     router := gin.Default()<br> ​<br>     router.POST(&quot;/login&quot;, func(c *gin.Context) {<br>         // validate request body<br>         var body struct{<br>             Account string<br>             Password string<br>         }<br>         err := c.ShouldBindJSON(&amp;body)<br>         if err != nil {<br>             c.JSON(http.StatusBadRequest, gin.H{<br>                 &quot;error&quot;: err.Error(),<br>             })<br>             return<br>         }<br> ​<br>         // check account and password is correct<br>         if body.Account == &quot;Kenny&quot; &amp;&amp; body.Password == &quot;123456&quot; {<br>             now := time.Now()<br>             jwtId := body.Account + strconv.FormatInt(now.Unix(), 10)<br>             role := &quot;Member&quot;<br> ​<br>             // set claims and sign<br>             claims := Claims{<br>                 Account:        body.Account,<br>                 Role:           role,<br>                 StandardClaims: jwt.StandardClaims{<br>                     Audience:  body.Account,<br>                     ExpiresAt: now.Add(20 * time.Second).Unix(),<br>                     Id:        jwtId,<br>                     IssuedAt:  now.Unix(),<br>                     Issuer:    &quot;ginJWT&quot;,<br>                     NotBefore: now.Add(10 * time.Second).Unix(),<br>                     Subject:   body.Account,<br>                 },<br>             }<br>             tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)<br>             token, err := tokenClaims.SignedString(jwtSecret)<br>             if err != nil {<br>                 c.JSON(http.StatusInternalServerError, gin.H{<br>                     &quot;error&quot;: err.Error(),<br>                 })<br>                 return<br>             }<br> ​<br>             c.JSON(http.StatusOK, gin.H{<br>                 &quot;token&quot;: token,<br>             })<br>             return<br>         }<br> ​<br>         // incorrect account or password<br>         c.JSON(http.StatusUnauthorized, gin.H{<br>             &quot;message&quot;: &quot;Unauthorized&quot;,<br>         })<br>     })<br> ​<br>     // protected member router<br>     authorized := router.Group(&quot;/&quot;)<br>     authorized.Use(AuthRequired)<br>     {<br>         authorized.GET(&quot;/member/profile&quot;, func(c *gin.Context) {<br>             if c.MustGet(&quot;account&quot;) == &quot;Kenny&quot; &amp;&amp; c.MustGet(&quot;role&quot;) == &quot;Member&quot; {<br>                 c.JSON(http.StatusOK, gin.H{<br>                     &quot;name&quot;: &quot;Kenny&quot;,<br>                     &quot;age&quot;: 23,<br>                     &quot;hobby&quot;: &quot;music&quot;,<br>                 })<br>                 return<br>             }<br> ​<br>             c.JSON(http.StatusNotFound, gin.H{<br>                 &quot;error&quot;: &quot;can not find the record&quot;,<br>             })<br>         })<br>     }<br> ​<br>     router.Run()<br> }<br> ​<br> // validate JWT<br> func AuthRequired(c *gin.Context) {<br>     auth := c.GetHeader(&quot;Authorization&quot;)<br>     token := strings.Split(auth, &quot;Bearer &quot;)[1]<br> ​<br>     // parse and validate token for six things:<br>     // validationErrorMalformed =&gt; token is malformed<br>     // validationErrorUnverifiable =&gt; token could not be verified because of signing problems<br>     // validationErrorSignatureInvalid =&gt; signature validation failed<br>     // validationErrorExpired =&gt; exp validation failed<br>     // validationErrorNotValidYet =&gt; nbf validation failed<br>     // validationErrorIssuedAt =&gt; iat validation failed<br>     tokenClaims, err := jwt.ParseWithClaims(token, &amp;Claims{}, func(token *jwt.Token) (i interface{}, err error) {<br>         return jwtSecret, nil<br>     })<br> ​<br>     if err != nil {<br>         var message string<br>         if ve, ok := err.(*jwt.ValidationError); ok {<br>             if ve.Errors &amp; jwt.ValidationErrorMalformed != 0 {<br>                 message = &quot;token is malformed&quot;<br>             } else if ve.Errors &amp; jwt.ValidationErrorUnverifiable != 0{<br>                 message = &quot;token could not be verified because of signing problems&quot;<br>             } else if ve.Errors &amp; jwt.ValidationErrorSignatureInvalid != 0 {<br>                 message = &quot;signature validation failed&quot;<br>             } else if ve.Errors &amp; jwt.ValidationErrorExpired != 0 {<br>                 message = &quot;token is expired&quot;<br>             } else if ve.Errors &amp; jwt.ValidationErrorNotValidYet != 0 {<br>                 message = &quot;token is not yet valid before sometime&quot;<br>             } else {<br>                 message = &quot;can not handle this token&quot;<br>             }<br>         }<br>         c.JSON(http.StatusUnauthorized, gin.H{<br>             &quot;error&quot;: message,<br>         })<br>         c.Abort()<br>         return<br>     }<br> ​<br>     if claims, ok := tokenClaims.Claims.(*Claims); ok &amp;&amp; tokenClaims.Valid {<br>         fmt.Println(&quot;account:&quot;, claims.Account)<br>         fmt.Println(&quot;role:&quot;, claims.Role)<br>         c.Set(&quot;account&quot;, claims.Account)<br>         c.Set(&quot;role&quot;, claims.Role)<br>         c.Next()<br>     } else {<br>         c.Abort()<br>         return<br>     }<br> }</pre><p>這邊為了方便示範JWT在RESTful API的作用，這邊只建立一個go檔案進行所有事情，並沒有做好的分層架構。</p><p>來一一解釋每段code的作用～</p><h3>建立custom claims</h3><pre>// custom claims<br> type Claims struct {<br>     Account string      `json:&quot;account&quot;`<br>     Role string         `json:&quot;role&quot;`<br>     jwt.StandardClaims<br> }</pre><p>在JWT原理介紹說過，JWT包含三大部分，分別是Header、Payload、Signature，這邊定義的Claims是指Payload的部分，例如想要在Payload裡面放使用者的Account(帳號)、Role(角色)資訊就可以在這邊定義，此外要加上一個jwt.StandardClaims作為Embedded，這個代表會加入標準的JWT Payload應有的屬性，例如：exp、iat、nbf等等。</p><h3>建立 JWT SecretKey</h3><pre>// jwt secret key<br> var jwtSecret = []byte(&quot;secret&quot;)</pre><p>這次示範採用JWT的簽名演算法是用HS256，這個是對稱式演算法，共用相同一把金鑰，因此要特別注意該密鑰不能外流，而在程式碼中定義也是相當危險的行為，事實上這種資料建議都採用環境變數的方式來存取，例如還有資料庫連線資訊等等，都應用環境變數的方式。</p><p>如果想知道JWT HS256跟RS256兩者演算法的差別及使用情境，可參考：<a href="https://stackoverflow.com/questions/39239051/rs256-vs-hs256-whats-the-difference">https://stackoverflow.com/questions/39239051/rs256-vs-hs256-whats-the-difference</a></p><p>在簡單的情況下可採用HS256即可。</p><p>然後要記住型態要宣告成[]byte，否則會出現key is of invalid type的錯誤訊息。</p><h3>定義login API路由</h3><pre>router.POST(&quot;/login&quot;, func(c *gin.Context) {<br>     // validate request body<br>     var body struct{<br>         Account string<br>         Password string<br>     }<br>     err := c.ShouldBindJSON(&amp;body)<br>     if err != nil {<br>         c.JSON(http.StatusBadRequest, gin.H{<br>             &quot;error&quot;: err.Error(),<br>         })<br>         return<br>     }<br> ​<br>     // check account and password is correct<br>     if body.Account == &quot;Kenny&quot; &amp;&amp; body.Password == &quot;123456&quot; {<br>         now := time.Now()<br>         jwtId := body.Account + strconv.FormatInt(now.Unix(), 10)<br>         role := &quot;Member&quot;<br> ​<br>         // set claims and sign<br>         claims := Claims{<br>             Account:        body.Account,<br>             Role:           role,<br>             StandardClaims: jwt.StandardClaims{<br>                 Audience:  body.Account,<br>                 ExpiresAt: now.Add(20 * time.Second).Unix(),<br>                 Id:        jwtId,<br>                 IssuedAt:  now.Unix(),<br>                 Issuer:    &quot;ginJWT&quot;,<br>                 NotBefore: now.Add(10 * time.Second).Unix(),<br>                 Subject:   body.Account,<br>             },<br>         }<br>         tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)<br>         token, err := tokenClaims.SignedString(jwtSecret)<br>         if err != nil {<br>             c.JSON(http.StatusInternalServerError, gin.H{<br>                 &quot;error&quot;: err.Error(),<br>             })<br>             return<br>         }<br> ​<br>         c.JSON(http.StatusOK, gin.H{<br>             &quot;token&quot;: token,<br>         })<br>         return<br>     }<br> ​<br>     // incorrect account or password<br>     c.JSON(http.StatusUnauthorized, gin.H{<br>         &quot;message&quot;: &quot;Unauthorized&quot;,<br>     })<br> })</pre><p>這個login API主要就是做三件事情：</p><ol><li>檢查Post Body是否有account、password</li><li>檢查account、password是否正確</li><li>若正確則給予JWT，不正確則回傳錯誤訊息</li></ol><p>因此在前面是用了gin框架檢查Post Body的方式：</p><pre>// validate request body<br> var body struct{<br>     Account string<br>     Password string<br> }<br> err := c.ShouldBindJSON(&amp;body)<br> if err != nil {<br>     c.JSON(http.StatusBadRequest, gin.H{<br>         &quot;error&quot;: err.Error(),<br>     })<br>     return<br> }</pre><p>主要要講解的是如何發放JWT：</p><pre>// check account and password is correct<br> if body.Account == &quot;Kenny&quot; &amp;&amp; body.Password == &quot;123456&quot; {<br>     now := time.Now()<br>     jwtId := body.Account + strconv.FormatInt(now.Unix(), 10)<br>     role := &quot;Member&quot;<br> ​<br>     // set claims and sign<br>     claims := Claims{<br>         Account:        body.Account,<br>         Role:           role,<br>         StandardClaims: jwt.StandardClaims{<br>             Audience:  body.Account,<br>             ExpiresAt: now.Add(20 * time.Second).Unix(),<br>             Id:        jwtId,<br>             IssuedAt:  now.Unix(),<br>             Issuer:    &quot;ginJWT&quot;,<br>             NotBefore: now.Add(10 * time.Second).Unix(),<br>             Subject:   body.Account,<br>         },<br>     }<br>     tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)<br>     token, err := tokenClaims.SignedString(jwtSecret)<br>     if err != nil {<br>         c.JSON(http.StatusInternalServerError, gin.H{<br>             &quot;error&quot;: err.Error(),<br>         })<br>         return<br>     }<br> ​<br>     c.JSON(http.StatusOK, gin.H{<br>         &quot;token&quot;: token,<br>     })<br>     return<br> }</pre><ol><li>首先檢查account、password是否符合Kenny及123456，當然這是為了示範，實務上應該要去資料庫存取，而且password也不應該是明碼。</li><li>接著我們就可以用前面宣告的Claims型態來定義我們的JWT，這邊基本上就是把Account、Role、標準的JWT Payload要有的資訊都填進去。當然看應用場景而定，簡單的話其實只要定義ExpiresAt即可。這邊設定是當發放JWT後的20秒該token就過期了，而NotBefore意思是在什麼時間點內該token是無效的，這邊定義發放後的10秒為無效。</li><li>定義好我們的JWT，接著就進行簽名，採用jwt.SigningMethodHS256演算法，並把前面定義的secret ket丟進去。如果這邊你key的型態是錯誤的，在這邊就會捕捉到錯誤。</li><li>若沒錯誤，就回傳正確的JWT給用戶端。</li></ol><h3>定義AuthRequired函式來檢查JWT是否正確</h3><p>當發放JWT出去，當使用者要存取受保護的API時，都應該帶著JWT，而後端都要檢查該JWT是否正確，如果正確才給予存取API，否則不允許。</p><p>直接看code：</p><pre>// validate JWT<br> func AuthRequired(c *gin.Context) {<br>     auth := c.GetHeader(&quot;Authorization&quot;)<br>     token := strings.Split(auth, &quot;Bearer &quot;)[1]<br> ​<br>     // parse and validate token for six things:<br>     // validationErrorMalformed =&gt; token is malformed<br>     // validationErrorUnverifiable =&gt; token could not be verified because of signing problems<br>     // validationErrorSignatureInvalid =&gt; signature validation failed<br>     // validationErrorExpired =&gt; exp validation failed<br>     // validationErrorNotValidYet =&gt; nbf validation failed<br>     // validationErrorIssuedAt =&gt; iat validation failed<br>     tokenClaims, err := jwt.ParseWithClaims(token, &amp;Claims{}, func(token *jwt.Token) (i interface{}, err error) {<br>         return jwtSecret, nil<br>     })<br> ​<br>     if err != nil {<br>         var message string<br>         if ve, ok := err.(*jwt.ValidationError); ok {<br>             if ve.Errors &amp; jwt.ValidationErrorMalformed != 0 {<br>                 message = &quot;token is malformed&quot;<br>             } else if ve.Errors &amp; jwt.ValidationErrorUnverifiable != 0{<br>                 message = &quot;token could not be verified because of signing problems&quot;<br>             } else if ve.Errors &amp; jwt.ValidationErrorSignatureInvalid != 0 {<br>                 message = &quot;signature validation failed&quot;<br>             } else if ve.Errors &amp; jwt.ValidationErrorExpired != 0 {<br>                 message = &quot;token is expired&quot;<br>             } else if ve.Errors &amp; jwt.ValidationErrorNotValidYet != 0 {<br>                 message = &quot;token is not yet valid before sometime&quot;<br>             } else {<br>                 message = &quot;can not handle this token&quot;<br>             }<br>         }<br>         c.JSON(http.StatusUnauthorized, gin.H{<br>             &quot;error&quot;: message,<br>         })<br>         c.Abort()<br>         return<br>     }<br> ​<br>     if claims, ok := tokenClaims.Claims.(*Claims); ok &amp;&amp; tokenClaims.Valid {<br>         fmt.Println(&quot;account:&quot;, claims.Account)<br>         fmt.Println(&quot;role:&quot;, claims.Role)<br>         c.Set(&quot;account&quot;, claims.Account)<br>         c.Set(&quot;role&quot;, claims.Role)<br>         c.Next()<br>     } else {<br>         c.Abort()<br>         return<br>     }<br> }</pre><p>這個是類似一個middleware的功能，可以加在受保護API的前面，也就是當存取受保護API時，都要先經過該函式，因此這邊就可以定義JWT Verify的功能。</p><p>首先先看：</p><pre>// parse and validate token for six things:<br> // validationErrorMalformed =&gt; token is malformed<br> // validationErrorUnverifiable =&gt; token could not be verified because of signing problems<br> // validationErrorSignatureInvalid =&gt; signature validation failed<br> // validationErrorExpired =&gt; exp validation failed<br> // validationErrorNotValidYet =&gt; nbf validation failed<br> // validationErrorIssuedAt =&gt; iat validation failed<br> tokenClaims, err := jwt.ParseWithClaims(token, &amp;Claims{}, func(token *jwt.Token) (i interface{}, err error) {<br>     return jwtSecret, nil<br> })</pre><p>這邊是go-jwt程式庫幫我們定義好的Verify的函式jwt.ParseWithClaims，它會幫我們做兩件事情：</p><ul><li>Parse JWT</li><li>Validate JWT</li></ul><p>但注意：需要提供一個func參數，這個func參數是要定義一個函式，而這個函式是要回傳secret key值跟error。在這邊可以看到我直接回傳了secret key跟nil，也就是沒做任何的條件判斷。事實上，你可以加入一些條件判斷，例如判斷讀取secret key環境變數是否成功，成功則回傳正確的key，不成功則回傳你自定義的error。那麼經由jwt.ParseWithClaims的時候，回傳的error就是你自定義的error，如果你回傳錯的key進去，而沒有傳自定義的error，則會回傳validationErrorUnverifiable，這個是由go-jwt幫我們定義好的error型態。</p><p>因此我們就可以來透過error型態來判斷JWT遇到什麼錯誤：</p><pre>if err != nil {<br>     message := err.Error()<br>     if ve, ok := err.(*jwt.ValidationError); ok {<br>         if ve.Errors &amp; jwt.ValidationErrorMalformed != 0 {<br>             message = &quot;token is malformed&quot;<br>         } else if ve.Errors &amp; jwt.ValidationErrorUnverifiable != 0{<br>             message = &quot;token could not be verified because of signing problems&quot;<br>         } else if ve.Errors &amp; jwt.ValidationErrorSignatureInvalid != 0 {<br>             message = &quot;signature validation failed&quot;<br>         } else if ve.Errors &amp; jwt.ValidationErrorExpired != 0 {<br>             message = &quot;token is expired&quot;<br>         } else if ve.Errors &amp; jwt.ValidationErrorNotValidYet != 0 {<br>             message = &quot;token is not yet valid before sometime&quot;<br>         } else {<br>             message = &quot;can not handle this token&quot;<br>         }<br>     }<br>     c.JSON(http.StatusUnauthorized, gin.H{<br>         &quot;error&quot;: message,<br>     })<br>     c.Abort()<br>     return<br> }</pre><p>jwt.ValidationError是go-jwt幫我們定義好了，方便我們檢驗錯誤的型態。因此在這邊可以透過型態判斷來得知屬於哪種error，這邊是採用位元運算來判斷。假設兩者的error是一樣的，它們的數字應該要一樣，因此進行 &amp; 運算，應 != 0。</p><p>所以如果剛剛在jwt.ParseWithClaims的func參數你有回傳自定義的error的話，這邊就不會進入jwt.ValidationError這邊，因為是不屬於該型態的，而是回傳你自定義的錯誤訊息。</p><p>最後，如果JWT是合法的話，就會進入下面這裡：</p><pre>if claims, ok := tokenClaims.Claims.(*Claims); ok {<br>     if claims.Account == &quot;&quot; || claims.Role == &quot;&quot; {<br>         c.JSON(http.StatusUnauthorized, gin.H{<br>             &quot;error&quot;: &quot;JWT token payload is improper&quot;,<br>         })<br>         c.Abort()<br>         return<br>     } else {<br>         fmt.Println(&quot;account:&quot;, claims.Account)<br>         fmt.Println(&quot;role:&quot;, claims.Role)<br>         c.Set(&quot;account&quot;, claims.Account)<br>         c.Set(&quot;role&quot;, claims.Role)<br>         c.Next()<br>     }<br> } else {<br>     c.JSON(http.StatusUnauthorized, gin.H{<br>         &quot;error&quot;: &quot;JWT token payload is improper&quot;,<br>     })<br>     c.Abort()<br>     return<br> }</pre><p>首先將jwt.ParseWithClaims回傳的tokenCliams進行型態判斷，理論上會是自定義的Cliams型態，如果不正確的話代表就是不合法的JWT，如果是是自定義的Cliams型態，可以在判斷是否有自定義的欄位，如果沒有的話也是當作不合法的JWT。如果有的話，就可以正式判斷該JWT是合法的，可以存取JWT Payload裡面的內容比較傳遞給受保護的API，讓其可以使用該資訊。</p><h3>受保護API路由</h3><pre>// protected member router<br> authorized := router.Group(&quot;/&quot;)<br> authorized.Use(AuthRequired)<br> {<br>     authorized.GET(&quot;/member/profile&quot;, func(c *gin.Context) {<br>         if c.MustGet(&quot;account&quot;) == &quot;Kenny&quot; &amp;&amp; c.MustGet(&quot;role&quot;) == &quot;Member&quot; {<br>             c.JSON(http.StatusOK, gin.H{<br>                 &quot;name&quot;: &quot;Kenny&quot;,<br>                 &quot;age&quot;: 23,<br>                 &quot;hobby&quot;: &quot;music&quot;,<br>             })<br>             return<br>         }<br> ​<br>         c.JSON(http.StatusNotFound, gin.H{<br>             &quot;error&quot;: &quot;can not find the record&quot;,<br>         })<br>     })<br> }</pre><p>這邊就不多加講解了，也就是當JWT是合法後，就能進入該API，而API也就能拿到JWT Payload裡面的資訊。</p><h3>總結</h3><p>jwt-go是個老牌的程式庫，但是其文件並沒有寫得很清楚，很多使用方式都是我去看source code來理解出來的。不過還好source code並沒有到很複雜，我覺得嘛雖然很多輪子都有前人造好了，但是還是要學會看原始碼的功力，這樣的話你才能有辦法去改造輪子，畢竟有時候輪子可能並不是很符合你的需求，有時候需求一改，可能就需要改造輪子來符合你的需求。像我覺得最後一段還要額外判斷是否有自定義的欄位在payload就很多餘，應該要在前面parse的那個函式就做掉會更理想。當然也可以想成，前面的jwt.ParseWithClaims是在驗證標準JWT Payload，而後面則是需要自己額外定義驗證加入的自定義欄位，這時候可能就可以想說如何去改造輪子，用起來更加舒適。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=225b377e0f79" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/golang-json-web-tokens-jwt-olang-json-web-tokens-jwt-%E7%A4%BA%E7%AF%84-225b377e0f79">Golang —  JSON Web Tokens(JWT)示範</a> was originally published in <a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88">企鵝也懂程式設計</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Golang — GOROOT、GOPATH、Go-Modules-三者的關係介紹]]></title>
            <link>https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/golang-goroot-gopath-go-modules-%E4%B8%89%E8%80%85%E7%9A%84%E9%97%9C%E4%BF%82%E4%BB%8B%E7%B4%B9-d17481d7a655?source=rss-e4adaf5f8fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/d17481d7a655</guid>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[back-end-development]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[Kenny Chen]]></dc:creator>
            <pubDate>Sun, 12 Jan 2020 08:53:25 GMT</pubDate>
            <atom:updated>2020-01-12T08:54:32.717Z</atom:updated>
            <content:encoded><![CDATA[<h3>Golang — GOROOT、GOPATH、Go-Modules-三者的關係介紹</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*30aoNxlSnaYrLhBT0O1lzw.png" /></figure><p>相信初學Golang語言的時候，一定會對GOROOT、GOPATH感到疑惑，究竟它們的差別在哪裡？而現在Golang語言版本已經來到1.13 Version，在1.11 Version新增了一個重大的功能那就是Go Modules，所以三者的差別是需要好好釐清的。</p><h3>GOROOT介紹</h3><p>在安裝完Golang語言的時候，所謂的安裝路徑其實就是你的GOROOT路徑，也就是說GOROOT存放的Golang語言內建的程式庫的所在位置，而通常你安裝完後，你電腦的環境變數就會設好GOROOT路徑，當你開發Golang程式的時候，當你import內建的程式庫的時候，並不需要額外安裝，而當程式運行後，預設也會先去GOROOT路徑下尋找相對應的程式庫來運行。</p><p>首先我們先看目前GOROOT路徑，透過以下指令：</p><pre>go env</pre><p>這樣可以看到當前有關Golang語言的全部相關環境變數設定，如下：</p><pre>...<br>set GOPATH=C:\Users\kenny\go<br>set GOROOT=c:\go<br>...</pre><p>通常如果你是初次安裝Golang語言並且沒做什麼環境變數設定的話，GOROOT設定路徑就是你當初安裝Golang語言的路徑，而GOPATH通常預設會是使用者目錄下的go資料夾。</p><p>那假設先在隨便的資料夾目錄下新增main.go檔案，程式碼內容如下：</p><pre>package main<br> ​<br> import &quot;fmt&quot;<br> ​<br> func main() {<br>     fmt.Println(&quot;Hello World&quot;)<br> }</pre><p>然後再執行以下指令：</p><pre>go run main.go</pre><p>就會成功輸出<strong>Hello World</strong>的字樣。go run其實會幫你將程式碼進行編譯並產生執行檔，而編譯檔跟執行檔事實上是存在一個暫存資料夾裡面，當運行完此程式就會自動刪除。該指令可以想成類似直譯的方式運行，而不需要做其他任何環境設定，即可運行。</p><p>那如果我們將程式碼改成這樣：</p><pre>package main<br> ​<br> import &quot;github.com/gin-gonic/gin&quot;<br> ​<br> func main() {<br>     router := gin.Default()<br>     router.Run()<br> }</pre><p>可以注意到import了一個<strong>github.com/gin-gonic/gin</strong>套件，這個是別人開發的Web Framework套件，是不存在於官方程式庫的，而是放在GitHub上的第三方套件。</p><p>那再執行這份程式碼，會出現以下的錯誤：</p><pre>main.go:3:8: cannot find package &quot;github.com/gin-gonic/gin&quot; in any of:<br>         c:\go\src\github.com\gin-gonic\gin (from $GOROOT)<br>         C:\Users\kenny\go\src\github.com\gin-gonic\gin (from $GOPATH)</pre><p>從這個訊息可以看出兩件事情：</p><ol><li>當執行Golang程式碼，當需要存取套件時，會先去GOROOT路徑下的src資料夾找同等於我們在程式碼中import的路徑下去找有沒有gin這個資料夾，而這資料夾裡面就是包含了所有有關於該套件的程式庫。</li><li>如果在GOROOT路徑下沒有找到，則會往GOPATH路徑下的src資料夾找同等於我們在程式碼中import的路徑下去找有沒有gin這個資料夾。</li></ol><p>所以只要GOROOT跟GOPATH路徑下都沒有找到該套件的話，就無法執行該程式碼。</p><h3>GOPATH介紹</h3><p>根據上面GOROOT的介紹，我們可以知道官方的程式庫所在位置就是在GOROOT裡面，而GOPATH就是專門存放第三方套件以供我們程式碼的需要。</p><p>那通常開發Golang的話，通常會在重新設定GOPATH的位置，例如像我習慣把我所有不同程式語言的專案都統一放在一個資料夾下，在去用語言去分類專案，所以這時候就需要設定GOPATH路徑。</p><p>採用指令如下：</p><pre>set GOPATH=&lt;PATH&gt;</pre><p><strong>&lt;PATH&gt;</strong>就是你想要放置Golang語言專案的地方，但是需要做成以下的分層：</p><pre>D:\CodingProject\GolangProject ---&gt; bin<br>                               ---&gt; pkg<br>                               ---&gt; src</pre><p>也就是<strong>&lt;PATH&gt;</strong>，實際上是D:\CodingProject\GolangProject，並不是D:\CodingProject\GolangProject\src，依照Golang語言的慣例(強制)，GOPATH是指src路徑的上一層，如果你去看GOROOT的設計，也是這樣的。而我們要在GOPATH路徑下主動新增src資料夾，所謂src就是代表source code的意思，也就是放我們開發Golang程式碼的相關專案的原始碼。</p><p>至於pkg、bin兩個資料夾是做什麼用的之後會提到。</p><p>所以一般開發上，會在src下創立專案資料夾，然後在專案資料夾在去新增package資料夾，在去寫相關的go語言程式碼。</p><p>例如實際上架構就會像是：</p><pre>D:\CodingProject\GolangProject\src\webDemo  ---&gt; controller<br>                                            ---&gt; model<br>                                            ---&gt; main.go</pre><p>假設是web專案的話，在controller跟model有你所設計的程式碼，而main.go就是所謂的主程式入口，裡面定義了main function。</p><p>這樣就能透過 go run main.go來啟動整個專案。</p><h3>go run、go build、go install的差別</h3><p>前面我們都只有提到用go run 來執行程式碼，但其實還有所謂的go build、go install等指令可以執行程式碼。</p><h3>go run介紹</h3><p>go run指令簡單來說就像是直譯的方式來執行程式碼，而在細節上它其實會將程式碼進行編譯，最後產生可執行檔案，然後運行該可執行檔案，產生程式執行後的結果，而可執行檔會放在特定的暫存檔裡面，執行完就會自動刪除了。通常開發上就是用於假設只是要測試一段程式碼，那就會用go run來執行。</p><h3>go build介紹</h3><p>go build指令就是將程式碼編譯為執行檔，例如：</p><pre>go build main.go</pre><p>這樣會在main.go當前目錄下產生一個main名稱的可執行檔，如果是Windows的話就是main.exe。也可以在build後面寫專案的名稱，那麼它會自動在當前專案資料夾下找package為main並且有main function的go檔案，在編譯成可執行檔。</p><p>例如：</p><pre>go build webDemo</pre><p>但記得如果把main function的go檔案放置在webDemo資料夾下的另一個package裡面的話，會讀取不到。</p><p>也可以透過以下指令指定build出來的可執行檔位置放置在哪：</p><pre>go build -o bin/main.exe src/webDemo/main.go</pre><p>-o 後面第一個參數代表產生出來執行檔路徑要放哪及名稱要取什麼，第二個參數代表要編譯哪一個go程式碼的路徑。從這邊就可以知道為什麼我們在GOPATH下要新增一個bin資料夾，依照官方慣例，GOPATH下會有一個bin資料夾專門就是放專案build出來的可執行檔。</p><p>但是go build有個缺點就是每次編譯程式碼，比較沒有效率，當專案架構越來越大，build的速度也就越來越慢。</p><h3>go install介紹</h3><p>因應go build的缺點，因此有go install指令，go install可以做兩件事情：</p><ul><li>將套件編譯成.a file</li><li>如果是main套件則編譯成可執行檔</li></ul><p>而有了第一項功能，在下次編譯的時候，就不會將套件的程式碼重新編譯，而是直接用編譯好的.a file。而.a file就位於GOPATH/pkg裡面。這就是為什麼golangGO慣例要在GOPATH下新增此三個資料夾，都是有用處的。</p><p>來看例子：</p><p>假設在src下新增兩個資料夾分別是mypkg跟mytest，而mypkg下新增一個mypkg.go檔案，程式碼如下：</p><pre>package mypkg<br> ​<br> import &quot;fmt&quot;<br> ​<br> func MyFunc() {<br>     fmt.Println(&quot;MyFunc&quot;)<br> }</pre><p>在mytest下新增一個mytest.go檔案，程式碼如下：</p><pre>package main<br> ​<br> import (<br>     &quot;mypkg&quot;<br> )<br> ​<br> func main() {<br>     mypkg.MyFunc()<br> }</pre><p>意思就是在mytest.go檔案中用了mypkg套件的相關函式。而可以透過go install指令先將mypkg編譯成.a file；</p><pre>go install mypkg</pre><p>以上是在src目錄下執行這個指令，也可以在mypkg下執行以下指令：</p><pre>go install</pre><p>就會發現在GOPATH/pkg/windows_amd64/mypkg.a有該檔案。</p><p>windows_amd64其實就是由GOOS_GOARCH這兩個環境變數所組合而成的，執行go env指令就可以看到，通常安裝golang語言時就會根據作業系統設定好名稱了。</p><p>特別注意：</p><ul><li>go install 如果要在非GOPATH路徑下使用的話，要先設定GOBIN環境變數，否則會出現錯誤</li><li>通常GOBIN環境變數就是設定GOPATH/bin。</li></ul><h3>GOPATH的缺點</h3><p>講完了GOROOT、GOPATH，不知道大家有沒有發現GOPATH的一個很大的缺點，那就是你相關的第三方套件只要不是官方程式庫，都需要放置在GOPATH/src的路徑下才可以使用。</p><p>也就是說通常我們會使用go get指令來獲取網路上的第三方套件，例如：</p><pre>go get github.com/gin-gonic/gin</pre><p>go get最常用在當我們想用別人公開在GitHub上的套件，可以幫我們從網路上clone到GOPATH/src裡面。雖然這樣很方便，但是你會發現GOPATH/src下的程式碼會很複雜，除了有你自己開發的專案資料夾，也包含其他第三方程式庫的專案資料夾。</p><p>再來，如果你開發的專案採用第三方套件是不同版本怎麼辦？以往的解決方法是要設定多組不同的GOPATH。雖然社群也有開發相對應的package manager，如Vendor、Dep來解決該問題，但畢竟不是官方主導的。</p><h3>Go Modules的誕生</h3><p>為了解決不被GOPATH的問題，因此官方在1.11開始推出了Go Modules的功能。Go Modules解決方式很像是Java看到Maven的做法，將第三方程式庫儲存在本地的空間，並且給程式去引用。</p><p>首先要先設定GO111MODULE環境變數，總共可以三種不同的值：</p><ul><li>auto</li></ul><p>默認值，go命令會根據當前目錄来决定是否啟用modules功能。需要滿足兩種情形：</p><ol><li>該專案目錄不在GOPATH/src/下</li><li>當前或上一層目錄存在go.mod檔案</li></ol><ul><li>on</li></ul><p>go命令會使用modules，而不會GOPATH目錄下查找。</p><ul><li>off</li></ul><p>go命令將不會支持module功能，尋找套件如以前GOPATH的做法去尋找。</p><p>我是建議要開發Go專案就不再使用GOPATH的功能了，而是採用Go Modules的做法，因此建議都設定為on。</p><p>而採用Go Modules，下載下來的第三方套件都在哪呢？其實就位在GOPATH/pkg/mod資料夾裡面。</p><p>來看個例子：</p><p>在GOPATH/src下建立一個專案資料夾：</p><pre>mkdir modtest</pre><p>然後在該資料夾下執行以下指令：</p><pre>go mod init &lt;module name&gt;</pre><p><strong>&lt;module name&gt;</strong>可填可不填，不填的話預設就是採用專案資料夾的名稱。執行之後可以看到會出現一個go.mod檔案，這檔案內容如下：</p><pre>module modtest<br> ​<br> go 1.13</pre><p>在此檔案內可以寫以下幾個關鍵字：</p><ul><li>module</li></ul><p>定義模組路徑</p><ul><li>go</li></ul><p>定義go語言 version</p><ul><li>require</li></ul><p>指定依賴的套件，預設是最新版，可以指定版本號</p><ul><li>exclude</li></ul><p>排除該套件和其版本</p><ul><li>replace</li></ul><p>使用不同的套件版本並替換原有的套件版本</p><ul><li>註解</li></ul><ol><li>// 單行註解</li><li>/* 多行註解 */</li><li>indirect 代表被間接導入的依賴包</li></ol><p>假設現在我要引入GitHub上的gin-gonic/gin的套件，如下定義：</p><pre>module modtest<br> ​<br> go 1.13<br> ​<br> require github.com/gin-gonic/gin v1.5.0</pre><p>再執行以下指令：</p><pre>go mod download</pre><p>會將需要的套件安裝在GOPATH/pkg/mod資料夾裡面。而且會發現出現一個go.sum的檔案，這個檔案基本上用來記錄套件版本的關係，確保是正確的，是不太需要理會的。</p><p>因此當下載完之後就可以在Go程式碼中引用囉：</p><pre>package main<br> ​<br> import &quot;github.com/gin-gonic/gin&quot;<br> ​<br> func main() {<br>     router := gin.Default()<br>     router.Run()<br> }</pre><p>這個就是在local 8080 port開啟一個web server～</p><p>如果將gin版本改成 v1.4.0再重新執行go mod download，就會發現在GOPATH/pkg/mod裡面gin-gonic會有兩個資料夾分別是gin@v1.4.0、gin@v1.5.0，藉此來區分版本。</p><p>當然其實也可以不執行go mod download，而直接運行go build or go install 也會自動將套件安裝在相對應的地方。</p><p>還有一種方式直接下載套件而不用在go.mod中定義：</p><pre>go get github.com/gin-gonic/gin@v1.5.0</pre><p>只要有開啟go modules功能，go get 就不會像以前一樣在GOPATH/src下放置套件檔案，而是會放在GOPATH/pkg/mod裡面，並且go.mod會寫好引入。</p><p>這樣也就不用使用go mod download指令了~</p><h3>總結</h3><p>Go Modules當然還有其他指令可以去玩玩，但就開發Go語言知道這些就差不多了，其他等有遇到在去看指令也可以，簡單來說Go Modules是Golang套件管理方式，這樣的方式也相對新手也比較好理解，我一開始碰Golang的時候，也被這些環境變數搞得很亂，畢竟之前設定環境既不像Java、Python、Node.JS那樣，會讓人感到難以上手，畢竟Golang語言當初設計是在Google大公司的情境，並且採用同一個Repository的方式去開發專案的。</p><p>我個人很喜歡Golang語言的，我大學大部分碰的靜態語言都是Java，雖然我還是滿喜歡Java，但Java有些時候令人詬病的物件開發方式，確實很煩人，而接觸Golang語言的時候，大部分是採用函數式開發，儘管Golang可以設計一些類似物件的方式，但是個人認為如果將兩者合在一起使用，其實是滿不錯的～</p><p>最讚的是Golang是專門開發Server Side的語言，特別合我的胃口，而且背後是Google大公司當親爹，以及一堆大公司正在積極地採用Golang開發新專案，或是重構舊專案來提升效能。</p><p>其實我覺得程式設計師，要會的語言不管是動態或靜態最好都要會各兩種，同時感受不同語言的奧妙之處，在不同情境下用不同語言，有時候還會迸出新想法呢~ ^^</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d17481d7a655" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/golang-goroot-gopath-go-modules-%E4%B8%89%E8%80%85%E7%9A%84%E9%97%9C%E4%BF%82%E4%BB%8B%E7%B4%B9-d17481d7a655">Golang — GOROOT、GOPATH、Go-Modules-三者的關係介紹</a> was originally published in <a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88">企鵝也懂程式設計</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JWT(JSON Web Token) — 原理介紹]]></title>
            <link>https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/jwt-json-web-token-%E5%8E%9F%E7%90%86%E4%BB%8B%E7%B4%B9-74abfafad7ba?source=rss-e4adaf5f8fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/74abfafad7ba</guid>
            <category><![CDATA[json-web-token]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[back-end-development]]></category>
            <category><![CDATA[jwt]]></category>
            <dc:creator><![CDATA[Kenny Chen]]></dc:creator>
            <pubDate>Mon, 06 Jan 2020 06:26:55 GMT</pubDate>
            <atom:updated>2020-01-06T06:26:55.930Z</atom:updated>
            <content:encoded><![CDATA[<h3>JWT(JSON Web Token) — 原理介紹</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sLWAKETzIemT7eUqWwL5TQ.png" /></figure><p>自從RESTful架構興起後，越來越多人提倡使用JWT來取代傳統Session的場景，到底什麼是JWT呢，來看看吧～</p><h3>JWT介紹</h3><ol><li>JWT是JSON Web Token的簡寫，是一種開放標準(<strong>RFC 7519</strong>)，也就是基於JSON object的編碼，並透過這個編碼進行傳遞資訊。</li><li>JWT會透過HMAC、RSA、ECDS等演算法進行加密</li><li>通常利用JWT來對使用者進行驗證，也就是使用者會先請求身分提供的伺服器給予該JWT，而後，只要使用者帶著這個JWT向資源伺服器請求資源，如果這個JWT是有效的，那麼就能獲取資源</li></ol><h3>JWT的組成</h3><p>JWT的組合可以看成是三個JSON object，並且用<strong>.</strong>來做區隔，而這三個部分會各自進行編碼，組成一個JWT字串。</p><p>也就是變成：<strong>xxxxx.yyyyy.zzzzz</strong></p><ul><li>Header</li></ul><p>由兩個欄位組合：</p><ol><li>alg</li></ol><p>也就是token被加密的演算法，如<strong>HMAC</strong>、<strong>SHA256</strong>、<strong>RSA</strong></p><p>2. typ</p><p>也就是token的type，基本上就是<strong>JWT</strong></p><p>範例：</p><pre>{<br>    &quot;alg&quot;: &quot;HS256&quot;,<br>    &quot;typ&quot;: &quot;JWT&quot;<br>}</pre><p>然後進行Base64進行編碼。Base64是透過64個字符來表示二進制數據的一種方法，編碼的方式是固定的而且是可以逆向解碼的，並不是那種安全的加密演算法。</p><ul><li>Payload</li></ul><p>這裡放的是聲明(Claim)內容，也就是用來放傳遞訊息的地方，在定義上有三種聲明：</p><ol><li>Registered claims</li></ol><p>可以想成是標準公認的一些訊息<strong>建議</strong>你可以放，但並不強迫，例如：</p><ul><li>iss(Issuer)：JWT簽發者</li><li>exp(Expiration Time)：JWT的過期時間，過期時間必須大於簽發JWT時間</li><li>sub(Subject)：JWT所面向的用戶</li><li>aud(Audience)：接收JWT的一方</li><li>nbf(Not Before)：也就是定義擬發放JWT之後，的某段時間點前該JWT仍舊是不可用的</li><li>iat(Issued At)：JWT簽發時間</li><li>jti(JWT Id)：JWT的身分標示，每個JWT的Id都應該是不重複的，避免重複發放</li></ul><p>2. Public claims</p><p>這個，可以想成是傳遞的欄位必須是跟上面Registered claims欄位不能衝突，然後可以向官方申請定義公開聲明，會進行審核等步驟，實務上在開發上是不太會用這部分的。</p><p>3. Private claims</p><p>這個就是發放JWT伺服器可以自定義的欄位的部分，例如實務上會放User Account、User Name、User Role等<strong>不敏感</strong>的數據。</p><p>所謂不敏感的數據就是不會放使用者的密碼等敏感數據，因為該Payload傳遞的訊息最後也是透過Base64進行編碼，所以是可以被破解的，因此放使用者密碼會有安全性的問題。</p><p>範例：</p><pre>{<br>  &quot;sub&quot;: &quot;1234567890&quot;,<br>  &quot;account&quot;: &quot;<a href="/service/mailto:kenny@example.com">kenny@example.com</a>&quot;,<br>  &quot;role&quot;: &quot;admin&quot;<br>}</pre><p>個人覺得通常都會放iat、exp等標準欄位，因為通常會需要檢查JWT發送時間及是否過期，以及還有使用者帳號，為了方便查詢使用者的一些數據，通常以前的做法是Session裡面存放使用者帳號，現在改用JWT的payload上存放，以及角色身分的定義，可以用來看該使用者是否有權限取得後端API的內容。</p><ul><li>Signature</li></ul><p>由三大部分組成：</p><ul><li>base64UrlEncode(header)</li><li>base64UrlEncode(payload)</li><li>secret</li></ul><p>也就是：</p><pre>HMACSHA256(<br>  base64UrlEncode(header) + &quot;.&quot; +<br>  base64UrlEncode(payload),<br>  secret)</pre><p>header跟payload中間用<strong>.</strong>來串接，secret是存放在伺服器端的秘密字串，最後將這三個部分串接再一起的字串進行加密演算法進行加密。</p><p>Note：</p><p>secret是要保存在伺服器端的，這個secret一旦外洩給客戶端，客戶端就可以自己產生JWT，並且透過該JWT存取資源，因此secret是永遠不該外流的。</p><p>最後將Header、Payload、Signature三者用<strong>.</strong>串聯在一起，就是一個合法簽發的JWT字串。</p><p>在JWT官網：<a href="https://jwt.io/">https://jwt.io/</a></p><p>有提供現成的JWT簽發工具，可以使用該工具來看產生的JWT字串長怎樣：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/1*Uz8ipymvwGZPRed2iYMtbA.jpeg" /></figure><p>我使用上面我寫的三個部份的內容各自填上去，左邊就會出現正確的JWT字串出來。紅色部分就是編碼後的Header、紫色部分就是編碼後的Payload，藍色部分就是將Header、Payload、Secrect合在一起並進行加密演算法加密後的編碼。最後就是用<strong>.</strong>來將三個部分串聯在一起。</p><h3>客戶端如何用JWT來訪問資源？</h3><ol><li>前端會先透過存取後端的登入API，後端驗證使用者帳密成功後，就會發放合法JWT字串</li><li>前端拿到JWT字串就會將JWT存放在Local Storage裡面</li><li>而後當前端要存取受保護的資源API時，只要在Header的填寫以下內容：</li></ol><pre>Authorization: Bearer &lt;JWT token&gt;</pre><p>4. 後端收到後，會去檢查Authorization的JWT token是否有效，如果有效，則允許前端訪問受保護的資源。在以前的Session的設計上，Session會存放在Redis等這種快取資料庫，每當使用者訪問受保護的資源時，會先去存取資料庫的Session進行比對，有效則讓使用者存取，以JWT的方式可以降低查詢資料庫的需求。</p><h3>JWT的優缺點</h3><p>優點：</p><ul><li>採用JSON object的形式，大部分的程式語言皆支援</li><li>可存放一些使用者資訊，但並非是敏感的資訊</li><li>整個JWT，只要Payload不要放過多的資訊，其實Size是相當小的</li><li>不用在Server的資料庫存放Session，特別適合多台Server的情境下，使得擴展性容易，因為多台Server要使用Session的話，會有共享Session的問題產生，</li><li>對於現在手機上的APP的應用特別好，使用者不用每次打開APP都要重新輸入帳號與密碼</li><li>支持跨域請求，不會有傳統用Cookie進行跨域請求等問題</li></ul><p>缺點：</p><ul><li>JWT沒辦法主動被中止，也就是說不能像Session一樣被強制無效，但是個人覺得這有很多方式可以避免</li><li>JWT一旦洩漏會有很大的安全性的問題，但是洩漏通常會透過兩種方式：</li></ul><ol><li>駭客使用你的電腦，並得知JWT</li></ol><p>這…你電腦都被攻陷了…那就不好說了XD</p><p>2. 使用中間人攻擊的方式，擷取客戶端傳送伺服器端的封包，並獲取JWT，但使用HTTPS傳輸可以大幅度降低該攻擊，只要定期更換SSL證書就可以了</p><h3>總結</h3><p>JWT之所以會興起，除了因為RESTful架構出現，加上現在微服務的架構的關係，一般來說上線的系統，不太可能用單台伺服器來處理一切，多台伺服器處理Session會有其麻煩性，雖然可以用統一的資料庫進行存放Session來控制，但是會有效能的問題。</p><p>不過其實這還有很多探討的空間，在這篇文章沒有去說，Session/Cookie的架構其實也是可以跟JWT並行，端看應用場景。但就我兩者都使用過的經驗來看，我覺得JWT的方式的確很簡單易懂，Session的機制有時候的確很煩人。</p><p>下次帶來有關JWT的一些語言相關Library的使用方式～以及在RESTful場景下使用方式。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=74abfafad7ba" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/jwt-json-web-token-%E5%8E%9F%E7%90%86%E4%BB%8B%E7%B4%B9-74abfafad7ba">JWT(JSON Web Token) — 原理介紹</a> was originally published in <a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88">企鵝也懂程式設計</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/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/%E5%BE%9E%E5%88%AA%E8%B3%87%E6%96%99%E5%BA%AB%E5%88%B0%E8%B7%91%E8%B7%AF-%E8%AB%96%E5%82%99%E4%BB%BD%E7%9A%84%E9%87%8D%E8%A6%81%E6%80%A7-71c65c15070e?source=rss-e4adaf5f8fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/71c65c15070e</guid>
            <category><![CDATA[backup]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[back-end-development]]></category>
            <dc:creator><![CDATA[Kenny Chen]]></dc:creator>
            <pubDate>Sun, 01 Dec 2019 04:33:07 GMT</pubDate>
            <atom:updated>2019-12-01T04:33:07.778Z</atom:updated>
            <content:encoded><![CDATA[<h3>從刪資料庫到跑路 — 論備份的重要性</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*Q9UqnulAKXwwA8y0Ps9c_Q.jpeg" /></figure><p>這其實是前陣子發生的事情了，那時候就覺得要紀錄一下，不過拖到現在才有時間寫XD</p><p>前陣子，在某台伺服器上線網站，但是因為伺服器不明原因，可能沒辦法開機了，由於這台伺服器是多人再用，所以在我不知情的情況下就被重灌了，當下聽到根本哭哭，因為資料庫的資料完全被洗掉了。</p><p>聽到這件事情，總和以下幾件事情須注意</p><h3>多人共用</h3><p>伺服器這東西嘛，當然最理想的狀況，是一個系統用一台，而不是在一台上面佈署多個系統，但是現實由於經費，加上是學生也未必有多個主機可以用。</p><p>這時候就須要考慮：</p><ul><li>權限控制</li></ul><p>通常掌管Database的，理論上他要有最高的權限，而不是其他人非掌管資料庫卻有權限直接存取資料庫，不論是CRUD哪個動作，都是不允許的。所以，存取資料庫的帳號密碼是一種保障的方式，當然此帳密也是不能夠輕易外流的。</p><ul><li>通常業界會使用的伺服器都是Linux，而Linux最高權限使用，都會需要輸入密碼，所以可以有一定程度保護伺服器，例如，最常聽到的笑話就是：</li></ul><pre>rm -rf /</pre><p>如果你是root權限，並且又執行這個指令就會刪除整個根目錄以下的所有檔案與目錄，也就是把整個系統都刪除了。然後你就可以跑路了….</p><ul><li>協調資料庫放的資料存在哪</li></ul><p>多人共用的話，假設多個系統使用的資料庫不一樣倒也還好，因為通常資料會存在安裝資料庫的路徑下，但如果使用同時同一個資料庫，那麼可能就要協調每個系統所放的資料路徑為何。</p><h3>備份很重要，不做嗎?</h3><p>備份這件事情對於資料庫來說真的真的真的非常重要，如果你上線一個系統，給使用者使用，你卻沒有做備份這件事情，這是一件非常蠢的一件事情，講白了是很低能。</p><p>回到前面，再重灌之前，雖然我有做備份的工作，我是每天晚上做備份，將資料多copy到硬碟上，但是重灌的時候把硬碟都洗乾淨了，所以備份的資料也就跟著沒了。</p><p>從那時候，我才覺得，哇靠，備份不是這樣備份的，因為你要想像如果你的伺服器整台硬體都壞掉怎辦?</p><ul><li>備份到雲端</li></ul><p>這個相信是最多人採用的選擇，雲端提供的公司有很多，任選一種即可，當然你說雲端公司有沒有可能會有誤刪你資料的那天?</p><p>有，但是相信機率不高，而且通常選擇有名的公司，例如Google，是有一定的品質的，不然就不會有那麼多人都願意選擇Google Drive放資料了。</p><ul><li>備份到另外一台主機的硬碟</li></ul><p>這很簡單，再多選擇一台主機，將資料備份到這台主機硬碟上，或是也可以拿那種外接硬碟也可以。</p><p>總之，以上兩件事情如果都並行，那當然是最理想的。</p><p>而備份的方式要怎麼啟動呢?</p><ol><li>寫script進行自動化備份 (沒有人在那邊手動備份會死的)</li><li>設定那些時間進行自動化備份</li></ol><p>就我的方式是：</p><ul><li>如果是Windows</li></ul><p>寫好.bat檔案，然後設定好排程任務，固定每天哪個時間去執行.bat檔案進行備份的動作</p><ul><li>如果是Linux</li></ul><p>就是寫crontab，一樣設定好時間並定時去做備份的動作</p><p>備份並不難，只是要熟悉一下不同作業系統的設定方式，當然最好要會寫那個作業系統的script檔案，當然其實也可以用一般的程式語言去撰寫，但其實很多餘，其實作業系統的script有些還滿強大的，但當然不常用就很容易忘記～有機會我也是要做個筆記了。</p><h3>好Docker一鍵部署不做嗎?</h3><p>這個算是多講的，但自從這件事情被重灌後，除了資料庫的資料沒了，更重要的是系統的所需要環境要重新建立，這是一件非常非常非常麻煩的一件事情，從那之後我體悟到，任何系統我一定要用docker去做一鍵部署的設定。</p><p>一鍵部署到底多香呢?</p><ol><li>在你想要的伺服器裡面裝Docker</li></ol><p>這邊特別注意，絕對絕對不裝Windows，因為就算你用Docker架好了，也不能夠外連，因為Windows他的Docker環境是虛擬機去做的。當然我不知道有甚麼辦法可以設定成功，總之我試了很久都沒成功。</p><p>所以建議伺服器環境一定要Linux，不管是你架在雲端平台好了，清一色選擇的作業系統都是Linux，業界架系統大多也是Linux，沒有人在跟你Windows的，有啦…還是有，但是我真的覺得Windows Server很爛。</p><p>2. 寫好docker-compose.yaml設定檔</p><p>這個設定檔可以寫好你系統所需要的環境，幫你在docker環境架設好container，例如你需要甚麼語言環境，資料庫環境、網頁伺服器等等，只要在這個設定檔寫好即可。</p><p>3. 執行以下指令</p><pre>docker-compose up -d</pre><p>一鍵部署加背後運行。</p><p>恩…然後你就不用做任何事情了，就架好了。</p><h3>總結</h3><p>其實很多學校上資料庫其實不會講到這些事情，但是備份的重要性其實應該是每個工程師的常識，不然就會被別人認為是非常沒有sense的。</p><p>很多東西在學校學不到，你需要自己上架系統，你才會去考慮很多事情，我也是透過去學習來的。</p><p>最後提醒大家，如果未來去外面公司工作，刪除掉資料庫，並且又沒有備份到的話，後果不堪設想，從刪資料庫到跑路不是說假的，更可能賠上大筆金額。</p><p>共勉之～</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71c65c15070e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/%E5%BE%9E%E5%88%AA%E8%B3%87%E6%96%99%E5%BA%AB%E5%88%B0%E8%B7%91%E8%B7%AF-%E8%AB%96%E5%82%99%E4%BB%BD%E7%9A%84%E9%87%8D%E8%A6%81%E6%80%A7-71c65c15070e">從刪資料庫到跑路 — 論備份的重要性</a> was originally published in <a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88">企鵝也懂程式設計</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[資料分析系列-探討決策樹(1)]]></title>
            <link>https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/%E8%B3%87%E6%96%99%E5%88%86%E6%9E%90%E7%B3%BB%E5%88%97-%E6%8E%A2%E8%A8%8E%E6%B1%BA%E7%AD%96%E6%A8%B9-1-1cc354484559?source=rss-e4adaf5f8fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/1cc354484559</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[jupyter-notebook]]></category>
            <category><![CDATA[decision-tree]]></category>
            <category><![CDATA[data-analysis]]></category>
            <dc:creator><![CDATA[Kenny Chen]]></dc:creator>
            <pubDate>Thu, 10 Oct 2019 13:58:32 GMT</pubDate>
            <atom:updated>2019-10-10T13:58:32.548Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*qGoft1C6qU7sVl3RomLM2g.png" /></figure><p>新的系列新的痛苦，因為這學期碩士課程中，我選修了一堂資料探勘的課，所以又要熟悉資料分析的一些理論及如何去用Python去實踐。</p><h3>何謂決策樹</h3><p>顧名思義，可以把它想成是樹狀圖的概念，正因為類似於樹圖，這個分析的過程很直覺也很簡單，也常常被用在分類的預測。它也是機器學習中監督式學習的一種，簡單來說就是在預設的分類下將一個物件透過條件一步一步地做決策將其分類到對應的分類裡面，而這個過程就是<strong>決策樹產生的過程</strong>。</p><h3>看個例子</h3><p>以我課堂上的例子去做舉例的話：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X5VO17IcEBVHc1S0HztRow.png" /></figure><p>這是我們的資料集，現在我想要透過這個資料集來進行分類，分類的目標是甚麼呢，我想要決定出怎樣的人是有<strong>買電腦(buys_computer)</strong>的。</p><p>那假設我選擇的分類條件如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yw77FlMEWXEXHaIB1-IPLg.png" /></figure><p>這是根據我選的分類條件而產生的其中一個決策樹的樣子。簡單來說決策樹就很像是一直<strong>if then else then</strong>的過程。可以看到根節點選擇<strong>age</strong>，而根據資料集<strong>age</strong>有<strong>&lt;=30、31..40、&gt;40</strong>這三個區間，而且<strong>31..40</strong>這個區間就是符合我們的目標有買電腦的人，因此節點到這邊就可以停了。而其他兩個節點，因為還無法決定出哪些人有買電腦，哪些人沒買電腦，因此要根據其它的分類的條件繼續往下分。就會產生上面這種的決策樹的圖。</p><p>這時候問題就來了….，我要怎麼知道我要選哪些分類條件當節點啊？一個一個試太麻煩了吧，而且如果節點的條件沒選好，可想而知決策樹的樹狀會越來越長，導致要很後面才能決定出結果。而且根據我們的資料集在看以上的樹狀圖，可以知道並不是所有的分類條件都會用到。</p><p>所以這時候就要介紹決策樹的演算法，能夠自動地幫我們選擇最好的節點當作分類的條件。</p><h3>決策樹演算法</h3><p>首先可以知道決策樹的演算法的基底，可以說是一種貪婪演算法，然後是<strong>top-down recursive divide-and-conquer</strong>的方式去實現的。</p><p>也就是：</p><ol><li>選擇所有的分類其中一個最好的分類，當作跟節點去分整個資料集</li><li>資料集會依據條件被拆成好幾個子資料集</li><li>每個子資料集再去選擇當下更好的分類，當作當下的節點去分子資料集</li><li>以上的動作遞迴去做，就會產生最理想的決策樹出來了。</li></ol><p>要注意的是：停止分類的情形是當所有的資料都屬於某一種分類下，無法再將當前的資料進行其他的分類，那麼就代表說可以停止分類這個動作了。</p><p>以這個例子來看：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8ICtgDHd81TZKHWG22MKXQ.png" /></figure><p>一個資料集，我們可以選擇這兩種屬性其中一種來進行分類，哪一種比較好呢？其中最重要的就是這個節點選下去之後，最好能夠把資料分類得一清二楚。因此我們可以知道<strong>Attribute1</strong>是比較好的，因為這個屬性可以將我們的資料集分類的比較<strong>pure</strong>。</p><p>那用以上的這種想法，可以去計算以下兩種東西：</p><ol><li>Information Gain(資訊獲利)</li><li>Gini Index(吉尼指數)</li></ol><p>來一一介紹兩種的方式。</p><h3>Information Gain</h3><p>那事實上如何去計算Information Gain的實作演算法有ID3、C4.5、C5.0….等等。其中後者兩個是ID3的改進版本。基本上它們的原理就是去算出哪個分類屬性有較高的<strong>Information Gain</strong>就先選擇哪個分類屬性下去分，而這個計算需要先算出<strong>entropy</strong>。</p><p>什麼是<strong>entropy</strong>：</p><p>就是用來度量資訊量的東西，也就是假設有一個資料集很純淨，就像是沒辦法用甚麼其他屬性下去分類，以及有一個資料集較雜亂，可以用很多屬性下去分類，那我們可以說純淨的資料集，假設資料都一致，那<strong>entropy = 0</strong>，反之雜亂的資料集如果各有一半不同，那<strong>entropy = 1</strong>。</p><p>因此如果決策樹採用<strong>Information Gain</strong>的方式，要先算出每個節點分類的<strong>entropy</strong>，在選擇節點較小的<strong>entropy</strong>，因為越小的<strong>entropy</strong>代表<strong>Information Gain</strong>越高，因此就要選這個節點進行分類，才會將資料集分類到越來越<strong>pure</strong>的狀態。</p><p><strong>entropy的公式如下</strong>：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/524/1*WYh2LlHl5DrLjzVJ0n6-HA.jpeg" /></figure><p>p：成功的機率（或true的機率)</p><p>q：失敗的機率(或false的機率)</p><p>直接來看例子：</p><p>以上面學生的資料集來看，決策樹的最終目標是要分類出有買電腦的人跟沒買電腦的人。</p><p>也就是p = buys_computer(YES)的機率 q = buys_computer(NO)的機率</p><p>好，接下來用python的程式來做講解：</p><ol><li>定義entropy的函式算法</li></ol><pre>import numpy as np<br>def entropy(i, j):<br>    if i == 0 or j == 0:<br>        return 0<br>    p = i / (i + j)<br>    return - p*np.log2(p) - (1 - p)*np.log2((1 - p))</pre><p>這邊使用numpy的套件來幫助計算，特別注意當i或j=0，則entropy=0，為什麼呢？</p><p>因為這邊i、j的意思各自代表有買電腦的人數、沒買電腦的人數，只要任何一個為0，那麼就代表目前這個entropy是很pure的，也就是說已經沒有分類的意義了，代表說這個分類屬性一分類下去有無買電腦的區分就很明顯。</p><p>2. 計算當前資料集的entropy</p><p>目前的資料集因為還沒分類，必須知道當前資料集它的entropy，也就是雜亂程度：</p><pre>ori_entropy = entropy(9, 5)<br>ori_entropy<br># 0.9402859586706309</pre><p>3. 分類屬性選擇age</p><p>計算如果一開始的分類選擇age，那麼選擇之後，我們的資料集的entropy會呈現怎樣呢？</p><p>這邊特別注意age有三種條件，分別是&lt;=30、31…40、&gt;40，因此需要個別計算在age這三個不同區間下有無買電腦的entropy，並進行加總，最後在用當前資料集的entropy去相減，就能算出選擇age這個屬性之後所產生的<strong>information gain</strong>。</p><pre>age_entropy = 5/14 * entropy(2, 3) + 4/14 * entropy(4, 0) + 5/14 * entropy(3, 2)<br>print(f&#39;age_entropy: {age_entropy}&#39;)<br>age_gain = ori_entropy - age_entropy<br>print(f&#39;age_gain: {age_gain}&#39;)<br># age_entropy: 0.6935361388961918<br># age_gain: 0.2467498197744391</pre><p>4. 分類屬性選擇income</p><p>這邊就按照age的類似步驟，就不多加講解</p><pre>income_entropy = 4/14 * entropy(2, 2) + 6/14 * entropy(4, 2) + 4/14 * entropy(3, 1)<br>income_entropy<br>print(f&#39;income_entropy: {income_entropy}&#39;)<br>income_gain = ori_entropy - income_entropy<br>print(f&#39;income_gain: {income_gain}&#39;)<br># income_entropy: 0.9110633930116763<br># income_gain: 0.029222565658954647</pre><p>5. 分類屬性選student</p><p>這邊就按照age的類似步驟，就不多加講解</p><pre>student_entropy = 7/14 * entropy(6, 1) + 7/14 * entropy(3, 4)<br>student_entropy<br>print(f&#39;student_entropy: {student_entropy}&#39;)<br>student_gain = ori_entropy - student_entropy<br>student_gain<br>print(f&#39;student_entropy: {student_entropy}&#39;)<br># student_entropy: 0.7884504573082896<br># student_gain: 0.15183550136234136</pre><p>6. 分類屬性選credit_rating</p><p>這邊就按照age的類似步驟，就不多加講解</p><pre>credit_rating_entropy = 6/14 * entropy(3, 3) + 8/14 * entropy(6, 2)<br>credit_rating_entropy<br>print(f&#39;credit_rating_entropy: {credit_rating_entropy}&#39;)<br>credit_rating_gain = ori_entropy - credit_rating_entropy<br>credit_rating_gain<br>print(f&#39;credit_rating_entropy: {credit_rating_entropy}&#39;)<br># credit_rating_entropy: 0.8921589282623617<br># credit_rating_gain: 0.04812703040826927</pre><p>7. 最後我們排序就可以知道：</p><pre>print(age_gain &gt; student_gain &gt; credit_rating_gain &gt; income_gain)<br># True</pre><p>age_gain是最高的，也就是一開始的分類屬性應該從age開始！</p><p>之後的算法依此類推，用過濾之後的資料集繼續進行以上的步驟，直到可以把資料集完全分開的情況產生。基本上就會像上面那張決策樹的圖一樣，是最理想的情況。</p><h3>Gini Index</h3><p>GINI Index的實作演算法是CART tree。CART是Classification And Regression Tree的縮寫，因此兼具分類與迴歸兩種功能。</p><p>要注意的是Gini Index與Information Gain兩者有一個最大的差別：INFORMATION GAIN一次可產生多個不同節點，而Gini Index一次僅能產生兩個，即True或False的Binary的二元分類樹。</p><p>公式如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/551/1*i-y-PrHhrkaLoLC5cyAN0Q.jpeg" /></figure><p>p：成功的機率（或true的機率)</p><p>q：失敗的機率(或false的機率)</p><p>直接用上面的例子來計算：</p><ol><li>定義gini的函式</li></ol><pre>def gini(i, j):<br>    p = 0<br>    if i != 0 or j != 0:<br>        p = i / (i + j)<br>    return 1 - p*p - (1-p)*(1-p)</pre><p>特別注意如果i、j都=0的話，那就代表p=0，避免程式錯誤因此這邊作條件的檢查。</p><p>2. 選擇income屬性</p><p>總共可以分為三種subset</p><ul><li>{low, medium}、{high}</li><li>{low, high}、{medium}</li><li>{medium, high}、{low}</li></ul><pre>gini_income_1 = 10/14 * gini(7, 3) + 4/14 * gini(2, 2)<br>gini_income_2 = 8/14 * gini(5, 3) + 6/14 * gini(4, 2)<br>gini_income_3 = 10/14 * gini(6, 4) + 4/14 * gini(3, 1)<br>print(&#39;gini_income_1:&#39;, gini_income_1)<br>print(&#39;gini_income_2:&#39;, gini_income_2)<br>print(&#39;gini_income_3:&#39;, gini_income_3)<br># gini_income_1: 0.44285714285714284<br># gini_income_2: 0.4583333333333333<br># gini_income_3: 0.45</pre><p>從以上三種計算選出最小的gini，才是最好的分割結果，後面其他屬性計算以此類推，所以後面就不多加講解了</p><p>3. 選擇age屬性</p><p>總共可以分為三種subset</p><ul><li>{youth, middle}、{senior}</li><li>{youth, senior}、{middle}</li><li>{middle, senior}、{youth}</li></ul><pre>gini_age_1 = 9/14 * gini(6, 3) + 5/14 * gini(3, 2)<br>gini_age_2 = 10/14 * gini(5, 5) + 4/14 * gini(4, 0)<br>gini_age_3 = 9/14 * gini(7, 2) + 5/14 * gini(2, 3)<br>print(&#39;gini_age_1:&#39;, gini_age_1)<br>print(&#39;gini_age_2:&#39;, gini_age_2)<br>print(&#39;gini_age_3:&#39;, gini_age_3)<br># gini_age_1: 0.45714285714285713<br># gini_age_2: 0.35714285714285715<br># gini_age_3: 0.3936507936507937</pre><p>4. 選擇student屬性</p><p>總共可以分為一種subset</p><ul><li>{no}, {yes}</li></ul><pre>gini_student_1 = 7/14 * gini(3, 4) + 7/14 * gini(6, 1)<br>print(&#39;gini_student_1:&#39;, gini_student_1)<br># gini_student_1: 0.3673469387755103</pre><p>5. 選擇credit_rating屬性</p><p>總共可以分為一種subset</p><ul><li>{fair}, {excellent}</li></ul><pre>gini_credit_1 = 8/14 * gini(6, 2) + 6/14 * gini(3, 3)<br>print(&#39;gini_credit_1:&#39;, gini_credit_1)<br># gini_credit_1: 0.42857142857142855</pre><p>6. 從以上屬性中算出來的gini，選出最小的</p><pre>print(gini_age_2 &lt; gini_student_1 &lt; gini_credit_1 &lt; gini_income_1)<br># true</pre><p>因此，可以知道選age這個分類屬性所獲得的gini index最小，因此第一個應該要選擇的條件就是age。 當age這個作為條件的母節點依序去往剩下的資料集遞迴以上的步驟，就可以出來理想中最好的決策樹的圖。</p><h3>總結</h3><p>這篇主要講解決策樹的主要兩種思路 — — — <strong>Information Gain</strong>、<strong>Gini Index</strong>，兩者演算法皆有其適用的地方及優劣之處，之後有機會再補充該注意的知識點…..累爆～～～</p><p>歡迎來我個人部落格觀看： <a href="https://kennychen-blog.herokuapp.com/">https://kennychen-blog.herokuapp.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1cc354484559" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/%E8%B3%87%E6%96%99%E5%88%86%E6%9E%90%E7%B3%BB%E5%88%97-%E6%8E%A2%E8%A8%8E%E6%B1%BA%E7%AD%96%E6%A8%B9-1-1cc354484559">資料分析系列-探討決策樹(1)</a> was originally published in <a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88">企鵝也懂程式設計</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python-jupyter-notebook互動式平台介紹]]></title>
            <link>https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/python-jupyter-notebook%E4%BA%92%E5%8B%95%E5%BC%8F%E5%B9%B3%E5%8F%B0%E4%BB%8B%E7%B4%B9-9b22e66ff854?source=rss-e4adaf5f8fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/9b22e66ff854</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[jupyter-notebook]]></category>
            <category><![CDATA[programming-languages]]></category>
            <dc:creator><![CDATA[Kenny Chen]]></dc:creator>
            <pubDate>Tue, 01 Oct 2019 12:01:03 GMT</pubDate>
            <atom:updated>2019-10-01T13:14:49.409Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*bdJlmaARH7gHF_FV8aGoxQ.png" /></figure><h3>Python - jupyter notebook互動式平台介紹</h3><p>這篇文章，主要講述如何安裝並操作<strong>jupyter notebook</strong>。這個平台在<strong>Python</strong>界，可以說是非常知名，最大的特點就在於說，它除了提供互動式的方式，還提供了視覺化的產生，使得我們執行程式可以方便我們快速看到結果。</p><h3>介紹 jupyter notebook</h3><p>jupyter notebook裡面的實現，其實是採用<strong>IPython</strong>，<strong>IPython</strong>是一種交互式解釋器，比起<strong>Python</strong>原生的交互式解釋器，多了不少功能，除了支援變數自動補全，自動縮排，內建了許多很有用的功能和函式，通常都會用在科學計算及資料視覺化。而<strong>jupyter notebook</strong>可以想成是<strong>web版的IPython</strong>，此外它現在也逐漸支援其他語言，而不是只有<strong>Python</strong>。</p><h3>安裝並啟動 jupyter notebook</h3><p>在安裝前，記得主機上已經要有<strong>Python3</strong>的環境，因為我們要透過<strong>pip(Python的管理套件工具)</strong>，來進行安裝。此外，建議先將<strong>pip的版本先更新到最新版</strong>，避免出錯。</p><p>更新<strong>pip</strong>：</p><pre>pip install --upgrade pip</pre><p>安裝<strong>jupyter notebook</strong>：</p><pre>pip install jupyter</pre><p>啟動<strong>jupyter notebook</strong>：</p><pre>jupyter notebook</pre><p>這個命令它會自動開啟一個local端的jupyter notebook，或是它會在terminal上，列出以下網址：</p><p><a href="http://localhost:8888/?token=8ab82a55ab3d3e0613a16605f61aeeb54370c184bf83af56">http://localhost:8888/?token=8ab82a55ab3d3e0613a16605f61aeeb54370c184bf83af56</a></p><p>也可以透過點擊這個網址來開啟。</p><p>畫面如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dmSR2o4-jDf6bcRXLI1UWw.jpeg" /></figure><p>這邊會列出你當前termial目錄下有哪些檔案，所以滿方便的。</p><p>接著可以點擊右邊的<strong>New</strong>，來產生副檔名為<strong>.ipynb</strong>的檔案，透過這個檔案我們可以在裡面撰寫<strong>Python的程式碼</strong>。</p><p>畫面如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/197/1*UN7iZXjYj5ksm_32eICPOQ.jpeg" /></figure><p>選擇Notebook下的Python版本，就可以產生<strong>.ipynb</strong>的檔案，並且使用哪個版本的Python環境。</p><p>新增之後畫面如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vdX15urBX7DObF_15WkuqQ.jpeg" /></figure><p>基本上首先要理解的就是：</p><p>在jupyter notebook裡面，執行程式碼是以區塊去執行的，通常程式碼會分好幾個區塊，每個區塊做不同的事情，然後就可以每個區塊去看執行結果，也可以一次執行多個區塊來看多個執行結果。</p><p>例如：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LAKwRdqR_AaEgBMyuwXEpw.jpeg" /></figure><p>我們就可以區塊內撰寫python的程式碼，當我們寫好後，只要點擊要執行的區塊，在按快捷鍵：<strong>shift+enter</strong></p><p>便可在區塊的下方秀出你的程式碼的執行結果。</p><p>這邊可以特別注意，假設你想秀出結果，放在區塊的最後一行程式碼，即使不寫<strong>print</strong>函式，也會秀出來：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_MIRYSrP4Iu5k7qYorjZyg.jpeg" /></figure><h3>jupyter notebook 特殊用法</h3><p>這邊介紹<strong>jupyter notebook 一些特殊用法，及常見的快捷鍵</strong>。</p><ol><li>利用<strong>?</strong>這個字元，放在函式前面，可以取得該函式的document，及相關用法。可以發現下方會出現，這個函式的<strong>dotstring</strong>，從這可以看出這個函式的功用是什麼，方便我們去做查詢。也可以對程式碼裡面產生的變數進行使用，就可以該變數的型態，以及裡面資料值及長度：</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DDpN4Ix2ir6QVg81k4kGOA.jpeg" /></figure><p>再來可以創建自定義的函式，而如果有在程式碼中撰寫該函式的<strong>dotstring</strong>，就會在之後看到自己定義的<strong>dotstring</strong>：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VD9x7E1_EjLwf-kfvI0-pg.jpeg" /></figure><p>2. 可以透過<strong>??</strong>，取得該函式的source code。</p><p>例如，如果我們在jupyter notebook中，定義了函式，再透過<strong>??</strong>去存取會得到以下的結果：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/959/1*MeyQqFIAMJD0ma4QSFKlew.jpeg" /></figure><p>以剛剛的<strong>say_hello</strong>函式為例子，可以發現下方會取得<strong>該函式的source code</strong>。但是要注意這不能用在一些非python建立的函式，因為主流python底層是用C語言實現，所以有些函是底層是C去完成的，使用<strong>??</strong>的效果會跟<strong>?</strong>一樣。</p><p>3. TAB鍵的功用，可自動產生相關的函式，方便使用</p><p>直接看例子：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/957/1*Lj4bHTZNW2bNX0lNrRxrFg.jpeg" /></figure><p>假設現在你想要用<strong>Python的list相關的函式</strong>，卻忘記有哪些可以用了，如果我們是用像是<strong>Pycharm</strong>這種IDE，當然會自動跳出上面圖片的功能，而在<strong>jupyter</strong>中，就是在<strong>.</strong>後面點擊<strong>TAB</strong>鍵，就會產生這樣的效果。</p><p>當然也可以用成先輸入幾個字，假設你只記得你要用的函式錢幾個英文字母而已的話：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*oFpki3zLH0kHkFSAh3ABBw.jpeg" /></figure><p>如果要取得內部屬性，可在前面加<strong>_</strong>，即可搜尋到：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/959/1*TlCy_TPMUDJvjHLQbmT_8g.jpeg" /></figure><p>此外，也能用在<strong>import package</strong>的時候，例如：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/1*r_uFaQCt6QnW4g7I_KlRoA.jpeg" /></figure><p>就可以知道當前的<strong>python環境</strong>有哪些模組可以使用。</p><p>4. 常用的快捷鍵，幫助開發速度。</p><p>魔術快捷鍵</p><p>官方稱這個為<strong>magic commands</strong>，其實滿多的，詳細的話可以去看官方文件，這邊只講兩個比較常用的。</p><ul><li>%time</li></ul><p>在做一些科學運算的時候，常常都會在乎運算時間的長短，在這邊最耳熟能詳的套件就是<strong>numpy</strong>，它的數學運算的性能相對於<strong>python</strong>內建的套件的性能就相當的優秀。</p><p>直接看例子：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*yMInOZeWg2GuS3XVuC10gg.jpeg" /></figure><p><strong>Wall time</strong>可以把它想成是這行程式碼花了多少時間，因此透過<strong>%time</strong>，它可以給我們這一行程式碼運行花了多少時間，可以知道<strong>numpy的sum跟內建的sum</strong>，有一定時間上的差距。</p><ul><li>%timeit</li></ul><p>直接看例子：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/943/1*_dHkE6qdbJgvEUP9z8bdPA.jpeg" /></figure><p>這邊我們可以知道，它給出的是每個loop中，平均會花費多少時間，簡單來說，它會自動多次執行該程式碼，最後產生精確平均會花的時間。</p><p>一般快捷鍵</p><ol><li>這邊講解比較常用的：</li><li>Shift+Enter：運行該<strong>cell</strong>，並跳到下一個<strong>cell</strong>。</li><li>Ctrl+Enter：運行該<strong>cell</strong>，不跳到下一個<strong>cell</strong>。</li><li>Esc：對該<strong>cell</strong>，進入編輯模式，可執行其他快捷鍵命令，或可選擇是否要<strong>code</strong>模式，還是<strong>markdown</strong>模式。按下<strong>M</strong>轉成markdown，按下<strong>Y</strong>轉成code模式。</li><li>方向鍵：按下<strong>Esc</strong>之後就可透過方向鍵上下來選取<strong>cell</strong>，也可用英文字母的<strong>K</strong>跟<strong>J</strong>來代表上下。</li><li>A：按下<strong>Esc</strong>之後，在按<strong>A</strong>，就可在當前的<strong>cell</strong>上方插入新<strong>cell</strong>。</li><li>B：按下<strong>Esc</strong>之後，在按<strong>B</strong>，就可在當前的<strong>cell下方插入新</strong>cell**。</li><li>X：按下<strong>Esc</strong>之後，在按<strong>B</strong>，就可刪除當前的<strong>cell</strong>。</li></ol><p>剩下的部分可參考官方文件，或是參考這個網址：</p><p><a href="http://opus.konghy.cn/ipynb/jupyter-notebook-keyboard-shortcut.html">http://opus.konghy.cn/ipynb/jupyter-notebook-keyboard-shortcut.html</a></p><h3>總結</h3><p><strong>jupyer notebook</strong>對於視覺化或是資料處理及計算都滿有幫助的，對新手初學<strong>Python</strong>，也有一定的幫助，不過如果是寫大型的專案，我還是喜歡用<strong>PyCharm</strong>，之後再發文講解<strong>PyCharm</strong>，堪稱開發python的神器！</p><p>之後會利用<strong>jupyter notebook的環境帶來numpy、pandas、sklearn等相關資料處理套件的講解</strong>。</p><p>歡迎來看我的個人部落格： <a href="https://kennychen-blog.herokuapp.com/">https://kennychen-blog.herokuapp.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9b22e66ff854" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/python-jupyter-notebook%E4%BA%92%E5%8B%95%E5%BC%8F%E5%B9%B3%E5%8F%B0%E4%BB%8B%E7%B4%B9-9b22e66ff854">Python-jupyter-notebook互動式平台介紹</a> was originally published in <a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88">企鵝也懂程式設計</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python-型態大哉問]]></title>
            <link>https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/python-%E5%9E%8B%E6%85%8B%E5%A4%A7%E5%93%89%E5%95%8F-8c5100657224?source=rss-e4adaf5f8fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/8c5100657224</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[programming-languages]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[tutorial]]></category>
            <dc:creator><![CDATA[Kenny Chen]]></dc:creator>
            <pubDate>Tue, 24 Sep 2019 01:24:14 GMT</pubDate>
            <atom:updated>2019-09-28T08:03:01.423Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*W5Tm6quiHlm0po50wi1ULQ.png" /></figure><p>這篇文章用來紀錄Python裡面的型態。</p><p>不管是怎樣的程式語言，內建型態通常都會有整數、浮點數、布林、字串、陣列等等。這些可以說是每個程式語言都一定需要的型態。</p><h3>型態</h3><p>在開始講型態之前，要知道一件事情，在<strong>Python中，萬物都是物件！</strong>，在Python寫下一個數字，這個數字在Python中就是一個物件，它是有屬性、函式等這些功能，這個感覺在後面就會慢慢體會到了。</p><h3>從內建型態開始講起</h3><h4>整數型態</h4><p>Python的整數，不同於<strong>Java</strong>這語言，有區分短整數、長整數。通常以Java來看的話：</p><pre>int a = 10;<br>long b = 20;</pre><p>會分為<strong>int型態</strong>及<strong>long型態</strong>，差別就在於能容納的位數不同。</p><p>但以<strong>Python</strong>來看的話：</p><pre>a = 10<br>b = 20000000000000000000000000000000000000</pre><p>這個在<strong>Python</strong>想產生多大的位數，基本上是無限制，取決於你的主機內存。因此在<strong>Python</strong>中，整數型態就叫<strong>int</strong>。</p><p>那如果在程式中寫二進位、八進位、十六進位的數字呢？</p><p>在二進位中需要在數字前加入<strong>0b或0B</strong>：</p><pre>a = 0b1010<br># a = 10<br>b = 0B1010<br># b = 10</pre><p>在八進位需要在數字前加入<strong>0o或0O</strong></p><pre>a = 0o12<br># a = 10<br>b = 0O12<br># b = 10</pre><p>在十六進位需要在數字前加入<strong>0x或0X</strong></p><pre>a = 0xA<br># a = 10<br>b = 0XA<br># b = 10</pre><p>在<strong>Python</strong>中如果要知道寫在程式中的數字是甚麼型態要怎麼做？</p><pre>type(10)<br># &lt;class &#39;int&#39;&gt;<br>a = 10<br>type(a)<br># &lt;class &#39;int&#39;&gt;</pre><p>使用<strong>type</strong>函式，將數字或變數放進去，就可以知道是int類別的實例，也呼應一開始說的任何型態在<strong>Python</strong>都是物件。</p><h4>浮點數型態</h4><p>這個顧名思義就是數學上小數的意思。在<strong>Python</strong>中稱為<strong>float型態</strong>，例如：</p><pre>a = 3.14<br>b = 1.414</pre><h4>布林型態</h4><p>布林，如果有學過邏輯學都知道，只有兩種值，<strong>True、False</strong>，在<strong>Python</strong>中稱為<strong>bool型態</strong>。而在電腦中因為只看得懂0或1，因此事實上程式在運行時，布林型態會自動轉成1或0，也就是<strong>True代表1，False代表0</strong>。</p><p>例如：</p><pre>a = True<br>b = False</pre><p>在<strong>Python中記得T跟F皆為大寫</strong>。</p><h4>字串型態</h4><p>在<strong>Python</strong>中如果要表示字串，可以用單引號(‘ ‘)或雙引號(“ “)，來包括文字，一般來說<strong>Python</strong>慣例中，習慣以單引號作為表示字串之用，雙引號則是拿來輔助用的！</p><p>例如：</p><pre>name = &#39;Kenny&#39;<br>dog = &quot;Kenny&#39;s dog&quot;</pre><p>假設在字串中，我們需要表達單引號的話，我們就可以把雙引號括在外面，單引號當作文字的一部分，如此以來就不會像其他語言需要一些輔助。</p><p>另外像在<strong>Java</strong>中，如果要表達<strong>\</strong>這個符號，通常會需要以下操作：</p><pre>System.out.println(&quot;C:\\hello&quot;);</pre><p>也就是需要特別在<strong>\</strong>前面再多加一個<strong>\</strong>。</p><p>而在<strong>Python</strong>中：</p><pre>print(&#39;C:\hello&#39;)</pre><p><strong>Python</strong>看到<strong>\</strong>會自動視為<strong>\\</strong>，也就是幫你自動進行轉換的工作了～</p><p>當然還是會有例外的時候：</p><pre>print(&quot;C:\todo&quot;)<br># C:    odo</pre><p>這個的話<strong>Python</strong>會將<strong>\t</strong>視為一個Tab的空白，因此在這邊就需要像<strong>Java</strong>一樣，在前面多加一個<strong>\</strong>。</p><p>那基本上常用的有以下：</p><p><strong>\n</strong>：表達換行。</p><p><strong>\t</strong>：表達一個Tab。</p><p><strong>\’</strong>：當要表達單引號的時候。</p><p><strong>\”</strong>：當要表達雙引號的時候。</p><p><strong>Python</strong>字串特別的地方還有，一般的單引號或雙引號沒辦法表示多行字串，需要使用<strong>’’’</strong>，來包括文字：</p><pre>&#39;&#39;&#39;<br> Kenny&#39;s blog is great!<br> Penguin Coco is a online judge system.<br>     Oh my godness!<br>&#39;&#39;&#39;</pre><p>這個縮排跟換行都會保留下來，而不是只有純文字的部份保留下來～</p><h4>集合型態</h4><p>這部份就比較多跟雜，在<strong>Python</strong>中常見的有陣列(List)、集合(Set)、字典(Dict)、元組(Turple)</p><p>這邊簡單講解用法，實際上裡面的內容足夠開幾篇文慢慢描述～</p><p>陣列(list)</p><p>中文翻譯有很多種，基本上最大的不同在於說，<strong>Python</strong>的List型態是沒有限制長度的，也就是說一個<strong>List</strong>可以包含0~無數個元素。</p><p>通常以我的經驗，List最常拿來收集資料，或是需要有序的結構，有序的意思也就是說，List是一個一個累加起來的，每個元素都有屬於它的索引值，根據它的索引值去拿取該元素的值。</p><p><strong>Python</strong>使用這些集合型態可以說是非常的方便，以<strong>Java</strong>來看對應的建立方式：</p><pre>List&lt;Integer&gt; numbers = new ArrayList&lt;&gt;(); <br>numbers.add(1);<br>numbers.add(2);<br>numbers.add(3);</pre><p>要先宣告一個List型態的變數，然後由ArrayList這個類別去<strong>Implements List Interface</strong>。</p><p>當然還有更簡潔的寫法：</p><pre>List&lt;Integer&gt; numbers = Arrays.asList(1, 2, 3);</pre><p>但是<strong>Python</strong>只需要：</p><pre>numbers = [1, 2, 3]</pre><p>這就是為什麼<strong>Python</strong>的開發者總是強調<strong>Python簡潔易於使用</strong>的一大原因，的確非常方便！</p><p>再來如果要建立空陣列，只需這樣：</p><pre>numbers = []</pre><p>List加入元素：</p><pre>numbers = [1, 2, 3]<br>numbers.append(4)</pre><p>List取得元素：</p><pre>numbers = [1, 2, 3]<br>numbers[0]<br># 1<br>numbers[1]<br># 2<br>numbers[2]<br># 3</pre><p>基本上與大多數語言相同，索引值從0開始。</p><p>List刪除元素：</p><pre>numbers = [1, 2, 3]<br>numbers.remove(1)<br># numbers = [2, 3]<br>del numbers[0]<br># numbers = [3]</pre><p>remove的話是填入刪除元素的值，del的話是填入索引值。</p><p>List加入多個元素：</p><pre>numbers = [1, 2, 3]<br>numbers.extend([20, 21, 22])<br># numbers = [1, 2, 3, 20, 21, 22]</pre><p>可以想成將其他list的元素全部加進來的感覺～</p><p>取得List的長度：</p><pre>numbers = [1, 2, 3]<br>len(numbers)<br># 3</pre><p>檢測該元素有沒有在List裡面：</p><pre>numbers = [1, 2, 3]<br>1 in numbers<br># True<br>5 in numbers<br># False</pre><p>再來與<strong>Java</strong>更大的不同的是，<strong>Python</strong>的List可以包含不同型態的元素，可以裡面有字串、數字、布林型態等都可以。</p><p>例如：</p><pre>mixed = [1, &#39;kenny&#39;, True]</pre><p>最後其實也可以用<strong>list()</strong>的方式來產生list型態：</p><pre>list(&#39;Kenny很帥&#39;)<br># [&#39;K&#39;, &#39;e&#39;, &#39;n&#39;, &#39;n&#39;, &#39;y&#39;, &#39;很&#39;, &#39;帥&#39;]</pre><p>這個會自動將字串每個字元拆解出來並加入到一個list裡面。</p><p>集合(set)</p><p>這個，以數學角度來看的話，就是一個集合裡面不應該要有重複的元素，而是唯一的。而這個特性也是程式中會不會使用Set的原因，通常像是收集資料過程，希望不要收集到重複的資訊，那我們可以建立一個Set型態去蒐集資料，避免有重複的問題，因為就算你加入重複的資料，<strong>Python</strong>這邊會自動過濾重複的元素，如果重複了就不會加進去。也就是你可以省去過濾的步驟！</p><p>建立方式基本上有兩種：</p><pre>animals = {&#39;dog&#39;, &#39;cat&#39;, &#39;bird&#39;}<br>languages = set()<br>languages.add(&#39;Java&#39;)<br>languages.add(&#39;Python&#39;)<br>languages.add(&#39;Golang&#39;)</pre><p>特別注意，相較於陣列，Set型態如果要建利空Set並不能直接使用<strong>{}</strong>，因為這會當作字典(dict)型態，因此只能使用<strong>set()</strong>的方式來建立空集合。</p><p>集合刪除元素：</p><pre>animals = {&#39;dog&#39;, &#39;cat&#39;, &#39;bird&#39;}<br>animals.remove(&#39;dog&#39;)<br># animals = {&#39;cat&#39;, &#39;bird&#39;}</pre><p>那因為集合裡面的元素並不是有序的，所以就無法使用<strong>del</strong>來刪除特定索引值的元素。</p><p>取得集合元素的個數：</p><pre>animals = {&#39;dog&#39;, &#39;cat&#39;, &#39;bird&#39;}<br>len(animals)<br># 3</pre><p>也可以使用上面List()類似的範例：</p><pre>set(&quot;Kenny&#39;s blog is great&quot;)<br># {&quot;&#39;&quot;, &#39; &#39;, &#39;s&#39;, &#39;o&#39;, &#39;a&#39;, &#39;b&#39;, &#39;l&#39;, &#39;i&#39;, &#39;r&#39;, &#39;y&#39;, &#39;t&#39;, &#39;n&#39;, &#39;e&#39;, &#39;g&#39;, &#39;K&#39;}</pre><p>是不是發現重複的元素就不會重複加入了呢～</p><p>就是這麼簡單～</p><p>字典(dict)</p><p>翻譯為字典，顧名思義就很像是我們查一個英文單字是甚麼中文意思的感覺，特別注意的就是，一個鍵只會對應一個值。</p><p>建立字典型態：</p><pre>user_info = {<br>     &#39;Kenny&#39;: 123,<br>     &#39;Nicole&#39;: 456<br> }<br>user_info = dict{&#39;Kenny&#39;: 123, &#39;Nicole&#39;: 456}</pre><p>這代表在user_info這個字典裏面，有兩個鍵，分別是<strong>Kenny、Nicole</strong>，個別有其對應的值。當然要注意的是同一個字典<strong>鍵不能重複</strong>，但是<strong>值可以重複</strong>。</p><p>取得dict裡面的值：</p><pre>user_info = {<br>     &#39;Kenny&#39;: 123,<br>     &#39;Nicole&#39;: 456<br> }<br>user_info[&#39;Kenny&#39;]<br># 123<br>user_info[&#39;Nicole&#39;]<br># 456</pre><p>修改dict裡面某個鍵對應的值：</p><pre>user_info = {<br>     &#39;Kenny&#39;: 123,<br>     &#39;Nicole&#39;: 456<br> }<br>user_info[&#39;Kenny&#39;] = 789</pre><p>刪除dict裡面的鍵值：</p><pre>user_info = {<br>     &#39;Kenny&#39;: 123,<br>     &#39;Nicole&#39;: 456<br> }<br>del user_info[&#39;Kenny&#39;]</pre><p>那如果要測試鍵有沒有在字典裏面，可以使用<strong>in</strong>來進行操作。</p><pre>user_info = {<br>     &#39;Kenny&#39;: 123,<br>     &#39;Nicole&#39;: 456<br> }<br>&#39;Kenny&#39; in user_info<br># True</pre><p>取得字典裏面所有的鍵、所有的值、所有的鍵值配對：</p><pre>user_info = {<br>     &#39;Kenny&#39;: 123,<br>     &#39;Nicole&#39;: 456<br> }<br>user_info.keys()<br># dict_keys([&#39;Kenny&#39;, &#39;Nicole&#39;])<br>list(user_info.keys())<br># [&#39;Kenny&#39;, &#39;Nicole&#39;]<br>user_info.values()<br># dict_values([123, 456])<br>list(user_info.values())<br># [123, 456]<br>user_info.items()<br># dict_items([(&#39;Kenny&#39;, 123), (&#39;Nicole&#39;, 456)])<br>list(user_info.items())<br># [(&#39;Kenny&#39;, 123), (&#39;Nicole&#39;, 456)]</pre><p>那回傳的物件，<strong>Python</strong>內部是用list去包裹的，只是型態不是顯示list。那基本上我們可以用list()在去包裹，就可以取得list型態的相關物件。</p><p>比較特別是items()回傳的結構類似於下一個要講的<strong>Turple</strong>一樣。</p><p>元組(turple)</p><p>這個理解方式我覺得就是想成是list的翻版，只是有一些不同之處：</p><ol><li>用<strong>()</strong>包括</li><li>無法改變裡面的元素內容</li></ol><p>建立turple：</p><pre>a = 1,<br># (1,)<br>b = 1, 2, 3<br># (1, 2, 3)<br>c = (1, 2, 3, 4)<br># (1, 2, 3, 4)<br>d = ()<br># () 空turple</pre><p>注意<strong>Python</strong>中並沒有turple()的方式可以建立turple喔！</p><p>這個我覺得在使用的時機可以是在當你定義一些明確的資料，而且是不允許去修改的話就很適合使用<strong>turple</strong>，而且<strong>turple</strong>占用的記憶體空間較小。</p><p>最後帶來兩種語言如果要實現兩個數字互換的功能的差別在哪：</p><p>Java版本：</p><pre>int x = 1;<br>int y = 2;<br>int temp = y;<br>y = x;<br>x = temp<br>System.out.println(&quot;x: &quot; + x + &quot;, &quot; + &quot;y: &quot; + y);</pre><p>Python版本：</p><pre>x = 1<br>y = 2<br>x, y = y, x<br>print(&#39;x:&#39;, x, &#39;,&#39;, &#39;y:&#39;, y)</pre><p>恩…實際上<strong>Python</strong>的版本就是利用<strong>turple</strong>的特性來進行互換值的動作！</p><h3>總結</h3><p>這個是一個Python的教學系列，也算是我的程式語言筆記系列。因為寫過太多語言，頭腦有時候會有混亂的狀態，例如靜態語言跟動態語言語法可以說是天差地別，有時候靜態語言寫久了要換到動態語言還真的不習慣，反之也是，最近因為碩士課程的關係，要重新擁抱Python，因此也希望做個紀錄，所以文章內容也會有靜態語言跟動態語言的比較，我通常都會拿<strong>Java</strong>來比較，畢竟差異性真的滿多的，之後也會多一些<strong>Python的資料分析套件介紹</strong>。</p><p>當然這種東西很多人都寫過了，我也只是將我的經驗以及前人的東西做個整理而已。</p><p>在這邊我特別推崇我喜歡的程式語言大師，因為不得不說學校教的程式語言的深度真的是太淺了，很多時候都是靠網路上自學或是去買書的～</p><ol><li><a href="https://openhome.cc/Gossip/Python/">https://openhome.cc/Gossip/Python/</a></li></ol><p>這個人很厲害，我也買過他出的<strong>Java、Python</strong>的書，非常推薦給大家。</p><p>2. <a href="https://docs.python.org/3/">https://docs.python.org/3/</a></p><p>這個不用說了，就是Python官方的文件，不得不說官方文件的東西還是要學習去看，更何況官方有出中文版的，沒理由不去看，官方畢竟才是權威，但是缺點就是可能不夠仔細，這也是為什麼很多人會出程式語言教學，也就是希望更詳細的去整理程式語言的相關細節～</p><p>歡迎來我個人部落格觀看： <a href="https://kennychen-blog.herokuapp.com/">https://kennychen-blog.herokuapp.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8c5100657224" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/python-%E5%9E%8B%E6%85%8B%E5%A4%A7%E5%93%89%E5%95%8F-8c5100657224">Python-型態大哉問</a> was originally published in <a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88">企鵝也懂程式設計</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PenguinCoCo後端專案重構之旅-Security和Session的處理]]></title>
            <link>https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/penguincoco%E5%BE%8C%E7%AB%AF%E5%B0%88%E6%A1%88%E9%87%8D%E6%A7%8B%E4%B9%8B%E6%97%85-security%E5%92%8Csession%E7%9A%84%E8%99%95%E7%90%86-6818e7ac98fd?source=rss-e4adaf5f8fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/6818e7ac98fd</guid>
            <category><![CDATA[spring]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[back-end-development]]></category>
            <dc:creator><![CDATA[Kenny Chen]]></dc:creator>
            <pubDate>Fri, 20 Sep 2019 13:50:08 GMT</pubDate>
            <atom:updated>2019-09-20T13:50:08.460Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*DTr1gQJ2YKgB_6FhCnhQsw.png" /></figure><p>上次我們解決了資料庫的設計，而這次文章我們需要解決兩大問題：</p><ul><li>Security</li><li>Session</li></ul><h3>Web專案中，Security會有哪些問題？</h3><p>首先，再次強調，該專案是採用前後端分離，而API的格式也盡量符合Restful API的格式。以下是我覺得最直接會遇到的安全問題：</p><ul><li>存取API的權限控制</li></ul><p>專案裡面有專屬於老師、助教、學生、管理員的各自API，很明顯不同身分的使用者不能存取其他身分的API，不然可能會造成學生身分卻能竄改自己的成績分數等問題。</p><ul><li>還沒登入就進行API的存取</li></ul><p>同樣的，假設該使用者尚未登入，就存取了API，也是不允許的，同時這樣的操作，也會讓系統無法判斷該使用者是誰，無法給予相對應的資料。</p><ul><li>使用者密碼加密的問題</li></ul><p>這個可以說是關於資料庫安全的問題，一般來說，使用者的密碼是不該以明碼的方式來存放資料庫，假設管理資料庫的人可以輕易看到每個使用者的明碼，那麼它就能夠透過你的帳戶進行登入，做一些操作，這是相當危險的事情，更別提假設資料庫被攻陷的話，後續引發的連鎖效應。</p><ul><li>SQL injection的問題</li></ul><p>這個問題，基本上如果有使用後端框架裡面的ORM工具，就不會有這個問題，因為通常這個SQL injection是因為前端那部分塞一個SQL指令給後端，讓後端去運行，藉此來竄改資料庫的資料，但因為有ORM工具，通常都是直接拿變數的值去對應ORM的函數，所以通常不會有執行前端傳過來SQL指令的時候。</p><p>假設前端那邊傳來，<strong>account</strong>、<strong>password</strong>兩個參數，而這個學生就是這麼手賤，它把account輸入了一個SQL指令：</p><pre>DELETE FROM teacher</pre><p>但是ORM這邊執行的函數接收方式是這樣：</p><pre>findByAccountAndPassword(account, password);</pre><p>而實際上ORM框架會將findByAccountAndPassword再轉成SQL指令，但只會把account、password變數參考進去，而不會執行該變數裡面的指令。</p><p>就像如下：</p><pre>SELECT * FROM teacher where account=&#39;DELETE FROM teacher&#39; AND password=&#39;xxxx&#39;</pre><p>實際上就只是把前端傳過來的SQL指令當作一個字串變數值而已，資料庫這並不會執行到，自然也不會刪除掉teacher這個表格囉。</p><h3>Web專案中，Session會有哪些問題？</h3><p>雖然專案是採Restful API的方式，但這邊我還是選擇採用Session的方案，而不是採用JWT來進行驗證使用者的功能。原因如下：</p><ul><li>目前專案只是純網站，並不是還有分APP端，因為如果有APP端，可能會變成API這邊要統一，並且由Web及APP端存取相同介面的API，藉此來統一，加上APP端這邊並沒有所謂的Session的方式，那我就會採用JWT的方式。</li><li>Session紀錄登入後的資訊方便，且容易掌握當下的使用者人數，通常使用者登入後，我會在session端存放使用者的帳號，這樣在一些的API上，前端就不用再刻意傳學生的帳號的參數，讓後端辨別是要存取哪位學生的資料。當然前端這邊就不用再找空間來存放這樣的資訊。由後端的session去存放這樣的資訊，再來，因為session是可以主動被後端刪除的，因此做一些強迫登出的動作也方便。相較於JWT就比較屬於被動性。</li></ul><p>但是Session還是會有一些問題需要去處理：</p><ul><li>Session存放位置</li></ul><p>原本的專案，Session其實是存放在內存中，但這樣會有一個問題，因為現在為了使用者體驗，我會將session過期時間設為無限，讓使用者不需要有頻繁登入的操作，登出的時間由使用者自由掌握。但這樣會導致內存中的session過多，因為內存的消耗是有限的，理論上內存越來越多的情況下，會導致後端運行速度變慢。</p><ul><li>不同瀏覽器的登入操作，造成同個使用者的Session變多，而不是唯一</li></ul><p>這個原因，主要是如果使用者採用不同瀏覽器進行登入的話，產生的Session其實是不一樣的，但都是同一位使用者，可能會導致同個使用者的session越存越多。</p><h3>Security的解決方案</h3><p>這邊的解決方案，我都是參考我之前撰寫的一篇文章，所以在這邊就不會講太細了，有興趣的朋友可以參考這篇文章：</p><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/spring-security-%E7%B5%90%E5%90%88restfulapi%E7%9A%84%E8%A8%AD%E8%A8%88-60b778fd3b22">Spring-Security-結合RestfulApi的設計</a></p><p>我們這邊採用的就是Spring Security，它可以說包辦了許多Spring中所有Security的設定，並且我們可以根據自己的需求去客製化裡面的設定，但這個框架是非常雜的，所以需要花一點時間去了解。</p><p>先來談談package裡面的配置；</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/209/1*QsfF6lCkotl04CfMAq05Xw.png" /></figure><p>這個可以說是專案的設定，所以我習慣根package命名為<strong>config</strong>，並且新增一個<strong>security</strong>的package，而這個package裡面就是專門設定security的相關事項，首先按照需求，分別有<strong>authority</strong>、<strong>login*&amp;</strong>、<strong>logout</strong>，這些來解決我們以上談到的問題。</p><p>直接上程式碼：</p><pre>@Configuration<br> public class SecurityConfig extends WebSecurityConfigurerAdapter {<br> ​<br>     private SecurityService securityService;<br> ​<br>     @Autowired<br>     public SecurityConfig(SecurityService securityService) {<br>         this.securityService = securityService;<br>     }<br>     <br>     /*<br>         設定使用者權限驗證的service(連結DB)、使用者密碼加密<br>      */<br>     @Override<br>     protected void configure(AuthenticationManagerBuilder auth) throws Exception {<br>         auth.userDetailsService(securityService)<br>                 .passwordEncoder(new BCryptPasswordEncoder());<br>     }<br> ​<br>     @Override<br>     protected void configure(HttpSecurity http) throws Exception {<br>         /*<br>             未登入存取API控制及身分權限存取API控制<br>          */<br>         http.exceptionHandling()<br>                 .authenticationEntryPoint(new AuthenticationEntryPointImpl())<br>                 .accessDeniedHandler(new AccessDeniedHandlerImpl());<br>         /*<br>             login API控制<br>          */<br>         http.addFilterAt(loginAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);<br>         /*<br>             logout API控制<br>          */<br>         http.logout()<br>                 .logoutUrl(&quot;/api/logout&quot;)<br>                 .invalidateHttpSession(true)<br>                 .logoutSuccessHandler(new LogoutSuccessHandlerImpl())<br>                 .and()<br>                 .csrf()<br>                 .disable();<br>     }<br>     <br>     /*<br>         設定Login API，登入成功及失敗的回覆<br>      */<br>     @Bean<br>     LoginAuthenticationFilter loginAuthenticationFilter() throws Exception {<br>         LoginAuthenticationFilter filter = new LoginAuthenticationFilter();<br>         filter.setAuthenticationManager(authenticationManagerBean());<br>         filter.setAuthenticationSuccessHandler(new LoginSuccessHandlerImpl());<br>         filter.setAuthenticationFailureHandler(new LoginFailureHandlerImpl());<br>         filter.setFilterProcessesUrl(&quot;/api/login&quot;);<br>         return filter;<br>     }<br>     <br>     /*<br>         取得預設的authenticationManagerBean，用來給LoginAuthenticationFilter設定<br>      */<br>     @Override<br>     @Bean<br>     public AuthenticationManager authenticationManagerBean() throws Exception {<br>         return super.authenticationManagerBean();<br>     }<br> }</pre><p>程式碼解釋：</p><pre>/*<br>     設定使用者權限驗證的service(連結DB)、使用者密碼加密<br> */<br> @Override<br> protected void configure(AuthenticationManagerBuilder auth) throws Exception {<br>     auth.userDetailsService(securityService)<br>         .passwordEncoder(new BCryptPasswordEncoder());<br> }</pre><p>這邊就是要讓spring security能夠去資料庫拿取使用者的帳號密碼，因此這邊如果要客製化的話，就是客製去資料庫拿帳號密碼這段，也就是securityService。再來，需要設定使用者密碼的加密演算法，這邊的演算法要跟註冊使用者那邊的加密演算法要一樣，這樣Spring Security才能根據這個演算法去跟前端傳過來的明碼進行比對，才知道是不是正確的密碼。</p><p>要建立securityService類別前，要先讓使用者的實體類別先去<strong>implements UserDetails類別</strong></p><p>如下：</p><pre>@EqualsAndHashCode(callSuper = true)<br> @Entity<br> @Data<br> @NoArgsConstructor<br> public class Student extends AbstractUser implements UserDetails {<br> ​<br>     private String studentClass;<br>     @ManyToMany<br>     @JoinTable(name = &quot;student_course&quot;, joinColumns = @JoinColumn(name = &quot;student_id&quot;),<br>             inverseJoinColumns = @JoinColumn(name = &quot;course_id&quot;))<br>     private List&lt;Course&gt; courses;<br>     @OneToMany(mappedBy = &quot;bestStudent&quot;, cascade = CascadeType.ALL, fetch = FetchType.LAZY)<br>     private List&lt;Problem&gt; bestProblems;<br>     @OneToMany(mappedBy = &quot;student&quot;, cascade = CascadeType.ALL, fetch = FetchType.LAZY)<br>     private List&lt;Judge&gt; judges;<br>     @OneToMany(mappedBy = &quot;referencedStudent&quot;, cascade = CascadeType.ALL, fetch = FetchType.LAZY)<br>     private List&lt;Copy&gt; referencedCopies;<br>     @OneToMany(mappedBy = &quot;referenceStudent&quot;, cascade = CascadeType.ALL, fetch = FetchType.LAZY)<br>     private List&lt;Copy&gt; referenceCopies;<br>     @OneToMany(mappedBy = &quot;student&quot;, cascade = CascadeType.ALL, fetch = FetchType.LAZY)<br>     private List&lt;Feedback&gt; feedbacks;<br> ​<br>     public Student(String account, String password,<br>                    String name, String studentClass) {<br>         super(account, password, name);<br>         this.studentClass = studentClass;<br>     }<br> ​<br>     @Override<br>     public Collection&lt;? extends GrantedAuthority&gt; getAuthorities() {<br>         List&lt;SimpleGrantedAuthority&gt; authorities = new ArrayList&lt;&gt;();<br>         authorities.add(new SimpleGrantedAuthority(&quot;ROLE_student&quot;));<br>         return authorities;<br>     }<br> ​<br>     @Override<br>     public String getUsername() {<br>         return super.getAccount();<br>     }<br> ​<br>     @Override<br>     public String getPassword() {<br>         return super.getPassword();<br>     }<br> ​<br>     @Override<br>     public boolean isAccountNonExpired() {<br>         return true;<br>     }<br> ​<br>     @Override<br>     public boolean isAccountNonLocked() {<br>         return true;<br>     }<br> ​<br>     @Override<br>     public boolean isCredentialsNonExpired() {<br>         return true;<br>     }<br> ​<br>     @Override<br>     public boolean isEnabled() {<br>         return true;<br>     }<br> ​<br> }</pre><p>那麼就會有一些Override的method需要定義，最主要就是<strong>getUsername</strong>、<strong>getPassword</strong>，Spring Security會根據這個去拿取這個使用者的<strong>account</strong>、<strong>password</strong>做一些身分驗證及登入的事項。</p><p>而securityService最主要做以下的事情：</p><pre>@Override<br> public UserDetails loadUserByUsername(String account) throws UsernameNotFoundException {<br>     Optional&lt;Student&gt; studentOptional = studentRepository.findByAccount(account);<br>     Optional&lt;Teacher&gt; teacherOptional = teacherRepository.findByAccount(account);<br>     Optional&lt;Assistant&gt; assistantOptional = assistantRepository.findByAccount(account);<br>     Optional&lt;Admin&gt; adminOptional = adminRepository.findByAccount(account);<br> ​<br>     if (studentOptional.isPresent()) {<br>         return studentOptional.get();<br>     }<br>     else if (teacherOptional.isPresent()) {<br>         return teacherOptional.get();<br>     }<br>     else if (assistantOptional.isPresent()) {<br>         return assistantOptional.get();<br>     }<br>     else if (adminOptional.isPresent()) {<br>         return adminOptional.get();<br>     }<br>     else {<br>         throw new UsernameNotFoundException(&quot;account not found&quot;);<br>     }<br> }</pre><p>根據<strong>account</strong>去不同的使用者身分的table拿取資料，因為這邊<strong>account</strong>是不會與其他身分的使用者衝突的。因此只會有一種存在的可能。</p><p>如果資料存在，則回傳UserDetails物件，而使用者的實體因為已經<strong>implements</strong> UserDetails類別，因此可直接回傳。</p><pre>@Override<br> protected void configure(HttpSecurity http) throws Exception {<br>     /*<br>         未登入存取API控制及身分權限存取API控制<br>      */<br>     http.exceptionHandling()<br>         .authenticationEntryPoint(new AuthenticationEntryPointImpl())<br>         .accessDeniedHandler(new AccessDeniedHandlerImpl());<br>     /*<br>         login API控制<br>     */<br>     http.addFilterAt(loginAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);<br>     /*<br>         logout API控制<br>     */<br>     http.logout()<br>         .logoutUrl(&quot;/api/logout&quot;)<br>         .invalidateHttpSession(true)<br>         .logoutSuccessHandler(new LogoutSuccessHandlerImpl())<br>         .and()<br>         .csrf()<br>         .disable();<br> }</pre><p>這邊的話就是設定未登入存取API控制、身分權限存取API控制、login API、logout API。要注意的就是login及logout這邊都要特別去對session做出來。我這邊就是登入後會在session存放使用者的account，登出就會把session給刪掉。</p><p>可參考如下：</p><pre>public class LoginSuccessHandlerImpl implements AuthenticationSuccessHandler {<br> ​<br>     private final String LOGGED_IN = &quot;logged_in&quot;;<br> ​<br>     @Override<br>     public void onAuthenticationSuccess(HttpServletRequest httpServletRequest,<br>                                         HttpServletResponse httpServletResponse,<br>                                         Authentication authentication) throws IOException {<br>         String account = authentication.getName();<br>         Collection authorityCollection = authentication.getAuthorities();<br>         String authority = authorityCollection.iterator().next().toString().replace(&quot;ROLE_&quot;, &quot;&quot;);<br> ​<br>         HttpSession session = httpServletRequest.getSession();<br>         session.setAttribute(LOGGED_IN, account);<br> ​<br>         ObjectMapper mapper = new ObjectMapper();<br>         Map&lt;String, String&gt; result = new HashMap&lt;&gt;();<br>         result.put(&quot;authority&quot;, authority);<br> ​<br>         httpServletResponse.setContentType(&quot;application/json;charset=UTF-8&quot;);<br>         httpServletResponse.setStatus(HttpServletResponse.SC_OK);<br>         httpServletResponse.getWriter().write(mapper.writeValueAsString(result));<br>         httpServletResponse.getWriter().flush();<br>         httpServletResponse.getWriter().close();<br>     }<br> }</pre><p>登入成功後，會在session的屬性中存放使用者的account，方便之後API的存取。</p><h3>Session的解決方案</h3><p>首先關於Session的存放位置後來我決定放在<strong>redis</strong>，<strong>redis</strong>是一個算是NoSQL的資料庫，但是它讀入存取的性能相當優秀，通常都會拿來當作快取的資料庫！再來，放在資料庫有一個好處，那就是我可以透過資料庫的確切得知目前Session有多少，根據Session我也可以知道目前系統的登入人數。</p><p>相較於之前存在內存空間，我認為這樣的作法彈性反而更大。再來關於多個瀏覽器的登入問題，我目前是不打算做甚麼約束，也就是說雖然不同瀏覽器的登入會造成同個使用者的Session存放數量變多，但我目前的做法是還不先刪除同樣使用者的Session，為了保持使用者體驗，也有之後在未來會採用Session過期的策略來清理Session。</p><p>怎麼用<strong>redis</strong>來存放Session呢？其實很簡單，只要加入以下<strong>dependency</strong>：</p><pre>&lt;dependency&gt;<br>     &lt;groupId&gt;org.springframework.session&lt;/groupId&gt;<br>     &lt;artifactId&gt;spring-session-data-redis&lt;/artifactId&gt;<br> &lt;/dependency&gt;</pre><p>因為在Springboot裡面，它會默認Session是存在內存，但只要提供該<strong>dependency</strong>，在自動配置下，就會幫我們自動存入redis裡面。</p><p>因此只要我們在<strong>aplication.properties</strong>裡面設定redis的連線資訊就可以了：</p><pre># Session and Redis 設定<br> spring.session.store-type=redis<br> server.servlet.session.timeout=-1s<br> spring.redis.host=localhost<br> spring.redis.password=root<br> spring.redis.port=6379</pre><p>同時這邊也設定<strong>Session的過期時間</strong>，<strong>-1s</strong>就代表是無限期存活Session。</p><p>基本上，這樣就全部設定完了，剛剛在LoginSuccessHandlerImpl這裡面，當我們登入成功後，會在session裡面的屬性存放account，基本上做這樣的動作，就會自動存入redis資料庫。</p><p>畫面如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EM0A7o660HSCkn-2V5Hujg.png" /></figure><p>預設的session存放路徑如上面這樣。基本上就是在sessions這裡面會存放所有的session，而每個sessionId當作key，value就是你存放的屬性內容。</p><h3>總結</h3><p>做到這一步之後，基本的Security跟Session就算完成了，日後再根據需求做更改。下篇文章講解系統分解架構，幫助之後撰寫API功能做準備。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6818e7ac98fd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/penguincoco%E5%BE%8C%E7%AB%AF%E5%B0%88%E6%A1%88%E9%87%8D%E6%A7%8B%E4%B9%8B%E6%97%85-security%E5%92%8Csession%E7%9A%84%E8%99%95%E7%90%86-6818e7ac98fd">PenguinCoCo後端專案重構之旅-Security和Session的處理</a> was originally published in <a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88">企鵝也懂程式設計</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Express-RestfulApi起手教學3]]></title>
            <link>https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/express-restfulapi%E8%B5%B7%E6%89%8B%E6%95%99%E5%AD%B83-77206cd64ebb?source=rss-e4adaf5f8fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/77206cd64ebb</guid>
            <category><![CDATA[expressjs]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[back-end-development]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Kenny Chen]]></dc:creator>
            <pubDate>Wed, 18 Sep 2019 12:40:22 GMT</pubDate>
            <atom:updated>2019-09-18T12:40:22.155Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nw84enGm5YDAA3QujyTGjw.png" /></figure><p>上次我們介紹了<strong>nodemon</strong>、<strong>dotenv</strong>兩個好用的套件，幫助我們快速開發。今天這篇文章要介紹一個套件 — — -<strong>body-parser</strong>使用方式及<strong>express框架中middleware</strong>的概念。</p><h3>body-parser使用</h3><p>現在專案裡面只有一個路由，且是採用<strong>GET METHOD</strong>，但我們要知道原本的express框架，並無法接收<strong>POST METHOD</strong>傳過來的參數的。在舊版的express框架是會自動處理這件事情，但現在新版的把處理這件事情的套件拿掉了，需要我們自己裝套件來完成這件事情。</p><p>而這套鍵也就是<strong>body-parser</strong>，它可以幫助我們解析POST METHOD所帶來過來的參數。</p><h3>安裝body-parser</h3><pre>npm install body-parser</pre><h3>body-parser啟用</h3><p>安裝成功之後，利用以下方式啟動body-parser的功能：</p><pre>const bodyParser = require(&#39;body-parser&#39;);<br> const express = require(&#39;express&#39;);<br> const app = express();<br> app.use(bodyParser.json());</pre><p>body-parser套件主要可以解析兩種方式的POST METHOD帶過來的參數：</p><ul><li>bodyParser.urlencoded</li></ul><p>也就是最常見的表單方式。</p><ul><li>bodyParser.json</li></ul><p>專門用來接收<strong>json</strong>格式，也就是最常用在開發<strong>restful</strong>的格式。</p><p>更多的body-parser的功能，可參觀官方的document：<a href="https://github.com/expressjs/body-parser">https://github.com/expressjs/body-parser</a></p><p>而在這邊，我們是要開發<strong>restful api</strong>，所以只須採用第二種的功能就可以了。而這個<strong>body-parser</strong>功能是需要放在我們叫做<strong>middleware</strong>層上，使得每個路由被拜訪前，都會經過這個<strong>middleware</strong>，由這個<strong>middleware</strong>先進行參數上的解析，最後在拜訪我們的路由。</p><h3>使用middleware</h3><h3>何謂middleware？</h3><p>在express的框架中，<strong>middleware</strong>可以說是無處不在，就連整個express的運作方式，你也可以看成是多個<strong>middleware</strong>在運作的樣子。</p><p>例如我們看以下的程式碼：</p><pre>const bodyParser = require(&#39;body-parser&#39;);<br> const express = require(&#39;express&#39;);<br> const app = express();<br> ​<br> app.use(bodyParser.json());<br> ​<br> app.post(&#39;/postTesting&#39;, (req, res, next) =&gt; {<br>     res.json(req.body);<br> });<br> ​<br> app.listen(port, function () {<br>     console.log(&#39;Express app started on &#39; + port);<br> });</pre><p><strong>app.use</strong>，這個功用就是說建立一個middleware，而我們可以選擇在middleware放置怎樣的function，例如我們放置body-parser套件並啟用解析json格式的功能。而之後的程式碼是撰寫路由的middleware，其middleware裡面的內容因應路由的path，來作想對應的function。</p><p>而因為開啟了body-parser套件的功能，因此我們透過<strong>req.body</strong>，就能正確取到POST帶過來的參數。</p><p>但是，特別要注意的就是，這個是有順序性的。也就是假設我們把<strong>app.use(bodyParser.json())</strong>，放到撰寫路由程式碼下面的話，會發現當去拜訪<strong>/postTesting</strong>的時候，response的內容為空。因為它無法解析req.body是什麼，也就是不知道你POST帶過來的參數是甚麼。</p><h3>通常middleware使用方式</h3><p>所以如果是一般全局的套件設定，比如說像body-parser，因為我們整個專案就是restful api，所以一定是每個路由如果用到了<strong>request body</strong>的方式，就一定會需要有body-parser的功能來解析json。我們就會在路由程式碼前面就寫<strong>app.use</strong>，才能讓每個路由前面擁有middleware去做前段的解析。</p><p>當然其實middleware的位置，可以根據需求去做改變，我也可以在特定路由上，再啟動我想要放置的middleware的function。如下：</p><pre>const bodyParser = require(&#39;body-parser&#39;);<br> const express = require(&#39;express&#39;);<br> const app = express();<br> const jsonParser = bodyParser.json();<br> ​<br> app.post(&#39;/postTesting&#39;, jsonParser, (req, res, next) =&gt; {<br>     res.json(req.body);<br> });<br> ​<br> app.listen(port, function () {<br>     console.log(&#39;Express app started on &#39; + port);<br> });</pre><p>這樣的話就只有<strong>/postTesting</strong>會有解析json參數的功能而已。</p><h3>整理一下現在的Code!</h3><p>app.js：</p><pre>require(&#39;dotenv&#39;).config();<br> const bodyParser = require(&#39;body-parser&#39;);<br> ​<br> const express = require(&#39;express&#39;);<br> const app = express();<br> const port = process.env.PORT;<br> ​<br> app.use(bodyParser.json());<br> ​<br> app.post(&#39;/postTesting&#39;, (req, res, next) =&gt; {<br>     res.json(req.body);<br> });<br> ​<br> app.get(&#39;/&#39;, function (req, res, next) {<br>     res.send(&#39;Hello World&#39;);<br> });<br> ​<br> app.listen(port, function () {<br>     console.log(&#39;Express app started on &#39; + port);<br> });</pre><p>這邊主要就是示範了POST METHOD的路由，如何透過body-parser的套件來解析json參數。以及用到了express框架中，常用的middleware的設計方式。</p><p>package.json：</p><pre>{<br>   &quot;name&quot;: &quot;node-rest-shop&quot;,<br>   &quot;version&quot;: &quot;1.0.0&quot;,<br>   &quot;description&quot;: &quot;&quot;,<br>   &quot;main&quot;: &quot;index.js&quot;,<br>   &quot;scripts&quot;: {<br>     &quot;start&quot;: &quot;nodemon app.js&quot;,<br>     &quot;test&quot;: &quot;echo \&quot;Error: no test specified\&quot; &amp;&amp; exit 1&quot;<br>   },<br>   &quot;keywords&quot;: [],<br>   &quot;author&quot;: &quot;&quot;,<br>   &quot;license&quot;: &quot;ISC&quot;,<br>   &quot;dependencies&quot;: {<br>     &quot;body-parser&quot;: &quot;^1.19.0&quot;,<br>     &quot;dotenv&quot;: &quot;^8.0.0&quot;,<br>     &quot;express&quot;: &quot;^4.17.1&quot;<br>   },<br>   &quot;devDependencies&quot;: {<br>     &quot;nodemon&quot;: &quot;^1.19.1&quot;<br>   }<br> }</pre><h3>總結</h3><p>下一個階段，可以來試試看如何連接資料庫，並且使用哪些<strong>ORM</strong>套件。</p><p>詳細的Source Code可參考：<a href="https://github.com/KennyChenFight/node-rest-shop/tree/section3">https://github.com/KennyChenFight/node-rest-shop/tree/section3</a></p><p>歡迎來我個人部落格參觀： <a href="https://kennychen-blog.herokuapp.com/">https://kennychen-blog.herokuapp.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=77206cd64ebb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/express-restfulapi%E8%B5%B7%E6%89%8B%E6%95%99%E5%AD%B83-77206cd64ebb">Express-RestfulApi起手教學3</a> was originally published in <a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88">企鵝也懂程式設計</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Express — RestfulApi起手教學2]]></title>
            <link>https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/express-restfulapi%E8%B5%B7%E6%89%8B%E6%95%99%E5%AD%B82-ef12782cef10?source=rss-e4adaf5f8fe7------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef12782cef10</guid>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[back-end-development]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[expressjs]]></category>
            <dc:creator><![CDATA[Kenny Chen]]></dc:creator>
            <pubDate>Sat, 14 Sep 2019 02:01:02 GMT</pubDate>
            <atom:updated>2019-09-14T02:01:02.942Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nw84enGm5YDAA3QujyTGjw.png" /></figure><h3>Express — RestfulApi起手教學2</h3><p>上次我們介紹如何利用Express快速建立了web server，這次要來介紹開發Express好用的一些工具。</p><h3>介紹nodemon</h3><p>nodemon套件能夠自動化的重啟Node.js所創立的application。意思就是，每次我們修改程式碼的時候，我們總要重新run程式，才會有我們想要看到的結果。而nodemon套件正是能夠幫我們自動化的重啟程式，不須手動去做重啟的動作，這樣可以幫助我們提升開發效率。對於Web專案，這種工具是很常見的，在各大語言的Web框架皆有類似的工具。</p><h3>安裝nodemon</h3><p>在我們node-rest-shop專案底下，開啟terminal輸入以下指令：</p><pre>npm install --save-dev nodemon</pre><p>— save-dev的意思代表此套件只存在開發階段，有些時候一些好用的工具套件我們只需在開發階段使用即可，未來將專案deploy到開發環境的時候，並不需要此套件。</p><h3>使用nodemon</h3><p>在package.json中裡面有個參數是script，這代表我們可以在裡面輸入一些指令，例如開啟專案入口點。以我們現在專案為例，我們新增以下指令：</p><pre>&quot;start&quot;: &quot;nodemon app.js&quot;</pre><p>利用nodemon去執行app.js，就能達到自動重啟功能!要啟用這項指令，我們可以在terminal輸入以下指令：</p><pre>npm run start</pre><p>就能開啟我們的專案入口點，app.js。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/956/1*K7yMk9QHdmyGmI51yUhQUw.png" /></figure><p>看到以上訊息，就代表我們成功使用nodemon去啟動我們的專案，而只要我們有任何修改程式碼的動作，只要有進行存檔，nodemon就會立刻讓專案重啟，而不需讓我們手動去重啟。</p><h3>介紹dotenv</h3><p>dotenv套件，能夠幫助我們自動load環境變數，而不用我們在程式碼裡面去用程式控制環境變數。通常web專案裡面會定義到的環境變數不外乎是port、database url等等。只要是一些固定的值，而這些值又會在專案裡面不同程式檔案中用到，又或者是這些值是相對私密的，不允許公開在code裡面。dotenv套件就是透過讀取.env檔案，來load環境變數，因此我們只要創建.env檔案在裡面定義這些環境變數的值，並在程式碼中載入dotenv套件，它就能幫我們自動載入這些環境變數供程式使用。</p><h3>安裝dotenv</h3><p>在我們node-rest-shop專案下，開啟terminal輸入以下指令：</p><pre>npm install dotenv</pre><h3>使用dotenv</h3><p>首先在專案下，創建.env檔案，該檔案裡面可以定義環境變數，其定義格式為NAME=VALUE，因為目前專案還太小，但port可以當作環境變數，因為在開發專案的時候要是port要更換，我們還要去code裡面尋找port變數定義在哪裡太麻煩了。因此將port環境變數定義為3000：</p><pre>PORT=3000</pre><p>通常像這種環境變數的名稱，慣例上會以全大寫來命名，多個單字的話就用底線來連接。</p><p>接著我們在app.js最上面加入以下code：</p><pre>require(&#39;dotenv&#39;).config()</pre><p>config函數裡面可放option參數，其中option裡面可以放置custom的環境變數檔案路徑。若沒添加，則預設讀取專案根目錄的.env檔案。當執行以上code，就會自動將環境變數assign給process.env。也就是當我們在程式碼裡面想要讀取環境變數PORT的值，我們只需要這樣讀取：</p><pre>const port = process.env.PORT</pre><p>port之值就會對應到.env檔案所定義的值。</p><h3>總結</h3><p>今天我們加入了nodemon及dotenv兩個實用套件，app.js內容更改如下：</p><pre>require(&#39;dotenv&#39;).config();<br> const express = require(&#39;express&#39;);<br> const app = express();<br> const port = process.env.PORT;<br> ​<br> app.get(&#39;/&#39;, function (req, res, next) {<br>     res.send(&#39;Hello World&#39;);<br> });<br> ​<br> app.listen(port, function () {<br>     console.log(&#39;Express app started on &#39; + port);<br> });<br> ​</pre><p>package.json如下：</p><pre>{<br>   &quot;name&quot;: &quot;node-rest-shop&quot;,<br>   &quot;version&quot;: &quot;1.0.0&quot;,<br>   &quot;description&quot;: &quot;&quot;,<br>   &quot;main&quot;: &quot;index.js&quot;,<br>   &quot;scripts&quot;: {<br>     &quot;start&quot;: &quot;nodemon app.js&quot;,<br>     &quot;test&quot;: &quot;echo \&quot;Error: no test specified\&quot; &amp;&amp; exit 1&quot;<br>   },<br>   &quot;keywords&quot;: [],<br>   &quot;author&quot;: &quot;&quot;,<br>   &quot;license&quot;: &quot;ISC&quot;,<br>   &quot;dependencies&quot;: {<br>     &quot;dotenv&quot;: &quot;^8.0.0&quot;,<br>     &quot;express&quot;: &quot;^4.17.1&quot;<br>   },<br>   &quot;devDependencies&quot;: {<br>     &quot;nodemon&quot;: &quot;^1.19.1&quot;<br>   }<br> }<br> ​</pre><p>.env</p><pre>PORT=3000</pre><p>詳細內容可參考Github Source Code：<a href="https://github.com/KennyChenFight/node-rest-shop/tree/section2">https://github.com/KennyChenFight/node-rest-shop/tree/section2</a></p><p>歡迎來我個人部落格參觀： <a href="https://kennychen-blog.herokuapp.com/">https://kennychen-blog.herokuapp.com/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef12782cef10" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88/express-restfulapi%E8%B5%B7%E6%89%8B%E6%95%99%E5%AD%B82-ef12782cef10">Express — RestfulApi起手教學2</a> was originally published in <a href="https://medium.com/%E4%BC%81%E9%B5%9D%E4%B9%9F%E6%87%82%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88">企鵝也懂程式設計</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>