BỘ TÀI NGUYÊN VÀ MÔI TRƯỜNG

TRƯỜNG ĐẠI HỌC TÀI NGUYÊN VÀ MÔI TRƯỜNG

KHOA: HỆ THỐNG THÔNG TIN VÀ VIỄN THÁM


ĐỒ ÁN MÔN HỌC
BẢO MẬT MẠNG MÁY TÍNH VÀ HỆ THỐNG
NGHIÊN CỨU GIẢI PHÁP ĐẢM BẢO AN TOÀN CHO RESTFUL
API VỚI SPRING BOOT TRÊN CƠ SỞ DỮ LIỆU MONGODB.

………………………………………………………………………………………………

Giảng viên hướng dẫn: ThS. Phạm Trọng Huynh

Sinh viên thực hiện: Hà Thị Thùy Trang
Phạm Lê Nhật Quang
Lớp: 08_DHCNPM
Khóa: 08

TP. Hồ Chí Minh, tháng 10 năm 2022

 BỘ TÀI NGUYÊN VÀ MÔI TRƯỜNG
TRƯỜNG ĐẠI HỌC TÀI NGUYÊN VÀ MÔI TRƯỜNG
KHOA: HỆ THỐNG THÔNG TIN VÀ VIỄN THÁM


ĐỒ ÁN MÔN HỌC
BẢO MẬT MẠNG MÁY TÍNH VÀ HỆ THỐNG
NGHIÊN CỨU GIẢI PHÁP ĐẢM BẢO AN TOÀN CHO RESTFUL
API VỚI SPRING BOOT TRÊN CƠ SỞ DỮ LIỆU MONGODB.
………………………………………………………………………………………………

Giảng viên hướng dẫn: ThS. Phạm Trọng Huynh

Sinh viên thực hiện: Hà Thị Thùy Trang

Phạm Lê Nhật Quang
Trần Bá Thiện
Lớp: 08_DHCNPM
Khóa: 08

TP. Hồ Chí Minh, tháng 10 năm 2022

MỞ ĐẦU
 LỜI CẢM ƠN

Em xin chân thành cảm ơn thầy Phạm Trọng Huynh, Giảng viên môn bảo mật mạng máy
tính và hệ thống trường Đại học Tài nguyên và Môi trường Thành phố Hồ Chí Minh đã
cung cấp cho tôi những kỹ năng cơ bản và kiến thức cần thiết để hoàn thành nhiệm vụ dự
án này.
Tuy nhiên, trong quá trình làm đề tài, do kiến thức chuyên môn còn hạn chế của em, chắc
chắn sẽ không tránh khỏi những thiếu sót trong việc nêu và đánh giá vấn đề. Em rất mong
được sự đóng góp ý kiến, đánh giá của các thầy cô giáo bộ môn để khóa luận của em
được hoàn thiện hơn. Chân thành cảm ơn!
 NHẬN XÉT
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................
.............................................................................................................................................

ĐIỂM
Chương 1 Giới thiệu đồ án

1.1 Định nghĩa vấn đề

Ngày này hệ thống Internet ngày càng phát triển, phần mềm sử dụng hệ thống internet ngày càng nhiều.
Các phần mềm đa dạng dẫn đến có rất nhiều yêu cầu cần được đáp ứng. Một số phần mềm đòi hỏi về
lượng thông tin lớn, dữ liệu lớn… nhưng không thể lưu dữ liệu đó tại thiết bị sử dụng, một số loại yêu
cầu được cập nhật realtime (theo thời gian thực) để đảm bảo sự đúng đắn của thông tin (chứng khoán,
tiền tệ ...), một số phần mềm đòi hỏi xử lý nhanh và mạnh, mà các thiết bị lại không thể thực hiện được
do cấu hình không đủ. Thông thường, để sử dụng các dịch vụ đó thì người dùng cần dùng trình duyệt,
truy cập website và thực hiện. Nhưng người dùng chỉ có thể sử dụng các giao diện mà nhà cung cấp đã
thiết kết sẵn tuy nhiên chúng không đáp ứng những mong muốn của người dùng. Để giải quyết vấn đề
trên chúng ta cần xây dựng một ứng dụng có các tính năng như các dịch vụ đó nhưng giao diện thân
thiện hơn. Vì vậy cần phải sử dụng những dịch vụ riêng biệt để tương tác với hệ thống cung cấp các dịch
vụ nói trên. Một hệ thống như vậy được gọi là API.

1.2 Phạm vi của đồ án

