首页手记 Java微服务学习入门：从零开始构建你的第一个微服务

Java微服务学习入门：从零开始构建你的第一个微服务

标签：

Java Spring Cloud 微服务

概述

本文介绍了Java微服务学习入门的相关知识，包括微服务架构的基本概念、Java在微服务中的应用、Spring Boot的快速搭建方法以及Docker和Kubernetes的部署技巧。文章详细讲解了如何使用Spring Boot创建第一个Java微服务，并探讨了微服务的通信机制、部署与运维策略。通过实战案例，展示了如何构建一个简单的订单系统，涵盖了微服务的设计、实现和部署。

Java微服务简介

微服务架构概述

微服务架构是一种将单体应用拆分为多个小型服务的架构风格，这些服务之间通过定义明确的接口进行通信。每个微服务负责独立的业务功能，并且能够独立部署。这种架构风格使得应用程序更易于扩展、维护以及部署。微服务架构的一个核心思想是服务的自治，即每个服务都有独立的数据库和启动流程，并且可以独立发布、扩展和替换。微服务架构的优势包括但不限于：

可扩展性：每个服务都可以独立扩展，可以更好地应对访问量的波动。
维护性：每个服务的维护和升级都不需要改动其他服务，提高了维护的效率。
故障隔离：即使某个服务出现故障，也不会影响到其他服务。

Java在微服务中的应用

Java 是一种广泛使用的编程语言，以其跨平台、垃圾回收和丰富的库支持而受到开发者欢迎。Java 语言本身非常适合开发微服务，因为它拥有大量的框架和工具，可以快速创建和部署微服务。Spring Boot 是一个基于 Spring 框架的轻量级开发框架，它简化了微服务的搭建过程，提供了快速构建独立的、生产级别的应用的能力。Spring Boot 通过约定优于配置的原则，使得开发者只需要关心业务逻辑，而无需处理大量配置细节。

示例代码：Spring Boot 启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

微服务与传统单体架构的对比

传统单体架构

传统单体架构指的是将应用的所有功能打包在一个单个服务中，这个服务通常包含所有功能模块，如用户界面、业务逻辑、数据库访问层等。这种架构的优点是开发简单、部署方便，适合初期开发阶段。但随着应用规模的扩大，单体架构的缺点逐渐显现：

难以扩展：单体应用的扩展往往意味着整体的重启，对于大型应用来说，这是一项耗时耗力的工作。
复杂度高：随着代码的增多，代码库的维护变得越来越复杂，代码改动的风险也相应增加。
部署缓慢：每次更新都需要重新部署整个应用，即使变更涉及的范围很小。

微服务架构

对比之下，微服务架构在扩展、维护、部署等方面具有明显优势，但也带来了一定的复杂性：

服务拆分：需要将应用拆分为多个独立的服务，这需要对应用进行详细的分析和设计。
服务通信：各个服务之间的通信变得更为复杂，需要设计合适的接口和协议。
部署管理：每个服务的部署和维护都需要进行单独管理，增加了运维的复杂性。

最终，微服务架构更适合大型复杂应用，能够更好地适应业务的变化和发展。但如何平衡好微服务的复杂性与带来的好处，是对开发者的一大挑战。

单体架构的例子代码

@RestController
@RequestMapping("/users")
public class UserController {
    private List<User> users = new ArrayList<>();

    @GetMapping
    public ResponseEntity<List<User>> getUsers() {
        return ResponseEntity.ok(users);
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        users.add(user);
        return ResponseEntity.ok(user);
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        User user = users.stream().filter(u -> u.getId().equals(id)).findFirst().orElse(null);
        return ResponseEntity.ok(user);
    }
}

必要工具和环境搭建

搭建Java开发环境

搭建 Java 开发环境需要安装 JDK（Java Development Kit）和 IDE（Integrated Development Environment）。JDK 提供了 Java 编译器、运行环境等工具，而 IDE 则是开发者进行编码、调试和测试的平台。通常推荐使用 IntelliJ IDEA 或 Eclipse 进行 Java 开发。

安装 JDK

首先，从 Oracle 官网下载最新版本的 JDK，然后按照说明进行安装。安装完成后，需要设置环境变量 JAVA_HOME 并将其添加到 PATH 中。例如：

