Java微服务学习入门教程-原创手记-慕课网

概述

本文介绍了Java微服务学习的相关内容，包括Java微服务的优势、常见框架和开发环境的搭建。文章详细讲解了如何使用Spring Boot创建第一个微服务，并深入探讨了微服务间通信的方法。此外，还涉及了微服务的部署与监控技术。

Java微服务简介

微服务的概念

微服务是一种架构风格，它将一个大型的复杂应用拆分成一组小型、可独立部署的服务。每个服务负责单一功能并运行在独立的进程中。这些服务之间通过定义良好的API接口进行通信。微服务架构的主要目标是提高应用的可维护性、灵活性和可扩展性。

Java微服务的优势

Java微服务架构利用Java语言及其强大的生态系统，为开发者提供了许多优势：

跨平台性：Java具有跨平台的特性，可以在各种操作系统和硬件平台上运行，包括Windows、Linux和Mac OS等。
丰富的库和框架：Java拥有庞大的开源库和框架，如Spring Boot、Spring Cloud等，这些工具大大简化了微服务的开发和部署。
强大的企业级支持：Java在企业应用开发领域占有重要地位，支持多线程、持久化、事务处理等功能，适用于各种复杂的业务场景。
成熟的监控和运维工具：Java社区提供了多种成熟的监控和运维工具，如Prometheus、Grafana等，方便开发者监控微服务的运行状态。

Java微服务的常见框架介绍

Java微服务开发中最常用的框架主要包括Spring Boot和Spring Cloud。Spring Boot简化了Spring应用的初始搭建以及开发过程，使得开发者能够快速搭建一个独立的、生产级别的应用。Spring Cloud则提供了多种工具，帮助开发者构建分布式系统和服务治理框架，如服务发现、负载均衡、配置中心等。

Java微服务开发环境搭建

开发工具选择（如IDEA）

开发Java微服务时，选择合适的开发工具至关重要。IntelliJ IDEA是一款非常流行的IDE，具有强大的代码编辑、调试、重构等功能，特别适合开发Spring Boot等Java应用。以下是如何安装IntelliJ IDEA的步骤：

访问JetBrains官网下载IntelliJ IDEA。
根据操作系统选择相应版本进行安装。

安装完成后，打开IDEA，选择导入或创建一个新的Spring Boot项目。

Java版本选择

在选择Java版本时，建议使用Java 11或更高版本，因为这些版本提供了更好的性能、更丰富的语言特性，以及对现代开发环境更好的支持。可以通过以下命令检查当前Java环境：

java -version

如果需要安装或更新Java环境，可以访问Oracle官网或OpenJDK官网下载安装包。

Maven或Gradle构建工具的配置

为了构建和管理Java项目，通常会使用Maven或Gradle。以下是配置Maven的基本步骤：

下载并安装Maven，可以从Maven官网获取安装包。
确保Maven安装目录的bin目录已添加到系统环境变量的PATH中。
创建一个Maven项目，通过命令行或IDEA的Maven插件创建一个pom.xml文件，定义项目的依赖关系和构建配置。

例如，一个简单的pom.xml文件可能如下所示：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>my-service</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.7.1</version>
        </dependency>
    </dependencies>
</project>

集成开发环境的配置

IDEA中配置Maven的方法如下：

打开IDEA，选择File -> Settings（或Preferences在macOS上）。
导航到Build, Execution, Deployment -> Build Tools -> Maven。
确保配置正确，设置Maven安装路径。
安装或更新Maven插件，以获得更好的IDE支持。

使用Spring Boot创建第一个微服务

Spring Boot简介

Spring Boot是Spring框架的一个模块，它简化了Spring应用的初始搭建和开发过程。Spring Boot通过约定优于配置的方式来减少代码量，使得开发者能够快速创建独立的、生产级别的应用。

创建Spring Boot项目

使用IDEA创建一个Spring Boot项目：

打开IDEA，选择File -> New -> Project。
选择Spring Initializr，点击Next。
填写项目信息，如Group、Artifact等。
选择所需技术栈，如Spring Web、Spring Data JPA等。
点击Finish，IDEA将创建一个Spring Boot项目。

添加Spring Boot Starter依赖

在pom.xml文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</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>
</dependencies>

实现一个简单的REST API服务

创建一个简单的REST API服务，如创建一个UserController：

package com.example.demo.controller;

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

import java.util.Arrays;
import java.util.List;

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

    @GetMapping
    public List<User> getUsers() {
        return Arrays.asList(new User("Alice", 30), new User("Bob", 25));
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        // 实现根据ID获取用户逻辑
        return new User("Alice", 30);
    }

    static class User {
        private String name;
        private int age;

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
    }
}

微服务间通信

REST API的基本概念

微服务架构中，服务间通信通常通过REST API实现。REST API定义了一组HTTP方法（如GET、POST、PUT、DELETE）来操作资源。每个资源通过唯一的URL地址访问。

使用Spring Cloud进行服务间通信

Spring Cloud提供了多种工具简化微服务之间的通信，如服务注册与发现、配置中心等。下面以服务发现为例，介绍如何使用Spring Cloud：

