Tải bản đầy đủ

luận văn thạc sĩ nghiên cứu và cài đặt một công cụ trên nền tảng eclipse để hỗ trợ phát triển các ứng dụng java

ĐẠI HỌC QUỐC GIA HÀ NỘI
TRƯỜNG ĐẠI HỌC CÔNG NGHỆ

VŨ THANH HÀ

NGHIÊN CỨU VÀ CÀI ĐẶT MỘT CÔNG
CỤ TRÊN NỀN TẢNG ECLIPSE ĐỂ HỖ
TRỢ PHÁT TRIỂN CÁC ỨNG DỤNG
JAVA
Ngành: Công nghệ Thông tin
Chuyên ngành: Kỹ thuật phần mềm
Mã số: 60480103

LUẬN VĂN THẠC SĨ CÔNG NGHỆ THÔNG TIN

NGƯỜI HƯỚNG DẪN KHOA HỌC: TS. ĐẶNG ĐỨC HẠNH

Hà Nội – 2018
L



LỜI CAM ĐOAN
Tôi xin cam đoan luận văn thạc sĩ “Nghiên cứu và cài đặt một công cụ trên nền
tảng Eclipse để hỗ trợ phát triển các ứng dụng Java” là công trình nghiên cứu của
riêng tôi và được sự hướng dẫn của TS. Đặng Đức Hạnh. Các nội dung nghiên cứu và
kết quả trong đề tài là trung thực và chưa từng được ai công bố trong bất kỳ công trình
nào khác.
Những phân tích, đánh giá được tác giả thu thập từ các nguồn khác nhau có ghi rõ
trong tài liệu tham khảo.

Học viên thực hiện

Vũ Thanh Hà

i


LỜI CẢM ƠN
Để hoàn thành được luận văn thạc sĩ, bên cạnh sự nỗ lực của bản thân còn có sự
hướng dẫn nhiệt tình của quý Thầy Cô, cũng như sự động viên ủng hộ của gia đình và
bạn bè trong suốt quá trình nghiên cứu và thực hiện luận văn.
Tôi xin chân thành bày tỏ lòng biết ơn sâu sắc đến Thầy TS. Đặng Đức Hạnh,
người đã tận tình hướng dẫn và tạo mọi điều kiện tốt nhất cho tôi hoàn thành luận văn
này. Xin chân thành cảm ơn các thầy cô khoa Công nghệ thông tin, Trường đại học
Công Nghệ đã truyền đạt những kiến thức quý báu cũng như giúp đỡ tôi trong quá
trình học tập nghiên cứu tại trường.
Cuối cùng, xin gửi lời cảm ơn đến gia đình, bạn bè, đồng nghiệp, những người
đã hỗ trợ tôi trong suốt quá trình học tập, nghiên cứu và thực hiện luận văn.
Học viên thực hiện

Vũ Thanh Hà

ii


MỤC LỤC
Trang
LỜI CAM ĐOAN........................................................................................................... i
LỜI CẢM ƠN............................................................................................................... ii
MỤC LỤC.................................................................................................................... iii
DANH SÁCH CÁC KÝ HIỆU VÀ CHỮ VIẾT TẮT................................................... v


DANH SÁCH CÁC HÌNH VẼ.................................................................................... vi
MỞ ĐẦU....................................................................................................................... 1
CHƯƠNG 1. KIẾN THỨC NỀN TẢNG...................................................................... 3
1.1. Giới thiệu chương................................................................................................ 3
1.2. Thiết kế hướng miền............................................................................................ 3
1.2.1. Kiến thức về miền vấn đề.............................................................................. 3
1.2.2. Ngôn ngữ chung............................................................................................ 4
1.2.3. Rằng buộc mô hình và cài đặt....................................................................... 5
1.2.4. Cô lập miền................................................................................................... 7
1.2.5. Mô hình được thể hiện trong phần mềm....................................................... 9
1.2.6. Vòng đời của đối tượng miền...................................................................... 12
1.3. Phương pháp phát triển phần mềm hướng miền DDSDM................................. 13
1.3.1. Phát triển một mô hình miền khái niệm...................................................... 14
1.3.2. Định nghĩa các vòng lặp phát triển.............................................................. 15
1.3.3. Thực hiện các vòng lặp phát triển............................................................... 15
1.3.4. Tích hợp các nguyên mẫu phần mềm.......................................................... 15
1.4. Công cụ hỗ trợ phát triển phần mềm hướng miền............................................. 16
1.4.1. Lịch sử phát triển........................................................................................ 16
1.4.2. Tổng quan kiến trúc.................................................................................... 16
1.4.3. Ví dụ điển hình: CourseMan....................................................................... 17
1.4.4. Phát triển các lớp miền................................................................................ 18
1.4.5. Xây dựng nguyên mẫu phần mềm từ các lớp miền..................................... 24
iii


1.5. Thành phần mở rộng Eclipse Plug-in................................................................ 25
1.5.1. Kiến trúc mở của Eclipse............................................................................ 25
1.5.2. Môi trường phát triển Plug-in..................................................................... 27
1.6. Tổng kết chương............................................................................................... 30
CHƯƠNG 2. XÂY DỰNG ELCIPSE PLUGIN CHO................................................ 31
2.1. Giới thiệu chương............................................................................................. 31
2.2. Mô tả yêu cầu cho Plug-in................................................................................. 31
2.3. Mô hình thiết kế Eclipse Plugin cho phần mềm hướng miền............................34
2.3.1. Mô hình thiết kế UML cho Eclipse Plugin.................................................. 34
2.3.2. Thuật toán sinh phương thức và Thuật toán sinh module phần mềm..........36
2.3.3 Thuật toán sinh cấu hình phần mềm SWC................................................... 40
2.4. Cài đặt chi tiết thiết kế plug-in.......................................................................... 42
2.5. Tổng kết chương............................................................................................... 48
CHƯƠNG 3. CÀI ĐẶT VÀ THỰC NGHIỆM............................................................ 49
3.1. Giới thiệu chương............................................................................................. 49
3.2. Môi trường cài đặt............................................................................................. 49
3.3. Bài toán quản lý khóa học................................................................................. 49
3.4. Kết quả thực nghiệm......................................................................................... 52
3.5. Tổng kết chương............................................................................................... 64
KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN................................................................... 65
TÀI LIỆU THAM KHẢO........................................................................................... 66

iv


DANH SÁCH CÁC KÝ HIỆU VÀ CHỮ VIẾT TẮT
Từ viết tắt

Thuật ngữ

Ý nghĩa

API

Application Programming Interface

Giao diện lập trình ứng dụng

DDD

Domain-Driven Design

Thiết kế hướng miền

DDSDM

Domain-driven software development
method

Phương pháp phát triển
mềm hướng miền

IDE

Integrated Development Environment

Môi trường phát triển tích hợp

JDT

Java Development Tools

Các công cụ phát triển Java

JRE

Java Runtime Environment

Môi trường chạy Java

MCC

Module Configuration Class

Lớp cấu hình mô đun phần mềm

MVC

Model View Controller

Mô hình thiết kế phần mềm

OSGi

Open Service Gateway Initiative

Nền tảng Java cho việc
triển và triển khai plug-in

PDE

Plug-in Development Environment

Môi trường phát triển plug-in

RCP

Rich Client Platform

Nền tảng lập trình các ứng dụng
Desktop

SWC

Software Configuartion

Cấu hình phần mềm

SWT

The Standard Widget Toolkit

Bộ công cụ đồ họa chuẩn

User interface

Giao diện người dùng

eXtensible Markup Language

Ngôn ngữ đánh dấu mở rộng

UI
XML

v

phần

phát