$ export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
$ export PATH=$JAVA_HOME/bin:$PATH

安装 IDE

安装完成后，可以使用 IntelliJ IDEA 或 Eclipse 开始编码。以下是 IntelliJ IDEA 安装的简要步骤：

访问 IntelliJ IDEA 官网下载页面。
根据操作系统的不同，下载对应版本。
执行安装文件，按照向导完成安装。
启动 IntelliJ IDEA，创建新项目，选择 Java 作为项目类型。

检查 JDK 安装

可以通过命令检查 JDK 是否安装成功：

$ java -version

此命令输出 JDK 版本信息，如：

java version "11.0.12" 2021-07-20 LTS
Java(TM) SE Runtime Environment (build 11.0.12+7-LTS)
Java HotSpot(TM) 64-Bit Server VM (build 11.0.12+7-LTS, mixed mode, sharing)

安装并配置Spring Boot

Spring Boot 是一个基于 Spring 框架的简化微服务开发框架，它能够帮助开发者快速搭建独立的、生产级别的应用。

安装 Spring Boot

在 IntelliJ IDEA 中，通过 Maven 或 Gradle 插件来安装和配置 Spring Boot。以下是使用 Maven 插件安装 Spring Boot 的步骤：

新建一个 Maven 项目。
在 pom.xml 文件中，添加 Spring Boot 的依赖。例如，添加 Spring Web 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.3.4.RELEASE</version>
</dependency>

在主类中添加 @SpringBootApplication 注解，并实现 main 方法。

示例代码：Spring Boot 主类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

启动 Spring Boot

使用 mvn spring-boot:run 命令启动 Spring Boot 应用。

$ mvn spring-boot:run

使用Docker和Kubernetes管理微服务

Docker 和 Kubernetes 是容器化和编排技术的核心工具，能够帮助开发者轻松地部署和管理微服务应用。

Docker

Docker 提供了一种标准化的方式来打包和运行应用，使得应用可以在不同的环境中保持一致的行为。以下是使用 Docker 的基本步骤：

安装 Docker：从 Docker 官网下载安装包，按照说明安装。
编写 Dockerfile：创建一个 Dockerfile 文件以定义镜像的构建过程。例如：

FROM openjdk:11-jre-slim
ADD target/myapp.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

构建 Docker 镜像：运行 docker build 命令构建镜像。

$ docker build -t myapp:1.0 .

运行 Docker 容器：使用 docker run 命令启动容器。

$ docker run -p 8080:8080 myapp:1.0

Kubernetes

Kubernetes 是一个开源的容器编排系统，负责管理容器化应用的部署、扩展和维护。以下是使用 Kubernetes 的基本步骤：

安装 Kubernetes：在本地使用 Minikube，或在云上使用托管服务。
编写 Kubernetes 配置文件：创建 deployment.yaml 和 service.yaml 文件，定义应用部署和集群服务。例如：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: myapp
spec:
  selector:
    app: myapp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

部署应用：使用 kubectl 命令创建应用实例。

$ kubectl apply -f deployment.yaml
$ kubectl apply -f service.yaml

第一个Java微服务的创建

使用Spring Boot快速搭建项目

Spring Boot 提供了快速搭建 Java 微服务的能力，能够帮助开发者专注于业务逻辑。以下是使用 Spring Boot 创建第一个微服务的步骤：

创建项目

创建 Spring Boot 项目：使用 Spring Initializr（可以在线访问 https://start.spring.io）或 Spring Boot CLI 工具创建新项目。
添加依赖：选择 Spring Web 依赖，以便创建 RESTful API。

示例代码：创建一个简单的 REST API

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, world!";
    }
}

运行项目

使用 spring-boot:run 命令运行项目。

$ mvn spring-boot:run

定义RESTful API接口

RESTful API 设计的核心原则是资源和行为分离。资源由 URL 识别，行为则由 HTTP 方法表示。以下是定义 RESTful API 的几个核心操作：