添加依赖：

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

配置服务注册中心（Eureka）：

spring.application.name=eureka-server
server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

创建Eureka服务注册中心：

package com.example.eureka;

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

服务注册：

package com.example.demo;

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

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

实现服务发现与服务注册

在application.properties文件中配置服务注册：

spring.application.name=service-provider
server.port=8081
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

然后在主启动类中添加@EnableEurekaClient注解：

package com.example.serviceprovider;

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

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

使用Feign客户端进行远程调用

Feign是一个声明式的Web服务客户端，使用它可以快速实现服务调用。首先添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

启用Feign客户端：

package com.example.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

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

定义Feign客户端：

package com.example.consumer.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(value = "service-provider")
public interface ServiceProviderClient {

    @GetMapping("/users")
    List<User> getUsers();
}

在Controller中使用Feign客户端：

package com.example.consumer.controller;

import com.example.consumer.service.ServiceProviderClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    private ServiceProviderClient serviceProviderClient;

    @GetMapping("/users")
    public List<User> getUsers() {
        return serviceProviderClient.getUsers();
    }
}

微服务部署与监控

Docker和容器化简介

Docker是一种容器化技术，它允许开发者将应用及其依赖打包在一个轻量级、可移植的容器中。容器化使得应用的部署、管理和扩展变得简单且标准化。

使用Docker部署微服务

为了使用Docker部署一个简单的微服务，首先需要创建一个Dockerfile：

FROM openjdk:11-jre-slim
ADD target/my-service.jar /app/my-service.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app/my-service.jar"]

然后构建Docker镜像：

docker build -t my-service:1.0 .

运行Docker容器：

docker run -d -p 8080:8080 --name my-service my-service:1.0

使用Kubernetes部署微服务

Kubernetes是一个开源的容器编排工具，它支持自动化部署、扩展和管理容器化应用。为了使用Kubernetes部署微服务，需要编写一个Kubernetes部署文件（如deployment.yaml）：

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

部署到Kubernetes集群：

kubectl apply -f deployment.yaml

使用Prometheus和Grafana进行监控

Prometheus是一个开源的监控系统和时间序列数据库，Grafana则是一个强大的可视化工具，用于展示Prometheus的数据。为了监控微服务，首先安装并配置Prometheus：

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'node_exporter'
    static_configs:
    - targets: ['localhost:9100']

在微服务中添加Prometheus监控：

import org.springframework.boot.actuate.metrics.annotation.Timed;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MetricsController {

    @GetMapping("/metrics")
    @Timed
    public String metrics() {
        return "metrics";
    }
}

配置Grafana以连接Prometheus，并创建仪表盘展示监控数据。例如，可以创建一个简单的Prometheus配置文件来监控微服务：

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'my-service'
    static_configs:
    - targets: ['localhost:8080']

同时，可以使用Grafana创建一个简单的仪表盘来展示Prometheus的监控数据，包括CPU使用率、内存使用情况等。

实战案例：构建一个简单的电商系统

项目需求分析

假设要构建一个简单的电商系统，包括以下主要功能：

用户管理：用户注册、登录、修改个人信息等。
商品管理：商品分类、商品列表、商品详情等。
订单管理：下单、查询订单、取消订单等。

系统架构设计

采用微服务架构，将电商系统分解为多个独立的服务，每个服务负责单一功能：

User Service: 负责用户相关操作，如注册、登录等。
Product Service: 负责商品信息的管理，如商品分类、商品列表等。
Order Service: 负责订单相关操作，如下单、查询订单等。

各服务模块实现

用户服务（User Service）

创建一个UserServiceApplication类作为项目入口：

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

定义User实体类：

package com.example.userservice.model;

public class User {
    private Long id;
    private String username;
    private String password;

    // Getters and Setters
}

实现用户相关的接口和控制器：

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

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.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

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

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

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

    public User updateUser(Long id, User user) {
        User existingUser = userRepository.findById(id).orElse(null);
        if (existingUser != null) {
            existingUser.setUsername(user.getUsername());
            existingUser.setPassword(user.getPassword());
            return userRepository.save(existingUser);
        }
        return null;
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

package com.example.userservice.controller;

import com.example.userservice.model.User;
import com.example.userservice.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public List<User> getUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @PostMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.updateUser(id, user);
    }

    @PostMapping("/users/{id}/delete")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

商品服务（Product Service）

创建一个ProductServiceApplication类作为项目入口：

package com.example.productservice;

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

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

定义Product实体类：

package com.example.productservice.model;

public class Product {
    private Long id;
    private String name;
    private String description;

    // Getters and Setters
}

实现商品相关的接口和控制器：

package com.example.productservice.repository;

import com.example.productservice.model.Product;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}

package com.example.productservice.service;

import com.example.productservice.model.Product;
import com.example.productservice.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ProductService {

    @Autowired
    private ProductRepository productRepository;

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    public Product getProductById(Long id) {
        return productRepository.findById(id).orElse(null);
    }

    public Product createProduct(Product product) {
        return productRepository.save(product);
    }

    public Product updateProduct(Long id, Product product) {
        Product existingProduct = productRepository.findById(id).orElse(null);
        if (existingProduct != null) {
            existingProduct.setName(product.getName());
            existingProduct.setDescription(product.getDescription());
            return productRepository.save(existingProduct);
        }
        return null;
    }

    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }
}

