ruby on rails

1. CÁC VẤN ĐỀ HIỆN ĐẠI CỦA CÔNG NGHỆ PHẦN MỀM
Chủ đề: Tổng quan về ngôn ngữ Ruby
Giảng viên: TS. Trương Anh Hoàng
Thành viên:
Nhữ Tuấn Anh
Đào Đức Thịnh
Đàm Thái Nhiên
Hà Nội 01/10/2012

2. Mục lục
Chương 1: Ngôn ngữ lập trình Ruby .............................................................................................. 4
1. Lịch sử hình thành.....................................................................................................................4
2. Giới thiệu về ngôn ngữ ruby .....................................................................................................4
3. Xem mọi thứ như hướng đối tượng ..........................................................................................4
4. Ruby là một ngôn ngữ mềm dẻo và linh hoạt...........................................................................5
Chương 2: Ngôn ngữ Ruby............................................................................................................. 6
1. Biến trong ruby .........................................................................................................................6
2. Các dạng dữ liệu trong ruby......................................................................................................6
2.1. Số .......................................................................................................................................6
2.2. Ký tự ..................................................................................................................................6
3. Mảng trong ruby........................................................................................................................7
4. Cấu trúc điều khiển trong ruby .................................................................................................7
5. Vòng lặp trong ruby..................................................................................................................9
5.1. While..................................................................................................................................9
5.2. Util.....................................................................................................................................9
5.3. For......................................................................................................................................9
5.4. Cấu trúc liệt kê...................................................................................................................9
5.5. Hash.................................................................................................................................10
5.6. Có một vấn đề trong đây là Blocks..................................................................................11
6. Lớp và modules.......................................................................................................................12
7. Thừa kế trong Ruby ................................................................................................................14
Chương 3: Framework Rails......................................................................................................... 16
1. Thế nào là framework .............................................................................................................16
2. Mô hình MVC.........................................................................................................................16
2.1. Khái quát về mô hình MVC.............................................................................................16
2.2. Các thành phần của mô hình MVC..................................................................................16
2.3. Ưu và nhược điểm của mô hình MVC ...........................................................................17
3. Ruby on Rails..........................................................................................................................18
3.1. Nguồn gốc của Rails........................................................................................................18
3.2. Mô hình MVC với Rails..................................................................................................18
3.3. Tự động sinh code trong Rails.........................................................................................19
3.4. Vòng đời phát triển một ứng dụng trong Rails................................................................19

3. 3.5. So sánh Ruby on Rails với Java và PHP .........................................................................20
Chương 4: Cài đặt và phát triển môi trường Rails........................................................................ 22
1. Các môi trường cụ thể để phát triển Ruby on Rails................................................................22
2. Cách cài đặt môi trường phát triển Ruby on Rails..................................................................22
3. Cài đặt công cụ hỗ trợ code.....................................................................................................22
Chương 5: Những vấn đề cụ thể của Rails.................................................................................... 24
1. Bộ công cụ để phát triển .........................................................................................................24
2. Đặc điểm cơ bản với cơ sở dữ liệu của Ruby on Rails...........................................................25
2.1. Giới thiệu Active Record.................................................................................................26
2.2. Đánh giá Active Record với các hệ csdl khác .................................................................26
2.3. Thao tác sử dụng Active Record .....................................................................................26
Chương cuối: Tổng kết ................................................................................................................. 28
Phụ Lục ......................................................................................................................................... 28
Tài liệu tham khảo........................................................................................................................ 28

4. Chương 1: Ngôn ngữ lập trình Ruby
1. Lịch sử hình thành
Ruby là một ngôn ngữ lập trình hướng đối tượng, có khả năng reflection. Cú pháp bị ảnh hưởng
từ Ada và Perl với các đặc tính hướng đối tượng của Smalltalk, và cũng chia sẻ một số đặc tính
với Python, Lisp, Dylan và CLU.
Ruby được tạo ra bởi Yukihiro “Matz” Matsumoto từ 24 tháng 2, 1993 và đưa ra bản chính thức
vào năm 1995.
Ruby chịu nhiều ảnh hưởng từ Perl, và khi hoàn tất ngôn ngữ này, anh đã đùa với một
người bạn rằng nên đặt tên thế nào nghe cho nó giống một thứ đá quý nào đó (Perl lúc đầu cũng
được đặt tên là Pearl - ngọc trai). Và bạn của anh đã gợi ý cái tên Ruby. Sau này Matz cũng bất
ngờ khi phát hiện ra Pearl là viên đá quý tượng trưng cho những người sinh tháng 6, còn Ruby
thì tượng trưng cho những người sinh tháng 7. Anh cho rằng cái tên Ruby như thế là phù hợp vì
Ruby kế thừa và phát triển nhiều đặc tính từ Perl.
Tháng 9 năm 2005, phiên bản ổn định mới nhất là 1.8.3. Ruby 1.9 (với một số thay đổi)
cũng đang trong quá trình phát triển.
2. Giới thiệu về ngôn ngữ ruby
Thay vì định nghĩa về Ruby tôi xin trích nguyên văn lời giới thiệu về Ruby của cộng đồng
Ruby như sau: “Ruby là một ngôn lập trình mã nguồn mở, linh hoạt, với một sự nổi bật về sự
đơn giản dễ dùng và hữu ích. Nó có cú pháp “tao nhã” và tự nhiên dễ đọc và dễ dàng để
viết”.
Và theo như tác giả của ngôn ngữ Ruby, anh Yukihiro “matz” Matsumoto người Nhật, thì tác
giả là một người rất ưa thích các ngôn ngữ như: Perl, Smalltalk, Eiffel, Ada, và Lisp. Tác giả
đã cố gắng kết hợp một cách thận trọng các ngôn ngữ này với nhau từ đó tạo ra Ruby. Có lẽ
chính vì vậy mà Ruby là một ngôn ngữ với các câu lệnh và cú pháp khá quen thuộc khi được
học.
Một vài đặc điểm nhận thấy ở ngôn ngữ Ruby là:
 Ruby có cú pháp ngắn nhưng có thể làm được nhiều việc.
 Ruby là ngôn ngữ rất hướng đối tượng.
