How to เขียน Java spring boot ให้ได้ภายใน 30 นาที

หากเราคิดจะทำอะไรให้เป็นอาชีพแบบจริง ๆ จัง ๆ สิ่งเดียวที่จะนำเราไปสู่เส้นทางแห่งความสำเร็จ คือเราต้องมีความ “รักและชอบ” มันจริง ๆ ถ้าอาชีพที่ทำอยู่ ณ​ ขณะนี้มันไม่ได้ “รัก” หรือชอบมันจริง ๆ จงกลับไปพิจารณามันอีกสักรอบหนึ่ง และอีกอย่างความรักและชอบมันอย่างเดียวจะไร้ความหมายเอามาก ๆ หากเราไม่มีวินัยในการสร้างองค์ความรู้มันมากพอ “จงชอบ และ ทำแบบที่เราชอบมัน” อย่าแค่บอกว่าชอบแต่ไร้ซึ่งวินัยและความพยายาม !

การสร้างโปรแกรมเว็บแอบพลิเคชั่นเซิฟเวอร์นั้นสามารถพัฒนาขึ้นด้วยหลากหลายภาษา และหนึ่งในภาษาที่ได้รับความนิยมในฝั่งของ Enterprise หรือเรียกอีกอย่างว่าบริษัทที่ค่อนข้างมีฐานะทางการเงินที่ดี ก็คือ Java เรียกได้ว่า java นั้นอยู่กับบริษัทใหญ่ ๆ มาค่อนข้างนาน แน่นอน Java ลำพังเพียว ๆ ก็ไม่สามารถรันเซิฟเวอร์ขึ้นมาได้ต้องตัวช่วยอื่น ๆ เช่น servlet tomcat เป็นต้น ซึ่งก็ได้ล่วงเลยผ่านการพัฒนาขึ้นมาเรื่อย ๆ จนกลายเป็น Spring boot ณ​ ปัจจุบัน

Step 1 ติดตั้ง environment

ก่อนที่จะเขียนโปรแกรมใด ๆ ก็ช่างสิ่งแรกที่จะต้องทำคือทำให้เครื่องตัวเองรันโปรแกรมให้ได้เสียก่อน นั่นคือสิ่งที่จำเป็น สำหรับ Java เองก็สามารถติดตั้งได้ไม่ยากนั้น โดยมีขั้นตอนดังนี้

• Download Java SE Runtime Environment(JRE) โดยสามารถดาวโหลดได้ที่ https://www.oracle.com/java/technologies/javase-jre8-downloads.html
• Download Java development kit (JDK) โดยสามารถดาวโหลดได้ที่
  https://www.oracle.com/java/technologies/javase-jdk11-downloads.html
• Install คือการติดตั้ง JRE และ JDK ตัวที่ Download มาเมื่อสักครู่ สำหรับขั้นตอนการติดตั้งก็เหมือนเราลงโปรแกรมทั่วไป กรณีที่ใช้ระบบปฏิบัติการ windows นั้นอาจจะจำเป็นต้องทำการ SET Path เพื่อให้ระบบรู้จะไปเรียกใช้ JRE และ JDK ที่ Path ไหน โดยมีขั้นตอนแบบละเอียดตามลิงค์ด้านล่างนี้
  http://programminghunter.blogspot.com/2015/10/set-java-home-path-in-window-10.html
• Test หลังจากที่ติดตั้งเครื่องมือเสร็จจำเป็นที่จะต้องทดสอบว่าเครื่องเรานั้นพร้อมสำหรับการเขียนโปรแกรม Java แล้วหรือยัง ด้วยวิธีการคือไปที่ Terminal หรือ cmd ของ Windows จากนั้นลองพิมพ์คำสั่ง java — version หากไม่ขึ้น command not found เป็นอันถูกต้อง ไปต่อขั้นตอนต่อไปได้เลย

Step 2 เลือกเครื่องมือในการเขียนโค๊ด

เครื่องมือในการเขียน java นั้นที่นิยมใช้อยู่มีประมาณ 3 ตัวคือ

• eclipse (free)
• intellij (free community)
• netbean (free)