DANH SÁCH CÁC HÌNH VẼ
Hình 1.1: Các thành phần của thiết kế hướng miền
Hình 1.2: Kiến trúc phân lớp
Hình 1.3: Vòng đời của đối tượng miền
Hình 1.4: Tổng quan về phương pháp phát triển phần mềm hướng miền
Hình 1.5: Thiết kế cơ bản các lớp miền của phần mềm CourseMan
Hình 1.6: Áp dụng meta-attribute DAssoc cho ba liên kết của CourseMan
Hình 1.7: Kiến trúc mở của Eclipse
Hình 1.8: Hoạt động của plug-in
Hình 2.1: Các thử thách cho DSL dựa trên annotation
Hình 2.2: Biểu đồ tuần tự cho plug-in
Hình 2.3: Biểu đồ lớp cho plug-in
Hình 2.4: Biểu đồ triển khai cho plug-in
Hình 2.5: Mô hình kiến trúc phần mềm COURSEMAN
Hình 2.6: Các bước xây dựng Plug-in
Hình 2.7: Màn hình nhập thông tin ban đầu Plug-in mới
Hình 2.8: Màn hình chọn Template cho Plug-in mới
Hình 2.9: Màn hình dự án Plug-in mới đã tạo
Hình 2.10: Màn hình Extensions
Hình 2.11: Màn hình tạo các command
Hình 2.12: Màn hình khai báo các handlers
Hình 2.13: Màn hình khai báo các bindings
Hình 2.14: Màn hình khai báo vị trí của các item mới trên menu
Hình 3.1: Mô hình ca sử dụng của CourseMan
Hình 3.2: Mô hình miền khái niệm và các mô hình con của CourseMan
Hình 3.3: Đầu vào của thực nghiệm
Hình 3.4: Giao diện menu sinh phương thức cho lớp miền
Hình 3.5: Giao diện menu sinh cấu hình mô-đun phần mềm
Hình 3.6: Cấu hình mô-đun phần mềm được sinh ra
Hình 3.7: Giao diện menu sinh cấu hình mô-đun phần mềm
Hình 3.8: Cấu hình phần mềm SWC1 được sinh ra
Hình 3.9: Cấu hình phần mềm SWC1 được sinh ra
Hình 3.10: Cấu hình Run Configurations để chạy mã nguồn
Hình 3.11: Giao diện phần mềm CourseMan
Hình 3.12: Giao diện các form của CourseMan trong vòng lặp đầu tiên
Hình 3.13: Giao diện các form của CourseMan sau khi sửa cấu hình mô-đun
vi


MỞ ĐẦU
Một ứng ứng dụng có thể được phát triển với kiến trúc tuyệt với, sử dụng công
nghệ mới nhất và có giao diện tốt nhất nhưng nếu nó không giải quyết được yêu cầu
nghiệp vụ được đề ra thì ứng dụng đó không thể được xem là hữu ích. Do đó, thiết kế
hướng miền DDD được đưa ra [2]. Thiết kế hướng miền DDD nhằm phát triển phần
mềm một cách lặp đi lặp lại xung quanh một mô hình miền thực tế. Cả phần mềm và
mô hình miền đều nắm bắt triệt để các yêu cầu miền và khả thi để cài đặt xét về mặt kỹ
thuật [6]. Ý tưởng chính của DDD là mô hình hóa miền cho phát triển phần mềm. Về
lý thuyết, đội phát triển chỉ cần tập trung chủ yếu vào xây dựng mô hình miền, và tuân
thủ các nguyên tắc DDD khi cài đặt. Khi bộ xương của hệ thống rắn chắc, mọi thứ trở
nên dễ dàng hơn và việc triển khai các tính năng mới tương tự như việc lắp ghép các
viên gạch xếp hình.
Trên thực tế, việc xây dựng một phần mềm hướng miền không hề đơn giản, quá
nhiều công việc cần phải thực hiện: từ phân tích miền, xây dựng mô hình miền, cài đặt
dưới dạng mã nguồn sử dụng ngôn ngữ lập trình nhất định, đảm bảo các nguyên tắc
của DDD là gắn chặt cài đặt với mô hình, cô lập lớp miền và chứa các thành phần cơ
bản cấu thành nên DDD [2]. Để tăng hiệu suất tạo ra phần mềm, một công cụ Java hỗ
trợ phát triển phần mềm hướng miền tên là DomainAppTool, đã được nhóm tác giả [5]
đề xuất. Công cụ này sử dụng các nghiên cứu gần đây trong DDD là tập trung vào mở
rộng các ngôn ngữ lập trình hướng đối tượng dựa trên annotation để xây dựng mô hình
miền. Mô hình này không chỉ là cơ sở cho ngôn ngữ chung giữa các thành viên nhóm
phát triển mà còn được sử dụng như đầu vào để sinh ra phần mềm [6].
DomainAppTool tự động tạo ra phần mềm từ một tập các lớp miền được thiết kế
với các tính năng thiết kế hướng miền. Lợi ích chính của công cụ là cho phép các nhà
phát triển chỉ tập chung vào thiết kế mô hình miền để đưa ra một tập các lớp miền của
phần mềm, toàn bộ phần mềm bao gồm giao diện đồ họa người dùng và đối tượng lưu
trữ sẽ được tạo ra tự động vào thời gian chạy. Tuy nhiên, một trong những hạn chế của
công cụ là chưa có giao diện người dùng, người sử dụng phải thực hiện thủ công một
loạt các lệnh command line để tạo ra phần mềm. Phát triển phần mềm là một quá trình
lặp đi lặp lại để sinh ra phần mềm cuối cùng. Trong mỗi vòng lặp phát triển, nếu sử
dụng công cụ thì người dùng lại phải thực hiện các lệnh đó, gây ra không ít khó khăn
và tốn nhiều thời gian. Vì vậy, tôi xin chọn đề tài “Nghiên cứu và cài đặt một công
cụ trên nền tảng Eclipse để hỗ trợ phát triển các ứng dụng Java” . Mục tiêu của
luận văn là tạo ra một gói mở rộng plug-in cài trên công cụ hỗ trợ lập trình Eclipse cho
DomainAppTool. Từ đó, các chức năng của nó sẽ được trực quan hóa, người dùng có
thể sử dụng bất kỳ khi nào trong quá trình phát triển phần mềm. Điều này có ý nghĩa
quan trọng giúp cho công cụ hỗ trợ phát triển phần mềm hướng miền được sử dụng
rộng rãi hơn.
1


Trong luận văn, tôi tập trung vào trình bày chi tiết hai đóng góp của mình là xây
dựng thuật toán tạo ra cấu hình phần mềm và xây dựng gói Eclipse plug-in; cuối cùng
là các bước thực hiện thực nghiệm và kết quả đạt được. Về phần bố cục, luận văn được
chia thành ba chương chính như sau:
Chương 1. Kiến thức nền tảng : Trình bày cơ sở lý thuyết và các công nghệ
chính được sử dụng trong luận văn. Bao gồm: Thiết kế hướng miền, phương pháp phát
triển phần mềm hướng miền, công cụ hỗ trợ phát triển phần mềm hướng miền và thành
phần mở rộng Eclipse Plug-in.
Chương 2. Xây dựng Eclipse Plug-in cho phần mềm hướng miền : Trình bày
mô hình thiết kế Plugin và cài đặt chi tiết của thiết kế. Các thuật toán tự động sinh
phương thức cho lớp miền và cấu hình mô-đun phần mềm cũng được giới thiệu nhưng
trọng tâm tập trung vào trình bày chi tiết thuật toán sinh cấu hình phần mềm.
Chương 3. Cài đặt và thực nghiệm : Trình bày các yêu cầu về môi trường cài
đặt thực nghiệm, bài toán thực nghiệm và cuối cùng là các kết quả đạt được.

2


CHƯƠNG 1. KIẾN THỨC NỀN TẢNG
1.1. Giới thiệu chương
Chương này sẽ trình bày cơ sở lý thuyết và các công nghệ chính được sử dụng
trong luận văn. Bao gồm ba nội dung chính:
 Thiết kế hướng miền DDD: khái niệm, ngôn ngữ chung, thiết kế hướng mô hình
và kiến trúc ứng dụng sử dụng DDD
 Phương pháp phát triển phần mềm hướng miền DDSDM: khái niệm, các pha
trong phát triển các nguyên mẫu phần mềm từ mô hình miền.
 Công cụ hỗ trợ phát triển phần mềm hướng miền: lịch sử phát triển, tổng quan
kiến trúc, phát triển các lớp miền và các bước xây dựng nguyên mẫu phần mềm
từ các lớp miền.
 Thành phần mở rộng Eclipse Plug-in: Kiến trúc mở của Eclipse và môi trường
phát triển Plug-in.

1.2. Thiết kế hướng miền
Thiết kế hướng miền là một cách tiếp cận để phát triển phần mềm có các yêu cầu
phức tạp về việc liên kết cài đặt với một mô hình phát triển. Tiền đề của thiết kế hướng
miền [2] là:
 Đặt trọng tâm chính của dự án tập trung vào miền lõi và logic miền.
 Các thiết kế phức tạp được xây dựng dựa trên một mô hình miền.
 Sự cộng tác giữa chuyên gia miền và chuyên gia phát triển để trau dồi lặp đi
