Patterns of Enterprise
Application Architecture 入門

def place_order(user_id, items)
  total = items.sum { |i| i[:price] * i[:quantity] }
  items.each do |i|
    stock = Stock.find_by!(product_id: i[:product_id])
    stock.decrement!(:quantity, i[:quantity])
  end
  Order.create!(user_id: user_id, total: total)
end

class Order
  def initialize(lines, customer)
    @lines = lines
    @customer = customer
  end

  def total
    subtotal - discount
  end

  def subtotal
    @lines.sum(&:amount)
  end

  def discount
    @customer.vip? ? subtotal * 0.1 : 0
  end
end

class OrderLine
  def amount = @price * @quantity
end

public class OrderModule {
    private DataTable table;  // 注文テーブル全体を保持

    public decimal CalculateDiscount(long orderId) {
        DataRow row = table.Rows.Find(orderId);
        decimal total = (decimal)row["total"];
        return total > 10000 ? total * 0.1m : 0;
    }
}

class OrderService
  def cancel_order(order_id)
    ActiveRecord::Base.transaction do
      order = Order.find(order_id)
      order.cancel              # ドメインモデルのふるまい
      order.restore_stock       # 在庫を戻す
      Mailer.notify_cancel(order).deliver_later
    end
  end
end

class UserGateway
  def find(id)
    DB.query("SELECT * FROM users WHERE id = ?", id) # 1行ぶんのHashを返す
  end

  def find_by_department(dept)
    DB.query("SELECT * FROM users WHERE department = ?", dept) # 複数行
  end
end

class UserRow
  attr_accessor :id, :name, :email

  def insert
    DB.execute("INSERT INTO users(name, email) VALUES(?, ?)", name, email)
    self.id = DB.last_insert_id
  end

  def update
    DB.execute("UPDATE users SET name=?, email=? WHERE id=?", name, email, id)
  end
end

class User < ApplicationRecord
  # 検索・保存はクラス／インスタンスが自分で行う
  def self.active = where(status: "active")

  # 業務ロジックも同じクラスに同居する
  def deactivate!
    update!(status: "inactive")
  end
end

user = User.find(1)
user.deactivate!

// ドメインオブジェクトはDBを知らない（ただのデータと振る舞い）
class User {
    private int id;
    private String name;
}

// マッパーが変換と永続化を担う
class UserMapper {
    User findById(int id) { /* SELECT して User に詰め替える */ }
    void insert(User user) { /* User から INSERT 文を組み立てる */ }
}

uow = UnitOfWork.new
uow.register_new(order)        # 追加予定として記録するだけ
uow.register_dirty(customer)   # 更新予定として記録するだけ
uow.register_removed(coupon)   # 削除予定として記録するだけ

# ここまでDBアクセスは発生しない
uow.commit  # 溜めた変更を1トランザクションでまとめて書き込む

def find(id)
  return identity_map.get(id) if identity_map.get(id)  # 台帳にあれば再クエリせず同じものを返す
  obj = load_from_db(id)
  identity_map.put(id, obj)                            # 初回はDBから読み、台帳に登録
  obj
end

a = repo.find(1)
b = repo.find(1)
a.equal?(b)   # => true（同一インスタンス。DBアクセスは1回だけ）

# before: 各 post.author でその都度クエリ → 1 + 10 回
posts = Post.limit(10)
posts.each { |post| puts post.author.name }

# after: 著者をまとめて先読み → 2 回（posts と authors）
posts = Post.includes(:author).limit(10)
posts.each { |post| puts post.author.name }

usersテーブル          User オブジェクト
id | name              user.id   == 1   ← 主キー値を保持（Identity Field）
---+------             user.name == "田中"
 1 | 田中

employeesテーブル              departmentsテーブル
id | name | department_id      id | name
---+------+--------------      ---+--------
 1 | 田中 |      10      --->   10 | 営業部

employee.department  #=> Department(id: 10)

studentsテーブル   enrollmentsテーブル        coursesテーブル
id | name          student_id | course_id     id | title
---+-----          -----------+----------     ---+--------
 1 | 佐藤      <--      1      |    20     -->  20 | 数学
                        1      |    21          21 | 物理

class Order
  # 明細の読み書きはOrderが一括で面倒を見る（LineItemは自分でDB操作しない）
  def load_line_items
    rows = db.query("SELECT * FROM line_items WHERE order_id = ?", id)
    @line_items = rows.map { |r| LineItem.new(r) }
  end
end

customersテーブル                     オブジェクト側
id | name | zip     | prefecture       customer.address
---+------+---------+-----------         => Address(zip:..., prefecture:...)
 1 | 田中 | 1000001 | 東京都

usersテーブル
id | name | settings
---+------+------------------------------------
 1 | 田中 | {"theme":"dark","notify":true}   ← JSONを丸ごと1カラムに

players（1テーブルに全種類）
id | type        | name | club    | batting_avg
---+-------------+------+---------+------------
 1 | Footballer  | 田中  | FC東京  | (NULL)
 2 | Cricketer   | 鈴木  | (NULL)  | 35.2

