Spring Cloud 环境和工程基本搭建

商品服务：

create database if not exists cloud_product charset utf8mb4;
-- 产品表
DROP TABLE IF EXISTS product_detail;
CREATE TABLE product_detail (
  `id` INT NOT NULL AUTO_INCREMENT COMMENT '产品 id',
  `product_name` varchar(128) NULL COMMENT '产品名称',
  `product_price` BIGINT(20) NOT NULL COMMENT '产品价格',
  `state` TINYINT(4) NULL DEFAULT 0 COMMENT '产品状态 0-有效 1-下架',
  `create_time` DATETIME DEFAULT now(),
  `update_time` DATETIME DEFAULT now(),
  PRIMARY KEY (id)
) ENGINE = INNODB DEFAULT CHARACTER SET = utf8mb4 COMMENT ='产品表';
-- 数据初始化
insert into product_detail (id, product_name, product_price, state)
values (1001, "T 恤", 101, 0), (1002, "短袖", 30, 0), (1003, "短裤", 44, 0), (1004, "卫衣", 58, 0), (1005, "马甲", 98, 0), (1006, "羽绒服", 101, 0), (1007, "冲锋衣", 30, 0), (1008, "袜子", 44, 0), (1009, "鞋子", 58, 0), (10010, "毛衣", 98, 0);

4. 工程搭建

4.1 构建父子工程

4.1.1 创建父工程

1. 创建一个空的 Maven 项目，删除所有代码，只保留 pom.xml。
2. 目录结构：保持标准的 Maven 目录结构。
3. 完善 pom 文件：使用 properties 来进行版本号的统一管理，使用 dependencyManagement 来管理依赖，声明父工程的打包方式为 pom。

<?xml version="1.0" encoding="UTF-8"?>
<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>org.example</groupId>
    <artifactId>spring-cloud-demo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.6</version>
        <relativePath/>
    </parent>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <java.version>17</java.version>
        <mybatis.version>3.0.3</mybatis.version>
        <mysql.version>8.0.33</mysql.version>
        <spring-cloud.version>2022.0.3</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <dependency>
                <groupId>com.mysql</groupId>
                <artifactId>mysql-connector-j</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter-test</artifactId>
                <version>${mybatis.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

DependencyManagement 和 Dependencies：

1. dependencies：将所依赖的 jar 直接加到项目中。子项目也会继承该依赖。
2. dependencyManagement：只是声明依赖，并不实现 Jar 包引入。如果子项目需要用到相关依赖，需要显式声明。如果子项目没有指定具体版本，会从父项目中读取 version。如果子项目中指定了版本号，就会使用子项目中指定的 jar 版本。此外父工程的打包方式应该是 pom，不是 jar，这里需要手动使用 packaging 来声明。

4.1.2 创建子项目 - 订单服务

做如下操作：创建模块并声明项目依赖和项目构建插件。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
    </dependency>
    <!--mybatis-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

4.1.3 创建子项目 - 商品服务

创建模块部分同上，下面声明项目依赖和项目构建插件。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
    </dependency>
    <!--mybatis-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

4.2 完善订单服务

4.2.1 完善启动类，配置文件

启动类：

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

配置文件（application.yml）：

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/cloud_order?characterEncoding=utf8&useSSL=false
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
  mybatis:
    configuration:
      # 配置打印 MyBatis 日志
      log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
      map-underscore-to-camel-case: true # 配置驼峰自动转换

4.2.2 业务代码

1. 实体类：

@Data
public class OrderInfo {
    private Integer id;
    private Integer userId;
    private Integer productId;
    private Integer num;
    private Integer price;
    private Integer deleteFlag;
    private Date createTime;
    private Date updateTime;
}

2. Controller：

@RequestMapping("/order")
@RestController
public class OrderController {
    @Autowired
    private OrderService orderService;

    @RequestMapping("/{orderId}")
    public OrderInfo getOrderById(@PathVariable("orderId") Integer orderId) {
        return orderService.selectOrderById(orderId);
    }
}

3. Service：

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;

    public OrderInfo selectOrderById(Integer orderId) {
        OrderInfo orderInfo = orderMapper.selectOrderById(orderId);
        return orderInfo;
    }
}

4. Mapper：

@Mapper
public interface OrderMapper {
    @Select("select * from order_detail where id=#{orderId}")
    OrderInfo selectOrderById(Integer orderId);
}

完善商品服务类似，故代码不展示。

5. 远程调用

5.1 需求

根据订单查询订单信息时，根据订单里产品 ID，获取产品的详细信息。

5.2 实现

实现思路： order-service 服务向 product-service 服务发送一个 HTTP 请求，把得到的返回结果，和订单结果融合在一起，返回给调用方。 实现方式：采用 Spring 提供的 RestTemplate。

1. 定义 RestTemplate：

@Configuration
public class BeanConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

