Elixir在后端业务逻辑中的实践策略,解析进程隔离、模式匹配、监督树等核心技术

defmodule PaymentProcessor do
  use GenServer

  # 支付处理主逻辑
  def handle_call({:process, order}, _from, state) do
    case validate_payment(order) do
      {:ok, _} -> 
        spawn(fn -> send_confirmation_email(order) end)  # 隔离邮件发送
        {:reply, :success, state}
      {:error, reason} -> 
        {:reply, {:error, reason}, state}
    end
  end

  # 独立监督的邮件服务进程
  def start_email_worker do
    DynamicSupervisor.start_child(:email_supervisor, {EmailWorker, []})
  end
end

defmodule OrderValidator do
  # 多子句函数处理不同订单状态
  def validate(%{status: :paid} = order), do: {:ok, order}
  def validate(%{status: :pending, items: items}) when length(items) > 10 do
    {:error, :exceed_max_items}
  end
  def validate(order) do
    with true <- valid_user?(order.user_id),
         true <- valid_address?(order.shipping_address) do
      {:ok, order}
    else
      false -> {:error, :invalid_parameters}
    end
  end
end

defmodule OrderSupervisor do
  use Supervisor

  def start_link(init_arg) do
    Supervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
  end

  def init(_init_arg) do
    children = [
      {DynamicSupervisor, strategy: :one_for_one, name: :payment_supervisor},
      {Registry, keys: :unique, name: :order_registry},
      worker(OrderCache, [])
    ]

    Supervisor.init(children, strategy: :one_for_all)
  end
end

defmodule ProductCache do
  use GenServer

  def init(_) do
    :ets.new(:product_cache, [:set, :protected, :named_table])
    load_initial_data()
    {:ok, %{}}
  end

  def handle_call({:get, product_id}, _from, state) do
    case :ets.lookup(:product_cache, product_id) do
      [{^product_id, data}] -> {:reply, data, state}
      [] -> {:reply, fetch_from_db(product_id), state}
    end
  end

  defp load_initial_data do
    products = Database.get_all_products()
    Enum.each(products, fn p -> 
      :ets.insert(:product_cache, {p.id, p})
    end)
  end
end

defmodule OrderPipeline do
  def process_order(raw_data) do
    raw_data
    |> parse_json()
    |> validate_params()
    |> calculate_discount()
    |> apply_coupons()
    |> persist_order()
    |> broadcast_event()
  rescue
    error -> 
      ErrorLogger.log(error)
      {:error, :processing_failed}
  end
end

defmodule LiveUpgrade do
  def upgrade(module) do
    {:ok, {_, beam}} = :compile.file(module, [:debug_info])
    {:module, _} = :code.load_binary(module, '', beam)
  end

  def downgrade(module, version) do
    Code.ensure_loaded?(module)
    :code.purge(module)
    :code.delete(module)
    load_previous_version(module, version)
  end
end