ติวสอบสัมภาษณ์งาน Java เบื้องต้น ฉบับ มือใหม่ [2]

Spring Framework เบื้องต้น
Java Spring Boot การ build project สามารถทำได้หลายรูปแบบ โดยขึ้นอยู่กับ build tool ที่ใช้ ซึ่งที่นิยมมากที่สุดมี 2 ตัวหลัก ๆ คือ

✅ 1. Gradle
✅ 2. Maven

ทั้งสอง เกี่ยวข้องโดยตรง กับกระบวนการ build, run, test, package, และ deploy ของ Spring Boot project

🔧 Gradle และ Maven คืออะไร?

วิธีการ build Project (Build ได้กี่แบบ?)

👉 หากใช้ Gradle:

./gradlew build         # สร้าง JAR
./gradlew bootRun       # รันแอปแบบ development
./gradlew bootJar       # สร้างไฟล์ JAR เฉพาะ Spring Boot
./gradlew clean         # ลบ build เดิมก่อน

👉 หากใช้ Maven:

mvn clean install       # สร้าง JAR และติดตั้งไว้ใน local repo
mvn spring-boot:run     # รันแอป
mvn package             # สร้าง JAR

📦 ผลลัพธ์ของการ Build

• ได้เป็นไฟล์ .jar หรือ .war (ขึ้นอยู่กับ config)
• สามารถนำไป deploy ได้ทันที (Spring Boot เป็น self-contained)

🎯 สรุปว่า Gradle/Maven เกี่ยวข้องอย่างไร?

✅ สรุปสุดท้าย

• Spring Boot build ได้หลายแบบ เช่น JAR, WAR, native image (GraalVM)
• ต้องใช้ build tool เช่น Gradle หรือ Maven ในการจัดการขั้นตอนต่าง ๆ
• Gradle กับ Maven ทำหน้าที่คล้ายกันแต่มี syntax และประสิทธิภาพที่ต่างกันเล็กน้อย

🌟 GraalVM คืออะไร?
GraalVM คือ High-Performance Virtual Machine ที่สามารถรันหลายภาษาได้ (เช่น Java, JavaScript, Python, Ruby ฯลฯ) โดยมี จุดเด่น คือ:

✅ รองรับการ compile Java application ให้กลายเป็น Native Executable (AOT Compile)
✅ ทำงานเร็วกว่า JVM แบบปกติในบางกรณี
✅ ใช้ memory น้อยลง
✅ Startup time ไวมาก (เช่น 0.01 วินาที เทียบกับ 2-3 วินาทีของ JVM ปกติ)

GraalVM ต่างจาก JVM ปกติยังไง?

🚀 GraalVM กับ Spring Boot
Spring Boot สามารถทำงานร่วมกับ GraalVM ได้ผ่าน Spring Native หรือ Spring Boot 3.x ขึ้นไปที่ใช้ AOT Processing โดยตรง

ตัวอย่าง Build แบบ Native:

./gradlew bootBuildImage --builder paketobuildpacks/builder:tiny

หรือใช้ GraalVM ตรง ๆ:

native-image -jar your-app.jar

ได้ผลลัพธ์เป็นไฟล์ .exe หรือ binary ที่สามารถ run ได้โดยไม่ต้องติดตั้ง Java

📌 ใช้ GraalVM ตอนไหนถึงจะดี?

📦 แต่ข้อควรระวัง

• ไม่รองรับ Reflection บางแบบ (เช่นการใช้ Class.forName()) ต้องกำหนดล่วงหน้า
• การ build นานมาก (บางครั้งหลักนาที)
• ต้องเขียนโค้ดให้ AOT-friendly
• ไม่รองรับทุก third-party lib โดยเฉพาะที่ใช้ dynamic code

🔍 AOT คืออะไร?
AOT = Ahead-Of-Time compilation
คือการ compile โค้ดล่วงหน้า (ก่อน runtime) ให้เป็น binary (เครื่องอ่านได้เลย)
ต่างจาก JIT ที่ compile ตอน runtime

📦 ตัวอย่าง:

🚀 ทำไม AOT เร็ว?
เพราะมัน ไม่ต้องตีความ หรือ compile ซ้ำ ขณะรันโปรแกรม
จึงได้ผลลัพธ์:

• ⚡ Startup เร็ว
• 🧠 ใช้ memory น้อยลง
• 🐳 เหมาะกับ container, serverless

🧩 AOT-Friendly คืออะไร?

โค้ดของเราต้องเขียนในแบบที่ "สามารถ compile ล่วงหน้า" ได้ โดยไม่ต้องพึ่ง runtime processing หรือ reflection ที่ไม่แน่นอน

❌ ตัวอย่าง "ไม่ AOT-friendly"

Class.forName("com.example.MyClass"); // ใช้ reflection

@Autowired
private Object someBean; // ใช้ dynamic injection แบบที่ compiler เดาไม่ได้

พวกนี้ GraalVM จะไม่สามารถ "คาดเดา" ได้ล่วงหน้า ทำให้ build ไม่ผ่าน หรือรันไม่ได้

✅ ตัวอย่าง "AOT-friendly"

@Autowired
private MyService myService; // แบบเจาะจง class

หรือใช้ annotation ที่ GraalVM รองรับ เช่น @RestController, @ConfigurationProperties แบบ static

📘 ใน Spring Boot 3+

Spring Boot 3.x ใช้ Spring AOT Engine เพื่อ:

• วิเคราะห์โค้ดทั้งหมด
• Generate code/metadata ที่ GraalVM เข้าใจได้
• ลด runtime reflection ลง

✅ สรุป

ตัวอย่างการใช้ Spring Boot สร้าง REST Controller ง่าย ๆ

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello from Spring Boot!";
    }
}

