W poprzednich dwóch artykułach pokazałem jak zainstalować JRubiego oraz jak może Ruby z Javą rozmawiać. Czas rozpocząć przygodę z JRuby on Rails.

W tym artykule pokażę:

• jak stworzyć prostą aplikację typu CRUD w Ruby on Rails, która będzie korzystać z bazy danych MySQL,
• jak wdrożyć tą aplikację na serwerze Tomcat przy użyciu narzędzia Warbler.

Wymagania. Zakładam, że masz już zainstalowaną bazę danych MySQL 5.0.x. Potrzebny będzie także serwer Tomcat, który można stąd pobrać (w chwili pisania korzystałem z najnowszej wersji 6.0.18). Jeśli nie masz jeszcze zainstalowanego Ruby on Rails to wykonaj następujące polecenie:

# Na wszelki wypadek Ruby on Rails przyda się :)
$ jruby -S gem install rails warbler jruby-openssl --no-ri --no-rdoc

Stworzenie prostej aplikacji

Czas napisać prostą aplikację. Jej funkcjonalność ograniczy się do dodawania, edytowania i usuwania wiadomości (dużo powiedziane, bo wiadomość będzie się składać tylko z łańcucha znaków ). Zaczynamy.

# Stworzenie szkieletu aplikacji
$ jruby -S rails rails_app
$ cd rails_app/
 
# Stworzenie modelu wiadomości oraz operacji CRUD dla niego
$ jruby -S script/generate scaffold message content:string
 
# i pozostaje konfiguracja dostępu do bazy danych - tego Rails jeszcze nie potrafią same zrobić :)
$ vim config/database.yml

Moją konfigurację można zobaczyć poniżej. Nie należy zapomnieć stworzyć bazy danych w MySQLu (wystarczy tylko railsapp_development).

defaults: &defaults
    adapter: mysql
    username: root
    password:
    host: localhost
    encoding: utf8

development:
  database: railsapp_development
  <<: *defaults

test:
  database: railsapp_test
  <<: *defaults

production:
  database: railsapp_production
  <<: *defaults

Aplikacja już napisana, baza danych skonfigurowana. Zostało jeszcze utworzenie odpowiednich tabelek w bazie danych i można już bawić się aplikacją.

[Bash]
# Jeśli nie było żadnego błędu po drodze to poniższa operacja powinna wykonać poprawnie
$ jruby -S rake db:migrate
(in /Users/wiktor/jruby/rails_app)
== 20081028224846 CreateMessages: migrating ===================================
– create_table(:messages)
-> 0.0049s
== 20081028224846 CreateMessages: migrated (0.0058s) ==========================
[/Bash]

Aplikację można już uruchomić poleceniem jruby -S script/server. Po wejściu na stronę http://localhost:3000 można zobaczyć środowisko uruchomienia aplikacji, a pod adresem http://localhost:3000/messages znajduje się przed chwilą stworzona, bardzo wyrafinowana aplikacja.

Wdrożenie Ruby on Rails na Tomcata

Żeby przygotować aplikacje Ruby on Rails do wdrożenia ją na Tomcata, należy użyć biblioteki Warbler. Została ona już zainstalowana poleceniem jruby -S gem install ... na samym początku artykułu.

Przez dłuższy czas obserwowałem rozwój Warblera. Kiedy projekt stawiał pierwsze kroki, przygotowanie aplikacji Ruby on Rails wiązało się ze starannym przygotowaniem pliku konfiguracyjnego, zadbaniem o odpowiednie sterowniki JDBC do bazy danych. Nie było to miłe zajęcie. Z tego powodu warto docenić, że obecnie przygotowanie aplikacji do wdrożenia na Tomcacie jest banalnie proste.

[Bash]
# Stworzenie pliku config/warble.rb.
$ jruby -S warble config

# Teraz należy w pliku config/warble.rb zamienić linijkę
# z # config.webxml.rails.env = ENV['RAILS_ENV'] || ‘production’
# na config.webxml.rails.env = ‘development’

# Przygotowanie aplikacji w postaci WAR.
$ jruby -S warble war
jar cf rails_app.war -C tmp/war .

# Gotowe?
$ ls -l rails_app.war
-rw-r–r– 1 wiktor wiktor 9800493 Oct 29 23:28 rails_app.war

# Mając już Tomcata uruchomionego możemy wdrożyć aplikację.
$ cp rails_app.war ../apache-tomcat-6.0.18/webapps/
[/Bash]

Aplikacja będzie dostępna pod adresem http://localhost:8080/rails_app, a bawić wiadomościami można się tutaj: http://localhost:8080/rails_app/messages.

Parę słów wyjaśnienia. Standardowo Warbler uruchamia aplikację w trybie produkcji. Jednym ze skutków jest to, że aplikacja będzie korzystać z bazy railsapp_production, a nie z railsapp_development, której do tej pory używaliśmy. Zmiana podyktowana była jedynie moją leniwością.

Warto też zauważyć, że cała aplikacja rails_app.war waży niecałe 10 MB. Co się tam znajduje? Otóż cała dystrybucja JRubiego, a także wszystkie zależności Ruby on Rails. Takie życie . Zachęcam także do przestudiowania pliku config/warble.rb, poprzez który można konfigurować zachowanie aplikacji na serwerze Javowym.

Smacznego .

24 kwietnia 2008 (czwartek), godz. 19:00 – 20:30
Akademia Górniczo-Hutnicza
Al. Mickiewicza 30, sala 429 C2

Czego można się spodziewać? Będzie to odświeżona wersja mojego show o JRuby’im (prezentacja i prawdziwe kodowanie na żywo), które debiutowało podczas WarsJava’07. Przez ostatnie pół roku się dużo zmieniło i będzie to odzwierciedlone na mojej prezentacji:

