--Letztes Mal habe ich eine API erstellt, die nur eine Zeichenfolge in Erstellen eines Web-API-Servers mit Spring Boot zurückgibt.
| Artikelname | Schimmel | Erläuterung |
|---|---|---|
| id | int | ID eindeutig für den Tweet |
| name | String | Der Name der Person, die getwittert hat |
| message | String | Tweet Inhalt |
| url | HTTP-Methode | Erläuterung |
|---|---|---|
| /tweet | POST | Speichern Sie den Tweet |
| /tweet | GET | Holen Sie sich alle Tweets |
| /tweet/{id} | PUT | Aktualisieren Sie Tweets mit der angegebenen ID |
| /tweet/{id} | DELETE | Löschen Sie den Tweet mit der angegebenen ID |
src/main/java/com/example/api
.
├── ApiApplication.java
├── model
│ └── Tweet.java
├── repository
│ └── TweetRepository.java
├── service
│ └── TweetService.java
└── controller
└── TweetController.java
--model: Stellt eine Entität dar (die zu verarbeitenden Daten)
--repository: Zugriff auf DB
--service: Geschäftslogik ausführen
--controller: Prozessanforderung / Antwort vom Client verarbeiten
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'
--Erstellen Sie application.properties oder application.yml unter src / main / resources und geben Sie die Informationen der Datenbank ein, zu der eine Verbindung hergestellt werden soll.
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
#Vermeiden Sie es, die Datenbank beim Start der Anwendung zu initialisieren
jpa:
hibernate:
ddl-auto: update
#Behebung des Problems, dass beim Start des Frühlingsstarts keine Tabelle in der Datenbank erstellt werden kann
properties:
hibernate:
dialect: org.hibernate.dialect.MySQL57Dialect
logging:
level:
sql: debug
spring.jpa.properties.hibernate.dialect ist enthalten, da die Tabelle beim Starten der Anwendung nicht erstellt werden konnte und der folgende Fehler aufgetreten ist. Gelöst unter Bezugnahme auf hierorg.hibernate.tool.schema.spi.CommandAcceptanceException: Error executing DDL "create table tweet (tweet varchar(255) not null, primary key (tweet)) engine=MyISAM" via JDBC Statement
...(Weggelassen)...
Caused by: java.sql.SQLSyntaxErrorException: Specified key was too long; max key length is 1000 bytes
...(Weggelassen)...
Create / Read
--Erstellen Sie eine Klasse, die den Tweet selbst unter dem Paket model darstellt
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: Gibt an, dass es sich um eine JPA-Entität handelt (ein in der Datenbank gespeichertes Objekt).
-- @Data / @NoArgsConstructor / @ AllArgsConstructor: Anmerkung von lombok. Getter, Setter, Konstruktor usw. automatisch erstellen.
--@ Table (name = "tweet"): Geben Sie den Tabellennamen an, der der Entität entspricht
-- @ Id: Anmerkung, die angibt, dass es sich um den Primärschlüssel der Entität handelt
-- @ GeneratedValue: Damit nummeriert die DB automatisch.
--@ Column (nullable = false): Eine Anmerkung zu einer DB-Spalte. Mit der Option nullable können Sie festlegen, ob null zugelassen werden soll
--Erstellen Sie eine Repository-Klasse unter dem Paket "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> {}
--Erstellen Sie eine Serviceklasse unter dem Paket "service"
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 Zeigt an, dass die Serviceklasse MVC ist. Ziel von DI (Dependency Injection)
-- @ Transactional: Anmerkung zur Transaktionssteuerung
-- @ Autowired: Anmerkung zum Injektionsziel des DI-Behälters
--Erstellen Sie eine Controller-Klasse unter dem Paket controller
--Mit der Annotation @RequestMapping () wird die postTweet-Methode aufgerufen, wenn die POST-Methode für den Pfad tweet aufgerufen wird, und die getTweet-Methode wird aufgerufen, wenn die GET-Methode aufgerufen wird.
@ RequestBody, um den Hauptteil der HTTP-Anforderung dem Tweet-Objekt zuzuordnen und an die postTweet-Methode des tweetService zu übergeben. Nach dem Ausführen von tweetService.postTweet () wird das Ergebnis zurückgegeben.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: Anmerkung zur Controller-Klasse
--@ RequestMapping (): Eine Anmerkung zum Akzeptieren von HTTP-Anforderungen. Geben Sie den Pfad zum Akzeptieren der Anforderung und die HTTP-Methode an
-- @ RequestBody: Eine Anmerkung, die den Hauptteil einer Anforderung einem angegebenen Objekt zuordnet
# post request
$ curl -X POST -H 'Content-Type:application/json' -d '{"name":"Name", "message":"Botschaft"}' localhost:8080/tweet
# response
{"id":1,"name":"Name","message":"Botschaft"}
--Überprüfen Sie die Datenbank und es ist in Ordnung, wenn der angeforderte Inhalt gespeichert wird
mysql> select * from tweet;
+----+-----------------+--------+
| id | message | name |
+----+-----------------+--------+
| 1 |Botschaft|Name|
+----+-----------------+--------+
1 row in set (0.01 sec)
# get request
curl -X GET -H 'Content-Type:application/json' localhost:8080/tweet
# response
[{"id":1,"name":"Name","message":"Botschaft"}]
Update / Delete
/ tweet / {id} angegebenen ID.
--JpaRepository implementiert bereits die zum Aktualisieren / Löschen verwendete Methode, sodass das Repository nicht geändert werden muss. (Einfach vom Service anrufen)TweetService.java
public Tweet updateTweet(Tweet tweet) {
return tweetRepository.save(tweet);
}
public void deleteTweet(Integer id) {
tweetRepository.deleteById(id);
}
--update verwendet dieselbe save () Methode wie create
--delete verwendet die Methode deleteById (), um die durch id angegebene Entität zu löschen
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);
}
@ PathVariable zu.# put request
$ curl -X PUT -H 'Content-Type:application/json' -d '{"name":"Name aktualisiert", "message":"Aktualisierte Nachricht"}' localhost:8080/tweet/1
# response
{"id":1,"name":"Name aktualisiert","message":"Aktualisierte Nachricht"}
--Überprüfen Sie die Datenbank und stellen Sie sicher, dass die Daten aktualisiert werden
mysql> select * from tweet;
+----+-----------------------------+--------------------+
| id | message | name |
+----+-----------------------------+--------------------+
| 1 |Aktualisierte Nachricht|Name aktualisiert|
+----+-----------------------------+--------------------+
1 row in set (0.01 sec)
# delete request
curl -X DELETE -H 'Content-Type:application/json' localhost:8080/tweet/1
#keine Antwort
--Überprüfen Sie die Datenbank und es ist in Ordnung, wenn die Daten gelöscht wurden!
mysql> select * from tweet;
Empty set (0.00 sec)
Recommended Posts