package com.example.productservice.controller;

import com.example.productservice.model.Product;
import com.example.productservice.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class ProductController {

    @Autowired
    private ProductService productService;

    @GetMapping("/products")
    public List<Product> getProducts() {
        return productService.getAllProducts();
    }

    @GetMapping("/products/{id}")
    public Product getProduct(@PathVariable Long id) {
        return productService.getProductById(id);
    }

    @PostMapping("/products")
    public Product createProduct(@RequestBody Product product) {
        return productService.createProduct(product);
    }

    @PostMapping("/products/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
        return productService.updateProduct(id, product);
    }

    @PostMapping("/products/{id}/delete")
    public void deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
    }
}

订单服务（Order Service）

创建一个OrderServiceApplication类作为项目入口：

package com.example.orderservice;

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

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

定义Order实体类：

package com.example.orderservice.model;

public class Order {
    private Long id;
    private Long userId;
    private Long productId;
    private int quantity;
    private double totalPrice;

    // Getters and Setters
}

实现订单相关的接口和控制器：

package com.example.orderservice.repository;

import com.example.orderservice.model.Order;
import org.springframework.data.jpa.repository.JpaRepository;

public interface OrderRepository extends JpaRepository<Order, Long> {
}

package com.example.orderservice.service;

import com.example.orderservice.model.Order;
import com.example.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 Order updateOrder(Long id, Order order) {
        Order existingOrder = orderRepository.findById(id).orElse(null);
        if (existingOrder != null) {
            existingOrder.setUserId(order.getUserId());
            existingOrder.setProductId(order.getProductId());
            existingOrder.setQuantity(order.getQuantity());
            existingOrder.setTotalPrice(order.getTotalPrice());
            return orderRepository.save(existingOrder);
        }
        return null;
    }

    public void deleteOrder(Long id) {
        orderRepository.deleteById(id);
    }
}

package com.example.orderservice.controller;

import com.example.orderservice.model.Order;
import com.example.orderservice.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class OrderController {

    @Autowired
    private OrderService orderService;

    @GetMapping("/orders")
    public List<Order> getOrders() {
        return orderService.getAllOrders();
    }

    @GetMapping("/orders/{id}")
    public Order getOrder(@PathVariable Long id) {
        return orderService.getOrderById(id);
    }

    @PostMapping("/orders")
    public Order createOrder(@RequestBody Order order) {
        return orderService.createOrder(order);
    }

    @PostMapping("/orders/{id}")
    public Order updateOrder(@PathVariable Long id, @RequestBody Order order) {
        return orderService.updateOrder(id, order);
    }

    @PostMapping("/orders/{id}/delete")
    public void deleteOrder(@PathVariable Long id) {
        orderService.deleteOrder(id);
    }
}

系统集成与测试

在完成各个服务模块的开发后，需要进行集成测试确保各个服务能够正常通信。可以使用JUnit和Mockito编写单元测试：

package com.example.userservice;

import com.example.userservice.model.User;
import com.example.userservice.repository.UserRepository;
import com.example.userservice.service.UserService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.Arrays;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    public void testGetAllUsers() {
        User user1 = new User(1L, "user1", "pass1");
        User user2 = new User(2L, "user2", "pass2");
        when(userRepository.findAll()).thenReturn(Arrays.asList(user1, user2));

        List<User> users = userService.getAllUsers();

        assertEquals(2, users.size());
        assertEquals("user1", users.get(0).getUsername());
        assertEquals("user2", users.get(1).getUsername());
    }
}

完成单元测试后，可以使用Docker和Kubernetes部署整个系统，进行端到端测试。例如，编写测试脚本来验证每个服务之间的通信：

package com.example.integrationtest;

import com.example.productservice.model.Product;
import com.example.productservice.service.ProductService;
import com.example.userservice.model.User;
import com.example.userservice.service.UserService;
import com.example.orderservice.model.Order;
import com.example.orderservice.service.OrderService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class IntegrationTest {

    @Autowired
    private ProductService productService;

    @Autowired
    private UserService userService;

    @Autowired
    private OrderService orderService;

    @Test
    public void testUserProductOrderIntegration() {
        User user = new User(1L, "user1", "pass1");
        user = userService.createUser(user);

        Product product = new Product(1L, "product1", "desc1");
        product = productService.createProduct(product);

        Order order = new Order(1L, user.getId(), product.getId(), 1, 100.0);
        order = orderService.createOrder(order);

        assertEquals(order.getUserId(), user.getId());
        assertEquals(order.getProductId(), product.getId());
        assertEquals(order.getQuantity(), 1);
        assertEquals(order.getTotalPrice(), 100.0);
    }
}

通过以上步骤，我们构建了一个简单的电商系统，实现了用户管理、商品管理和订单管理三大功能，并且每个功能模块都独立部署，可以方便地进行扩展和维护。