1.3 Mục tiêu, sự cần thiết của đề tài, tại sao lại chọn đề tài này?
Chương 2 Tìm hiểu JDK 8, Gradle, Spring Boot, Spring data mongodb

2.1 JDK là gì?

Java Development Kit (JDK) là một trong ba gói công nghệ cốt lõi được sử dụng
trong lập trình Java, cùng với JVM (Máy ảo Java - Java Virtual Machine) và JRE (Java
Runtime Environment - Môi trường Java Runtime). Việc phân biệt giữa ba công nghệ
này, cũng như hiểu được cách chúng kết nối với nhau là rất quan trọng.

 JVM là thành phần Java nền tảng để chạy các chương trình.
 JRE là phần on-disk của Java, phần tạo ra JVM.
 JDK cho phép các developer tạo các chương trình Java, trong đó các chương trình
có thể được JVM và JRE xử lý và chạy.

Các developer khi mới sử dụng Java thường dễ nhầm lẫn Java Development Kit với Java
Runtime Environment. Để phân biệt, ta cần nhớ rằng JDK là một gói các công cụ phát
triển phần mềm dựa trên Java, trong khi JRE là gói công cụ sử dụng để chạy Java code.

JRE có thể được sử dụng như một thành phần độc lập để chạy các chương trình Java, dù
vậy, JRE vẫn là một phần của JDK. JDK đòi hỏi bộ công cụ JRE vì chạy các chương
trình Java là một phần của việc phát triển chúng.

Chia sẻ JDK theo 2 cách như sau:

Định nghĩa chuyên ngành: JDK là một hệ tiêu chuẩn trong việc triển khai nền tảng Java,
bao gồm các trình thông dịch dịch và thư viện lớp.

Định nghĩa thông thường: JDK là gói phần mềm bạn tải xuống để tạo các ứng dụng dựa
trên Java.

2.2 IDK 8
Java Development Kit 8 (JDK – Bộ công cụ cho người phát triển ứng dụng bằng ngôn
ngữ lập trình Java) là một tập hợp những công cụ phần mềm được phát triển bởi Sun
Microsystems dành cho các nhà phát triển phần mềm, dùng để viết những applet Java hay
những ứng dụng Java – bộ công cụ này được phát hành miễn phí gồm có trình biên dịch,
trình thông dịch, trình giúp sửa lỗi (debugger, trình chạy applet và tài liệu nghiên cứu).

Kể từ khi ngôn ngữ Java ra đời, JDK là bộ phát triển phần mềm thông dụng nhất cho
Java. Ngày 17 tháng 11 năm 2006, hãng Sun tuyên bố JDK sẽ được phát hành dưới giấy
phép GNU General Public License (GPL), JDK trở thành phần mềm tự do. Việc này đã
được thực hiện phần lớn ngày 8 tháng 5 năm 2007 và mã nguồn được đóng góp cho
OpenJDK.

Java Development Kit 8 là một bộ bao gồm các công cụ cần thiết trong quá trình phát
triển các ứng dụng Java + JRE. Các công cụ đó là: javac.exe, java.exe, applet viewer,…
vai trò của từng công cụ như sau:

 Javac.exe – giúp biên dịch các file nguồn viết bằng ngôn ngữ Java (*.java) thành
mã máy (byte code)

 Java.exe – gọi tới JRE, tải nạp các file mã máy đã được biên dịch và gọi tới
method main để thực thi các mã đó.

 Applet Viewer – để chạy các ứng dụng viết bằng applet.

Như vậy JDK cung cấp tới bạn bộ công cụ trọn gói để phát triển các ứng dụng Java bao
gồm: phát triển (kết quả là các file .java) –> biên dịch (kết quả là các file .class) –> thực
thi ứng dụng.

Yêu cầu phần mềm / Cấu hình:

Windows XP/Vista/7/8
 2.3 Giới thiệu Gradle

Trong quá trình phát triển phần mềm, việc tự động hóa quá trình build và quản lý các thư
viện rất quan trọng, nhằm tối ưu hóa công đoạn biên dịch, đóng gói; thuận tiện hơn cho
việc phát triển phần mềm, cũng như maven và gradle cũng là một trong những công cụ đó.
 Năm 2000, Apache Ant ra đời như là một trong những tool đóng gói hiện đại và
