[RUBY] Erstellen Sie mit Grape einen RESTful-API-Service

Überblick

Ich habe einen RESTful-API-Service mit Trauben erstellt, daher werde ich ihn zusammenfassen. Nach dem Erstellen habe ich Postman verwendet, um das Verhalten zu überprüfen.

Umgebung

ruby 2.6.5

Rails 5.2.4

Was du getan hast

• Erstellen Sie einen beliebigen Benutzer in der Seeds-Datei. Edelstein verwendet Trauben. Im API-Modus erstellen.

• Zugriff vom Client über Postman zum Registrieren, Aktualisieren und Löschen von Daten. Daten bekommen -Die Anwendung wurde erstellt, damit allgemeine CRUD-Funktionen und Datenerfassung mit JSON erfasst werden können.

Erstellen Sie zuerst eine Anwendung

console

$ rails new sample_app

Diesmal war der App-Name "sample_app".

Installieren Sie zuerst den Edelstein

Fügen Sie Folgendes hinzu

Gemfile

gem ‘grape’　#Erstellen Sie problemlos RESTful-APIs mit Rack-Anwendungen wie Rails und Sinatra
gem 'grape-entity’ #Wenn nur Trauben verwendet werden, werden alle Werte angezeigt. Traube-Sie können die Entität verwenden, um Anzeigeelemente einzuschränken und zu formatieren.
gem ‘grape_on_rails_routes’  #Es erleichtert das Lesen und Schreiben von Routen, die mit der Grape-API erstellt wurden.

Dann Bündel installieren.

$ bundle install --path vendor/bundle

DB-Konfiguration

Generieren Sie ein Benutzermodell

console

$ bundle exec rails g model User name:string email:string age:integer
$ rails db:migrate

Bereiten Sie die Daten für die Probe vor.

Erstellen Sie db / seeds.rb mit dem folgenden Inhalt.

db/seeds.rb

User.create(name: 'Sony', email: '[email protected]', age: '40')
User.create(name: 'Fredo', email: '[email protected]', age: '38')
User.create(name: 'Tom', email: '[email protected]', age: '35')
User.create(name: 'Michael', email: '[email protected]', age: '33')
User.create(name: 'Connie', email: '[email protected]', age: '30')

Lassen Sie die DB die Datei lesen.

$ bundle exec rake db:seed

Verzeichnisaufbau

Machen Sie die folgende Verzeichnisstruktur.

~/sample_api/
　　├ app/api/
　　│　　　　└ api.rb
　　│　　　　└ resources/
　　│          └ v1/
　　│            └ root.rb
　　│　　　　　　  └ user.rb
　　│       └ entities/
　　│　　　　　　└ v1/
　　│　　　　　　　 └ root_entity.rb
　　│　　　　　　　 └ user_entity.rb

Einstellungen für das automatische Laden

Stellen Sie sicher, dass die Dateien unter App / API automatisch geladen werden.

config/application.rb

module SampleApi
  class Application < Rails::Application
    #..  
    # app/Autoload der rb-Datei unter API
   + config.paths.add File.join('app', 'api'), glob: File.join('**', '*.rb')
   + config.autoload_paths += Dir[Rails.root.join('app', 'api', '*')]
  end
end

API erstellen

Montieren Sie in der Beziehung [Eltern-Kind-Enkel-Urenkel], wie in der folgenden Abbildung gezeigt.

config/routes.rb  # [Elternteil]Routing-Einstellungen
  └ app/api/api.rb # [Kind]Übergeordnete API-Klasse
      └ app/api/resources/v1/root.rb # [Enkel]Übergeordnete API v1-Klasse
          └ app/api/resources/v1/users.rb # [Urenkel]userAPI-Klasse

[Übergeordnet] config / route.rb

Stellen Sie das Routing ein.

config/routes.rb

Rails.application.routes.draw do
# app/api/api.Mount rb
+ mount API => ‘/'　#Bei dieser Methode zeigt die Basisklasse auf jede Aktion in der Klasse, sodass Sie nicht jeder Aktion eine Route hinzufügen müssen.
end

[Kind] app / api / api.rb.

Erstellen Sie eine übergeordnete API-Klasse.

app/api/api.rb

class API < Grape::API
  #Erster Segmentname der URL ex) http://localhost/api/
  prefix 'api'
  # app/api/resources/v1/root.Mount rb
  mount Resources::V1::Root
end

[Enkel] app / api / resources / v1 / root.rb.

Erstellen Sie eine übergeordnete Klasse für API v1.

app/api/resources/v1/root.rb

module Resources
  module V1
    class Root < Grape::API
      version 'v1'
      format :json
      content_type :json, 'application/json'

      # app/api/resources/v1/users.Mount rb
      mount Resources::V1::Users
    end
  end
end

​ Erstellen Sie als Nächstes eine Entitätsdatei, bevor Sie die userAPI-Klasse erstellen. Wenn Sie dies nicht erstellen, werden Daten, die Sie nicht anzeigen möchten, wie Erstellungszeit und Aktualisierungszeit, angezeigt, wenn Daten erfasst werden.

• Wenn Sie alle Daten abrufen möchten, müssen Sie sie nicht erstellen.

Erstellen Sie eine übergeordnete Klasse für die Entität

app/api/entities/v1/root_entity.rb

module Entities
  module V1
    class RootEntity < Grape::Entity

    end
  end
end

Erstellen Sie eine Entitätsdatei für userAPI

Nur Anzeigename, E-Mail-Adresse und Alter.

