Einführung in Ruby On Rails
           Architektur und Konzepte




                                 Frank Egger
         ...
Agenda

  Basis-Sprache Ruby / Programmierparadigmen
  Rails Architekturprinzipien und -eigenschaften
  Spezialthemen
 –  ...
Die Sprache Ruby - Programmierparadigmen

 Dynamisch typisierte (Script-)Programmiersprache

 Rein objektorientiert und vo...
Rails Architekturprinzipien und -merkmale

  MVC Paradigma als Schichtenarchitektur

  Konventionen über Konfigurationen

...
Basiswissen MVC-Paradigma




                                                   Model
Views werden über die              ...
MVC bei Rails


                                                   Controller

                       Request

           ...
Rails Controller in Aktion


  Controller steuern Ablauf
  (Routing anpassbar)
                                           ...
Rails Controller – Features und Merkmale
                                                                Controller
  Zugr...
Rails Model
Model
                                                                         s
class Task < ActiveRecord::Ba...
Rails Model – Assoziationen / Relationen

       Model                                                            s
      ...
Rails Views

      Embedded Ruby (ERB) als Templating-Mechanismus

      Datenzugriff über Instanzvariablen des Controller...
Rails Anwendungsrahmen

 Jede Rails-Anwendung hat einen identisch aufgebauten
 Anwendungsrahmen

 Über einen Generator wir...
Scaffolding und Generatoren

  Scaffolding (Gerüstbau)

   – schnelle Abbildung von z. B. CRUD-Methoden auf allen
     Arc...
Rails und

  Scriptaculous u. Prototype sind in Rails per Default integriert

  RJS (Rails Javascript) vereinfacht die Ums...
Email-Versand / (-Empfang) bei Rails

     Email-Versand über ActionMailer-Model

     Aufruf der Model-Methoden zum Versa...
Webservices mit Rails

  Definition einer Webservice-API über ein von ActionWebservice
  abgeleitetes Interface

  Abbilde...
Datenbank-Management / -Migrationen

  Repräsentation des Schemas in Datenbank-unabhängiger Sprache (Ruby)

  Migrationssc...
Testing bei Rails
                                                   def setup
                                           ...
Testdatendefinition

  Testdaten werden in „Fixtures“ definiert                                         Fixture
          ...
Rails Entwicklungsumgebung

 Aptana Rails / RadRails (basiert auf Eclipse)

   – Syntax Highlighting

   – Code Completion...
Quellen

  http://www.rubyonrails.org/

  http://www.rubyonrails.de/

  http://www.rubyonrailsblog.com/

  http://www.ruby...
Nächste SlideShare
Wird geladen in …5
×

Einführung in Ruby On Rails

4.707 Aufrufe

Veröffentlicht am

Veröffentlicht in: Technologie
0 Kommentare
3 Gefällt mir
Statistik
Notizen
  • Als Erste(r) kommentieren

Keine Downloads
Aufrufe
Aufrufe insgesamt
4.707
Auf SlideShare
0
Aus Einbettungen
0
Anzahl an Einbettungen
118
Aktionen
Geteilt
0
Downloads
25
Kommentare
0
Gefällt mir
3
Einbettungen 0
Keine Einbettungen

Keine Notizen für die Folie