nhanh chóng được sử dụng trong các dự án sử dụng ngôn ngữ Java. Ant cho phép
nhà phát triển mô tả meta-data của dự án cũng như các hoạt động trong quá trình
build thông qua bộ cú pháp XML. Tuy nhiên những đoạn mã viết theo tiêu chuẩn
của Ant quá dài và phức tạp.

 Năm 2004, Apache Maven ra đời và đưa ra các cải thiện so với Ant. Bằng việc
đưa ra một cấu trúc dự án tiêu chuẩn, Maven cho phép nhà phát triển sử dụng một
trong các plugin của mình thay vì phải viết toàn bộ các dòng code mô tả quá trình
đóng gói. Ngoài ra Maven còn cho phép tải về các thư viện phụ thuộc thông qua
internet, điều này giúp cho việc chia sẻ cũng như quản lý phiên bản trở nên dễ
dàng hơn. Đổi lại, nhà phát triển sẽ mất khá nhiều công sức để tùy chỉnh nếu cấu
trúc dự án hiện tại không tuân theo Maven Standard Directory Layout. Và việc vẫn
sử dụng XML làm cho file POM (Project Object Model) trở nên dài dòng và phức
tạp để nắm bắt logic.

 Gradle kết hợp các ưu điểm của Ant và Maven đồng thời thêm vào các cải thiện
mới và sử dụng Groovy trong việc giải quyết bài toán đóng gói.

2.4 Các ưu điểm của gradle

 Gradle kết hợp các ưu điểm của Ant và Maven đồng thời đem lại các cải thiện mới
thông qua việc sử dụng Groovy (một trong những ngôn ngữ JVM) trong việc giải
quyết bài toán đóng gói. Nhờ vậy build script viết bằng Gradle trở nên ngắn gọn
và trực quan dễ đọc hơn.
 Ngoài việc sử dụng Groovy làm DSL, Gradle cũng chú ý hỗ trợ thêm snhiều tính
năng khác để cải thiện quá trình đóng gói cũng như tăng năng suất cho nhà phát
triển. Đối với các dự án lớn, việc có nhiều module bên trong phụ thuộc lẫn nhau là
hết sức phổ biến. Khi sử dụng Maven, quá trình build diễn ra lâu do quá trình
clean toàn bộ các artifact và sau đó là quá trình đóng gói lại từ đầu, đồng thời thời
gian chạy các đoạn Unit Test cũng tiêu tốn khá nhiều thời gian. Đối với Gradle, do
một task build (một đơn vị logic của một quá trình build) đều được định nghĩa
input và output, nên khi có sự thay đổi nhỏ trong source code, Gradle sẽ chỉ thực
hiện build lại một phần cần thiết. Đặc biệt, Gradle sẽ tự tìm kiếm các task khác lệ
thuộc task này và thực hiện quá trình build lại. Như vậy, tốc độ build của Gradle
sẽ được rút ngắn. Hơn thế nữa, Gradle cho phép chạy parallel các đoạn code test
nhờ đó rút ngắn thời gian của quá trình build. Trong tương lai, Gradle cho phép
thực hiện việc phân phối các đoạn code test qua nhiều machine khác nhau để giảm
thiểu thời gian chờ đợi. Đồng thời điểm khác biệt lớn so với Maven là thay vì
dừng quá trình build ngay khi gặp lỗi, Gradle sẽ thực thi hết tất cả các task có thể
và tổng hợp toàn bộ các lỗi gặp phải trong một lần đóng gói. Nhà phát triển sẽ
không phải chờ đợi quá lâu để build và gặp lỗi, sửa lỗi và build lại.

2.4.1 Build cho nhiều ngôn ngữ.

 Gradle hỗ trợ build cho nhiều ngôn ngữ lập trình khác nhau bao gồm Java, Scala,
Python, C/C++, Android, iOS.

 Được thiết kế để chạy trên JVM, Gradle hỗ trợ mạnh mẽ cho các dự án viết bằng
Java và các ngôn ngữ JVM khác như Scala, Groovy,... với việc hỗ trợ nhiều loại
ứng dụng và công cụ phát triển thiết yếu như test frameworks (JUnit, TestNG,
Spock), application frameworks (Java EE, Grails, Play!), embedded web servers
(Jetty) and code analysis cops (Checkstyle, CodeNarc, FindBugs, JDepend, PMD,
JaCoCo, Sonar).
  Tích hợp với Android Studio hỗ trợ quản lý dependency, multi-project. Đồng thời
tích hợp các test services phổ biến như AppThwack, TestDroid và Manymo. Ngoài
ra, có thể tạo nhiều APK từ 1 module và upload chúng lên Google Play và các app
store khác với các phiên bản khác nhau (free, paid,...)

 Hỗ trợ compiler, assembler và linker; cho phép phân phối các thư viện, file thực