lặp lại một mô hình miền khái niệm giải quyết các vấn đề miền cụ thể.
Thiết kế hướng miền phát triển từ tiền đề coi trái tim của phát triển phần mềm là
kiến thức về vấn đề cần giải quyết và tìm các cách hữu ích nhất để hiểu vấn đề đó. Sự
phức tạp cần giải quyết chính là sự phức tạp của miền chứ không phải là kiến thức kỹ
thuật, không phải là giao diện người dùng hay thậm chí không phải chức năng cụ thể.
Điều này có nghĩa là thiết kế mọi thứ xung quanh hiểu biết và quan niệm về hầu hết
các khái niệm cần thiết của nghiệp vụ, chứng minh cho bất kỳ sự phát triển nào khác
bằng cách nó hỗ trợ miền lõi đó như thế nào.

1.2.1. Kiến thức về miền vấn đề
Phát triển phần mềm là quy trình xây dựng ra phần mềm để giải quyết các bài
toán nghiệp vụ thực tế hay miền vấn đề. Phần mềm bắt nguồn và liên quan chặt chẽ
với miền này. Mặt khác, phần mềm được làm từ mã nguồn. Nhà phát triển thường sa
đà vào việc dành nhiều thời gian tạo ra mã nguồn và nhìn phần mềm như các đối tượng
và phương thức đơn giản [2].
Xem xét ví dụ sản xuất ô tô [1]. Công nhân liên quan trực tiếp đến việc lắp ráp
linh kiện ô-tô có góc nhìn hạn chế về quy trình sản xuất một chiếc ô tô. Họ coi ô tô là
một tập khổng lồ những linh kiện và cần lắp ráp chúng với nhau; thực ra quy trình tạo
3


ra một chiếc ô tô phức tạp hơn thế nhiều. Một chiếc xe tốt bắt nguồn từ một tầm nhìn
và nó được đặc tả một cách chi tiết, tiếp theo là thiết kế (rất, rất nhiều thiết kế). Sau
nhiều tháng, thậm chí có thể vài năm; thiết kế đó lại được thay đổi, cải tiến cho tới khi
thiết kế trở nên hoàn hảo nhất. Quá trình thiết kế có thể không làm luôn trên giấy,
nhiều phần thiết kế bao gồm việc mô hình hóa và kiểm thử dưới điều kiện cụ thể để
xem xe hoạt động hay không. Sau đó, thiết kế được thay đổi theo kết quả kiểm thử.
Cuối cùng, chiếc xe được đưa vào sản xuất bao gồm sản xuất linh kiện và lắp ráp
chúng vào nhau. Việc phát triển phần mềm cũng tương tự như vậy, không thể tạo ra
phần mềm phức tạp mà chỉ ngồi viết mã nguồn. Để tạo ra phần mềm tốt, nhà phát triển
cần hiểu về miền vấn đề mà phần mềm cần giải quyết thông qua việc trao đổi với
chuyên gia miền. Những kiến thức thô về nghiệp vụ không dễ dàng chuyển hóa thành
cấu trúc phần mềm trừ khi miền được “trừu tượng hóa”. “Trừu tượng hóa” miền vấn
đề là việc xây dựng một mô hình miền. Theo Eric Evans, một mô hình miền không
phải là một giản đồ cụ thể, quan trọng là ý tưởng mà giản đồ đó muốn truyền đạt; quan
trọng không phải là kiến thức trong đầu của chuyên gia miền mà là sự trừu tượng hóa
miền kết hợp chặt chẽ với kiến thức đó và cả nhóm phát triển có thể hiểu được [1].
Mô hình là một sự thể hiện của miền cần xem xét và rất cần thiết trong suốt quá
trình phát triển phần mềm. Mô hình hóa miền đòi hỏi kiến thức xử lý theo cách tương
tự các nhà phân tích tài chính xử lý những con số để hiểu hiệu suất hàng quý của một
công ty. Khi làm việc với chuyên gia miền, người mô hình hóa miền sẽ thử đưa ra một
số ý tưởng tổ chức tập các khái niệm, sau đó, tạo các mô hình, dùng thử chúng, một số
mô hình bị loại bỏ trong khi một số khác bị biến đổi.
Phát triển là lặp đi lặp lại, phân tích kiến thức về miền vấn đề là liên tục trong
suốt vòng đời của dự án. Các nỗ lực mô hình hóa được tạo ra trong các vòng lặp đầu
tiên thường hời hợt. Sự trừu tượng hóa xuất hiện theo thời gian và phải được tái cấu
trúc và sử dụng vào trong mô hình. Để đạt được điều này cần duy trì một mối quan hệ
chặt chẽ, liên tục với các chuyên gia miền.

1.2.2. Ngôn ngữ chung
Yêu cầu đầu tiên của cách tiếp cận DDD là ngôn ngữ chung cho phép chuyên gia
miền và chuyên gia phần mềm có thể hiểu nhau và cộng tác với nhau [2]. Thông
thường, lập trình viên chỉ nghĩ tới lớp, phương thức, thuật toán và khuynh hướng diễn
đạt mọi vấn đề dưới dạng mã nguồn. Khi nhìn vào các đối tượng nào đó và quan hệ mô
hình giữa chúng, lập trình viên nghĩ đến kế thừa, đa hình, lập trình hướng đối tượng,…
Tuy nhiên, chuyên gia miền thường không hiểu những khái niệm đó. Để vượt qua rào
cản giao tiếp này, DDD khuyến khích xây dựng mô hình, trao đổi ý tưởng về mô hình,
về những thành phần liên quan đến mô hình. Giao tiếp tốt ở mức này rất quan trọng
cho sự thành công của dự án. Khi trao đổi về mô hình, có nhiều khái niệm chuyên
ngành rất dễ bị hiểu sai với người ngoài ngành. Vì vậy, cần có một từ điển thuật ngữ
dự án giải thích chi tiết các khái niệm đó, đảm bảo tất cả các bên liên quan
4


đến dự án đều hiểu đúng về mô hình.
Nguyên tắc cốt lõi của thiết kế hướng miền là sử dụng ngôn ngữ dựa trên mô
hình. Vì mô hình là xuất phát điểm chung, là đầu vào cho phần mềm giải quyết miền
vấn đề. Ngôn ngữ chung kết nối mọi phần của thiết kế cũng như hoạt động của nhóm
phát triển.

1.2.3. Rằng buộc mô hình và cài đặt
Đối tượng điển hình trong mô hình có các liên kết phức tạp với các đối tượng
khác và mạng lưới liên kết này có một vài đường biên tự nhiên. Khi nhà phát triển bắt
đầu cài đặt ứng dụng, họ nhanh chóng phát hiện ra rằng mớ hỗn độn các liên kết không
chuyển thành các đơn vị có thể lưu trữ, có thể phục hồi và đảm bảo tính toàn vẹn dữ
liệu [2]. Nếu dự án sử dụng cơ sở dữ liệu đối tượng thì nhà phát triển thậm chí phải đối
mặt với những thách thức của việc ánh xạ các đối tượng vào các bảng quan hệ. Ở mức
độ cơ bản, mô hình không cung cấp hướng dẫn để cài đặt.
Mô hình là “chính xác” nếu là kết quả của sự cộng tác chặt chẽ giữa chuyên gia
nghiệp vụ và nhà phân tích kỹ thuật. Tuy nhiên, các nhà phát triển đã đi đến kết luận
rằng các đối tượng dựa trên khái niệm không thể là nền tảng thiết của họ [2]. Vì vậy,
họ tiến hành phát triển thiết kế sử dụng một vài tên lớp và thuộc tính giống nhau cho
việc lưu trữ dữ liệu, nhưng nó không dựa trên bất kì mô hình đang tồn tại.
Dự án có một mô hình miền nhưng mô hình chỉ tốt trên giấy trừ khi nó trực tiếp
trợ giúp sự phát triển phần mềm. Mô hình đến từ nhiều nguồn và phục vụ nhiều vai
trò, thậm chí những vai trò được giới hạn trong từng hoàn cảnh của một dự án phát
triển phần mềm. Thiết kế hướng miền đề xuất một mô hình không chỉ hỗ trợ phân tích
sớm mà còn là nền tảng của thiết kế. Việc liên kết chặt chẽ mã nguồn với một mô hình
bên dưới mang lại ý nghĩa lớn cho mã nguồn, đồng thời làm cho mô hình trở nên thích
hợp. Nhiều dự án phức tạp áp dụng một số mô hình miền nhưng không duy trì kết nối
chặt chẽ giữa mô hình và mã nguồn. Mô hình được phát triển có thể hữu ích như một
công cụ thăm dò ban đầu nhưng nó ngày càng trở nên không liên quan đến mã nguồn
và thậm chí gây hiểu lầm khi mã nguồn không gắn chặt với mô hình.
Thiết kế hướng mô hình
Nhiều phương pháp thiết kế ủng họ mô hình phân tích khá khác biệt so với thiết
kế và thường được phát triển bởi những người khác nhau. Nó được gọi là một mô hình
phân tích bởi vì nó là sản phẩm phân tích miền nghiệp vụ nhằm sắp xếp các khái niệm
mà không quan tâm đến các phần khác trong hệ thống phần mềm. Một mô hình phân
tích có ý nghĩa như là một công cụ để chỉ để hiểu miền vấn đề; việc kết hợp với cài đặt
sẽ làm sao nhãng việc tập trung vào phân tích vấn đề. Do đo, thiết kế được tạo ra có
thể chưa tương ứng với mô hình phân tích.
Một số kiến thức được xem xét, phân tích trong mô hình phân tích nhưng hầu hết
nó lại bị quên khi lập trình, khi nhà phát triển buộc phải đưa ra các trừu tượng hóa cho
5


