| nom de l'article | Moule | La description |
|---|---|---|
| id | int | ID unique au tweet |
| name | String | Le nom de la personne qui a tweeté |
| message | String | Contenu du Tweet |
| url | Méthode HTTP | La description |
|---|---|---|
| /tweet | POST | Enregistrez le tweet |
| /tweet | GET | Recevoir tous les tweets |
| /tweet/{id} | PUT | Mettez à jour le tweet avec l'ID spécifié |
| /tweet/{id} | DELETE | Supprimer le tweet avec l'ID spécifié |
--Cette fois, nous allons créer le code avec la structure de package suivante
src/main/java/com/example/api
.
├── ApiApplication.java
├── model
│ └── Tweet.java
├── repository
│ └── TweetRepository.java
├── service
│ └── TweetService.java
└── controller
└── TweetController.java
--model: Représente une entité (les données à traiter)
--repository: accès à la base de données
--service: exécuter la logique métier
--controller: traiter la demande / réponse du client
--Ajouter une bibliothèque pour faciliter l'échange de données avec la base de données --Ajoutez ce qui suit aux dépendances de build.gradle
org.springframework.boot:spring-boot-starter-data-jpamysql:mysql-connector-javaorg.projectlombok:lombokbuild.gradle
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation 'mysql:mysql-connector-java'
compileOnly 'org.projectlombok:lombok:1.18.8'
annotationProcessor 'org.projectlombok:lombok:1.18.8'
--Créez ʻapplication.properties ou ʻapplication.yml sous src / main / resources et entrez les informations de la base de données à laquelle se connecter.
application.yml
spring:
datasource:
sqlScriptEncoding: UTF-8
driverClassName: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/testdb?useSSL=false&requireSSL=false
username: root
password: hoge
#Évitez d'initialiser la base de données au démarrage de l'application
jpa:
hibernate:
ddl-auto: update
#Résolution du problème selon lequel une table ne peut pas être créée dans le DB au démarrage de Spring Boot
properties:
hibernate:
dialect: org.hibernate.dialect.MySQL57Dialect
logging:
level:
sql: debug
spring.jpa.properties.hibernate.dialect est inclus car la table n'a pas pu être créée au démarrage de l'application et l'erreur suivante s'est produite. Résolu en se référant à iciorg.hibernate.tool.schema.spi.CommandAcceptanceException: Error executing DDL "create table tweet (tweet varchar(255) not null, primary key (tweet)) engine=MyISAM" via JDBC Statement
...(Omis)...
Caused by: java.sql.SQLSyntaxErrorException: Specified key was too long; max key length is 1000 bytes
...(Omis)...
Create / Read
--Créez une classe qui représente le tweet lui-même sous le package model
Tweet.java
package com.example.api.model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
@Table(name = "tweet")
public class Tweet {
@Id
@GeneratedValue
private int id;
@Column(nullable = false)
private String name;
@Column(nullable = false)
private String message;
}
-- @ Entity: indique que l'entité est une entité JPA (un objet enregistré dans la base de données).
-- @Data / @NoArgsConstructor / @ AllArgsConstructor: Annotation de lombok. Créez automatiquement un getter, un setter, un constructeur, etc.
--@ Table (name = "tweet"): Spécifiez le nom de la table correspondant à l'entité
-- @ Id: Annotation indiquant qu'il s'agit de la clé primaire de l'entité
-- @ GeneratedValue: Avec cela, DB numérotera automatiquement.
--@ Column (nullable = false): Une annotation donnée à une colonne DB. Vous pouvez définir si vous souhaitez autoriser null avec l'option nullable
--Créez une classe de référentiel sous le package repository
TweetRepository.java
package com.example.api.repository;
import com.example.api.model.Tweet;
import org.springframework.data.jpa.repository.JpaRepository;
public interface TweetRepository extends JpaRepository<Tweet, Integer> {}
--Créez une classe de service sous le package service
@ Autowired à tweetRepository, l'instance est transmise depuis le conteneur DI et la méthode peut être appelée sans nouveau.TweetService.java
package com.example.api.service;
import com.example.api.model.Tweet;
import com.example.api.repository.TweetRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
@Transactional
public class TweetService {
@Autowired
TweetRepository tweetRepository;
public Tweet postTweet(Tweet tweet) {
return tweetRepository.save(tweet);
}
public List<Tweet> getTweet() {
return tweetRepository.findAll();
}
}
-- @ Service: spring Indique que la classe de service est MVC. Cible de DI (injection de dépendance)
-- @ Transactional: Annotation pour le contrôle des transactions
-- @ Autowired: Annotation attachée à la cible d'injection du conteneur DI
--Créez une classe de contrôleur sous le paquet controller
@RequestMapping (), la méthode postTweet est appelée lorsque la méthode POST est appelée pour le chemin tweet, et la méthode getTweet est appelée lorsqu'elle est appelée par la méthode GET.@ RequestBody pour mapper le corps de la requête HTTP à l'objet Tweet et le transmettre à la méthode postTweet de tweetService. Après avoir exécuté tweetService.postTweet (), le résultat est renvoyé.TweetController.java
package com.example.api.controller;
import com.example.api.model.Tweet;
import com.example.api.service.TweetService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("tweet")
public class TweetController {
@Autowired
TweetService tweetService;
@RequestMapping(method = RequestMethod.POST)
Tweet postTweet(@RequestBody Tweet tweet) {
return tweetService.postTweet(tweet);
}
@RequestMapping(method = RequestMethod.GET)
List<Tweet> getTweet() {
return tweetService.getTweet();
}
}
-- @ RestController: Annotation donnée à la classe de contrôleur
--@ RequestMapping (): Une annotation pour accepter les requêtes HTTP. Spécifiez le chemin pour accepter la requête et la méthode HTTP
-- @ RequestBody: Une annotation qui mappe le corps d'une demande à un objet spécifié
# post request
$ curl -X POST -H 'Content-Type:application/json' -d '{"name":"Nom", "message":"message"}' localhost:8080/tweet
# response
{"id":1,"name":"Nom","message":"message"}
--Vérifiez la base de données et c'est OK si le contenu demandé est enregistré
mysql> select * from tweet;
+----+-----------------+--------+
| id | message | name |
+----+-----------------+--------+
| 1 |message|Nom|
+----+-----------------+--------+
1 row in set (0.01 sec)
# get request
curl -X GET -H 'Content-Type:application/json' localhost:8080/tweet
# response
[{"id":1,"name":"Nom","message":"message"}]
Update / Delete
/ tweet / {id}.
--JpaRepository implémente déjà la méthode utilisée pour la mise à jour / suppression, il n'est donc pas nécessaire de modifier le référentiel. (Il suffit d'appeler du service)--Ajoutez la méthode suivante dans la classe de TweetService.java
TweetService.java
public Tweet updateTweet(Tweet tweet) {
return tweetRepository.save(tweet);
}
public void deleteTweet(Integer id) {
tweetRepository.deleteById(id);
}
--update utilise la même méthode save () que create
--delete utilise la méthode deleteById () pour supprimer l'entité spécifiée par id
--Ajoutez la méthode suivante dans la classe de TweetController.java
TweetController.java
@RequestMapping(value = "{id}", method = RequestMethod.PUT)
Tweet putTweet(@PathVariable("id") Integer id, @RequestBody Tweet tweet) {
tweet.setId(id);
return tweetService.updateTweet(tweet);
}
@RequestMapping(value = "{id}", method = RequestMethod.DELETE)
void deleteTweet(@PathVariable("id") Integer id) {
tweetService.deleteTweet(id);
}
--Spécifiez {id} dans l'option de valeur de @ RequestMapping et définissez la méthode correspondante à appeler à la demande de / tweet / {id}.
@ PathVariable.# put request
$ curl -X PUT -H 'Content-Type:application/json' -d '{"name":"Nom mis à jour", "message":"Message mis à jour"}' localhost:8080/tweet/1
# response
{"id":1,"name":"Nom mis à jour","message":"Message mis à jour"}
--Vérifiez la base de données et assurez-vous que les données sont mises à jour
mysql> select * from tweet;
+----+-----------------------------+--------------------+
| id | message | name |
+----+-----------------------------+--------------------+
| 1 |Message mis à jour|Nom mis à jour|
+----+-----------------------------+--------------------+
1 row in set (0.01 sec)
--Enfin, exécutez la commande suivante à partir du terminal pour confirmer la suppression des données.
# delete request
curl -X DELETE -H 'Content-Type:application/json' localhost:8080/tweet/1
#pas de réponse
mysql> select * from tweet;
Empty set (0.00 sec)
Recommended Posts