【SpringCloud笔记】（1）微服务之架构理论及入门案例

前言：

本笔记基于尚硅谷阳哥【springCloud】第二季视频教程

视频代码：https://github.com/zzyybs/atguigu_spirngcloud2020

其中所使用的工具，全部使用docker安装，与视频中存在差异，可供参考

笔记完结后，我会将我个人手敲的代码（基于视频中源代码，有些许改动）传到个人gitee上

地址如下：*************************

微服务架构理论

• 一种架构模式，倡导将单一应用程序划分为一组小的服务，服务之间相互协调、相互配合

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

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

springCloud主要组件

主要使用组件：

springboot与springCloud版本选型

注*大家有什么问题，可以直接访问官网，官网比任何资料都有效

官网地址： https://spring.io/projects/spring-cloud

• springboot版本以数字开头

• springCloud版本采用名称而非版本号命名，这些版本号采用伦敦地铁站名字命名，根据字母顺序来对应时间顺序

选择版本请严格按照官网给定的关系对应选择，如下图所示：

由cloud版本决定boot版本

官网已强烈建议springboot版本升级到2.x，springcloud使用Greenwich及以上版本

本次笔记所使用的版本为：

组件停更/升级/替换/

如第一张图所示，主要组件就那么多

但是一些组件已经停更了，目前很多公司已经摒弃这些旧组件使用更全面的替换组件，如下图所示：

微服务架构编码构建

（以订单-支付模块微服务为例）

编程风格：约定 > 配置 > 编码

构建整体聚合父工程project

1、file > new > project

选择黄色标注的版本

2、设置编码UTF-8

3、注解生效激活

勾选黄色标识处

4、java编译版本选择8

5、File Type过滤

新构建的project会有一些令人心烦意乱的.xxx文件，屏蔽掉！

将这些文件放入到ignored files and folders中

父工程POM

1、加上packaging

表示pom是总的父工程，让子工程继承版本号便于各种依赖的版本管理

  <groupId>com.atguigu.springcloud</groupId>
  <artifactId>cloud2020</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

2、删除新建项目中的src文件

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">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.atguigu.springcloud</groupId>
  <artifactId>cloud2020</artifactId>
  <version>1.0-SNAPSHOT</version>
  <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>5.1.47</mysql.version>
    <druid.version>1.1.16</druid.version>
    <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
  </properties>

  <!-- 子模块继承之后，提供作用：锁定版本+子modlue不用写groupId和version  -->
  <dependencyManagement>
    <dependencies>
      <!--spring boot 2.2.2-->
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.2.2.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <!--spring cloud Hoxton.SR1-->
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>Hoxton.SR1</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>2.1.0.RELEASE</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.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>${mybatis.spring.boot.version}</version>
      </dependency>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
      </dependency>
      <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
      </dependency>
      <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok.version}</version>
        <optional>true</optional>
      </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的作用是什么？
1、dependencyManagement:
通常会在一个组织或者项目的最顶层的父POM中看到dependencyManagement元素
使用pom.xml中的dependencyManagement元素能让所有在子项目中引用一个依赖而不用显式的列出版本号
dependencyManagement里只是声明依赖，并不引入依赖，子项目需要显式引用依赖
通俗的说，父项目定义了一个依赖的版本号，你子项目可以引入这个依赖的时候不需要声明版本号，我给你声明好了，你可以直接继承，当然你也可以声明自己需要的版本号
但是如果你不引入这个依赖，那你就别用了，因为我仅仅只是规范了这个依赖的版本号但没引入依赖，没办法给你继承呀
2、dependencies
用来声明子项目自己的依赖，可以在这里声明自己的版本号

Rest微服务工程构建

如何构建一个微服务模块（简介版）
1、建module
2、改POM
3、写YML
4、主启动
5、业务类

构建微服务提供者8001模块

1、创建module

2、pom文件配置

<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>
    <parent>
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>cloud2020</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

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

    <dependencies>
        <!--包含了sleuth+zipkin-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
        <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>
        </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>
            <version>8.0.33</version>
        </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>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

3、编写yml文件

server:
  port: 8001

spring:
  application:
    name: cloud-provider-payment

  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver            # mysql驱动包
    url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities  

4、进行业务编码

建表sql

create table `payment`(
    `id` bigint(20) not null auto_increment comment 'ID',
    `serial` varchar(200) default '',
    PRIMARY KEY (`id`)

)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8

entities

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {

    private Long id;
    private String serial;
}

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

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

    //自定义两个参数的构造方法
    public CommonResult(Integer code,String message){
        this(code,message,null);
    }
}

dao

