常见的微服务架构介绍，包括包含缓存数据库redis，消息队列 RabbitMQ，日志管理ELK，使用docker服务容器，且采用热部署，搭建这个微服务器的安装配置以及部署应用服务，日志监控，消息监控

最新推荐文章于 2025-10-10 01:30:00 发布

原创最新推荐文章于 2025-10-10 01:30:00 发布 · 置顶 · 1.3k 阅读

26 ·

CC 4.0 BY-SA版权

文章标签：

#架构 #缓存 #数据库

java 同时被 2 个专栏收录

50 篇文章

订阅专栏

微服务

26 篇文章

订阅专栏

构建一个完整的微服务架构涉及多个组件和技术栈，下面是一个详细的指南，涵盖常见的微服务架构组件（如 Redis、RabbitMQ、ELK Stack、Docker、热部署等），以及如何配置和部署这些组件。

1. 微服务架构概述

微服务架构将应用程序分解为一组小的、独立的服务，每个服务运行在自己的进程中，并通过轻量级机制（通常是 HTTP API）进行通信。这些服务可以独立部署、扩展和维护。

常见微服务架构组件

服务注册与发现：Eureka、Consul、Zookeeper
配置中心：Spring Cloud Config、Apollo
API 网关：Spring Cloud Gateway、Kong
服务调用：Feign、RestTemplate
熔断器：Hystrix、Resilience4j
缓存数据库：Redis
消息队列：RabbitMQ、Kafka
日志管理：ELK Stack（Elasticsearch, Logstash, Kibana）
容器化：Docker
编排工具：Kubernetes
热部署：Spring Boot DevTools、JRebel

2. 使用的技术栈

编程语言：Java (Spring Boot)
缓存数据库：Redis
消息队列：RabbitMQ
日志管理：ELK Stack (Elasticsearch, Logstash, Kibana)
容器化：Docker
编排工具：Docker Compose (简化部署)
热部署：Spring Boot DevTools

3. 微服务架构示例

假设我们有一个简单的微服务架构，包含以下服务：

User Service：用户管理服务
Order Service：订单管理服务
Product Service：产品管理服务
API Gateway：统一入口

3.1 服务注册与发现

使用 Eureka 作为服务注册与发现中心。

3.1.1 创建 Eureka Server

pom.xml

xml

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

application.yml

yaml

server:
  port: 8761

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://localhost:8761/eureka/

EurekaServerApplication.java

java

package com.example.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);
    }
}

3.2 API Gateway

使用 Spring Cloud Gateway 作为 API 网关。

3.2.1 创建 API Gateway 服务

pom.xml

xml

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

application.yml

yaml

server:
  port: 8080