(Created_at und aktualisierte_at werden nicht angezeigt)

app/api/entities/v1/user_entity.rb

module Entities
  module V1
    class UserEntity < RootEntity
      # name, email,Zeige nur das Alter
      expose :name, :email, :age
    end
  end
end

Erstellen Sie eine Klasse für userAPI.

app/api/resources/v1/user.rb

module Resources
  module V1
    class Users < Grape::API
      resource :users do
        desc "user list"
        get do
          present User.all, with: Entities::V1::UserEntity 　#　with:Wenden Sie den Inhalt der Entitätsdatei an, indem Sie ~ ~ festlegen
        end

        desc "create new user"
        params do
          requires :name, type: String
          requires :email, type: String
          requires :age, type: Integer
        end
        post do
          User.create!({ name: params[:name], email: params[:email], age: params[:age] })
        end

        desc "Update user"
        route_param :id do 
          put do
            User.find(params[:id]).update({ name: params[:name], email: params[:email], age: params[:age] })
          end
        end

        desc "show user"
        params do
          requires :id, type: Integer, desc: "user id"
        end
        get ":id" do
          present User.find(params[:id]), with: Entities::V1::UserEntity　#Gleiches gilt für diese Datenerfassung.
        end

        desc "Delete user"
        route_param :id do
           delete do
             user = User.find(params[:id])
             user.destroy
           end
        end
      end
    end
  end
end

$ rails grape:routes or rake grape:routes
        GET  |  /api/:version/users(.:format)      |  v1  |  user list      
       POST  |  /api/:version/users(.:format)      |  v1  |  create new user
        PUT  |  /api/:version/users/:id(.:format)  |  v1  |  Update user    
        GET  |  /api/:version/users/:id(.:format)  |  v1  |  user_show      
     DELETE  |  /api/:version/users/:id(.:format)  |  v1  |  Delete user

Sie können die Liste der Trauben-API-Routen anzeigen, indem Sie den obigen Befehl ausführen.

Sie haben die API bisher erstellt. Von hier aus prüfen wir, ob die CRUD-Funktion und die Datenerfassung mit Postman korrekt ausgeführt werden können.

• Holen Sie sich alle Benutzerinformationen
  • http://localhost:3000/api/v1/users
• 1 Benutzerinformation der angegebenen ID abrufen
  • http://localhost:3000/api/v1/users/{:id}

Sie können die Erfassung bestätigen, indem Sie nach dem Starten der Schienen den obigen URI eingeben.

Überprüfen von Anfragen und Antworten mit Postman

Postboten-URL https://www.postman.com/

Starten Sie Postman Die Registrierung ist einfach, wenn Sie den Anweisungen folgen.

Starten Sie den lokalen Server

$ rails s

Daten erstellen

Legen Sie die zu registrierenden Daten im JSON-Format fest und führen Sie sie aus

Methode: Post

URL：http://localhost:3000/api/v1/users

Body: raw JSON(application/json)

Body

{
  “name”:"Stichprobe"
  “email”: “[email protected]”
  “age”: 19
}

Ändern Sie die Postman-Einstellungen wie oben beschrieben und drücken Sie die Senden-Taste

Sie können sehen, dass ein neuer Benutzer mit der 6. ID in der folgenden Spalte registriert ist.

Daten bearbeiten (Update)

Aktualisieren Sie die registrierten Informationen. Legen Sie die zu ändernden Informationen im Body-Element fest.

Methode: Put

URL：http://localhost:3000/api/v1/users/:id (: id ist der in db registrierte id-Wert, hier auf 6 gesetzt)

Body:raw JSON(application/json)

Body

{
  “name”:"Stichprobe"
  “email”: “[email protected]”
  “age”: 20
}

Das Update wird durchgeführt.

Daten löschen (zerstören)

Löschen Sie die registrierten Informationen

Methode: Löschen

URL：http://localhost:3000/api/v1/users/:id

(: id ist der in db registrierte id-Wert, hier auf 6 gesetzt)

Es ist mir gelungen, die zuvor erstellten Daten zu löschen.

Daten abrufen (Index)

Holen Sie sich alle registrierten Informationen. Versuchen Sie, 5 Daten als Seeds-Daten zu registrieren.

Methode: Get

URL：http://localhost:3000/api/v1/users

Sie können die unten registrierten Daten überprüfen.

Daten per ID abrufen (anzeigen)

Geben Sie die ID aus den registrierten Informationen an und erfassen Sie nur bestimmte Informationen (die Dateninformationen von ID: 6 vor dem Löschen werden erfasst).

Methode: Get

URL：http://localhost:3000/api/v1/users/:id

Wir konnten das Verhalten der CRUD-Funktion bestätigen. Ich habe nicht genug über die Funktionen von Postman gelernt, deshalb werde ich es vertiefen.

Da es für Traubensteine immer noch verschiedene Funktionen gibt, werden wir sie kennenlernen, damit wir sie beherrschen können.

• Referenz: Memo zur Verwendung von Postman, einem praktischen Tool für die API-Entwicklung und -Tests https://qiita.com/zaburo/items/16ac4189d0d1c35e26d1

• Referenz: Überprüfen Sie die API mit Postman https://qiita.com/me-654393/items/b14824dd9b37de0da163

• Referenz: RESTFUL API MIT GRAPE IN RAILS https://www.nascenia.com/restful-api-using-grape-in-rails/

• Referenz: Traubengithub https://github.com/ruby-grape/grape