Luận văn Phát triển ứng dụng dịch vụ hướng vị trí trên nền Drupal
TRƯỜNG ………………….
KHOA……………………….
-----[\ [\-----
Báo cáo tốt nghiệp
Đề tài:
PHÁT TRIỂN ỨNG DỤNG DỊCH VỤ
HƯỚNG VỊ TRÍ TRÊN NỀN DRUPAL
Lời cảm ơn
Trước tiên, tôi muốn gửi lời cảm ơn sâu sắc đến T.S Nguyễn Hải Châu, người đã
hết lòng hướng dẫn tôi trong suốt quá trình thực hiện khóa luận tốt nghiệp.
Tôi xin chân thành cảm ơn các thầy, các cô của trường đại học Công Nghệ đã
cung cấp cho tôi nền tảng kiến thức quý báu và sự giúp đỡ tận tình để tôi có thể hoàn
thành khóa luận của mình.
Tôi cũng muốn cảm ơn các bạn tôi, những người đã giúp đỡ tôi đưa ra giải pháp
lập trình hiệu quả khi thực hiện các thử nghiệm liên quan đến khóa luận này.
Cuối cùng, tôi xin gửi lời cảm ơn đến gia đình và người thân của tôi, những
người đã luôn động viên và giúp đỡ tôi trong suốt quá trình học tập và thực hiện khóa
luận.
Hà Nội, ngày 20 tháng 5 năm 2010
Sinh viên
Đặng Vĩnh Thiêm
i
Tóm tắt khóa luận
Drupal là một hệ quản trị nội dung được sử dụng khá phổ biến trên Internet trong
thời gian gần đây. Với thiết kế mang tính module, Drupal cho phép mở rộng các tính
năng một cách linh hoạt thông qua các module được thêm vào mà không phải thay đổi
mã nguồn của hệ thống.
Trong khoá luận này, chúng tôi tập trung tìm hiểu các kiến thức liên quan đến
việc xây dựng module cho Drupal bao gồm triển khai các hook, làm việc với cơ sở dữ
liệu, thực thi mã JavaScript, xử lý form..v..v. Đi vào thực nghiệm, chúng tôi đã thiết kế
và cài đặt thành công một module có chức năng tích hợp bản đồ số Google Maps vào
trang web bằng cách sử dụng API do Google cung cấp. Module này hướng tới các đối
tượng website liên quan đến địa danh, địa điểm như website du lịch, tra cứu địa điểm
trên bản đồ...
ii
Mục lục
1.2.1 Kiến trúc module........................................................................................................3
1.2.2 Các module lõi...........................................................................................................4
1.2.3 Hook...........................................................................................................................5
1.2.4 Giao diện....................................................................................................................6
1.3.1 Node...........................................................................................................................6
1.3.2 Người dùng (User).....................................................................................................8
1.3.3 Khối và cách thể hiện trang.......................................................................................9
1.3.4 Thực đơn – Menu.....................................................................................................10
1.3.5 Form.........................................................................................................................10
1.3.6 API cơ sở dữ liệu và lược đồ...................................................................................11
1.5.1 Vai trò của Web server............................................................................................13
1.5.2 Quá trình khởi động.................................................................................................13
1.5.3 Xử lý yêu cầu...........................................................................................................14
1.5.4 Giao diện hoá nội dung............................................................................................15
1.6.1 Module Devel...........................................................................................................15
1.6.2 Module Coder..........................................................................................................15
iii
2.1.1 File .info...................................................................................................................17
2.1.2 File .module.............................................................................................................19
2.4.1 Cách tạo một hook...................................................................................................24
2.4.2 Sử dụng hook vào các module khác.........................................................................26
2.6.1 Giới thiệu về jQuery................................................................................................28
2.6.2 jQuery hoạt động như thế nào..................................................................................28
2.6.2.1 Sử dụng bộ lọc ID của CSS..............................................................................29
2.6.2.2 Sử dụng XPath..................................................................................................29
2.6.3 jQuery trong Drupal.................................................................................................30
2.7.1 Quá trình thao tác với form......................................................................................31
2.7.2 Một số thao tác cơ bản.............................................................................................34
2.7.2.1 Tạo form............................................................................................................34
2.7.2.2 Giao diện hoá form...........................................................................................35
2.7.2.3 Kiểm tra dữ liệu................................................................................................35
2.7.2.4 Gửi form lên trang web.....................................................................................36
2.8.1 Định nghĩa các tham số trong CSDL.......................................................................36
2.8.2 Một số truy vấn đơn giản.........................................................................................37
2.8.3 Lấy kết quả truy vấn................................................................................................38
iv
3.2.1 Tạo một bản đồ đơn giản.........................................................................................41
3.2.2 Dịch vụ Geocoder - Chuyển đổi giữa địa chỉ và toạ độ...........................................42
3.3.1 Module Google Maps..............................................................................................42
3.3.1.1 File .info............................................................................................................42
3.3.1.2 File .module......................................................................................................43
3.3.1.3 Tạo thêm trường thông tin cho bài viết.............................................................43
v
Bảng từ viết tắt
Từ viết tắt
Cụm từ đầy đủ
URI
CVS
API
Uniform Resource Identifier
Concurrent Version System
Application Programming Interface
Cơ sở dữ liệu
CSDL
CMS
Content Management System
vi
Mở đầu
Trong thời đại Công nghệ thông tin ngaỳ nay, cać dic̣ h vụ và ứng dụng web ngày
càng phat́ triển. Việc một cá nhân hay tổ chức sở hưũ một website, một côn̉ g thông tin
là điều dễ thấy trên Internet. Để thiết kế một trang web phục vụ muc̣ đích riêng, người
dùng có nhiều lựa chọn. Một trong số đó là sử dụng hệ quản trị nội dung sẵn có để tổ
chức và xây dựng các trang thông tin.
Với mục đích đó, chúng tôi đã chọn Drupal, một trong các CMS phổ biến nhất,
để thực hiện nghiên cứu. Sở dĩ chúng tôi chọn CMS này vì đây là một hệ mã nguồn
mở miễn phí, được sử dụng rộng rãi và được cộng đồng mạng phát triển ngày càng
hoàn thiện.
Drupal có thể được sử dụng trong nhiều mục đích như xây dựng cổng thông tin
trực tuyến, website cá nhân, tổ chức, website thương mại, báo điện tử, thư viện hình
ảnh...
Hệ thống Drupal được thiết kế để có thể tuỳ biến theo mong muốn của người
dùng và việc tuỳ biến chỉ được thực hiện bằng cách thêm các module để làm tăng khả
năng của hệ thống mà không thay đổi bộ nhân. Do đó, trong khoá luận này chúng tôi
chú trọng tìm hiểu cách xây dựng module cho Drupal và các vấn đề liên quan.
Chúng tôi hi vọng phần kiến thức tìm hiểu được trong khóa luận sẽ mạng lại
những ý nghĩa tích cực trong thực tiễn.
Ngoài phần mở đầu, bố cục của khóa luận gồm 3 chương sau:
• Chương 1: Trình bày các kiến thức cơ bản về hệ thống Drupal và cách hoạt
động.
• Chương 2: Tìm hiểu cách viết một module trong Drupal.
• Chương 3: Đưa lý thuyết đã trình bày vào thực tế để thiết kế một module cụ
thể.
• Cuối cùng là phần kết luận và hướng phát triển trong tương lai.
1
Chương 1: Tổng quan về Drupal
1.1 Giới thiệu về Drupal
Drupal là một framework dùng cho phát triển phần mềm hướng module, một hệ
thống quản trị nội dung miễn phí và mã nguồn mở.
Cũng giống như các hệ thống quản trị nội dung hiện đại khác, Drupal cho phép
người quản trị hệ thống tạo và tổ chức dữ liệu, tùy chỉnh cách trình bày, tự động hóa
các tác vụ điều hành và quản lý hệ thống. Drupal có cấu trúc lập trình rất tinh vi, dựa
trên đó, hầu hết các tác vụ phức tạp có thể được giải quyết với rất ít đoạn mã được
viết, thậm chí không cần. Đôi khi, Drupal cũng được gọi là "Framework cho ứng dụng
Web" vì kiến trúc thông minh và uyển chuyển của nó.
Drupal được chạy trên rất nhiều môi trường khác nhau, bao gồm Windows, Mac
OS X, Linux, FreeBSD, OpenBSD và các môi trường hỗ trợ máy phục vụ web Apache
(phiên bản 1.3+) hoặc IIS (phiên bản 5+) có hỗ trợ ngôn ngữ PHP (phiên bản 4.3.3+).
Drupal kết nối với cơ sở dữ liệu MySQL hoặc PostgreSQL để lưu nội dung và các
thiết lập.
Hình 1.1. Các dịch vụ được sử dụng trong Drupal.
1.2 Kiến trúc của Drupal
Nói một cách ngắn gọn thì Drupal là một hệ quản trị nội dung được viết bằng
ngôn ngữ PHP và sử dụng cơ sở dữ liệu quan hệ để lưu trữ (thông thường là MySQL).
Mặc dù Drupal được viết bằng PHP nhưng lại không sử dụng hướng đối tượng mà sử
dụng kiểu lập trình thủ tục truyền thống. Một trong số lý do đó là khi Drupal ra đời thì
PHP chưa hỗ trợ mạnh về hướng đối tượng. Tuy nhiên, nhìn một cách tổng quát thì
2
Drupal vẫn áp dụng những nguyên lý trong lập trình hướng đối tượng: tính đóng gói,
kế thừa, đa hình...
Kiến trúc của Drupal có thể mô tả như biểu đồ dưới đây:
Hình 1.2. Kiến trúc Drupal
Ở trung tâm của kiến trúc là phần nhân gồm một tập các file chứa các đoạn mã
nạp chương trình và các thư viện quan trọng. Thư viện nhân Drupal đóng vai trò như
lớp kết nối các modules. Phần này cung cấp các dịch vụ như kết nối và quản lý cơ sở
dữ liệu, quản lý bộ khung hook, thư viện trừu tượng phục vụ mail và hình ảnh, hỗ trợ
Unicode... Mặc dù những thư viện này cung cấp các tính năng quan trọng nhưng sức
mạnh thực sự của Drupal nằm ở kiến trúc kiểu module.
1.2.1 Kiến trúc module
Module là một bộ gồm mã PHP và các file hỗ trợ sử dụng API và kiến trúc của
Drupal tích hợp các thành phần mới vào trong framework của Drupal.
Cơ chế module của Drupal được thiết kế để cung cấp một cách thức đồng nhất
giúp người phát triển mở rộng khả năng của hệ thống.
Những file tạo nên module được gộp vào một ví trí nhất định trong cấu trúc thư
mục của Drupal. Khi Drupal cần thông tin về module nào đó, nó sẽ tìm trong những
thư mục này. Mỗi module nằm ở một thư mục riêng và có ít nhất là 2 file - một file
cung cấp thông tin về module và một hay nhiều file khác chứa mã PHP thực hiện chức
3
năng của module đó.
Để một module sử dụng được thì nó phải được bật bởi người quản trị trang web.
Drupal sẽ chuyển các yêu cầu của người dùng đến module đó nếu cần thiết.
1.2.2 Các module lõi
Một số module có vai trò rất quan trọng trong hệ thống Drupal. Nếu gỡ bỏ hoặc
vô hiệu hóa các module này sẽ dẫn đến Drupal mất đi các chức năng thiết yếu. Những
module này được gọi là module lõi, được mặc định phân phối theo mã nguồn Drupal.
Danh sách module lõi nằm ở Administer | Site building | Modules. Trong số này có 5
module quan trọng nhất là Block, Filter, Node, System và User. Những module này
không thể gỡ bỏ hoặc vô hiệu hóa.
Hình 1.2.2. Danh sách các module lõi
Một nét đặc biệt trong kiến trúc của Drupal là các module có thể tác động với
nhau một cách dễ dàng. Bằng cách sử dụng cơ chế hook, dịch vụ mà các module khác
nhau cung cấp có thể kết hợp với nhau để tạo nên các tính năng mạnh hơn mà không
cần phải viết lại một lượng lớn mã nguồn.
4
1.2.3 Hook
Cơ chế hook là một khái niệm rất quan trọng trong việc phát triển module cho
Drupal. Cơ chế này giúp Drupal biết được phải gọi module nào khi xử lý các yêu cầu
khác nhau từ người dùng.
Một yêu cầu của người dùng sẽ được Drupal xử lý qua một chuỗi các bước khác
nhau. Đầu tiên, phần lõi khởi động ứng dụng, định nghĩa các các biến và các hàm
thường dùng. Tiếp theo, hệ thống sẽ nạp các thư viện, giao diện và module cần thiết và
ánh xạ URI được yêu cầu tới đoạn mã điều khiển tương ứng. Sau đó, dữ liệu sẽ được
định dạng và đặt vào giao diện để đưa ra trình duyệt của người dùng.
Trong một thời điểm xác định trước, Drupal thực thi các hook. Hệ thống sẽ dựa
vào hook để kiểm tra một số hoặc tất cả các module đang được bật, tìm kiếm các hàm
theo khuôn mẫu được định nghĩa trước. Một số mẫu liên kết quá trình này với phương
thức "callback" thường được sử dụng trong mô hình xử lý sự kiện. Cơ chế hook cũng
tương tự như thế.
Ví dụ, trong khi tạo nội dung cho một trang dạng View, Drupal có thể quét qua
các module để tìm những hàm có tên <modulename>_block() và <modulename>_view()
với modulename được thay bằng tên của module cụ thể khi kiểm tra. Những module
chứa các hàm trên bổ sung cho các hook hook_block() và hook_view().
Khi Drupal tìm thấy những hàm đó thì sẽ thực thi chúng và sử dụng dữ liệu lấy
được để trả lời yêu cầu của người dùng. Sau đó hệ thống sẽ tiếp tục quá trình xử lý
từng bước đã nói ở trên và có thể sẽ thực thi các hook khác nếu cần thiết.
Khi tất cả các bước đã hoàn thành, phản hồi được gửi lại người dùng, Drupal sẽ
dọn dẹp hệ thống và thoát ra.
Những người quen thuộc với lập trình hướng đối tượng có thể xem hook là một
cơ chế tương tự như các giao diện hoặc phương thức ảo. Giống như giao diện trong lập
trình hướng đối tượng, bản triển khai (bao gồm tên, các tham số và giá trị trả về) phải
khớp với phần khai báo của hook. Khác với giao diện, người phát triển module có thể
chọn những hook nào sẽ sử dụng và những hook nào được bỏ qua. Drupal không yêu
cầu tất cả các hook đã định nghĩa phải được triển khai và sử dụng.
Module có thể định nghĩa các hook riêng và module khác có thể dùng chung các
hook đó. Theo cách này, cơ chế hook được mở rộng để cung cấp các chức năng phức
tạp. Sử dụng hook thực chất là cách để người phát triển tương tác gián tiếp với bộ
5
nhân của Drupal.
1.2.4 Giao diện
Đối với một hệ quản trị nội dung (CMS) trên nền web, sức mạnh xử lý không
phải là tất cả. Một CMS ở cấp độ thương mại cần phải cho phép người thiết kế có khả
năng tùy chỉnh trang web với chế độ xem-và-cảm nhận (look-and-feel) mà họ mong
muốn. Drupal cung cấp một hệ thống giao diện mạnh mẽ để phục vụ mục đích này.
Hệ thống giao diện của Drupal khá phức tạp. Giống như các module, giao diện
được thiết kế sao cho có thể được cải tiến và mở rộng bằng cách sử dụng cơ chế hook.
Giao diện bao gồm một bộ tài nguyên bao gồm các mẫu PHP, CSS, Javascript và
hình ảnh, tạo nên bố cục và cách trình bày cho nội dung trong Drupal. Một giao diện
đơn giản có thể được tạo ra bởi một vài file - một file định nghĩa cách trình bày, một
file thông tin về giao diện và một vài hình ảnh. Bằng cách sử dụng mẫu có sẵn của
Drupal, người phát triển có thể tạo ra một giao diện tùy chỉnh mà không tốn nhiều thời
gian.
Một giao diện cũng có thể phát triển để đáp ứng những nhu cầu cao hơn. Những
khuôn mẫu tùy biến, thường được viết bằng ngôn ngữ PHP dành cho mẫu, có thể tái
cấu trúc các chi tiết của HTML. Một số file PHP được viết để nạp chồng các phương
thức của bộ máy giao diện. Các cấu hình phức tạp của Javascript và các file CSS cũng
được hỗ trợ. Module có thể được sử dụng để giao tiếp với hệ thống giao diện phức tạp
này.
Nói tóm lại, một giao diện có thể trở thành đơn giản hay phức tạp là tùy vào thiết
kế của người phát triển.
1.3 Các khái niệm cơ bản trong Drupal
1.3.1 Node
Drupal là một framework quản lý nội dung. Khi nói về nội dung trong trường
hợp này, chúng ta thường nghĩ đến các đối tượng văn bản như bài viết tin tức hoặc một
mẫu blog.
Khái niệm về một mẫu nội dung dạng văn bản tổng quát trong Drupal được gọi
bằng thuật ngữ Node. Một node, hiểu theo cách của Drupal, là một đối tượng tổng
quát dùng để biểu diễn nội dung dạng văn bản.
Tuy nhiên, với khả năng tùy biến của Drupal, người phát triển có thể tạo ra các
6
module mở rộng khả năng trình bày của node để có thể hiển thị các nội dung ngoài văn
bản thuần túy, như hình ảnh, video hay các file âm thanh.
Các node được lưu trữ trong cơ sở dữ liệu và sẽ được lấy ra khi cần thiết. Một
node gồm có các thành phần:
- Một định danh không trùng nhau đối với 2 node bất kỳ (nid - Node ID).
- Ít nhất một giá trị thể hiện phiên bản của node (vid - Version ID).
- Ngày khởi tạo và thay đổi, cùng với thông tin xác định người dùng làm việc trực tiếp
với node đó.
- Dữ liệu meta như trạng thái xuất bản, ngôn ngữ được sử dụng và và các bản dịch
sang ngôn ngữ khác...
Thêm vào đó, hầu hết các node đều có phần tiêu đề và phần nội dung. Người
quản trị và nhà phát triển có thể chọn vô hiệu hóa hai phần này.
Chúng ta sẽ xem qua quá trình tạo một nội dung mới để hiểu thêm về node.
Mặc định, người dùng có thể tạo một nội dung mới trong Drupal bằng cách nhấn
vào liên kết Create content ở trang điều hướng. Tại đây, người dùng sẽ được yêu cầu
chọn loại nội dung họ sẽ tạo ra.
Hình 1.3.1.a. Giao diện chọn nội dung cần tạo
Nói một cách tổng quát thì node là phần cốt lõi của hệ thống quản lý nội dung
của Drupal. Các API của node sẽ được khai thác nhiều ở các phần sau của khóa luận.
Lưu ý rằng comments (các bài bình luận) không phải là node. Trong khi hầu hết
các nội dung ở dạng bài viết là dựa trên node thì comment là một ngoại lệ. Bình luận
7
thực chất là một cơ chế phản hồi ở cấp người dùng được gắn vào các bài viết, trang tin
hay mẫu blog... Khi tạo ra một trang nội dung mới, người dùng có thể chọn cho phép
hoặc không cho phép các bài bình luận.
Dưới đây là ví dụ về giao diện khi người dùng muốn gửi bình luận:
Hình 1.3.1.b. Thêm chú thích vào bài viết
Lời bình luận đóng một vai trò khác với node trong hệ thống Drupal. Mặc dù
không phải là một thành phần quan trọng trong việc phát triển module nhưng lời bình
luận cho thấy Drupal là một kiến trúc rất uyển chuyển, có thể chấp nhận các phần mở
rộng (như comment) mà không phù hợp với khuôn mẫu điển hình của nội dung và
không sử dụng các API của node.
1.3.2 Người dùng (User)
Một kiểu đối tượng quan trọng khác trong Drupal là đối tượng Người dùng.
Giống như comment và node, dữ liệu người dùng cũng được lưu trữ trong cơ sở dữ
liệu và được lấy ra trong quá trình xử lý.
Thông tin về người dùng được sử dụng trong việc xác thực, định nghĩa các thiết
lập cá nhân và quyền hạn, và tạo các bản log.
8
Truy xuất và bảo mật
Các đặc quyền của người dùng được liên kết chặt chẽ với đối tượng người dùng
mà hệ thống chỉ định. Drupal có cơ chế để có thể cấp quyền cho một tập hợp người
dùng. Mặc định, mỗi người dùng được gán một vai trò và các đặc quyền được cấp phát
hoặc thu hồi qua vai trò đó.
Vì thế, khi kiểm tra truy cập đến tài nguyên, Drupal nạp một đối tượng người
dùng, tìm vài trò của người dùng đó và kiểm tra các đặc quyền của vai trò để quyết
định cho phép truy cập hay không.
Những việc này được thực hiện bởi API người dùng, người phát triển module
không cần thao tác trực tiếp với vai trò của người dùng trước khi xác định quyền hạn.
1.3.3 Khối và cách thể hiện trang
Một khái niệm quan trọng trong Drupal là Khối (block). Nếu một node được sử
dụng để lưu trữ và trình bày các bài viết và mẫu tin lớn thì khối được dùng để biểu
diễn các nội dung nhỏ hơn. Ví dụ, menu điều hướng, đoạn trích dẫn, khung bầu chọn
hay ô tìm kiếm thường được thể hiện dưới dạng các khối.
Khối không phải là một dạng nội dung mà thực chất là một đối tượng trừu tượng
được sử dụng chủ yếu để hiển thị các đối tượng nội dung khác. Người quản trị có thể
vào Block editor để chỉ định vị trí đặt các khối trong một trang giao diện:
9
Hình 1.3.3. Các vị trí đặt Blocks
Những phần được đánh dấu màu vàng ở hình trên cho thấy các vị trí mà khối có
thể được đặt.
Việc định nghĩa một block thực chất là chọn nội dung để hiển thị và chuyển đến
công cụ định dạng phù hợp.
1.3.4 Thực đơn – Menu
Một khái niệm liên quan chặt chẽ đến khối là Thực đơn. Drupal có một hệ thống
thực đơn phức tạp được sử dụng với mục đích chính là xây dựng điều hướng cho trang
web. Ví dụ, hình trên thể hiện thực đơn chính với các mục Code review, My account,
Create content... Thực đơn này được khởi tạo động bởi hệ thống thực đơn của
Drupal.
Hệ thống này còn thực hiện chức năng như một công cụ dùng để ánh xạ các URL
tới chương trình điều khiển riêng. Bằng cách sử dụng API thực đơn, người phát triển
có thể liên kết các đường dẫn tới hàm định nghĩa trước.
1.3.5 Form
Cách chủ yếu để đưa thông tin, nội dung lên Web là thông qua các form HTML.
10
Mặc dù sự phổ biến của form làm cho người dùng web thuận tiện hơn nhưng đối với
lập trình viên, có rất ít lựa chọn cho công cụ xử lý form trong việc viết mã.
Tuy nhiên, trong Drupal, form được hỗ trợ đầy đủ và mạnh mẽ. Bộ API form
(FAPI) cung cấp một giao diện lập trình linh hoạt giúp cho lập trình viên giảm bớt
lượng công việc và thời gian trong việc thiết kế và xử lý form.
Bằng cách sử dụng FAPI, người phát triển chỉ cần cung cấp thông tin một form,
Drupal sẽ xây dựng và hiển thị form đó, thu thập kết quả và thậm chí kiểm tra tính hợp
lệ của dữ liệu người dùng đưa vào.
1.3.6 API cơ sở dữ liệu và lược đồ
Nằm ở dưới các framework cung cấp ứng dụng và giao diện là một lớp chịu trách
nhiệm về quản lý và thao tác về cơ sở dữ liệu. Drupal cung cấp một API cơ sở dữ liệu
ở cấp thấp để đơn giản hoá việc viết truy vấn SQL.
API này có cơ chế bảo mật giúp kiểm soát và lọc các truy vấn, đồng thời giúp
người phát triển dễ dàng viết các đoạn mã SQL để có thể thực thi ở các cơ sở dữ liệu
khác nhau.
Ngoài ra, một API mới được giới thiệu từ phiên bản Drupal 6 là API lược đồ,
cho phép định nghĩa cấu trúc một cơ sở dữ liệu mà không cần phải viết mã SQL.
Trong khi các cơ sở dữ liệu khác nhau sử dụng các cấu trúc riêng biệt cho việc định
nghĩa bảng, API này giúp giải quyết vấn đề phát triển module có tính di động.
1.4 Hệ thống tệp tin và thư mục của Drupal
Hiểu rõ cấu trúc thư mục của Drupal giúp người quản trị quản lý website một
cách toàn diện và người phát triển có thể can thiệp sâu hơn vào hệ thống. Mặc định,
cấu trúc thư mục của Drupal được sắp xếp như sau:
Hình 1.4.a. Hệ thống tệp tin và thư mục của Drupal
Thư mục files sử dụng cho các logo tuỳ biến, hình ảnh đại diện người dùng
hoặc chứa các file đa phương tiện được tải lên website. Thư mục này phải được đặt
quyền đọc và ghi bởi web server phục vụ Drupal.
11
Thư mục includes chứa thư viện các hàm thường dùng.
Thư mục misc lưu trữ các biểu tưởng và hình ảnh dùng cho Javascript và một số
tài nguyên khác.
Thư mục profiles chứa các profile khác nhau dùng cho cài đặt và thiết lập
Drupal. Ở lần đầu tiên cài đặt, Drupal sẽ hỏi xem người dùng sử dụng profile nào.
Mục đích của các profile là giúp tự động hoá việc cài đặt bằng cách bật các module và
chức năng định sẵn trong phần nhân hệ thống để phù hợp với mục đích sử dụng
website.
Thư mục scripts chứa các tập lệnh dùng để phân tích cú pháp, dọn dẹp mã
nguồn và xử lý các tác vụ đặc biệt với cron. Những tập lệnh tiện ích này được viết
bằng ngôn ngữ shell và Perl.
Thư mục themes chứa các công cụ tạo khuôn mẫu và giao diện mặc định cho
Drupal.
Thư mục sites chứa các thay đổi đối với Drupal dưới dạng thiết lập, module và
giao diện. Các module được thêm vào sẽ nằm trong sites/all/modules. Trong thư
mục sites có thư mục được đặt tên là default chứa các thiết lập mặc định cho hệ
thống Drupal, được ghi lại trong file settings.php. Dưới đây là cấu trúc bên trong thư
mục sites:
Hình 1.4.b. Cây thư mục con của thư mục sites
12
1.5. Drupal xử lý yêu cầu như thế nào?
Nắm được cách thức Drupal xử lý yêu cầu từ phía người dùng và người quản trị
sẽ giúp lập trình viên tác động sâu vào trong hệ thống. Quá trình này có thể tự tìm hiểu
bằng cách sử dụng một bộ dò lỗi và bắt đầu từ file index.php, nơi mà Drupal tiếp nhận
hầu hết các yêu cầu.
1.5.1 Vai trò của Web server
Drupal hoạt động trên một web server, thường là Apache. Nếu web server hỗ trợ
file .htaccess, một số tuỳ chọn trong PHP sẽ được khởi tạo và chức năng URL rút
gọn cũng được bật. Chức năng này giúp chuyển các URL yêu cầu thành dạng ngắn
http://example.com/foo/bar. Đối với các web server khác như Microsoft IIS, chức
năng này được hỗ trợ trong các module interface (ISAPI – Windows Internet Server
Application Programming Interface) như ISAPI_Rewrite.
1.5.2 Quá trình khởi động
Drupal tự nạp phần khởi động khi có yêu cầu bằng cách thao tác qua một chuỗi
các bước được định nghĩa trong file bootstrap.inc. Những thao tác này gồm:
Cấu hình
Bước này sinh ra một mảng chứa cấu hình bên trong Drupal và thiết lập biến
$base_url cho trang web. File settings.php được phân tích thông qua hàm
include_once() và sử dụng các biến được nạp chồng trước đó.
Bộ nhớ đệm
Trong những trường hợp yêu cầu khả năng mở rộng hệ thống cao, một bộ nhớ
đệm cần được thiết lập trước khi kết nối cơ sở dữ liệu. Bước này cho phép dẫn giải đến
một file PHP chứa hàm page_cache_fastpath() có nhiệm vụ lấy thông tin và trả lại
dữ liệu cho trình duyệt. Chức năng tạo bộ nhớ đệm được bật bằng cách đặt giá trị
TRUE cho biến page_cache_fastpath và file được tham chiếu phải được định nghĩa
thông qua đường dẫn của biến cache_inc.
Cơ sở dữ liệu
Quá trình này xác định loại cơ sở dữ liệu được sử dụng và một kết nối ban đầu
được thiết lập để sử dụng cho các truy vấn.
Truy cập
13
Drupal cho phép ngăn chặn các truy cập từ máy khách thông qua tham chiếu IP
và tên máy. Trong bước này, hệ thống sẽ kiểm tra xem yêu cầu có phải được thực hiện
từ địa chỉ bị chặn hay không, nếu phải thì truy cập sẽ bị từ chối.
Phiên phục vụ
Drupal tận dụng lợi thế của PHP trong việc quản lý phiên đồng thời phát triển
thêm các chức năng riêng để bổ sung cho việc quản lý phiên cơ sở dữ liệu. Trong bước
này, các phiên sẽ được khởi tạo hoặc thiết lập lại.
Xử lý đường dẫn
Tại bước này, đoạn mã dùng để xử lý đường dẫn và định danh được nạp. Những
URL ở dạng rút gọn hoặc đã được chuyển sang dạng dễ đọc sẽ được phân tích thành
các yêu cầu.
Bước kết thúc
Bước này hoàn thành quá trình khởi động bằng cách nạp các thư viện và các hàm
dùng chung, bộ phận giao diện, xử lý file, mã Unicode, bộ công cụ ảnh PHP, khởi tạo
và xử lý form... Đến đây tất cả các module ở trạng thái bật cũng được nạp. Cuối cùng,
Drupal gọi hook có tên là init để các thông báo đến các module trước khi quá trình xử
lý yêu cầu chính thức bắt đầu.
Khi Drupal đã hoàn thành quá trình khởi động, tất cả các thành phần của
framework đều chuyển sang trạng thái sẵn sàng. Lúc này, hệ thống lấy và phân tích
yêu cầu từ phía trình duyệt và chuyển sang các hàm PHP tương ứng để xử lý.
1.5.3 Xử lý yêu cầu
Việc ánh xạ giữa địa chỉ URL và các hàm xử lý được thực hiện thông qua một
bước đăng ký hàm callback để quản lý URL và quyền truy cập. Các module đăng ký
hàm callback của mình bằng cách sử dụng hook menu.
Khi Drupal xác định được có tồn tại một callback đến địa chỉ URL của trình
duyệt mà yêu cầu được ánh xạ và người dùng gửi yêu cầu này có quyền truy cập
callback thì việc xử lý yêu cầu sẽ được giao cho hàm callback đó.
3, URL sẽ được ánh xạ đến hàm node_page_view() ở trong node.module. Các quá trình
xử lý tiếp theo sẽ tiếp nhận dữ liệu cho node đó từ cơ sở dữ liệu. Cuối cùng, phản hồi
sẽ được gửi trả lại trình duyệt qua bộ phận giao diện.
14
1.5.4 Giao diện hoá nội dung
Việc giao diện hoá thực chất là chuyển dữ liệu mà Drupal nhận được, dữ liệu
thông qua xử lý hay dữ liệu tự tạo ra sang dạng HTML. Drupal sẽ sử dụng giao diện
mà người quản trị chọn trước để thiết kế trang web đúng với yêu cầu và chuyển kết
quả HTML cho trình duyệt để hiển thị tới người dùng.
1.6 Công cụ dành cho người phát triển
Drupal đưa ra một số công cụ đặc thù dành cho người phát triển module Drupal.
Những công cụ này được cung cấp bởi 2 module chủ yếu, có thể lấy từ trang web của
Drupal, là module Devel và module Coder.
1.6.1 Module Devel
Module này cung cấp một số công cụ đặc biệt hữu dụng cho việc phát triển
Drupal, gồm có quản lý bộ nhớ cache, công cụ dò lỗi SQL, công cụ thăm dò, công cụ
tham chiếu API...
Thông tin chi tiết về module này có ở:
Các công cụ trên được hiển thị dưới dạng các mục trong một Khối. Vì thế, sau
khi cài đặt module Devel, người quản trị phải vào Administer | Site building |
Modules để bật module và vào mục Blocks để xác định ví trí hiện thị nội dung trên
trang chủ.
Module này còn bao gồm các công cụ để xây dựng giao diện, bộ sinh mã macro
để giả lập dữ liệu dành cho form và các dữ liệu cho quá trình testing.
1.6.2 Module Coder
Cũng như một số framework khác, người phát triển Drupal phải tuân theo những
quy ước nhất định trong việc viết mã. Module Coder là một công cụ được thiết kế
nhằm giúp xác định và sửa những đoạn mã không theo quy ước định sẵn.
Ngoài ra, công cụ này còn thực hiện một số bước kiểm tra tính bảo mật bằng
cách quản lý việc các đoạn mã được xử lý như thế nào. Chức năng này hữu ích trong
việc phát hiện các lỗi lập trình và cảnh báo trước khi trở thành các lỗ hổng bảo mật.
Thông tin chi tiết về module này có thể tìm tại trang:
15
Mặc dù không làm tăng hiệu suất trong việc phát triển như module Devel nhưng
Coder giúp tạo nên những đoạn mã gọn gàng và mang phong cách Drupal. Quá trình
kiểm tra cú pháp của công cụ này còn có thể phát hiện các lỗ hổng về bảo mật.
16
Chương 2 - Xây dựng module cho Drupal
Trong nhiều ứng dụng mã nguồn mở, người dùng có thể tuỳ biến chương trình
bằng cách thay đổi hoặc thêm các đoạn mã. Điều này dẫn đến việc mỗi khi có bản cập
nhật, người dùng phải kiểm tra xem sự tuỳ chỉnh có còn tương thích và hoạt động
đúng như mong muốn hay không. Drupal hoạt động theo một cách khác. Mọi thay đổi
và sự mở rộng được thực hiện thông qua các module. Chương này sẽ tập trung tìm
hiểu cách viết một module cho Drupal.
2.1 File .info và .module
Cấu trúc của một module có thể gồm nhiều tập tin khác nhau nhưng phải có ít
nhất một tập tin <tenmodule>.info và một tập tin <tenmodule>.module trong đó
<tenmodule> là tên của thư mục chứa module được tạo, tên này không được trùng với
các module đã tồn tại trong hệ thống.
2.1.1 File .info
Trước khi thực sự đi vào viết mã cho một module, chúng ta phải tạo ra một file
văn bản chứa các thông tin cơ bản về module đó. Một số thành phần của Drupal sẽ sử
dụng các thông tin trong file này cho việc quản lý module.
File .info được viết theo kiểu của file PHP INI, một định dạng file dùng cho
việc xác định các thiết lập. Nội dung một file .info có dạng như sau:
name = “Google Maps”
description = “Displays a map using Google Maps API”
core = 6.x
php = 5.1
Trường name khai báo tên của module, tên này sẽ hiển thị trong danh sách các
module có ở khu vực cho người quản trị. Ví dụ:
17
Hình 2.1.1. Minh họa giao diện hiển thị tên module
Trong hình trên, Aggregrator và Blog được lấy từ giá trị của trường name trong
file .info của các module tương ứng.
Tiếp theo là phần description chứa thông tin thêm về module, mô tả chức năng,
nhiệm vụ mà module sẽ thực hiện.
Name và description là hai trường bắt buộc phải có trong file .info.
Trường thông tin thứ ba là core. Mục này chỉ rõ module sẽ hoạt động tốt trên
phiên bản nào của Drupal. Giá trị 6.x cho biết module này yêu cầu phiên bản Drupal 6,
bao gồm các phiên bản nâng cấp từ bản 6. Trong nhiều trường hợp, Drupal sẽ tự động
đặt giá trị này một cách hợp lý, nhưng những người phát triển làm việc với CVS
(Concurrent Version System - hệ thống quản lý phiên bản ứng dụng) được khuyến cáo
nên tự mình đặt giá trị cho trường core.
Chỉ dẫn cuối cùng trong file .info trên là php, cho biết phiên bản tối thiểu của
PHP mà module yêu cầu.
Ngoài ra, các module phức tạp hơn còn có thêm một số trường thông tin trong
file .info như:
- Package: nhóm các chức năng của module, nếu không khai báo package thì module
được đưa vào nhóm “other”.
- Dependencies: các module phụ thuộc, cách nhau bằng khoảng trống. Nếu module
được yêu cầu chưa được bật trên hệ thống thì module này không thể bật được.
Sau khi có file .info, chúng ta bắt đầu việc viết mã cho module trong file
.module.
18
2.1.2 File .module
File .module là file quan trọng nhất trong một module, chứa các đoạn mã PHP
thực hiện chức năng của module đó. File này thông thường sẽ mở rộng một số hàm
hook mà Drupal gọi tại các thời điểm nhất định đối với một yêu cầu.
Cũng giống như file .info, file .module được đặt tên theo quy tắc
<modulename>.module, trong đó <modulename> là tên thư mục chứa module.
Nội dung file .module bắt đầu bằng thẻ <?php, sau đó là mã nguồn. Theo quy ước
của Drupal, file này sẽ không chứa dấu đóng ?>. Việc này giúp tránh in những ký tự
trống trong đầu ra của mã kịch bản trong một số trường hợp. Ví dụ, nếu các ký tự
trống được xuất ra trước khi phần thông tin header của HTML gửi đi, ở trình duyệt
máy khách sẽ xuất hiện thông báo lỗi trên đầu của trang web.
Mã nguồn chi tiết của file này sẽ được đề cập trong những phần tiếp theo.
2.2 Chú thích trong mã nguồn
Như đã đề cập ở trên, Drupal tuân theo các tiêu chuẩn viết mã và tài liệu một
đó là chuẩn viết chú thích trong mã nguồn.
Mở đầu các module và hàm trong đó, lập trình viên phải chú thích rõ ràng và đầy
đủ chức năng của khối mã tiếp theo đó. Ví dụ, dưới đây là chú thích của module
GoogleMaps:
/**
* @file
* Module for displaying a map from Google Maps.
* This module provides block content retrieved from
* Google Maps data.
*/
Phần này chính là tài liệu cho API, chứa trong một khối chú thích đặc biệt bắt
đầu bằng /** và kết thúc với */. Tất cả các dòng nằm trong cặp dấu này đều được coi
là tài liệu và sẽ không được trình biên dịch xử lý.
Trong ví dụ trên có hai định danh là @file và @see. Định danh @file cho biết
khối này sẽ chú thích cho toàn bộ file, không phải cho riêng một hàm hay biến ở trong
19
file.
Định danh @see chỉ dẫn bộ xử lý tài liệu liên kết file này đến thông tin ở các
nguồn khác. Trong ví dụ, nguồn dẫn là một địa chỉ URL. Các hàm, hằng số và biến
cũng được tham chiếu bởi định danh @see. Trong các trường hợp này, bộ xử lý tài liệu
sẽ liên kết khối chú thích đến thông tin API của các đối tượng tương ứng.
Khi chú thích cho một hàm, các định danh khác sẽ được sử dụng. Ví dụ:
/**
* Retrieve information from the Goodreads bookshelp XML API.
*
* This makes an HTTP connection to the given URL, and
* retrieves XML data, which it then attempts to format
* for display.
*
* @param $url
* URL to the goodreads bookshelf.
* @param $num_items
* Number of items to include in results.
* @return
* String containing the bookshelf.
*/
Khối này bắt đầu bằng một câu khái quát về chức năng của hàm, theo sau là các
dòng chú thích chi tiết hơn. Từ khoá định danh @param được dùng để mô tả về các
tham số mà hàm này sử dụng, bao gồm thông tin về loại dữ liệu. Từ khoá này được
khai báo theo theo định dạng: @param <tên_biến> <mô tả>. Một định danh khác được
sử dụng cho chú thích hàm là @return cho biết giá trị mà hàm sẽ trả về.
Từ những chú thích này, người phát triển có thể sử dụng những chương trình
phân tích tài liệu như Doxygen để trích ra làm tài liệu dành cho người dùng.
2.3 Một số hook cơ bản
- Hook block:
Hook này được sử dụng để tạo một block hiển thị thông tin. Khi hook_block
được gọi, Drupal sẽ truyền 3 tham số vào hàm: $op, $delta và $edit.
20
Tham số $op chứa thông tin về loại thao tác mà module sẽ thực hiện. Tham số
này có thể nhận một trong 4 giá trị sau:
list: Giá trị này được dùng khi module cung cấp thông tin về chính nó. Ví dụ, ở
danh sách các module hiển thị trong khu vực quản trị, tham số $op sẽ được đặt là list.
view: Giá trị này được truyền vào khi Drupal muốn hook block cung cấp thông
tin để hiển thị cho người dùng.
configure: Dùng để điều chỉnh các thiết lập cho block.
save: Giá trị này được dùng khi thông tin về thiết lập của block lấy từ form dữ
liệu sinh ra bởi configure cần được lưu lại.
Tham số $delta được đặt phụ thuộc vào các thao tác nhất định của module. Khi
$op có giá trị là view thì $delta sẽ được đặt. Tham số này chứa các thông tin thêm về
nội dung sẽ hiển thị trong block. Bằng cách sử dụng $delta, một hàm hook_block()
có thể hiển thị nhiều block khác nhau. Nội dung nào trong block sẽ được sử dụng tuỳ
thuộc vào giá trị của $delta được truyền vào.
Cuối cùng là tham số $edit, được sử dụng trong quá trình điều chỉnh các thiết
lập của block (khi thao tác save được gọi). $edit thực chất là một mảng chứa các thay
đổi mà người quản trị thực hiện lên các thiết lập của block.
Giá trị trả về của hàm này phụ thuộc vào thao tác mà nó thực hiện. Thông
thường, hàm sẽ trả về một mảng chứa thông tin của block (info), tiêu đề (subject) và
nội dung (content).
- Hook help:
Hook này được dùng để cung cấp các thông tin trợ giúp cho người sử dụng. Hàm
hook_help() nhận hai tham số: $path chứa một đoạn URI cho biết trang trợ giúp nào
được gọi, và tham số $arg chứa một số thông tin thêm.
Với các trường hợp phức tạp, lập trình viên có thể sử dụng phát biểu switch đối
với giá trị của $path để trả về các văn bản trợ giúp khác nhau đối với mỗi đường dẫn.
Giá trị này tuân theo định dạng admin/help#<module name> , trong đó <module name>
được thay bằng tên của module tương ứng. Kết quả của hàm này được hiển thị tại mục
Administer | Help page:
21
Hình 2.3.a. Minh họa nội dung sử dụng hook_help().
- Hook user:
Mặc định, mỗi người dùng đã đăng ký đều có thể truy cập trang My account để
xem thông tin tài khoản của họ. Địa chỉ URL của trang này có dạng:
Hình 2.3.b. Giao diện thông tin tài khoản người dùng
Trang thông tin người dùng cũng có thể được truy cập bởi một người quản trị có
quyền tương ứng. Phần lớn nội dung của trang này được tạo ra bởi hook_user(). Bằng
cách triển khai hook này trong module, người phát triển có thể liên kết với giao diện
quản lý người dùng.
Thực ra, hook người dùng làm được nhiều việc hơn là hiển thị trang tài khoản
người dùng. Trong Drupal 6 có 13 thao tác mà hook này thực thi, bao gồm việc thêm,
sửa chữa hoặc xoá bộ ghi nhớ đăng nhập.
Một bản triển khai của hook_user() sẽ nhận 4 tham số sau:
$op: Tên của thao tác mà người dùng thực hiện. Tham số này nhận 1 trong 13 giá
trị tương ứng với 13 thao tác (view, login, delete...).
$edit: Một mảng chứa các giá trị được gửi lên từ một form. Giá trị này được
truyền vào qua tham chiếu &$edit và được sử dụng bởi các thao tác xử lý dữ liệu như
insert.
22
$account: Dùng để chứa đối tượng tài khoản cho một người dùng nhất định.
Tham số này cũng được truyền qua tham chiếu &$account.
$category: Một vài thao tác sử dụng tham số này để xác định phần nào của thông
tin người dùng sẽ được trích xuất cho yêu cầu.
Chi tiết về hook này xem tại địa chỉ
- Hook mail:
Phần lớn các yêu cầu về việc gửi email trong Drupal đều được hỗ trợ bởi các
hàm có trong Mail API nên người phát triển không cần phải viết mã cho những thao
tác này. Tuy nhiên, tuỳ theo yêu cầu, người phát triển có thể tuỳ chỉnh định dạng của
thông điệp, và việc này được thực hiện thông qua hook_mail(). Việc triển khai hook
này cho phép thiết lập các phần đầu và thân của thông điệp trước khi gửi đi.
Khi hàm triển khai hook mail được thực thi, nó sẽ truyền 3 tham số sau:
$key: Một khoá dạng chuỗi dùng để xác định thông tin về việc thông điệp sẽ
được định dạng như thế nào.
$message: Là cấu trúc dữ liệu thể hiện thông điệp mà Drupal đã khởi tạo trước
đó. Tham số này phải được truyền dưới dạng tham chiếu &$message nếu muốn thay
đổi giá trị.
$params: Một tập các tham số được truyền vào từ lời gọi hàm drupal_mail() của
module.
- Hook view:
Trước khi một node được hiển thị đến người dùng, thông tin của nó có thể được
cập nhật bằng cách sử dụng hook_view(). Hook này được gọi khi hệ thông nạp một
đối tượng $node, nhưng vào thời điểm trước khi node được hiển thị. Hàm này sẽ cần
thiết trong một số trường hợp mà nội dung của node có thêm một số trường thông tin
Drupal chưa xử lý được.
Đồng thời, hook này sẽ cung cấp thêm thông tin cho hệ thống giao diện để có thể
biểu diễn nội dung như mong muốn của người dùng.
Hàm triển khai của hook này sẽ nhận 3 tham số:
$node chứa đối tượng node cần hiển thị.
$teaser là cờ đánh dấu cho biết bài viết sẽ được hiển thị đầy đủ hay chỉ có bản
23
Tải về để xem bản đầy đủ
58 trang
25/04/2025
300
Bạn đang xem 30 trang mẫu của tài liệu "Luận văn Phát triển ứng dụng dịch vụ hướng vị trí trên nền Drupal", để 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_phat_trien_ung_dung_dich_vu_huong_vi_tri_tren_nen_d.pdf