players(共通)    footballers(固有)   cricketers(固有)
id | name        id | club           id | batting_avg
---+-----        ---+------          ---+-----------
 1 | 田中  <同id>  1 | FC東京
# Footballer 1人を得るには players と footballers をJOINする

footballers(完結)        cricketers(完結)
id | name | club          id | name | batting_avg
---+------+------         ---+------+-----------
 1 | 田中  | FC東京         1 | 鈴木  | 35.2
# name を各テーブルが個別に持つ／JOIN不要で速い

class AbstractPlayerMapper                       # 共通のSQL組み立て・ロード/保存
  def load(row); ...; end
end
class FootballerMapper < AbstractPlayerMapper    # Footballer固有部分だけ実装
end

mapping = {
  User => { table: "users",
            columns: { name: "name", email: "email_address" } }
}
# この表を解釈してSQLとオブジェクトを自動変換する（フィールドが増えても手書きしない）

query = UserQuery.new
  .where(:prefecture, "=", "東京都")
  .where(:purchased_at, ">", 30.days.ago)
users = query.execute   # ここで初めてSQLに変換して実行

class UserRepository
  def find_active_users
    # 中ではQuery ObjectやSQLを使うが、呼び出し側からは隠れている
    UserQuery.new.where(:active, "=", true).execute
  end
end

users = UserRepository.new.find_active_users

# app/controllers（Controller：入力を受け、Modelを呼び、Viewへ渡す）
class UsersController < ApplicationController
  def index
    @users = User.active   # Modelに問い合わせ → views/users/index.html.erb が表示
  end
end
# app/models（Model：データと業務ロジック）
class User < ApplicationRecord
  scope :active, -> { where(active: true) }
end

# config/routes.rb（URLごとに窓口を割り当てる）
get   "/users/:id",  to: "users#show"
patch "/users/:id",  to: "users#update"

# 画面・操作ごとに1メソッド＝1窓口
class UsersController < ApplicationController
  def show
    @user = User.find(params[:id])   # この画面専用の処理
  end
end

# config/routes.rb：全リクエストはまずこのルーターが受け、振り分ける
Rails.application.routes.draw do
  resources :users   # /users/:id → 該当アクションへディスパッチ
end

# 共通処理（認証・ログ）は1か所に集約してから各処理へ流す
class ApplicationController < ActionController::Base
  before_action :authenticate!   # 全リクエスト共通の入口処理
end

<!-- app/views/users/show.html.erb（HTMLが主役、穴に値を埋める） -->
<h1><%= @user.name %> さん</h1>
<p>登録日：<%= @user.created_at.to_date %></p>
<% if @user.active? %>
  <span class="badge">利用中</span>
<% end %>

# app/views/users/show.json.jbuilder（@user を1要素ずつ出力へ変換）
json.id      @user.id
json.name    @user.name
json.orders @user.orders do |order|
  json.total order.total_price   # 子要素も同じ要領で変換規則を積み上げる
end

<!-- 第2段：全画面共通の枠 app/views/layouts/application.html.erb -->
<html>
  <body>
    <header>共通ヘッダ</header>
    <%= yield %>   <!-- 第1段で組んだ各画面の中身が流し込まれる -->
  </body>
</html>
<!-- 第1段：この画面の中身だけ app/views/users/show.html.erb -->
<h1><%= @user.name %></h1>

# 「現在の状態 → 次の画面」の対応を1か所に集約
class RegistrationFlow
  STEPS = { address: :confirm, confirm: :done }   # どのステップの次はどこか
  def next_step(current) = STEPS.fetch(current)   # 遷移先の判断はここだけが知る
end
# 各アクションは「次どこ？」をこのフローに尋ねるだけ
redirect_to step_path(flow.next_step(:address))   # → confirm へ

# NG: 1項目ごとに往復が発生する
api.get_order_id(42); api.get_customer_name(42); api.get_shipping_address(42)

# Remote Facade: 1回の呼び出しで画面に必要な分をまとめて返す
class OrderFacade
  def order_summary(order_id)
    order = Order.find(order_id)
    { id: order.id,
      customer_name: order.customer.name,
      shipping_address: order.shipping_address.to_s }
  end
end

{
  "order_id": 42,
  "customer_name": "佐藤太郎",
  "total": 12800,
  "line_items": [
    { "product_name": "Tシャツ", "quantity": 2, "price": 3900 },
    { "product_name": "靴下",   "quantity": 1, "price": 5000 }
  ]
}

# articles に lock_version 列を持たせ、読み込み時の version を WHERE 条件に入れる
UPDATE articles
SET title = ?, lock_version = lock_version + 1
WHERE id = ? AND lock_version = ?
# 更新行数が0なら他人が先に更新済み → StaleObjectError
# Rails では lock_version 列があれば save! 時にこの判定が自動で走る

# SELECT ... FOR UPDATE でロックを取得し、コミットまで他者の更新を待たせる
ActiveRecord::Base.transaction do
  account = Account.lock.find(account_id)  # FOR UPDATE
  account.balance -= 1000
  account.save!
