使用 Spring Boot 构建您的第一个微服务系统：初学者指南（您的.第一个.微服.初学者.构建...）

介绍

在本指南中，我们将逐步介绍如何使用 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 步：初始化项目

1. 转到 spring initializr。
2. 填写项目详情：
   • 项目：maven 项目
   • 语言：java
   • spring boot：2.5.7（或兼容版本）
   • 群组：com.ordersystem
   • 神器：订单服务
   • 名称：订单服务
   • 包名: com.ordersystem.orderservice
   • 包装：罐装
   • java：17
3. 添加以下依赖：
   • 春天网
   • spring 数据 jpa
   • mysql 驱动程序
   • 龙目岛
4. 点击生成下载项目。解压下载的 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> {
}
</order>

第 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);
    }
}
</order>

第 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);
    }
}
</order>

微服务2：库存服务 第 1 步：初始化项目

1. 转到 spring initializr。
2. 填写项目详情：
   • 项目：maven 项目
   • 语言：java
   • spring boot：2.5.7（或兼容版本）
   • 群组：com.ordersystem
   • artifact：库存服务
   • 名称：库存服务
   • 包名: com.ordersystem.inventoryservice
   • 包装：罐装
   • java：17
3. 添加以下依赖：
   • 春天网
   • spring data mongodb
   • 龙目岛
4. 点击生成下载项目。解压下载的 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> {
}
</inventoryitem>

第 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);
    }
}
</inventoryitem>

第 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);
    }
}
</inventoryitem>

使用 eureka 进行服务发现 第1步：初始化eureka服务器

1. 转到 spring initializr。
2. 填写项目详情：
   • 项目：maven 项目
   • 语言：java
   • spring boot：2.5.7（或兼容版本）
   • 群组：com.ordersystem
   • 神器：尤里卡服务器
   • 名称：尤里卡服务器
   • 包名: com.ordersystem.eurekaserver
   • 包装：罐装
   • java：17
3. 添加eureka server依赖。
4. 点击生成下载项目。解压下载的 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网关

1. 转到 spring initializr。
2. 填写项目详情：
   • 项目：maven 项目
   • 语言：java
   • spring boot：2.5.7（或兼容版本）
   • 群组：com.ordersystem
   • 神器：api 网关
   • 名称：api网关
   • 包名: com.ordersystem.apigateway
   • 包装：罐装
   • java：17
3. 添加 gateway 和 eureka discovery client 依赖项。
4. 点击生成下载项目。解压下载的 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);
    }
}

测试微服务

1. 启动 eureka server：运行 eureka server 应用程序。
2. 启动订单服务：运行订单服务应用程序。
3. 启动库存服务：运行库存服务应用程序。
4. 启动 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 网关用于路由请求。这种架构允许可扩展且可维护的微服务，可以在未来轻松扩展。

以上就是使用 Spring Boot 构建您的第一个微服务系统：初学者指南的详细内容，更多请关注知识资源分享宝库其它相关文章！