Was sind Microservices? Sie erkennen die Serie auf einen Blick!
Wird weiter aktualisiert, bitte liken und folgen Sie!
Was ist Spring Cloud?
Spring Cloud ist eine geordnete Sammlung einer Reihe von Frameworks. Es nutzt den Entwicklungskomfort von Spring Boot, um die Entwicklung verteilter Systeme wie Service Discovery, Service Gateway, Service Routing, Link Tracking usw. zu vereinfachen. Spring Cloud erfindet das Rad nicht neu, sondern integriert und kapselt gut entwickelte Module auf dem Markt und reduziert so die Entwicklungskosten jedes Moduls. Mit anderen Worten: Spring Cloud stellt den „Familien-Bucket“ bereit, der zum Aufbau verteilter Systeme erforderlich ist.
Spring Cloud-Status Quo
Derzeit gibt es in China nicht viele Unternehmen, die die Spring Cloud-Technologie nutzen. Das liegt nicht daran, dass Spring Cloud nicht gut ist. Die Hauptgründe sind folgende:
- Spring Cloud verfügt nur über wenige chinesische Dokumente und es gibt nicht viele Lösungen für Probleme im Internet.
- Die meisten technischen Leiter inländischer Unternehmerunternehmen sind Mitarbeiter der Ali-Abteilung, und die Ali-Abteilung verwendet hauptsächlich Dubbo zum Aufbau der Microservice-Architektur.
- Große Unternehmen verfügen grundsätzlich über eigene verteilte Lösungen, während viele kleine und mittlere Unternehmen in ihren Architekturen keine Microservices verwenden, sodass kein Bedarf für den Einsatz von Spring Cloud besteht.
Allerdings liegt die Microservice-Architektur im Trend und Spring Cloud ist führend bei Microservice-Lösungen. Dies ist auch die Bedeutung des Autors dieser Kursreihe.
Vor- und Nachteile von Spring Cloud
Seine Hauptvorteile sind:
集大成者，Spring Cloud 包含了微服务架构的方方面面。
约定优于配置，基于注解，没有配置文件。
轻量级组件，Spring Cloud 整合的组件大多比较轻量级，且都是各自领域的佼佼者。
开发简便，Spring Cloud 对各个组件进行了大量的封装，从而简化了开发。
开发灵活，Spring Cloud 的组件都是解耦的，开发人员可以灵活按需选择组件。
Seine Nachteile:
项目结构复杂，每一个组件或者每一个服务都需要创建一个项目。
部署门槛高，项目部署需要配合 Docker 等容器技术进行集群部署，而要想深入了解 Docker，学习成本高。
Die Vorteile von Spring Cloud liegen auf der Hand. Daher ist das Erlernen von Spring Cloud für Studenten, die Microservice-Architektur studieren möchten, eine gute Wahl.
Bau des Spring Cloud-Projekts
Erinnerung: Sie müssen über eine bestimmte Springboot-Grundlage verfügen!
Im letzten Artikel haben wir etwas über Microservices gelernt. Es reicht nicht aus, es zu verstehen. Das Wichtigste ist, es zu praktizieren, denn die Praxis ist das einzige Kriterium, um die Wahrheit zu testen. Erst wenn wir sowohl Theorie als auch Praxis beherrschen, können wir es wirklich lernen. Wir wissen, dass Microservices über mehrere Dienste verfügen, verschiedene Unternehmen in unterschiedliche Dienste einteilen und sich dann zwischen den Diensten gegenseitig anrufen. Daher müssen wir ein neues allgemeines Projekt (übergeordnetes Projekt) erstellen, um die anderen unten aufgeführten Microservice-Projekte zu verwalten. Der gesamte Prozess wird mit dem Maven-Projekt erstellt, was dem Springboot-Building entspricht. Beginnen wir mit dem Aufbau!
Projektkonstruktionsdiagramm:
Wir erstellen zuerst das übergeordnete Projekt. Hier verwenden wir zum Erstellen das Maven-Projekt.
Geben Sie gav ein, füllen Sie es entsprechend Ihren eigenen Gewohnheiten aus und klicken Sie dann auf Weiter
Die folgende Oberfläche wird angezeigt. Klicken Sie auf „Fertig stellen“. Das neue Projekt ist abgeschlossen.
Als nächstes konfigurieren wir es zunächst. Zuerst konfigurieren wir die POM.XML-Datei.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.study.springcloud</groupId>
<artifactId>mcroservice</artifactId>
<!-- 首先修改打包方式 -->
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<mysql.version>5.1.47</mysql.version>
<druid.version>1.1.10</druid.version>
<junit.version>4.1.2</junit.version>
<lombok.version>1.16.10</lombok.version>
<log4j.vsrsion>1.2.17</log4j.vsrsion>
</properties>
<!-- 因为是总项目 所以用dependencyManagement来管理 因为其他的子项目就不会来管理版本了了 可以直接引用 -->
<dependencyManagement>
<dependencies>
<!-- springcloud的依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Greenwich.SR1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- springboot的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.1.4.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- 数据库-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>${druid.version}</version>
</dependency>
<!-- springboot启动器-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.2</version>
</dependency>
<!--单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<!-- lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.8</version>
</dependency>
<!-- log4j-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.vsrsion}</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-core</artifactId>
<version>1.2.3</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>
Da unser übergeordnetes Projekt kein Geschäft schreibt, können wir den Ordner src löschen und festlegen, dass einige nutzlose Dateien nicht angezeigt werden, oder sie löschen. An diesem Punkt haben wir die Erstellung des übergeordneten Projekts abgeschlossen, so einfach ist das.
Als nächstes können wir mit dem Aufbau anderer Microservice-Projekte fortfahren. Wir erstellen zunächst einen Dienst speziell für unsere Entitätsklasse, damit andere Dienste ihn aufrufen können.
Wählen Sie unser übergeordnetes Projekt aus, klicken Sie auf „Neu“ und dann auf „Modul“, wie unten gezeigt:
Dies ist dasselbe wie das übergeordnete Projekt.
Geben Sie den Projektnamen unseres Moduls ein.
Beachten Sie, dass im folgenden Schritt das - in unserem Projektnamen im Modulnamen weggelassen wird, da es im eigentlichen Projekt mehr Projekte gibt. Um es klarer zu sehen, müssen wir - hinzufügen, um es aufzuteilen! Dann klicken wir auf Fertig stellen.
Zu diesem Zeitpunkt ist unser erstes Microservice-Projekt eingerichtet und der nächste Schritt ist die Konfiguration. Wir konfigurieren zunächst die Datei POM.xml. Hier stellen wir das Hutool-JAR-Paket vor, eine grundlegende Java-Toolklasse, die JDK-Methoden wie Dateien, Streams, Ver- und Entschlüsselung, Transkodierung, Regularisierung, Threads, XML usw. kapselt, um verschiedene Util-Toolklassen zu bilden, und auch bereitstellt die folgenden Komponenten:
布隆过滤
缓存
克隆接口
类型转换
日期处理
数据库ORM（基于ActiveRecord思想）
基于DFA有限自动机的多个关键字查找
HTTP客户端
IO和文件
有用的一些数据结构
日志
反射代理类的简化（AOP切面实现）
Setting（一种扩展Properties的配置文件）
System（JVM和系统信息等）
WatchService的封装（文件变动监控）
XXXUtil各种有用的工具类
Es ist außerdem sehr benutzerfreundlich und daher ein Artefakt in unserer Java-Entwicklung.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>mcroservice</artifactId>
<groupId>com.study.springcloud</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>cloud-api-commons</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- 工具包-->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.1.0</version>
</dependency>
</dependencies>
</project>
Dies ist die Pojo-Klasse, die wir in den Dienst schreiben können. Wir nehmen hier die Zahlung als Beispiel, also erstellen wir zunächst eine Zahlungstabelle in den Daten. Die SQL-Anweisung lautet wie folgt
CREATE TABLE `payment` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
`serial` varchar(200) COLLATE utf8_unicode_ci DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
Wir fügen der Tabelle Daten hinzu und die SQL-Anweisung lautet wie folgt:
insert into `payment`(`id`,`serial`) values (1,'百度'),(2,'alibaba'),(3,'京东'),(4,'头条');
Nachdem wir die Tabelle erstellt und Daten hinzugefügt haben, erstellen wir eine neue entsprechende Entitätsklasse. Das Bild unten zeigt das Projektstrukturdiagramm:
Die Entitätsklasse, die der Zahlungstabelle entspricht. Hier wird Lombok verwendet. Die obige POM-Datei importiert Abhängigkeiten, aber das Lombok-Plug-In muss installiert sein, sonst wird ein Fehler gemeldet! Wie nachfolgend dargestellt:
package com.buba.springcloud.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
//网络通信 一定要实现序列化
//使用lombok 没有配置的童鞋要去百度查一下 jar我们导入了 需要在idea装一个插件就可以了
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class Payment implements Serializable {
private Long id;
// 微服务 一个服务对应一个数据库，同一个信息可能存在不同的数据库
private String serial;
}
Zur Vereinfachung der Datenübertragung und zur Trennung von Front-End- und Back-End-Projekten kapseln wir die zurückgegebenen Daten in einer Entitätsklasse.
package com.buba.springcloud.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class CommonResult<T> {
private Integer code;//返回状态码
private String message;//返回是否调用成功
private T data; //返回的数据
public CommonResult(Integer code, String message) {
this(code,message,null);
}
}
Unser Entitätsklassendienst speichert hauptsächlich Entitätsklassen und schreibt keine Geschäftslogik. Wir können auch den src-Ordner löschen. Zu diesem Zeitpunkt haben wir das allgemeine Projekt und das Microservice-Projekt, das Entitätsklassen bereitstellt, erfolgreich erstellt. Da das Dienstprojekt der Entitätsklasse von anderen Dienstprojekten aufgerufen werden muss, müssen die Dienste der Entitätsklasse gepackt und in einer gemeinsamen lokalen Bibliothek abgelegt werden.
Wir bereinigen zunächst das Projekt, um sicherzustellen, dass die Maven-Konfiguration des aktuellen Projekts erfolgreich ist.
Die folgende Schnittstelle wird angezeigt und zeigt an, dass kein Problem mit der Maven-Konfigurationsumgebung des aktuellen Projekts vorliegt.
Dann beginnen wir mit der Installation und dem Packen in die lokale Bibliothek. Das Folgende ist die erfolgreiche Schnittstelle:
An diesem Punkt können wir sehen, dass cloud-api-commons in die pom.xml-Datei unseres allgemeinen Projekts eingeführt wurde, wie unten gezeigt:
In unserem nächsten Artikel werden wir ein Microservice-Projekt für Produzenten und Verbraucher aufbauen. Der Artikel wird laufend aktualisiert, bitte liken und folgen!
