Que sont les microservices ? Vous connaîtrez la série en un coup d’œil !
Continuez à mettre à jour, veuillez aimer et suivre !
Qu’est-ce que Spring Cloud ?
Spring Cloud est une collection ordonnée d'une série de frameworks.Il utilise la commodité de développement de Spring Boot pour simplifier le développement de systèmes distribués, tels que la découverte de services, la passerelle de services, le routage de services, le suivi des liens, etc. Spring Cloud ne réinvente pas la roue, mais intègre et encapsule des modules bien développés sur le marché, réduisant ainsi le coût de développement de chaque module. En d'autres termes : Spring Cloud fournit le « compartiment familial » nécessaire pour créer des systèmes distribués.
Statu quo sur Spring Cloud
À l'heure actuelle, peu d'entreprises utilisent la technologie Spring Cloud en Chine. Ce n'est pas parce que Spring Cloud n'est pas bon. Les principales raisons sont les suivantes :
- Spring Cloud possède peu de documents chinois et il n'existe pas beaucoup de solutions aux problèmes sur Internet.
- La plupart des patrons techniques des entreprises entrepreneuriales nationales sont des employés du département Ali, et le département Ali utilise principalement Dubbo pour construire l'architecture des microservices.
- Les grandes entreprises disposent essentiellement de leurs propres solutions distribuées, tandis que l'architecture des petites et moyennes entreprises n'utilise pas de microservices, il n'est donc pas nécessaire d'utiliser Spring Cloud.
Cependant, l'architecture des microservices est une tendance et Spring Cloud est un leader dans les solutions de microservices, c'est pourquoi l'auteur a écrit cette série de cours.
Avantages et inconvénients de Spring Cloud
Ses principaux avantages sont :
集大成者，Spring Cloud 包含了微服务架构的方方面面。
约定优于配置，基于注解，没有配置文件。
轻量级组件，Spring Cloud 整合的组件大多比较轻量级，且都是各自领域的佼佼者。
开发简便，Spring Cloud 对各个组件进行了大量的封装，从而简化了开发。
开发灵活，Spring Cloud 的组件都是解耦的，开发人员可以灵活按需选择组件。
Ses inconvénients :
项目结构复杂，每一个组件或者每一个服务都需要创建一个项目。
部署门槛高，项目部署需要配合 Docker 等容器技术进行集群部署，而要想深入了解 Docker，学习成本高。
Les avantages de Spring Cloud sont évidents. Par conséquent, pour les étudiants qui souhaitent étudier l’architecture des microservices, apprendre Spring Cloud est un bon choix.
Construction du projet Spring Cloud
Rappel chaleureux : vous devez avoir une certaine base de springboot !
Dans le dernier article, nous avons découvert les microservices. Les comprendre ne suffit pas. Le plus important est de les pratiquer, car la pratique est le seul critère pour tester la vérité. Ce n'est que lorsque la théorie et la pratique sont maîtrisées que nous pouvons vraiment l'apprendre. Nous savons que les microservices ont plusieurs services, regroupent différentes entreprises dans différents services, puis s'appellent entre chaque service. Nous devons donc créer un nouveau projet général (projet parent) pour gérer les autres projets de microservices ci-dessous. L'ensemble du processus est construit à l'aide du projet maven, qui est le même que la version springboot. Commençons à construire !
Schéma de construction du projet :
Nous construisons d'abord le projet parent, ici nous utilisons le projet maven pour construire.
Remplissez gav, remplissez selon vos propres habitudes, puis cliquez sur Suivant
L'interface suivante apparaît, cliquez sur Terminer et le nouveau projet est terminé.
Ensuite, nous allons d'abord le configurer, en commençant par le fichier POM.XML.
<?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>
Étant donné que notre projet parent n'écrit pas d'affaires, nous pouvons supprimer le dossier src et définir certains fichiers inutiles pour qu'ils ne soient pas affichés ou les supprimer. À ce stade, nous avons terminé la construction du projet parent, c’est aussi simple que cela.
Ensuite, nous pouvons continuer à créer d’autres projets de microservices. Nous construisons d'abord un service dédié à notre classe d'entité afin que d'autres services puissent l'appeler.
Sélectionnez notre projet parent, cliquez sur Nouveau, puis cliquez sur Module, comme indiqué ci-dessous :
C'est la même chose que le projet parent.
Remplissez le nom du projet de notre module.
Notez qu'à l'étape suivante, le - du nom de notre projet est omis dans le nom du module, car il y a plus de projets dans le projet réel, et nous devons ajouter - pour le diviser pour faciliter la visualisation ! Ensuite, nous cliquons sur Terminer.
À ce stade, notre premier projet de microservice a été établi et la prochaine étape est la configuration. Nous configurons d'abord le fichier POM.xml. Nous présentons ici le package jar de Hutool, qui est une classe d'outils Java de base qui encapsule les méthodes JDK telles que les fichiers, les flux, le cryptage et le déchiffrement, le transcodage, la régularisation, les threads et XML pour former diverses classes d'outils Util, et fournit les composants suivants. en même temps :
布隆过滤
缓存
克隆接口
类型转换
日期处理
数据库ORM（基于ActiveRecord思想）
基于DFA有限自动机的多个关键字查找
HTTP客户端
IO和文件
有用的一些数据结构
日志
反射代理类的简化（AOP切面实现）
Setting（一种扩展Properties的配置文件）
System（JVM和系统信息等）
WatchService的封装（文件变动监控）
XXXUtil各种有用的工具类
Il est également très pratique à utiliser, ce qui en fait un artefact dans notre développement Java.
<?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>
C'est la classe pojo que l'on peut écrire dans ce service. Ici, nous prenons le paiement comme exemple, nous suggérons donc d'abord un tableau de paiement dans les données. L'instruction SQL est la suivante
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;
Nous ajoutons des données à la table et l'instruction SQL est la suivante :
insert into `payment`(`id`,`serial`) values (1,'百度'),(2,'alibaba'),(3,'京东'),(4,'头条');
Après avoir créé la table et ajouté des données, nous créerons une nouvelle classe d'entité correspondante. L'image ci-dessous montre le diagramme de structure du projet :
La classe d'entité correspondant à la table de paiement. Lombok est utilisé ici, et le fichier pom ci-dessus importe les dépendances, mais le plug-in lombok doit être installé, sinon une erreur sera signalée ! Comme indiqué ci-dessous:
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;
}
Pour faciliter la transmission des données et pour séparer les projets front-end et back-end, nous encapsulons les données renvoyées dans une classe d'entité.
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);
}
}
Notre service de classe d'entité stocke principalement les classes d'entité et n'écrit pas de logique métier. Nous pouvons également supprimer le dossier src. À ce stade, nous avons construit avec succès le projet général et le projet de microservice qui fournit des classes d'entités. Étant donné que le projet de service de la classe d'entité doit être appelé par d'autres projets de service, le service de la classe d'entité doit être empaqueté et placé dans une bibliothèque publique locale.
Nous nettoyons d'abord le projet pour nous assurer que la configuration maven du projet actuel réussit.
L'interface suivante apparaît, indiquant qu'il n'y a aucun problème avec l'environnement de configuration maven du projet en cours.
Ensuite, nous commencerons à l'installer et à l'emballer dans la bibliothèque locale. Voici l'interface réussie :
À ce stade, nous pouvons voir que le fichier pom.xml de notre projet général a introduit cloud-api-commons, comme indiqué ci-dessous :
Notre prochain article construira des projets de microservices pour les producteurs et les consommateurs. L'article est mis à jour en permanence, n'hésitez pas à aimer et à suivre !