thiết kế. Sau đó, không có gì đảm bảo rằng các thông tin chi tiết thu được từ chuyên
gia phân tích được nhúng vào mô hình, sẽ được lưu lại và tái sử dụng. Tại thời điểm
này, việc duy trì bất kì sự ánh xạ nào giữa thiết kế và mô hình là không hiệu quả chi
phí. Thậm chí, mô hình phân tích thuần túy còn thiếu mục tiêu chính của nó là hiểu
miền vấn đề do những khám phá quan trọng luôn xuất hiện trong quá trình thiết kế/cài
đặt. Kết quả là mô hình phân tích không được sử dụng ngay sau khi việc viết mã
nguồn bắt đầu và kiến thức nền tảng phải được xem xét lại [2].
Nếu thiết kế hoặc một số phần trung tâm của nó không ánh xạ lên mô hình miền
thì mô hình đó không mang lại giá trị lớn và tính chính xác của phần mềm vẫn còn bị
nghi ngờ. Đồng thời, các ánh xạ phức tạp giữa các mô hình và các chức năng thiết kế
rất khó hiểu và trên thực tế không thể duy trì khi thay đổi thiết kế.
Quá trình phân tích phải nắm bắt được các khái niệm cơ bản từ miền vấn đề theo
một cách dễ hiểu. Thiết kế phải xác định một tập các thành phần có thể được xây dựng
cùng với các công cụ lập trình được sử dụng trong dự án, các công cụ này sẽ thực hiện
trong môi trường triển khai đích một cách hiệu quả và giải quyết chính xác các vấn đề
đặt ra cho ứng dụng.
Thiết kế hướng mô hình loại bỏ sự phân tách giữa mô hình phân tích và mô hình
thiết kế để tìm ra một mô hình duy nhất phục vụ cả hai mục đích. Đặt vấn đề kỹ thuật
sang một bên, mỗi đối tượng trong thiết kế đóng vai trò một khái niệm được mô tả
trong mô hình.
Có nhiều cách trừu tượng hóa một miền và cũng có nhiều cách thiết kế có thể giải
quyết vấn đề của ứng dụng. Đây chính là thứ làm cho việc liên kết chặt chẽ mô hình và
thiết kế trở nên thực tế. Liên kết này không khiến cho mô hình phân tích bị suy yếu,
tổn hại bởi việc xem xét các yếu tố kỹ thuật; hay phải chấp nhận các thiết kế phản ánh
ý tưởng miền vụng về nhưng không sử dụng các nguyên tắc thiết kế phần mềm. Khi
một mô hình dường như không phù hợp với thực tế cài đặt hoặc không thể hiện một
cách trung thực các khái niệm thì mô hình đó nên được thay thế. Do đó, quy trình mô
hình hóa và thiết kế trở thành một vòng lặp tiếp tục. Yêu cầu liên kết chặt chẽ giữa mô
hình miền và thiết kế cung cấp thêm một tiêu chí cho việc lựa chọn các mô hình hữu
ích trong vô số mô hình có thể có.
Từ mô hình, thuật ngữ được sử dụng trong thiết kế và phân công công việc. Mã
nguồn trở thành sự thể hiện của mô hình, vì vậy, một sự thay đổi mã nguồn có thể là
một thay đổi mô hình. Ảnh hưởng của nó chắc chắn sẽ lan ra hoạt động còn lại của dự
án. Việc gắn cài đặt với mô hình thường yêu cầu các công cụ và ngôn ngữ phát triển
phần mềm hỗ trợ mô hình hóa như lập trình hướng đối tượng.
Thiết kế hướng mô hình là trái tim của thiết kế hướng miền [2]. Hình 1.1. mô tả
các thành phần cơ bản cấu thành nên thiết kế hướng mô hình.

6


Hình 1.1: Các thành phần cơ bản của thiết kế hướng mô hình [2]
Trong các phần tiếp, các thành phần cơ bản này sẽ được trình bày một cách chi tiết.

1.2.4. Cô lập miền
Trong phần mềm, việc giải quyết các vấn đề cụ thể từ miền thường chỉ chiếm
một phần nhỏ trong toàn bộ phần mềm mặc dù nó rất quan trọng. Các thành phần của
mô hình cần được xem xét như một hệ thống và các đối tượng miền cần được tách biệt
khỏi các chức năng khác của hệ thống để tránh gây nhầm lẫn khái niệm miền với khái
niệm khác chỉ liên quan đến công nghệ phần mềm. Các kỹ thuật phức tạp cho sự cô lập
này đã xuất hiện. Đây là nền tảng vững chắc, quan trọng đối với việc áp dụng thành
công các nguyên tắc mô hình hóa miền từ quan điểm hướng miền [2].
Có rất nhiều cách phân chia một hệ thống phần mềm, nhưng trong ngành công
nghiệp phần mềm, kiến trúc phân tầng (layer) được sử dụng rộng rãi. Nguyên tắc cơ là
bất kỳ thành phần nào của một layer chỉ phụ thuộc vào các thành phần khác trong cùng
layer hoặc layer bên dưới. Mặc dù có nhiều biến thể nhưng hầu hết các kiến trúc thành
công đều sử dụng một số phiên bản của bốn layer khái niệm sau:

7


Hình 1.2: Kiến trúc phân lớp
[2] Tầng giao diện người dùng
Chịu trách nhiệm cho việc hiển thị thông tin cho người dùng và diễn giải các lệnh
của người dùng. Tác nhân bên ngoài đôi khi có thể là một hệ thống khác chứ không
phải con người.
Tầng ứng dụng
Định nghĩa các công việc mà phần mềm sẽ thực hiện và điều khiển các đối tượng
miền giải quyết các vấn đề. Các nhiệm vụ của layer này là phối hợp các xử lý cho
tương tác với các layer ứng dụng của các hệ thống khác.
Tầng nghiệp vụ
Chịu trách nhiệm cho việc biểu diễn các khái niệm, thông tin về nghiệp vụ trong
hệ thống. Logic nghiệp vụ được điều khiển và sử dụng ở đây, mặc dù các chi tiết kỹ
thuật lưu trữ nó được giao cho cơ sở hạ tầng.
Tầng cơ sở hạ tầng
Cung cấp khả năng kỹ thuật chung hỗ trợ các layer cao hơn như: gửi các bản tin
cho ứng dụng, sự tồn tại lâu bền cho miền, vẽ các widget cho UI, … Layer này cũng
có thể hỗ trợ mô hình tương tác giữa bốn layer thông qua một nền tảng kiến trúc. Khi
cơ sở hạ tầng được cung cấp dưới dạng các dịch vụ được gọi thông qua các giao diện
thì nó khá trực quan (layer làm việc như thế nào và làm sao để duy trì liên kết lỏng lẻo
giữa các layer). Nhưng một số vấn đề kỹ thuật đòi hỏi nhiều dạng cơ sở hạ tầng hơn
nên các nền tảng tích hợp nhiều cơ sở hạ tầng thường được yêu cầu cho các layer khác.
Khi áp dụng một nền tảng, các mục tiêu phải cần được tập trung là xây dựng một cài
đặt thể hiện cho một mô hình miền và sử dụng nó để giải quyết các vấn đề.
Kiến trúc phân tầng được sử dụng trong hầu hết các hệ thống hiện nay theo các
sơ đồ phân tầng khác nhau. Tuy nhiên, thiết kế hướng miền chỉ yêu cầu một tầng cụ
thể phải tồn tại đó là tầng nghiệp vụ.
8


