Luận văn Phương pháp sinh tự động bản mẫu giao diện người dùng từ đặc tả yêu cầu chức năng
ĐẠI HỌC QUỐC GIA HÀ NỘI
TRƯỜNG ĐẠI HỌC CÔNG NGHỆ
NGUYỄN MINH HẰNG
PHƯƠNG PHÁP SINH TỰ ĐỘNG BẢN MẪU GIAO DIỆN
NGƯỜI DÙNG TỪ ĐẶC TẢ YÊU CẦU CHỨC NĂNG
Ngành: Công nghệ thông tin
Chuyên ngành: Kỹ thuật phần mềm
Mã số: 8480103.01
LUẬN VĂN THẠC SĨ CÔNG NGHỆ THÔNG TIN
CÁN BỘ HƯỚNG DẪN: TS. ĐẶNG ĐỨC HẠNH
Hà Nội – 2020
i
TÓM TẮT
Tóm tắt: Giao diện người dùng (User Interface) rất quan trọng trong thời đại ứng
dụng web và di động ngày nay. Do đó, trong các giai đoạn đầu của Vòng đời phát triển
phần mềm (Software Development Life Cycle), việc phát triển giao diện người dùng
chính xác là vô cùng cần thiết. Để đạt được điều này, Nhóm Quản lý Đối tượng (Object
Management Group - OMG) đã giới thiệu tiêu chuẩn Ngôn ngữ mô hình hóa luồng tương
tác (Interaction Flow Modeling Language - IFML) vào năm 2013. IFML cung cấp mô
hình giao diện người dùng cho các ứng dụng đa dạng như thiết bị di động, web và máy
tính. Mặc dù IFML dựa trên nguyên tắc của kỹ nghệ hướng mô hình (Model Driven
Engineering - MDE), sự phát triển của các mô hình giao diện người dùng từ các yêu cầu
ban đầu là công việc phức tạp và tốn thời gian. Đặc biệt, nó đòi hỏi kiến thức chuyên môn
về miền và hiểu biết một số khái niệm của IFML như view container, view component,
event, ... Do đó, cách tiếp cận để tự động hóa việc phát triển bản mẫu giao diện người
dùng từ các đặc tả yêu cầu chức năng ban đầu là nhu cầu vô cùng cần thiết. Luận văn này
giới thiệu một phương pháp để tự động tạo các mô hình IFML từ các đặc tả yêu cầu chức
năng dạng văn bản bằng cách sử dụng các tính năng của xử lý ngôn ngữ tự nhiên (Natural
Language Processing - NLP). Sau đó, một tập các luật được áp dụng để trích xuất các
phần tử quan trọng của IFML như view container, view component, event, action ... từ
văn bản đầu vào. Từ đó, kết hợp các đặc tả yêu cầu văn bản cho sơ đồ lớp và sơ đồ ca sử
dụng để sinh ra json file biểu diễn mô hình IFML. Từ mô hình IFML có thể sinh tự động
bản mẫu giao diện người dùng mong muốn. Cuối cùng, các ví dụ đơn giản cũng được
trình bày trong luận văn nhằm đánh giá tính khả thi và tính hiệu quả của phương pháp.
Từ khóa: UI, IFML, NLP, MDE
ii
MỤC LỤC
LỜI CẢM ƠN.......................................................................................................................v
LỜI CAM ĐOAN................................................................................................................vi
DANH MỤC HÌNH ẢNH..................................................................................................vii
DANH MỤC BẢNG BIỂU.................................................................................................ix
CHƯƠNG 1. GIỚI THIỆU ..................................................................................................1
1.1. Đặt vấn đề ..................................................................................................................1
1.2. Mục tiêu và phương pháp...........................................................................................2
1.3. Bố cục luận văn..........................................................................................................2
CHƯƠNG 2. KIẾN THỨC NỀN TẢNG.............................................................................4
2.1. Giới thiệu....................................................................................................................4
2.2. Kỹ nghệ hướng mô hình (MDE)................................................................................4
2.2.1. Giới thiệu MDE ...................................................................................................4
2.2.2. Các cấp độ mô hình hóa.......................................................................................5
2.3. Mô hình hóa luồng tương tác (IFML)........................................................................6
2.3.1. Khái niệm.............................................................................................................6
2.3.2. Cú pháp và ngữ nghĩa của IFML.........................................................................7
2.3.3. Ví dụ minh họa mô hình IFML..........................................................................18
2.4. Đặc tả yêu cầu chức năng.........................................................................................18
2.4.2. Sơ đồ lớp dạng văn bản .....................................................................................20
2.4.3. Sơ đồ ca sử dụng dạng văn bản .........................................................................22
2.4. Thư viện xử lý ngôn ngữ tự nhiên OpenNLP ..........................................................24
2.5. Tổng kết chương ......................................................................................................25
CHỨC NĂNG ....................................................................................................................26
3.1. Giới thiệu..................................................................................................................26
3.2. Các luật chuyển đổi xác định thành phần cấu trúc IFML........................................26
iii
3.2.1. Luật chuyển đổi cho View Container................................................................27
3.2.2. Luật chuyển đổi cho View Component .............................................................28
3.2.3. Luật chuyển đổi cho Event ................................................................................30
3.2.4. Luật chuyển đổi cho Action...............................................................................32
3.5. Tổng kết chương ......................................................................................................35
CHƯƠNG 4. CÀI ĐẶT VÀ THỰC NGHIỆM..................................................................36
4.1. Giới thiệu..................................................................................................................36
4.2. Công cụ và môi trường hỗ trợ..................................................................................36
4.3. Nghiên cứu tình huống Quản lý sách.......................................................................36
4.4. Kết quả thực nghiệm ................................................................................................42
4.5. Đánh giá và thảo luận...............................................................................................42
4.6. Tổng kết chương ......................................................................................................43
5.1. Kết quả đạt được ......................................................................................................44
5.2. Hướng phát triển ......................................................................................................45
TÀI LIỆU THAM KHẢO..................................................................................................46
iv
LỜI CẢM ƠN
Trong suốt quá trình làm nghiên cứu, bên cạnh những nỗ lực của bản thân, tôi còn
nhận được sự hỗ trợ rất lớn từ phía nhà trường và giảng viên hướng dẫn, cũng như bạn bè
trong nhóm nghiên cứu.
Trước hết, tôi muốn gửi lời cảm ơn chân thành đến giảng viên hướng dẫn, Tiến Sĩ
Đặng Đức Hạnh - hiện đang công tác tại bộ môn Công Nghệ Phần Mềm, người đã tận tâm
hướng dẫn và chỉ dạy tôi để hoàn thành luận văn này. Tôi cũng xin cảm ơn sự hỗ trợ
của đề tài nghiên cứu khoa học mã số QG.20.54 của Đại học Quốc gia Hà Nội. Tôi
cũng xin gửi lời cảm ơn về phía nhà trường đã hỗ trợ tối đa về điều kiện vật chất và giúp
đỡ tôi trong quá trình nghiên cứu và thực hiện luận văn.
Cuối cùng, tôi muốn gửi lời cảm ơn đến các bạn trong lớp, những người đã động
viên, giúp đỡ tôi trong quá trình thực hiện luận văn.
Hà Nội, tháng 12 năm 2020
Học viên thực hiện
Nguyễn Minh Hằng
v
LỜI CAM ĐOAN
Tôi là Nguyễn Minh Hằng, học viên cao học khóa K24 - CNPM của Trường Đại học
Công nghệ - Đại học Quốc gia Hà Nội. Tôi xin cam đoan đây là công trình nghiên cứu
của tôi dưới sự giúp đỡ rất lớn của Giảng viên hướng dẫn là Tiến sĩ Đặng Đức Hạnh và
các bạn trong nhóm Nghiên cứu. Những nội dung nghiên cứu và kết quả trong đề tài này
là hoàn toàn trung thực. Các trích dẫn từ tài liệu bên ngoài tôi đều liệt kê rõ ràng ở cuối
của luận văn.
Hà Nội, tháng 12 năm 2020
Học viên thực hiện
Nguyễn Minh Hằng
vi
DANH MỤC HÌNH ẢNH
Hình 2.2. Metamodel của mô hình IFML.............................................................................7
Hình 2.3. Thành phần View Container Main. ......................................................................8
Hình 2.4. Giao diện được sinh ra từ View Container Main. ................................................8
Hình 2.5. Thành phần Details với điều kiện thuộc tính đơn giản.......................................10
Hình 2.7. Thành phần Multiple Details..............................................................................11
Hình 2.8. Giao diện cho thành phần Multiple Details........................................................11
Hình 2.9. Thành phần Simple List......................................................................................11
Hình 2.10. Giao diện của Simple List. ...............................................................................12
Hình 2.11. Thành phần List................................................................................................12
Hình 2.12. Giao diện cho thành phần List..........................................................................13
Hình 2.13. Thành phần Checkable List..............................................................................13
Hình 2.14. Giao diện của Checkable List...........................................................................13
Hình 2.15. Thành phần Form. ............................................................................................14
Hình 2.16. Giao diện của thành phần Form .......................................................................15
Hình 2.17. Thành phần phân cấp Hierarchies. ...................................................................15
Hình 2.18. Giao diện hệ thống phân cấp Hierarchies.........................................................16
Hình 2.19. Action chuyển đổi dữ liệu từ Form sang List...................................................17
Hình 2.21. Mô hình IFML mô tả chương trình quản lý Book............................................18
Hình 2.22. Sơ đồ lớp là một loại sơ đồ UML cấu trúc tĩnh................................................20
Hình 2.24. Sơ đồ lớp Book Store Online biểu diễn dạng văn bản. ....................................22
Hình 2.25. Sơ đồ ca sử dụng là một loại sơ đồ UML hành vi............................................22
Hình 2.26. Các thành phần của sơ đồ ca sử dụng...............................................................23
Hình 2.28. Sơ đồ ca sử dụng biểu diễn dưới dạng văn bản................................................24
Hình 3.1. Sơ đồ mô tả phương pháp sinh giao diện người dùng........................................26
Hình 3.9. Các luật chuyển đổi cho View Container...........................................................27
Hình 3.10. Các luật chuyển đổi cho View Component......................................................29
Hình 3.11. Các luật chuyển đổi cho thành phần Event. .....................................................30
Hình 3.12. Các luật chuyển đổi cho Action. ......................................................................32
đổi. ......................................................................................................................................33
Hình 3.15. Một element của mô hình IFML trong json file..............................................33
vii
CHƯƠNG 1. GIỚI THIỆU
1.1. Đặt vấn đề
Giao diện người dùng (User Interface - UI) là một phần rất quan trọng trong các ứng
dụng web và di động ngày nay. Các ứng dụng này ngày càng có các giao diện đa dạng và
phức tạp nên việc phát triển giao diện người dùng trong giai đoạn đầu của vòng đời phát
triển phần mềm (Software Development Life Cycle - SDLC) vô cùng tốn kém công sức
và thời gian. Người ta ước tính rằng việc phát triển một ứng dụng yêu cầu 48% code được
áp dụng trên các giao diện người dùng và 50% thời gian phát triển được dành cho việc
biểu diễn các giao diện người dùng [1]. Do đó, quá trình phát triển từ các yêu cầu đến
thiết kế đã làm dấy lên những lo ngại liên quan đến việc tăng cường tiêu thụ nguồn lực và
thời gian.
Kỹ nghệ hướng mô hình (Model Driven Engineering - MDE) có xu hướng đơn giản
hóa kiến trúc của hệ thống bằng cách giới thiệu các mô hình cung cấp các mức độ trừu
tượng khác nhau. Theo MDE, các lớp trừu tượng khác nhau sử dụng các mô hình khác
nhau để xác định một hệ thống. Do đó, một phép biến đổi mô hình tự động được phát
triển để lấy lớp trừu tượng thấp hơn từ lớp trừu tượng cao hơn [2]. Điều này dẫn đến việc
tách biệt các phức tạp của lập trình khỏi nền tảng thực thi. Hơn nữa, năng suất được tăng
lên và việc tái sử dụng thiết kế hệ thống cũng được đảm bảo và việc duy trì khả năng truy
xuất nguồn gốc, tính đầy đủ và nhất quán cũng đạt được. Do những lợi ích của MDE đã
nói ở trên, ngày nay nó thường được áp dụng để phát triển các giao diện người dùng.
Cho đến năm 2013, chưa có tiêu chuẩn MDE nào có sẵn để áp dụng các khái niệm
về mô hình trừu tượng cho giao diện người dùng ngoại trừ ngôn ngữ mô hình hóa web
WebML[3] và nó chỉ dành cho các ứng dụng web. Để giải quyết vấn đề này, ngôn ngữ
mô hình hóa luồng tương tác (IFML) đã được OMG giới thiệu vào tháng 3 năm 2013 [4].
Đặc biệt, IFML dựa trên các khái niệm WebML và cung cấp mô hình hóa các giao diện
người dùng tinh vi cho các ứng dụng khác nhau như di động, web. Nó là một ngôn ngữ
mô hình hóa độc lập nền tảng do đó được triển khai ở cấp Mô hình Độc lập Nền tảng
(Platform Independent Model - PIM). Nó cho phép nắm bắt tương tác của người dùng, nội
dung của các giao diện người dùng front-end và lập mô hình hành vi kiểm soát của các
giao diện người dùng của hệ thống chủ thể [5].
Trong Vòng đời phát triển phần mềm (SDLC), phân tích yêu cầu là một giai đoạn
quan trọng. Các yêu cầu được phân tích ban đầu đóng vai trò là đầu vào cho các giai đoạn
SDLC tiếp theo. Thông thường, các yêu cầu được đưa ra từ người dùng bằng ngôn ngữ tự
nhiên vì nó thúc đẩy quyền tự do ngôn luận. Tuy nhiên, nó cũng tạo ra nhiều vấn đề cho
các bên liên quan khác nhau do tính chất dễ mắc lỗi và không rõ ràng vì các yêu cầu được
1
viết bằng ngôn ngữ tự nhiên thuần túy có thể được diễn giải theo nhiều cách khác nhau
[6]. Để quản lý các vấn đề như vậy, các mô hình hoặc bản mẫu khác nhau được phát triển
để thực hiện xác nhận ban đầu của các yêu cầu. IFML đang cho thấy các tính năng đầy
hứa hẹn để phát triển các mô hình/bản mẫu giao diện người dùng ban đầu từ các yêu cầu.
Điều này dẫn đến việc thực hiện xác nhận các yêu cầu chính trong giai đoạn đầu.
Hơn nữa, nó cũng giảm thời gian phát triển vì các mô hình IFML đã tạo có thể được sử
dụng trong các giai đoạn SDLC tiếp theo bằng cách áp dụng các phép chuyển đổi mô
hình. Mặc dù IFML dựa trên nguyên tắc MDE, việc phát triển các mô hình giao diện
người dùng từ các yêu cầu ban đầu vẫn là công việc phức tạp và tốn thời gian. Đặc biệt,
nó đòi hỏi kiến thức chuyên môn về miền để hiểu một số khái niệm IFML như mô hình
miền, view container, event, ... để có thể mô hình hóa giao diện người dùng phù hợp. Do
đó, có một yêu cầu mạnh mẽ về cách tiếp cận để tự động hóa việc phát triển các mô hình
IFML từ các yêu cầu văn bản thuần túy ban đầu. Điều này có thể đạt được bằng cách sử
dụng các tính năng của xử lý ngôn ngữ tự nhiên.
Luận văn này cung cấp một phương pháp sinh tự động bản mẫu giao diện người
dùng từ đặc tả yêu cầu chức năng thông qua mô hình hóa luồng tương tác IFML.
1.2. Mục tiêu và phương pháp
Luận văn đưa ra mục tiêu xây dựng một phương pháp sinh tự động bản mẫu giao
diện người dùng từ các đặc tả yêu cầu ban đầu dựa trên kỹ thuật mô hình hóa nhằm tách
biệt các phức tạp của lập trình khỏi nền tảng thực thi, và tăng hiệu suất phát triển nhờ việc
tái sử dụng thiết kế hệ thống.
Đầu tiên, luận văn áp dụng việc xử lý ngôn ngữ tự nhiên và các luật chuyển đổi để
sinh tự động các thành phần của mô hình IFML từ đặc tả yêu cầu được viết bằng ngôn
ngữ tự nhiên. Tiếp theo, kết hợp các thành phần IFML với các đặc tả yêu cầu chức năng
mô hình ca sử dụng và mô hình lớp dạng văn bản để sinh ra json file biểu diễn mô hình
IFML. Từ đó, sử dụng công cụ IFML Editor để sinh tự động bản mẫu giao diện người
dùng từ mô hình IFML. Cuối cùng, các ví dụ đơn giản mô phỏng phương pháp sinh bản
mẫu giao diện người dùng được trình bày.
1.3. Bố cục luận văn
• Chương 1: Giới thiệu, trình bày vấn đề nghiên cứu, mục tiêu và phương pháp sử
dụng
2
• Chương 2: Kiến thức nền tảng, trình bày các cơ sở lý thuyết về mô hình IFML và
thư viện xử lý ngôn ngữ tự nhiên OpenNPL được áp dụng để sinh bản mẫu giao
diện.
• Chương 3: Trình bày phương pháp sinh tự động bản mẫu giao diện người dùng từ
đặc tả yêu cầu chức năng.
• Chương 4: Đưa ra ví dụ minh họa để đánh giá tính khả thi của phương pháp.
• Chương 5: Tóm tắt những kết quả đạt được, các hạn chế còn tồn tại và hướng phát
triển trong tương lai.
3
CHƯƠNG 2. KIẾN THỨC NỀN TẢNG
Để có thể áp dụng phương pháp sinh tự động bản mẫu giao diện người dùng từ đặc
tả yêu cầu chức năng, luận văn cần tìm hiểu các kiến thức nền tảng về kỹ nghệ hướng mô
hình MDE, mô hình hóa luồng tương tác IFML, các đặc tả yêu cầu chức năng và thư viện
xử lý ngôn ngữ tự nhiên OpenNLP.
2.1. Giới thiệu
Chương này trình bày các cơ sở lý thuyết về các kỹ thuật, ngôn ngữ và công cụ hỗ
trợ được sử dụng trong luận văn. Phần đầu chương, luận văn tìm hiểu về kỹ nghệ hướng
mô hình MDE, trình bày các khái niệm và các cấp độ mô hình hóa của nó. Tiếp theo, luận
văn trình bày lý thuyết về ngôn ngữ mô hình hóa luồng tương tác IFML bao gồm khái
niệm và các thành phần chính của IFML. Sau đó, luận văn nêu ra các kiến thức nền tảng
về các đặc tả yêu cầu chức năng như đặc tả yêu cầu bằng ngôn ngữ tự nhiên, đặc tả ca sử
dụng và đặc tả sơ đồ lớp dạng văn bản. Phần cuối sẽ tìm hiểu về thư viện xử lý ngôn ngữ
tự nhiên OpenNLP nhằm hỗ trợ quá trình xử lý đặc tả yêu cầu.
2.2. Kỹ nghệ hướng mô hình (MDE)
Mô hình có vai trò quan trọng trong việc hiểu và chia sẻ kiến thức về các phần mềm
phức tạp. Kỹ nghệ hướng mô hình (Model-Driven Engineering MDE) được hình thành
như một phương pháp để chuyển đổi mô hình trong công nghệ phần mềm.
2.2.1. Giới thiệu MDE
Kỹ nghệ hướng mô hình (MDE) có thể được định nghĩa là một phương pháp luận để
áp dụng các lợi thế của mô hình hóa vào các hoạt động kỹ thuật phần mềm [7]. Mục đích
của các mô hình có thể trải dài từ giao tiếp giữa mọi người tới khả năng thực thi của phần
mềm được thiết kế: cách thức mà các mô hình được xác định và quản lý sẽ dựa trên nhu
cầu thực tế mà nó sẽ giải quyết. Do các nhu cầu có thể khác nhau mà MDE giải quyết, vai
trò của MDE trở thành xác định các phương pháp tiếp cận kỹ thuật đối với định nghĩa về
mô hình, biến đổi và kết hợp chúng trong quy trình phát triển phần mềm.
Theo phương trình nổi tiếng về chương trình phần mềm của Niklaus Wirth:
Thuật toán + Cấu trúc dữ liệu = Chương trình [7]
Trong ngữ cảnh MDE mới, phương trình trở lên đơn giản hơn:
Mô hình + Phép chuyển đổi = Phần mềm [7]
Cả mô hình và các phép chuyển đổi cần được thể hiện trong một dạng ký hiệu hoặc
ngôn ngữ nào đó, trong MDE, nó được 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 định nghĩa trong
4
một số ngôn ngữ lập trình. Tuy nhiên, phương trình này không cho biết được loại mô hình
nào (theo thứ tự nào, ở mức trừu tượng nào, v.v.) được xác định. Do đó cần có một bộ
công cụ thích hợp để làm cho MDE khả thi trong thực tế. Đối với chương trình, cần có
các IDE cho phép xác định các mô hình và các phép biến đổi cũng như các trình biên dịch
hoặc trình thông dịch để thực thi chúng và tạo ra các tạo phẩm phần mềm cuối cùng.
MDE rất coi trọng tuyên bố “mọi thứ đều là một mô hình”. Thực tế, trong bối cảnh
này, người ta có thể nghĩ ngay đến tất cả các thành phần được mô tả ở trên là một thứ có
mô hình hóa được. Cụ thể, có thể thấy các phép biến đổi là các mô hình hoạt động cụ thể
dựa trên các mô hình. Định nghĩa của một ngôn ngữ mô hình hóa có thể được xem như là
một mô hình: MDE gọi thủ tục này là siêu mô hình (memtamodel) (nghĩa là mô hình hóa
một mô hình, hoặc mô hình hóa một ngôn ngữ mô hình hóa, hoặc mô hình hóa tất cả các
mô hình có thể được biểu diễn bằng ngôn ngữ). Theo cách này, có thể định nghĩa là các
mô hình cũng là các quy trình, công cụ phát triển và các chương trình kết quả. [14]
2.2.2. Các cấp độ mô hình hóa
Mức độ trừu tượng của các mô hình có thể thay đổi tùy thuộc vào mục tiêu của các
mô hình. Có ba mức trừu tượng khác nhau được đưa ra cho các mô hình trong MDE [7],
được chỉ ra trong Hình 2.1.
• Mô hình độc lập tính toán (Computation-Independent Model-CIM): cấp độ
trừu tượng nhất. Đại diện cho bối cảnh, yêu cầu và mục đích của giải pháp mà
không có bất kỳ ràng buộc nào đối với việc tính toán. Nó trình bày chính xác
những gì giải pháp dự kiến sẽ làm, nhưng ẩn các thông số kỹ thuật công nghệ
thông tin, để độc lập với việc hệ thống sẽ được thực hiện như thế nào.
• Mô hình độc lập với nền tảng (Platform-Independent Mode - PIM): Cấp độ
mô tả hành vi và cấu trúc của ứng dụng, mà không phụ thuộc nền tảng triển
khai. Lưu ý rằng PIM chỉ dành cho một phần của CIM mà được giải quyết bằng
giải pháp dựa trên phần mềm và tinh chỉnh nó theo các yêu cầu đối với hệ thống
phần mềm. PIM thể hiện một mức độ độc lập đủ để cho phép ánh xạ của nó tới
một hoặc nhiều nền tảng triển khai cụ thể.
• Mô hình dành riêng cho nền tảng (Platform-Specific Mode-PSM): mô hình
chứa tất cả thông tin bắt buộc liên quan đến hành vi và cấu trúc của một ứng
dụng trên một nền tảng cụ thể mà các nhà phát triển có thể sử dụng để triển khai
mã thực thi.
5
Hình 2.1. Ba mức độ trừu tượng của mô hình hóa trong MDA [7].
2.3. Mô hình hóa luồng tương tác (IFML)
Mục này tập trung tìm hiểu ngôn ngữ mô hình hóa luồng tương tác IFML bao gồm
khái niệm, tính chất và vai trò của nó trong quá trình thiết kế giao diện. Đồng thời, cú
pháp và ngữ nghĩa của các thành phần cấu trúc của IMFL cũng được trình bày.
2.3.1. Khái niệm
Thiết kế bậc giao diện của một hệ thống về cơ bản phụ thuộc vào các ca sử dụng chi
tiết hoặc sơ đồ trình tự hệ thống, vì giao diện phải cho phép người dùng theo dõi tất cả các
luồng ca sử dụng. Thiết kế sơ đồ lớp và hợp đồng cũng có thể rất hữu ích. Trong quá trình
thiết kế giao diện, các yêu cầu phi chức năng đã được chú thích với các ca sử dụng phải
được sửa đổi lại, vì chúng có thể chứa các chỉ dẫn về cách thiết kế giao diện ca sử dụng.
Ngôn ngữ mô hình hóa luồng tương tác (IFML) là một phần mở rộng của UML cho
các giao diện người dùng chuyên sâu về dữ liệu của mô hình. Nó là một sự phát triển của
WebML (Ceri, Fraternali, Bongio, Brambilla, Comai và Matera, 2003). IFML đang được
chấp nhận như một tiêu chuẩn OMG.
IFML nhằm mục đích mô tả hành vi và cấu trúc của ứng dụng theo quan điểm của
người dùng [15]. Tuy nhiên, mô tả hành vi và cấu trúc của ứng dụng trong ngữ cảnh logic
nghiệp vụ và thành phần dữ liệu bị giới hạn ảnh hưởng trực tiếp đến trải nghiệm người
dùng [15]. IFML hỗ trợ việc tích hợp với các mô hình khác để chỉ rõ các tính năng của
ứng dụng một cách hoàn chỉnh.
6
IFML là một ngôn ngữ mô hình hóa độc lập nền tảng do đó được triển khai ở cấp độ
mô hình độc lập nền tảng (PIM) để thể hiện các quyết định thiết kế tương tác độc lập với
nền tảng triển khai. Nó cho phép nắm bắt tương tác của người dùng, nội dung của các
giao diện người dùng front-end và mô hình hóa hành vi kiểm soát của các giao diện người
dùng của hệ thống. [8]
2.3.2. Cú pháp và ngữ nghĩa của IFML
Ngôn ngữ mô hình luồng tương tác bao gồm một số các thành phần để mô hình hóa
các yêu cầu giao diện người dùng. Hình 2.2 bên dưới trình bày một metamodel của IFML,
nó thể hiện các thành phần cấu trúc của mô hình IFML và mối quan hệ giữa các thành
phần này.
Hình 2.2. Metamodel của mô hình IFML
Các phần tử IFML quan trọng được tập trung tìm hiểu và nghiên cứu trong luận văn
là: View Container, View Component, Event và Action.
2.3.2.1. Thành phần View Container
View Container là một trong những phần tử dạng View Elements của mô hình
IFML, phần có thể nhìn thấy ở cấp giao diện người dùng. Một số thuộc tính của View
Containner là:
• Mô hình IFML bao gồm một hoặc nhiều View Container, được sử dụng để thể
hiện các web page trong trường hợp ứng dụng web hay window trong ứng dụng
máy tính để bàn.
• View Container biểu diễn nội dung của giao diện. Giống như các trang html, nó
có thể chứa một hoặc nhiều thành phần View Component như form, detail hoặc
list.
7
Ví dụ về Book Store Online được đưa ra trong chương này để minh họa các thành
phần của mô hình IFML. Hình 2.3 biểu diễn một View Container Main của giao diện ứng
dụng Book Store chứa 2 phần tử View Component là list of publishers and list of books.
Và Hình 2.4 thể hiện giao diện tương ứng được sinh ra từ mô hình của View Container
Main.
Hình 2.3. Thành phần View Container Main.
Hình 2.4. Giao diện được sinh ra từ View Container Main.
2.3.2.2. Thành phần View Component
View Component là thành phần dạng View Elements cơ bản nhất trong đặc tả
IFML. Một View Component không bao giờ có thể tồn tại bên ngoài View Container.
View Component bao gồm nhiều loại khác nhau như:
• Details: Hiển thị thông tin về một đối tượng duy nhất.
• Multiple Details: Hiển thị thông tin về tập hợp các thực thể (instances) của cùng
một lớp.
8
• Simple List: Hiển thị nhiều thực thể của một lớp dưới dạng danh sách.
• List: Một cải tiến của Simple List cho phép cuộn và sắp xếp động.
• Checkable list: Danh sách cho phép nhiều lựa chọn.
• Hierarchy: Hiển thị nhiều thực thể của các lớp khác nhau được tổ chức theo hệ
thống phân cấp, ví dụ như chi tiết tổng thể hoặc toàn bộ.
• Recursive hierarchy: Hiển thị nhiều thực thể của một lớp đơn lẻ được tổ chức
phân cấp.
• Scroller: Cho phép thực hiện các thao tác cuộn trên một chuỗi các đối tượng.
• Form: Cho phép nhập dữ liệu dựa trên biểu mẫu.
IFML vẫn còn nhiều hơn các thành phần khác nữa nhưng chương này chỉ tập trung
trình bày các thành phần cơ bản nhất. Mỗi loại thành phần View Component sẽ có một
định nghĩa đồ họa tương ứng thể hiện nó.
Details: Trình bày thông tin về một đối tượng duy nhất của một lớp nhất định. Nó
được xác định bởi các thuộc tính sau:
• Tên: được chọn người thiết kế mô hình
• Thực thể: một lớp trong sơ đồ lớp
• Thuộc tính hiển thị: là danh sách các thuộc tính của lớp sẽ được hiển thị
Thành phần Details phép định nghĩa một hoặc nhiều biểu thức điều kiện hoạt động
như bộ lọc trên tập hợp các thực thể được hiển thị. Có ba loại biểu thức điều kiện:
• Điều kiện khóa (Key condition): Mỗi đối tượng trong mô hình dữ liệu được
xác định bởi một định danh của đối tượng OID (Object IDentifier) - một thuộc
tính là duy nhất, bắt buộc và bất biến. OID là mã được tạo bên trong tương ứng
với khóa chính của một đối tượng. Người dùng không thể biết hoặc cập nhật
OID. Điều kiện khóa cho phép người ta chọn một hoặc nhiều thực thể từ một
lớp nhất định dựa trên giá trị của thuộc tính OID của nó.
• Điều kiện thuộc tính (Attribute condition): Điều kiện cho phép lựa chọn một
hoặc nhiều thực thể dựa trên các giá trị của thuộc tính của chúng. Các phép
toán như lớn hơn, bằng hoặc bao gồm có thể được sử dụng để so sánh giá trị
của một thuộc tính với một tham số nhất định.
• Điều kiện vai trò quan hệ (Relationship role condition) : Điều kiện cho phép
lựa chọn một hoặc nhiều thể hiện dựa trên các liên kết của chúng.
Hình 2.5 trình bày một thành phần Details nhằm hiển thị dữ liệu về một bản sao của
sách cho một mã sách tiêu chuẩn quốc tế ISBN (International Standard Book Number)
9
nhất định. Biểu thức điều kiện isbn = 0517149257 xác định thực thể nào được hiển thị.
Nếu một thực thể như vậy không tồn tại, thì không có thông tin nào được hiển thị bởi
thành phần đó.
Hình 2.5. Thành phần Details với điều kiện thuộc tính đơn giản.
Hình 2.6 bên dưới biểu diễn giao diện tương ứng của thành phần Details mô tả trong
Hình 2.5.
Hình 2.6. Giao diện tương ứng cho thành phần Details với các thuộc tính của lớp Book.
Multiple Details: trình bày một nhóm các thực thể của một lớp cùng một lúc. Bên
cạnh ba thuộc tính đã nêu trên của thành phần Details, Multiple Details còn bao gồm thêm
các thuộc tính tùy chọn mới:
• Sắp xếp thuộc tính (Sort attributes): Xác định các thuộc tính được sử dụng để
sắp xếp các thực thể.
• Kết quả tối đa (Max results): Chỉ định số lượng thực thể tối đa được truy
xuất. Theo mặc định, tất cả các thực thể đều được truy xuất.
• Phân biệt (Distinct): Chỉ định rằng các phần tử trùng lặp sẽ không được hiển
thị nhiều lần
Multipel Details cũng cho phép định nghĩa và sử dụng các biểu thức điều kiện để
chọn các phần tử sẽ được hiển thị. Hình 2.7 trình bày một ví dụ về MultiPle Details.
10
Tải về để xem bản đầy đủ
57 trang
13540
Free
Bạn đang xem 20 trang mẫu của tài liệu "Luận văn Phương pháp sinh tự động bản mẫu giao diện người dùng từ đặc tả yêu cầu chức năng", để 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_phuong_phap_sinh_tu_dong_ban_mau_giao_dien_nguoi_du.pdf
