<%= simple_format @article.body %>
<%# Partial für Kommentare %>
<%= render @comments %>
```
Der typische Ablauf: Der Request erreicht den Router, der ihn an den passenden Controller weiterleitet. Der Controller interagiert mit dem Model, um Daten abzurufen oder zu ändern, und übergibt diese dann der View für das HTML-Rendering.
### Frage 2: Was ist Active Record und wie funktioniert das ORM von Rails?
Active Record ist das ORM (Object-Relational Mapping) von Rails, das das Active-Record-Pattern implementiert. Jede Model-Klasse repräsentiert eine Datenbanktabelle, und jede Instanz repräsentiert eine Zeile.
```ruby
# app/models/user.rb
# Active Record ordnet Spalten automatisch Attributen zu
class User < ApplicationRecord
# Die Tabelle 'users' wird automatisch zugeordnet
# Spalten: id, email, name, created_at, updated_at
has_secure_password # BCrypt für das Passwort
has_many :articles, foreign_key: :author_id
has_one :profile, dependent: :destroy
has_and_belongs_to_many :roles
# Validierungen
validates :email, presence: true,
uniqueness: { case_sensitive: false },
format: { with: URI::MailTo::EMAIL_REGEXP }
# Callbacks
before_save :normalize_email
# Klassenmethoden für Abfragen
def self.admins
joins(:roles).where(roles: { name: 'admin' })
end
private
def normalize_email
self.email = email.downcase.strip
end
end
```
```ruby
# Beispiele für Active-Record-Abfragen
# Rails-Konsole oder innerhalb eines Service
# Erstellung
user = User.create!(email: 'dev@example.com', name: 'Alice', password: 'secret123')
# Lesen mit Bedingungen
active_users = User.where(active: true).order(:name)
user = User.find_by(email: 'dev@example.com')
# Verkettete Abfragen (Lazy Evaluation)
recent_admins = User.admins
.where('created_at > ?', 1.month.ago)
.includes(:profile)
.limit(10)
# N+1-Vermeidung mit Eager Loading
articles = Article.includes(:author, :comments).published
# Aktualisierung
user.update!(name: 'Alice Martin')
# Transaktionen
User.transaction do
user.debit_balance!(100)
recipient.credit_balance!(100)
Payment.create!(from: user, to: recipient, amount: 100)
end
```
Active Record wandelt Ruby-Methoden in optimierte SQL-Abfragen um. Methoden wie `where`, `joins`, `includes` sind lazy: Die Abfrage wird erst beim Iterieren oder beim Aufruf von `to_a` ausgeführt.
### Frage 3: Erklären Sie das Migrationssystem von Rails
Migrationen ermöglichen es, das Datenbankschema mit Ruby zu versionieren. Sie sind reversibel und ermöglichen eine kontrollierte Weiterentwicklung der Datenstruktur.
```ruby
# db/migrate/20260203100000_create_products.rb
# Migration zum Anlegen einer Tabelle
class CreateProducts < ActiveRecord::Migration[7.1]
def change
create_table :products do |t|
t.string :name, null: false
t.text :description
t.decimal :price, precision: 10, scale: 2, null: false
t.integer :stock_quantity, default: 0
t.references :category, null: false, foreign_key: true
t.boolean :active, default: true
t.timestamps # created_at und updated_at automatisch
end
# Indizes für die Performance
add_index :products, :name
add_index :products, [:category_id, :active]
end
end
```
```ruby
# db/migrate/20260203110000_add_slug_to_products.rb
# Migration zum Ändern einer existierenden Tabelle
class AddSlugToProducts < ActiveRecord::Migration[7.1]
def change
add_column :products, :slug, :string
add_index :products, :slug, unique: true
# Bestehende Slugs befüllen
reversible do |dir|
dir.up do
Product.find_each do |product|
product.update_column(:slug, product.name.parameterize)
end
end
end
# Nach Befüllung NOT NULL setzen
change_column_null :products, :slug, false
end
end
```
```bash
# Wesentliche Migrationsbefehle
rails db:migrate # Ausstehende Migrationen ausführen
rails db:rollback # Letzte Migration rückgängig machen
rails db:rollback STEP=3 # Letzte 3 Migrationen rückgängig machen
rails db:migrate:status # Status der Migrationen anzeigen
rails db:seed # db/seeds.rb ausführen
rails db:reset # Drop, create, migrate, seed
```
Migrationen müssen reversibel sein. Die Methode `change` ist intelligent und kann gängige Operationen automatisch umkehren. Für komplexe Fälle `up` und `down` separat verwenden.
## Fortgeschrittenes Active Record
### Frage 4: Wie optimiert man N+1-Abfragen in Rails?
Das N+1-Problem tritt auf, wenn auf eine initiale Abfrage N zusätzliche Abfragen folgen, um Assoziationen zu laden. Rails bietet mehrere Eager-Loading-Methoden zur Lösung dieses Problems.
```ruby
# app/controllers/orders_controller.rb
class OrdersController < ApplicationController
def index
# ❌ N+1-PROBLEM: 1 Abfrage + N Abfragen pro Bestellung
# @orders = Order.all
# In der View: order.user.name erzeugt eine Abfrage pro Bestellung
# ✅ LÖSUNG mit includes (Eager Loading)
@orders = Order.includes(:user, :items)
.where(status: 'completed')
.order(created_at: :desc)
# Erzeugt insgesamt nur 3 Abfragen
end
def show
# includes: lädt Assoziationen separat (2-3 Abfragen)
@order = Order.includes(items: :product).find(params[:id])
# preload: erzwingt separates Laden
@order = Order.preload(:items, :user).find(params[:id])
# eager_load: erzwingt LEFT OUTER JOIN (1 Abfrage)
@order = Order.eager_load(:items).find(params[:id])
end
end
```
```ruby
# app/models/order.rb
class Order < ApplicationRecord
belongs_to :user
has_many :items, class_name: 'OrderItem'
has_many :products, through: :items
# Scope mit standardmäßigem includes
scope :with_details, -> { includes(:user, items: :product) }
# Counter Cache zur Vermeidung von COUNT-Abfragen
# Erfordert: add_column :users, :orders_count, :integer, default: 0
belongs_to :user, counter_cache: true
end
```
```ruby
# N+1-Erkennung mit der Bullet-Gem (Entwicklung)
# config/environments/development.rb
config.after_initialize do
Bullet.enable = true
Bullet.alert = true
Bullet.bullet_logger = true
Bullet.rails_logger = true
end
# Bullet zeigt Warnungen, wenn:
# - Eine N+1-Abfrage erkannt wird
# - Unnötiges Eager Loading vorliegt
# - Ein Counter Cache verwendet werden sollte
```
Die Regel: standardmäßig `includes` verwenden (Rails wählt die optimale Strategie), `preload` wenn separate Abfragen erzwungen werden sollen, `eager_load` wenn auf Assoziationen gefiltert wird.
### Frage 5: Erklären Sie Scopes und Query Objects in Rails
Scopes kapseln wiederverwendbare Abfragebedingungen. Für komplexe Abfragen bieten Query Objects bessere Organisation und Testbarkeit.
```ruby
# app/models/product.rb
class Product < ApplicationRecord
# Einfache Scopes
scope :active, -> { where(active: true) }
scope :in_stock, -> { where('stock_quantity > 0') }
scope :featured, -> { where(featured: true) }
# Scopes mit Parametern
scope :cheaper_than, ->(price) { where('price < ?', price) }
scope :in_category, ->(category) { where(category: category) }
# Verkettbare Scopes
scope :available, -> { active.in_stock }
# Scope mit Joins
scope :with_recent_orders, -> {
joins(:order_items)
.where('order_items.created_at > ?', 30.days.ago)
.distinct
}
# Scope mit Subquery
scope :bestsellers, -> {
where(id: OrderItem.group(:product_id)
.order('COUNT(*) DESC')
.limit(10)
.select(:product_id))
}
end
```
```ruby
# app/queries/products_search_query.rb
# Query Object für komplexe Suchen
class ProductsSearchQuery
def initialize(relation = Product.all)
@relation = relation
end
def call(params)
@relation = filter_by_category(params[:category])
@relation = filter_by_price_range(params[:min_price], params[:max_price])
@relation = filter_by_search(params[:q])
@relation = apply_sorting(params[:sort])
@relation
end
private
def filter_by_category(category)
return @relation if category.blank?
@relation.where(category_id: category)
end
def filter_by_price_range(min, max)
@relation = @relation.where('price >= ?', min) if min.present?
@relation = @relation.where('price <= ?', max) if max.present?
@relation
end
def filter_by_search(query)
return @relation if query.blank?
@relation.where('name ILIKE ? OR description ILIKE ?',
"%#{query}%", "%#{query}%")
end
def apply_sorting(sort)
case sort
when 'price_asc' then @relation.order(price: :asc)
when 'price_desc' then @relation.order(price: :desc)
when 'newest' then @relation.order(created_at: :desc)
else @relation.order(:name)
end
end
end
# Verwendung im Controller
@products = ProductsSearchQuery.new(Product.active).call(params)
```
Scopes eignen sich perfekt für einfache, wiederverwendbare Bedingungen. Query Objects passen zu komplexen Suchen mit mehreren optionalen Filtern und Kompositionslogik.
## Routing und Controllers
### Frage 6: Wie funktioniert RESTful Routing in Rails?
Rails fördert RESTful-Routen, die HTTP-Verben auf CRUD-Aktionen abbilden. Der Router übersetzt URLs in spezifische Controller-Aufrufe.
```ruby
# config/routes.rb
Rails.application.routes.draw do
# Standardmäßige RESTful-Routen (7 Aktionen)
resources :articles do
# Verschachtelte Routen
resources :comments, only: [:create, :destroy]
# Member-Routen (wirken auf eine Instanz)
member do
post :publish
delete :archive
end
# Collection-Routen (wirken auf die Sammlung)
collection do
get :drafts
get :search
end
end
# API-Routen mit Namespace
namespace :api do
namespace :v1 do
resources :products, only: [:index, :show, :create, :update] do
resources :reviews, shallow: true
end
end
end
# Benutzerdefinierte Route
get 'dashboard', to: 'dashboard#index'
# Routenbeschränkungen
constraints(SubdomainConstraint.new) do
resources :admin_settings
end
# Root-Route
root 'home#index'
end
```
```bash
# rails routes - Zeigt alle generierten Routen
#
# Verb URI Pattern Controller#Action
# GET /articles articles#index
# POST /articles articles#create
# GET /articles/new articles#new
# GET /articles/:id/edit articles#edit
# GET /articles/:id articles#show
# PATCH /articles/:id articles#update
# DELETE /articles/:id articles#destroy
# POST /articles/:id/publish articles#publish
# GET /articles/drafts articles#drafts
```
Generierte Route-Helper (`article_path(@article)`, `new_article_path`) erlauben es, URLs dynamisch und wartbar zu referenzieren.
### Frage 7: Erklären Sie Callbacks und Filter in Controllern
Callbacks (before_action, after_action, around_action) erlauben es, Code vor, nach oder rund um Controller-Aktionen auszuführen.
```ruby
# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
# CSRF-Schutz standardmäßig aktiviert
protect_from_forgery with: :exception
# Globaler Callback für die Authentifizierung
before_action :authenticate_user!
# Globale Fehlerbehandlung
rescue_from ActiveRecord::RecordNotFound, with: :not_found
rescue_from ActionController::ParameterMissing, with: :bad_request
private
def not_found
render json: { error: 'Ressource nicht gefunden' }, status: :not_found
end
def bad_request(exception)
render json: { error: exception.message }, status: :bad_request
end
end
```
```ruby
# app/controllers/admin/products_controller.rb
class Admin::ProductsController < ApplicationController
# Callbacks mit Optionen
before_action :require_admin
before_action :set_product, only: [:show, :edit, :update, :destroy]
after_action :log_activity, only: [:create, :update, :destroy]
# Bedingter Callback
before_action :check_stock, only: [:update], if: :stock_changed?
def create
@product = Product.new(product_params)
if @product.save
redirect_to [:admin, @product], notice: 'Produkt erstellt.'
else
render :new, status: :unprocessable_entity
end
end
def update
if @product.update(product_params)
redirect_to [:admin, @product], notice: 'Produkt aktualisiert.'
else
render :edit, status: :unprocessable_entity
end
end
private
def require_admin
redirect_to root_path unless current_user&.admin?
end
def set_product
@product = Product.find(params[:id])
end
def stock_changed?
params[:product][:stock_quantity].present?
end
def log_activity
ActivityLog.create!(
user: current_user,
action: action_name,
resource: @product
)
end
def product_params
params.require(:product).permit(:name, :price, :description, :stock_quantity)
end
end
```
Callbacks werden in der Reihenfolge ihrer Deklaration ausgeführt. `skip_before_action` in Subklassen verwenden, um geerbte Callbacks zu deaktivieren. Callbacks mit zu viel Geschäftslogik vermeiden: Service Objects bevorzugen.
## Services und Architektur
### Frage 8: Wie implementiert man Service Objects in Rails?
Service Objects kapseln komplexe Geschäftslogik, die weder zu Models noch zu Controllern gehört. Sie verbessern die Testbarkeit und folgen dem Single-Responsibility-Prinzip.
```ruby
# app/services/order_processor.rb
# Service Object mit standardisierter Schnittstelle
class OrderProcessor
def initialize(order, payment_method:)
@order = order
@payment_method = payment_method
end
def call
return failure('Bestellung bereits verarbeitet') if @order.processed?
ActiveRecord::Base.transaction do
validate_stock!
process_payment!
update_inventory!
send_confirmation!
@order.update!(status: 'completed', processed_at: Time.current)
end
success(@order)
rescue PaymentError => e
failure("Zahlung fehlgeschlagen: #{e.message}")
rescue InsufficientStockError => e
failure("Lagerbestand unzureichend: #{e.message}")
end
private
def validate_stock!
@order.items.each do |item|
unless item.product.stock_quantity >= item.quantity
raise InsufficientStockError, item.product.name
end
end
end
def process_payment!
result = PaymentGateway.charge(
amount: @order.total,
method: @payment_method,
description: "Bestellung ##{@order.id}"
)
raise PaymentError, result.error unless result.success?
@order.update!(payment_reference: result.transaction_id)
end
def update_inventory!
@order.items.each do |item|
item.product.decrement!(:stock_quantity, item.quantity)
end
end
def send_confirmation!
OrderMailer.confirmation(@order).deliver_later
end
def success(data)
Result.new(success: true, data: data)
end
def failure(error)
Result.new(success: false, error: error)
end
Result = Struct.new(:success, :data, :error, keyword_init: true) do
def success? = success
def failure? = !success
end
end
```
```ruby
# app/controllers/orders_controller.rb
class OrdersController < ApplicationController
def create
@order = current_user.orders.build(order_params)
if @order.save
result = OrderProcessor.new(@order, payment_method: params[:payment_method]).call
if result.success?
redirect_to @order, notice: 'Bestellung bestätigt!'
else
@order.update!(status: 'payment_failed')
flash.now[:alert] = result.error
render :new, status: :unprocessable_entity
end
else
render :new, status: :unprocessable_entity
end
end
end
```
Das Service-Object-Pattern folgt einer einfachen Konvention: eine Klasse, eine Verantwortung, eine öffentliche `call`-Methode. Ein Result-Objekt zurückzugeben ermöglicht eine saubere Behandlung von Erfolg und Fehler.
### Frage 9: Erklären Sie Concerns in Rails
Concerns ermöglichen es, Code zwischen Models oder Controllern zu extrahieren und zu teilen. Sie nutzen `ActiveSupport::Concern` für eine saubere Inklusionssyntax.
```ruby
# app/models/concerns/sluggable.rb
# Wiederverwendbares Concern zur Slug-Generierung
module Sluggable
extend ActiveSupport::Concern
included do
# Beim Einbinden ausgeführter Code
before_validation :generate_slug, if: :should_generate_slug?
validates :slug, presence: true, uniqueness: true
end
# Klassenmethoden
class_methods do
def find_by_slug!(slug)
find_by!(slug: slug)
end
def sluggable_source(column = :title)
@sluggable_source = column
end
def sluggable_source_column
@sluggable_source || :title
end
end
# Instanzmethoden
def to_param
slug
end
private
def should_generate_slug?
slug.blank? || send("#{self.class.sluggable_source_column}_changed?")
end
def generate_slug
source = send(self.class.sluggable_source_column)
return if source.blank?
base_slug = source.parameterize
self.slug = unique_slug(base_slug)
end
def unique_slug(base)
slug = base
counter = 1
while self.class.where(slug: slug).where.not(id: id).exists?
slug = "#{base}-#{counter}"
counter += 1
end
slug
end
end
```
```ruby
# app/models/article.rb
class Article < ApplicationRecord
include Sluggable
sluggable_source :title # Optional, :title als Standard
end
# app/models/product.rb
class Product < ApplicationRecord
include Sluggable
sluggable_source :name
end
```
```ruby
# app/controllers/concerns/pagination.rb
# Concern für Controller
module Pagination
extend ActiveSupport::Concern
included do
helper_method :page_param, :per_page_param
end
private
def paginate(relation)
relation.page(page_param).per(per_page_param)
end
def page_param
params[:page]&.to_i || 1
end
def per_page_param
[params[:per_page]&.to_i || 25, 100].min
end
end
```
Concerns sind nützlich für wirklich gemeinsam genutzten Code. Vermeiden, Concerns nur zu erstellen, um ein Model zu "verkürzen": Das versteckt Komplexität, ohne sie zu reduzieren.
## Testen mit RSpec
### Frage 10: Wie strukturiert man RSpec-Tests in Rails?
RSpec ist das Standard-Testing-Framework für Rails. Eine gute Teststruktur umfasst Model Specs, Controller Specs, Service Specs und Integrationstests.
```ruby
# spec/models/user_spec.rb
require 'rails_helper'
RSpec.describe User, type: :model do
# Factories mit FactoryBot
let(:user) { build(:user) }
let(:admin) { build(:user, :admin) }
describe 'validations' do
it { is_expected.to validate_presence_of(:email) }
it { is_expected.to validate_uniqueness_of(:email).case_insensitive }
it 'validiert das E-Mail-Format' do
user.email = 'invalid'
expect(user).not_to be_valid
expect(user.errors[:email]).to include('is invalid')
end
end
describe 'associations' do
it { is_expected.to have_many(:articles).dependent(:destroy) }
it { is_expected.to have_one(:profile) }
it { is_expected.to belong_to(:organization).optional }
end
describe '#full_name' do
it 'gibt Vor- und Nachname kombiniert zurück' do
user = build(:user, first_name: 'John', last_name: 'Doe')
expect(user.full_name).to eq('John Doe')
end
it 'behandelt fehlenden Nachnamen' do
user = build(:user, first_name: 'John', last_name: nil)
expect(user.full_name).to eq('John')
end
end
describe '.active' do
it 'gibt nur aktive Benutzer zurück' do
active = create(:user, active: true)
inactive = create(:user, active: false)
expect(User.active).to include(active)
expect(User.active).not_to include(inactive)
end
end
end
```
```ruby
# spec/services/order_processor_spec.rb
require 'rails_helper'
RSpec.describe OrderProcessor do
let(:user) { create(:user) }
let(:product) { create(:product, stock_quantity: 10, price: 100) }
let(:order) { create(:order, user: user, items: [build(:order_item, product: product, quantity: 2)]) }
subject { described_class.new(order, payment_method: 'card') }
describe '#call' do
context 'wenn die Bestellung gültig ist' do
before do
allow(PaymentGateway).to receive(:charge).and_return(
OpenStruct.new(success?: true, transaction_id: 'txn_123')
)
end
it 'verarbeitet die Bestellung erfolgreich' do
result = subject.call
expect(result).to be_success
expect(order.reload.status).to eq('completed')
end
it 'verringert den Produktbestand' do
expect { subject.call }.to change { product.reload.stock_quantity }.by(-2)
end
it 'sendet die Bestätigungs-E-Mail' do
expect { subject.call }
.to have_enqueued_mail(OrderMailer, :confirmation)
.with(order)
end
end
context 'wenn die Zahlung fehlschlägt' do
before do
allow(PaymentGateway).to receive(:charge).and_return(
OpenStruct.new(success?: false, error: 'Card declined')
)
end
it 'gibt ein Fehlerergebnis zurück' do
result = subject.call
expect(result).to be_failure
expect(result.error).to include('Card declined')
end
it 'aktualisiert den Bestellstatus nicht' do
expect { subject.call }.not_to change { order.reload.status }
end
end
end
end
```
```ruby
# spec/requests/api/v1/products_spec.rb
require 'rails_helper'
RSpec.describe 'API V1 Products', type: :request do
let(:user) { create(:user) }
let(:headers) { { 'Authorization' => "Bearer #{user.api_token}" } }
describe 'GET /api/v1/products' do
let!(:products) { create_list(:product, 3, :active) }
it 'gibt die Produktliste zurück' do
get '/api/v1/products', headers: headers
expect(response).to have_http_status(:ok)
expect(json_response['data'].size).to eq(3)
end
it 'filtert nach Kategorie' do
category = create(:category)
categorized = create(:product, category: category)
get '/api/v1/products', params: { category_id: category.id }, headers: headers
expect(json_response['data'].map { |p| p['id'] }).to eq([categorized.id])
end
end
describe 'POST /api/v1/products' do
let(:valid_params) do
{ product: { name: 'Neues Produkt', price: 99.99, category_id: create(:category).id } }
end
it 'erstellt ein neues Produkt' do
expect {
post '/api/v1/products', params: valid_params, headers: headers
}.to change(Product, :count).by(1)
expect(response).to have_http_status(:created)
end
end
end
```
Best Practices: `let` für Daten, `describe` für Methoden/Kontexte, `context` für Bedingungen und `it` für spezifische Assertions. Ein Test sollte eine Sache testen.
### Frage 11: Wie verwendet man Factories mit FactoryBot?
FactoryBot ermöglicht es, Testdaten deklarativ und wartbar zu erstellen. Factories ersetzen statische Fixtures.
```ruby
# spec/factories/users.rb
FactoryBot.define do
factory :user do
# Sequenzen für Eindeutigkeit
sequence(:email) { |n| "user#{n}@example.com" }
first_name { Faker::Name.first_name }
last_name { Faker::Name.last_name }
password { 'password123' }
confirmed_at { Time.current }
# Traits für Variationen
trait :admin do
role { 'admin' }
after(:create) do |user|
user.permissions.create!(name: 'admin_access')
end
end
trait :unconfirmed do
confirmed_at { nil }
end
trait :with_profile do
after(:create) do |user|
create(:profile, user: user)
end
end
trait :with_articles do
transient do
articles_count { 3 }
end
after(:create) do |user, evaluator|
create_list(:article, evaluator.articles_count, author: user)
end
end
# Geerbte Factory
factory :admin_user do
admin
with_profile
end
end
end
```
```ruby
# spec/factories/orders.rb
FactoryBot.define do
factory :order do
user
status { 'pending' }
trait :with_items do
transient do
items_count { 2 }
end
after(:create) do |order, evaluator|
create_list(:order_item, evaluator.items_count, order: order)
order.recalculate_total!
end
end
trait :completed do
status { 'completed' }
processed_at { Time.current }
with_items
end
trait :high_value do
after(:create) do |order|
create(:order_item, order: order, quantity: 10, unit_price: 500)
order.recalculate_total!
end
end
end
end
```
```ruby
# Verwendung in Tests
RSpec.describe OrderProcessor do
# build: nicht persistierte Instanz
let(:user) { build(:user) }
# create: in DB persistiert
let(:order) { create(:order, :with_items, user: user) }
# create_list: mehrere Instanzen
let(:products) { create_list(:product, 5) }
# Traits kombinieren
let(:admin) { create(:user, :admin, :with_profile) }
# Attribute überschreiben
let(:expensive_order) { create(:order, :with_items, items_count: 10) }
# build_stubbed: schneller, für Unit-Tests
let(:stubbed_user) { build_stubbed(:user) }
end
```
`build` oder `build_stubbed` gegenüber `create` bevorzugen, wenn keine Persistenz nötig ist: Das beschleunigt die Tests deutlich.
## Background Jobs
### Frage 12: Wie verwendet man Active Job und Sidekiq in Rails?
Active Job bietet eine einheitliche Schnittstelle für Hintergrundjobs, unabhängig vom Backend (Sidekiq, Resque usw.). Sidekiq ist die populäre Wahl wegen seiner Performance mit Redis.
```ruby
# app/jobs/process_order_job.rb
class ProcessOrderJob < ApplicationJob
queue_as :default
# Wiederholungskonfiguration
retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
retry_on Net::OpenTimeout, wait: :polynomially_longer, attempts: 10
discard_on ActiveJob::DeserializationError
# Sidekiq-Optionen (bei Sidekiq-Backend)
sidekiq_options retry: 5, backtrace: true
def perform(order_id)
order = Order.find(order_id)
OrderProcessor.new(order).call
rescue ActiveRecord::RecordNotFound
# Bestellung zwischen Einreihen und Ausführung gelöscht
Rails.logger.warn("Order #{order_id} not found, skipping job")
end
end
```
```ruby
# app/jobs/batch_email_job.rb
class BatchEmailJob < ApplicationJob
queue_as :mailers
# Rate Limiting mit Sidekiq Enterprise oder Throttle-Gem
sidekiq_options throttle: { threshold: 100, period: 1.minute }
def perform(user_ids, template_id)
template = EmailTemplate.find(template_id)
User.where(id: user_ids).find_each do |user|
UserMailer.custom_email(user, template).deliver_later
end
end
end
```
```ruby
# Jobs einreihen
# Sofort
ProcessOrderJob.perform_later(order.id)
# Verzögert
ProcessOrderJob.set(wait: 5.minutes).perform_later(order.id)
# Zu einem bestimmten Zeitpunkt
ProcessOrderJob.set(wait_until: Date.tomorrow.noon).perform_later(order.id)
# Bestimmte Queue
ProcessOrderJob.set(queue: :critical).perform_later(order.id)
# Synchron (für Tests oder Debugging)
ProcessOrderJob.perform_now(order.id)
```
```ruby
# config/sidekiq.yml
:concurrency: 10
:queues:
- [critical, 3] # Hohe Priorität, Gewicht 3
- [default, 2] # Mittlere Priorität, Gewicht 2
- [mailers, 1] # Niedrige Priorität, Gewicht 1
- [low, 1]
:schedule:
cleanup_job:
cron: '0 3 * * *' # Jeden Tag um 3 Uhr
class: CleanupJob
```
Active Job abstrahiert das Backend, aber der Zugriff auf spezifische Funktionen (Batches, Rate Limiting) erfordert oft eine Kopplung an das gewählte Backend.
## API-Entwicklung
### Frage 13: Wie baut man eine RESTful API mit Rails?
Rails erleichtert den Bau von JSON-APIs mit API-only-Controllern und Serializern. Eine gute API ist versioniert, dokumentiert und sicher.
```ruby
# app/controllers/api/v1/base_controller.rb
module Api
module V1
class BaseController < ActionController::API
include ActionController::HttpAuthentication::Token::ControllerMethods
before_action :authenticate_token!
rescue_from ActiveRecord::RecordNotFound, with: :not_found
rescue_from ActiveRecord::RecordInvalid, with: :unprocessable_entity
rescue_from ActionController::ParameterMissing, with: :bad_request
private
def authenticate_token!
authenticate_or_request_with_http_token do |token, options|
@current_user = User.find_by(api_token: token)
end
end
def current_user
@current_user
end
def not_found(exception)
render json: { error: 'Ressource nicht gefunden', details: exception.message },
status: :not_found
end
def unprocessable_entity(exception)
render json: { error: 'Validierung fehlgeschlagen', details: exception.record.errors },
status: :unprocessable_entity
end
def bad_request(exception)
render json: { error: 'Ungültige Anfrage', details: exception.message },
status: :bad_request
end
end
end
end
```
```ruby
# app/controllers/api/v1/products_controller.rb
module Api
module V1
class ProductsController < BaseController
before_action :set_product, only: [:show, :update, :destroy]
def index
@products = Product.active
.includes(:category)
.page(params[:page])
.per(params[:per_page] || 20)
render json: {
data: ProductSerializer.new(@products).serializable_hash,
meta: pagination_meta(@products)
}
end
def show
render json: ProductSerializer.new(@product, include: [:category, :reviews])
end
def create
@product = Product.new(product_params)
@product.save!
render json: ProductSerializer.new(@product), status: :created
end
def update
@product.update!(product_params)
render json: ProductSerializer.new(@product)
end
def destroy
@product.destroy!
head :no_content
end
private
def set_product
@product = Product.find(params[:id])
end
def product_params
params.require(:product).permit(:name, :description, :price, :category_id)
end
def pagination_meta(collection)
{
current_page: collection.current_page,
total_pages: collection.total_pages,
total_count: collection.total_count
}
end
end
end
end
```
```ruby
# app/serializers/product_serializer.rb
# Mit der jsonapi-serializer-Gem
class ProductSerializer
include JSONAPI::Serializer
attributes :id, :name, :description, :price, :created_at
attribute :formatted_price do |product|
"$#{product.price.to_f.round(2)}"
end
belongs_to :category
has_many :reviews
link :self do |product|
Rails.application.routes.url_helpers.api_v1_product_url(product)
end
end
```
API-Best-Practices: über Namespace versionieren, passende HTTP-Codes verwenden, Sammlungen paginieren und klare Fehlermeldungen bereitstellen.
### Frage 14: Wie implementiert man JWT-Authentifizierung in Rails?
JWT (JSON Web Tokens) ist eine populäre stateless Authentifizierungsmethode für APIs. Das Token kodiert die Identität und Gültigkeit des Benutzers.
```ruby
# app/services/jwt_service.rb
class JwtService
SECRET_KEY = Rails.application.credentials.secret_key_base
ALGORITHM = 'HS256'.freeze
class << self
def encode(payload, exp = 24.hours.from_now)
payload[:exp] = exp.to_i
payload[:iat] = Time.current.to_i
JWT.encode(payload, SECRET_KEY, ALGORITHM)
end
def decode(token)
decoded = JWT.decode(token, SECRET_KEY, true, algorithm: ALGORITHM)
HashWithIndifferentAccess.new(decoded.first)
rescue JWT::ExpiredSignature
raise AuthenticationError, 'Token abgelaufen'
rescue JWT::DecodeError
raise AuthenticationError, 'Ungültiges Token'
end
end
end
```
```ruby
# app/controllers/api/v1/auth_controller.rb
module Api
module V1
class AuthController < ActionController::API
def login
user = User.find_by(email: params[:email])
if user&.authenticate(params[:password])
token = JwtService.encode(user_id: user.id)
render json: {
token: token,
user: UserSerializer.new(user),
expires_at: 24.hours.from_now
}
else
render json: { error: 'Ungültige Zugangsdaten' }, status: :unauthorized
end
end
def refresh
token = JwtService.encode(user_id: current_user.id)
render json: { token: token, expires_at: 24.hours.from_now }
end
end
end
end
```
```ruby
# app/controllers/concerns/jwt_authenticatable.rb
module JwtAuthenticatable
extend ActiveSupport::Concern
included do
before_action :authenticate_jwt!
end
private
def authenticate_jwt!
header = request.headers['Authorization']
token = header&.split(' ')&.last
raise AuthenticationError, 'Token fehlt' unless token
decoded = JwtService.decode(token)
@current_user = User.find(decoded[:user_id])
rescue AuthenticationError => e
render json: { error: e.message }, status: :unauthorized
rescue ActiveRecord::RecordNotFound
render json: { error: 'Benutzer nicht gefunden' }, status: :unauthorized
end
def current_user
@current_user
end
end
```
Für die Produktion in Betracht ziehen: Refresh Tokens, Token-Blacklisting beim Logout und kurze Ablaufzeiten. Gems wie `devise-jwt` vereinfachen die Implementierung.
## Caching und Performance
### Frage 15: Wie implementiert man Caching in Rails?
Rails bietet mehrere Caching-Ebenen: Fragment Caching, Russian Doll Caching, Low-Level-Caching. Die Wahl hängt vom Anwendungsfall ab.
```ruby
# config/environments/production.rb
config.action_controller.perform_caching = true
config.cache_store = :redis_cache_store, {
url: ENV['REDIS_URL'],
namespace: 'myapp:cache',
expires_in: 1.day,
race_condition_ttl: 10.seconds
}
```
```erb
<%# app/views/products/index.html.erb %>
<%# Fragment Caching mit automatischem Cache-Schlüssel %>
<% @products.each do |product| %>
<%# Cache basiert auf updated_at des Produkts %>
<% cache product do %>
<%= render product %>
<% end %>
<% end %>
<%# Russian Doll Caching - verschachtelter Cache %>
<% cache ['v1', @category] do %>