3. Xem mọi thứ như hướng đối tượng
Với Ruby, mọi thứ đều là một đối tượng. Mọi bit thông tin hay code đều có thể được đưa ra
cho chính chúng việc sở hữu các thuộc tính hay hành động. Trong lập trình hướng đối
tượng thì các thuộc tính gọi là các biến thực thể (instance variables) và các hành động gọi
là các phương thức. Ruby là một hướng đối tượng “tinh khiết”, điều này có thể thấy bằng
một bit của code mà thực hiện một hành động với một con số. Số 5 cũng được coi là một đối

5. tượng và có phương thức làm times. Đoạn code dưới sẽ in ra 5 lần dòng “We *love* Ruby”:
5.times{ print "We *love* Ruby" }
Đa số các ngôn ngữ khác, con số và một số kiểu dữ liệu nguyên thủy khác thì không được coi
là hướng đối tượng. Nhưng Ruby theo sự ảnh hưởng lớn của ngôn ngữ Smalltalk bằng việc
đưa ra các phương thức và thực thể biến tới tất cả các kiểu của nó. Điều này tạo nên sự thống
nhất và dế dàng khi sử dụng Ruby với tất cả các đối tượng.
4. Ruby là một ngôn ngữ mềm dẻo và linh hoạt
Ruby được coi là một ngôn ngữ mềm dẻo và linh hoạt, từ khi nó cho phép người dùng tự do
sửa đổi cả phần cốt lõi của nó. Các phần cốt lõi của Ruby có thể được rời đi hoặc định nghĩa
lại như ý muốn. Các phần hiện hữu có thể được thêm vào. Ruby cố gắng không hạn chế các
nhà lập trình.

