如何使用Phoenix框架呈现JSON文件？

Question

Instead of fetching data from a database, I want to use as data a manually written JSON file. Suppose my data is this:

[
    { "id": 1, "name": "Alice", "email": "alice@example.com" },
    { "id": 2, "name": "Bob", "email": "bob@example" },
    { "id": 3, "name": "Charles", "email": "charles@example.com"}
]

and it's written in a file called MOCK_DATA.json . What should I do to render this file when I access the localhost:port/api/v1/users url? How about the localhost:port/api/v1/users/1 url to show { "id": 1, "name": "Alice", "email": "alice@example.com" } ?

Answer 1

Here is a basic working example...

Step 1: Create the phoenix app

eg, exjson for ExampleJson or whatever name your like

  scope "/api/v1", Exjson do
    pipe_through :api
    resources "/users", UserController
  end

Step 2: Set up the router

Add this scope to the web/router.ex file

  scope "/api/v1", Exjson do pipe_through :api resources "/users", UserController end 

Step 3: Put the mock data somewhere accessible to the app

 priv/data/MOCK_DATA.json 

Step 4: Set up the UsersController

Think of the Users Controller as having a number of actions (functions) where the conn struct is fed into from your phoenix endpoint along with any parameters

 defmodule Exjson.UserController do use Exjson.Web, :controller # GET http://localhost:4000/api/v1/users/ def index(conn, _params) do users = File.read!(file) |> Poison.decode!() render conn, users: users end # GET http://localhost:4000/api/v1/users/1 def show(conn, params) do users = File.read!(file) |> Poison.decode!() render conn, user: users |> Enum.find(&(&1["id"] === String.to_integer(params["id"]))) end defp file() do Path.join(:code.priv_dir(:exjson), "data/MOCK_DATA.json") end end 

Step 5: Set up the UsersView

You can also think of the Users View as having functions that will render the data received from the Controller in the appropriate way. In this case, you are using json data so phoenix has some built in functions to help with that.

 defmodule Exjson.UserView do use Exjson.Web, :view def render("index.json", %{users: users}) do render_many(users, __MODULE__, "user.json") end def render("show.json", %{user: user}) do render_one(user, __MODULE__, "user.json") end def render("user.json", %{user: user}) do %{ id: user["id"], name: user["name"], email: user["email"] } end end 

Answer 2

To give you some real code to get started, this is the simplest thing I can think of:

defmodule MyApp.UserController do
  @mock_data (
    Application.app_dir(:my_app, "priv/mock_data/users.json")
    |> File.read!
    |> Poison.decode!
  )

  def index(conn, _params) do
    conn
    |> put_status(:ok)
    |> json(@mock_data)
  end
end

Then just save your fake data in priv/mock_data/users.json inside your project. There might be typos in there, but you get the basic idea...

Answer 3

Since you're just echoing the JSON back for the /users endpoint, in that case you don't need the Poison.decode/1 call which does unnecessary decoding/encoding of the JSON.

So, adapting Patrick's code:

defmodule MyApp.UserController do
  @mock_data_string (
    Application.app_dir(:my_app, "priv/mock_data/users.json")
    |> File.read!
  )

  def index(conn, _params) do
    conn
    |> put_resp_content_type("application/json")
    |> send_resp(200, @mock_data_string)
  end
end

However, for the /users/1 endpoint, it is best to extract values by using Poison.decode/1 , as @stephen_m's answer illustrates.

Answer 4

If the file is static (does not change for the course of the service running) then you can read it when the app compiles in your controller. Look into module parameters (the ones you define in your module, outside of functions). This way i'll be parsed once.

If this file is dynamic then you may need to read it every time the API is called and parse it. Not really advised since reading a file from disk IO will slow it down.

In any case the result of the file, parsed to a Map can then be passed in into the view and rendered, no difference from the database.

Edit: another suggestion is to reformat your JSON (if possible) and have id as a key and the rest of the data as a value. This way lookups by id will be very fast, just like a primary key index in the database.