Mô hình miền là một tập hợp các khái niệm. Tầng nghiệp vụ là sự thể hiện của
mô hình đó và tất cả các thành phần thiết kế trực tiếp liên quan đến. Thiết kế và cài đặt
logic nghiệp vụ tạo thành tầng nghiệp vụ. Trong thiết kế hướng mô hình, các cấu trúc
phần mềm của tầng nghiệp vụ phản ánh các khái niệm mô hình. Nói cách khác, mô
hình được tồn tại trong tầng nghiệp vụ.
Để thu được mô hình miền trong khi logic miền được trộn lẫn với các mối quan
tâm khác của chương trình là không thực tế. Việc cô lập cài đặt miền là một điều kiện
tiên quyết cho thiết kế hướng miền.

1.2.5. Mô hình được thể hiện trong phần mềm
Để hài hòa với cài đặt mà không làm mất điểm mạnh của một thiết kế hướng mô
hình yêu cầu phải tập hợp lại các nền tảng cơ bản. Kết nối mô hình và cài đặt phải
được thực hiện trong nhiều mức chi tiết. Đầu tiên là những vấn đề liên quan đến thiết
kế và tinh giảm các liên kết. Liên kết giữa các đối tượng rất đơn giản để tưởng tượng
và vẽ ra, nhưng cài đặt chúng là một vũng lầy tiềm ẩn. Các liên kết minh họa các quyết
định triển khai chi tiết, quan trọng đối với khả năng tồn tại của thiết kế hướng mô hình.
Tự mình chuyển sang đối tượng, nhưng tiếp tục xem xét mối quan hệ giữa các
lựa chọn mô hình chi tiết và các mối quan tâm đến cài đặt, ba mẫu của các thành phần
mô hình được sử dụng để thể hiện mô hình: thực thể, đối tượng của giá trị và các dịch
vụ [2]. Xác định các đối tượng nắm bắt các khái niệm miền dường như là rất trực quan
bên ngoài, nhưng ẩn dấu nhiều thử thách nghiêm trọng bên trong sắc thái ý nghĩa. Một
số khác biệt đã xuất hiện, làm rõ nghĩa của các thành phần mô hình và gắn vào khung
của thiết kế để tạo ra các loại đối tượng cụ thể. Một đối tượng có đại diện cho một thứ
gì đó có tính liên tục, có định danh và theo dõi được thông qua các trạng thái khác
nhau hoặc thậm chí các cài đặt khác nhau; hay nó là một thuộc tính mô tả trạng thái
của thứ gì khác. Đây là sự khác biệt cơ bản giữa thực thể và đối tượng của giá trị. Việc
xác định rõ ràng các đối tượng theo một pattern làm cho đối tượng ít mơ hồ hơn và đưa
ra phương hướng cho việc lựa chọn một thiết kế tốt nhất. Sau đó, các khía cạnh của
miền được thể hiện rõ ràng hơn dưới dạng hành động hoặc hoạt động chứ không chỉ là
đối tượng. Mặc dù là một xuất phát nhỏ từ mô hình hướng đối tượng truyền thống,
nhưng tốt nhất, thể hiện chúng dưới dạng các dịch vụ thay vì buộc phải gán trách
nhiệm cho một hoạt động trên thực thể hay đối tượng của giá trị. Một dịch vụ là thứ gì
đó được thực hiện do client theo yêu cầu.
Cuối cùng, mô-đun được sử dụng để dẫn đến quan điểm rằng mọi quyết định
thiết kế nên được thúc đẩy bởi một số hiểu biết sâu sắc về miền. Ý tưởng về sự gắn kết
chặt chẽ và gắn kết lỏng lẻo thường được coi là các tiêu chí kỹ thuật có thể được áp
dụng cho chính các khái niệm đó. Trong thiết kế hướng mô hình, mô-đun là một phần
của mô hình và chúng nên phản ánh các khái niệm trong mô hình.
Các liên kết
Sự tương tác giữa mô hình hóa và các cài đặt đặc biệt phức tạp do những liên kết
9


giữa các đối tượng. Một mô hình cho thấy liên kết giữa một khách hàng và đại diện
bán hàng tương ứng với hai thứ. Một là nó trừu tượng quan hệ giữa hai người thực, hai
là nó tương ứng với một con trỏ giữa hai đối tượng Java; hoặc một sự đóng gói của tra
cứu cơ sở dữ liệu. Ví dụ, một liên kết one-to-many có thể được cài đặt như một tập hợp
các instance của đối tượng. Nhưng thiết kế không cần thiết quá rõ ràng. Có thể không
có tập hợp nào; một phương thức truy nhập truy vấn cơ sở dữ liệu để tìm các bản ghi
phù hợp và khởi tạo các đối tượng dựa trên chúng. Tất cả thiết kế cùng phản ánh cùng
mô hình. Thiết kế phải xác định một cơ chế truyền tải cụ thể mà hành vi của nó nhất
quán với liên kết trong mô hình.
Các thực thể
Thực thể được biết đến là đối tượng tham chiếu. Nhiều đối tượng không được
xác định một cách cơ bản bởi các thuộc tính của chúng mà bởi một chuỗi liên tục và
định danh. Ví dụ, một người có định danh kéo dài từ khi sinh ra đến khi chết đi và
thậm chí sau đó. Các thuộc tính vật lý của người đó biến đổi và cuối cùng biến mất,
thuộc tính của người có thể thay đổi nhưng danh tính luôn tồn tại. Mô hình hóa đối
tượng có xu hướng tập trung các thuộc tính của một đối tượng nhưng khái niệm cơ bản
của một thực thể là một chuỗi liên tục trừu tượng hóa qua một vòng đời và thậm chí đi
qua nhiều trạng thái. Đối tượng đại diện cho một chuỗi định danh qua thời gian. Đôi
khi, một đối tượng phải được khớp với một đối tượng khác mặc dù thuộc tính của
chúng khác nhau. Một đối tượng phải được phân biệt với đối tượng khác dù chúng có
thể có cùng thuộc tính. Nhần lẫn định danh có thể dẫn tới những sai hỏng dữ liệu.
Các đối tượng của giá trị
Do các đối tượng dễ thấy nhất trong mô hình thường là thực thể và việc theo dõi
mỗi định danh của thực thể là rất quan trọng, nên xem xét việc gán 1 thực thể cho tất
cả đối tượng miền. Một số nền tảng gán một định danh duy nhất cho tất cả đối tượng.
Hệ thống phải thực hiện tất cả công việc theo dõi; và nhiều tối ưu hiệu năng được
loại bỏ. Cần nỗ lực phân tích để xác định các định danh có ý nghĩa và tìm ra cách đơn
giản để theo dõi đối tượng trên các hệ thống phân tán hoặc trong lưu trữ cơ sở dữ liệu.
Quan trọng không kém là những định danh giả làm rối loạn mô hình, gây ra những
nhầm lẫn.
Theo dõi định danh của thực thể là cần thiết, nhưng gắn định danh cho các đối
tượng khác có thể làm giảm hiệu năng hệ thống, thêm công việc phân tích và làm rối
loạn mô hình do tất cả các đối tượng trông giống nhau. Thiết kế phần mềm là một trận
chiến liên tục với sự phức tạp. Cần phải tạo ra sự khác biệt để áp dụng xử lý đặc biệt
khi cần thiết. Trong thực tế, các đối tượng này có đặc điểm riêng và ý nghĩa riêng đối
với mô hình.
Một đối tượng đại diện cho một khía cạnh của miền, không có định danh về mặt khái
niệm được gọi là đối tượng của giá trị. Đối tượng của giá trị được khởi tạo để đại diện
cho các thành phần của thiết kế mà chỉ quan tâm chúng là cái gì và không quan 10