thi với nhiều loại (debug, release), platforms (x86, x86_64), phiên bản
(community, enterprise) khác nhau. Tích hợp GCC, CLANG, XCODE, VISUAL
C++ …

 Tích hợp công cụ: Từ các IDE (Integrated Development Environment) đến các CI
(Continuous Integration) hay các công cụ deploy, Gradle tích hợp với tất cả mọi
thứ mà bạn có thể nghĩ đến. tham khảo: https://gradle.org/why/integrates-with-
everything/

2.4.2 Quản lý dependency mạnh mẽ:

 ví dụ đơn giản

repositories {

jcenter()

dependencies {

compile project(':core')

compile 'org.slf4j:slf4j-api:1.7.10'

runtime 'org.slf4j:slf4j-simple:1.7.10'

testCompile('junit:junit:4.12') {
 exclude group: 'org.hamcrest'

testCompile 'org.mockito:mockito-core:1.0'

 Có thể nhận từ bất kỳ repository nào được biết đến : từ public hay private đến
local; pha trộn và kết hợp các loại repository, Maven repositories, public (Maven
Central, jCenter), third-party and in-house (Bintray, Artifactory), local Maven
repository, Ivy repositories, Custom & legacy repositories

2.4.3 Giải pháp dependency tối ưu

 Không bao giờ tải 1 artifact nhiều lần

 Cache

 Xác minh qua checksum

 Track nguồn gốc dependency đảm bảo tính hợp lệ và ngăn chặn lỗi ...

2.5 So sánh với maven

2.5.1 Maven:
 quá trình build diễn ra lâu do quá trình clean toàn bộ các artifact và sau đó là quá
trình đóng gói lại từ đầu.

 các đoạn Unit Test cũng tiêu tốn khá nhiều thời gian.

 dừng quá trình build ngay khi gặp lỗi.

 2.5.2 Gradle
 một task build đều được định nghĩa input và output, nên khi có sự thay đổi nhỏ
trong source code, Gradle sẽ chỉ thực hiện build lại một phần cần thiết.

 Gradle sẽ tự tìm kiếm các task khác lệ thuộc task này và thực hiện quá trình build
lại.

 Gradle cho phép chạy parallel các đoạn code test nhờ đó rút ngắn thời gian của
quá trình build.

 Ngoài ra Gradle cho phép thực hiện việc phân phối các đoạn code test qua nhiều
machine khác nhau để giảm thiểu thời gian chờ đợi.

 thực thi hết tất cả các task có thể.

 Tổng hợp toàn bộ các lỗi gặp phải trong một lần đóng gói.

2.6 Spring Boot là gì? 

Spring Boot là một dự án phát triển bởi JAV (ngôn ngữ java) trong hệ sinh thái Spring
framework. Nó giúp cho các lập trình viên chúng ta đơn giản hóa quá trình lập trình một
ứng dụng với Spring, chỉ tập trung vào việc phát triển business cho ứng dụng.

2.7 Tạo và triển khai CRUD trong project Spring Boot

Ở thời điểm hiện tại Spring Boot có lẽ đang là framework nổi tiếng và được sử dụng
nhiều bậc nhất trong phát triển các ứng dụng sử dụng ngôn ngữ Java. Được xây dựng trên
nền tảng Spring framework, nó có tất cả các tính năng của Spring cộng thêm những tiện
ích mà nó mang lại như giảm thiểu các bước cấu hình phức tạp, nhúng server container
(Tomcat, Jetty hoặc Undertow) tự động vào ứng dụng giúp chúng ta có thể khởi chạy một
ứng dụng ngay lập tức, quản lý dependence thông minh,…
Tất cả điều này đã tạo nên một sức lôi cuốn vô cùng lớn đối với cộng đồng developer trên
khắp thế giới, các công ty cũng đang dần chuyển sang dùng Spring Boot cho các dự án
tiếp theo. Lựa chọn học Spring Boot ở thời điểm hiện tại là một quyết định đúng đắn vì
thị trường việc làm của nó đang rất nhiều. Không chỉ vậy, hiện tại có nhiều công ty cũng
đang dần chuyển từ Spring qua Spring Boot cho các dự án cũ và các dự án mới sẽ dùng
hẳn Spring Boot.

 Khởi tạo project spring boot

Để khởi tạo một project Spring Boot nhanh chóng các bạn có thể truy cập vào trang
Spring Initializr và lựa chọn các thông số cấu hình cho dự án, cũng như các dependency
cần thiết hoặc khởi tạo project maven với các dependency như sau:

Lưu ý: Nếu dùng Spring Initializr, các bạn có thể thêm các dependency này bằng cách
chọn “Add dependencies” ở tab “Dependencies”.
 Cấu trúc project Spring Boot

Trong một project Spring Boot thường sẽ có các layer chính:

 Domain: chứa các ánh xạ database – entity

 Repository: định nghĩa các DAO (Data access object) class dùng để làm việc với
database

 Service: chứa các business logic class

 Controller: nhận request từ client

 Mapper: dùng để convert qua lại giữa entity và dto (không có cũng được)

 Exception Hanlder: xử lý các exception xảy ra trong quá trình thực thi yêu cầu của
client
Dự án sau khi được hoàn thành sẽ có cấu trúc như thế này. Bây giờ, chúng ta sẽ bắt đầu
đi từng phần một.

 Domain layer

Đối với hầu hết các dự án, chúng ta thường bắt đầu với domain layer trước, sau khi đã
phân tích thiết kế cơ sở dữ liệu xong, chúng ta sẽ đến bước định nghĩa các entity ánh xạ
các table tương ứng dưới database.

Trong bài viết này, chúng ta dùng H2 database, các bạn có thể linh hoạt sử dụng các
database khác như SQL, MySQL, Mariadb tùy ý. Vì sử dụng JPA và JPA provider bên
dưới là Hibernate nên có thể dễ dàng chuyển đổi qua lại giữa các database mà code
không bị ảnh hưởng. Trong khuôn khổ bài viết này, định nghĩa một User entity có thể
làm như sau:

Các entity class phải được chú thích với @Entity annotation, ngoài ra các annotation
khác của lombok được mình sử dụng để giảm thiểu việc triển khai các method getter,
setter, constructor, …

 Repository Layer

Đây là layer chúng ta định nghĩa các DAO class dùng để thao tác với database. Tuy
nhiên, trong phần này, chúng ta không cần phải triển khai các method cơ bản như là
findById (), findAll, save (), delete(), update() vì chúng đã được triển khai thông qua một
tầng abstraction được đặt ở trên JPA implementation. Để sử dụng các tính năng cơ bản
này, chúng ta chỉ cần khai báo một Repository class thừa kế từ CrudRepository.

 Service Layer
Như đã đề cập trước đó, Service layer sẽ là nơi chứa các business chính của dự án, là cầu
nối giữa Controller layer và Repository layer. Với một ứng dụng CRUD thì chúng ta cần
ít nhất các method dùng cho việc thêm, sửa, xóa, cập nhật và tìm kiếm. Trước tiên, chúng
ta cần định nghĩa một UserService Interface và một UserServiceImpl class dùng để triển
khai các method định nghĩa trong UserService.

và

Các bạn thấy cách làm này có “kỳ cục” không? Tại sao chúng ta không tạo luôn
UserService class rồi triển khai code trong đó? Điều này hoàn toàn được, tuy nhiên các
bạn cần phải biết đây là một cách làm giúp tăng tính mở rộng code.

Giả sử, hiện tại chúng ta đang có UserService và UserServiceImpl hoạt động ổn. Về sau
này, chúng ta cần chỉnh sửa một số tính năng trong UserServiceImpl để tăng performance
hoặc adapt cho phù hợp với business mới. Nhưng do UserServiceImpl đã được phát triển
qua một thời gian dài, nên việc sửa code trong này rất khó khăn, lúc đó, chúng ta có thể
tạo ra một UserServiceImplNew mới cũng như implement UserService và triển khai code
tách bạch khỏi UserServiceImpl. Sau đó, chúng ta chỉ cần thay đổi việc sử dụng
UserServiceImplNew thay vì UserServiceImpl mà không cần chỉnh sửa code ở những
chỗ khác.
Những chỗ khác đang sử dụng UserServiceImpl mà không có nhu cầu chỉnh sửa thì vẫn
có thể sử dụng, do không có chỉnh sửa gì trên UserServiceImpl nên chúng ta yên tâm là
các tính năng sẽ vẫn hoạt động như cũ.

 Create

Đến với chức năng đầu tiên, chúng ta cần tạo một hàm createUser dùng để tạo và lưu một
record User xuống database.

Các bạn có thể tùy ý thêm các mã kiểm tra khác như email có hợp lệ không, email có tồn
tại trước đó hay chưa, sau đó sử dụng method save() để lưu xuống database.

Chú ý: Khi sử dụng H2 trong project Spring Boot thì mặc định nó đã cấu hình tự động
cho bạn sử dụng một database H2-mem, nghĩa là khi tắt ứng dụng thì dữ liệu sẽ bị mất.

 Update
Với hàm update(), client cần truyền cho chúng ta ID của user muốn cập nhật và một User
object chứa các thông tin được cập nhật.

 Delete

Tính năng này khá đơn giản, chúng ta sẽ nhận vào một User ID và xóa User trong
database có ID tương ứng.

 Find

Sẽ có 2 method thường được dùng là tìm kiếm theo ID hoặc lấy tất cả.
  Controller Layer

Đến layer cuối cùng dùng để nhận các request từ client, chúng ta sẽ cần đến
@RestController annotation để đánh dấu một class là một controller, và
@RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping
để chỉ định các endpoint cụ thể cho các API.
Trong đó, các bạn cần chú ý @RequestBody dùng để parse request body sang User object
tự động, và @PathVariable dùng để parse ID từ Path parameter.

2.8Giới thiệu tổng quan về Spring Data MongoDB

Thư viện spring-data-mongodb của Spring ngoài việc cung cấp cho chúng ta interface
MongoOperations giúp chúng ta có thể dễ dàng thao tác với MongoDB, nó còn cung cấp
thêm cho chúng ta cơ chế mà một project Spring Data cần làm đó là giảm thiểu các đoạn
code lặp đi lặp lại liên quan đến phần thao tác đến các hệ thống quản trị data khi phát
triển các ứng dụng có sử dụng Spring framework. Cụ thể như thế nào? Chúng ta hãy cùng
nhau tìm hiểu trong bài viết này các bạn nhé!

Đầu tiên, mình sẽ tạo một Maven project để làm ví dụ:

với Spring Data MongoDB dependency như sau

Spring Data MongoDB sẽ sử dụng đối tượng MongoTemplate để quản lý kết nối tới
MongoDB nên chúng ta cần khởi tạo bean cho đối tượng này các bạn nhé:
Vì mình sử dụng MongoDB local và không cần username, password nên như các bạn
thấy, mình chỉ khởi tạo đối tượng MongoClient đơn giản như trên.

Như mình đã nói trong bài viết Tổng quan về Spring Data JPA về Spring Data thì để
giảm thiểu code, interface Repository đã được giới thiệu. Mỗi một module trong Spring
Data sẽ có những interface khác extend từ interface này để hiện thực riêng cho hệ thống
database của module đó. Ngoài ra, trong Spring Data Common, chúng ta còn có 2
interface khác extend từ interface Repository là CrudRepository
và PagingAndSortingRepository định nghĩa các thao tác create, read, update, delete,
paging, sort.

Trong Spring Data Mongodb, như Spring Data Jpa, chúng ta cũng chỉ có duy nhất một
interface extend từ interface PagingAndSortingRepository là MongoRepository. Các bạn
có thể thấy rõ điều này qua hình ảnh sau:

Class implement interface MongoRepository là SimpleMongoRepository.

Một ví dụ để xem MongoRepository làm việc như thế nào

Tạo mới một interface tên là HelloRepository extend từ MongoRepository với nội dung
như sau:
với class Student có nội dung như sau:

Với việc sử dụng interface MongoRepository, đối tượng Student của chúng ta không cần
phải định nghĩa là một Document nữa. Spring Data MongoDB sẽ làm việc đó cho chúng
ta, đối tượng Student bây giờ chỉ đơn thuần là một POJO. Spring Data MongoDB sẽ map
class Student vào collection tên là student. Nếu muốn thay đổi tên của collection thì có
thể khai báo thêm cho class Student annotation @Document như sau:

Sử dụng tên collection mặc định từ tên của class Student.

Khai báo interface HelloRepository trong Spring container như sau:

Ở đây, mình sử dụng namespace mongo:repositories với base package là

com.huongdanjava.springdatamongodb để scan interface HelloRepository. Với khai báo
như trên, Spring Data MongoDB sẽ tự động lấy đối tượng implement tự động cho
interface HelloRepository là SimpleMongoRepository như các bạn thấy trong hình ảnh ở
trên để khởi tạo trong Spring container.

Đến đây đã hoàn thành những phần cấu hình cần thiết. Giờ chạy ví dụ.

Giả sử trong database mình đang có những dữ liệu sau đây:

thì khi chạy ví dụ sau đây:

Kết quả sẽ là: