Luận văn Nghiên cứu kỹ thuật chuyển đổi mô hình sang văn bản và ứng dụng vào sinh mã nguồn Java
ĐẠI HỌC QUỐC GIA HÀ NỘI
TRƯỜNG ĐẠI HỌC CÔNG NGHỆ
----------
----------
PHẠM VĂN TRƯỜNG
NGHIÊN CỨU KỸ THUẬT CHUYỂN ĐỔI MÔ HÌNH SANG
VĂN BẢN VÀ ỨNG DỤNG VÀO SINH MÃ NGUỒN JAVA
LUẬN VĂN THẠC SĨ CÔNG NGHỆ THÔNG TIN
Hà Nội – 2020
ĐẠI HỌC QUỐC GIA HÀ NỘI
TRƯỜNG ĐẠI HỌC CÔNG NGHỆ
----------
----------
PHẠM VĂN TRƯỜNG
NGHIÊN CỨU KỸ THUẬT CHUYỂN ĐỔI MÔ HÌNH SANG
VĂN BẢN VÀ ỨNG DỤNG VÀO SINH MÃ NGUỒN JAVA
Ngành: Công nghệ thông tin
Chuyên ngành: Kỹ thuật phần mềm
Mã số học viên: 17025008
LUẬN VĂN THẠC SĨ CÔNG NGHỆ THÔNG TIN
Hà Nội – 2020
LỜI CAM ĐOAN
Tôi xin cam đoan đây là công trình nghiên cứu của cá nhân tôi, được thực hiện qua sự
hướng dẫn tận tình của thầy TS. Đặng Đức Hạnh.
Các nội dung nghiên cứu và kết quả thực nghiệm được trình bày trong luận văn là
hoàn toàn trung thực, do cá nhân tôi cài đặt, cấu hình và lên kịch bản. Các kiến thức hàn
lâm được tôi chắt lọc từ các tài liệu tham khảo trên mạng, sách và các bài báo khoa học của
các tác giả uy tín trong cùng lĩnh vực nghiên cứu.
Hà Nội, tháng 12 năm 2020
Người thực hiện
Phạm Văn Trường
i
LỜI CẢM ƠN
Lời đầu tiên, tôi xin dành lời cảm ơn sâu sắc nhất tới giảng viên hướng dẫn của tôi,
TS. Đặng Đức Hạnh – Giảng viên Bộ môn Công nghệ Phần mềm – Khoa Công nghệ
Thông tin – Trường Đại học Công nghệ - ĐHQGHN, là người đã trực tiếp định hướng và
hướng dẫn tôi hoàn thành luận văn này. Tôi cũng xin được cảm ơn sự hỗ trợ của đề tài
nghiên cứu khoa học cấp Đại học Quốc gia Hà Nội, mã số QG.20.54.
Với cá nhân tôi, lĩnh vực này là một lĩnh vực hoàn toàn mới và vô cùng trừu tượng,
thời điểm ban đầu còn gặp nhiều khó khăn về việc nghiên cứu cũng như cách tiếp cận,
nhưng qua sự định hướng cả về kĩ năng chuyên môn và phương pháp nghiên cứu của Thầy,
tôi đã thu được những kiến thức nhất định sau khi thực hiện luận văn này. Bên cạnh đó,
trong khoảng thời gian học tập và tham gia nghiên cứu tại Trường Đại học Công nghệ –
ĐHQGHN, với sự giảng dạy và giúp đỡ của các Thầy/Cô cùng các bạn học viên, tôi đã học
được rất nhiều kiến thức bổ ích và có nhiều tính thực tiễn. Những kiến thức gặt hái được
giúp tôi có khả năng tư duy, phân tích, tổng hợp các vấn đề một cách khoa học, và thậm chí
áp dụng được khá nhiều vào công việc tôi đang làm.
Một lần nữa, tôi xin gửi lời cảm ơn chân thành nhất tới các Thầy/Cô và các bạn. Tôi
cũng xin gửi lời cảm ơn tới gia đình đã luôn luôn động viên tôi vượt qua khó khăn và hoàn
thành tốt công việc học tập và nghiên cứu tại đây. Do lĩnh vực nghiên cứu được đề cập
trong luận văn còn mới lạ, chưa được áp dụng nhiều, và vẫn còn đang trong giai đoạn phát
triển, cho nên tôi đã gặp không ít khó khăn trong việc nghiên cứu. Hạn chế về mặt thời gian
và phát sinh từ công việc hiện khiến tôi chưa tập trung hết khả năng và sự sáng tạo để khai
thác các vấn đề một cách kỹ càng và đầy đủ hơn nữa. Do vậy luận văn sẽ còn nhiều hạn
chế, rất mong nhận được ý kiến đóng góp của các Thầy/Cô và bạn đọc quan tâm.
Xin chân thành cảm ơn.
Hà Nội, tháng 12 năm 2020
Người thực hiện
Phạm Văn Trường
ii
MỤC LỤC
LỜI CAM ĐOAN..........................................................................................................................................i
LỜI CẢM ƠN...............................................................................................................................................ii
MỤC LỤC....................................................................................................................................................iii
DANH MỤC HÌNH ẢNH VÀ ĐỒ THỊ.....................................................................................................vi
DANH MỤC BẢNG BIỂU .......................................................................................................................viii
MỞ ĐẦU .......................................................................................................................................................1
CHƯƠNG 1. KIẾN THỨC NỀN TẢNG....................................................................................................3
1.1. Phát triển phần mềm hướng mô hình ........................................................................................3
Các thuật ngữ chính.............................................................................................................4
Các cấp độ của MDSE .........................................................................................................6
Meta-model...........................................................................................................................7
Unified Modeling Language................................................................................................9
Biểu đồ lớp ..........................................................................................................................10
Định nghĩa...................................................................................................................10
Các thành phần ..........................................................................................................11
Công cụ................................................................................................................................11
1.2. Chuyển đổi mô hình...................................................................................................................12
Chuyển đổi mô hình sang mô hình ...................................................................................14
Chuyển đổi mô hình và sự phân loại ........................................................................14
Ngoại sinh và sự chuyển đổi bên ngoài.....................................................................16
Nội sinh và sự chuyển đổi nội tại...............................................................................18
Chuỗi chuyển đổi mô hình.........................................................................................19
Chuyển đổi mô hình sang văn bản....................................................................................19
Mô hình và định nghĩa mã nguồn.............................................................................20
Sinh mã nguồn tự động..............................................................................................21
1.3. Tổng kết chương.........................................................................................................................23
CHƯƠNG 2. TỔNG QUAN KỸ THUẬT SINH MÃ NGUỒN..............................................................24
2.1. Giới thiệu ....................................................................................................................................24
iii
2.2. Sinh mã nguồn bằng ngôn ngữ lập trình..................................................................................24
2.3. Sinh mã nguồn bằng ngôn ngữ chuyển đổi mô hình...............................................................29
2.4. Kỹ thuật sinh mã nguồn sử dụng ngôn ngữ chuyển đổi Acceleo ...........................................31
Tổng quan ...........................................................................................................................31
Ví dụ ....................................................................................................................................33
2.5. Tổng kết chương.........................................................................................................................35
3.1. Giới thiệu ....................................................................................................................................36
3.2. Nghiên cứu tình huống...............................................................................................................36
Biểu đồ lớp ..........................................................................................................................37
Cách thức thực hiện...........................................................................................................41
3.3. Đặc tả chuyển Acceleo ...............................................................................................................43
Quy tắc chuyển đổi.............................................................................................................43
Quy tắc chuyển đổi tĩnh.............................................................................................43
Quy tắc chuyển đổi mở rộng .....................................................................................45
3.4. Template và dữ liệu mẫu ...........................................................................................................47
3.5. Tổng kết chương.........................................................................................................................48
CHƯƠNG 4. CÀI ĐẶT VÀ THỰC NGHIỆM........................................................................................49
4.1. Môi trường cài đặt .....................................................................................................................49
Cấu hình phần cứng, phần mềm.......................................................................................49
Dữ liệu đầu vào...................................................................................................................51
Cách thức thực hiện...........................................................................................................52
Cài đặt dữ liệu mẫu....................................................................................................52
Cài đặt mã nguồn Acceleo .........................................................................................53
4.2. Kết quả thực nghiệm..................................................................................................................55
4.3. Tổng kết chương.........................................................................................................................58
KẾT LUẬN.................................................................................................................................................59
TÀI LIỆU THAM KHẢO .........................................................................................................................60
iv
DANH MỤC KÝ HIỆU CÁC CHỮ VIẾT TẮT
Chữ viết tắt
Chú giải
MDSE
IDE
Model-Driven Software Enginerring
Integrated Development Environment
Model-Driven Development
Model-Driven Architecture
Unified Modeling Language
XML Metadata Interchange
Model To Model
MDD
MDA
UML
XMI
M2M
M2T
ATL
OCL
PIM
Model To Text
ATLAS Transformation Language
Object Constraint Language
Platform-Independent Model
Platform-Specific Models
PSM
JSP
Java Server Pages
MOF
XSTL
Meta-Object Facility
eXtensible Stylesheet Language Transformations
v
MỞ ĐẦU
Hiện nay ngành công nghệ thông tin nói chung và phát triển phần mềm nói riêng đang
ngày một phát triển và là xu thế tất yếu để vươn lên của mỗi quốc gia. Các hệ thống công
nghệ thông tin cũng ngày một đa dạng, phức tạp và cồng kềnh hơn trước rất nhiều, do nhu
cầu phát triển và tiến hóa về mặt kiến trúc. Các hệ thống không chỉ dừng lại ở một phiên
bản phát triển mà còn phát sinh nhiều bản cập nhật. Khi trải nghiệm người dùng và các
chức năng mới được thêm vào cùng với các yêu cầu mới về hệ thống được đưa ra, và các
phiên bản phần mềm mới lại ra đời sao cho có thể hoạt động tốt được trên nền tảng mới.
Điều này tất nhiên nhằm đáp ứng nhu cầu người dùng thực tế, mặt khác lại gây ra rất nhiều
phiền phức cho các nhà phát triển, và lúng túng trong các khâu quản lý, duy trì phần mềm
một cách thủ công nếu họ vẫn áp dụng phương pháp phát triển cũ. Công sức và thời gian
tiêu tốn cho việc duy trì đó là rất lớn. Vậy bài toán đặt ra đó là làm thế nào để tăng tính tự
động, giảm tải các chi phí phát sinh và bớt các khâu thủ công trong quá trình phát triển phần
mềm.
Để giải quyết vấn đề này, các nhà phát triển đã chuẩn bị các nguồn lực và các đầu vào
cần thiết bằng cách mô hình hóa một cách bao quát các thành phần của hệ thống, các bộ
phận có liên quan thông qua các quy tắc và cú pháp tương ứng cho từng phương pháp. Việc
này được thực hiện thông qua ngôn ngữ mô hình hóa. Kết quả của việc mô hình hóa sẽ giúp
việc phát triển phần mềm đi đúng hướng, giải quyết vấn đề quản lý các phiên bản, tăng tính
tự động hóa, qua đó tăng hiệu suất, giảm chi phí phát triển phần mềm. Từ yêu cầu phát triển
đó, phương pháp phát triển phần mềm hướng mô hình ra đời, tập trung mô hình hóa phần
mềm, từ đó chuyển đổi sang các mô đun, mã nguồn có thể thực thi bằng các công cụ chuyển
đổi mô hình.
Từ những yêu cầu thực tế và bức thiết trong phát triển phần mềm, tôi đã lựa chọn đề
tài “Nghiên cứu kỹ thuật chuyển đổi mô hình sang văn bản và ứng dụng vào sinh mã
nguồn Java” nhằm đáp ứng việc nghiên cứu phương pháp chuyển đổi hướng mô hình. Để
thực hiện giai đoạn mô hình hóa, các mô hình cũng cần được bổ sung thêm các thông tin
thực hiện chương trình, ví dụ như các yêu cầu về thành phần của hệ thống, các ràng buộc
trong nền tảng và các chức năng,... Ngoài ra, các hành vi của ứng dụng cũng cần được mô
hình hóa, như là sự tương tác giữa các đối tượng, các phương thức sử dụng, khai báo và xử
lý kết quả trả về...bên cạnh việc tập trung vào tìm hiểu và nghiên cứu các kỹ thuật chuyển
đổi mô hình dựa theo giải pháp ModelToText, luận văn hướng tới việc xây dựng quy tắc
sinh mã nguồn Java một cách tự động và áp dụng cho bài toán cụ thể. Kết quả đạt được sẽ
gồm các tệp mã nguồn Java kết hợp với các cấu hình cần thiết để có thể thực thi và kiểm
tra chương trình sau khi sinh tự động.
1
Cấu trúc luận văn được chia thành các mục như sau:
Chương 1: Tổng quan về phương pháp phát triển hướng mô hình trong phát triển phần
mềm (MDSD/MDSE). Chương đầu tiên tập trung đề cập đến phương pháp phát triển hướng
mô hình trong phát triển phần mềm, tìm hiểu các thuật ngữ và các thành phần thiết yếu. Sau
đó trình bày cụ thể hơn về phạm vi chuyển đổi mô hình, gồm chuyển đổi mô hình sang mô
hình và mô hình sang văn bản.
Chương 2: Hướng tới khía cạnh cụ thể của chuyển đổi mô hình sang văn bản, với ứng
dụng phổ biến nhất là sinh mã nguồn tự động (Code generation). Khi áp dụng phương pháp
này, ngoài các chế tác có thể sinh ra từ các mô hình thì chương này tập trung vào chế tác
sinh mã nguồn tự động, sử dụng công cụ chuyển đổi, ngôn ngôn ngữ chuyển đổi, cụ thể sẽ
áp dụng ngôn ngữ Acceleo. Qua đó thống kê đánh giá các mặt tích cực, hạn chế của phương
pháp được áp dụng.
Chương 3: Với khía cạnh sinh mã nguồn đã trình bày trong chương trước, chương 3
tập trung nghiên cứu bài toán cụ thể sinh mã nguồn Java từ biểu đồ lớp với input/output
cần thiết. Ứng với bài toán này, chương 3 mô tả các quy tắc chuyển đổi, ví dụ áp dụng,
template, dữ liệu mẫu…
Chương 4: Cài đặt ví dụ cụ thể của phương pháp áp dụng chuyển đổi mô hình sang
mã nguồn Java và kết quả thực nghiệm, đánh giá kết quả đạt được (kết quả, hạn chế) và
hướng nghiên cứu, phát triển mới trong tương lai.
2
CHƯƠNG 1. KIẾN THỨC NỀN TẢNG
Chương đầu tiên sẽ khái quát các kiến thức nền tảng xoay quanh đề tài nghiên cứu,
các thuật ngữ chính và các công cụ hỗ trợ. Chương gồm các phần chính: tổng quan phát
triển phần mềm hướng mô hình và các khái niệm cốt lõi, chuyển đổi từ mô hình sang mô
hình hoặc từ mô hình sang văn bản, và phần cuối là tổng kết chương.
1.1. Phát triển phần mềm hướng mô hình
Mô hình (model) là một sự trừu tượng của hệ thống thường được sử dụng để thay thế
cho hệ thống đang được nghiên cứu. Nhìn chung, một mô hình đại diện cho một cái nhìn
đơn giản và phân mảnh từng phần của một hệ thống, do vậy, việc tạo ra nhiều mô hình là
khá cần thiết để thể hiện và hiểu rõ hơn về hệ thống đang được tiếp cận nghiên cứu. Mô
hình hóa là một phương pháp kỹ thuật nổi tiếng được áp dụng bởi các lĩnh vực kỹ thuật
cũng như các lĩnh vực khác như Vật lý, Toán học, Sinh học, Kinh tế, Chính trị và Triết
học… Tuy nhiên, luận văn sẽ chỉ tập trung vào các mô hình trong bối cảnh cụ thể đó là lĩnh
vực kỹ thuật phần mềm. Điều đó có nghĩa là các mô hình có bản chất dựa trên ngôn ngữ và
có xu hướng mô tả hoặc quy định một hệ thống nào đó, ví dụ với các mô hình trong Toán
học vốn được hiểu là diễn giải một lý thuyết.
Các mô hình cho phép chia sẻ tầm nhìn chung giữa các bên liên quan về cả mặt kỹ
thuật và phi kỹ thuật, tạo điều kiện và thúc đẩy giao tiếp giữa các bên. Hơn nữa, các mô
hình còn làm cho việc lập kế hoạch dự án hiệu quả hơn đồng thời cung cấp một cái nhìn
phù hợp hơn về hệ thống được phát triển qua đó cho phép kiểm soát dự án theo các tiêu chí
đã đặt ra từ ban đầu. Ngày nay, một xu hướng tiếp cận mới đã xuất hiện, với góc nhìn các
mô hình không chỉ là các chế tác về mặt tài liệu, mà còn là chế tác về việc triển khai thực
hiện trong lĩnh vực kỹ thuật phần mềm, cho phép tạo hoặc thực thi tự động các hệ thống
phần mềm. Các đề xuất xoay quanh mô hình như vậy được gọi chung là “Kỹ thuật phát
triển phần mềm theo hướng mô hình (Model-Driven Software Enginerring – MDSE)”.
Đây không phải là một kỹ thuật cụ thể, mà là một cách tiếp cận, nhằm mục đích định hướng
vấn đề theo hướng mô hình hóa.
Kỹ thuật phát triển phần mềm theo hướng mô hình (MDSE) có thể được hiểu như một
phương pháp luận nhằm áp dụng các ưu điểm của mô hình hóa vào các kỹ thuật phần mềm.
Trong ngữ cảnh của MDSE, các khái niệm cốt lõi là: mô hình và phép chuyển đổi
(transformation) tức là các hoạt động thao tác trên mô hình. Dưới đây là phương trình nổi
cốt lõi:
Algorithms + Data Structures = Programs
3
Điều này có nghĩa là các chương trình được tạo nên từ 2 thành phần chính gồm: Thuật
toán (Algorithms) và Cấu trúc dữ liệu (Data Structures). Tuy nhiên trong ngữ cảnh MDSE,
điều này sẽ được nhìn nhận dưới góc nhìn khác, chương trình (có thể hiểu là một sản phẩm
phần mềm) được tạo thành từ 2 thành phần chính: mô hình và các phép chuyển đổi:
Models + Transformations = Software
Rõ ràng, cả mô hình và phép chuyển đổi đều cần được thể hiện dưới một dạng ký hiệu
nào đó hoặc ngôn ngữ nào đó, mà trong MDSE gọi là ngôn ngữ mô hình hóa (theo cách
tương tự như trong phương trình Wirth, các thuật toán và cấu trúc dữ liệu cần được định
nghĩa trong một số ngôn ngữ lập trình). Tuy nhiên, điều này vẫn chưa đủ. Phương trình
không cho chúng ta biết loại mô hình nào và theo thứ tự nào, ở mức trừu tượng nào… cần
được xác định tùy thuộc vào loại phần mềm chúng ta muốn tạo ra. Đó là lúc quá trình lựa
chọn theo mô hình phát huy tác dụng. Cuối cùng cần một bộ công cụ thích hợp để làm cho
MDSE khả thi và hữu ích hơn trong thực tế. Đối với lập trình, chúng ta cần các IDE
(Integrated Development Environment – Môi trường tích hợp phát triển) cho phép chúng
ta xác định các mô hình và phép chuyển đổi cũng như trình biên dịch hoặc trình thông dịch
để thực thi chúng nhằm tạo ra các tạo tác phần mềm cuối cùng.
Dưới góc nhìn của MDSE giống như nguyên tắc cơ bản “mọi thứ đều là một đối
tượng”, thì MDSE coi “mọi thứ đều là mô hình”, hữu ích trong thúc đẩy công nghệ theo
hướng đơn giản, tổng quát và sức mạnh tích hợp cho các ngôn ngữ và công nghệ hướng đối
ngay đến tất cả các thành phần được mô tả ở trên như một thứ có thể được mô hình hóa.
Đặc biệt, người ta có thể xem các phép chuyển đổi là các mô hình hoạt động cụ thể trên các
mô hình. Bản thân định nghĩa của ngôn ngữ mô hình hóa có thể được xem như là một mô
hình: MDSE đề cập đến quy trình này là siêu mô hình hóa (tức là mô hình hóa một mô hình,
hoặc hơn thế…). Theo cách này, người ta có thể định nghĩa các mô hình cũng như các quy
trình, công cụ phát triển và chương trình kết quả. Phần tiếp theo, luận văn sẽ đi lướt qua
các khái niệm, thuật ngữ chính nhằm tăng sự hiểu biết cần thiết đối với phương pháp luận
MDSE trước khi áp dụng vào bài toán trong ngữ cảnh cụ thể.
1.1.1. Các thuật ngữ chính
Hình 1.1 dưới đây cho thấy một cách trực quan về mối quan hệ giữa các thuật ngữ mô
4
Hình 1. 1. Mối quan hệ giữa các thuật ngữ viết tắt MD*.
Trong đó:
•
Phát triển hướng mô hình (Model-Driven Development – MDD) là mô hình
phát triển sử dụng các mô hình làm thành phần chính của quá trình phát
triển. Thông thường, trong MDD, việc triển khai được tạo tự động (bán tự
động) từ các mô hình.
•
•
Kiến trúc hướng mô hình (Model-Driven Architecture – MDA) là một kiến
trúc phát triền của MDD do “Nhóm quản lý đối tượng” (Object
Management Group – OMG) đề xuất và do đó dựa trên việc sử dụng các
tiêu chuẩn OMG. Do đó, MDA có thể được coi là một tập con của MDD,
trong đó các ngôn ngữ mô hình hóa và chuyển đổi được tiêu chuẩn hóa
bởi OMG.
Kỹ thuật dựa trên mô hình hoặc “phát triển dựa trên mô hình” (Model-based
engineering – MBE) để chỉ phiên bản MDE mềm hơn. Có nghĩa là quy trình
MBE là một quy trình trong đó các mô hình phần mềm đóng một vai trò
quan trọng mặc dù chúng không nhất thiết phải là tạo tác chính của sự phát
triển (tức là các mô hình không “điều khiển” quy trình như trong MDE).
Một ví dụ sẽ là một quá trình phát triển trong đó, trong giai đoạn phân tích,
các nhà thiết kế chỉ định các mô hình miền của hệ thống nhưng sau đó các
mô hình này được giao trực tiếp cho các lập trình viên dưới dạng bản thiết
kế để lập trình theo cách thủ công (không liên quan đến việc tạo mã tự động
và không có định nghĩa rõ ràng của bất kỳ mô hình nền tảng cụ thể nào).
Trong quá trình này, các mô hình vẫn đóng một vai trò quan trọng nhưng
không phải là tạo tác trung tâm của quá trình phát triển và có thể kém hoàn
thiện hơn (tức là chúng có thể được sử dụng nhiều hơn như các bản thiết kế
5
hoặc bản phác thảo của hệ thống) so với các mô hình trong cách tiếp cận
MDD. MBE là một tập con của MDE. Tất cả các quy trình dựa theo hướng
mô hình hóa đều dựa trên mô hình, nhưng không phải ngược lại.
1.1.2. Các cấp độ của MDSE
Phần này sẽ đi vào chi tiết về các thành phần của MDSE, làm rõ rằng mô hình hóa có
thể được áp dụng ở các mức độ trừu tượng khác nhau. Bên cạnh đó sẽ mô tả vai trò và bản
chất của các phép chuyển đổi mô hình. MDSE cung cấp một tầm nhìn toàn diện để phát
triển hệ thống. Hình 1.2 dưới đây cho thấy tổng quan về các khía cạnh chính được xem xét
trong MDSE và tóm tắt cách giải quyết các vấn đề khác nhau. MDSE tìm kiếm các giải
pháp theo các khía cạnh: khái niệm hóa (các cột trong hình) và thực hiện hóa (các hàng
trong hình).
Hình 1. 2. Tổng quan về phương pháp MDSE (quy trình từ trên xuống).
số hệ thống đang thực thi hiện tại hoặc trong tương lai. Do đó sẽ bao gồm việc xác định ba
khía cạnh cốt lõi.
•
•
Cấp độ mô hình (Model-level): nơi các mô hình được xác định.
Cấp độ hiện thực hóa (Realization-level): nơi các giải pháp được thực hiện
thông qua các mã nguồn thực sự được sử dụng trong hệ thống đang thực thi.
•
Cấp độ tự động hóa (Automation-level): nơi đặt các ánh xạ từ cấp độ mô
hình hóa đến cấp độ hiện thực hóa.
Vấn đề khái niệm hóa (conceptualization) được định hướng để xác định các mô hình
khái niệm để mô tả hệ thống một cách thực tế. Điều này có thể được áp dụng ở ba mức
chính sau đây:
6
• Mức ứng dụng: nơi mô hình của các ứng dụng được xác định, các quy tắc
chuyển đổi được thực hiện và các thành phần đang chạy thực tế được tạo ra.
• Mức miền ứng dụng: nơi xác định định nghĩa của ngôn ngữ mô hình hóa,
phép chuyển đổi và nền tảng triển khai cho một miền cụ thể.
• Mức meta-level: nơi xác định khái niệm về mô hình và các phép chuyển đổi.
Luồng cốt lõi của MDSE là từ các mô hình ứng dụng xuống quá trình chạy thực, thông
qua các chuyển đổi mô hình ở mức độ tiếp theo. Điều này cho phép tái sử dụng các mô hình
và thực thi hệ thống trên các nền tảng khác nhau. Ở cấp độ hiện thực, phần mềm đang chạy
dựa trên một nền tảng cụ thể (được xác định cho một miền ứng dụng cụ thể) để thực thi nó.
Để thực hiện điều này, các mô hình được chỉ định theo ngôn ngữ mô hình hóa, lần lượt
được xác định theo ngôn ngữ siêu mô hình hóa. Việc thực hiện chuyển đổi được xác định
dựa trên một tập hợp các quy tắc chuyển đổi, được xác định bằng cách sử dụng một ngôn
ngữ chuyển đổi cụ thể. Trong hình này, việc xây dựng hệ thống được kích hoạt bởi một quy
trình từ trên xuống từ các mô hình quy định nhằm xác định phạm vi bị giới hạn như thế nào
và mục tiêu nên được thực hiện như thế nào. Mặt khác, tính trừu tượng được sử dụng từ
dưới lên để tạo ra các mô hình mô tả của hệ thống.
1.1.3. Meta-model
Khi các mô hình đóng một vai trò quan trọng và phổ biến trong MDSE, một bước tiếp
theo để định nghĩa các mô hình là thể hiện bản thân chính các mô hình đó giống như là “các
thể hiện” của một số mô hình trừu tượng hơn. Do đó, giống hệt như cách chúng ta định
nghĩa một mô hình giống như một sự trừu tượng nào đó của các hiện tượng trong thế giới
làm nổi bật các thuộc tính của chính mô hình đó. Thực tế, meta-model về cơ bản cấu thành
định nghĩa của một ngôn ngữ mô hình hóa, vì chúng cung cấp cách mô tả toàn bộ lớp mô
hình có thể được biểu diễn bằng ngôn ngữ đó. Do đó, người ta có thể định nghĩa các mô
hình thực tế, và sau đó là các mô hình mô tả mô hình (gọi là meta-model). Một cách cụ thể,
một mô hình tuân theo meta-model của nó khi tất cả các phần tử của nó có thể được biểu
thị dưới dạng các thể hiện của các lớp meta-model.
7
Hình 1. 3. Mối quan hệ giữa conformsTo và instanceOf.
Hình 1.4 cho thấy một ví dụ về meta-model: các đối tượng trong thế giới thực được
hiển thị ở mức M0 (trong ví dụ này là một bộ phim), đại diện được mô hình hóa của chúng
được hiển thị ở cấp độ M1, nơi mô hình mô tả khái niệm Video với các thuộc tính. Meta-
model của mô hình này được hiển thị ở mức M2 và mô tả các khái niệm được sử dụng ở
M1 để xác định mô hình, đó là: Lớp (Class), Thuộc tính (Attribute) và Sự thể hiện
(Instance). Cuối cùng, cấp độ M3 xác định các khái niệm được sử dụng tại M2: tập hợp này
thu gọn trong khái niệm Lớp duy nhất. Rõ ràng là không cần thêm các cấp meta-model vượt
quá M3, vì chúng sẽ luôn chỉ bao gồm khái niệm Lớp.
Hình 1. 4. Sự phân cấp model, metamodel và meta-metamodel.
8
Meta-model có thể được sử dụng cho việc: xác định ngôn ngữ mới để mô hình hóa
hoặc lập trình, xác định ngôn ngữ mô hình hóa mới để trao đổi và lưu trữ thông tin, và cuối
cùng nhằm xác định các thuộc tính hoặc tính năng mới được liên kết với thông tin hiện có
(meta-data – siêu dữ liệu).
1.1.4. Unified Modeling Language
Phần này nhằm cung cấp một cái nhìn tổng quan về ngôn ngữ UML (Unified
và chấp nhận rộng rãi, UML như một ngôn ngữ khá thú vị để thảo luận về các tính năng và
khía cạnh được trình bày với các đặc điểm chung cho các ngôn ngữ mô hình hóa. Nhìn
chung UML là một bộ ngôn ngữ chính thức, vì nó bao gồm một tập hợp các biểu đồ khác
nhau để mô tả một hệ thống từ các khía cạnh khác nhau. Hình 1.5 là sự phân loại của biểu
đồ UML. Có 7 biểu đồ khác nhau có thể được sử dụng để mô tả các khía cạnh tĩnh (cấu
trúc) của hệ thống, trong khi 7 biểu đồ khác có thể được sử dụng để mô tả các khía cạnh
động (hành vi).
Hình 1. 5. Phâm loại biểu đồ UML.
Như thể hiện trong Hình 1.6 dưới đây, một số trong số các sơ đồ này mô tả đặc điểm
của các lớp (tức là các khái niệm trừu tượng), trong khi các sơ đồ khác được sử dụng để mô
tả các tính năng và hành vi của các mục riêng lẻ (tức là các cá thể). Một số sơ đồ có thể
được sử dụng để mô tả cả hai cấp độ.
9
Hình 1. 6. Phân tách giữa các mô hình dựa trên lớp.
Luận văn sẽ áp dụng một trong số những biểu đồ thể hiện bởi ngôn ngữ UML, nhằm
xác định meta-model cụ thể của một model.
1.1.5. Biểu đồ lớp
1.1.5.1. Định nghĩa
Biểu đồ lớp là một loại biểu đồ UML mô tả cấu trúc của một hệ thống theo các lớp,
thuộc tính của hệ thống đó và mối quan hệ giữa các lớp trong hệ thống. Biểu đồ lớp phổ
khung thiết kế tĩnh của hệ thống và các lớp trong hệ thống. Các lớp là đại diện cho các “đối
tượng” được xử lý trong hệ thống. Các lớp có thể quan hệ với nhau trong nhiều dạng thức:
•
•
•
Liên kết (associated): được nối kết với nhau.
Phụ thuộc (dependent): một lớp này phụ thuộc vào lớp khác.
Chuyên biệt hóa (specialized): một lớp này là một kết quả chuyên biệt hóa của
lớp khác.
• Đóng gói (packaged): hợp với nhau thành một đơn vị.
Tất cả các mối quan hệ đó đều được thể hiện trong biểu đồ lớp, đi kèm với cấu trúc
bên trong của các lớp theo khái niệm thuộc tính (attribute) và phương thức (operation).
Biểu đồ được coi là biểu đồ tĩnh theo phương diện cấu trúc được miêu tả ở đây có hiệu lực
tại bất kỳ thời điểm nào trong toàn bộ vòng đời hệ thống.
Một hệ thống thường sẽ có một loạt các biểu đồ lớp – không phải bao giờ tất cả các
biểu đồ lớp này cũng được nhập vào một biểu đồ lớp tổng thể duy nhất – và một lớp có thể
tham gia vào nhiều biểu đồ lớp.
10
Tải về để xem bản đầy đủ
71 trang
14480
Free
Bạn đang xem 20 trang mẫu của tài liệu "Luận văn Nghiên cứu kỹ thuật chuyển đổi mô hình sang văn bản và ứng dụng vào sinh mã nguồn Java", để tải tài liệu gốc về máy hãy click vào nút Download ở trên
File đính kèm:
- luan_van_nghien_cuu_ky_thuat_chuyen_doi_mo_hinh_sang_van_ban.pdf
