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

PHPz

发布时间：2024-08-13 08:53:13

643人浏览过

来源于dev.to

转载

使用 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 步：初始化项目

转到 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 {
}

第 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 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 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 接口：

6pen Art

AI绘画生成

下载

package com.ordersystem.inventoryservice.repository;

import com.ordersystem.inventoryservice.model.inventoryitem;
import org.springframework.data.mongodb.repository.mongorepository;

public interface inventoryrepository extends mongorepository {
}

第 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 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 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 客户端依赖：


    org.springframework.cloud
    spring-cloud-starter-netflix-eureka-client

在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);
    }
}