<?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.atguigu.springcloud.dao.PaymentDao">
	//id对应的是dao层的方法名，否则会报错：org.apache.ibatis.binding.BindingException: Invalid bound statement (not found)
    <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
        insert into payment(serial) values (#{serial})
    </insert>

    <resultMap id="BaseResultMap" type="Payment">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <result column="serial" property="serial" jdbcType="VARCHAR"/>
    </resultMap>
    <select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap">
        select * from payment where id = #{id}
    </select>
</mapper>

@Mapper
public interface PaymentDao
{
    public int create(Payment payment);

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

目录结构

service

public interface PaymentService
{
    public int create(Payment payment);

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

@Service
public class PaymentServiceImpl implements PaymentService {
    @Resource
    private PaymentDao paymentDao;

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

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

controller

//因为实际项目中都是前后端分离，所以每个方法传参及返回值都应是json格式
@RestController
@Slf4j
public class PaymentController {
    @Resource
    private PaymentService paymentService;

	//使用@RequestMapping也可以，但是尽量要区分
    @PostMapping(value = "/payment/create")
    public CommonResult create(@RequestBody Payment payment) {
        int result = paymentService.create(payment);
        log.info("*****插入结果：" + result);
        return result > 0 ? 
        new CommonResult(200, "插入数据库成功,serverPort: " + serverPort, result) : 
        new CommonResult(444, "插入数据库失败", null);
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id) {
        Payment payment = paymentService.getPaymentById(id);
        return ObjectUtils.isEmpty(payment) ? 
        new CommonResult(444, "没有对应记录,查询ID: " + id, null) : 
        new CommonResult(200, "查询成功,serverPort:  " + serverPort, payment);
    }
}

5、测试结果

浏览器不支持post请求方式，所以create方法需要使用其他方式测试，比如使用postman

热部署devtools

在模块中加入依赖

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

在父POM里添加插件

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

开启自动编译的选择

更新池

老版本：

快捷键：ctrl+shift+alt+/

idea2021.2 版本之后：

在setting中配勾选如下配置

再按老版本的方法检查actionSystem.assertFocusAccessFromEdit是否勾选。

重启idea，完成

构建微服务消费者order80模块

消费者是方法的调用者，无需对数据进行持久化操作

1、创建module

2、改POM文件

不需要进行持久化操作，所以较服务提供者模块POM少引入了两个依赖

<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>
    <parent>
        <groupId>com.mzr.springcloud</groupId>
        <artifactId>cloud2020</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

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


    <dependencies>
        <!--包含了sleuth+zipkin-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
        <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>

3、创建YML

消费者模块默认使用80端口

80端口是服务器默认端口，这样用户输入网址时便不需要数据端口号

server:
  port: 80

4、主启动类

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

5、编写业务类

entities

直接复制使用提供者模块的实体类Payment、CommonResult

配置RestTemplate

使用RestTemplate访问提供者模块
RestTemplate提供了多种便捷访问远程http服务的方法，
是一种简单便捷的访问restful服务模板类，是spring提供的用于rest服务的客户端模板工具集

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

controller

@RestController
@Slf4j
public class OrderController {

    public static final String PAYMENT_URL = "http://localhost:8001";

    @Resource
    private RestTemplate restTemplate;

    @PostMapping("/consumer/payment/create")
    public CommonResult<Payment> create(@RequestBody Payment payment) {
        return restTemplate.postForObject(
                PAYMENT_URL + "/payment/create",       		//url地址
                payment,                                    //请求体对象
                CommonResult.class);                        //返回类型
    }

    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable("id") Long id) {
        return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
    }
}

6、测试

如果项目启动时报错：Failed to configure a DataSource: ‘url‘ attribute is notspecified and no embedded datasource
原因可能时pom文件中多了无用的依赖，比如mybatis及druid…

建议使用Run Dashboard控制台
微服务架构有多个模块，使用Run Dashboard控制台方便我们管理

#如何调出Run Dashboard控制台？三种方法
# 1、view > Tool Windows > Run Dashboard
# 2、idea界面右上角搜索
# 3、工程目录下找到.idea文件夹下的workspace.xml，在其中相应位置加入以下代码：

<component name="RunDashboard">
   <option name="configurationTypes">
       <set>
           <option value="SpringBootApplicationConfigurationType"/>
       </set>
   </option>
   <option name="ruleStates">
       <list>
           <RuleState>
               <option name="name" value="ConfigurationTypeDashboardGroupingRule"/>
           </RuleState>
           <RuleState>
               <option name="name" value="StatusDashboardGroupingRule"/>
           </RuleState>
       </list>
   </option>
</component>

测试get

测试create

工程重构

不难看出在上边两个模块中，有重复的entities及引入的jar

我们可以将重复的部分整合为一个独立的模块，打包放入maven仓库供其它模块统一调配使用

1、新建cloud-api-commons模块

2、将entities包复制到该模块中

3、将pom文件中重复引入jar包放入pom文件

<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>
    <parent>
        <groupId>com.mzr.springcloud</groupId>
        <artifactId>cloud2020</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

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


    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <!--optional标签要去掉，否则不会传递依赖给其他两个模块，其他两个模块依然要重新引入该模块-->
            <!--可参考这篇文章：https://blog.csdn.net/weixin_43888891/article/details/130510971?spm=1001.2014.3001.5506-->
            <!--<optional>true</optional>-->
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
             <!--<optional>true</optional>-->
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.1.0</version>
        </dependency>
    </dependencies>

</project>

4、使用maven:clean、maven:install将其打包放入本地仓库

5、改造消费者模块及提供者模块

删除两个模块中的entities包，及删除加入到cloud-api-commons的依赖配置

在pom文件中引入cloud-api-commons模块

<dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
    <groupId>com.dkf.cloud</groupId>
    <artifactId>cloud-api-commons</artifactId>
    <version>${project.version}</version>
</dependency>

至此，入门的demo已经学习完了，我们还没有使用任何springcloud组件，接下来我们将开始学习springcloud的各种组件