SpringCloud微服务概述及项目聚合实例之支付模块（非常适合初学者）

概述

提出者

Martin Fowler

什么是微服务

微服务架构是一种架构模式。

它提倡将单一应用程序划分成一组小的服务，服务之间互相协调、互相配合，为用户提供最终价值。

每个服务运行在其独立的进程中，服务与服务间采用轻量级的通信机制互相协作（通常是基于HTTP协议的RESTful API)。

每个服务都围绕着具体业务进行构建，并且能够被独立的部署到生产环境、类生产环境等。

另外，应当尽量避免统一的、集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具对其进行构建

微服务组件

服务注册与发现

服务调用

服务熔断

负载均衡

服务降级

服务消息队列

配置中心管理

服务网关

服务监控

全链路追踪

自动化构建部署

服务定制任务调度操作

京东分布式体系

阿里分布式体系

目前主流的微服务架构

版本对照（2020.11.26）

Springboot与SpringCloud的版本不能任意搭配，必须按照官方指定的规则进行组合

具体对照查看网址

https://start.spring.io/actuator/info

项目架构

创建项目父依赖

父项目名称 cloud2021
父项目结构采用 maven 结构

<?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>com.lejia.springcloud</groupId>
  <artifactId>cloud2021</artifactId>
  <version>1.0-SNAPSHOT</version>
  <modules>
    <module>cloud-provider-payment8001</module>
  </modules>
  <!--  项目父依赖标志-->
  <packaging>pom</packaging>


  <!--统一管理jar包版本-->
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <junit.version>4.12</junit.version>
    <log4j.version>1.2.17</log4j.version>
    <lombok.version>1.16.18</lombok.version>
    <mysql.version>8.0.19</mysql.version>
    <druid.version>1.1.16</druid.version>
    <spring.boot.version>2.2.2.RELEASE</spring.boot.version>
    <spring.cloud.version>Hoxton.SR1</spring.cloud.version>
    <spring.cloud.alibaba.version>2.1.0.RELEASE</spring.cloud.alibaba.version>
    <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
  </properties>

  <!--子模块继承后,提供作用:锁定版本+子module不用groupId和version-->
  <dependencyManagement>
    <dependencies>
    
      <!--springboot 2.2.2-->
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>${spring.boot.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      
      <!--Spring cloud Hoxton.SR1-->
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>${spring.cloud.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      
      <!--Spring cloud alibaba 2.1.0.RELEASE-->
      <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-alibaba-dependencies</artifactId>
        <version>${spring.cloud.alibaba.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      
      <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
      </dependency>
      
      <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
      </dependency>
      
      <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <fork>true</fork>
          <addResources>true</addResources>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

DependencyManagement 和Dependencies的区别

Maven使用dependencyManagement元素来提供了一种管理依赖版本号的方式。

通常会在一个组织或者项目的最顶层的父POM中看到dependencyManagement元素。

使用pom.xml 中的dependencyManagement元素能让所有在子项目中引用一个依赖而不用显式的列出版本号。

Maven 会沿着父子层次向上走，直到找到一个拥有dependencyManagement元素的项目，然后它就会使用这个dependencyManagement元素中指定的版本号。

dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。

支付微服务模块配置

1、提供者

1.1、配置步骤

1、建Module

2、改POM

3、写YML

4、主启动

5、业务类

1.2、建Module

创建 cloud-provider-payment8001 子工程

1.3、改POM

子类模块不用写groupId和version

子类依赖没定义版本号，就用父类的

子类依赖定义了版本号，就用子类的

<?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">
    <parent>
        <artifactId>cloud2021</artifactId>
        <groupId>com.lejia.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-provider-payment8001</artifactId>

    <dependencies>

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

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.0</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

1.4、写YML(application.yml)

server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/cloud2020?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
    username: root
    password: 1234

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.lejia.springcloud.entities

1.5、主启动

package com.lejia.springcloud;

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

/**
 * @Author: LeJia
 * @Date: 2020/11/26 21:47
 * @Version 1.0
 */

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

1.6、业务类

1.6.1、创建表

sql

1.6.2、创建entities

1.6.2.1、创建通用返回json字符的结果实体类(CommonResult)

package com.lejia.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Author: LeJia
 * @Date: 2020/11/26 21:57
 * @Version 1.0
 * 定义返回接口，给前端返回json字符串
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommentResult<T> {

    private Integer code;
    private String message;
    private T      data;	//与传入的类型相同

    public CommentResult(Integer code, String message){
        this(code,message,null);
    }
}

1.6.2.2、创建业务实体类(Payment)

package com.lejia.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @Author: LeJia
 * @Date: 2020/11/26 21:55
 * @Version 1.0
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {

    private Long id;
    private String serial;

}

1.6.3、创建dao(PaymentDao)

package com.lejia.springcloud.dao;

import com.lejia.springcloud.entities.Payment;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

/**
 * @Author: LeJia
 * @Date: 2020/11/26 22:10
 * @Version 1.0
 */
//推荐使用Mapper,使用repository可能在以后的项目中出现bug
@Mapper
public interface PaymentDao {

    public int create(Payment payment);

    public Payment getPaymentById(@Param("id") Long id);
}

1.6.4、创建dao具体实现mapper配置文件(PaymentMapper.xml)

PaymentMepper.xml 在resources -> mapper目录下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lejia.springcloud.dao.PaymentDao">

    <!--parameterType 参数类型   useGeneratedKeys 成功返回>0的值  keyProperty 主键  -->
    <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
        insert into payment(serial) value(#{serial});
    </insert>

    <!--别名映射
        column - 数据库
        property - 实体类
    -->
    <resultMap id="BaseResultMap" type="com.lejia.springcloud.entities.Payment">
        <id column="id" property="id" jdbcType="BIGINT"></id>
        <id column="serial" property="serial" jdbcType="VARCHAR"></id>
    </resultMap>

    <select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap">
        select * from payment where id=#{id}
    </select>

</mapper>

1.5、创建service

1.5.1、Service(PaymentService)

package com.lejia.springcloud.service;

import com.lejia.springcloud.entities.Payment;
import org.apache.ibatis.annotations.Param;

/**
 * @Author: LeJia
 * @Date: 2020/11/26 22:32
 * @Version 1.0
 */
public interface PaymentService {
    public int create(Payment payment);

    public Payment getPaymentById(@Param("id") Long id);
}

1.5.2、ServiceImpl (PaymentServiceImpl)

package com.lejia.springcloud.service.impl;

import com.lejia.springcloud.dao.PaymentDao;
import com.lejia.springcloud.entities.Payment;
import com.lejia.springcloud.service.PaymentService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @Author: LeJia
 * @Date: 2020/11/26 22:32
 * @Version 1.0
 */
@Service
public class PaymentServiceImpl implements PaymentService {

//    @Autowired  //springboot的
    @Resource      //java自带的
    private PaymentDao paymentDao;


    @Override
    public int create(Payment payment) {
        return paymentDao.create(payment);
    }

    @Override
    public Payment getPaymentById(Long id) {
        return paymentDao.getPaymentById(id);
    }
}

1.6、创建controller (PaymentController)

package com.lejia.springcloud.controller;

import com.lejia.springcloud.entities.CommentResult;
import com.lejia.springcloud.entities.Payment;
import com.lejia.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
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.RestController;

import javax.annotation.Resource;

/**
 * @Author: LeJia
 * @Date: 2020/11/26 22:45
 * @Version 1.0
 */
@RestController
@Slf4j
public class PaymentController {

    @Resource
    private PaymentService paymentService;


    @PostMapping("/payment/create")
    public CommentResult create(Payment payment){

        int result = paymentService.create(payment);
        log.info("*****插入结果***** " + result);

        if(result > 0) {
            return new CommentResult(200, "插入成功", result);
        }else {
            return new CommentResult(444, "插入失败", null);
        }
    }

    @GetMapping("/payment/get/{id}")
    public CommentResult getPaymentById(@PathVariable("id") Long id){

        Payment paymentById = paymentService.getPaymentById(id);
        log.info("*****查询结果***** " + paymentById);

        if(paymentById != null) {
            return new CommentResult(200, "查询成功", paymentById);
        }else {
            return new CommentResult(444, "查询失败,没有 " + id + " 的信息", null);
        }
    }
}

1.7、编写测试代码

1.7.1、get请求

http://localhost:8081/payment/get/10

1.7.2、post请求

http://localhost:8081/payment/create?serial=hello

浏览器大多数对post的支持不太好，所以尽量在postman中测试

设置热部署

导入依赖

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

设置自动编译

开启自动编译

按下 CTRL + SHIFT + ALT + /

选择第一个选项

找到compiler … running 开启这个功能

重启IDEA

说明

热部署只允许在开发阶段使用，当项目进入生产阶段后，必须关闭热部署功能

2、消费者模块

1、配置步骤

1、建Module

2、改POM

3、写YML

4、主启动

5、业务类

2、建moudle

cloud-consumer-order80

3、改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">
    <parent>
        <artifactId>cloud2021</artifactId>
        <groupId>com.lejia.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-order80</artifactId>

    <dependencies>

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

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

4、写yml

server:
  port: 80
spring:
  application:
    name: cloud-consumer-order80

5、主启动

package com.lejia.springcloud;

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

/**
 * @Author: LeJia
 * @Date: 2020/11/27 10:56
 * @Version 1.0
 */
@SpringBootApplication
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class, args);
    }
}

6、业务类

什么是restTemplate

传统情况下在java代码里访问restful服务，一般使用Apache的HttpClient。

不过此种方法使用起来太过繁琐。

spring提供了一种简单便捷的模板类来进行操作，这就是RestTemplate。

使用restTemplate访问restful接口非常的简单粗暴无脑。

(url, requestMap, ResponseBean.class) 这三个参数分别代表REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。

restTemplate底层封装了HttpClient

1、创建restTemplate 实现调用主接口

package com.lejia.springcloud.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

/**
 * @Author: LeJia
 * @Date: 2020/11/27 11:09
 * @Version 1.0
 */

@Configuration
public class ApplicationContextConfig {

    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

2、创建业务类

package com.lejia.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;


@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {
    private Integer id;
    private String message;
    private T  data;

    public CommonResult(Integer id, String message) {
        this.id = id;
        this.message = message;
    }
}

package com.lejia.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;


@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {
    private Long id;
    private String serial;

}

3、实现controller

package com.lejia.springcloud.controller;
import com.lejia.springcloud.entities.CommentResult;
import com.lejia.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;

/**
 * @Author: LeJia
 * @Date: 2020/11/27 11:05
 * @Version 1.0
 */

@RestController
@Slf4j
@RequestMapping("/consumer")
public class OrderController {

	//restTemplate远程请求的地址
    public static final String PAYMENT_URL = "http://localhost:8001";

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("/payment/create")
    public CommentResult<Payment> create(Payment payment){
        log.info("插入中 ... " + payment);
        return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommentResult.class);
    }

    @GetMapping("/payment/get/{id}")
    public CommentResult<Payment> getPayment(@PathVariable Long id){
        log.info("查询中 ... " + id);
        return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id, CommentResult.class);
    }
}