Einführung in Ruby On Rails

  1. 1. Einführung in Ruby On Rails Architektur und Konzepte Frank Egger Okt. 2007
  2. 2. Agenda Basis-Sprache Ruby / Programmierparadigmen Rails Architekturprinzipien und -eigenschaften Spezialthemen – „Scaffolding“, Generatoren, Plugins und Engines – AJAX – Email-Versand – Webservices – Datenbank-Management / -Migrationen Testing Entwicklungsumgebung Seite 2 Einführung in Ruby On Rails – Architektur und Konzepte
  3. 3. Die Sprache Ruby - Programmierparadigmen Dynamisch typisierte (Script-)Programmiersprache Rein objektorientiert und voll funktional class RubyClass < SuperClass include RubyModule Introspektion/Reflexion, „duck typing“ def method(param) @instvar = param end principle of least surprise (POLS) end obj = RubyClass.new obj.method(quot;Rubyquot;) Erscheinungsjahr ca. 1995 Einflüsse von Perl, Python, Smalltalk, LISP, u.a. Initiator: Yukihiro Matsumoto („Matz“), mittlerweile Open Source Garbage Collection, Exceptions, reguläre Ausdrücke, Erweiterung von Klassen, Code-Blöcke, RubyGems (Paketmanager), Rdoc (vgl. Javadoc), usw. Seite 3 Einführung in Ruby On Rails – Architektur und Konzepte
  4. 4. Rails Architekturprinzipien und -merkmale MVC Paradigma als Schichtenarchitektur Konventionen über Konfigurationen „DRY“-Prinzip („Don‘t Repeat Yourself“) Plugin-fähige Architektur zur einfachen Erweiterung von Anwendungen durch Standardkomponenten Eingebaute bzw. ergänzbare Einweg-Generatoren Identischer Anwendungsrahmen (Verzeichnisse, Struktur) Integrierte AJAX-Unterstützung Hohe Testbarkeit Seite 4 Einführung in Ruby On Rails – Architektur und Konzepte
  5. 5. Basiswissen MVC-Paradigma Model Views werden über die Controller ändert den Änderungen des Zustandes Zustand des des Geschäftsmodells Geschäftsmodells informiert View Controller Views geben die Benutzerinteraktionen an den Controller weiter Seite 5 Einführung in Ruby On Rails – Architektur und Konzepte
  6. 6. MVC bei Rails Controller Request Creates, Reads, Deletes, Modifies Redirects Forwards Model Response Provides Data View Helper Client Web/App- Database Server Seite 6 Einführung in Ruby On Rails – Architektur und Konzepte
  7. 7. Rails Controller in Aktion Controller steuern Ablauf (Routing anpassbar) Controller Controller verwalten Modell class TasksController < ApplicationController def show Aufruf der Controller über @task = Task.find(params[:id]) end Konvention und Introspektion end Jede Methode im Controller entspricht einer ausführbaren Action View View erhält Daten (für Vorbelegungen) über show.rhtml Instanzvariablen Views werden über Konvention vom Controller angesprochen bzw. erzeugt Seite 7 Einführung in Ruby On Rails – Architektur und Konzepte
  8. 8. Rails Controller – Features und Merkmale Controller Zugriff auf Session, Cookies, Parameter class TasksController < ApplicationController über Hashs include AuthenticatedSystem before_filter :login_required Verhalten der Controller kann mit Hilfe def access von Filtern beeinflusst werden (z.B. für user = session[:user] cookie = cookies[:user_cookie] Autorisierung, Authentifizierung) param = params[:id] end Seitenlayout kann über Controller oder end Action gesteuert werden render(:action => quot;actionquot;, :layout => quot;layoutnamequot;) render(:layout => quot;layoutnamequot;) Seite 8 Einführung in Ruby On Rails – Architektur und Konzepte
  9. 9. Rails Model Model s class Task < ActiveRecord::Base validates_presence_of :description def print return quot;Die Aufgabe heißt #{description}.quot; end end Validierungen werden im Model definiert Durch Ableitung von ActiveRecord werden automatisch getter/setter für Attribute erzeugt DRY-Prinzip: Definition der Attribute nur in der Datenbank Konvention: Tabellennamen immer Plural vom Modellnamen (Legacy- Schemata werden auch unterstützt) Vererbung (Single Table Inheritance) ist möglich Seite 9 Einführung in Ruby On Rails – Architektur und Konzepte
  10. 10. Rails Model – Assoziationen / Relationen Model s class Task < ActiveRecord::Base belongs_to :user ... end Model class User < ActiveRecord::Base has_many :tasks s ... end Relationen textuell beschreiben: – 1:1 -> has_one / belongs_to – 1:n -> has_many / belongs_to – n:m -> has_and_belongs_to_many / has_and_belongs_to_many Foreign Keys werden über Konvention benannt: „relationierte Entität“_id Seite 10 Einführung in Ruby On Rails – Architektur und Konzepte
  11. 11. Rails Views Embedded Ruby (ERB) als Templating-Mechanismus Datenzugriff über Instanzvariablen des Controllers Inkludierung von Seitenteilen möglich (Partials) Seitenweises blättern (Pagination) View <%= link_to 'Next page', { :page => @task_pages.current.next } if @task_pages.current.next %> Neben HTML als Ausgabeformat werden auch Javascript/RJS (AJAX), XML und Binärformate unterstützt Controller View <% for @task in @tasks %> class TasksController < ApplicationController <p class=quot;taskdescriptionquot;> def list <%= @task.description %> @task_pages, @tasks = paginate :tasks, </p> :per_page => 10 end <p class=quot;accountablequot;> <%= (@task.accountable == 1 ? quot;jaquot; : quot;neinquot;) %> end </p> ... Seite 11 Einführung in Ruby On Rails – Architektur und Konzepte
  12. 12. Rails Anwendungsrahmen Jede Rails-Anwendung hat einen identisch aufgebauten Anwendungsrahmen Über einen Generator wird der Anwendungsrahmen angelegt („rails <projektname>“) Danach muss nur noch die Datenbankverbindung konfiguriert werden und die Enticklung kann starten Seite 12 Einführung in Ruby On Rails – Architektur und Konzepte
  13. 13. Scaffolding und Generatoren Scaffolding (Gerüstbau) – schnelle Abbildung von z. B. CRUD-Methoden auf allen Architekturebenen (Modell/Controller/View) „on the fly“ – Einmalgenerierung von Sourcecode für CRUD-Methoden Generatoren – Bieten Unterstüzung bei der Erstellung von Architekturelementen (Models, Controllers, Views, Helpers) – Können komplexe Umgebungen bereitstellen (z.B. Autorisierung / Login) – Können Artefakte auch wieder löschen (Verlust von manuell hinzugefügtem Sourcecode möglich!) – Sind erweiterbar und können als Plugins in Projekten eingebunden werden Seite 13 Einführung in Ruby On Rails – Architektur und Konzepte
  14. 14. Rails und Scriptaculous u. Prototype sind in Rails per Default integriert RJS (Rails Javascript) vereinfacht die Umsetzung von AJAX-Elementen ABER: Keine aufwändigen AJAX-Anwendungen ohne fundiertes Javascript- Know How Rails ermöglicht die automatische Erkennung von Javascript – AJAX-Formulare werden bei fehlender Javascript-Unterstützung des Clients in „normale“ Formulare gewandelt – ABER: Controller muss beide Varianten beherrschen! View <% form_remote_tag(:html => { :action => url_for(:action => quot;createquot;) }, :url => { :action => :createAjax }, :update => {:failure => quot;inputformquot; }, :loading => quot;Element.show('loading')quot;, :loaded => quot;Element.hide('loading')quot; ) do %> Seite 14 Einführung in Ruby On Rails – Architektur und Konzepte
  15. 15. Email-Versand / (-Empfang) bei Rails Email-Versand über ActionMailer-Model Aufruf der Model-Methoden zum Versand mit „deliver_Methodenname“ Email-Inhalt als View-Template Multipart-Email möglich Mailversand über integrierten „Dummy“-Mailserver testbar Model class UserNotifier < ActionMailer::Base def signup_notification(user) url = HOST_URL @recipients = quot;#{user.email}quot; @from = quot;f.egger@dpcom.dequot; @subject = quot;Please activate your new accountquot; @sent_on = Time.now Your account has been created. @body[:user] = user Username: <%= @user.login %> @body[:url] = Visit this url to activate your account: quot;#{url}/account/activate/#{user.activation_code}quot; end <%= @url %> end Seite 15 Einführung in Ruby On Rails – Architektur und Konzepte
  16. 16. Webservices mit Rails Definition einer Webservice-API über ein von ActionWebservice abgeleitetes Interface Abbilden der API auf einen / mehrere Controller mit einem / mehreren Endpoint/s (direct, delegated, layered) Einfache und komplexe Parameter-Typen werden unterstützt (z. B. string, Model Elemente, arrays, hashs...) Unterstützung für WSDLs mit soap4r Controller class TaskAPI < ActionWebService::API::Base api_method :new_task, :expects => [Task], :returns => [:bool] end class TaskController < ApplicationController web_service_api TaskAPI def new_task(task) return task.save end end Seite 16 Einführung in Ruby On Rails – Architektur und Konzepte
  17. 17. Datenbank-Management / -Migrationen Repräsentation des Schemas in Datenbank-unabhängiger Sprache (Ruby) Migrationsscripte enthalten einzelne Updates für Änderungen am Schema oder den Daten Das Schema wird in der Datenbank versioniert Rails kann mit Hilfe der Version automatisch Up-/Down-Migrationen der Datenbank vornehmen Es existieren per Default drei Datenbanken: Entwicklung, Test, Produktion class CreateUsers < ActiveRecord::Migration def self.up create_table quot;usersquot;, :force => true do |t| t.column :login, :string t.column :crypted_password, :string end end def self.down drop_table quot;usersquot; end end Seite 17 Einführung in Ruby On Rails – Architektur und Konzepte
  18. 18. Testing bei Rails def setup create_fine_working_time Grundlage für Testing bilden end Unit-Tests def test_create_without_task @working_time.task = nil @working_time.task_id = nil Entwicklung und Ausführung result = @working_time.save vergleichbar mit Junit assert !result errors = @working_time.errors (setup, teardown...) assert_not_nil errors[:task_id] assert includes_match?(errors[:task_id], 'Bitte eine Aufgabe auswählen!') Sind aufgrund der dynamischen end Typisierung sehr wichtig zur Model-Tests Sicherung der Funktionalität bei Refactorings Unterteilung der Tests in Unit-Tests (Model) und Functional-Tests (Controller / View) Bei Functional-Tests werden Requests und Responds gemockt (vergleichbar mit HttpUnit + integriertem Webserver) E-Mail- und Webservice-Infrastrukturen können gemockt werden Seite 18 Einführung in Ruby On Rails – Architektur und Konzepte
  19. 19. Testdatendefinition Testdaten werden in „Fixtures“ definiert Fixture <% today = Date.today %> worked_and_traveled: Fixtures werden in yaml (vereinfachtes id: 1 date: <%= (today - 1).to_s :db %> XML) formuliert hours_worked: 5 minutes_worked: 30 hours_traveled: 2 Jedes Fixture entspricht einem Datensatz minutes_traveled: 30 in der Datenbank comment: kunde ausgequetscht task_id: 1 project_id: 4 Fixtures sollten sprechende Bezeichnungen user_id: 1 besitzen fixtures :working_times def setup Fixtures werden vor Ausführung von Tests create_fine_working_time end automatisch in die Datenbank geladen def test_create_without_task working_times(:worked_and_traveled) Als Standard laufen Test-Methoden [...] innerhalb einer Transaktion ab end Model-Tests Auch Beziehungen werden in den Testdaten abgebildet Seite 19 Einführung in Ruby On Rails – Architektur und Konzepte
  20. 20. Rails Entwicklungsumgebung Aptana Rails / RadRails (basiert auf Eclipse) – Syntax Highlighting – Code Completion (etwas buggy!) – Unit-Testing – Webserver (WEBrick, LightTPD, Mongrel) – Generatoren – Rake Tasks – Rails Plugins – RI (API Doku) Seite 20 Einführung in Ruby On Rails – Architektur und Konzepte
  21. 21. Quellen http://www.rubyonrails.org/ http://www.rubyonrails.de/ http://www.rubyonrailsblog.com/ http://www.ruby-lang.org/de/ http://prototypejs.org/api http://www.sitepoint.com/article/learn-ruby-on-rails/ http://home.vr-web.de/juergen.katins/ruby/buch/ Seite 21 Einführung in Ruby On Rails – Architektur und Konzepte

×