示例代码：定义 RESTful API 接口

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {
    private static List<User> users = new ArrayList<>();

    @GetMapping
    public ResponseEntity<List<User>> getUsers() {
        return ResponseEntity.ok(users);
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        users.add(user);
        return ResponseEntity.ok(user);
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        User user = users.stream().filter(u -> u.getId().equals(id)).findFirst().orElse(null);
        return ResponseEntity.ok(user);
    }
}

完整的项目结构和代码

package com.example.order;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

项目打包与部署

打包项目

使用 Maven 或 Gradle 打包项目为可执行的 JAR 文件。

$ mvn package

部署项目

使用 Docker 或 Kubernetes 部署项目。

$ docker build -t myapp:1.0 .
$ docker run -p 8080:8080 myapp:1.0

微服务通信机制

REST API调用

REST（Representational State Transfer）是一种设计风格，用于构建 Web 服务。REST API 的核心是资源和 HTTP 方法。资源由 URL 识别，行为则由 HTTP 方法表示。REST API 的主要特点包括无状态性、幂等性和缓存等。

示例代码：客户端调用 REST API

import org.springframework.web.client.RestTemplate;

public class RestClient {
    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();
        String result = restTemplate.getForObject("http://localhost:8080/api/users", String.class);
        System.out.println(result);
    }
}

RPC调用

RPC（Remote Procedure Call）是一种通信协议，用于在不同进程或不同主机之间调用过程。RPC 的主要特点包括客户端和服务器端的透明调用过程、异步调用等。常见的 RPC 框架包括 gRPC、Apache Thrift 等。

示例代码：使用 gRPC 定义服务

syntax = "proto3";
option java_multiple_files = true;
option java_package = "com.example.helloworld";
option java_outer_classname = "HelloWorldProto";

service Greeter {
  rpc sayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

示例代码：使用 gRPC 实现客户端和服务端

public class HelloWorldGrpc {
    public static void main(String[] args) {
        ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 50051)
                .usePlaintext()
                .build();
        GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channel);
        HelloRequest request = HelloRequest.newBuilder().setName("world").build();
        HelloReply response = stub.sayHello(request);
        System.out.println(response.getMessage());
        channel.shutdown();
    }
}

使用消息队列实现异步通信

消息队列是一种异步通信机制，用于解耦应用的不同组件。常见的消息队列系统包括 RabbitMQ、Kafka 等。消息队列的主要特点包括消息分发、消息持久化、消息过滤等。

示例代码：使用 RabbitMQ 发布消息

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class EmitLog {
    private final static String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            String message = "Hello, world!";
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

示例代码：使用 RabbitMQ 订阅消息

import com.rabbitmq.client.*;

public class ReceiveLogs {
    private final static String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            String queue = channel.queueDeclare().getQueue();
            channel.queueBind(queue, EXCHANGE_NAME, "");
            System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            };
            channel.basicConsume(queue, true, deliverCallback, consumerTag -> {});
        }
    }
}

微服务的部署与运维

使用Docker容器化微服务

Docker 提供了一种标准化的方式来打包和运行应用，使得应用可以在不同的环境中保持一致的行为。以下是使用 Docker 的基本步骤：

编写 Dockerfile：定义镜像的构建过程。
构建 Docker 镜像：使用 docker build 命令构建镜像。
运行 Docker 容器：使用 docker run 命令启动容器。

使用Kubernetes管理微服务集群

Kubernetes 是一个开源的容器编排系统，负责管理容器化应用的部署、扩展和维护。以下是使用 Kubernetes 的基本步骤：

编写 Kubernetes 配置文件：定义应用部署和集群服务。
部署应用：使用 kubectl 命令创建应用实例。

监控与日志管理

监控和日志管理是微服务运维中不可或缺的部分，可以使用 Prometheus、Grafana 和 ELK（Elasticsearch, Logstash, Kibana）等工具。

使用 Prometheus 监控

Prometheus 是一个开源的监控系统和时间序列数据库。以下是使用 Prometheus 的基本步骤：

安装 Prometheus：下载并安装 Prometheus。
编写配置文件：定义监控目标。
启动 Prometheus：运行 Prometheus 服务。

使用 ELK 日志管理

ELK 是一套开源的日志管理工具，包括 Elasticsearch、Logstash 和 Kibana。以下是使用 ELK 的基本步骤：