tâm chúng là ai. Ví dụ, trong phần mềm đặt hàng qua mạng, địa chỉ thư điện tử cần
được cung cấp để xác nhận thẻ tín dụng và thực hiện ship hàng. Dù là chủ tài khoản
hay không, chỉ cần biết được thông tin về địa chỉ thư điện tử thì đều đặt được hàng.
Các đối tượng của giá trị thậm chí có thể là các thực thể tham chiếu. Ví dụ, trong
phần mềm cho dịch vụ bưu chính, nhằm tổ chức các tuyến giao hàng, cây quốc gia có
thể được tạo theo phân cấp vùng, thành phố, mã khu vực bưu chính, lô và cuối cùng
địa chỉ. Các đối tượng địa chỉ sẽ lấy mã của mình trong cây quốc gia và nếu dịch vụ
bưu chính sẽ quyết định gán mã khu vực bưu chính, tất cả các địa chỉ trong đó sẽ cùng
đi trong một chuyến.
Khi cần quan tâm đến thuộc tính của một thành phần trong mô hình, hãy phân
loại nó thành một đối tượng của giá trị. Nhờ đó mà thể hiện ý nghĩa của thuộc tính mà
nó truyền tải và cung cấp cho nó chức năng liên quan. Hãy coi đối tượng của giá trị là
không thay đổi và không gán cho nó bất kì định danh nào nhằm tránh sự phức tạp
không cần thiết trong thiết kế để duy trì thực thể.
Dịch vụ
Sai lầm phổ biến nhất là từ bỏ dễ dàng việc đưa hành vi phù hợp với một đối
tượng cụ thể và dần trượt về phía lập trình thủ tục. Khi buộc một hoạt động vào một
đối tượng không phù hợp với định nghĩa của đối tượng thì đối tượng mất đi sự rõ ràng
của khái niệm và trở nên khó hiểu hoặc tái cấu trúc. Và do các hoạt động này thường
liên quan đến nhiều đối tượng miền nên việc kết hợp chúng và thêm vào các hành
động hay trách nhiệm sẽ tạo nên nhiều sự phụ thuộc vào tất cả các đối tượng đó, các
khái niệm không thể được hiểu một cách độc lập.
Một số khái niệm từ miền không tự nhiên để mô hình như các đối tượng. Việc ép
các chức năng được yêu cầu thành trách nhiệm của thực thể hay đối tượng của giá trị
sẽ gây ra méo mó định nghĩa của đối tượng dựa vào mô hình hoặc thêm vào các đối
tượng giả vô nghĩa. Một dịch vụ là một hoạt động được cung cấp như một giao diện
độc lập trong mô hình mà không đóng gói trạng thái như thực thể và đối tượng của giá
trị. Dịch vụ là một mô hình chung trong các nền tảng kỹ thuật nhưng chúng cũng có
thể áp dụng trong tầng nghiệp vụ (domain layer). Tên của dịch vụ nhấn mạnh mối
quan hệ với các đối tượng khác. Dịch vụ vẫn có thể là một định nghĩa trừu tượng. Một
dịch vụ vẫn nên có trách nhiệm rõ ràng; trách nhiệm đó và giao diện thực hiện nên
được định nghĩa như một phần của mô hình miền. Các tham số và kết quả nên là các
đối tượng miền.
Một dịch vụ tốt có ba đặc tính:
 Hoạt động liên quan đến khái niệm miền không phải là thành phần vốn có của
một thực thể hay một đối tượng của giá trị.
 Giao diện được định nghĩa dưới dạng các thành phần khác của mô hình miền.
 Hoạt động không có trạng thái.
11


Các mô-đun
Mô-đun được sử dụng như một phần chính thức của mô hình. Mã nguồn được
chia nhỏ thành tất cả các danh mục, từ khía cạnh kiến trúc kỹ thuật đến nhiệm vụ được
giao của nhà phát triển. Sự thật là nên có sự liên kết lỏng lẻo giữa các mô-đun và sự
gắn kết cao bên trong chúng.
Liên kết lỏng lẻo (low coupling) và gắn kết cao (high cohension) là các nguyên
tắc thiết kế chung, áp dụng nhiều cho các đối tượng riêng lẻ như mô-đun, nhưng chúng
đặc biệt quan trong trong mô hình hóa và thiết kế hướng miền. Bất cứ khi nào hai phần
tử của mô hình được tách thành các mô-đun khác nhau thì mối quan hệ giữa chúng trở
nên ít trực tiếp hơn so với giải pháp ban đầu (tăng chi phí hiểu vị trí của chúng trong
mô hình). Liên kết lỏng lẻo giữa các mô-đun tối thiểu hóa chi phí này và có thể phân
tích nội dung của một mô-đun với mức độ tham chiếu đến mô-đun khác (mà nó tương
tác) là ít nhất.
Mô-đun và các thành phần nhỏ hơn nên cùng phát triển, nhưng thông thường lại
không như vậy. Mô-đun được chọn để tổ chức một dạng rất sớm của các đối tượng.
Sau đó, các đối tượng có xu hướng thay đổi theo cách giữa trong trong giới hạn định
nghĩa của mô-đun hiện có. Việc tái cấu trúc mô-đun trở nên vất vả hơn và rắc rối hơn
tái cấu trúc lớp và không thể làm thường xuyên. Nhưng cũng giống như các đối tượng
của mô hình có xu hướng bắt đầu là cụ thể và đơn giản, sau đó dần dần biến đổi để cho
thấy cái nhìn sâu sắc hơn, mô-đun có thể trở nên tinh tế và trừu tượng. Việc để các môđun phản ánh sự thay đổi hiểu biết về lớp miền cũng cho phép đối tượng bên trong
chúng tự do phát triển.
Giống như các thành phần khác trong mô hình hướng miền, mô-đun là một cơ
chế trao đổi. Ý nghĩa của các đối tượng cần được phân vùng để thúc đẩy việc lựa chọn
các mô-đun. Nếu mô hình là một quyển sách thì các mô-đun là các chương. Tên của
mô-đun truyền tải ý nghĩa có nó.

1.2.6. Vòng đời của đối tượng miền
Mỗi đối tượng đều có một vòng đời. Một đối tượng được sinh ra, nó có thể trải
qua các trạng thái khác nhau và cuối cùng là nó được lưu trữ hoặc bị xóa đi khi kết
thúc vòng đời của mình. Một số đối tượng đơn giản được tạo ra bằng việc gọi hàm
khởi tạo của nó, được sử dụng trong một số tính toán và cuối cùng được bộ thu gom
rác truy tìm và xóa bỏ khỏi bộ nhớ khi chương trình không dùng đến; các đối tượng
này không cần làm phức tạp chúng. Nhưng các đối tượng có vòng đời dài hơn, có phụ
thuộc phức tạp với các đối tượng khác, chúng trải qua những thay đổi trạng thái cho
đến khi bất biến thì việc quản lý các đối tượng này là thử thách khi áp dụng thiết kế
hướng mô hình.

12


Hình 1.3: Vòng đời của đối tượng miền [2]
Những thử thách này chia thành hai loại:
 Duy trì tính toàn vẹn trong suốt vòng đời.
 Ngăn chặn mô hình khỏi sa lầy vào sự phức tạp của quản lý vòng đời.
Các vấn đề này sẽ được giải quyết thông qua ba pattern: Aggregates, Factories,
Repositories.
Aggregates
Pattern này rất quan trọng để duy trì tính toàn vẹn trong tất cả các pha của vòng
đời. Nó thắt chặt mô hình nhờ việc định nghĩa rõ ràng quyền sở hữu và các ranh giới,
tránh sự hỗn loạn và rắc rối trong đối tượng.
Factories
Pattern này được sử dụng để tạo và tái tạo các đối tượng phức tạp trong giai đoạn
đầu của vòng đời, giữ cho cấu trúc bên trong của chúng được đóng gói.
Repositories
Pattern này thực hiện ở giữa và cuối vòng đời, cung cấp các phương pháp tìm
kiếm và truy xuất các đối tượng cùng với đóng gói tất cả cơ sở hạ tầng liên quan.
Mặc dù repositories và factories không tự xuất phát từ miền nhưng chúng có vai
trò ý nghĩa trong thiết kế miền. Những pattern này hoàn thiện thiết kế hướng mô hình
nhờ việc cung cấp các xử lý, có thể truy cập được đến các đối tượng mô hình. Mô hình
hóa aggregates và bổ sung factories, repositories vào thiết kế sẽ cung cấp khả năng
thao tác với các đối tượng mô hình một cách hệ thống trong suốt vòng đời của chúng.
Aggregates đánh dấu phạm vi mà trong đó các bất biến phải được duy trì ở mọi giai
đoạn của vòng đời. Factories và Repositories hoạt động trên aggregates, đóng gói sự
phức tạp của các quá trình chuyển đổi trạng thái trong vòng đời cụ thể.