ในบทความนี้ผมจะแนะนำให้ใช้ intellij ซึ่งโปรแกรมนี้ถูกพัฒนาขึ้นมาโดยบริษัท Jetbrains ซึ่งเป็นบริษัทเดียวกันกับที่ทำ android studio, pycham, phpstrom, webstrom และอื่น ๆ จริง ๆแล้วบริษัทนี้ถูกตั้งมาเพื่อสร้าง editor เพื่อการเขียนโค๊ตให้เร็วและง่ายขึ้นไม่ว่าจะดัดแปลงไปทำเครื่องมือสำหรับภาษาใด ๆ ก็ตาม ทุกเครื่องมือก็จะอยู่บนหลักการเดียวกัน และใช้ core แบบเดียวกัน ซึ่งมันค่อนข้างง่ายสำหรับคนที่เคยใช้ editor แบบอื่นของค่ายมาก่อนหน้านี้แล้ว ทำให้สามารถย้ายไปใช้เครื่องมือตัวอื่นสำหรับภาษาใหม่ได้สะดวก แต่มันก็มีข้อเสียอยู่บ้าง ตรงที่ค่อนข้างจะกินทรัพยากรของเครื่องเอาเรื่องด้วยเหมือนกัน สามารถดาวโหลดได้ตามลิงค์ด้านล่าง https://www.jetbrains.com/idea/download/

การที่เรามีเครื่องมือที่ดีนั้นจะช่วยให้เราเขียนโค๊ตได้เร็วยิ่งขึ้น ดั่งนักดาบที่มีกระบี่ที่คมและดี ย่อมได้เปรียบคู่ต่อสู้เสมอ ดังนั้นจงเลือกกระบี่ให้ถูกกับจริตของตัวเองและทีม

Step 3 ทำความเข้าใจ Spring boot เบื้องต้น

อย่างที่เล่าไปในหัวข้อข้างต้น Spring boot ถูกพัฒนาขึ้นมาเพื่อทำให้ภาษา java สามารถเขียนโปรแกรมในลักษณะที่เป็น Web application Programming ซึ่งโปรแกรมนี้จะถูกประมาลผลอยู่ทางฝั่งของ Server side โดยการส่งข้อมูลผ่านโปรตอลคอล HTTP (hypertext transfer protocol) ถ้าลักษณะงานที่เรากำลังพัฒนาอยู่มีความเป็น Web application Programming หรือ Rest API หรืออื่น ๆ ที่ใช้การประมวลผลในลักษณะ Server -> client ตัว spring boot เองก็น่าจะเป็นอีกหนึ่งตัวเลือกเพื่อนำไปใช้งานในการพัฒนาระบบได้เป็นอย่างดี

Step 4 ทำความเข้าใจภาษาโปรแกรม Java

• Java เป็นภาษาที่เรียกว่า Strong Type แปลเป็นไทยคือ เวลาที่เราจะทำอะไรก็ช่างต้องมีประเภทของตัวแปรหรือ Object กำกับมันเสมอ ตัวอย่างประเภทของตัวแปรเช่น String , int , boolean Object และอื่น ๆ
• การสร้าง method หรือ function นั้นจะต้อง return กำกับคู่ด้วยเสมอเช่นเดียวกันถ้าไม่มีอะไรคืนค่าไปก็จำเป็นที่จะต้องประกาศเป็น void กำกับ
• การสร้าง parameter ที่ส่งเข้าไปทำงานใน function ก็ต้องกำกับด้วยประเภทของตัวแปรด้วยเช่นกัน

ดังนั้นเมื่อ Java มันถูกออกแบบมาแบบนี้จึงกลายเป็นคุณสมบัติอย่างหนึ่งที่ให้ Perfomance ของมันดี โดยมีหลักการง่าย ๆ คือมันไม่จำเป็นต้องไปสืบว่า ตัวแปรนั้นคือประเภทอะไรช่วยลดภาระงานในการประมวลผลได้เป็นอย่างดี อันนี้แค่ส่วนเล็ก ๆ น้อยของมัน สิ่งที่ควรรู้ต่อไปคือโครงสร้างทางกายภาพของภาษา Java ซึ่งสามารถอธิบายด้วยภาพดังนี้

Step 5 รู้จักกับ spring initializr

spring initializr เป็นเครื่องมือสำหรับตั้งต้นโปรเจ็คด้วย spring boot สามารถเข้าถึงออนไลน์ได้ที่ https://start.spring.io/ ซึ่งการใช้งานค่อนข้างง่ายและสะดวก

spring intializr

Tab ฝั่งขวามือจะเป็นการตั้งค่าเกี่ยวกับโปรเจ็ค และฝั่งซ้ายมือ dependencies จะเกี่ยวกับ library ต่าง ๆ ที่เราต้องการติดตั้งไปพร้อมกับจังหวะที่ init โปรเจ็ค สามารถเพิ่ม package library ต่าง ๆ ได้โดยการคลิ๊กที่ปุ่ม Add แล้วเลือก search package ที่ต้องการ สามารถอ่านเพิ่มเติมได้ที่ http://assanai.com/initialize-spring-boot-project/