安装 ELK：分别安装 Elasticsearch、Logstash 和 Kibana。
配置 Logstash：定义日志采集和处理规则。
配置 Kibana：创建可视化面板和仪表板。

实战案例：构建简单的订单系统

分析订单系统的需求和架构

订单系统通常包括用户、订单、商品等模块。每个模块都可以被设计为一个独立的服务，从而实现微服务架构的优点。订单系统的架构可以设计为：

用户服务：处理用户管理，如注册、登录等。
商品服务：处理商品信息，如查询、搜索等。
订单服务：处理订单管理，如创建订单、修改订单等。

分解功能模块并实现

用户服务

用户服务需要处理用户管理相关的功能，如注册、登录、获取用户信息等。以下是用户服务的实现：

创建一个新的 Spring Boot 项目。
定义用户实体类 User。
创建用户控制器 UserController，实现用户管理的 REST API。

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/users")
public class UserController {
    private static List<User> users = new ArrayList<>();

    @GetMapping
    public ResponseEntity<List<User>> getUsers() {
        return ResponseEntity.ok(users);
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        users.add(user);
        return ResponseEntity.ok(user);
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        User user = users.stream().filter(u -> u.getId().equals(id)).findFirst().orElse(null);
        return ResponseEntity.ok(user);
    }
}

商品服务

商品服务需要处理商品信息相关的功能，如查询、搜索等。以下是商品服务的实现：

创建一个新的 Spring Boot 项目。
定义商品实体类 Product。
创建商品控制器 ProductController，实现商品管理的 REST API。

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/products")
public class ProductController {
    private static List<Product> products = new ArrayList<>();

    @GetMapping
    public ResponseEntity<List<Product>> getProducts() {
        return ResponseEntity.ok(products);
    }

    @PostMapping
    public ResponseEntity<Product> createProduct(@RequestBody Product product) {
        products.add(product);
        return ResponseEntity.ok(product);
    }

    @GetMapping("/{id}")
    public ResponseEntity<Product> getProductById(@PathVariable Long id) {
        Product product = products.stream().filter(p -> p.getId().equals(id)).findFirst().orElse(null);
        return ResponseEntity.ok(product);
    }
}

订单服务

订单服务需要处理订单管理相关的功能，如创建订单、修改订单等。以下是订单服务的实现：

创建一个新的 Spring Boot 项目。
定义订单实体类 Order。
创建订单控制器 OrderController，实现订单管理的 REST API。

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private static List<Order> orders = new ArrayList<>();

    @GetMapping
    public ResponseEntity<List<Order>> getOrders() {
        return ResponseEntity.ok(orders);
    }

    @PostMapping
    public ResponseEntity<Order> createOrder(@RequestBody Order order) {
        orders.add(order);
        return ResponseEntity.ok(order);
    }

    @GetMapping("/{id}")
    public ResponseEntity<Order> getOrderById(@PathVariable Long id) {
        Order order = orders.stream().filter(o -> o.getId().equals(id)).findFirst().orElse(null);
        return ResponseEntity.ok(order);
    }
}

集成测试与部署

集成测试

集成测试是为了验证不同服务之间的协作是否正常。可以使用 JUnit、Spring Test 等工具进行集成测试。

创建测试类：定义测试用例和测试方法。
编写测试方法：调用服务的 REST API，验证返回结果。

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest(UserController.class)
public class UserControllerTest {
    @Autowired
    private MockMvc mockMvc;

    @Test
    public void shouldReturnDefaultMessage() throws Exception {
        mockMvc.perform(get("/api/users"))
               .andExpect(status().isOk());
    }
}

部署

部署微服务应用可以通过 Docker 和 Kubernetes 实现。

编写 Dockerfile：定义镜像的构建过程。
构建 Docker 镜像：使用 docker build 命令构建镜像。
部署应用：使用 kubectl 命令创建应用实例。

FROM openjdk:11-jre-slim
ADD target/myapp.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: user-service:1.0
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

狐的传说

手记
篇

粉丝

88

获赞与收藏

555

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19367 315

Java 并发原理入门教程

26个小节 39106 568

Java 入门教程

50个小节 342495 3164

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空