DTO とは何か？
DTO はデータ転送オブジェクトを表し、リモート インターフェイスで作業しているときに、呼び出し数を減らすことを思いついた設計パターンです。Martin Fowler がブログで定義するように、データ転送オブジェクトを使用する主な理由は複数のリモート通話を１つのバッチにすることです。
例えば、銀行アカウントのデータを公開する RESTful API で通信しているとしましょう。この場合、現状や最新のアカウント取引をチェックするように複数の要求を発する代わりに、銀行は DTO を返すエンドポイントを公開してすべてを要約することができます。リモート アプリケーションの操作で最も高価なもののひとつはクライアントとサーバーの間の往復時間なので、この粒度の粗いインターフェイスはパフォーマンスの改善に大きく役立ちます。
DTO および Spring Boot API
Java（と Spring Boot）で書き込まれた RESTful API で DTO を使用するもうひとつの利点はドメイン オブジェクト（別名：エンティティ）の実装詳細を非表示するときに役立ちます。エンドポイントを介してエンティティを公開することは、どのプロパティをどの操作を通して変更するかをよく注意しなければ、セキュリティ問題になります。
例として、ユーザーの詳細を公開し、２つのエンドポイントを介してユーザーの更新を承諾する Java API を想像してみましょう。最初のエンドポイントは
GETPUT“DTO は Java アプリケーション上のデータ整合性を保つのに役立ちます。”
これをツイートする
本アーティクルでは、このような状況を処理するために DTO を利用していきます。後で説明するように、この設計パターンではさらにいくつかのクラスをアプリケーションに導入しますが、そのセキュリティは改善されます。
ModelMapper の導入
DTO をマップするために面倒な/定型コードをエンティティに書き込んだり、その反対を避けるために、ModelMapper と呼ばれるライブラリを使用していきます。ModelMapper の目標はあるオブジェクト モデルを別のものにどのようにマップするかを自動的に決定して、オブジェクト マッピングを簡単にすることです。このライブラリはかなり強力で、マッピングプロセスを簡素化する非常にたくさんの構成を適用できますが、ほとんどのケースに当てはまる既定の動作を提供して構成よりも規則を優遇します。
このライブラリのユーザー マニュアルはよく書かれており、マッピング プロセスを調整する必要があるときに貴重なリソースになります。このライブラリの機能を少しご紹介するために、次のような
User// assume getters and setters class User { long id; String firstName; String lastName; String email; String password; String securitySocialNumber; boolean isAdmin; }
そして、
idfirstNameemail// assume getters and setters class UserDTO { long id; String firstName; String email; }
それから、次ように ModelMapper を呼び出します。
ModelMapper modelMapper = new ModelMapper(); // user here is a prepopulated User instance UserDTO userDTO = modelMapper.map(user, UserDTO.class);
つまり、公開したい構成を定義し、
modelMapper.map何を構築するか？
これからは、Spring Boot RESTful API のエンティティを公開する DTO を使うことに集中していきます。ModelMapper を使って、この API を DTO に、およびその反対に作成するエンティティからマップしていきます。新しいプロジェクトを一から設定することにあまり時間を費やしたくはないので、前回のアーティクルで作成した QuestionMarks プロジェクトを利用していきます。このアーティクルの全文を読む 必要はありません 。これからそのプロジェクトをサポートする GitHub レポジトリを複製し、私たちが関心があることを中心とした確固たる基盤を与えてくれる特定の Git タグ を確認していきます。
QuestionMarks の背景にある考え方は、このアプリケーションはユーザーが多岐選択式の質問に答えて実践し、知識を高めることができることです。より良い体制を提供するために、これらの質問は異なる試験にグループ化されています。例えば、ユーザーがインタビューに備えるのに役立つ JavaScript 関係の質問を保留する JavaScript インタビュー と呼ばれる試験があります。もちろん、本書では、アプリケーション全体を構築すると時間がかかり、アーティクルが大きくなりますので、構築しませんが、上記のテクノロジーのアクションをご覧いただけます。
前回のアーティクルでは、Spring Data JPA、PostgreSQL、および Liquibase を統合して永続レイヤーを管理しました。エンティティを公開する良い方法がなかったので、RESTful エンドポイントを作成しませんでした。これは本書の主な目標です。
PostgreSQL を起動する
既存のプロジェクトを複製する前に、PostgreSQL インスタンスを設定してデータベース操作や永続化をサポートする必要があります。前のアーティクルで述べたように、Docker は開発機にインストールしないでアプリケーションを起動するには素晴らしいソリューションです。
Docker をインストールする必要がありますが、それをインストールするプロセスは簡単です（MacOS はこちらのリンク、Windows はこちらのリンク、および Ubuntu はこちらのリンク）。Docker を正しくインストールすると、Docker 化した PostgreSQL のインスタンスを次のように実行できます。
docker run --name questionmarks-psql \ -p 5432:5432 \ -e POSTGRES_DB=questionmarks \ -e POSTGRES_PASSWORD=mysecretpassword \ -d postgres
Docker インスタンス内で PostgreSQL を起動したくない場合、または別の PostgreSQL インスタンスがすでにある場合は、
questionmarkspostgresmysecretpassword./src/main/resources/application.propertiesspring.datasource.url=jdbc:postgresql://localhost/questionmarks spring.datasource.username=postgres spring.datasource.password=mysecretpassword spring.datasource.driver-class-name=org.postgresql.Driver
QuestionMarks を複製する
次のステップは、QuestionMarks をサポートする GitHub レポジトリ を複製することです。本書の特定タグを確認してください。次のコマンドを発行して達成します。
git clone https://github.com/auth0-blog/questionmarks-server.git cd questionmarks-server git checkout post-2
前のアーティクルではエンドポイントを作成しなかったので、ここでアプリケーションを実行するのは良くありません。アプリケーションを実行しても害にはなりません。Liquibase はすでに作成されている５つのエンティティをサポートするテーブルの構造を作成します。しかし、エンドポイントを開発した後にそれが実行するのを待つことは同じ効果を出します。
その後、Spring Boot プロジェクトを優先 IDE（統合開発環境）にインポートする必要があります。
依存関係を追加する
QuestionMarks プロジェクトを複製し、IDE にインポートしたら、DTO の自動マッピング処理に進みます。まず行う最初のステップは
./build.gradlehibernate-java8// ... other definitions dependencies { // ... other dependencies compile('org.modelmapper:modelmapper:1.1.0') compile('org.hibernate:hibernate-java8:5.1.0.Final') }
試験エンティティをリファクタ―する
DTO を使う本当の利点を証明し、マッピング プロセスのさらに有意義な例を実行するために、
Exam./src/main/java/com/questionmarks/model/Exam.java// ... other imports import java.time.LocalDateTime; // ... annotations public class Exam { // ... other properties @NotNull private LocalDateTime createdAt; @NotNull private LocalDateTime editedAt; @NotNull private boolean published; }
最後のセクションに
hibernate-java8LocalDateTimeまた、新しいプロパティ（列として）を、アプリケーションをサポートする PostgreSQL データベースに追加する必要があります。前回のアーティクルでは、スキーマ移行を処理する Liquibase をセットアップしましたので、そのコマンドで新しいファイルを作り、新しい列を追加しなければなりません。このファイルを
v0002.sql./src/main/resources/db/changelog/changes/alter table exam add column created_at timestamp without time zone not null default now(), add column edited_at timestamp without time zone not null default now(), add column published boolean not null default false;
このアプリケーションを次回実行するとき、Liquibase はこのファイルを読み取り、これらのコマンドを実行して３つの列を追加します。SQL コマンドは既存記録の既定値でこれら列も事前設定します。そのほかに、JPA/Hibernate が列やその処理に対応するために変更する必要があるものはありません。
DTO を作成する
ユーザーに直接変更してほしくない機微なプロパティを保留する
ExamExamCreationDTOcom.questionmarks.modeldtopackage com.questionmarks.model.dto; import com.fasterxml.jackson.annotation.JsonIgnore; import lombok.Getter; import lombok.Setter; import javax.validation.constraints.NotNull; import java.time.LocalDateTime; @Getter @Setter public class ExamCreationDTO { @NotNull private String title; @NotNull private String description; @JsonIgnore private final LocalDateTime createdAt = LocalDateTime.now(); @JsonIgnore private final LocalDateTime editedAt = LocalDateTime.now(); }
新しい試験の作成に協力的なユーザーは新しい DTO で定義されている構造を含むリクエストを送信する必要があります。つまり、このユーザーは
titledescriptioncreatedAteditedAt@JsonIgnoreExampublishedこれから作成する２つめの DTO は既存の試験を更新する担当になります。この DTO を
ExamUpdateDTOcom.questionmarks.model.dtopackage com.questionmarks.model.dto; import com.fasterxml.jackson.annotation.JsonIgnore; import lombok.Getter; import lombok.Setter; import javax.persistence.Id; import javax.validation.constraints.NotNull; import java.time.LocalDateTime; @Getter @Setter public class ExamUpdateDTO { @Id @NotNull private Long id; @NotNull private String title; @NotNull private String description; @JsonIgnore private final LocalDateTime editedAt = LocalDateTime.now(); }
他の DTO との違いは、これは更新する
idcreatedAtDTO の視点から、これは大体、試験を安全に作成し、更新するために必要なことです。これから、これらマッピングを手動で操作しなくてもいいように、DTO をエンティティへマッピングするプロセスの合理化に集中していきます。
ちょっとお待ちください！次の作業に進む前に、ModelMapper が実際に DTO を
Exam./src/test/java/com/questionmarks/com.questionmarksmodelExamUTpackage com.questionmarks.model; import com.questionmarks.model.dto.ExamCreationDTO; import com.questionmarks.model.dto.ExamUpdateDTO; import org.junit.Test; import org.modelmapper.ModelMapper; import static org.junit.Assert.assertEquals; public class ExamUT { private static final ModelMapper modelMapper = new ModelMapper(); @Test public void checkExamMapping() { ExamCreationDTO creation = new ExamCreationDTO(); creation.setTitle("Testing title"); creation.setDescription("Testing description"); Exam exam = modelMapper.map(creation, Exam.class); assertEquals(creation.getTitle(), exam.getTitle()); assertEquals(creation.getDescription(), exam.getDescription()); assertEquals(creation.getCreatedAt(), exam.getCreatedAt()); assertEquals(creation.getEditedAt(), exam.getEditedAt()); ExamUpdateDTO update = new ExamUpdateDTO(); update.setTitle("New title"); update.setDescription("New description"); modelMapper.map(update, exam); assertEquals(update.getTitle(), exam.getTitle()); assertEquals(update.getDescription(), exam.getDescription()); assertEquals(creation.getCreatedAt(), exam.getCreatedAt()); assertEquals(update.getEditedAt(), exam.getEditedAt()); } }
このクラスで唯一定義された
@TesttitledescriptionExamCreationDTOExamModelMapperExamExamCreationDTOtitledescriptioncreatedAteditedAt最後に、
ExamUpdateDTOtitledescriptioneditedAtcreatedAtExamgradle testDTO をエンティティへ自動的にマッピングする
ModelMapper ライブラリには Spring のために特別に設計された拡張がありますが、これから実行することには役立たないので使用しません。これから DTO を処理する RESTful API を構築していき、これら DTO をできるだけ自動的にエンティティへ変換したいので、この魔法をするために独自のセットの汎用クラスを作成します。
用心深い読者は
ExamUpdateDTOid@Id@Ids@IdExamこれから作成する最初のアーティファクトは DTO をエンティティへ自動的にマッピングする注釈です。
com.questionmarksutilDTOpackage com.questionmarks.util; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) public @interface DTO { Class value(); }
このインターフェイスは
@interface@Retention (RetentionPolicy.RUNTIME)@Target (ElementType.PARAMETER)value次に作成する要素はその作業を担当するクラスです。このクラスは DTO の一部の構造に適合するユーザーによるリクエストを取得し、特定のエンティティ上の DTO を変換します。このクラスは送信した DTO が
@IdDTOModelMappercom.questionmarks.utilpackage com.questionmarks.util; import com.fasterxml.jackson.databind.ObjectMapper; import org.modelmapper.ModelMapper; import org.springframework.core.MethodParameter; import org.springframework.core.annotation.AnnotationUtils; import org.springframework.http.HttpInputMessage; import org.springframework.http.converter.HttpMessageNotReadableException; import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter; import org.springframework.web.HttpMediaTypeNotSupportedException; import org.springframework.web.bind.WebDataBinder; import org.springframework.web.bind.support.WebDataBinderFactory; import org.springframework.web.context.request.NativeWebRequest; import org.springframework.web.method.support.ModelAndViewContainer; import org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor; import javax.persistence.EntityManager; import javax.persistence.Id; import javax.validation.constraints.NotNull; import java.io.IOException; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.Type; import java.util.Collections; public class DTOModelMapper extends RequestResponseBodyMethodProcessor { private static final ModelMapper modelMapper = new ModelMapper(); private EntityManager entityManager; public DTOModelMapper(ObjectMapper objectMapper, EntityManager entityManager) { super(Collections.singletonList(new MappingJackson2HttpMessageConverter(objectMapper))); this.entityManager = entityManager; } @Override public boolean supportsParameter(MethodParameter parameter) { return parameter.hasParameterAnnotation(DTO.class); } @Override protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) { binder.validate(); } @Override public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception { Object dto = super.resolveArgument(parameter, mavContainer, webRequest, binderFactory); Object id = getEntityId(dto); if (id == null) { return modelMapper.map(dto, parameter.getParameterType()); } else { Object persistedObject = entityManager.find(parameter.getParameterType(), id); modelMapper.map(dto, persistedObject); return persistedObject; } } @Override protected Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException { for (Annotation ann : parameter.getParameterAnnotations()) { DTO dtoType = AnnotationUtils.getAnnotation(ann, DTO.class); if (dtoType != null) { return super.readWithMessageConverters(inputMessage, parameter, dtoType.value()); } } throw new RuntimeException(); } private Object getEntityId(@NotNull Object dto) { for (Field field : dto.getClass().getDeclaredFields()) { if (field.getAnnotation(Id.class) != null) { try { field.setAccessible(true); return field.get(dto); } catch (IllegalAccessException e) { throw new RuntimeException(e); } } } return null; } }
これは、ここまで生成したクラスの中で最も複雑ですから、良くご理解いただくために細かく説明していきましょう。
- このクラスは
に拡張します。リクエストをクラスに変換するプロセス全体を書かなくてもいいように、このプロセッサを利用します。Spring MVC に慣れている方のために、拡張されたクラスはRequestResponseBodyMethodProcessor
parameters を処理し事前設定するものです。これは、例えば JSON 本文などを取り、クラスのインスタンスで変換することを意味します。今回は、基本クラスを調整して、代わりに DTO のインスタンスを事前設定します。@RequestBody - このクラスは
のスタティック インスタンスを含みます。このインスタンスは DTO をエンティティへマップするために使用されます。ModelMapper - このクラスは
のインスタンスを含みます。DTO を介してパスしたEntityManager
を基に、既存エンティティのデータベースをクエリできるように、このクラスにエンティティ マネージャを挿入します。id
メソッドを上書きします。このメソッドを上書きせずに、新しいクラスは丁度、基本クラスのようにsupportsParameter
パラメータに適用されます。ですから@RequestBody
注釈のみに適用されるように調整する必要があります。@DTO
を上書きします。基本クラスはパラメータにvalidateIfApplicable
または@Valid
のマークが付いている場合のみ Bean Validation を実行します。この動作を変更してすべての DTO に bean validation を適用します。@Validated
を上書きします。これはこの実装で最も重要なメソッドです。このプロセスでそれを調整してresolveArgument
インスタンスを埋め込み、DTO をエンティティへマップします。しかし、マッピングする前に、新しいエンティティを処理するか、または既存エンティティへ DTO によって提案された変更を適用しなければならないかをチェックします。ModelMapper
メソッドを上書きします。基本クラスはこのパラメターのタイプを取り、このリクエストをそれのインスタンスに変換します。このメソッドを上書きしてこの変換がreadWithMessageConverters
注釈で定義されたタイプにし、DTO からエンティティへのマッピングをDTO
メソッドに残します。resolveArgument
メソッドを定義します。このメソッドは事前設定される DTO のフィールドで反復し、getEntityId
のマークが付いているものをチェックします。それが見つかれば、フィールドの値が返され、@Id
はそれと共にデータベースをクエリできるようになります。resolveArgument
サイズは大きいですが、このクラスの実装を理解するのは難しくありません。要約すると、これは DTO のインスタンスを事前設定し、
@DTO@Idこの Spring Boot アプリケーションで
DTOModelMapperWebMvcConfigurerAdaptercom.questionmarksWebMvcConfigpackage com.questionmarks; import com.fasterxml.jackson.databind.ObjectMapper; import com.questionmarks.util.DTOModelMapper; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.Configuration; import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder; import org.springframework.web.method.support.HandlerMethodArgumentResolver; import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter; import javax.persistence.EntityManager; import java.util.List; @Configuration public class WebMvcConfig extends WebMvcConfigurerAdapter { private final ApplicationContext applicationContext; private final EntityManager entityManager; @Autowired public WebMvcConfig(ApplicationContext applicationContext, EntityManager entityManager) { this.applicationContext = applicationContext; this.entityManager = entityManager; } @Override public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) { super.addArgumentResolvers(argumentResolvers); ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().applicationContext(this.applicationContext).build(); argumentResolvers.add(new DTOModelMapper(objectMapper, entityManager)); } }
WebMvcConfigApplicationContextEntityManagerDTOModelMapperApplicationContextObjectMapperDTOModelMapperRequestResponseBodyMethodProcessor“DTO をエンティティへ自動的に Spring Boot 上にマッピングする”
これをツイートする
このプロジェクトの
WebMvcConfig@DTOExamRepositorycom.questionmarks.persistencepackage com.questionmarks.persistence; import com.questionmarks.model.Exam; import org.springframework.data.jpa.repository.JpaRepository; public interface ExamRepository extends JpaRepository<Exam, Long> { }
JpaRepositorysave (Exam exam)findAll ()delete (Exam exam)com.questionmarks.controllerExamRestControllerpackage com.questionmarks.controller; import com.questionmarks.model.Exam; import com.questionmarks.model.dto.ExamCreationDTO; import com.questionmarks.model.dto.ExamUpdateDTO; import com.questionmarks.persistence.ExamRepository; import com.questionmarks.util.DTO; import org.springframework.http.HttpStatus; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PutMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseStatus; import org.springframework.web.bind.annotation.RestController; import java.util.List; @RestController @RequestMapping("/exams") public class ExamRestController { private ExamRepository examRepository; public ExamRestController(ExamRepository examRepository) { this.examRepository = examRepository; } @GetMapping public List<Exam> getExams() { return examRepository.findAll(); } @PostMapping public void newExam(@DTO(ExamCreationDTO.class) Exam exam) { examRepository.save(exam); } @PutMapping @ResponseStatus(HttpStatus.OK) public void editExam(@DTO(ExamUpdateDTO.class) Exam exam) { examRepository.save(exam); } }
このクラスの実装はとても簡単でした。各エンドポイントに１つのメソッドで３つのメソッドを作り、コンストラクターを介して
ExamRepositorygetExamsGETnewExamExamCreationDTOPOSTDTOModelMapperExameditExamPUTExamUpdateDTOExamこの最後のメソッドが永続化
ExamidtitledescriptioneditedAtExamUpdateDTOIDE を介してまたは
gradle bootRuncurl# retrieves all exams curl http://localhost:8080/exams # adds a new exam curl -X POST -H "Content-Type: application/json" -d '{ "title": "JavaScript", "description": "JS developers." }' http://localhost:8080/exams # adds another exam while ignoring fields not included in the DTO curl -X POST -H "Content-Type: application/json" -d '{ "title": "Python Interview Questions", "description": "An exam focused on helping Python developers.", "published": true }' http://localhost:8080/exams # updates the first exam changing its title and description curl -X PUT -H "Content-Type: application/json" -d '{ "id": 1, "title": "JavaScript Interview Questions", "description": "An exam focused on helping JS developers." }' http://localhost:8080/exams
Aside: Securing Spring APIs with Auth0
Securing Spring Boot APIs with Auth0 is easy and brings a lot of great features to the table. With Auth0, we only have to write a few lines of code to get solid identity management solution, single sign-on, support for social identity providers (like Facebook, GitHub, Twitter, etc.), and support for enterprise identity providers (like Active Directory, LDAP, SAML, custom, etc.).
In the following sections, we are going to learn how to use Auth0 to secure APIs written with Spring Boot.
Creating the API
First, we need to create an API on our free Auth0 account. To do that, we have to go to the APIs section of the management dashboard and click on "Create API". On the dialog that appears, we can name our API as "Contacts API" (the name isn't really important) and identify it as
https://contacts.blog-samples.comRegistering the Auth0 Dependency
The second step is to import a dependency called
. This can be done on a Maven project by including the following configuration to auth0-spring-security-api
pom.xml<project ...> <!-- everything else ... --> <dependencies> <!-- other dependencies ... --> <dependency> <groupId>com.auth0</groupId> <artifactId>auth0-spring-security-api</artifactId> <version>1.0.0-rc.3</version> </dependency> </dependencies> </project>
Integrating Auth0 with Spring Security
The third step consists of extending the WebSecurityConfigurerAdapter class. In this extension, we use
JwtWebSecurityConfigurerpackage com.auth0.samples.secure; import com.auth0.spring.security.api.JwtWebSecurityConfigurer; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; @Configuration @EnableWebSecurity @EnableGlobalMethodSecurity(prePostEnabled = true) public class SecurityConfig extends WebSecurityConfigurerAdapter { @Value(value = "${auth0.apiAudience}") private String apiAudience; @Value(value = "${auth0.issuer}") private String issuer; @Override protected void configure(HttpSecurity http) throws Exception { JwtWebSecurityConfigurer .forRS256(apiAudience, issuer) .configure(http) .cors().and().csrf().disable().authorizeRequests() .anyRequest().permitAll(); } }
As we don't want to hard code credentials in the code, we make
SecurityConfig
: This is the value that we set as the identifier of the API that we created at Auth0 (auth0.apiAudience
).https://contacts.blog-samples.com
: This is our domain at Auth0, including the HTTP protocol. For example:auth0.issuer
.https://blog-samples.auth0.com/
Let's set them in a properties file on our Spring application (e.g.
application.propertiesauth0.issuer:https://blog-samples.auth0.com/ auth0.apiAudience:https://contacts.blog-samples.com/
Securing Endpoints with Auth0
After integrating Auth0 and Spring Security, we can easily secure our endpoints with Spring Security annotations:
package com.auth0.samples.secure; import com.google.common.collect.Lists; import org.springframework.security.access.prepost.PreAuthorize; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.List; @RestController @RequestMapping(value = "/contacts/") public class ContactController { private static final List<Contact> contacts = Lists.newArrayList( Contact.builder().name("Bruno Krebs").phone("+5551987654321").build(), Contact.builder().name("John Doe").phone("+5551888884444").build() ); @GetMapping public List<Contact> getContacts() { return contacts; } @PostMapping public void addContact(@RequestBody Contact contact) { contacts.add(contact); } }
Now, to be able to interact with our endpoints, we will have to obtain an access token from Auth0. There are multiple ways to do this and the strategy that we will use depends on the type of the client application we are developing. For example, if we are developing a Single Page Application (SPA), we will use what is called the Implicit Grant. If we are developing a mobile application, we will use the Authorization Code Grant Flow with PKCE. There are other flows available at Auth0. However, for a simple test like this one, we can use our Auth0 dashboard to get one.
Therefore, we can head back to the APIs section in our Auth0 dashboard, click on the API we created before, and then click on the Test section of this API. There, we will find a button called Copy Token. Let's click on this button to copy an access token to our clipboard.
After copying this token, we can open a terminal and issue the following commands:
# create a variable with our token ACCESS_TOKEN=<OUR_ACCESS_TOKEN> # use this variable to fetch contacts curl -H 'Authorization: Bearer '$ACCESS_TOKEN http://localhost:8080/contacts/
Note: We will have to replace
with the token we copied from our dashboard.<OUR_ACCESS_TOKEN>
As we are now using our access token on the requests we are sending to our API, we will manage to get the list of contacts again.
That's how we secure our Node.js backend API. Easy, right?
次のステップ：例外処理および I18N
@DTODTOModelMapper私たちは API を購入する誰もにできるだけ素晴らしい経験を提供したいと願っています。これにはよくフォーマットされたエラー メッセージを与えることも含まれます。それ以上に、私たちは英語以外の他の言語を話すユーザーとコミュニケーションができるようにしたいと思います。よって、次回のアーティクルでは、Spring Boot API で例外の処理や I18N（国際化）に取り組んでいきます。お見逃しなく！
About the author
Bruno Krebs
R&D Content Architect