1.3. Phương pháp phát triển phần mềm hướng miền DDSDM
DDSDM là một phương pháp phát triển lặp cho việc phát triển các nguyên mẫu
phần mềm từ mô hình miền do nhóm tác giả [5] đề xuất. Các nguyên mẫu này được sử
13


dụng theo hai cách: Cách sử dụng đầu tiên và cũng là chủ yếu dành cho các chuyên gia
miền và các nhóm phát triển để phát triển mô hình miền một cách tăng dần, hợp tác và
tương tác. Cách sử dụng thứ hai là nguyên mẫu sẽ được tái sử dụng trong giai đoạn sau
để phát triển ra phần mềm thương mại.
Hình 1.4 mô tả DDSDM bao gồm các pha sau:





Pha 1: Phát triển mô hình miền khái niệm
Pha 2: Định nghĩa các vòng lặp phát triển
Pha 3: Thực hiện các vòng lặp để phát triển một tập các nguyên mẫu phần mềm
Pha 4: Tích hợp các nguyên mẫu phần mềm để tạo ra nguyên mẫu cuối cùng.

Hình 1.4: Tổng quan về phương pháp phát triển phần mềm hướng miền [5]

1.3.1. Phát triển một mô hình miền khái niệm
Đây là một mô hình miền ở mức cao, sẽ được sử dụng làm điểm khởi đầu cho
quá trình phát triển. Mô hình này được sử dụng để định nghĩa ra các vòng lặp phát
triển, hiệu suất phát triển và dần dần làm phong phú thêm mô hình miền với tính năng
chi tiết mới.
Mô hình miền ở mức cao chỉ bao gồm các lớp miền lõi (có cấu trúc không hoàn
thiện) và các liên kết ban đầu giữa các lớp miền đó. Các lớp miền và liên kết này được
xác định từ yêu cầu chức năng của phần mềm. Các yêu cầu đó thường được mô tả dưới
dạng các ca sử dụng.
Về nguyên tắc, mỗi chức năng được xác định từ một tập các lớp miền liên quan
trong mô hình gọi là mô hình con. Hình 1.4 mô tả các yêu cầu chức năng sử dụng mô
hình ca sử dụng. Mỗi ca sử dụng được kết nối tới một mô hình con của mô hình miền.
Ranh giới của mỗi mô hình con được biểu diễn bởi một hình ô-van đây có chứa một
14


hoặc nhiều lớp miền cùng với liên kết giữa chúng (nếu có). Ví dụ, ca sử dụng F1 được
kết nối đến mô hình con chứa hai lớp miền (tên là Cz và Cw) cùng với kết nối giữa
chúng. Các mô hình con của hai chức năng chồng lên nhau ở một lớp miền được chia
sẻ và/hoặc một liên kết giữa các hai lớp miền của hai mô hình con. Thông qua các
điểm chồng lẫn này mà các mô hình con được kết hợp để tạo thành toàn bộ mô hình
miền. Ví dụ, hình 1.4 cho thấy cách mô mình con F1 chồng lên một mô hình con khác
chứa hai lớp là Cz và Cx thông qua lớp Cz, mô hình con này lại chồng lên một mô
hình con khác chỉ chứa lớp Cy thông qua kết nối giữa Cx và Cy.

1.3.2. Định nghĩa các vòng lặp phát triển
Khi mô hình miền ở mức cao đã được tạo, pha tiếp theo là định nghĩa ra các vòng
lặp. Cùng với nhau, các vòng lặp này sẽ xây dựng kế hoạch phát triển cho phần mềm.
Ý tưởng chính là định nghĩa ra mỗi vòng lặp theo ranh giới của một mô hình con.
Đầu ra của mỗi vòng lặp là một nguyên mẫu phần mềm cho mô hình con đó. Một mô
hình con có thể là mô hình con được định nghĩa cho mỗi chức năng trong pha trước
hoặc là mô hình con nhỏ hơn trong mô hình con này. Kích thước chính xác của mô
hình con phụ thuộc tài nguyên phát triển (quan trọng nhất là nguồn tài nguyên con
người) sẵn có cho dự án.
Mỗi vòng lặp liên quan đến việc thực hiện bốn hoạt động của một quy trình phát
triển phần mềm điển hình là phân tích, thiết kế, lập trình và kiểm thử. Sự khác biệt duy
nhất ở đây là thực hiện các hoạt động này để phát triển một nguyên mẫu phần mềm
cho một mô hình con chứ không phải toàn bộ mô hình miền.
Về mặt khái niệm, các vòng lặp phát triển hình thành một chu trình phát triển liên
tục. Hình 1.4 minh họa chu trình phát triển này bằng một đường cong bên ngoài có
mũi tên đi qua và kết nối bốn hoạt động phát triển phần mềm.

1.3.3. Thực hiện các vòng lặp phát triển
Mỗi vòng lặp phát triển được thực hiện bởi việc phân tích, thiết kế, lập trình và
kiểm thử để tạo ra một nguyên mẫu phần mềm của một mô hình con. Thông qua các
vòng lặp này, các mô hình con trở nên phong phú hơn với các tính năng chi tiết hơn
bao gồm các lớp miền mới, các thuộc tính và phương thức mới.
Thực tế là các vòng lặp được thực hiện lặp đi lặp lại trên các mô hình phần mềm
(mô hình chức năng và mô hình miền) bằng cách đóng gói chu trình phát triển bao
hàm cả mô hình ca sử dụng và mô hình miền. Tính năng chính của chu trình phát triển
DDSDM là ở chỗ các vòng lặp phát triển có thể được tổ chức để thực hiện song song
do các mô hình con của chúng (mặc dù có chồng lên nhau) chủ yếu thực hiện các yêu
cầu chức năng khác nhau.

1.3.4. Tích hợp các nguyên mẫu phần mềm
Khi các vòng lặp phát triển được hoàn thành, tạo ra một tập các nguyên mẫu cho
các mô hình con thì pha cuối cùng là tích hợp các nguyên mẫu này. Mục tiêu của việc
15


tính hợp này: thứ nhất, tạo ra mô hình miền cuối cùng ;và thứ hai, tạo ra một nguyên
mẫu hoàn chỉnh. Tích hợp phần mềm thu được một cách dễ dàng trong DDSDM nhờ
khả năng của công cụ hỗ trợ phát triển phần mềm DomainAppTool do cùng các tác giả
của DDSDM xây dựng. Khi các mô hình con được làm phong phú thêm nhờ các vòng
lặp, chúng sẽ hợp với nhau bằng cách sử dụng các lớp miền chia sẻ và/hoặc thông qua
việc xác định các liên kết mới kết nối các lớp miền trong mô hình con.
Bởi vì tất cả các chức năng phần mềm đã được tính toán bằng các vòng lặp nên
không cần thiết thực hiện bất kỳ phân tích, thiết kế và lập trình nào nữa trong pha này.
Hoạt động duy nhất phải thực hiện trong pha này là kiểm thử để đảm bảo toàn các
chức năng của nguyên mẫu phần mềm là chính xác (nghĩa là tất cả các phần của nó
hoạt động với nhau một cách chính xác).

1.4. Công cụ hỗ trợ phát triển phần mềm hướng miền
DomainAppTool là một công cụ phát triển phần mềm Java thuần túy, được sử
dụng để phát triển nhanh phần mềm phù hợp với các nguyên tắc thiết kế phần mềm
hướng miền [5].