Step 6 ลอง Hello world ด้วย Spring boot

แน่นอนก่อนจะเขียนโปรแกรมให้มัน advance ขึ้นไป เราต้องผ่านกระบวนการ Hello world เพื่อทดสอบ Runtime + editor ของเราก่อนเสมอ ในขั้นตอนนี้สำหรับคนที่จะทำตามต้องผ่าน Step 1 setup และติดตั้งเครื่องมือให้เรียบร้อยเสียก่อน ถ้าหากทำเสร็จแล้วก็มาต่อได้เลย โดยเริ่มจากการสร้าง init project จาก https://start.spring.io/ ในขั้นตอนนี้ผมจะสร้างโปรเจ็ค hello ง่าย ๆ โดยการตั้งชื่อ group ว่า com.samark และ artifact ว่า hello และเพิ่ม package เข้ามาหนึ่งตัวคือ web ดังภาพ

spring intializr

หลังจากนั้นก็กด generate ที่ปุ่มได้เลยระบบจะทำการบังคับให้ดาวโหลดไฟล์เป็น zip นำไปเก็บไว้ในส่วนที่เราคิดว่าหาเจอ จากนั้นให้ทำการแตกไฟล์ออกมาแล้วนำไปเปิดด้วย program intellij เราจะเห็นโครงสร้างของไฟล์ดังภาพ

spring boot on intellij

ทดสอบรันโปรแกรมด้วย maven ที่ติดมาตัว zip file ตอนที่เรา init จากนั้นให้ไปที่ tab terminal ใน intellij เพื่อที่จะทดสอบรันโปรแกรมด้วยคำสั่ง

./mvnw spring-boot:run

ถ้าไม่มีอะไรผิดพลาดระบบจำทำการสร้าง Http server ขึ้นมาบน port default ของ Spring boot คือ 8080 ในส่วนของ intellij จะเห็นภาพดังนี้

spring boot run in intellij with mvnw command

ถ้าผิดไปจากนี้แสดงว่าต้องมีส่วนใดส่วนหนึ่งไม่ถูกต้องให้กลับไปทบทวนทีละ step ใหม่อีกครั้ง ขั้นตอนต่อไปคือจะทำการสร้าง Controller Hello world โดยการ click ขวาที่ hello folder แล้วเลือก new -> java class ดังภาพ

intellij create file

จากนั้นให้พิมพ์ชื่อ HelloController ไฟล์ของไปดังภาพ

intellij input file name

หลังจากที่ได้ไฟล์ HelloController มาแล้วให้ทำการแก้ไข code ตามตัวอย่างด้านล่างดังนี้

package com.samark.hello;

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

@RestController
@RequestMapping("hello")
public class HelloController {

    @GetMapping("mama")
    public String callMama() {
        return "Hello mama";
    }
}

หลังจากที่แก้ไขไพล์ HelloController เสร็จแล้วให้ทำการทดสอบรันดูด้วยคำสั่งเดิมด้านบน หากไม่มีอะไรผิดพลาดจะเห็นภาพดังนี้

hello mama controller

และสุดท้ายถ้ารันขึ้นแล้วสามารถเข้าไปทดสอบผ่าน web browser ด้วย url http://localhost:8080/hello/mama จะได้ผลลัพธ์คือ “Hello mama” เป็นอันว่า ณ ตอนนี้เราก็สามารถทำให้ เครื่องของเราสามารถพัฒนา spring boot ได้แล้ว

Step 7 ความแตกต่างของ dependency management [maven vs gradle]

สองตัวนี้ทำหน้าที่เหมือนกันคือจัดการ package ต่าง ๆ ของโปรเจ็ครวมถึงการจัดการรันโปรแกรม แต่ก็มีคุณสมบัติบางอย่างที่แตกต่างกันเช่น maven เป็น xml ส่วน gradle นั้นเป็น groovy script และอื่น ๆ ที่แตกต่างกันดังภาพ

maven vs gradle

Step 8 วิธีการ run project ด้วยคำสั่งต่าง ๆ ของ maven

คำสั่งของ maven ก็มีไม่กี่อย่างซึ่งมันมี highlight อย่างหนึ่งคือถ้าหากเราติดตั้ง maven package ไปในเครื่อง เราจะสามารถใช้คำสั่ง mvn ได้เช่นเดียวกันกับ ./mvnw ซึ่งจะมีความต่างคือ mvn จะสามารถรันคำสั่งที่ไหนก็ได้ใน cmd หรือ terminal path แต่ mvnw นั้นจะรันได้เฉพาะที่เรามีไฟล์ mvnw อยู่เท่านั้น ตัวอย่างคำสั่งที่เราควรรู้จักของ maven มีดังต่อไปนี้