• będzie użyta najnowsza wersja Ruby on Rails 2.0,
• architektura REST, czyli architektura zorientowana na zasoby,
• ilość zmian w aplikacji RoR, żeby uruchomić pod JRuby dramatycznie zmalała,
• sposób wdrażania aplikacji RoR na serwery aplikacyjne został uproszczony,
• i oczywiście nie zabraknie AJAXa .

Zapraszam!

• źródła stworzonej aplikacji
• scenariusz prezentacji

| View | Upload your own

Już w najbliższą sobotę o godzinie 11:00 będę dawał prezentację “JRuby on Rails, czyli łączenie Javy i Rubiego” na WarsJava – I Warszawskie Warsztaty Javowe organizowane przez Warszawa JUG. Warsztaty będą miały miejsce na MIMUWie. I co najważniejsze: WSTĘP WOLNY .

Podczas warsztatów pokażę:

• jak stworzyć prostą aplikację w Ruby on Rails,
• jak korzystać z kodu Javy z poziomu Ruby’iego,
• jak korzystać ze sterowników JDBC do łączenia się z bazą danych,
• jak integrować stworzoną aplikacją z istniejącą aplikacją JEE (JMS, serwer aplikacji JBoss),
• jak wdrażać aplikacje oparte o Ruby on Rails.

Zapraszam!

[ruby]
class User < ActiveRecord::Base

validates_presence_of :name, :middlename, :surname, :sex, :birthday

end
[/ruby]

Zakładam, że jestem uczciwy względem siebie i chce przetestować, czy walidacje działają poprawnie. Zaczynam więc pisać test:
[ruby]
class UserTest < Test::Unit::TestCase
fixtures :users

def test_validation_name
u = users('user1')

u.name = ''
assert !u.valid?
assert u.errors.invalid?("name")

u.name = nil
assert !u.valid?
assert u.errors.invalid?("name")

end

# ...i tak dalej... nudny w sumie kod....
end
[/ruby]

Ale przecież możemy skorzystać z dynamicznej natury Ruby'iego i wstrzyknąć wygenerowane wcześniej metody. Poniżej widać, jak to zrobić:

[ruby]
class UserTest < Test::Unit::TestCase
fixtures :users

#tworzę tablicę z poniższych elementów i iteruję po niej
%w(name middlename surname sex birthday).each do |name|

#definiuję nową metodę do testowania poprawności walidacji
define_method(:”test_validation_#{name}”) do

u = users(‘user1′)

#dynamiczne wywołanie metody, a dokładnie przypisanie pustego napisu do pola
u.send :”#{name}=”, ”
assert !u.valid?
assert u.errors.invalid?(:”#{name}”)

u.send :”#{name}=”, nil
assert !u.valid?
assert u.errors.invalid?(:”#{name}”)
end
end

end
[/ruby]

Piękne rozwiązanie, prawda?

Jeśli ktoś chce prosto zacząć swoją wędrówkę z Javowego świata do dynamicznego świata Ruby i Railsów to istnieje tylko jeden sposób: Netbeans 6.0 M6 (instalacja typu full zawiera w sobie wszystko, co niezbędne; w tym JRuby i pakiet Ruby on Rails). Można go pobrać stąd. Teraz już albo tworzymy nowy projekt lub importujemy istniejący i wszystko działa.

Teraz odpalamy projekt i na konsolce możemy sprawdzić, że cała aplikacja została uruchomiona na JRuby’im.

I jak się tutaj nie cieszyć . Jeśli jesteś zainteresowany postępem w pracach nad wtyczką do Rubiego w Netbeansie to przeglądaj Tor Norbye’s Weblog.

Ruby on Rails poprzez dostarczenie mechanizmu migracji pozwala na szybkie rozwijanie aplikacji i następnie poprawianie usterek. Trzeba podkreślić, że dodawanie nowej funkcjonalności staje się równie miłe i przyjemne.

Zobaczmy to na przykładzie .

Powiedzmy, że mamy już istniejącą aplikację. Naglę się zorientowaliśmy, że zapomnieliśmy wprowadzić systemu logowania dla użytkowników . Czyli mamy model User, a w bazie danych ponad 1000 rekordów. Coś trzeba zrobić. Zacznijmy od wygenerowania nowej migracji:

$ ruby script/generate migration AddLoginAndPassword
exists db/migrate
create db/migrate/002_add_login_and_password.rb


Teraz zabierzmy sie do edytowania pliku 002_add_login_and_password.rb.

#
# Migracja zmienia model użytkownika i dodaje do niego 2 kolumny:
#   - login (domyślna wartość to pierwsze słowo nazwy użytkownika)
#   - password (domyślna wartość to login użytkownika)
#
class AddLoginAndPassword < ActiveRecord::Migration
    def self.up
        add_column :users, :login, :string, :null => false
        add_column :users, :password, :string, :null => false
        User.find(:all).each { |user|
            user.login = user.name.scan(/\w+/)[0].strip.downcase
            user.password = Digest::SHA1.hexdigest(user.user)
            user.save
        }
    end
 
    def self.down
        remove_column :users, :login
        remove_column :users, :password
    end
end

Powyższy kod jest bardzo czytelny i widać od razu, co on robi. Wartym podkreślenia jest fakt, że migracje pozwalają nie tylko zmieniać strukturę bazy danych, ale także wypełniać ją jakimiś danymi. Jest to bardzo przydatne, gdy wprowadzamy nową funkcjonalność. Teraz zostaje nam tylko dodać do modelu więzy spójności i odpalić:

rake db:migrate VERSION=2

Voilà!