[JAVA] Lassen Sie uns schreiben, wie API mit SpringBoot + Docker von 0 erstellt wird
Einführung
Ich habe versucht, eine einfache API mit Spring Boot und Docker zu erstellen. Es gab nicht viele Artikel, die von Grund auf erklärt wurden, also mache ich selbst einen und poste ihn. Ehrlich gesagt habe ich jedoch wenig Wissen über Api und Docker. Bitte weisen Sie auf Fehler hin! Bitte verzeihen Sie mir auch, da davon ausgegangen wird, dass es diesmal auf einem Mac erstellt wird.
Produktionsumfeld
・ Betriebssystem: Mac ・ DB: MySQL (mariaDB) ・ VM: Docker ・ Sprache: Spring Boot (Java 8) -Bauwerkzeug: Maven
Installation jedes Werkzeugs
Installieren Sie Docker
https://docs.docker.com/docker-for-mac/install/
Bitte laden Sie diese URL herunter und installieren Sie sie. 
Java-Installation
Hier herunterladen http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
Diesmal benutze ich 1.8.0-181.
Installieren Sie Maven
Alles, was die Maven-Version betrifft, ist in Ordnung, aber dieses Mal werde ich "3.5.2" verwenden. Bitte beziehen Sie sich hier. So installieren Sie eine bestimmte Version von Maven
Installieren Sie MySQL
Ich werde es mit Brew Home installieren.
$ brew install mysql
Installation von STS (Spring Tool Suite)
STS (Spring Tool Suite) ist eine Eclipse-ähnliche IDE, die Spring enthält. Dieses Mal werden wir dies verwenden, um ein Projekt zu erstellen. https://spring.io/tools/sts/all Lassen Sie uns von hier aus installieren.
Jetzt, wo wir alles haben, was wir brauchen, können wir mit der Produktion beginnen.
Produktion
Erstellen Sie eine API, um eine Entität mit einem Benutzer (Name, E-Mail) zu CRUDEN.
Die zu erstellende API lautet wie folgt.
GET / api / users => Alle Benutzer abrufen (getUsers) GET / api / users / {id} => Benutzer mit ID abrufen (getUser) POST / api / users => Benutzer hinzufügen (createUser) PUT / api / users / {id} => Benutzerupdate (updateUser) DELETE / api / users / {id} => Benutzer mit ID löschen (deleteUser)
** Erstellen Sie ein Projekt mit STS **
file -> new -> Spring Starter Project
Ich werde ein Projekt mit machen.
Dieses Mal werde ich es mit dem Projektnamen " sampleApi "machen.
Erstellen Sie ein Projekt, indem Sie in Spring Initializr jpa, web, lombok, mysql auswählen.
Vorbereitung
Entität, Repository, Service erstellen.
Entity
@Data
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue
private Long id;
private String name;
private String email;
}
Vereinfacht ausgedrückt ist Entity ein Ort zum Speichern von Werten, die in der Datenbank registriert / aktualisiert werden sollen, oder zum Speichern der von der Datenbank erhaltenen Werte. Die Datenbanktabelle, die mit @Table ausgetauscht werden soll, wird angegeben. Wir werden diese Tabelle usw. später erstellen.
Repository
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}
Dieses Repository ist die Klasse, die direkt mit BD kommuniziert.
Service
@Service
@Transactional
public class UserService {
@Autowired
UserRepository userRepository;
public User findUser(Long id){
return userRepository.findOne(id);
}
public List<User> findUsers(){
return userRepository.findAll();
}
public User save(User user) {
return userRepository.save(user);
}
public void delete(Long id) {
userRepository.delete(id);
}
}
Die Geschäftslogikverarbeitung wird in dieser Serviceklasse ausgeführt. Sie erhalten den Wert vom unten beschriebenen Controller und weisen das Repository an, ihn zu verarbeiten.
Controller Erstellen Sie einen Controller für den Benutzeraustausch. Beschreiben Sie den Prozess, der der HTTP-Anforderung entspricht. Wenn Sie Benutzer durch den Ressourcennamen ersetzen, können Sie ihn für andere Ressourcen verwenden. Ich habe den Antwortcode diesmal nicht angegeben, aber wenn Sie ihn streng implementieren möchten, ist es möglicherweise besser, ihn anzugeben?
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
UserService userService;
@RequestMapping(method = RequestMethod.GET)
public List<User> getUsers() {
return userService.findUsers();
}
@RequestMapping(method=RequestMethod.GET, value="{id}")
public User getUser(@PathVariable("id") Long id) {
return userService.findUser(id);
}
@RequestMapping(method=RequestMethod.POST)
public User createUser(@Validated @RequestBody User user) {
return userService.save(user);
}
@RequestMapping(method=RequestMethod.PUT, value="{id}")
public User updateUser(@PathVariable("id") Long id, @RequestBody User user) {
user.setId(id);
return userService.save(user);
}
@RequestMapping(method=RequestMethod.DELETE, value="{id}")
public void deleteUser(@PathVariable("id") Long id) {
userService.delete(id);
}
}
@ RestController ist eine Anmerkung zum Erstellen von RestAPI, und Sie können mit @ Controller + @ ResponseBody + JSON austauschen. Spring-Boot-Starter-Web behandelt, was Jackson erhält und was es anzeigt.
Docker Es ist ein Hafenarbeiter. Ich bin immer noch nicht eindeutig, also schreibe ich es kurz. Zunächst werden die Dateien "docker-compose.yml" und "Dockerfile" benötigt, um den Docker-Container zu starten. Erstellen Sie diese beiden Dateien also direkt unter dem Projektordner.
Nach dem Erstellen werde ich den Inhalt der Datei schreiben
** Zunächst " docker-compose.yml "**
version: '3'
services:
db:
image: mariadb:10.2
restart: always
command: mysqld --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
environment:
MYSQL_ROOT_PASSWORD: password
MYSQL_USER: hogeuser
MYSQL_PASSWORD: password
MYSQL_DATABASE: sampleapi_development
ports:
- "3306:3306"
volumes:
- ./docker/tmp/mysql:/var/lib/mysql
- ./docker/mysql/initdb.d:/docker-entrypoint-initdb.d
volumes:
data:
driver: local
Es ist eine Beschreibung zum Starten des Datenbankservers. Außerdem wird beim Starten des Servers eine Datenbank erstellt. Das ist hier
MYSQL_ROOT_PASSWORD: password
MYSQL_USER: hogeuser
MYSQL_PASSWORD: password
MYSQL_DATABASE: sampleapi_development
Von oben ist es das Kennwort für die Stammberechtigung, den Serverbenutzernamen, das Kennwort und den Datenbanknamen.
** Dann " Dockerfile "**
FROM openjdk:jdk-alpine
VOLUME /tmp
RUN mkdir /app
WORKDIR /app
ENV JAVA_OPTS=""
ENV JAR_TARGET "sampleApi-1.0.0-SNAPSHOT.jar"
ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar build/libs/sampleApi-1.0.0-SNAPSHOT.jar" ]
In Bezug auf "docker-compose.yml" denke ich, dass es durch Kopieren funktioniert, aber für "Dockerfile" ist es notwendig, "sampleApi-1.0.0-SNAPSHOT.jar" von "ENV" und "ENTRYPOINT" ein wenig zu ändern. Dies ist eine Beschreibung, die auf die JAR-Datei abzielt, die beim Erstellen des Projekts generiert wurde. Der vom Projekt generierte Dateiname ist jedoch unterschiedlich. Bitte schreiben Sie es unter Bezugnahme auf Folgendes neu.
Ich denke, es gibt "pom.xml" im Projekt, also ist es drin
<artifactId>sampleApi</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>jar</packaging>
Ich denke, es gibt eine solche Beschreibung. Wie Sie sehen können, sehen Sie sich den Inhalt dieser "Artefakt-ID", "Version" und "Verpackung" an und schreiben Sie ihn neu.
Geben Sie als Nächstes den Inhalt von " application.properties "ein.
Die Datei hier befindet sich in "src / main / resources".
Füllen Sie Folgendes aus:
spring.datasource.url=jdbc:mysql://localhost:3306/sampleapi_development
spring.datasource.username=hogeuser
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
Dies ist, was Sie benötigen, um das Projekt und die Datenbank zu verbinden, und beschreibt den Benutzernamen und den Datenbanknamen, die oben in "docker-compose.yml" erstellt wurden.
Nachdem die Erstellung abgeschlossen ist, werden wir sie tatsächlich starten. Verwenden Sie zunächst den Befehl, um direkt unter das Projekt zu gelangen.
$ cd ~/sampleApi
Starten wir Docker. Geben Sie Folgendes ein:
$ docker-compose up --build
Wenn keine Fehler vorliegen, ist dies erfolgreich.
Starten wir nun die Anwendung. Ich dachte, aber ich habe den Inhalt (die Tabelle) der Datenbank noch nicht erstellt, also werde ich ihn erstellen. Sie müssen sich in den von Docker gestarteten Datenbankserver begeben. Geben Sie zunächst Folgendes ein, um den Servernamen zu überprüfen.
$ docker-compose ps
Name Command State Ports
------------------------------------------------------------------------------
sampleapi_db_1 docker-entrypoint.sh mysqld Up 0.0.0.0:3306->3306/tcp
Nachdem Sie den Servernamen kennen, geben Sie ein.
$ docker exec -it sampleapi_db_1 bash
root@c71a21817893:/# mysql -h localhost -P 3306 -u hogeuser -p
Enter password:
Welcome to the MariaDB monitor. Commands end with ; or \g.
Your MariaDB connection id is 20
Server version: 10.2.16-MariaDB-1:10.2.16+maria~bionic mariadb.org binary distribution
Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
MariaDB [(none)]>
Überprüfen Sie, ob die Datenbank erstellt wurde.
MariaDB [(none)]> show databases;
+-----------------------+
| Database |
+-----------------------+
| information_schema |
| sampleapi_development |
+-----------------------+
2 rows in set (0.06 sec)
MariaDB [(none)]>
Es gibt kein Problem
Lass uns einen Tisch machen.
Klicken Sie hier, um eine Anweisung zu erstellen
CREATE TABLE users ( id int NOT NULL AUTO_INCREMENT, name varchar(255) NOT NULL, email varchar(255) NOT NULL, PRIMARY KEY (id) );
Ich glaube jedoch nicht, dass dies so gemacht werden kann, wie es ist, daher ist es notwendig, die Datenbank zu wechseln.
Lassen Sie uns mit dem folgenden Befehl wechseln und erstellen.
//Datenbanken wechseln
MariaDB [(none)]> use sampleapi_development;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Database changed
MariaDB [sampleapi_development]> CREATE TABLE users (
-> id int NOT NULL AUTO_INCREMENT,
-> name varchar(255) NOT NULL,
-> email varchar(255) NOT NULL,
-> PRIMARY KEY (id)
-> );
Query OK, 0 rows affected (0.02 sec)
MariaDB [sampleapi_development]> INSERT INTO users(id, name, email) VALUES(1, 'ishii', '[email protected]');
Query OK, 1 row affected (0.01 sec)
Da es einfacher zu verstehen ist, ob Daten vorhanden sind, habe ich sie mit einer INSERT-Anweisung hinzugefügt.
Programm starten
Nachdem der Inhalt erstellt wurde, starten wir die App. Öffnen Sie STS und klicken Sie mit der rechten Maustaste auf das Projekt. Run as → Spring Boot App Lasst uns beginnen.
Überprüfen Sie, ob die API funktioniert.
$ curl localhost:8080/api/users
[{"id":1,"name":"ishii","email":"[email protected]"}]
Sie können es richtig bekommen
Ich werde einen Benutzer hinzufügen
$ curl -XPOST -H "Content-Type:application/json" http://localhost:8080/api/users -d '{
"name":"ishii2","email":"[email protected]"
}'
{"id":2,"name":"ishii2","email":"[email protected]"}
Kein Problem!
Übrigens Docker fallen zu lassen
$ docker-compose down
Sie können es fallen lassen, indem Sie tun. Es wird empfohlen, den Docker nach dem Spielen ordnungsgemäß fallen zu lassen.
Schließlich
Für Datenbanken ist es meiner Meinung nach wirklich besser, die Migration zu verwenden. Dieses Mal versuche ich jedoch, Daten direkt zu erstellen, da ich nicht so viel jagen konnte und der Artikel aufgebläht wurde. Ich wünschte, ich könnte auch hier herumschreiben.
Referenzierte Site
・ API-Konstruktion https://ishiis.net/2016/09/08/spring-boot-rest-api/ ・ Docker https://qiita.com/ken0909/items/a3f8594ce677bbc7c4c2 ・ Greifen Sie in der Docker-App auf die Datenbank zu https://qiita.com/M_Nagata/items/120831bb4e4a3deace13
Das Obige ist, wie man eine API mit Docker + Spring erstellt, die ich erstellt und gesehen habe. Es ist ein hässlicher Artikel, aber danke, dass Sie ihn bis zum Ende gesehen haben. Ich studiere gerade Schienen, also hoffe ich, dass ich in Zukunft einen Artikel darüber schreiben kann.
Recommended Posts