介绍
在本指南中，我们将逐步介绍如何使用 spring boot 创建一个简单而全面的微服务系统。我们将介绍微服务的基础知识，设置所需的环境，并实现两个微服务：orderservice 和 inventoryservice。此外，我们将使用 eureka 和 api 网关集成服务发现来管理服务之间的路由。
什么是微服务？
微服务是一种软件架构风格，其中应用程序被构建为协同工作的小型独立服务的集合。每个服务都是独立的，并通过明确定义的 api 与其他服务进行通信，使系统更加灵活、可扩展且更易于管理。
系统架构
我们系统的架构将由两个微服务组成：orderservice 和 inventoryservice。 orderservice 将使用关系数据库 (mysql) 来存储订单详细信息，而 inventoryservice 将使用 nosql 数据库 (mongodb) 来管理库存数据。我们还将使用 eureka 实现服务发现，并使用 api 网关来路由请求。
项目设置
在开始之前，请确保您已安装以下工具：
- ide：intellij idea（首选）或 eclipse
- jdk：版本 17 或更高版本
- 构建工具：maven
- 数据库：mysql 和 mongodb
微服务一：订单服务
第 1 步：初始化项目
- 转到 spring initializr。
- 填写项目详情：
- 项目：maven 项目
- 语言：java
- spring boot：2.5.7（或兼容版本）
- 群组：com.ordersystem
- 神器：订单服务
- 名称：订单服务
- 包名: com.ordersystem.orderservice
- 包装：罐装
- java：17
- 添加以下依赖：
- 春天网
- spring 数据 jpa
- mysql 驱动程序
- 龙目岛
- 点击生成下载项目。解压下载的 zip 文件并在 ide 中打开它。
第 2 步：配置应用程序
打开 src/main/resources 中的 application.properties 文件，添加以下配置：
spring.datasource.url=jdbc:mysql://localhost:3306/orderservice spring.datasource.username=root spring.datasource.password=yourpassword spring.datasource.driver-class-name=com.mysql.cj.jdbc.driver spring.jpa.hibernate.ddl-auto=update spring.jpa.show-sql=true spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.mysql8dialect server.port=8081
第 3 步：实施模型
在src/main/java/com/ordersystem/orderservice/model/order.java中创建order实体类：
package com.ordersystem.orderservice.model;
import lombok.allargsconstructor;
import lombok.data;
import lombok.noargsconstructor;
import javax.persistence.*;
@data
@allargsconstructor
@noargsconstructor
@entity
@table(name = "orders")
public class order {
@id
@generatedvalue(strategy = generationtype.identity)
private long id;
private string product;
private int quantity;
private double price;
}
第 4 步：创建存储库
在 src/main/java/com/ordersystem/orderservice/repository/orderrepository.java 中创建 orderrepository 接口：
package com.ordersystem.orderservice.repository;
import com.ordersystem.orderservice.model.order;
import org.springframework.data.jpa.repository.jparepository;
public interface orderrepository extends jparepository<order, long> {
}
第 5 步：实施服务
在 src/main/java/com/ordersystem/orderservice/service/orderservice.java 中创建 orderservice 类：
package com.ordersystem.orderservice.service;
import com.ordersystem.orderservice.model.order;
import com.ordersystem.orderservice.repository.orderrepository;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;
import java.util.list;
@service
public class orderservice {
@autowired
private orderrepository orderrepository;
public list<order> getallorders() {
return orderrepository.findall();
}
public order getorderbyid(long id) {
return orderrepository.findbyid(id).orelse(null);
}
public order createorder(order order) {
return orderrepository.save(order);
}
public void deleteorder(long id) {
orderrepository.deletebyid(id);
}
}
第 6 步：创建控制器
在 src/main/java/com/ordersystem/orderservice/controller/ordercontroller.java 中创建 ordercontroller 类：
package com.ordersystem.orderservice.controller;
import com.ordersystem.orderservice.model.order;
import com.ordersystem.orderservice.service.orderservice;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.*;
import java.util.list;
@restcontroller
@requestmapping("/api/orders")
public class ordercontroller {
@autowired
private orderservice orderservice;
@getmapping
public list<order> getallorders() {
return orderservice.getallorders();
}
@getmapping("/{id}")
public order getorderbyid(@pathvariable long id) {
return orderservice.getorderbyid(id);
}
@postmapping
public order createorder(@requestbody order order) {
return orderservice.createorder(order);
}
@deletemapping("/{id}")
public void deleteorder(@pathvariable long id) {
orderservice.deleteorder(id);
}
}
微服务2：库存服务
第 1 步：初始化项目
- 转到 spring initializr。
- 填写项目详情：
- 项目：maven 项目
- 语言：java
- spring boot：2.5.7（或兼容版本）
- 群组：com.ordersystem
- artifact：库存服务
- 名称：库存服务
- 包名: com.ordersystem.inventoryservice
- 包装：罐装
- java：17
- 添加以下依赖：
- 春天网
- spring data mongodb
- 龙目岛
- 点击生成下载项目。解压下载的 zip 文件并在 ide 中打开它。
第 2 步：配置应用程序
打开 src/main/resources 中的 application.properties 文件，添加以下配置：
spring.data.mongodb.uri=mongodb://localhost:27017/inventoryservice server.port=8082
第 3 步：实施模型
在src/main/java/com/ordersystem/inventoryservice/model/inventoryitem.java中创建inventoryitem实体类：
package com.ordersystem.inventoryservice.model;
import lombok.allargsconstructor;
import lombok.data;
import lombok.noargsconstructor;
import org.springframework.data.annotation.id;
import org.springframework.data.mongodb.core.mapping.document;
@data
@allargsconstructor
@noargsconstructor
@document(collection = "inventory")
public class inventoryitem {
@id
private string id;
private string product;
private int quantity;
}
第 4 步：创建存储库
在 src/main/java/com/ordersystem/inventoryservice/repository/inventoryrepository.java 中创建 inventoryrepository 接口：
package com.ordersystem.inventoryservice.repository;
import com.ordersystem.inventoryservice.model.inventoryitem;
import org.springframework.data.mongodb.repository.mongorepository;
public interface inventoryrepository extends mongorepository<inventoryitem, string> {
}
第 5 步：实施服务
在 src/main/java/com/ordersystem/inventoryservice/service/inventoryservice.java 中创建 inventoryservice 类：
package com.ordersystem.inventoryservice.service;
import com.ordersystem.inventoryservice.model.inventoryitem;
import com.ordersystem.inventoryservice.repository.inventoryrepository;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;
import java.util.list;
@service
public class inventoryservice {
@autowired
private inventoryrepository inventoryrepository;
public list<inventoryitem> getallitems() {
return inventoryrepository.findall();
}
public inventoryitem getitembyid(string id) {
return inventoryrepository.findbyid(id).orelse(null);
}
public inventoryitem createitem(inventoryitem item) {
return inventoryrepository.save(item);
}
public void deleteitem(string id) {
inventoryrepository.deletebyid(id);
}
}
第 6 步：创建控制器
在 src/main/java/com/ordersystem/inventoryservice/controller/inventorycontroller.java 中创建 inventorycontroller 类：
package com.ordersystem.inventoryservice.controller;
import com.ordersystem.inventoryservice.model.inventoryitem;
import com.ordersystem.inventoryservice.service.inventoryservice;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.*;
import java.util.list;
@restcontroller
@requestmapping("/api/inventory")
public class inventorycontroller {
@autowired
private inventoryservice inventoryservice;
@getmapping
public list<inventoryitem> getallitems() {
return inventoryservice.getallitems();
}
@getmapping("/{id}")
public inventoryitem getitembyid(@pathvariable string id) {
return inventoryservice.getitembyid(id);
}
@postmapping
public inventoryitem createitem(@requestbody inventoryitem item) {
return inventoryservice.createitem(item);
}
@deletemapping("/{id}")
public void deleteitem(@pathvariable string id) {
inventoryservice.delete
item(id);
}
}
使用 eureka 进行服务发现
第1步：初始化eureka服务器
- 转到 spring initializr。
- 填写项目详情：
- 项目：maven 项目
- 语言：java
- spring boot：2.5.7（或兼容版本）
- 群组：com.ordersystem
- 神器：尤里卡服务器
- 名称：尤里卡服务器
- 包名: com.ordersystem.eurekaserver
- 包装：罐装
- java：17
- 添加eureka server依赖。
- 点击生成下载项目。解压下载的 zip 文件并在 ide 中打开它。
第2步：配置eureka服务器
打开 src/main/resources 中的 application.properties 文件，添加以下配置：
server.port=8761 eureka.client.register-with-eureka=false eureka.client.fetch-registry=false
第三步：启用eureka服务器
在 src/main/java/com/ordersystem/eurekaserver/eurekaserverapplication.java 中的主应用程序类上添加 @enableeurekaserver 注释：
package com.ordersystem.eurekaserver;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.cloud.netflix.eureka.server.enableeurekaserver;
@springbootapplication
@enableeurekaserver
public class eurekaserverapplication {
public static void main(string[] args) {
springapplication.run(eurekaserverapplication.class, args);
}
}
将服务与 eureka 集成
为 orderservice 和 inventoryservice 添加 eureka 客户端依赖：
<dependency>
<groupid>org.springframework.cloud</groupid>
<artifactid>spring-cloud-starter-netflix-eureka-client</artifactid>
</dependency>
在application.properties文件中添加eureka客户端配置：
订购服务：
eureka.client.service-url.defaultzone=http://localhost:8761/eureka/ spring.application.name=order-service
库存服务：
eureka.client.service-url.defaultzone=http://localhost:8761/eureka/ spring.application.name=inventory-service
api网关
步骤一：初始化api网关
- 转到 spring initializr。
- 填写项目详情：
- 项目：maven 项目
- 语言：java
- spring boot：2.5.7（或兼容版本）
- 群组：com.ordersystem
- 神器：api 网关
- 名称：api网关
- 包名: com.ordersystem.apigateway
- 包装：罐装
- java：17
- 添加 gateway 和 eureka discovery client 依赖项。
- 点击生成下载项目。解压下载的 zip 文件并在 ide 中打开它。
步骤2：配置api网关
打开 src/main/resources 中的 application.yml 文件，添加以下配置：
server:
port: 8080
spring:
application:
name: api-gateway
cloud:
gateway:
routes:
- id: order-service
uri: lb://order-service
predicates:
- path=/api/orders/**
- id: inventory-service
uri: lb://inventory-service
predicates:
- path=/api/inventory/**
eureka:
client:
service-url:
defaultzone: http://localhost:8761/eureka/
步骤 3：启用发现客户端
在 src/main/java/com/ordersystem/apigateway/apigatewayapplication.java 中的主应用程序类上使用 @enablediscoveryclient 进行注释：
package com.ordersystem.apigateway;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@SpringBootApplication
@EnableDiscoveryClient
public class ApiGatewayApplication {
public static void main(String[] args) {
SpringApplication.run(ApiGatewayApplication.class, args);
}
}
测试微服务
- 启动 eureka server：运行 eureka server 应用程序。
- 启动订单服务：运行订单服务应用程序。
- 启动库存服务：运行库存服务应用程序。
- 启动 api gateway：运行 api gateway 应用程序。
使用 postman 或任何其他 api 客户端通过 api 网关测试端点：
- 创建订单：post http://localhost:8080/api/orders
- 获取订单：get http://localhost:8080/api/orders
- 创建库存商品：post http://localhost:8080/api/inventory
- 获取库存物品：get http://localhost:8080/api/inventory
结论
在本指南中，我们使用 spring boot 构建了一个简单的微服务系统。我们创建了两个微服务（orderservice 和 inventoryservice），将服务发现与 eureka 集成，并设置 api 网关用于路由请求。这种架构允许可扩展且可维护的微服务，可以在未来轻松扩展。
