ĐẠI HỌC QUỐC GIA HÀ NỘI
TRƢỜNG ĐẠI HỌC CÔNG NGHỆ
LÊ HỒNG HÀ
ÁP DỤNG OSGi TRONG VIỆC XÂY DỰNG HỆ THỐNG
DỰA THÀNH PHẦN
LUẬN VĂN THẠC SĨ CÔNG NGHỆ THÔNG TIN
Hà Nội - 2014
ĐẠI HỌC QUỐC GIA HÀ NỘI
TRƢỜNG ĐẠI HỌC CÔNG NGHỆ
LÊ HỒNG HÀ
ÁP DỤNG OSGi TRONG VIỆC XÂY DỰNG HỆ THỐNG
DỰA THÀNH PHẦN
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.TRẦN THỊ MINH CHÂU
Hà Nội - 2014
i
LỜI CAM ĐOAN
Tôi xin cam đoan rằng, luận văn thạc sĩ công nghệ thông tin “Áp dụng OSGi
trong việc xây dựng hệ thống dựa thành phần” là sản phẩm nghiên cứu của riêng cá
nhân tôi dưới sự giúp đỡ rất lớn của giảng viên hướng dẫn là TS. Trần Thị Minh Châu,
tôi không sao chép lại của người khác. Nhữngđiềuđã được trình bày trong toàn bộ nội
dung của luận văn này hoặc là của chính cá nhân tôi, hoặc là được tổng hợp từ nhiều
nguồn tài liệu. Tất cả các tài liệu tham khảo đều có nguồn gốc rõ ràng và được trích
dẫn hợp pháp.
Tôi xin hoàn toàn chịu trách nhiệm và chịu mọi hình thức kỷ luật theo quy định
cho lời cam đoan của mình.
Hà nội, ngày 26 tháng 10 năm 2014
Người cam đoan
Lê Hồng Hà
ii
LỜI CẢM ƠN
Trước tiên, tôi xin bày tỏ lòng biếtơn chân thành và sâu sắc đến cô giáo, TS.
Trần Thị Minh Châu - ngườiđã dành nhiều tâm huyết, tận tình chỉ bảo và giúp đỡ tôi
trong suốt quá trình kể từ khi tôi xin cô hướng dẫn đề tài, cho đến khi tôi hoàn
thànhluận văn này.
Tôi xin gửi lời cảmơn chân thành tới các thầy cô giáo khoa Công nghệ thông
tin, trườngĐại học Công nghệ, Đại học Quốc Gia Hà Nội- nơi tôi đã theo họctừ bậc đại
học cho đến nay. Các thầy cô đã cung cấp cho tôi những kiến thức quý báu, tạođiều
kiện tốt nhất cho tôi trong suốt quá trình học tập và nghiên cứu tại trường.
Cuối cùng, tôi xin chân thành cảmơn những người thân trong gia đình, đặc biệt
là bố mẹ tôiđãluôn động viên vàủng hộ tôi. Xin cảmơn bạn bè cùng khóađãgiúp đỡ tôi
trong quá trình học tập.
iii
MỤC LỤC
GIỚI THIỆU ....................................................................................................................1
1.1. Giới thiệu hệ thống dựa thành phần ......................................................................3
1.2. Kiến trúc phần mềm dựa thành phần ....................................................................4
1.3. Đặc tính của thành phần phần mềm ......................................................................5
1.4. Một số mô hình thành phần hiện tại ......................................................................6
2.1. OSGi framework .................................................................................................10
2.1.1. Tổng quan về OSGi ......................................................................................10
2.1.2. Lớp Module ..................................................................................................12
2.1.3. Lớp Lifecycle ................................................................................................ 23
2.1.4. Lớp Service ...................................................................................................28
2.2. OSGi trong phát triển phần mềm dựa thành phần .............................................33
2.2.1. Mô hình thành phần ......................................................................................33
2.2.2. Mô hình thành phần trong OSGi ..................................................................33
Chương 3. ÁP DỤNG XÂY DỰNG ỨNG DỤNG BÁN HÀNG TRỰC TUYẾN ......38
3.1. Phân tích kiến trúc và lựa chọn các công nghệ ...................................................40
3.1.1. Kiến trúc phân tầng và dựa thành phần ........................................................42
3.1.2. Áp dụng kiến trúc phân tầng và dựa thành phần vào ứng dụng ...................43
3.2. Phát triển ứng dụng .............................................................................................51
3.2.1. Biên dịch ứng dụng với Bndtool...................................................................51
3.2.2. Triển khai ứng dụng với Apache Felix .........................................................52
3.2.3. Các chức năng của ứng dụng ........................................................................53
3.3. Đánh giá so với việc phát triển hệ thống với phương pháp truyền thống ...........61
4.1. Các kết quả đạt được ...........................................................................................67
4.2. Định hướng nghiên cứu trong tương lai ..............................................................68
PHỤ LỤC 1 ...................................................................................................................71
PHỤ LỤC 2 ...................................................................................................................72
iv
BẢNG CÁC KÝ HIỆU VÀ CHỮ VIẾT TẮT
STT
Ký hiệu
Diễn giải
Tiếng Việt
Application Programming Interface
Component Implementation
Definition Language
Component Implementation
Framework
1
API
2
CIDL
3
CIF
4
COM
Component Object Model
5
CORBA
Common Object Request Broker
Architecture
6
DS
Declarative Services
7
EJB
Enterprise JavaBeans
8
GPS
9
IDE
Global Positioning System
Integrated Development
Environment
10
IDL
Interface Defination Language
11
JMS
Java Message Service
Giao diện lập trình ứng dụng
Ngôn ngữ định nghĩa cài đặt
thành phần
Framework cài đặt thành
phần
Mô hình đối tượng thành
phần
Kiến trúc chung gian yêu
cầu đối tượng chung
Một trong những mô hình
thành phần để khai báo và
sử dụng dịch vụ trong OSGi
Mô hình thành phần dùng
cho phát triển ứng dụng
doanh nghiệp với Java
Hệ thống định vị toàn cầu
Môi trường phát triển tích
hợp
Ngôn ngữ định nghĩa giao
diện
Dịch vụ truyền tin trongJava
12
JRE
Java Runtime Environment
Môi trường chạy Java
13
JVM
Java Virtual Machine
14
REST
Representational State Transfer
15
SCA
Service Component Architechture
16
SCR
Service Component Runtime
17
SOA
Service-Oriented Architecture
18
SOAP
Simple Object Access Protocol
Máy ảo Java
Một phong cách kiến trúc
cho hệ thống mạng. Ứng
dụng phổ biến là cho dịch
vụ Web
Kiến trúc thành phần dịch
vụ
Môi trường chạy thành phần
dịch vụ
Kiến trúc hướng dịch vụ
Giao thức truy cập đối
tượng đơn giản
v
DANH MỤC HÌNH VẼ
STT
Số hiệu
Tên hình vẽ
1
1.1
Phát triển hệ thống phần mềm dựa thành phần
2
1.2
Kiến trúc hệ thống dựa thành phần
3
1.3
Ví dụ hệ thống dựa thành phần
4
1.4
Sự kết hợp có thể giữa client cũ và mới và các thành phần của nó
5
2.1
6
2.2
7
2.3
8
2.4
9
2.5
Kiến trúc OSGi
Một module định nghĩa phạm vi logic. Module tự nó cũng tường
minh chỉ định lớp nào được đóng gói bên trong, lớp nào được hiện
diện ra bên ngoài
Các lớp có phụ thuộc tường minh vì các tham chiếu trong mã
nguồn. Các module có phụ thuộc ngầm định vì mã nguồn chúng
bao gồm
Mặc dù hướng đối tượng và tính module đều cung cấp những khả
năng như nhau nhưng ở các cấp độ khác nhau
Cấu trúc của bundle
10
2.6
11
2.7
12
2.8
13
2.9
14
2.10
Classloader trong OSGi
Chuỗi Classloader, nếu một Classloader không thể nạp một lớp nó
sẽ chuyển cho Classloader tiếp theo
Khả năng thay thế
Một bundle fragment được gắn với một bundle chủ của nó và cùng
chia sẻ một Classloader
Cấu trúc đánh phên bản
15
2.11
Các phụ thuộc của phụ thuộc có thể có các phiên bản không tương
thích. OSGi cho phép cùng tồn tại bằng cách cô lập chúng với cái
kia
16
2.12
Class Path trong Java và quản lý vòng đời trong OSGi framework
17
2.13
Vòng đời của bundle trong OSGi
18
2.14
19
2.15
20
2.16
Các lệnh OSGi tương ứng với các thao tác khi triển khai ứng dụng
Một dịch vụ được cung cấp bởi một bundle và được sử dụng bởi
một bundle khác. Hình tam giác có đỉnh trỏ về bên cung cấp dịch
vụ
Một service consumer có thể sử dụng nhiều instance của một dịch
vụ
21
3.1
Đối tượng người dùng và chức năng của hệ thốngđặt hàng
22
3.2
Các bước xử lý khi khách hàng đặt hàng
vi
23
3.3
Kiến trúc và các thành phần công nghệ trong ứng dụng
24
3.4
Kiến trúc ba tầng
25
3.5
Phụ thuộc vòng
26
3.6
Chia các tầng thành các thành phần nhỏ hơn
27
3.7
Các tầng trong ứng dụng
28
3.8
Các thành phần trong ứng dụng
29
3.9
Các thành phần và giao tiếp giữa chúng
30
3.10
Cấu trúc bundle chipshop.admin.general.ui trong Bnd project
31
3.11
32
3.12
33
3.13
Cấu trúc bundle chipshop.admin.general.ui sau khi build
Tương tác giữa các bundle liên quan đến sản phẩm thông qua dịch
vụ
Các bundle xử lý đơn hàng
34
3.14
Các bundle của toàn bộ ứng dụng
35
3.15
Phát triển ứng dụng với Bndtool
36
3.16
Chạy ứng dụng trực tiếp trong Eclipse
37
3.17
Kết quả chạy unit test
38
3.18
Danh sách và trạng thái các bundle
39
3.19
Danh sách sản phẩm trên frontend
40
3.20
Xem thông tin trong giỏ hàng
41
3.21
Đăng ký và đăng nhập
42
3.22
Đặt hàng
43
3.23
Đặt hàng thành công
44
3.24
Xem lại đơn hàng đã đặt
45
3.25
Đăng nhập vào trang quản trị
46
3.26
Xem thông tin và sửa sản phẩm
47
3.27
Thêm sản phẩm, danh mục hoặc xóa danh mục
48
3.28
Sản phẩm mới tạo trên backend
49
3.29
Sản phẩm mới tạo trên frontend
50
3.30
51
3.31
52
3.32
53
3.33
Xem và cập nhật trạng thái các đơn hàng
Các bundle cung cấp chương trình khuyến mại sau khi được triển
khai
Thực đơn khuyến mại tự động xuất hiện sau khi các bundle được
triển khai
Thông tin khuyến mại
vii
54
3.34
55
3.35
56
3.36
57
3.37
58
3.38
Dừng bundle chipshop.discounts.mongo
Bundle chipshop.discounts.mongo chuyển sang trạng thái
Resolved
Thực đơn “khuyến mại” biến mất sau khi bundle
chipshop.discounts.mongo bị dừng
Các thành phần liên quan đến khuyến mại có thể được triển độc lập
và động
Các bundle không thể chuyển sang trạng thái Active khi các phụ
thuộc và ràng buộc chưa được thỏa mãn
1
GIỚI THIỆU
Các hệ thống phần mềm ngày càng trở nên phức tạp, cùng với nhu cầu phát triển
nhanh và cập nhật thường xuyên, từ đó tạo ra nhu cầu cần một kiến trúc để đáp ứng
được những nhiệm vụ khó khăn này. Kiến trúc dựa thành phần là một giải pháp, đặc
tính cơ bản của kiến trúc dựa thành phần là chia mã nguồn thành những thành phần
nhỏ, độc lập giúp ta dễ dàng hiểu, nâng cấp và bảo trì. Khái niệm hệ thống phần mềm
dựa thành phần và việc phát triển hệ thống phần mềm dựa thành phần không còn là
mới. Nhưng những ưu điểm của việc phát triển phần mềm theo mô hình dựa thành
phần vẫn còn nguyên giá trị và ngày càng phổ biến hơn. Chia hệ thống thành các phần
mã nguồn nhỏ giúp ta có thể thay đổi, cập nhật hoặc đơn giản thay thế nó mà không
ảnh hưởng đến các phần khác của hệ thống.
Để đưa kiến trúc dựa thành phần từ thiết kế áp dụng vào thực tế không hề đơn
giản và dễ dàng và không thể thực hiện được nếu chỉ sử dụng Java thuần túy. OSGi
giúp ta thực hiện được điều này cùng với Java. Ngoài việc giúp ta phát triển một hệ
thống dựa thành phần OSGi cũng khắc phục một số nhược điểm còn tồn tại của class
path trong Java, tránh được những lỗi khi hệ thống đang chạy (run time) rất thường
xuyên xảy ra với một hệ thống lớn và phức tạp. Triển khai hay cập nhật các thành
phần khi hệ thống vẫn đang chạy mà không phải khởi động lại, điều này không thể có
được với một hệ thống phát triển với Java thông thường.
Những ưu điểm mà OSGi mang lại là rất rõ ràng, tuy nhiên trước đây OSGi
thường có tiếng là quá phức tạp và khó sử dụng, do vậy OSGi còn chưa được sử dụng
rộng rãi. Gần đây có nhiều sự thay đổi về công cụ phát triển cũng như framework.
Trong luận văn tôi đã tìm hiểu và đưa ra những kinh nghiệm lập trình, áp dụng những
công nghệ, kỹ thuật được cho là tốt nhất hiện có với nhiều ưu điểm như dịch vụ Web
RESTful đang dần thay thế SOAP và WSDL, NoSQL hay AngularJS [21,23,16]. Kết
hợp với OSGi để đưa ra lựa chọn cho một kiến trúc hiệu quả giúp ta không còn tốn
nhiều thời gian để lựa chọn kiến trúc cũng như công nghệ trước khi phát triển một hệ
thống, nhất là hệ thống lớn và phức tạp. Giúp ta có nhiều thời gian tập trung vào phát
triển nghiệp vụ cho hệ thống.
Nội dung luận văn chia thành bốn chương. Chương 1 tìm hiểu về các khái niệm
trong hệ thống dựa thành phần, kiến trúc dựa thành phần và phát triển hệ thống phần
mềm dựa thành phần. Tìm hiểu, phân tích một số mô hình thành phần hiện tại và đưa
ra lựa chọn mô hình phù hợp cho phát triển phần mềm hiện nay. Chương 2 tìm hiểu về
lịch sử, kiến trúc và các đặc tính của OSGi. Từ đó hiểu rõ về kiến trúc, mục đích thiết
kế giúp OSGi có được những đặc tính phù hợp với việc phát triển hệ thống dựa thành
phần, bổ sung và khắc phục những nhược điểm còn tồn tại trong Java chuẩn. Chương
3 trình bày việc áp dụng OSGi để xây dựng một hệ thống bán hàng trực tuyến theo
kiến trúc dựa thành phần. Trình bày việc phân tích kiến trúc hệ thống, tìm hiểu những
2
công nghệ liên quan và những công cụ tốt nhất hiện có sử dụng cho quá trình phát
triển. Đưa ra những lựa chọn khi thiết kế, phân tách các thành phần sao cho phát huy
được tốt nhất những ưu điểm của kiến trúc dựa thành phần và OSGi. Hệ thống sau khi
hoàn thành sẽ bao gồm đầy đủ các thành phần cơ bản như một ứng dụng doanh nghiệp.
Như một giao diện Web frontend cho phép khách hàng xem và đặt mua sản phẩm
thông qua chức năng giỏ hàng và một trang quản trị dành cho quản trị viên. Web
frontend sẽ giao tiếp với hệ thống backend xử lý nghiệp vụ thông qua dịch vụ Web
RESTful. Dịch vụ Web RESTful giao tiếp với các thành phần OSGi bên dưới thông
qua các dịch vụ OSGi, bản thân dịch vụ Web RESTful cũng là một dịch vụ OSGi. Các
dịch vụ OSGi bên dưới cũng truy cập đến cơ sở dữ liệu NoSQL thông qua các dịch vụ
OSGi. Chương 4 là kết luận, đánh giá những kết quả đạt được và định hướng phát triển
của đề tài. Phần cuối cùng là tài liệu tham khảo và phụ lục.
3
Chƣơng 1. TỔNG QUAN VỀ PHÁT TRIỂN PHẦN MỀM DỰA THÀNH
PHẦN
1.1. Giới thiệu hệ thống dựa thành phần
“Xây dựng hệ thống dựa thành phần là hướng tiếp cận dựa trên ý tưởng sử dụng lại các
thành phần phần mềm thay vì phát triển các thành phần lại từ đầu” [4]. Từ quan điểm
đó các thành phần được định nghĩa, cài đặt và sau đó các thành phần độc lập, có mối
quan hệ không chặt chẽ với nhau được kết hợp đưa vào hệ thống. Xây dựng hệ thống
dựa thành phần mang lại nhiều ưu điểm như phát triển nhanh, giảm giá thành, khả
năng sử dụng lại tốt hơn. Hình 1.1 minh họa việc sử dụng lại các thành phần từ các
nguồn cung cấp sau đó sắp xếp và cài đặt thành một hệ thống phần mềm.
Hình 1.1: Phát triển hệ thống phần mềm dựa thành phần
Các hệ thống phần mềm ngày càng trở nên phức tạp và cung cấp nhiều tính năng hơn.
Để có thể tạo ra các sản phẩm phần mềm như thế với chi phí hợp lý. Các nhà cung cấp
thường sử dụng công nghệ dựa thành phần thay vì phát triển tất cả các phần của hệ
thống từ đầu. Động lực đằng sau việc sử dụng các thành phần là giảm thiểu giá thành
phát triển, nhưng về sau nó trở thành việc quan trọng hơn đó là giảm thiểu thời gian để
đưa sản phẩm ra thị trường, nhằm đáp ứng nhu cầu cấp thiết của khách hàng.
Các kỹ sư phần mềm quan tâm đến các thành phần như một phần nền móng cho
hướng dịch vụ (Service Orientation). Ví dụ trong dịch vụ Web (Web Service) hay gần
đây là kiến trúc hướng dịch vụ (SOA), một thành phần được chuyển đổi bởi dịch vụ
Web thành một dịch vụ (service) và do đó nó kế thừa các đặc tính cao hơn vượt ra khỏi
phạm vi của một thành phần thông thường.
4
1.2. Kiến trúc phần mềm dựa thành phần
Định nghĩa một thành phần phần mềm:
“Một thành phần phần mềm (software component) là một đơn vị kết cấu
(composition) tuân thủ các quy định của mô hình thành phần. Các thành phần giao tiếp
với nhau thông qua các giao diện (interface). Thành phần phần mềm có thể được triển
khai (deploy) độc lập, là đối tượng để cấu thành hệ thống phần mềm và cũng là đối
tượng được cung cấp bởi bên thứ ba (third party) trong phát triển phần mềm dựa thành
phần” [6].
Mô hình thành phần:
“Mô hình thành phần định nghĩa định dạng và giao diện chuẩn giữa các thành phần.
Chúng cho phép các thành phần có thể được triển khai và giao tiếp với nhau” [4].
Phần mềm dựa thành phần được cấu tạo nên bởi các thành phần phần mềm. Tất cả các
quy trình của hệ thống được đặt trong các thành phần tách biệt, do đó tất cả các chức
năng và dữ liệu bên trong mỗi thành phần là có liên quan với nhau về mặt ý nghĩa nào
đó. Do vậy người ta thường nói các thành phần có tính module và gắn kết. Các thành
phần có thể sử dụng lại các thành phần có sẵn và chỉ phải phát triển những thành phần
nghiệp vụ riêng của ứng dụng. Hình 1.2 mô tả kiến trúc của một hệ thống dựa thành
phần, ứng dụng 1 có thể sử dụng chung thành phần 2 và A với ứng dụng 2 và nó chỉ
phải phát triển các thành phần A, B, C.
Hình 1.2: Kiến trúc hệ thống dựa thành phần
Mỗi thành phần có một giao diện được định nghĩa rõ ràng và chúng giao tiếp với các
thành phần khác qua giao diện này. Khi một thành phần cung cấp dịch vụ cho phần
5
còn lại của hệ thống, nó thông qua giao diện để xác định dịch vụ mà các thành phần
khác có thể sử dụng và sử dụng như thế nào. Giao diện này có thể được xem như là
chữ ký của thành phần. Hình 1.3 mô tả các thành phần trong một hệ thống dựa thành
phần và giao tiếp giữa các thành phần trong hệ thống.
Hình 1.3: Ví dụ hệ thống dựa thành phần
1.3. Đặc tính của thành phần phần mềm
Một thành phần phần mềm có những đặc tính sau [6]:
- Đóng gói (Encapsulated): Client có thể sử dụng mà không cần biết về cài đặt cụ thể
cũng như là các công việc bên trong của thành phần. Ví dụ hệ thống trong hình 1.3
trên thì thành phần đặt phòng khách sạn sẽ sử dụng dịch vụ của thành phần thanh toán.
Nó chỉ cần biết đến giao diện IBilling để sử dụng và không cần biết thành phần thanh
toán sử dụng thanh toán qua credit card, tiền mặt hay một phương thức thanh toán nào
khác.
- Chuẩn hóa (Standardised): Chuẩn hóa thành phần có nghĩa là các thành phần sử dụng
trong hệ thống dựa thành phần phải tuân theo một số mô hình thành phần đã được
chuẩn hóa. Mô hình này có thể định nghĩa các giao diện cho thành phần, meta-data,
cấu tạo của thành phần, triển khai (deployment). Khi đó thì các hệ thống có thể sử
dụng lại các thành phần và dễ dàng triển khai.
- Độc lập (Independent): Một thành phần nên độc lập, nó nên được tạo ra và triển khai
mà không cần sử dụng các thành phần khác. Trong một số trường hợp khi mà thành
phần cần các dịch vụ từ bên ngoài thì điều này nên được khai báo trong một bản đặc tả
giao diện được yêu cầu.
- Có thể thay thế (Substitutable): Một thành phần có thể được thay thế bởi một thành
phần khác (trong thời gian thiết kế hoặc thời gian chạy – run time), nếu một thành
phần đáp ứng được các yêu cầu của thành phần ban đầu (yêu cầu này mô tả thông qua
giao diện). Theo đó một thành phần có thể được thay thế bởi một phiên bản cập nhật
6
hoặc thay thế hoàn toàn mà không làm ảnh hưởng đến hệ thống mà thành phần này
đang hoạt động. Hình 1.4 mô tả ví dụ về đặc tính này, bộ xử lý văn bản có thể dễ dàng
sử dụng phiên bản mới của từ điển thay cho phiên bản cũ.
- Khả năng sử dụng lại (Reusability): Đây là một đặc tính quan trọng của một thành
phần phần mềm có chất lượng tốt. Các lập trình viên nên thiết kế và cài đặt nên các
thành phần phần mềm theo cách này, khi đó nhiều chương trình khác nhau có thể sử
dụng lại chúng.
- Triển khai độc lập (deployable): Để có thể triển khai độc lập thì một thành phần cần
phải tự bao hàm (self-contained) và có thể hoạt động như một thực thể độc lập trên
một số nền tảng thực thi mô hình thành phần.
Hình 1.4: Sự kết hợp có thể giữa client cũ và mới và các thành phần của nó
1.4. Một số mô hình thành phần hiện tại
Common Object Request Broker Architecture (CORBA)
Được phát triển từ mô hình đối tượng CORBA và được giới thiệu như một mô hình cơ
bản của đặc tả thành phần OMG. Đặc tả mô hình thành phần CORBA định nghĩa một
mô hình chung, một mô hình lập trình, một mô hình đóng gói, một mô hình triển khai,
một mô hình thực thì và một mô hình meta. Mô hình meta định nghĩa các khái niệm và
quan hệ giữa các mô hình khác nhau. Các thành phần CORBA giao tiếp với thế giới
bên ngoài thông qua các cổng. Mô hình thành phần CORBA sử dụng ngôn ngữ riêng
để đặc tả thành phần: IDL (Interface Defination Language). Mô hình thành phần
CORBA cung cấp một framework gọi là framework cài đặt thành phần CIF
(Component Implementation Framework) dựa trên ngôn ngữ định nghĩa cài đặt thành
phần CIDL (Component Implementation Definition Language) và mô tả các phần chức
năng và phi chắc năng của một thành phần nên tương tác với nhau như thế nào. Thêm
nữa, mô hình thành phần CORBA sử dụng XML để xác định các thông tin về đóng gói
và triển khai. Mô hình thành phần CORBA cũng có một bộ mô tả cài đặt, nó bao gồm
meta-data về việc làm thế nào hai hoặc nhiều thành phần có thể được kết hợp cùng
nhau [12].
7
JavaBeans
Được phát triển bởi Sun Microsystems dựa trên ngôn ngữ lập trình Java. Trong đặc tả
JavaBeans một bean là một thành phần phần mềm có thể sử dụng lại và có thể được sử
dụng trực quan vào trong các applet, các ứng dụng, servlet, các thành phần tổng hợp,
sử dụng công cụ xây dựng ứng dụng trực quan. Lập trình một thành phần Java yêu cầu
định nghĩa của ba tập hợp dữ liệu: thuộc tính (tương tự các thuộc tính trong một class);
phương thức; sự kiện, sự kiện là một thay thế cho việc gọi phương thức khi gửi dữ
liệu. JavaBeans ban đầu được thiết kế cho việc xây dựng giao diện đồ họa người dùng
(Graphic User Interface). Mô hình định nghĩa ba dạng của tương tác điểm, được xem
như cổng (port): phương thức, như trong Java; thuộc tính, sử dụng để tham số hóa các
thành phần ở thời điểm xây dựng (composition time); nguồn sự kiện, nơi lắng nghe sự
kiện (listener) cho việc giao tiếp dựa sự kiện (event-based) [13].
Enterprise JavaBeans (EJB)
Được phát triển bởi Sun Microsystems, EJB là việc kết hợp hướng đối tượng và các
ứng dụng doanh nghiệp phân tán. Nó cung cấp một tập các dịch vụ, giống như
transaction, persistence, concurrency và khả năng tương tác. EJB phân ra ba loại thành
phần khác nhau là EntityBeans, SessionBean và MessageDrivenBeans. Mỗi bean này
được triển khai trong một EJB container, container này chịu trách nhiệm quản lý ở thời
điểm chạy (start, stop, pasivation hay activation) và việc bảo mật, độ tin cậy hay hiệu
năng [11].
Microsoft Component Object Model (COM)
Là một trong những mô hình thành phần phần mềm được sử dụng phổ biến nhất cho
các ứng dụng desktop và ứng dụng ở phía server. Một đặc tính cơ bản của COM là các
giao diện được xác định tách biệt với cả hai thành phần cài đặt chúng và sử dụng
chúng. COM định nghĩa một một ngôn ngữ là Interface Definition Language (IDL), nó
được sử dụng để xác định các giao diện hướng đối tượng. Các giao diện là hướng đối
tượng và các phương thức của chúng được cài đặt bởi một lớp (class) và chuyền một
tham chiếu tới một đối tượng cụ thể của lớp gọi. Một khái niệm được biết đến như là
“interface navigation” cho phép đối tượng sử dụng đạt được một con trỏ trỏ tới mỗi
giao diện được hỗ trợ bởi đối tượng. Việc này thực hiệ dựa trên VTable [3].
OSGi
Là một đặc tả định nghĩa một framework module và hướng dịch vụ được phát hành bởi
OSGi Alliance là tổ chức được thành lập bởi một số đối tác công nghiệp như
Ericsson, IBM, Motorola, Sun Microsystems, v.v. Trái ngược với hầu hết với các định
nghĩa thành phần, OSGi nhấn mạnh việc tách biệt giữa một đơn vị thành phần và một
đơn vị triển khai trong việc gọi một thành phần tương ứng là dịch vụ hoặc bundle. Tức
là trong kiến trúc của hệ thống người ta nhắc đến các thành phần của OSGi như là các
8
dịch vụ, còn trong khi triển khai người ta đề cập đến các thành phần như các bundle.
Khác với hầu hết các mô hình thành phần khác OSGi cũng đề xuất một kiến trúc hệ
thống linh hoạt, hệ thống có thể được phát triển động trong thời gian chạy. Tức là
trong hệ thống, bất kỳ thành phần nào cũng có thể được thêm, bớt, hoặc cập nhật trong
thời gian chạy. Do dựa trên Java nên OSGi độc lập với nền tảng và cung cấp thêm cho
Java một số đặc tính như tăng cường tính module, quản lý phiên bản cho các phụ thuộc
[8].
Lựa chọn mô hình thích hợp
Một số đặc tính của các mô hình thành phần được mô tả trong bảng 1.1.
Đóng gói
Quản lý
phiên bản,
phụ thuộc
Triển
khai
động
CORBA IDL
(CIDL)
JAR, DLL
X
X
Java
Java
JAR
X
X
EJB
Java
Java Programming
Language +
Annotations
JAR
X
X
COM
Ngôn ngữ
hướng đối
tượng
Microsoft IDL
DLL
X
X
OSGi
Java
Java
OSGi
bundle
V
V
Mô hình
thành phần
Cài đặt
Ngôn ngữ giao diện
CORBA
Độc lập với
ngông ngữ
JavaBeans
X : không hỗ trợ, V: hỗ trợ
Bảng 1.1: Đặc tính của một số mô hình thành phần hiện tại
Mô hình thành phần CORBA tuy độc lập với ngôn ngữ lập trình nhưng nó chủ yếu
dùng cho mô hình client/server, các thành phần giao tiếp với nhau thông qua mạng do
đó thích hợp hơn đối với các hệ thống phân tán hay dùng để giao tiếp giữa các hệ
thống với nhau. Không thích hợp cho một hệ thống duy nhất do ảnh hưởng về hiệu
năng khi truyền thông qua mạng, hoặc khi thay đổi thì cần cập nhật lại thông tin về
giao tiếp mạng như địa chỉ, cổng, v.v. Việc chuyển đổi định dạng dữ liệu giữa các hệ
thống cũng tương đối phức tạp. JavaBeans, EJB cũng như COM thiếu cơ chế quản lý
phụ thuộc và phiên bản của các phụ thuộc. Khiến cho việc quản lý phụ thuộc trở nên
rắc rối và phức tạp và mất nhiều thời gian để giải quyết khi gặp phải vấn đề. Người ta
9
thường nhắc đến vấn đề này như vấn đề JAR hell hay DLL hell. Các mô hình này cũng
không hỗ trợ sẵn cơ chế triển khai động các thành phần trong khi hệ thống đang chạy,
mà thường chúng ta phải thêm mã nguồn để tự quản lý việc này rất phức tạp. Ngoài ra
thì Java thông thường cũng thiếu tính module do đó các mô hình dựa trên Java cũng
gặp phải vấn đề này.
OSGi cũng dựa trên ngôn ngữ Java nhưng cung cấp thêm tính module cho Java
giúp tăng cường sự gắn kết trong từng module, giảm sự phụ thuộc giữa các module.
Ngoài những tính năng của một mô hình dựa thành phần, OSGi cũng cung cấp cơ chế
quản lý phụ thuộc sử dụng các ràng buộc phiên bản giúp tránh được vấn đề JAR hell.
Với kiến trúc hướng dịch vụ OSGi mang đến cơ chế động cho hệ thống. Kiến trúc
hướng dịch vụ giúp cho các thành phần độc lập do đó dễ dàng thay thế hay sử dụng lại.
Các dịch vụ có thể xuất hiện hoặc biến mất động cũng như các thành phần có thể được
triển khai hoặc gỡ bỏ động khi hệ thống vẫn đang hoạt động. Ngoài những ưu điểm thì
OSGi cũng có mặt hạn chế như các công cụ hỗ trợ cho việc phát triển hiện tại còn
phức tạp, hầu hết các thư viện hữu ích vẫn dưới dạng Java thông thường do đó cần cơ
chế để kế thừa lại trong OSGi. Nhưng những nhược điểm này có thể dần được khắc
phục do các công cụ hỗ trợ cho OSGi ngày càng nhiều và thuận tiện. Các công cụ sau
này cũng hỗ trợ việc sử dụng lại các thư viện Java thông thường trong OSGi. Với
những đặc tính như đã phân tích rõ ràng OSGi là một lựa chọn hàng đầu cho việc phát
triển hệ thống phần mềm dựa thành phần hiện nay.
10
Chƣơng 2. OSGi VÀ PHÁT TRIỂN PHẦN MỀM DỰA THÀNH PHẦN
2.1. OSGi framework
2.1.1. Tổng quan về OSGi
OSGi xuất hiện lần đầu tiên năm 1999. Ban đầu OSGi được gọi là “Open Service
Gateway Initiative”. Nhưng các đặc tả của OSGi ngày nay vượt ra ngoài phạm vi của
các cổng dịch vụ, và nay nó được sử dụng trong một dải rộng các ứng dụng từ điện
thoại di động cho tới mã nguồn mở Eclipse IDE, công nghiệp tự động hóa, ứng dụng
doanh nghiệp (enterprise), application servers, v.v. Ngày nay OSGi Alliance nhắc đến
OSGi như một bản đặc tả framework, một nền tảng dịch vụ và đơn giản gọi là “The
Dynamic Module System for Java” chứ không bao hàm ý nghĩa của một từ viết tắt của
“Open Service Gateway Initiative”.
OSGi Alliance là một tổ chức phi lợi nhuận được thành lập tháng 3 năm 1999.
Bao gồm nhiều công ty lớn như: Ericsson, IBM, Motorola, Sun Microsystems, v.v.
Nhiệm vụ của OSGi Alliance là duy trì, phát hành đặc tả OSGi (OSGi specification),
chứng nhận các bản cài đặt (implementation) và tổ chức các sự kiện về OSGi.
Phiên bản đầu tiên là R1 (OSGi Release 1) tháng 5 năm 2000. Phiên bản mới
nhất hiện nay là R6 (OSGi Release 6) tháng 6 năm 2014 [14].
Những thành phần cốt lõi của OSGi là bundle, quản lý vòng đời (lifecycle) của
các bundle và hạ tầng dịch vụ được hỗ trợ bởi môi trường được biết đến như một
OSGi framework. Hình 2.1 [14] mô tả các lớp trong OSGi, ta có thể sử dụng OSGi
bundle (lớp module) mà không đụng đến lớp quản lý vòng đời (Life Cycle) hay lớp
dịch vụ (Service). Nhưng để tận dụng được các ưu điểm của các dịch vụ trong OSGi,
một ứng dụng cần phải được tạo lên từ các bundle.
Hình 2.1: Kiến trúc OSGi
11
OSGi bao gồm một lớp bảo mật (Security) cung cấp các mở rộng cho kiến trúc bảo
mật của Java. Lớp này hỗ trợ tất cả các lớp còn lại như ta thấy trên hình nó cắt ngang
qua các lớp khác. Nhưng ta không thảo luận sâu về lớp này trong luận văn.
Như trên hình 2.1 các lớp Service, Life Cycle, Modules và Execution
Environment được cung cấp bởi OSGi; Các bundle là nội dung của người dùng. Ứng
dụng sẽ nhận được các ưu điểm của OSGi framework bằng cách cung cấp các module,
và tinh vi hơn với việc quản lý vòng đời. Những module này có thể giao tiếp với cái
khác và được hỗ trợ bởi các dịch vụ OSGi.
Một số OSGi framework được sử dụng rộng rãi ngày nay. Phổ biến hầu như bậc
nhất là Eclipse Equinox, Apache Felix, Knopferfish, và ProSyst. Equinox củng cố
Eclipse IDE và Rich Client Platform, trong khi Felix là trái tim của application server
Apache Tomcat. Một số application server khác cũng hỗ trợ OSGi (Xem thêm trong
phụ lục 2). ProSyst được nhúng trong các thiết bị giống như router và hệ thống GPS
trong ô tô.
Ngoài khả năng hỗ trợ tính module và xây dựng hệ thống dựa thành phần (được coi
như SOA - Service-Oriented Architecture trong một máy ảo - virtual machine), thì khi
xây dựng hệ thống với OSGi ta còn có thê khắc phục được một số nhược điểm của
Java:
- Khắc phục được tình trạng gặp phải ClassNotFoundException khi khởi động ứng
dụng, bởi vấn đề Class Path trong Java. OSGi có thể giúp đỡ bằng cách đảm bảo các
phần mã nguồn phụ thuộc được thỏa mãn trước khi cho phép mã nguồn thực thi.
- Lỗi trong khi chạy (execution-time error) từ ứng dụng của ta bởi vì một thư viện phụ
thuộc nào đó trong Class Path sai phiên bản dẫn đến lỗi NoSuchMethodError hoặc
nguy hiểm hơn là không có ngoại lệ nhưng chương trình chạy sai logic. OSGi có thể
giúp ta kiểm tra những phần phụ thuộc là đồng nhất với phiên bản mong đợi và các
ràng buộc khác.
- Đóng gói một ứng dụng như các file JAR độc lập về mặt logic và có thể triển khai
chỉ những phần ta cần.
- Đóng gói một ứng dụng như những file JAR độc lập về mặt logic, khai báo mã nguồn
có thể được truy cập từ mỗi file JAR. OSGi cho phép một mức mới cho việc xác định
khả năng hiện diện của mã nguồn cho các file JAR, điều này cho phép ta xác định
những gì sẽ hiện diện và không hiện diện với bên ngoài.
- Xem thêm -