@RestController คือการประกาศว่า Class นี้เป็น Controller แบบ REST

@GetMapping คือการแมป HTTP GET กับ method

Dependency Injection (DI)

@Service
public class UserService {
    // business logic
}

@RestController
public class UserController {
    private final UserService userService;

    // Constructor Injection
    public UserController(UserService userService) {
        this.userService = userService;
    }
}

JDBC (Java Database Connectivity)
JDBC คือ API มาตรฐานของ Java สำหรับเชื่อมต่อและสั่งงานฐานข้อมูลแบบ relational เช่น MySQL, PostgreSQL

ตัวอย่าง JDBC เชื่อมต่อฐานข้อมูล

String url = "jdbc:mysql://localhost:3306/mydb";
String user = "root";
String password = "password";

try (Connection conn = DriverManager.getConnection(url, user, password)) {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT * FROM users");

    while (rs.next()) {
        System.out.println(rs.getString("username"));
    }
} catch (SQLException e) {
    e.printStackTrace();
}

🌐 REST API
REST (Representational State Transfer) คือสถาปัตยกรรมสำหรับสร้าง Web Services ที่ใช้ HTTP Method (GET, POST, PUT, DELETE) ในการจัดการ Resource

HTTP Methods ที่ควรรู้

ตัวอย่าง REST API ด้วย Spring Boot

@RestController
@RequestMapping("/api/users")
public class UserRestController {

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        // return user by id
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        // create user
    }
}

📌 Lombok คืออะไร?
Lombok เป็นไลบรารีของ Java ที่ช่วยลดโค้ดซ้ำซ้อน เช่น getter, setter, constructor, toString() โดยอาศัย annotation-based code generation ที่ compile-time

Lombok Annotations ที่ใช้บ่อย

ตัวอย่างการใช้ Lombok

import lombok.Data;
import lombok.Builder;

@Data
@Builder
public class User {
    private String name;
    private int age;
}

ผลลัพธ์ที่ได้: class นี้จะมี getter, setter, toString, equals, hashCode และสามารถสร้าง object แบบนี้ได้:

User user = User.builder()
                .name("Alice")
                .age(25)
                .build();

✅ Annotation ใน Java คือชนิดพิเศษของ interface
❌ ไม่ใช่ class (class ธรรมดา)
❌ ไม่ใช่ function

• Annotation = ป้ายกำกับ (label) ที่อธิบายว่า class หรือ method นี้ "มีความหมายพิเศษ"
• Annotation คือคำสั่งพิเศษที่ขึ้นต้นด้วย @ ใช้เพื่อ แนบ metadata (ข้อมูลเพิ่มเติม) ให้กับ class, method, field ฯลฯ

• ไม่ส่งผลต่อ logic โดยตรง แต่สามารถใช้ร่วมกับ framework, tooling, หรือ compile-time processing

• ใน Java ทุก annotation ถูกสร้างด้วยคีย์เวิร์ด @interface

• ซึ่งหมายความว่า annotation เป็นชนิดหนึ่งของ interface ที่มี metadata เท่านั้น

• เบื้องหลัง @interface → Java จะสร้าง interface พิเศษ ที่เก็บเฉพาะ "ค่ากำกับ (metadata)" เท่านั้น ไม่มี logic หรือพฤติกรรมแบบ class ทั่วไป

สรุปเปรียบเทียบ

แล้ว annotation ใช้ยังไง?

@MyAnnotation(value = "dev")
public class Demo {}

• JVM จะไม่เรียก MyAnnotation แบบ object แต่จะเก็บข้อมูลนี้เป็น metadata
• เราสามารถใช้ reflection อ่าน metadata เหล่านี้ได้ใน runtime
• หรือ framework เช่น Spring, JUnit, Hibernate จะใช้ annotation เพื่อกำหนดพฤติกรรม

🧠 สรุปสุดท้ายจำง่าย:

• ❓ Annotation คือ class ไหม?
• 🔸 ❌ ไม่ใช่ class
• 🔹 ✅ เป็น interface แบบพิเศษ (ประกาศด้วย @interface)
• 🔸 📌 ใช้เพื่อแนบ metadata ไม่ได้มี logic หรือสร้าง instance แบบ class ได้

Spring Boot Annotations ที่ควรรู้
ตัวอย่าง Annotation ที่ใช้บ่อยใน Java

Annotation ที่ใช้บ่อยใน Spring Framework

🔽 Annotation ระดับ Class

🔼 Annotation ระดับ Method / Field

🧩 ตัวอย่าง REST API Controller ด้วย Spring + Lombok

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    @GetMapping("/{id}")
    public UserDto getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping
    public UserDto createUser(@RequestBody CreateUserRequest request) {
        return userService.createUser(request);
    }
}

@Data
public class CreateUserRequest {
    private String name;
    private int age;
}

📚 สรุปหัวข้อเสริม

• ✅ Lombok ช่วยลดโค้ดซ้ำซ้อน ทำให้ class สั้น กระชับ (Boilerplate code-โค้ดพื้นฐานที่ต้องเขียนซ้ำ ๆ เพื่อให้ระบบทำงาน แต่ไม่ใช่ logic หลัก)
• ✅ ใช้ annotation เช่น @data, @builder, @RequiredArgsConstructor บ่อยมากใน Spring
• ✅ เข้าใจ annotation ของ Spring จะช่วยให้พัฒนาได้รวดเร็ว และอธิบายโค้ดได้เวลาสัมภาษณ์

คำถามสัมภาษณ์เกี่ยวกับ Lombok & Spring Annotations

คำถามสัมภาษณ์งานยอดนิยม