mvnw [สำหรับ unix base]
mvnw.cmd [สำหรับ windows]
mvn clean test [clean คือการ clear cache , test คือการรัน test]
mvn spring-boot:run [สั่ง application run]
mvn clean spring-boot:run -X  [สั่ง application run พร้อม debug]
mvn package [pack jar file]

Step 9 ความแตกต่างของ configuration [yaml vs properties]

ส่วนนี้คือตัวจัดการ configuration ของโปรเจ็คซึ่งมีสองอย่างคือ yaml และ properties แน่นอนว่าสามารถเลือกใช้ได้เพียงอย่างใดอย่างหนึ่งเท่านั้น สำหรับไฟล์ yaml จะเขียนในลักษณะ node และ child แต่ properties จะเขียนข้อความแบบเต็ม ดังตัวอย่างด้านล่าง

## yml
spring:
  datasource:
       username:postgres
## properties
spring.datasource.username=postgres

Step 10 รู้จักกับ pom.xml หรือ

pom คือส่วนที่รวบรวม dependecy ทั้งหมดของโปรเจ็คจะอยู่ในรูปแบบของไฟล์​ xml นอกเหนือจากนั้นจะเป็นส่วนที่ไว้ใช้จัดการ configulation บางอย่างของโปรเจ็ค อีกด้วย ตัวอย่างไฟล์ pom.xml ที่ได้มาจาก hello mana

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.2.6.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.samark</groupId>
   <artifactId>hello</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>hello</name>
   <description>Demo project for Spring Boot</description>

   <properties>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
         <exclusions>
            <exclusion>
               <groupId>org.junit.vintage</groupId>
               <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
         </exclusions>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

สรุป

ที่มาที่ไปของการเขียนบทความนี้เพื่อเป็นการสรุปให้ตัวเองและสำหรับผู้ที่เริ่มสนใจการพัฒนาโปรแกรมด้วย spring boot ถ้าอ่านแบบผ่าน ๆ เร็ว ๆ จะเห็นว่ากระบวนนั้นก็ไม่ได้มีอะไรที่ยากเลย เพียงแต่ว่าหลาย ๆ บทความที่ผมไปเจอมาส่วนมักจะตัดกระบวนการกลางทางมานำเสนอ ส่วนที่ผมจะนำเสนอคือต้องการให้ผู้ที่เริ่มจากไม่รู้อะไรเลยสามารถนำไปศึกษาได้ด้วยตัวเองและต่อยอดได้ ซึ่งผู้เขียนหวังเป็นอย่างยิ่งว่าจะเป็นประโยชน์สำหรับท่านผู้อ่านไม่มากก็น้อย

กระบวนการในการพัฒนาโปรแกรมนั้นสามารถทำได้หลากหลายรูปแบบ หรือ “ท่า”​ซึ่งในแต่ละทีมก็จะมีท่าที่เหมาะสมของตัวเองที่สำคัญคือเราหา “ท่า”​ นั้นเจอหรือยัง แน่นอนว่ามันเร็วไปที่เราจะนิยามคำว่า “ถูก”​ หรือ “ผิด” ถ้ายังไม่ได้ทดลองทำ “ท่า”​ต่าง ๆ ให้มันมากพอ หลายทีมก็ชอบยก best practice ของที่อื่นมาเป็นตัวตั้ง แล้วนำมาปรับใช้ ถามว่ามันผิดไหมตอบเลยว่า “ไม่ผิด”​ สุดท้ายมันอยู่ที่ทีมเรามากว่าว่าจะรู้สึกกับมันยังไงต่างหากเล่า การเขียน code ก็เหมือนการสร้างงานศิลปะ ถ้ามีอารมณ์ที่ดีผ่อนคลาย การสร้างงานที่ดีออกมานั้นก็ไม่ใช่เรื่องที่ยาก และผลงานทางศิลปะนั้นจะออกมาดีผมคิดว่าน่าจะต้องมีบางอย่างที่เอกลักษณ์ที่เป็นของตัวเองบ้างก็คงจะดีไม่น้อย

สำหรับภาคแรกผู้เขียนขอจบลงไว้เพียงเท่านี้ ไว้จะมาเขียนต่อในบทถัดไป
ปล.หากข้อมูลผิดพลาดประการใดต้องขอภัยมา ณ​ ที่นี้
สมัคร ชัยสงวน