1.4.1. Lịch sử phát triển
Năm 2012, ý tưởng xây dựng một nền tảng phần mềm hướng miền tên là
jDomainApp đã được các tác giả [5] khởi xướng. Ban đầu, nền tảng được hình thành
để phục vụ như một công cụ cho việc giảng dạy một phương pháp phát triển chương
trình hướng đối tượng trong Java. Phương pháp này được đề xuất trong một cuốn sách
[10] đã được cập nhật và điều chỉnh bởi tác giả để giảng dạy hai mô-đun khóa học
chính của kỹ sư phần mềm tại khoa Công nghệ thông tin, Đại học Hà Nội.
Năm 2014, DomainAppTool bắt đầu được phát triển dựa trên jDomainApp do
nhu cầu cần một công cụ thân thiện với người sử dụng, có thể được sử dụng để thực thi
và kiểm thử các lớp miền một cách nhanh chóng và tương tác. Công cụ này đã được
chứng minh là hữu ích sau khi áp dụng tại khoa Công nghệ thông tin trong việc giảng
dạy một mô-đun khóa học khác của kỹ sư phần mềm là môn “Dự án 2”.
Sự phát triển của công cụ DomainAppTool nói riêng và nền tảng jDomainApp
nói chung là liên tục không ngừng. Công cụ được sử dụng không chỉ để chứng minh
khả năng của nền tảng mà còn để thử nghiệm một cách nhanh chóng bất kì ý tưởng mô
hình hóa miền mới nào được tích hợp vào nền tảng. Đến cuối năm 2016, sự phát triển
này đã đạt tới một cột mốc quan trong khi ba bài báo khoa học chính thức được xuất
bản tại hội nghị KSE với mục tiêu củng cố và khẳng định tính đúng đắn của lý thuyết
cốt lõi của nền tảng và công cụ.

1.4.2. Tổng quan kiến trúc
Công cụ được thiết kế dựa trên kiến trúc phần mềm MVC. Về mặt khái niệm,
kiến trúc của công cụ được xây dựng từ thành phần chính: quản lý mô hình, quản lý
hiển thị và quản lý đối tượng.
16


Quản lý mô hình
Thành phần này chịu trách nhiệm xử lý các lớp miền. Một lớp miền là một lớp
Java được thiết kế với các tính năng thiết kế hướng miền. Mỗi lớp nắm giữ các yêu cầu
miền của một khái niệm hoặc một thực thể quan tâm đến phần mềm. Các lớp miền
được xác định như đầu vào khi chạy công cụ.
Một tính năng chính của công cụ là nó chỉ yêu cầu nhà phát triển xác định tập các
lớp miền của một phần mềm. Toàn bộ phần mềm bao gồm giao diện đồ họa GUI và
lưu trữ đối tượng sẽ được tạo ra một cách tự động tại thời điểm chạy.
Quản lý hiển thị
Phần mềm do công cụ tạo ra có giao diện đồ họa GUI, giúp người dùng dễ dàng
thực hiện các chức năng của phần mềm. Giao diện GUI này được tạo ra một cách tự
động tại thời điểm chạy từ thông tin thiết kế được nhúng trong các lớp miền của phần
mềm và quản lý hiển thị là thành phần chịu trách nhiệm cho nhiệm vụ này.
Về nguyên tắc, quản lý hiển thị cung cấp một desktop manager cho việc quản lý
các biểu mẫu đối tượng khác nhau, một thư viện các thành phần dựa trên Java Swing
được sử dụng để tạo ra các biểu mẫu đó. Biểu mẫu đối tượng là thành phần then chốt
trong việc cung cấp một giao diện cho phép người dùng xem và thao tác trên các đối
tượng miền của một lớp miền.
Quản lý đối tượng
Thành phần này chịu trách nhiệm quản lý các đối tượng miền của phần mềm.
Quản lý đối tượng quản lý hiệu quả các đối tượng trong bộ nhớ trong và cung cấp một
cơ chế để lưu trữ các đối tượng trong bộ nhớ ngoài.
Hiện tại, công cụ DomainAppTool đã hỗ trợ hệ thống quản trị cơ sở dữ liệu quan
hệ Java DB, được cung cấp với nền tảng Java. Cơ sở dữ liệu được tạo một cách tự
động cho phần mềm trong lần chạy đầu tiên. Schema của cơ sở dữ liệu được tạo từ các
thông tin thiết kế nhúng trong các lớp miền của phần mềm. Tại thời điểm chạy, các đối
tượng miền của phần mềm được chuyển đổi thành các bản ghi và được lưu trữ trong cơ
sở dữ liệu này.

1.4.3. Ví dụ điển hình: CourseMan
Để minh họa ứng dụng của công cụ DomainAppTool trong việc tự động tạo ra
phần mềm, phần mềm quản lý khóa học CourseMan được sử dụng. Các phần sau đây
sẽ mô tả các yêu cầu của phần mềm này.
Các yêu cầu chức năng
CourseMan là một phần mềm quản lý khóa học đơn giản bao gồm các chức năng
sau: Thứ nhất, cho phép khoa quản lý sinh viên và quản lý các mô-đun khóa học được
cung cấp cho sinh viên. Thứ hai, phần mềm cho phép sinh viên đăng kí vào các môđun khóa học trong mỗi học kì, cho phép khoa nhập điểm của sinh viên và phần mềm
phải tự tính toán ra điểm cuối cùng của sinh viên trong mỗi mô-đun khóa học đó. Thứ
17


ba, phần mềm cần cho phép khoa quản lý các lớp từ các nhóm sinh viên. Ngoài ra,
phần mềm cũng cần cung cấp một số báo cáo liên quan ví dụ như báo cáo học sinh
theo tên, cho phép người dùng tìm kiếm tất cả các sinh viên có tên chứa một chuỗi xác
định trước.
Các yêu cầu dữ liệu
Sinh viên được đặc trưng bởi các thuộc tính cơ bản: mã sinh viên, tên sinh viên,
ngày tháng năm sinh, địa chỉ và email. Thuộc tính mã sinh viên là một định danh duy
nhất được sinh ra một cách tự động bởi hệ thống theo công thức: bắt đầu bằng chữ “S”
và theo sau bởi một số tự động tăng lên từ năm hiện tại. Ví dụ, sinh viên đầu tiên đăng
ký vào chương trình học trong năm 2016 có mã sinh viên là S2016 thì sinh viên thứ
hai của năm đó sẽ có mã sinh viên là S2017, .vv.. Lớp Student được mô tả bởi mã sinh
viên, tên và địa chỉ.
Mô-đun học (course module) được đặc trưng bởi các thuộc tính: định danh (id),
mã mô-đun (code), tên mô-đun (name), kỳ học (semester) và số tín chỉ (credits). Thuộc
tính kỳ học phải có giá trị nằm trong phạm vi từ 1 đến 10, trong khi số tín chỉ phải lớn
hơn 0. Thuộc tính mã mô-đun được tạo ra một cách tự động nhờ kết hợp chữ “M” với
1 số được tính bằng việc nhân học kỳ với 100 và cộng với một số tự động tăng bắt đầu
từ 0. Ví dụ, mã mô-đun khóa học đầu tiên trong học kỳ 1 là “M100”, mã mô-đun khóa
học thứ hai là “M101”, .vv.. Có hai loại mô-đun khóa học là bắt buộc và tự chọn.
Ngoài các thuộc tính chung, một mô-đun tự chọn được đặc trưng bởi thuộc tính tên của
khoa (deptName) giảng dạy mô-đun đó. Khoa này có thể khác với khoa mà sinh viên
đang theo học.
Sự ghi danh (enrolment) thực tế là sinh viên đăng ký học một mô-đun khóa học
cụ thể trong một kỳ nhất định. Nó lưu các dữ liệu về điểm quá trình, điểm cuối kỳ và
điểm trung bình của sinh viên trong từng mô-đun. Điểm trung bình là một ký tự đơn
thuộc một trong các thành phần sau: “E”- Giỏi, “G”- Khá, “P”- Trung bình, “F”- Yếu.

1.4.4. Phát triển các lớp miền
Phần này sẽ giải thích cách phát triển các lớp miền sử dụng các tính năng
DDD. Tổng quan thiết kế
Lớp miền là lớp được thiết kế với thông tin chuyên biệt miền. Các nền tảng ngôn
ngữ hướng đối tượng hiện tại (ví dụ : .NET và Java) cung cấp hỗ trợ đặc tả các thông
tin đó như một phần của thiết kế lớp. Ý tưởng là mô hình hóa thông tin chuyên biệt
miền như một tập các meta-attribute, có thể được gắn vào lớp, vào các thành viên của
lớp hoặc cả hai. Một meta-attribute là một tập các thuộc tính có giá trị cụ thể khi thuộc
tính được đính kèm.
Trong DomainAppTool, năm meta-attribute cơ bản được sử dụng để mô hình hóa
một lớp miền là DClass, Dattr, DAssoc, DOpt, AttrRef. Trong đó, DClass được đính
kèm vào lớp, còn các thuộc tính khác được đính kèm vào thành viên của lớp. Một
18


Tài liệu bạn tìm kiếm đã sẵn sàng tải về

Tải bản đầy đủ ngay

×