spring:
  application:
    name: api-gateway
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/users/**
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/orders/**
        - id: product-service
          uri: lb://product-service
          predicates:
            - Path=/products/**
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

ApiGatewayApplication.java

java

package com.example.apigateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class ApiGatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(ApiGatewayApplication.class, args);
    }
}

3.3 User Service

3.3.1 创建 User Service

pom.xml

xml

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

application.yml

yaml

server:
  port: 0

spring:
  application:
    name: user-service
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password:
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

User.java

java

package com.example.userservice.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

UserRepository.java

java

package com.example.userservice.repository;

import com.example.userservice.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

UserController.java

java

package com.example.userservice.controller;

import com.example.userservice.model.User;
import com.example.userservice.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @GetMapping
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }
}

UserServiceApplication.java

java

package com.example.userservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

3.4 Order Service 和 Product Service

Order Service 和 Product Service 的结构与 User Service 类似，只需更改 application.yml 中的服务名称和端口。

Order Service application.yml

yaml

server:
  port: 0

spring:
  application:
    name: order-service
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password:
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

Product Service application.yml

yaml

server:
  port: 0

spring:
  application:
    name: product-service
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password:
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

4. 使用 Redis 作为缓存数据库

4.1 添加 Redis 依赖

在每个服务的 pom.xml 中添加 Redis 依赖：

xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

4.2 配置 Redis

在 application.yml 中配置 Redis 连接：

yaml

spring:
  redis:
    host: localhost
    port: 6379

4.3 使用 Redis 进行缓存

在 User Service 中使用 Redis 进行缓存示例：

UserCacheService.java

java

package com.example.userservice.service;

import com.example.userservice.model.User;
import com.example.userservice.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class UserCacheService {

    @Autowired
    private UserRepository userRepository;

    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

UserServiceApplication.java 启用缓存：

java

package com.example.userservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
@EnableCaching
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

5. 使用 RabbitMQ 作为消息队列

5.1 添加 RabbitMQ 依赖

在每个服务的 pom.xml 中添加 RabbitMQ 依赖：

xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

5.2 配置 RabbitMQ

在 application.yml 中配置 RabbitMQ 连接：

yaml

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest

5.3 使用 RabbitMQ 发送和接收消息

在 Order Service 中发送消息示例：

OrderService.java

java

package com.example.orderservice.service;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    @Autowired
    private AmqpTemplate amqpTemplate;

    public void sendOrder(String order) {
        amqpTemplate.convertAndSend("orderQueue", order);
    }
}

在 User Service 中接收消息示例：

UserReceiver.java

java

package com.example.userservice.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class UserReceiver {

    @RabbitListener(queues = "orderQueue")
    public void receiveMessage(String order) {
        System.out.println("Received order: " + order);
    }
}

6. 使用 ELK Stack 进行日志管理

6.1 安装 ELK Stack

使用 Docker Compose 安装 ELK Stack：

docker-compose.yml

yaml

version: '3'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.10.2
    container_name: elasticsearch
    environment:
      - discovery.type=single-node
    ports:
      - "9200:9200"
      - "9300:9300"

  logstash:
    image: docker.elastic.co/logstash/logstash:7.10.2
    container_name: logstash
    volumes:
      - ./logstash/pipeline:/usr/share/logstash/pipeline/
    ports:
      - "5044:5044"
    depends_on:
      - elasticsearch

  kibana:
    image: docker.elastic.co/kibana/kibana:7.10.2
    container_name: kibana
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch

logstash/pipeline/logstash.conf

conf

input {
  beats {
    port => 5044
  }
}

output {
  elasticsearch {
    hosts => ["http://elasticsearch:9200"]
    index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
  }
}

启动 ELK Stack：

bash

docker-compose up -d

6.2 配置 Spring Boot 应用程序使用 Filebeat

在每个 Spring Boot 应用程序中添加 Filebeat 配置：

filebeat.yml

yaml

filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /var/log/*.log

output.logstash:
  hosts: ["logstash:5044"]

在 Docker Compose 文件中添加 Filebeat 服务：

docker-compose.yml

yaml

version: '3'
services:
  # 其他服务...

  filebeat:
    image: docker.elastic.co/beats/filebeat:7.10.2
    container_name: filebeat
    volumes:
      - ./filebeat/filebeat.yml:/usr/share/filebeat/filebeat.yml
      - /var/log:/var/log
    depends_on:
      - logstash

7. 使用 Docker 容器化服务

7.1 创建 Dockerfile

为每个服务创建 Dockerfile。以 User Service 为例：

Dockerfile

Dockerfile

FROM openjdk:17-jdk-slim
VOLUME /tmp
COPY target/user-service.jar user-service.jar
ENTRYPOINT ["java", "-jar", "/user-service.jar"]

7.2 构建 Docker 镜像

在每个服务目录下构建 Docker 镜像：

bash

mvn clean package
docker build -t user-service .

7.3 使用 Docker Compose 部署服务

创建 docker-compose.yml 文件来定义所有服务：

docker-compose.yml

yaml

version: '3'
services:
  eureka-server:
    image: eureka-server:latest
    ports:
      - "8761:8761"
    networks:
      - microservices-network

  api-gateway:
    image: api-gateway:latest
    ports:
      - "8080:8080"
    networks:
      - microservices-network
    depends_on:
      - eureka-server

  user-service:
    image: user-service:latest
    networks:
      - microservices-network
    depends_on:
      - eureka-server
      - redis
      - rabbitmq

  order-service:
    image: order-service:latest
    networks:
      - microservices-network
    depends_on:
      - eureka-server
      - redis
      - rabbitmq

  product-service:
    image: product-service:latest
    networks:
      - microservices-network
    depends_on:
      - eureka-server
      - redis
      - rabbitmq

  redis:
    image: redis:6.2
    ports:
      - "6379:6379"
    networks:
      - microservices-network

  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "5672:5672"
      - "15672:15672"
    networks:
      - microservices-network

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.10.2
    container_name: elasticsearch
    environment:
      - discovery.type=single-node
    ports:
      - "9200:9200"
      - "9300:9300"
    networks:
      - microservices-network

  logstash:
    image: docker.elastic.co/logstash/logstash:7.10.2
    container_name: logstash
    volumes:
      - ./logstash/pipeline:/usr/share/logstash/pipeline/
    ports:
      - "5044:5044"
    depends_on:
      - elasticsearch
    networks:
      - microservices-network

  kibana:
    image: docker.elastic.co/kibana/kibana:7.10.2
    container_name: kibana
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch
    networks:
      - microservices-network

  filebeat:
    image: docker.elastic.co/beats/filebeat:7.10.2
    container_name: filebeat
    volumes:
      - ./filebeat/filebeat.yml:/usr/share/filebeat/filebeat.yml
      - /var/log:/var/log
    depends_on:
      - logstash
    networks:
      - microservices-network

networks:
  microservices-network:
    driver: bridge

7.4 构建并启动所有服务

构建所有服务的 Docker 镜像：

bash

docker-compose build

启动所有服务：

bash

docker-compose up -d

8. 配置负载均衡

8.1 使用 Nginx 作为负载均衡器

创建一个 Nginx 配置文件来负载均衡 API Gateway 实例。

nginx.conf

nginx

events {
    worker_connections 1024;
}

http {
    upstream api-gateway {
        server api-gateway-1:8080;
        server api-gateway-2:8080;
        # 可以根据需要添加更多 API Gateway 实例
    }

    server {
        listen 80;

        location / {
            proxy_pass http://api-gateway;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }
    }
}

8.2 使用 Docker Compose 启动 Nginx

在 docker-compose.yml 中添加 Nginx 服务：

yaml

version: '3'
services:
  # 其他服务...

  nginx:
    image: nginx:latest
    container_name: nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - api-gateway
    networks:
      - microservices-network

启动所有服务后，Nginx 将会自动将请求分发到多个 API Gateway 实例，实现负载均衡。

9. 日志监控与消息监控

9.1 日志监控

使用 ELK Stack 进行日志管理。通过 Kibana 的可视化界面，可以实时查看和分析日志数据。

9.1.1 查看日志

打开浏览器，访问 http://localhost:5601。
登录 Kibana 后，选择“Discover”选项卡。
选择相应的索引模式（如 filebeat-*），即可查看所有日志。

9.1.2 创建仪表盘

在 Kibana 中选择“Dashboard”选项卡。
点击“Create new dashboard”，然后添加各种图表和可视化组件。
通过这些图表可以监控日志中的错误、警告等信息。

9.2 消息监控

使用 RabbitMQ Management Plugin 监控 RabbitMQ 中的消息队列。

9.2.1 启用 RabbitMQ 管理插件

在 Docker Compose 文件中已经启用了 RabbitMQ 管理插件，可以通过以下命令手动启用：

bash

docker exec -it rabbitmq rabbitmq-plugins enable rabbitmq_management

9.2.2 访问 RabbitMQ 管理界面

打开浏览器，访问 http://localhost:15672。
使用默认的用户名和密码 guest/guest 登录。
在管理界面中可以查看队列状态、消息数量、消费者连接等信息。

10. 热部署配置

热部署允许在不重启应用程序的情况下更新代码。这里我们使用 Spring Boot DevTools 来实现热部署。

10.1 添加 DevTools 依赖

在每个 Spring Boot 应用程序的 pom.xml 中添加 DevTools 依赖：

xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

10.2 配置 IDE 支持

10.2.1 IntelliJ IDEA

打开项目设置，进入“Build, Execution, Deployment” -> “Compiler”。
勾选“Build project automatically”。
按下 Ctrl + Shift + A，输入“Registry”，打开 Registry 设置。
勾选 compiler.automake.allow.when.app.running。

10.2.2 Eclipse

打开 Window -> Preferences -> General -> Workspace。
勾选“Build automatically”。

10.3 测试热部署

修改任意服务中的代码（例如 UserController.java）。
保存修改后，Spring Boot 应用程序会自动重新加载更改的部分。
访问相关接口，验证新代码是否生效。

11. 总结

通过上述步骤，我们构建了一个完整的微服务架构，涵盖了服务注册与发现、API 网关、缓存数据库 Redis、消息队列 RabbitMQ、日志管理 ELK Stack、容器化 Docker、负载均衡 Nginx 以及热部署等功能。这个架构不仅能够满足高并发、分布式系统的开发需求，还提供了强大的监控和运维能力，确保系统的稳定性和可扩展性。