7、编写测试代码

测试消费者端调用服务端接口

http://localhost/consumer/payment/get/11

测试消费者端调用服务端接口

http://localhost/consumer/payment/create?serial=我是消费者哦

3、工程重构

我们在实现了微服务的支付模块后，发现消费者与服务者都拥有相同的实体bean对象，并且为了将来系统的可维护性，我们将公共代码抽取出来，设计一个公共模块，减少代码的复用

1、建共用moudle

cloud-api-commons

2、改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">
    <parent>
        <artifactId>cloud2021</artifactId>
        <groupId>com.lejia.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-api-commons</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--时间日期格式-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.1.0</version>
        </dependency>
    </dependencies>


</project>

3、将公共实体类抽取出来

在公共模块下新建com.lejia.springcloud.entities包

CommentResult

package com.lejia.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Author: LeJia
 * @Date: 2020/11/27 11:04
 * @Version 1.0
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommentResult<T> {

    private Integer code;
    private String message;
    private T      data;

    public CommentResult(Integer code, String message){
        this(code,message,null);
    }
}

Payment

package com.lejia.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @Author: LeJia
 * @Date: 2020/11/27 11:04
 * @Version 1.0
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {

    private Long id;
    private String serial;

}

4、打包发布

5、将consumer模块和provider模块中的复用代码entities删除掉

6、在其他环境中引用

      <!--删除掉entities后，将公用代码打包放到公共模块中，引入模块-->
        <dependency>
            <groupId>com.lejia.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>

4、项目整体结构图如下