# 1. Tạo Annotaion và Configuration trong Spring ## 1.1. Giới thiệu Spring Framework **Spring Framework** là một framework phổ biến nhất trong việc phát triển ứng dụng Java. Spring Framework cung cấp một giải pháp toàn diện cho việc xây dựng ứng dụng Java Enterprise. Spring Framework cung cấp một cách linh hoạt và mạnh mẽ để xây dựng ứng dụng Java Enterprise. Spring Framework cung cấp một số tính năng chính sau: - **Inversion of Control (IoC)**: Spring Framework cung cấp một container để quản lý các đối tượng của ứng dụng. Container này sẽ tạo ra các đối tượng, inject các đối tượng vào các đối tượng khác, và quản lý vòng đời của các đối tượng. - **Dependency Injection (DI)**: Spring Framework cung cấp một cách để inject các đối tượng vào các đối tượng khác. Dependency Injection giúp giảm sự phụ thuộc giữa các đối tượng trong ứng dụng. - **Aspect-Oriented Programming (AOP)**: Spring Framework hỗ trợ Aspect-Oriented Programming. AOP giúp chia nhỏ chức năng của ứng dụng thành các phần nhỏ hơn, dễ quản lý hơn. - **Transaction Management**: Spring Framework hỗ trợ quản lý transaction. Spring Framework cung cấp một cách để quản lý transaction một cách dễ dàng. - **Model-View-Controller (MVC)**: Spring Framework cung cấp một cách để xây dựng ứng dụng web theo mô hình MVC. - **Data Access**: Spring Framework hỗ trợ các cách để truy cập dữ liệu từ cơ sở dữ liệu. ## 1.2. Ví dụ Trong ví dụ này, chúng ta sẽ tạo một ứng dụng Spring đơn giản. > HelloWorld.java ```java package com.example.demo; import org.springframework.context.annotation.Bean; // Import Bean annotation import org.springframework.context.annotation.Configuration; // Import Configuration annotation @Configuration // Đánh dấu đây là một Configuration class, nó sẽ được Spring Framework quản lý và tạo ra các Bean public class HelloWorld { @Bean // Đánh dấu đây là một Bean, Spring Framework sẽ tạo ra một Bean từ phương thức này public String helloWorld() { return "Hello World!"; } } ``` > Main.java ```java package com.example.demo; import org.springframework.context.annotation.AnnotationConfigApplicationContext; // Import AnnotationConfigApplicationContext public class Main { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(HelloWorld.class); // Tạo một AnnotationConfigApplicationContext với HelloWorld class, nó sẽ tạo ra các Bean từ HelloWorld class String helloWorld = context.getBean("helloWorld", String.class); // Lấy Bean có tên là "helloWorld" từ context System.out.println(helloWorld); // In ra màn hình, kết quả sẽ là "Hello World!" context.close(); // Đóng context } } ``` ## 1.3. Sử dụng Annotation để tạo Bean và Configuration Trong Spring Framework, chúng ta có thể sử dụng các Annotation để tạo Bean và Configuration. Thay vì dùng @Bean và @Configuration như trên, chúng ta có thể sử dụng các Annotation sau: - **@Component**: Đánh dấu một class là một Bean. - **@Repository**: Đánh dấu một class là một Bean, thường được sử dụng cho các class truy cập cơ sở dữ liệu. - **@Service**: Đánh dấu một class là một Bean, thường được sử dụng cho các class chứa logic xử lý. - **@Controller**: Đánh dấu một class là một Bean, thường được sử dụng cho các class xử lý request trong ứng dụng web. - **@Configuration**: Đánh dấu một class là một Configuration class. Ví dụ: >Pacman.java ```java package com.example.demo.game; import org.springframework.stereotype.Component; // Import Component annotation @Component // Đánh dấu đây là một Bean public class Pacman { public void play() { System.out.println("Pacman is playing!"); } } ``` > Main.java ```java package com.example.demo; import org.springframework.context.annotation.AnnotationConfigApplicationContext; // Import AnnotationConfigApplicationContext import org.springframework.context.annotation.ComponentScan; // Import ComponentScan annotation, sử dụng để quét các Bean @Configuration // Đánh dấu đây là một Configuration class @ComponentScan("com.example.demo.game") // Quét các Bean trong package com.example.demo.game và package con của nó public class Main() { public static void main(String[] args) { try (var context = new AnnotationConfigApplicationContext(Main.class)) { // Tạo một AnnotationConfigApplicationContext với Main class, nó sẽ tạo ra các Bean từ Main class var game = context.getBean(Pacman.class); // Lấy Bean có kiểu là Pacman từ context pacman.play(); // Gọi phương thức play() của Bean } } } ``` ## 1.4. Import Dependency Injection trong Spring Việc sử dụng Dependency Injection trong Spring Framework giúp giảm sự phụ thuộc giữa các đối tượng trong ứng dụng. Chúng ta có thể sử dụng các Annotation sau để inject các đối tượng vào các đối tượng khác: - **@Autowired**: Đánh dấu một thuộc tính, setter method, hoặc constructor để Spring Framework inject một Bean vào đó. - **@Qualifier**: Đánh dấu một Bean để chỉ định Bean cụ thể sẽ được inject. Có những cách sau để inject các đối tượng vào các đối tượng khác: - **Constructor Injection**: Inject các đối tượng thông qua constructor. (nên sử dụng cách này) - **Setter Injection**: Inject các đối tượng thông qua setter method. (Sử dụng Annotation @Autowired) - **Field Injection**: Inject các đối tượng thông qua thuộc tính. (Sử dụng Annotation @Autowired) Ví dụ: > Hello.java ```java package com.example.demo; import org.springframework.stereotype.Component; // Import Component annotation @Component // Đánh dấu đây là một Bean public class Hello { // - **Constructor Injection**: Inject các đối tượng thông qua constructor private final Vietnamese vietnamese; public Hello(Vietnamese vietnamese) { super(); this.vietnamese = vietnamese; // Inject Vietnamese Bean vào Hello Bean thông qua constructor } // - **Setter Injection**: Inject các đối tượng thông qua setter method private English english; @Autowired // Đánh dấu đây là một Bean sẽ được inject public void setEnglish(English english) { this.english = english; // Inject English Bean vào Hello Bean thông qua setter method } // - **Field Injection**: Inject các đối tượng thông qua thuộc tính @Autowired // Đánh dấu đây là một Bean sẽ được inject private Vietnamese vietnamese; // Inject Japanese Bean vào Hello Bean thông qua thuộc tín } @Component // Đánh dấu đây là một Bean class English { public String display() { return "Hello World!"; } } @Component // Đánh dấu đây là một Bean class Vietnamese { public String display() { return "Xin chào!"; } } ``` ## 1.5. So sánh @Component và @Bean | @Component | @Bean | |------------|-------| | Đánh dấu một class là một Bean | Đánh dấu một phương thức là một Bean | | Dễ sử dụng hơn qua việc thêm Annotation vào class | Phải viết nhiều code hơn | | Inject các đối tượng thông qua constructor, setter method, hoặc field | Inject các đối tượng thông qua gọi hàm hoặc parameter | | Được tạo ra bởi Spring Framework | Được tạo ra bởi lập trình viên | | Thiết lập Bean cho toàn bộ ứng dụng: Code @Component | Tùy chỉnh logic nghiệp vụ hoặc chỉ thiết lập Bean cho ứng dụng, thư viện bên thứ ba: Code @Bean | ## 1.6. Các Annotation Component trong Spring Spring Framework cung cấp một số Annotation `Component` để chúng ta có thể sử dụng trong việc tạo Bean và Configuration. Ngoài `@Component`, chúng ta còn có các Annotation cụ thể `@Repository`, `@Service`, `@Controller` để đánh dấu một class là một Bean. Nhưng nó hoạt động giống nhau, chỉ khác nhau ở mục đích sử dụng: - **@Repository**: Đánh dấu một class là một Bean, thường được sử dụng cho các class truy cập cơ sở dữ liệu. - **@Service**: Đánh dấu một class là một Bean, thường được sử dụng cho các class chứa logic xử lý. - **@Controller**: Đánh dấu một class là một Bean, thường được sử dụng cho các class xử lý request trong ứng dụng web. Spring khuyến khích chúng ta sử dụng các Annotation cụ thể `@Repository`, `@Service`, `@Controller` để chúng ta có thể phân biệt rõ ràng mục đích sử dụng của Bean. # 2 Record trong Java 14 ## 2.1. Giới thiệu **Record** là một thuật ngữ mới trong Java 14, nó được giới thiệu trong [JEP 359](https://openjdk.java.net/jeps/359). Record giúp chúng ta tạo ra các class immutable một cách dễ dàng hơn. 1 class được gọi là `immutable` khi các trạng thái của nó không thể thay đổi sau khi khởi tạo. Để tạo ra một class immutable trong Java trước đây, chúng ta cần phải làm như sau: - Khai báo class là `final` để không thể kế thừa. - Khai báo tất cả các trường là `private final`. - Tạo ra các phương thức getter cho các trường. Với Record, chúng ta không cần phải làm như vậy nữa, chúng ta chỉ cần khai báo các trường và sử dụng `record` keyword. ## 2.2. Ví dụ về Record > Java version < 14 ```java public final class Person { private final String name; private final int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } ``` > Java 14 ```java public record Person(String name, int age) {} ``` Ngoài ra, chúng ta cũng có thể thêm các phương thức, constructor vào Record: ```java public record Person(String name, int age) { public void printInfo() { System.out.println("Name: " + name + ", Age: " + age); } } ``` ## 2.3. Tính năng của Record - **Tạo constructor**: Record sẽ tạo ra một constructor với các tham số truyền vào. - **Tạo getter**: Record sẽ tạo ra các phương thức getter cho các trường. - **Tạo equals() và hashCode()**: Record sẽ tạo ra các phương thức `equals()` và `hashCode()` cho các trường. - **Tạo toString()**: Record sẽ tạo ra phương thức `toString()` để in ra thông tin của Record. Mặc định, nó sẽ in ra tên của class và giá trị của các trường. # 3 Annotation Primary và Qualifier trong Spring ## 3.1. Annotation @Primary Trong Spring Framework, khi chúng ta có nhiều Bean cùng kiểu dữ liệu, chúng ta có thể sử dụng Annotation `@Primary` để chỉ định Bean mặc định sẽ được sử dụng. Ví dụ: > Hello.java ```java package com.example.demo; public interface Hello { String display(); } ``` > HelloWorld.java ```java package com.example.demo; import org.springframework.context.stereotype.Component; @Component // Đánh dấu đây là một Bean public class HelloWorld implements Hello{ public String display() { return "Hello World!"; } } ``` > HelloVietnam.java ```java package com.example.demo; import org.springframework.context.annotation.Primary; import org.springframework.context.stereotype.Component; @Component // Đánh dấu đây là một Bean @Primary // Đánh dấu đây là Bean mặc định public class HelloVietnam implements Hello{ public String display() { return "Xin chào!"; } } ``` > Main.java ```java package com.example.demo; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; @Configuration // Đánh dấu đây là một Configuration class @ComponentScan("com.example.demo") // Quét các Bean trong package com.example.demo và package con của nó public class Main { public static void main(String[] args) { try (var context = new AnnotationConfigApplicationContext(Main.class)) { var text = context.getBean(Hello.class); System.out.println(text.display()); // In ra màn hình, kết quả sẽ là "Xin chào!" } } } ``` Trong ví dụ trên, chúng ta có hai Bean cùng kiểu dữ liệu `String`, Bean `HelloVietnam` được đánh dấu là Bean mặc định với Annotation `@Primary`, nên khi chúng ta lấy Bean từ context, Bean `HelloVietnam` sẽ được lấy ra. ## 3.2. Annotation @Qualifier Trong Spring Framework, khi chúng ta có nhiều Bean cùng kiểu dữ liệu, chúng ta có thể sử dụng Annotation `@Qualifier` để chỉ định Bean cụ thể sẽ được sử dụng. Độ ưu tiên cuả `@Qualifier` cao hơn `@Primary`. Ví dụ: > Hello.java ```java package com.example.demo; public interface Hello { String display(); } ``` > HelloWorld.java ```java package com.example.demo; import org.springframework.context.stereotype.Component; @Component // Đánh dấu đây là một Bean public class HelloWorld implements Hello{ public String display() { return "Hello World!"; } } ``` > HelloVietnam.java ```java package com.example.demo; import org.springframework.context.annotation.Qualifier; import org.springframework.context.stereotype.Component; @Component // Đánh dấu đây là một Bean @Qualifier("vietnam") // Đánh dấu tên cho Bean public class HelloVietnam implements Hello{ public String display() { return "Xin chào!"; } } ``` > Main.java ```java package com.example.demo; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; @Configuration // Đánh dấu đây là một Configuration class @ComponentScan("com.example.demo") // Quét các Bean trong package com.example.demo và package con của nó public class Main { public static void main(String[] args) { try (var context = new AnnotationConfigApplicationContext(Main.class)) { var text = context.getBean(@Qualifier("vietnam") Hello.class); // Lấy Bean có tên là "vietnam" từ context System.out.println(text.display()); // In ra màn hình, kết quả sẽ là "Xin chào!" } } } ``` Trong ví dụ trên, chúng ta có hai Bean cùng kiểu dữ liệu `String`, Bean `helloVietnam` được đánh dấu với tên "vietnam" với Annotation `@Qualifier`, nên khi chúng ta lấy Bean từ context, Bean `helloVietnam` sẽ được lấy ra. Mặc định, nếu không sử dụng `@Qualifier`, muốn lấy Bean cụ thể, chúng ta phải sử dụng tên của Bean (tên mặc định là tên phương thức, class tạo Bean). # 4 Lazy Initialization và Eager Initialization trong Spring ## 4.1. Giới thiệu Trong Spring Framework, chúng ta có thể sử dụng Lazy Initialization và Eager Initialization để quản lý việc tạo ra các Bean. - **Lazy Initialization**: Khi chúng ta sử dụng Lazy Initialization, các Bean sẽ được tạo ra khi chúng ta cần sử dụng chúng. - **Eager Initialization**: Khi chúng ta sử dụng Eager Initialization, các Bean sẽ được tạo ra ngay khi ApplicationContext được khởi tạo. Mặc định, Spring Framework sử dụng **Eager Initialization**. ## 4.2. Sử dụng Lazy Initialization Để sử dụng Lazy Initialization, chúng ta có thể sử dụng Annotation `@Lazy` và có thể đặt ở những nơi sau: - Ngay sau Annotation `@Component`, `@Service`, `@Repository`, `@Controller`. - Ngay sau Annotation `@Bean`. - Ngay sau Annotation `@Configuration` (Các Bean trong Configuration class sẽ được tạo ra theo cách Lazy Initialization). Ví dụ: ```java package com.example.demo; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Lazy; @Configuration public class AppConfig { @Bean @Lazy public Hello hello() { return new Hello(); } } ``` ## 4.3. Lợi ích và hạn chế của Lazy Initialization và Eager Initialization ### 4.3.1. Lazy Initialization - **Tiết kiệm tài nguyên**: Chúng ta chỉ tạo ra các Bean khi cần sử dụng, giúp tiết kiệm tài nguyên hệ thống. - **Tăng hiệu suất**: Khi ứng dụng có nhiều Bean, việc sử dụng Lazy Initialization giúp tăng hiệu suất của ứng dụng. - Tuy nhiên, việc sử dụng `Lazy Initialization` có thể làm cho ứng dụng không bắt được lỗi, gây ra crash trong quá trình chạy ứng dụng. ### 4.3.2. Eager Initialization - **Dễ dàng quản lý**: Khi chúng ta sử dụng Eager Initialization, tất cả các Bean sẽ được tạo ra ngay khi ApplicationContext được khởi tạo, giúp dễ dàng quản lý các Bean. - **Dễ dàng debug**: Khi ứng dụng có lỗi, chúng ta dễ dàng debug vì tất cả các Bean đã được tạo ra. - **Kiểm soát lỗi**: Khi ứng dụng có lỗi, App sẽ bắt được lỗi ngay từ đầu, và không chạy tiếp nếu có lỗi. - Được Spring recommend sử dụng. # 5. Scope Prototype và Singleton trong Spring ## 5.1. Giới thiệu Trong Spring Framework, chúng ta có thể sử dụng Scope Prototype và Singleton để quản lý vòng đời của các Bean. - **Singleton**: Khi chúng ta sử dụng Singleton, Spring Framework sẽ tạo ra một Bean duy nhất cho mỗi ApplicationContext. - **Prototype**: Khi chúng ta sử dụng Prototype, Spring Framework sẽ tạo ra một Bean mới mỗi khi chúng ta cần sử dụng. Mặc định, Spring Framework sử dụng **Singleton**. ## 5.2. Sử dụng Scope Prototype và Singleton Để sử dụng Scope Prototype và Singleton, chúng ta có thể sử dụng Annotation `@Scope` và có thể đặt ở những nơi sau: - Ngay sau Annotation `@Component`, `@Service`, `@Repository`, `@Controller`. - Ngay sau Annotation `@Bean`. - Ngay sau Annotation `@Configuration` (Các Bean trong Configuration class sẽ được tạo ra theo cách Prototype hoặc Singleton). Ví dụ: ```java package com.example.demo; import org.springframework.context.annotation.Bean; import org.springframework.context.stereotype.Component; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Scope; import org.springframework.beans.factory.config.ConfigurableBeanFactory; @Component class NormalClass {} @Component @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) // Đánh dấu Bean sẽ được tạo ra theo Prototype, mỗi lần lấy Bean sẽ tạo ra một Bean mới class PrototypeClass {} @Configuration @ComponentScan class Main { public static void main(String[] args) { try (var context = new AnnotationConfigApplicationContext(Main.class)) { // Mặc định sẽ là Singleton, in ra cùng một địa chỉ vùng nhớ System.out.println(context.getBean(NormalClass.class)); // #0 System.out.println(context.getBean(NormalClass.class)); // #0 System.out.println(context.getBean(NormalClass.class)); // #0 // Prototype, in ra các địa chỉ vùng nhớ khác nhau System.out.println(context.getBean(PrototypeClass.class)); // #1 System.out.println(context.getBean(PrototypeClass.class)); // #2 System.out.println(context.getBean(PrototypeClass.class)); // #3 } } } ``` ## 5.3. Lợi ích khi sử dụng Scope trong Spring - **Singleton**: Khi chúng ta sử dụng Singleton, chúng ta có thể tạo ra một Bean duy nhất cho mỗi IoC Container, giúp tiết kiệm tài nguyên hệ thống. - **Prototype**: Khi chúng ta sử dụng Prototype, chúng ta có thể tạo ra một Bean mới mỗi khi cần sử dụng, giúp tránh được việc sử dụng Bean cũ. - **Scope** chỉ dành cho phát triển Web + **Request**: Bean sẽ được tạo ra mỗi khi có một HTTP Request. + **Session**: Bean sẽ được tạo ra mỗi khi có một HTTP Session. + **Application**: Bean sẽ được tạo ra mỗi khi ứng dụng được khởi tạo. + **WebSocket**: Bean sẽ được tạo ra mỗi khi có một WebSocket. # 6. Sử dụng PostConstruct và PreDestroy trong Spring ## 6.1. Giới thiệu Trong Spring Framework, chúng ta có thể sử dụng Annotation `@PostConstruct` và `@PreDestroy` để quản lý vòng đời của các Bean. - **@PostConstruct**: Đánh dấu một phương thức sẽ được gọi ngay sau khi Bean được tạo ra (gọi ngay sau Constructor). - **@PreDestroy**: Đánh dấu một phương thức sẽ được gọi ngay trước khi Bean bị hủy (gọi trước khi Bean bị Garbage Collection). ## 6.2. Sử dụng PostConstruct và PreDestroy Để sử dụng PostConstruct và PreDestroy, chúng ta có thể sử dụng Annotation `@PostConstruct` và `@PreDestroy` và đặt sau các phương thức cần sử dụng. Ví dụ: ```java package com.example.demo; import jakarta.annotation.PostConstruct; import jakarta.annotation.PreDestroy; import org.springframework.stereotype.Component; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; @Component class ClassA { public void display() { System.out.println("Class A"); } } @Component class ClassB { //DI private final ClassA classA; public ClassB(ClassA classA) { this.classA = classA; System.out.println("All dependencies are injected"); } @PostConstruct // Phương thức này sẽ được gọi ngay sau khi Bean được tạo ra, init() sẽ được gọi ngay sau Constructor public void init() { classA.display(); } @PreDestroy // Phương thức này sẽ được gọi ngay trước khi Bean bị hủy, destroy() sẽ được gọi trước khi Bean bị Garbage Collection public void destroy() { System.out.println("Destroy Class B"); } } @Configuration @ComponentScan class Main { public static void main(String[] args) { try (var context = new AnnotationConfigApplicationContext(Main.class)) { context.getBean(ClassB.class); // PostConstruct sẽ được gọi ngay sau khi Bean được tạo ra } // Sau khi context.close() được gọi, PreDestroy sẽ được gọi ngay trước khi Bean bị hủy } } ``` ## 6.3. Lợi ích khi sử dụng PostConstruct và PreDestroy ### 6.3.1. PostConstruct - **Init Bean**: Sử dụng PostConstruct giúp chúng ta khởi tạo Bean ngay sau khi Bean được tạo ra, giúp chúng ta khởi tạo các giá trị mặc định cho Bean. - **Inject Dependency**: Sử dụng PostConstruct giúp chúng ta inject các dependency ngay sau khi Bean được tạo ra, giúp chúng ta sử dụng các dependency ngay sau khi Bean được tạo ra. - **Init Connection**: Sử dụng PostConstruct giúp chúng ta khởi tạo kết nối ngay sau khi Bean được tạo ra, giúp chúng ta sử dụng kết nối ngay sau khi Bean được tạo ra. (Database connection, Socket connection, ...) ### 6.3.2. PreDestroy - **Close Connection**: Sử dụng PreDestroy giúp chúng ta đóng kết nối ngay trước khi Bean bị hủy, giúp chúng ta đóng kết nối ngay trước khi Bean bị hủy. (Database connection, Socket connection, ...) - **Destroy Bean**: Sử dụng PreDestroy giúp chúng ta hủy Bean ngay trước khi Bean bị hủy - **Clean Up**: Sử dụng PreDestroy giúp chúng ta dọn dẹp các resource không cần thiết ngay trước khi Bean bị hủy, giúp chúng ta dọn dẹp các resource không cần thiết ngay trước khi Bean bị hủy. # 7 Bắt đầu dự án SpringBoot ## 7.1. Sử dụng Spring Initializr **Spring Initializr** là một công cụ giúp chúng ta tạo ra một dự án SpringBoot một cách nhanh chóng và dễ dàng. Để sử dụng **Spring Initializr**, chúng ta truy cập vào trang chủ của Spring Initializr tại [https://start.spring.io/](https://start.spring.io/). Sau đó, để tạo một dự án SpringBoot, chúng ta thực hiện các bước sau: 1. Chọn **Project** là **Maven Project** hoặc **Gradle Project**. 2. Chọn **Language** là **Java** hoặc **Kotlin** hoặc **Groovy**. 3. Chọn **Spring Boot** version. 4. Chọn **Project Metadata**: - **Group**: Group ID của dự án. - **Artifact**: Artifact ID của dự án. - **Name**: Tên dự án. - **Description**: Mô tả dự án. - **Package Name**: Package name của dự án. - **Packaging**: Jar hoặc War. - **Java**: Java version. 5. Chọn **Dependencies**: - **Spring Boot DevTools**: Cung cấp một số công cụ hỗ trợ phát triển dự án SpringBoot, reload server khi có thay đổi mà không cần restart server, trừ khi thay đổi file `pom.xml`. - **Spring Web**: Hỗ trợ phát triển ứng dụng Web. - **Thymeleaf**: Template Engine. - **Spring Data JPA**: Hỗ trợ phát triển ứng dụng sử dụng JPA, một loại giao tiếp với cơ sở dữ liệu. - **Spring Data JDBC**: Hỗ trợ phát triển ứng dụng sử dụng JDBC, một loại giao tiếp với cơ sở dữ liệu. - **H2 Database**: Cơ sở dữ liệu H2, một cơ sở dữ liệu in-memory. Sau khi chọn xong, chúng ta nhấn vào nút **Generate** để tải về dự án SpringBoot. ## 7.2. Import dự án vào IDE Sau khi tải về dự án SpringBoot, chúng ta giải nén dự án và import vào IDE. Với IntelliJ IDEA, chúng ta chọn **File** -> **Open...** và chọn thư mục dự án vừa giải nén. Với Eclipse, chúng ta chọn **File** -> **Import...** -> **Existing Maven Projects** và chọn thư mục dự án vừa giải nén. ## 7.3. Chạy ứng dụng SpringBoot Để chạy ứng dụng SpringBoot, chúng ta chạy file **DemoApplication.java**. ## 7.4. Tạo API đơn giản Để tạo một API đơn giản, chúng ta tạo một Controller và một API. Sử dụng Annotation `@RestController` để đánh dấu một class là một Controller. Sử dung Annotation `@RequestMapping` để đánh dấu một phương thức là một API (Bao gồm cả phương thức GET, POST, PUT, DELETE). Sử dụng Annotation `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping` để đánh dấu một phương thức là một API (Tương ứng với phương thức GET, POST, PUT, DELETE). Ví dụ: ```java package com.example.demo; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class HelloController { @GetMapping("/hello") public String hello() { return "Hello World!"; } } ``` Trong ví dụ trên, chúng ta đã tạo một API `/hello` trả về chuỗi "Hello World!". ## 7.5. Cấu hình môi trường cho ứng dụng SpringBoot Trong SpringBoot, chúng ta có thể cấu hình các profiles cho ứng dụng SpringBoot thông qua file **application.properties** hoặc **application.yml**. > Lưu ý: Việc cấu hình tên cho projects rất quan trọng để tránh trùng lặp với các projects khác nhất là trong Microservices: `spring.application.name`. ### 7.5.1. Cấu hình các profiles cho ứng dụng SpringBoot Thông thường, khi phát triển ứng dụng SpringBoot, chúng ta cần cấu hình các profiles cho ứng dụng SpringBoot như: `dev`, `prod`, `test`. Để cấu hình các profiles cho ứng dụng SpringBoot, chúng ta tạo các file cấu hình với tên là `application-{profile}.properties` hoặc `application-{profile}.yml`. Các file cấu hình này sẽ được load tương ứng với profile mà chúng ta cấu hình trong file **application.properties** hoặc **application.yml**. Nếu có trùng giá trị với file gốc, giá trị trong file cấu hình profile sẽ được sử dụng. Ví dụ: >`application-dev.properties`: Cấu hình cho môi trường `dev`. ```properties # Logging logging.level.org.springframework=trace ``` >`application-prod.properties`: Cấu hình cho môi trường `prod`. ```properties # Logging logging.level.org.springframework=info ``` >`application.properties`: Cấu hình mặc định. ```properties # Logging logging.level.org.springframework=debug # Chọn profile, giá trị chính là tên sau dấu '-' trong tên file cấu hình spring.profiles.active=dev ``` ### 7.5.2. Đọc biến môi trường từ file `application.properties` bằng `@ConfigurationProperties` để cấu hình ứng dụng SpringBoot Trong SpringBoot, chúng ta có thể cấu hình các thông số cho ứng dụng SpringBoot thông qua Annotation `@ConfigurationProperties`. Nó sẽ lấy các giá trị từ file cấu hình `application.properties` hoặc `application.yml`. `@ConfigurationProperties` với `prefix` sẽ lấy các giá trị từ file cấu hình với prefix tương ứng. Sử dụng annotation này giúp chúng ta có thể lấy được nhiều thông số từ file cấu hình một cách dễ dàng và không bị mã hóa cứng trong code. Ví dụ: >`application.properties` ```properties # Cấu hình thông số cho ứng dụng app.name=Demo app.version=1.0 ``` >`AppProperties.java` ```java package com.example.demo; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; @Component @ConfigurationProperties(prefix = "app") // Lấy thông số từ file cấu hình application.properties với prefix là 'app' public class AppProperties { private String name; // Lấy thông số 'app.name' sẽ tự động gán vào biến name private String version; // Lấy thông số 'app.version' sẽ tự động gán vào biến version // Getter và Setter (Bắt buộc phải có để SpringBoot có thể inject giá trị vào biến) } ``` Trong ví dụ trên, chúng ta đã tạo một class `AppProperties` để lấy thông số `app.name` và `app.version` từ file cấu hình `application.properties`. Lưu ý phải thêm Annotation `@Component` để SpringBoot có thể quản lý Bean này. ### 7.5.3. Đọc biến môi trường từ file `application.properties` bằng `@Value` để cấu hình ứng dụng SpringBoot Trong SpringBoot, chúng ta có thể cấu hình các thông số cho ứng dụng SpringBoot thông qua Annotation `@Value`. Nó sẽ lấy các giá trị từ file cấu hình `application.properties` hoặc `application.yml`. `@Value` sẽ lấy giá trị từ file cấu hình với key tương ứng. Sử dụng annotation này giúp chúng ta có thể lấy được một thông số từ file cấu hình một cách dễ dàng. Ví dụ: >Serivce.java ```java package com.example.demo; import org.springframework.beans.factory.annotation.Value; public class Service { @Value("${app.name}") // Lấy thông số 'app.name' từ file cấu hình application.properties và gán vào biến name private String name; @Value("${app.version}") // Lấy thông số 'app.version' từ file cấu hình application.properties và gán vào biến version private String version; } ``` Trong ví dụ trên, chúng ta đã tạo một class `Service` để lấy thông số `app.name` và `app.version` từ file cấu hình `application.properties`. ### 7.5.4. Đọc biến môi trường từ file `application.properties` bằng `Environment` để cấu hình ứng dụng SpringBoot Trong SpringBoot, chúng ta có thể cấu hình các thông số cho ứng dụng SpringBoot thông qua Interface `Environment`. Nó sẽ lấy các giá trị từ file cấu hình `application.properties` hoặc `application.yml`. `Environment` sẽ lấy giá trị từ file cấu hình với key tương ứng. Sử dụng Interface này giúp chúng ta có thể lấy được một thông số từ file cấu hình một cách dễ dàng. Ngoài ra, `Environment` là một Bean của SpringBoot nên chúng ta phải Inject nó vào class cần sử dụng thông qua Annotation `@Autowired` hoặc thông qua `Constructor`. `Environment` còn được sử dụng để đọc biến môi trường ở môi trường OS. Ví dụ: >Serivce.java ```java package com.example.demo; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.env.Environment; public class Service { @Autowired // Cần phải Inject Environment vào Service để sử dụng private Environment env; public void print() { System.out.println(env.getProperty("app.name")); // Lấy thông số 'app.name' từ file cấu hình application.properties System.out.println(env.getProperty("app.version")); // Lấy thông số 'app.version' từ file cấu hình application.properties } } ``` Trong ví dụ trên, chúng ta đã tạo một class `Service` để lấy thông số `app.name` và `app.version` từ file cấu hình `application.properties`. ## 7.6. Sử dụng Actuator trong ứng dụng SpringBoot Trong SpringBoot, chúng ta có thể sử dụng Actuator để quản lý ứng dụng SpringBoot. Để sử dụng Actuator, chúng ta thêm thư viện `spring-boot-starter-actuator` vào file **pom.xml**. Sau khi thêm thư viện, chúng ta có thể truy cập vào các API của Actuator thông qua đường dẫn `/actuator`. Để kiểm tra toàn bộ thông tin ứng dụng, chúng ta sửa cấu hình trong file **application.properties** hoặc **application.yml**: ```properties management.endpoints.web.exposure.include=* # Cho phép truy cập tất cả các API của Actuator management.endpoints.web.exposure.include=health,metrics # Cho phép truy cập API health và metrics của Actuator (nên sử dụng cấu hình này tránh lỗi bảo mật) ``` Các API của Actuator: - `/actuator/health`: Kiểm tra trạng thái của ứng dụng. - `/actuator/info`: Hiển thị thông tin ứng dụng. - `/actuator/metrics`: Hiển thị các metrics của ứng dụng. - `/actuator/beans`: Hiển thị các Bean của ứng dụng. - `/actuator/env`: Hiển thị các thông số môi trường của ứng dụng. - `/actuator/loggers`: Hiển thị các loggers của ứng dụng. - `/actuator/mappings`: Hiển thị các mappings của ứng dụng. - `/actuator/trace`: Hiển thị các trace của ứng dụng. ## 7.7. Deploy ứng dụng SpringBoot Để deploy ứng dụng SpringBoot, chúng ta có thể thực hiện các bước sau: 1. Build ứng dụng SpringBoot bằng lệnh Maven: `mvn clean install`. 2. Sau khi build xong, chúng ta sẽ có file `tenProject.jar` trong thư mục `target`. 3. Chạy ứng dụng SpringBoot bằng lệnh: `java -jar target/tenProject.jar`. - Nếu muốn chạy ứng dụng SpringBoot với một cấu hình khác thủ công, chúng ta thêm tiền tố cấu hình vào sau `--` đặt ở cuối lệnh. Ví dụ: `java -jar target/tenProject.jar --spring.profiles.active=prod`. (Program arguments: Ưu tiên cao nhất) - Hoặc có thể đê sau `-D` để cấu hình thông số khác. Ví dụ: `java -Dserver.port=8080 -jar target/tenProject.jar`. (VM arguments: Ưu tiên thấp hơn) - Hoặc có thể dùng biến môi trường để cấu hình, với quy tắc `viết hoa` và `thay dấu '.' bằng '_'` các biến cách nhau bởi dấu `;` (Environment arguments: Ưu tiên thấp nhất). Ví dụ: + Windows: `env:SPRING_PROFILES_ACTIVE="prod";java -jar target/tenProject.jar`. + Linux & MacOS: `SPRING_PROFILES_ACTIVE="prod" java -jar target/tenProject.jar`. ## 7.8. Các thư viện quan trọng trong SpringBoot (file pom.xml) Trong file **pom.xml**, chúng ta có thể thêm các thư viện quan trọng sau: - **Spring Boot Starter Web**: Thư viện hỗ trợ phát triển ứng dụng Web. - **Spring Boot DevTools**: Thư viện hỗ trợ phát triển ứng dụng SpringBoot, reload server khi có thay đổi mà không cần restart server, trừ khi thay đổi file `pom.xml`. - **Spring Boot Starter Actuator**: Thư viện hỗ trợ quản lý ứng dụng SpringBoot bao gồm: thông tin ứng dụng, thông tin về các Bean, thông tin về các request, thông tin về các lỗi, ... - **Spring Boot Starter Test**: Thư viện hỗ trợ việc test ứng dụng SpringBoot. - **Spring Boot Starter Data JPA**: Thư viện hỗ trợ giao tiếp với cơ sở dữ liệu sử dụng JPA. - **Spring Boot Stảter Data JDBC**: Thư viện hỗ trợ giao tiếp với cơ sở dữ liệu sử dụng JDBC. - **Spring Boot Starter Security**: Thư viện hỗ trợ bảo mật ứng dụng SpringBoot. # 8. Build Image Spring Boot App. ## 8.1. Giới thiệu Sau khi chúng ta đã viết xong ứng dụng `Spring Boot`, chúng ta cần `build` ứng dụng thành một file thực thi `(jar)` để chạy trên môi trường khác nhau. Đặc biệt với `Microservice`, chúng ta cần `build` ứng dụng thành một `image` để chạy trên `Docker`. Có 3 cách chính để `build` ứng dụng `Spring Boot`: - Sử dụng `Dockfile` để `build` ứng dụng thành `image`. - Sử dụng `Buildpacks` để `build` ứng dụng thành `image` (Maven và Gradle) Mặc định từ `Spring Boot 2.3`. - Sử dụng `Google Jib` để `build` ứng dụng thành `image`. ## 8.2. Build Image Spring Boot App ### 8.2.1. Sử dụng Dockerfile Đầu tiên, chúng ta `build` ứng dụng `Spring Boot` thành một file `jar` bằng lệnh `mvn clean install`. File `jar` sẽ được lưu trong thư mục `target`. Sau đó, chúng ta cần tạo một file `Dockerfile` trong thư mục gốc của ứng dụng `Spring Boot`. ```Dockerfile # Dockerfile FROM openjdk:21-jdk-slim COPY target/demo-0.0.1-SNAPSHOT.jar app.jar ENTRYPOINT ["java","-jar","/app.jar"] ``` Trong đưong dẫn `project` chạy lệnh sau để `build` ứng dụng thành `image`. ```shell docker build -t demo-spring-boot . ``` Chạy lệnh sau để chạy `image`. ```shell docker run -p 8080:8080 demo-spring-boot ``` Chúng ta có thể tạo `Dockfile` làm cả 2 việc `build` ứng dụng thành `jar` và `image`... ### 8.2.2. Sử dụng Buildpacks Từ `Spring Boot 2.3`, chúng ta có thể sử dụng `Buildpacks` để `build` ứng dụng thành `image` với `Maven` và `Gradle`. Chúng ta cần thêm các thành phần sau vào file `pom.xml`. > Thêm tag `jar` để `build` thành file `jar`. ```xml jar ``` > Thêm tag `image và name` vào `spring-boot-maven-plugin` để đặt tên cho `image`. ```xml org.springframework.boot spring-boot-maven-plugin dannguyenmessi/${project.artifactId}-bank:v1 ``` Sau đó, chúng ta chạy lệnh sau để `build` ứng dụng thành `image`. ```shell mvn spring-boot:build-image # hoặc với máy chưa có mvn, sử dụng ./mvnw có sẵn trong project ./mvnw spring-boot:build-image ``` Sau khi chạy lệnh trên, chúng ta sẽ thấy `image` được tạo trong `Docker`. Image này sẽ tối ưu hóa và nhỏ gọn hơn so với `Dockerfile`. ### 8.2.3. Sử dụng Google Jib `Google Jib` là một công cụ giúp chúng ta `build` ứng dụng `Spring Boot` nhanh chóng và dễ dàng thành `image`. Chúng ta cần thêm các thành phần sau vào file `pom.xml`. > Thêm tag `jar` để `build` thành file `jar`. ```xml jar ``` > Thêm `plugin` vào file `pom.xml` ở phần `build` để sử dụng `Google Jib`. ```xml com.google.cloud.tools jib-maven-plugin 3.4.3 myimage ``` Sau đó, chúng ta chạy lệnh sau để `build` ứng dụng thành `image`. ```shell mvn compile jib:dockerBuild # hoặc với máy chưa có mvn, sử dụng ./mvnw có sẵn trong project ./mvnw compile jib:dockerBuild ``` Sau khi chạy lệnh trên, chúng ta sẽ thấy `image` được tạo trong `Docker`. Image này sẽ tối ưu hóa và nhỏ gọn hơn so với `Dockerfile`. Sử dụng `Google Jib` giúp chúng ta có thể `build` image mà không cần cài đặt `Docker`. Hướng dẫn chi tiết về `Google Jib` với link sau: [Google Jib](https://github.com/GoogleContainerTools/jib) ## 8.3. So sánh 3 cách `build` ứng dụng `Spring Boot` thành `image` - `Dockerfile`: + Cách này không phù hợp với người mới bắt đầu với `Docker` vì cần phải viết `Dockerfile` và chạy nhiều lệnh, tối ưu hóa `image` không cao. + Cách này phù hợp với người muốn tùy chỉnh `image` theo ý muốn. - `Buildpacks`: + Cách này phù hợp với người mới bắt đầu với `Docker` vì không cần viết `Dockerfile` và chạy nhiều lệnh. + Ngoài ra, `Buildpacks` còn hỗ trợ tối ưu hóa `image` khi `build`. + Hỗ trợ `Cache` giúp tăng tốc độ `build` ứng dụng. + Hỗ trợ nhiều ngôn ngữ lập trình khác nhau. + Tuy nhiên, cách này không phù hợp với người muốn tùy chỉnh `image` theo ý muốn vì nó bắt buộc phải tuân thủ theo quy tắc của `Buildpacks`. - `Google Jib`: + Cách này phù hợp với người mới bắt đầu với `Docker` vì không cần cài đặt `Docker`, không cần viết `Dockerfile` và chạy nhiều lệnh. + Ngoài ra, `Google Jib` còn hỗ trợ tối ưu hóa `image` khi `build`. + Tuy nhiên, cách này không phù hợp với người muốn tùy chỉnh `image` theo ý muốn vì nó bắt buộc phải tuân thủ theo quy tắc của `Google Jib`. ## 8.4. Chạy nhiều `services` với Docker Compose Với việc sử dụng `Google Jib` hoặc `Buildpacks` chúng ta không thể có file `Dockerfile` để build offline với `Docke Compose`. Vì thế cần phải `push` image lên `Docker Hub` hoặc `Registry` khác hoặc phải build image trước khi chạy `Docker Compose`. > Lệnh `push` image lên `Docker Hub` (Lưu ý tên image phải đúng chuẩn `Docker Hub`: `{account}/{image}:{tag}`). ```shell docker push {account}/{image}:{tag} ``` > Khi tạo các `services` trong file `docker-compose.yml`, chúng ta cần cho các `services` sử dụng chung một `network` để có thể giao tiếp với nhau. ```yml services: service1: image: {account}/{image}:{tag} ports: - "8080:8080" networks: - my-network service2: image: {account}/{image}:{tag} ports: - "8081:8081" networks: - my-network networks: my-network: driver: bridge ``` > Chạy lệnh sau để chạy `Docker Compose`. ```shell docker-compose up -d ``` > Lưu ý: Khi chạy `Docker Compose` cần phải chạy lệnh `docker login` để đăng nhập vào `Docker Hub` hoặc `Registry` khác để `pull` image về máy.

Spring: Làm quen với Spring Framework, Spring Boot