2. 修改 order-service 中的 OrderService：

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;

    public OrderInfo selectOrderById(Integer orderId) {
        OrderInfo orderInfo = orderMapper.selectOrderById(orderId);
        String url = "http://127.0.0.1:9090/product/" + orderInfo.getProductId();
        ProductInfo productInfo = restTemplate.getForObject(url, ProductInfo.class);
        orderInfo.setProductInfo(productInfo);
        return orderInfo;
    }
}

6. RestTemplate 详解

RestTemplate 是从 Spring3.0 开始支持的一个 HTTP 请求工具，它是一个同步的 REST API 客户端，提供了常见的 REST 请求方案的模版。

什么是 REST？ REST (Representational State Transfer)，表现层资源状态转移。 REST 是由 HTTP 的主要设计者提出来的软件架构风格。这里面主要有三个概念：

1. 资源：网络上的所有事物都可以抽象为资源，每个资源都有一个唯一的资源标识符 (URI)。
2. 表现层：资源的表现形式，比如文本作为资源，可以用 txt 格式表现，也可以通过 HTML, XML, JSON 等格式来表现，甚至以二进制的格式表现。
3. 状态转移：访问 URI，也就是客户端和服务器的交互过程。客户端用到的手段，只能是 HTTP 协议。这个过程中，可能会涉及到数据状态的变化。比如对数据的增删改查，都是状态的转移。

REST 是一种设计风格，指资源在网络中以某种表现形式进行状态转移。 简单来说：REST 描述的是在网络中 Client 和 Server 的一种交互形式，REST 本身不实用，实用的是如何设计 RESTful API（REST 风格的网络接口）。

什么是 RESTful？ REST 是一种设计风格，并没有一个明确的标准。满足这种设计风格的程序或接口我们称之为 RESTful（从单词字面来看就是一个形容词）。所以 RESTful API 就是满足 REST 架构风格的接口。

RESTful 风格大致有以下几个主要特征：

1. 资源：资源可以是一个图片，音频，视频或者 JSON 格式等网络上的一个实体，除了二进制的资源外普通的文本资源更多以 JSON 为载体、面向用户的一组数据 (通常从数据库中查询而得到)。
2. 统一接口：对资源的操作。比如获取，创建，修改和删除。这些操作正好对应 HTTP 协议提供的 GET、POST、PUT 和 DELETE 方法。换而言之，如果使用 RESTful 风格的接口，从接口上你可能只能定位其资源，但是无法知晓它具体进行了什么操作，需要具体了解其发生了什么操作动作要从其 HTTP 请求方法类型上进行判断。 比如同一个的 URL：
   • GET /blog/{blogId}：查询博客
   • DELETE /blog/{blogId}：删除博客 这些内容都是通过 HTTP 协议来呈现的。所以 RESTful 是基于 HTTP 协议的。 RestTemplate 是 Spring 提供，封装 HTTP 调用，并强制使用 RESTful 风格。它会处理 HTTP 连接和关闭，只需要使用者提供资源的地址和参数即可。

RESTful 实践 RESTful 风格的 API 固然很好很规范，但大多数互联网公司并没有按照其规则来设计，因为 REST 是一种风格，而不是一种约束或规则，过于理想的 RESTful API 会付出太多的成本。 RESTful API 缺点：

1. 操作方式繁琐，RESTful API 通常根据 GET, POST, PUT, DELETE 来区分对资源的操作动作。但是 HTTP Method 并不可直接见到，需要通过抓包等工具才能观察。如果把动作放在 URL 上反而更加直观，更利于团队的理解和交流。
2. 一些浏览器对 GET, POST 之外的请求支持不太友好，需要额外处理。
3. 过分强调资源。而实际业务需求可能比较复杂，并不能单纯使用增删改查就能满足需求，强行使用 RESTful API 会增加开发难度和成本。 所以，在实际开发中，如果业务需求和 RESTful API 不太匹配或者很麻烦时，也可以不用 RESTful API。如果使用场景和 REST 风格比较匹配，就可以采用 RESTful API。 总之：无论哪种风格的 API，都是为了方便团队开发，协商以及管理，不能墨守成规。尽信规范不如无规范。

7. 项目存在问题

• 远程调用时，URL 的 IP 和端口号是写死的 (http://127.0.0.1:9090/product/)，如果更换 IP，需要修改代码。
  • 调用方如何可以不依赖服务提供方的 IP？
• 多机部署，如何分摊压力？
• 远程调用时，URL 非常容易写错，而且复用性不高，如何优雅的实现远程调用。
• 所有的服务都可以调用该接口，是否有风险？

除此之外，微服务架构还面临很多问题，后续文章将为大家介绍学习如何使用 Spring Cloud 来解决这些问题。

8. 总结

本文搭建了 Spring Cloud 后续组件使用的基本工程环境，介绍了服务拆分原则及基于 RestTemplate 的远程调用实现，并指出了当前方案存在的局限性，为后续深入学习服务发现与负载均衡打下基础。