6. Chương 2: Ngôn ngữ Ruby
Trong chương này sẽ nói qua tổng thể những vấn đề cơ bản với Ruby. Các bạn sẽ hiểu những
cái cơ bản nhất về Ruby. Và các bạn có thể thao tác cơ bản với những vấn đề của ngôn ngữ
Ruby.
1. Biến trong ruby
Biến của ruby không cần khai báo kiểu. Khi gán giá trị cho biến nó sẽ tự động nhận kiểu, nhận
các giá trị cho biến.
Ví dụ:
User =”user”
Puts user => user
Khai báo biến của ruby làm cho ngôn ngữ trở lên linh hoạt hơn.
Biến toàn cục của ruby: khi thêm @ trước biến thì nó trở thành biến toàn cục để sử dụng khi tác
động trong chương trình.
Còn khi không có @ thì nó là biến địa phương chỉ được sử dụng trong một phần nào đó của
chương trình.
Mỗi biến của ruby là một đối tượng. Nhờ vào vấn đề này, bạn có thể tác động đến từng vấn đề
của biến: như chuyển kiểu, ghép các biến với nhau.
Nhờ có tính chất trên các biến trong ruby có thể tương tác với nhau một cách dễ dàng. Ví dụ:
@u =”Ngon ngu”
“{#@u} lap trinh”=> “Ngon ngu lap trinh”
Cũng có thể đảo ngược chuỗi hoặc viết hoa …
2. Các dạng dữ liệu trong ruby
Ruby là một ngôn ngữ hướng đối tượng. Ở đây các thành phần dữ liệu từ số, ký tự, mảng đều
được xây dựng trên cơ sở các lớp.
2.1. Số
Cấu trúc phân cấp dữ liệu dạng số trong Ruby: Các dang dữ liệu kiểu số được xây dựng từ lớp
Numeric. Kiểu số nguyên: Integer có hai dạng là Fixnum với độ dài 31 bits và Bignum có độ
dài tùy ý. Kiểu số thực được thể hiện qua lớp Float. Bên cạnh đó một số kiểu dữ liệu khác
không có sẵn nhưng được đinh nghĩa trong thư viện chuẩn của Ruby.
2.2. Ký tự
String là lớp dùng để thể hiện chuỗi ký tự. Khác với Java String trong Ruby là “mutable” .
String trong Ruby có thể được khai báo trong dấu ngoặc đơn hoặc ngoặc kép. Với dạng chuỗi
được đặt trong dấu nháy đơn ‘’ thì ký tự chỉ có ý nghĩa khi sau nó là ký tự hoặc ‘. Bên cạnh

7. đó chuỗi trong nháy đơn được viết xuống dòng thì nó sẽ được hiển thị thành nhiều dòng tương
ứng.
Với dạng chuối trong dấu nháy kép “” thì nhiều ký tự đặc biệt được hỗ trợ, ví dụ như n, t như
trong java. Bên cạnh đó chuối trong dấu nháy kép còn có thể hiện thị kết quả của biểu thức
trong nó thông qua ký tự #.
3. Mảng trong ruby
Mảng có thể khai báo trực tiến hoặc thông qua đối tượng Array.
Ví dụ:
Arr= [1,2,3,4,5,6]
Arr= Array.new
Cách đánh chỉ số mảng trong Ruby được đánh từ 0 đến số phần tử -1.
Ruby việc sắp xếp các thành phần mảng khá linh hoạt và mềm dẻo.
Ta có thể khai báo mảng một chiều gồm các phần tử đơn: arr = [1,2,3,4,5,6].
Hoặc mảng lồng: arr = [[1,2],[3,4,5,6],[7,8,9]].
Hoặc mảng được trích xuất subArr = arr[0,2]#subArr = [[1,2],[3,4,5,6]].
Các mảng có thể tương tác với nhau thông qua các toán tử như +,-,*…
Với phép + ta có thể cộng hai mảng với nhau: ar= [1,2,3] +[4] # ar=[1,2,3,4]
Với phép trừ các phần tử mảng ở mảng trừ sẽ loại bỏ các phần tử có trong mảng bị trừ.
ar= [1,2,3] -[2] # ar=[1,3]
Với phép nhân, ta có thể nhân một mảng với một số và kết quả cho ta số phần tử mảng được lặp
lại theo giá trị được nhân: ar= [1,2,3]*2 # ar= [1,2,3,1,2,3]
Các mảng có thể đính thêm phần tử với phép toán <<: ar= [1,2,3]<<4 # ar= [1,2,3,4]
Và các phép so sánh: |, &. Với | các giá trị trùng lặp của hai mảng sẽ được bỏ đi ( kể cả các
phần tử trùng lặp trong 1 mảng. ar = [1,2,2,4,3,4] | [] # ar[1,2,4,3]. Trong khi đó với phép toán
& các phần tử trùng nhau được giữ lại ( và không lặp). ar = [1,2,2,4,3,4] & [4,4] # ar[4]
4. Cấu trúc điều khiển trong ruby
if <<điều kiện>>
<>
end
<> if <<điều kiện>>
if-else
if <<điều kiện>>
<>
else
<>

8. end
elsif
if <<điều kiện>>
<>
elsif<<điều kiện>>
<>
elsif<<điều kiện>>
<>
end
unless
unless <<điều kiện>>
<>
end
unless cũng có thể được sử dụng với else như trường hợp của if.
case
Case trong Ruby không lằng nhằng như trong java ( quên break là cả một vấn đề rồi). Ở đây có
thể sử dụng cấu trúc elseif để đưa ra khối điều khiển giống như trong khối điều khiển case, tuy
nhiên cú pháp case vấn thường được sử dụng nhiều hơn.
case
when <> then <>
when <> then <>
when <> then <>
end
Chú ý là ở đây nếu có nhiều hơn một điều kiện đúng thì hành động của điều kiện đầu tiên sẽ
được thực hiện
Ví dụ
x=1
a=case
when x>0 then
puts "x is 1"
puts "hehe"
when x==2 then puts "x is 2"
when x<3 then "three"
end
puts a
Kết quả sẽ là
x is 1

9. hehe
nil
* cấu trúc ?: trong Ruby giống như trong java nhưng được mô tả như cấu trúc if với ? là then và
: là else
Ruby cũng cung cấp hỗ trợ một số từ khóa hỗ trợ điều khiển cấu trúc chương trình như: return,
break, next …
5. Vòng lặp trong ruby
5.1. While
While<> do begin
<> <>
End while
5.2. Util
Util <<condition>>do begin
<<actions>> <<actions>>
End end
Util<<conditions>>
5.3. For
for <<variables>> in <<collection>> do
<<actions>>
end
5.4. Cấu trúc liệt kê
+ Với đối tượng số
upto/downto
0.upto(9){|s| print s}
times
10.times{|s| print s}
step
0.step(9,1){|x| print x}
+ Với Array, Range
each
(1..9).each{|s| print s}
Result: 123456789
collect
result = (2..4).collect{|s| s*s*s}

10. puts result
Result:
8
27
64
select
positive = [1,-2,3,4,-9].select{|s| s>0}
puts positive
Result:
1
3
4
reject
negative = [1,-2,3,4,-9].reject{|s| s>0}
puts negative
Result:
-2
-9
5.5. Hash
Mảng Hash cũng không có gì đặc biệt so với các mảng thông thường. Thay vì mảng Array chỉ
chấp nhận các chỉ số (index) là dạng Integer thì mảng Hash chấp nhận bất kỳ Object nào vẫn
được xem như một chỉ số
Ví dụ: với mảng Array
persons = ["Ho Chi Minh","Nhan vat lich su","yeu nuoc"]
Giả sử nếu muốn biết chính xác tên nhân vật là gì, xếp loại nhân vật, tính cách là gì ,… thì phải
cần tới class Hash
persons = {
"ten"=>"Ho Chi Minh",
"xep loai"=>"Nhan vat lich su",
"tinh cach"=>"yeu nuoc"
}
Với mảng Hash, ta có persons[xep loai] = "Nhan vat lich su"
Mảng Hash không sử dụng chỉ số (index) để truy vấn dữ liệu mà sử dụng từ khóa (clef) để liên
kết với dữ liệu liên quan
Mảng Hash cũng giống như mảng Array nên được thừa hưởng phương thức each
persons = {

11. "ten" => "Ho Chi Minh",
"xep loai" => "Nhan vat lich su",
"tinh cach" => "yeu nuoc"
}
persons.each do |clef,value|
puts clef + "=>" + value
end
5.6. Có một vấn đề trong đây là Blocks
Trong quá trình sử dụng các cấu trúc liệt kê, chúng ta thường thấy một nhóm các câu lệnh nằm
trong cặp ngoặc nhọn hoặc trong long khối begin/end. Người ta gọi đó là block. Thông
thường block bao giờ cũng được thực hiện sau lời gọi hàm
Ví dụ:
10.downto(0){|x| print x}
Ở đây khối |x| print x được thực hiện sau lời gọi hàm và đó là block. Theo quy ước thì với với
block trong phạm vi một dòng ta nên dùng ngoặc nhọn còn với block có nhiều dòng ta nên sử
dụng do .. end
Chú ý là trong block, giá trị trả về được thông qua câu lệnh next chứ không phải là return (chỉ
trả về giá trị cho hàm đóng).
Cấu trúc hàm trong Ruby
def <> (<>)
Ví dụ:
def squareRootOf(n,loop)
ini = n/2
loop.times {ini = (n/ini + ini)/2}
return ini
end
Một điểm đặc biệt ở đây là nhiều giá trị có thể đồng thời được trả về trong một phương thức.
Các giá trị trả về sẽ được tập hợp trong một mảng.
Ví dụ:
def multiValuesReturn()
return 1
end
arr = multiValuesReturn
arr.each {|x| print x}
procs và lambdas

12. procs và lambdas là hai cách thức để đưa blocks vào trong đối tượng. Tùy thuộc vào cách mà
đối tượng được tạo ra ta sẽ có procs haylambdas.
Tạo procs
def createProcs(&p)
p
end
exp = createProcs{|x,y| x**y}
Hoặc
exp = Proc.new{|x,y| x**y}
Gọi procs
puts exp.call(2,3)
Tạo lambdas
incre = lambda{|x| x+1}
hoặc
incre= ->(x){x+1} # ruby version 1.9
hoặc
incre=->(x;step=2){x+step} # Một tham số x và biến nội bộ step
Gọi lambdas
puts incre.call(2)
Closures
Closures là một khái niệm chỉ một hàm sử dụng một biến giới hạn. Thông thường closures dùng
để nói đến hàm lồng. Ở đó hàm bên trong sử dụng biến được khai báo bởi hàm chứa nó. Ở
Ruby, khái niệm này thường được thể hiện bởi các khối lambdas hoặc procs.
Ví dụ
def mainFunction(n,m)
lambda{|x| x*n/m}
end
myLambda = mainFunction(2,4)
puts myLambda.call(2)
Kết quả ở đây là 1
6. Lớp và modules
Là một ngôn ngữ hướng đối tượng, khái niệm lớp là thành phần cơ bản trong Ruby. Lớp được
khai báo như sau:
class <<name_of_class>>
<<body_of_class>>
end

13. Khới tạo class
<<name_of_class>>.new
Hàm khởi tạo trong lớp. ( giống như hàm tạo và khởi tạo giá trị trong java)
def initialize(<<var1>>,<<var2>>)
<<khới tạo các giá trị>>
end
Đối với các hàm việc xác định khả năng truy cập được thông qua các từ
khóa public , private, protected giống như Java. Tuy nhiên ở Java chúng ta có thêm default và
được coi như mặc định trong khai báo còn ở đây public được coi là mặc định trong khai
báo. Public cho phép các hàm được truy nhập từ bất kỳ đâu trong khi private chỉ cho các hàm
được truy nhập từ các thành phần khác trong lớp đó và các lớp con của
nó, protected giống private chỉ khác ở chỗ các hàm protected có thể được gọi bởi các thực thể
của chính lớp đó hoặc với sefl.
class Test
private
def myTest()
puts "test"
end
protected
def proTest()
puts "pro"
end
public
def testTest()
theTest = Test.new
theTest.proTest()
end
def testPrivate()
theTest = Test.new
theTest.myTest()
end
end
a = Test.new
a.testTest()# =>pro
a.testPrivate()#=> error in red as below
Kết quả:
pro

14. HelloWorld.rb:20:in `testPrivate': private method `myTest' called for #(NoMethodError)
from HelloWorld.rb:28
Bên cạnh đó ở Ruby các biến trong lớp đều được đặt là private, trong khi các hằng số đều
là public.
7. Thừa kế trong Ruby
Là ngôn ngữ hướng đối tượng nên Ruby có đầy đủ các tính chất như tính đa hình, đóng gói…
và kế thừa
class Parent
def printOut
puts "This is Parent class"
end
end
class Child <>
def printOut
puts "This is Child Class"
end
end
Modules
Modules là nhóm các thành phần hàm, biến, hằng số và chạy độc lập
module MyModule
def MyModule.intro
puts "This is the intro of modul"
end
def MyModule.sayHello
puts "Hello"
end
end
class MyClass
include(MyModule)
def sayHello
MyModule.sayHello
end
end
myClass = MyClass.new
myClass::sayHello

15. Một chương trình có thế gồm nhiều file, và với ngôn ngữ script như Ruby thì việc phân chia
chương trình thành các file chứa các module khác nhau.Các file này sau đó có thể được sử dụng
thông qua lời gọi require hoặc load trong chương trình chính.

16. Chương 3: Framework Rails
Đến với chương này các bạn có thể biết được thế nào là một framework, mô hình kiến trúc của
nó, những đặc điểm của framework Rails và những đánh giá của nó với các framework khác.
1. Thế nào là framework
Framework là những thư viện code, được thiết kế để giúp đỡ trong việc phát triển phần mềm.
Framework tạo ra một bộ ứng dụng thiết kế dựa vào những thư viện phát triển theo ngôn ngữ
để tạo người lập trình dễ dàng để phát triển những phần mềm một cách nhanh nhóng và hiệu
quả.
Khi phát triển một phần mềm dựa vào một framework nào đó thì việc phát triển nó trở lên thuận
lợi với người lập trình bởi vì nó giảm bớt thời gian tập trung vào việc code hơn để có thể tập
trung vào việc giải quyết những vấn đề liên quan đến logic điều đó làm tăng hiệu quả của người
lập trình.
2. Mô hình MVC
Ngày này các framework về thiết kế website hầu như đều sử dụng mô hình MVC để phát triển.
vậy mô hình này có những đặc điểm gì mà các framework được sử dụng nó để phát triển như
vậy?
2.1. Khái quát về mô hình MVC
MVC là viết tắt của Model – View – Controller. Nó là một kiến trúc phần mêm hay mô hình
thiết kế được sử dụng trong kỹ thuật phần mềm, giúp cho người lập trình tách ứng dụng của họ
thành ba thành phần khác nhau Model, View và Controller. Mỗi thành phần có một nhiệm vụ
riêng biệt và độc lập với thành phần khác.
2.2. Các thành phần của mô hình MVC
Dưới đây là sơ đồ của mô hình MVC:

17. Các thành phần trong mô hình MVC có mỗi quan hệ chặt chẽ với nhau. Các thao tác của nó
được lặp lại mỗi khi tiếp nhận yêu cầu của người dùng.
Như hình trên có thể thấy mô hình MVC gồm 3 thành phần chính: Model, View và Controller.
Model:
Gồm mọi hoạt động liên quan đến cơ sở dữ liệu, các thao tác với cơ sở dữ liệu đều được thực
hiện ở đây gồm: chuẩn hóa, phân tích đánh giá…
View:
Phần này liên quan đến người dùng. Nó là phần hiển thị với người dùng. Nó đưa thông tin cụ
thể đến với người dùng một cách cụ thể nhất. Và nó cũng nhận tương tác giữa người dùng và hệ
thống .
Controller
Controller chịu trách nhiệm phân phối ứng dụng. Nó nhận sự kiện từ bên ngoài, rồi tương tác
với Model để xử lý thông tin. Sau khi xử lý tác động liên quan đến hệ thống thì nó truyền đến
View để hiển thị với người dùng.
Như vậy dễ dàng thấy rằng sự tương tác giữa các thành phần trong mô hình đều thông qua
controller. Controller là cầu lối giữa View và Model. Nó điều khiển dữ liệu rồi sau đó đưa ra
những thông tin cần thiết cho người dùng.
2.3. Ưu và nhược điểm của mô hình MVC
 Ưu điểm của mô hình MVC:
 Mô hình MVC làm tăng khả năng phát triển và mở rộng ứng dụng.
 Mô hình MVC khiến cho việc bảo trì trở lên dễ dàng hơn: vì các thành phần phụ thuộc
thấp với nhau, vì vậy khi thay đổi một cái thì không ảnh hưởng đến cái khác.

18.  Các thành phần trong mô hình MVC được sử dụng lại: ví dụ một model có thể sử dụng
cho nhiều phần hiển thị và ngược lại cũng vậy.
 Mô hình MVC có thể phân tán: sự chia sẽ cách biệt về code giữa các thành phần có ý
nghĩa là mỗi thành phần trong chúng có thể ở trên một máy tính riêng, nếu thấy cần thiết.
 Nhược điểm của mô hình MVC: Đối với dự án nhỏ áp dụng mô hình MVC gây cồng
kềnh, tốn thời gian trong quá trình phát triển và tốn thời gian luân chuyển qua các tầng.
3. Ruby on Rails
3.1. Nguồn gốc của Rails
Đầu tiên, tôi muốn giới thiệu với các bạn nguồn gốc hình thành framework Ruby on Rails.
Rails ra mắt công chúng lần đầu tiên vào năm 2004, Rails thoạt đầu được dùng như là nền
tảng cho một công cụ quản lý dự án được đặt tên là Basecamp và được tạo ra bởi nhà
phát triển web David Heinemeier Hansson, một nhân viên của công ty phát triển web
37signals (Mỹ). Ban đầu họ xây dựng Rails không phải với mục đích là xây dựng ra một
framework riêng, chủ tâm ban đầu là dùng nó để xây dựng các ứng dụng khác của 37signals.
Sau đó Heinemeier Hansson thấy tiềm năng của nó giúp cho anh ấy làm các công việc dễ dàng
hơn bằng cách rút ra các tính năng phổ biến như trừu tượng cơ sở dữ liệu và khuôn
mẫu(template) bên trong, và sau đó nó trở thành phiên bản đầu tiên được tung ra của Ruby on
Rails.
Trên thực tế Rails được rút trích từ Basecamp, một chương trình mà được cộng đồng Rails
cho là trong quá trình làm chương trình đó thì đã gặp và giải quyết được rất nhiều các vấn đề
phức tạp. Và Rails, một framework bắt nguồn từ chương trình đó thì nó đã thừa kế được
những sức mạnh từ dự án đó. Vì vậy Rails luôn sẵn sàng có thể giải quyết được các vấn đề
thực tế tồn tại trong quá trình phát triển web. Ngoài ra, ban đầu Rails được xây dựng ra còn với
mục đích là để xây dựng các ứng dụng khác từ nó, bởi vậy Rails trước khi xuất hiện trên
thế giới thì nó đã chứng minh được bản thân nó là một framework rất hữu dụng, chặt chẽ và
toàn diện.
Sau khi phiên bản đầu tiên được tung ra thì cộng đồng Rails cũng đã đóng góp bổ sung
hàng mở rộng nó, và sửa các lỗi được tìm thấy. Và phiên bản mới nhất của Rails bây giờ là
phiên bản 2.0.2.
3.2. Mô hình MVC với Rails
Hiện nay mô hình MVC đang được sử dụng hầu hết các framework phát triển ứng dụng web.
Rails cũng không là ngoại lệ. Rails dự trên mô hình MVC để phát triển framework của mình.
Cấu trúc của mô hình MVC rất rõ ràng. Điều này làm cho người lập trình đẽ dàng phát triển
ứng dụng của mình.
Hiện tại chương này giới thiệu những vấn đề cơ bản của Rails nên mình chỉ nói sơ qua phần này

19. ở đây để làm rõ được mô hình mà framework xử dụng. Còn về các mục sau mình sẽ làm rõ
những tác động cụ thể của mô hình MVC đối với Rails.
3.3. Tự động sinh code trong Rails
Ta cũng có thể nói đến Rails với việc sinh code tự động. Khi bạn phát triển trên Rails, có
các thư mục hay file là nơi để bạn điền code vào, và tất cả các phần trong ứng dụng của bạn
tương tác với nhau trên một cách thức chuẩn. Hay nó đã chuẩn bị sẵn một bộ khung
chương trình trước cho bạn, điều này giúp bạn đơn giản là chỉ việc điền các đoạn code login
vào trong ứng dụng và tích kiệm và giảm tải công việc của bạn. Và nhờ có bộ khung đã định
nghĩa sẵn này, Rails cung cấp các generate, rake, script cho phép bạn nhanh chóng tạo, xóa ra
một số template để bạn định nghĩa model, view ,controller, hay ngay cả database trong cơ sở
dữ liệu.
3.4. Vòng đời phát triển một ứng dụng trong Rails
Rails động viên sử dụng các điều kiện khác nhau cho mỗi giai đoạn trong chu trình vòng đời
của ứng dụng(phát triển,kiểm tra, và sản phầm). Nếu bạn đã hoàn thành việc phát triển ứng
dụng web trong một khoảng thời gian, đây có lẽ là cách để bạn thực hiện. Rails chỉ hợp thức
hóa các môi trường này.
Development trong điều kiện development, thay đổi tới code nguồn của ứng dụng ngay lập
tức; tất cả chúng ta cần làm là load lại trang tương ứng trong trình duyệt. Tốc độ không phải
là yếu tố quyết định trong điều kiện này; Thay vì vậy, mục tiêu là cung cấp cho người
phát triển nhìn xuyết suốt các thành phần có liên quan đến việc hiển thị trên mỗi trang web.
Khi một lỗi xảy ra trong điều kiện phát triển, các nhà phát triển có thể nhìn thoáng qua để biết
dòng code nào gây ra lỗi, và như thế nào dòng đó được gọi tới. Khả năng này được cung cấp
bởi stack trace(bao gồm đầy đủ các danh sách các phương thức gọi để chuẩn bị cho lỗi),
cái này được hiển thị khi một lỗi không trông đợi xảy ra.
Test Trong điều kiện kiểm tra, chúng ta thường làm mới(refresh) cơ sở dữ liệu với một
ranh giới của dữ liệu giả cho mỗi lần kiểm tra được lặp lại-điều này đảm bảo rằng kết quả
của cuộc kiểm tra là nhất quán, và cách xử lý đó là có khả năng tăng thêm. Unit và các thủ
tục kiểm tra là tự động hóa hòan toàn trong Rails. Khi chúng ta kiểm tra ứng dụng Rails,
chúng ta không xem nó sử dụng một trình duyệt web truyền thống. Thay vì vậy, các cuộc
kiểm tra được gọi từ các dòng lệnh, và có thể chạy dưới background. Điều kiện kiểm tra
cung cấp một môi trường chuyên dụng để xử lý các hoạt động đem lại hiệu quả.
Production Giai đoạn mà ứng dụng của bạn đã hoàn thành, khi mà các kết quả kiểm tra là
tốt, các lỗi đã được loại ra. Khi đó việc thay đổi code là rất hiếm, điều này có nghĩa là môi
trường sản phẩm có thể lạc quan để tập trung vào việc sử dụng. Nhiệm vụ như viết số lượng
lớn các log cho mục đích gỡ rồi là trở nên không cần thiết khi này. Tuy nhiên, nếu một lỗi

20. xảy ra, bạn không muốn làm người dùng sợ hãi với những thông báo dấu vết khó hiểu(nó chỉ
tốt trong giai đoạn phát triển).
Với các nhu cầu khác nhau cho mỗi điều kiện,giai đoạn, Rails lưu trữ dữ liệu cho mỗi điều
kiện trong các dữ liệu được tách biệt hoàn toàn. Bởi vậy, tại bất kỳ thời điểm nào, bạn có
thể có:
 Dữ liệu trực tiếp với người dùng thực sự tương tác trong môi trường điều kiện
sản phẩm.
 Một bản copy của dữ liệu trực tiếp mà bạn sử dụng để gở rối lỗi hay phát triển
tính năng mới trong môi trường điều kiện phát triển.
 Một bộ dữ liệu kiểm tra để mà bạn có thể liên tục làm việc load lại trong môi trường
điều kiện kiểm tra.
3.5. So sánh Ruby on Rails với Java và PHP
Để đánh giá một framework, người ta sẽ dựa vào 4 yếu tố: tốc độ phát triển (Dev Speed), khả
năng bảo trì (maintainability), công cụ hỗ trợ (Dev Tools)và khả năng mở rộng thay đổi
(Scaling). Như vậy theo lược đồ đánh giá trên, có thể thấy mỗi framework có những điểm mạnh
– yếu riêng. Với RoR, đó là tốc độ phát triển và khả năng bảo trì. Vậy đâu mới là yếu tố quan
trọng nhất trong 4 yếu tố trên để đánh giá một framework nên được sử dụng nhất. Theo như
Tim Bray và nhiều chuyên gia, thì đó là tính bảo trì, bởi một ứng dụng khi được xây dựng thì đa
số nó sẽ được sử dụng trong thời gian dài, hơn thế nữa thực tế cho thấy chi phí cho công tác bảo
trì luôn là không nhỏ. Mặt khác, với sự hỗ trợ của mô hình MVC, độ dễ hiểu và độ dài của code
cũng được cải thiện hơn so với PHP và Java.

21. Ngoài 4 yếu tố trên, có thể nêu thêm các yếu tố cụ thể sau ảnh hưởng tới tầm quan trọng của
RoR so với các framework khác. Đó là ở giải pháp mã nguồn mở và khả năng thương mại. Với
giải pháp mã nguồn mở, RoR đã dung hòa tính dễ học của PHP và cấu trúc chặt chẽ của Java.
Còn về khả năng thương mại, các nền tảng J2EE và .NET hiện đang được sử dụng trong các
công ty lớn với tính năng ổn định và sự an toàn chặt chẽ trong việc quản lý khối lượng lớn dữ
liệu. RoR có thể đảm bảo nhiệm vụ tương tự với giá thành hạ.

22. Chương 4: Cài đặt và phát triển môi trường Rails
Như chương trước đã đề cập đến vấn đề framework nói chung và một số những điều cơ bản liên
quan đến framewoerk Rails. Chương này đề cập đến các cài đặt để phát triển một môi trường để
học cũng như để chạy ngôn ngữ trên Rails.
1. Các môi trường cụ thể để phát triển Ruby on Rails
Hầu như mọi môi trường đều có thể phát triển framework. Bạn có thế cài đặt nó trên hệ điều
hành Window, Linux và Mac.
Nhưng hiện nay học tập và phát triển một trang web các nhà lập trình thường sử dụng Linux
hoặc Mac.
Để có một server để thực thi một hệ thống phát triển bằng Rails người phát triển thường chọn
sever Linux.
2. Cách cài đặt môi trường phát triển Ruby on Rails
Ở đây tôi hướng dẫn các bạn cài đặt môi trường phát triển Rails trên Windown
B1: Truy cập vào trang web railsinstaller.org và download gói “web the kit “.
B2: Chọn cài đặt gói vừa tài về bằng kích đúp vào .Chọn next sau đó là chọn install chương
trình.
B3: Bỏ tích đánh dấu khỏi dòng “Configure git and ssh when installation has completed”và
chọn finish.
B4: Từ màn hình cmd bạn gõ: rails new project1 ấn enter.
B5: Di chuyển vào thư mục project1 và gõ: rails s và enter.
B6: Bạn dùng trình duyệt bất kỳ gõ vào địa chỉ: “localhost:3000” nếu màn hình nếu màn hình
hiển thị “welcome aboard” tức là bạn đã cài đặt thành công.
3. Cài đặt công cụ hỗ trợ code
B1: Bạn download công cụ sublimetext tại trang http://www.sublimetext.com/.
B2: Cài đặt sublimetext .
B3: Sau khi cài đặt xong sublimetext ta di chuyển vào thư mục đã cài đặt mặc định là:
C:Program FilesSublime Text 2
B4: Copy file sublime_text.exe vào chính thư mục đó và đổi tên là “subl”
B5: Copy đường dẫn thư mục chứa file “subl”.

23. B6: Kích phải chuột vào "My Computer", chọn "Advanced System Settings", chọn
"Environment Variables", kéo xuống và tìm "Path", chọn "Edit". Thêm ";" vào cuối của dòng và
dán đường link vừa rồi vào đó.
B7: Khởi động lại Command line và chọn đường dẫn project : gõ “subl” để mở Sublime text.
Khi hoàn thành xong các mục trên bạn đã tạo thành công môi trường phát triển và công cụ hỗ
trợ code. Đến đây bạn có thể học và phát triển một ứng dụng web bằng framework Rails.
Bây giờ khi đã hoàn thành môi trường phát triển và có những kiến thức cơ bản về ngôn ngữ
Ruby thì bạn có có thể tìm hiểu những vấn để phát triển Ruby on Rails
Còn nếu khi bạn muốn thực thi môi trường Rails trên một hệ thống khác bạn có thể xem thêm
tại mục 3 của tài liệu kham khảo.

24. Chương 5: Những vấn đề cụ thể của Rails
1. Bộ công cụ để phát triển
Rake: là một công cụ xây dựng viết bằng Ruby, Có một sự khác biệt lớn giữa Rake và những
công cụ khác.Tất cả các công việc được viết bởi chính ngôn ngữ Ruby. Vì vậy, nó được thừa
hưởng tính linh hoạt, đầy đủ và có thể tận dụng lợi thế của một số tính năng tốt của Ruby.
Cài đặt: Để cài đặt Rake, từ cmd ta gõ lệnh : “ gem install rake “ và enter .
Chức năng:
 Rake hỗ trợ các mô hình quy tắc tổng hợp các nhiệm vụ ngầm.
 Người dùng có thể xác định các nhiệm vụ với điều kiện tiên quyết.
 Một thư viện các nhiệm vụ đóng gói sẵn để thực hiện xây dựng rakefiles dễ dàng hơn.
 FileLists khá linh hoạt hoạt động như mảng nhưng vẫn hiểu các thao tác tên tập tin và
đường dẫn.
Các hỗ trợ nhiệm vụ : Di chuyển đến thư mục cần kiểm tra , gõ lệnh : rake --tasks
+ Mỗi một danh sách các nhiệm vụ có sẵn của rake tạo ra phụ thuộc vào thư mục bạn kiểm tra.
+ Các nhiệm vụ thường là liên quan đến database, xóa sửa tạo mới, clean bộ nhớ cache.
Các hỗ trợ nhiệm vụ chính:
+ rake about: Thông tin về các phiên bản cũng như cài đặt phiên bản đang cài sẵn trên máy
bạn để tiện cho việc chỉnh sửa , update .
+ rake assets: Có 2 chức năng là clean để xóa bỏ những assets đã compiler , và compiler những
assets hiện tại .
+ rake db: Tổng hợp các nhiệm vụ có sẵn của rake với database như tạo, xóa sửa , rollback…
rất hữu ích khi xử lý xự cố với db.
+ rake doc: là một công cụ hỗ trợ việc tạo ra những tài liệu hướng dẫn cho các ứng dụng của
bạn, tài liệu API .Nó được tách ra để làm cho code của bạn trở lên đơn giản.
 rake doc:app : Tạo ra các tài liệu hướng dẫn cho các ứng dụng của bạn trong doc/ app.
 rake doc:guides : Tạo ra các hướng dẫn rails trong doc/guides .
 rake doc:rails : Tạo ra các hướng dẫn rails api trong doc/api.
 rake doc:plugins : Tạo ra các tài liệu api cho tất cả các plugin được cài trong
doc/plugins.
 rake doc:clobber_plugins : Loại bỏ tất cả các tài liệu tạo ra cho plugins.

25. + rake notes : Hàm tìm kiếm thông qua code của bạn và bắt đầu với các từ khóa FIXME,
OPTIMIZE or TODO . Nó có thể tìm kiếm trong các file có phần mở rộng .builder, .rb, .erb,
.haml and .slim.
+ rake routes: Cung cấp tất cả các đường dẫn và định tuyến có sẵn trong code của bạn để bạn
có thể hình dung về tổng thể .
+ rake test: Công cụ có sẵn unit, nó hỗ trợ tạo ra các bản test có sẵn và kiểm tra tính ổn định
của ứng dụng.
+ rake tmp: trong rails ta có file “Rails.root/tmp” để lưu trữ các file tạm , process id đang dùng
và các hoạt động đã diễn ra. Rake tmp hỗ trợ dọn dẹp file này để giải phóng bộ nhớ.
 rake tmp:cache:clear : xóa bỏ tmp/cache
 rake tmp:sessions:clear : xóa bỏ tmp/session.
 rake tmp:sockets:clear : xóa bỏ tmp/sockets
 rake tmp:clear : xóa toàn bộ cả 3 file trên .
Bundler: Bundler là một công cụ duy trì một môi trường phù hợp cho mã code của một nhà
phát triển trên tất cả các dòng máy. Khi mã code của một nhà phát triển được triển khai trên các
máy khác nhau, những thư viện trước đây của nhà phát triển có thể thay đổi theo môi trường đi
cùng máy. Điều này phá vỡ ứng dụng của nhà phát triển. Bundler đảm bảo rằng các thư viện sẽ
vẫn như cũ, ghi hình tất cả mọi thứ lại với nhau để phát triển ứng dụng chạy rất tốt trên mỗi
máy, nơi mà nó được triển khai.Ở đây bundler giúp ta quản lý và sử dùng gem trực tiếp trên
Rubygems.org hoặc một số trang khác .
Gem: là một gói thư viện của Ruby.
Cài đặt bunlder:
B1 : Trong thư mục gốc của app , chọn gemfile và tùy chỉnh cài đặt theo mong muốn , chọn
những gói gem hỗ trợ app của mình như “jQuery JavaScript library”, giao diện Ruby cho
SQLite database….Bằng cách xóa ký tự # trước những gói cần thiết và thêm phiên bản của
những gói đó. Hoặc bạn có thể tìm những thư viện của để cài đặt trong Gem.
B2: Sau khi lưu file Gem bạn có thể dùng lệnh bundle install để cài đặt nó vào ứng dụng của
mình. Và tiến hành sử dụng thư viện đó.
2. Đặc điểm cơ bản với cơ sở dữ liệu của Ruby on Rails
Rails là một Framework hỗ trợ khá đầy đủ các các ứng dụng liên quan đến quản trị cơ sở dữ
liệu (csdl) như xampp, wamp ...Trong quá trình phát triển của Rails, bản thân Rails cũng đã trừu
tượng hóa csdl thông qua một tầng liên kết là Active record . Đây là một thành phần cho phép

26. điều khiển sự tương tác qua lại giữa ứng dụng với cơ sở dữ liệu và là bộ não trung tâm của
Rails.
2.1. Giới thiệu Active Record
Active Record là một tầng ánh xạ quan hệ với đối tượng cho phép các bảng ánh xạ tới các lớp,
các hàng tới các đối tượng và các cột tới các thuộc tính. Tức là thay vì làm việc với csdl thông
thường qua hàng cột, thông quá Active Record ta sẽ làm việc với lớp, đối tượng, thuộc tính.
2.2. Đánh giá Active Record với các hệ csdl khác
Ưu điểm: + Thông qua việc Rails tự động thêm vào các thuộc tính theo các cột csdl thì việc chỉ
định rõ thuộc tính theo các hướng khác nhau là không cần thiết .
+ Có thể không cần sử dụng ngôn ngữ SQL để làm việc với csdl mà có thể sử dụng duy nhất
một ngôn ngữ là Rails để tạo sự đồng nhất cũng như dễ dàng trong việc lập trình.
+ Tự động tìm kiếm Primary key và Foreign key khi xây dựng csdl và việc liên kết giữa các
bảng cũng được làm tự động.
Nhược điểm : + Hạn chế của Active Record là do đi theo một chuẩn mẫu sẵn khi khởi tạo dữ
liệu nên việc thay đổi tùy biến là không thể .
+ Do sự liên kết giữa các bảng là tự động và không do người cài đặt nên việc liên quan đến
chỉnh sửa csdl trở lên phức tạp hơn.
2.3. Thao tác sử dụng Active Record
a. Xác định mối quan hệ
Có 3 loại mối quan hệ: 1-1, 1 - nhiều, nhiều – nhiều.
Quan hệ 1 - 1:
Quan hệ 1 – nhiều :
Quan hệ nhiều – nhiều :

27. b. Lấy đối tượng
Active record hỗ trợ việc lấy đối tượng thông qua việc với
Model.”method”
với Model là biến ánh xạ tên của bảng method là các hàm định sẵn như find , first , last , first!,
last!.
Lấy dữ liệu có primary key là 1 :
Model.find(1); <=> select * from Model limit 1
Lấy dữ liệu có promary key từ 1 -> 10
Model.find([1,10])<=> SELECT * FROM clients WHERE (clients.id IN (1,10)
Đối với những khối dữ liệu lớn , ta sử dụng “find_each và find_in_batches” với việc lấy nhiều
nhiều bản khi và ghi ra khối để có thể gọi và sử dụng dễ dàng.
Find_each : với batch_size là số lượng hồ sơ được lấy ra để chuyển vào từng lô để sử lý

28. Chương cuối: Tổng kết
Ở đây nhóm sẽ tổng kết các vấn đề trong phiên bản báo cáo này:
Các bạn đã hiểu ngôn ngữ Ruby là gì và những điều cơ bản về nó. Hiểu được thế nào là mô
hình MVC và Framework là gì. Và em đã trình bầy về framework Rails và những thư xung
quanh đến nó.
Những vấn đề tiếp theo của RoR sẽ giới thiệu trong phiên bản sau.
Phụ Lục
Những từ ngữ viết tắt:
RoR: Ruby on Rails
Csdl: cơ sở dữ liệu
Db: database
Tài liệu tham khảo
[1] http://dev.vast.vn/tuananh/Web/C%C4%90048-1
[2] Nguyễn Hải Châu, “Tổng quan về Framework Rails”
[3] Michael Harlt,”Ruby on Rails Tutorial Learn Web Development With Rails”
http://ruby.railstutorial.org/ruby-on-rails-tutorial-book