end  # commit でロック解放。他のトランザクションはここまでブロックされる

# 明細それぞれに lock_version を持たせず、親 order の lock_version を全員で共有
order = Order.find(order_id)
order.line_items.first.quantity = 3   # 子を変更
order.save!  # 判定するのは親 order のバージョンだけ。子の変更も含めて一括で守られる

# 開発者は明示的なロック処理を書かない
article = Article.find(id)
article.title = "新タイトル"
article.save!  # ← この中で lock_version の照合が自動的に走る（書き忘れようがない）

<!-- hidden フィールドやクッキー、URLパラメータに状態を埋め込む -->
<input type="hidden" name="wizard_step" value="2">
<input type="hidden" name="plan" value="pro">
# 受け取り側： step = params[:wizard_step].to_i（状態はリクエストから読む）

# クライアントは session_id だけクッキーで持つ。中身はサーバー（メモリやRedis）が保持
session[:cart] = { items: [{ product_id: 1, qty: 2 }] }

# 次のリクエストでは session_id から状態を引き当てる
cart = session[:cart]

# セッション状態を専用テーブルに保存（アプリサーバーはステートレスでいられる）
SessionState.upsert(session_id: sid, key: "wizard_step", value: "2")

# 次のリクエストはどのサーバーでも、DBから状態を読み直せる
step = SessionState.find_by(session_id: sid, key: "wizard_step").value

class WeatherGateway
  def temperature(city)
    res = Net::HTTP.get(URI("https://api.example.com/weather?city=#{city}"))
    JSON.parse(res)["temp_c"]
  end
end

# 利用側はAPIのURLやJSON構造を知らなくてよい
temp = WeatherGateway.new.temperature("Tokyo")

class UserMapper
  def to_domain(row)   # DBの行 → 業務オブジェクト
    User.new(name: "#{row['first_name']} #{row['last_name']}")
  end

  def to_row(user)     # 業務オブジェクト → DBの行
    first, last = user.name.split(" ", 2)
    { "first_name" => first, "last_name" => last }
  end
end

class DomainObject
  attr_reader :id
  def ==(other)
    other.is_a?(self.class) && id == other.id
  end
end

class Customer < DomainObject; end
class Product  < DomainObject; end   # どちらも == を継承して持つ

# 業務ロジック層に置く「契約」
module Notifier
  def notify(user, message); end
end
# インフラ層に置く「実装」（業務層はこのクラスを名指ししない）
class SendGridNotifier
  include Notifier
  def notify(user, message) = SendGrid::Client.new.send(to: user.email, body: message)
end
# 業務層は Notifier 型として受け取るだけ
class WelcomeService
  def initialize(notifier:) = @notifier = notifier
  def run(user) = @notifier.notify(user, "ようこそ")
end

class Registry
  def self.current_user      = @current_user
  def self.current_user=(u)  = @current_user = u
end

Registry.current_user = login_user
puts Registry.current_user.name   # 遠く離れた処理からでも取り出せる

class Point
  attr_reader :x, :y
  def initialize(x, y)
    @x, @y = x, y
    freeze                 # 不変にする
  end
  def ==(other)            # 値が同じなら等しい（IDでは比較しない）
    other.is_a?(Point) && x == other.x && y == other.y
  end
  def move(dx, dy)         # 自身を変えず新しい点を返す
    Point.new(x + dx, y + dy)
  end
end

Point.new(1, 2) == Point.new(1, 2)   # => true

class Money
  attr_reader :amount, :currency
  def initialize(amount, currency)
    @amount = BigDecimal(amount.to_s)
    @currency = currency
  end
  def +(other)
    raise "通貨が違います" if currency != other.currency
    Money.new(amount + other.amount, currency)
  end
end

Money.new("100.50", :JPY) + Money.new("0.50", :JPY)   # => 101 JPY
Money.new("100", :JPY)    + Money.new("1", :USD)      # => 例外

class NullCustomer
  def name      = "ゲスト"
  def premium?  = false
end

def find_customer(id)
  Customer.find_by(id: id) || NullCustomer.new
end

puts find_customer(999).name   # => "ゲスト"（nilチェック不要）

# 設定で実装クラス名を指定（コードではなく設定で決める）
config = { storage: "S3Storage" }   # テスト時は "LocalDiskStorage"

# 起動時に設定を読んで実装を差し込む
storage = Object.const_get(config[:storage]).new

storage.save("report.pdf", data)    # 利用側は同じI/Fを呼ぶだけ

# 本物と同じ I/F を持つスタブ（実際には通信しない）
class StubPaymentService
  def charge(amount)
    { status: "success", amount: amount }   # 常に成功を返す
  end
end

# テストでは本物の代わりにスタブを注入する
result = StubPaymentService.new.charge(1000)
expect(result[:status]).to eq("success")

// SQLの結果を表（行×列）としてメモリに保持する
DataTable customers = adapter.GetCustomers();

foreach (DataRow row in customers.Rows)
{
    Console.WriteLine(row["name"] + ": " + row["email"]);  // 列名で値を取り出せる
}