微服务入门

微服务简介

所谓的微服务是SOA架构下的最终产物，该架构的设计目标是为了肢解业务，使得服务能够独立运行。

微服务设计原则：

1、各司其职

2、服务高可用和可扩展性

       微服务架构是一种架构模式，它提倡将单一应用程序划分成一组小的服务，服务之间互相依赖、互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务于服务间采用轻量级的通信机制互相协作（通常是基于HTTP协议的RESTful API）。每个服务都围绕着具体业务进行构建，并且能够被独立的部署到生产环境、类生产环境等。另外，应当尽量避免统一的、集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文选择合适的语言、工具对其进行构建。

SpringCloud简介

       Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子，它只是将各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

SpringCloud = 分布式微服务架构的一站式解决方案，是多种微服务架构落地技术的集合体，俗称微服务全家桶

SpringCloud技术栈2020

红色表示已经停止更新或者已经淘汰的技术点，黄色的表示还没出来就倒了（开发人员跳槽了）

查看最新版本兼容最好的版本：https://spring.io/projects/spring-cloud#learn

此截图为2020年6月8日的版本，但是这次使用的是 SR1 和 2.2.2

创建第一个父子工程

约定 > 配置 > 编码

先创建一个简单的Maven项目

根据以上步骤创建好之后就可以开始设置为父工程了

创建父工程

将刚才创建好的maven项目中的文件全部删除，只保留一个pom.xml文件

修改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.lyang.springcloud</groupId>
    <artifactId>SpringCloud2020</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>  <!-- 表示这是一个pom父工程 -->
    
	<!-- 统一管理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：

       Maven 中使用 dependencyManagement 元素来提供了一种管理依赖版本号的方式。通常会在一个组织或者项目的最顶层的父 pom 中看到 dependencyManagement 元素。

好处：

​        如果有多个子项目都引用同一个依赖，那么可以避免在每个使用的子项目里都声明一个版本号，这样当想升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要一个一个子项目的修改，另外如果某个子项目需要另外的一个版本，只需要声明 version 即可。

注意：

1. dependencyManagement 里面只是声明依赖，并不会实现引入，因此子项目需要显示的声明需要用的依赖。
2. 如果不再子项目中声明依赖，是不会从父项目中继承下来的。只有在子项目中写了该依赖项但是没有指定具体版本的时候才会从父项目中继承该项，并且 version 和 scope 都读取自父 pom。
3. 如果子项目中指定了版本号，那么会使用子项目中指定的 jar 版本。

关闭单元测试

其他一些基本设置

添加以上依赖和关闭单元测试，还有一些需要的操作后父工程就算完成了

子工程

步骤：

1. 建项目

   创建一个名为 cloud-provider-payment8001 的子项目

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>SpringCloud2020</artifactId>
           <groupId>com.lyang.springcloud</groupId>
           <version>1.0-SNAPSHOT</version>
       </parent>
       <modelVersion>4.0.0</modelVersion>
   
       <artifactId>cloud-provider-payment8001</artifactId>
   
       <dependencies>
           <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-actuator</artifactId>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
           <dependency>
               <groupId>org.mybatis.spring.boot</groupId>
               <artifactId>mybatis-spring-boot-starter</artifactId>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
           <dependency>
               <groupId>com.alibaba</groupId>
               <artifactId>druid-spring-boot-starter</artifactId>
               <version>1.1.10</version>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-jdbc -->
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-jdbc</artifactId>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-devtools -->
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-devtools</artifactId>
               <scope>runtime</scope>
               <optional>true</optional>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
           <dependency>
               <groupId>org.projectlombok</groupId>
               <artifactId>lombok</artifactId>
               <optional>true</optional>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-test -->
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>
   </project>
   

   创建好项目之后父工程 pom 文件中会多出一个 modules 标签

3. 写YML

   server:
     port: 8001
   
   spring:
     application:
       name: cloud-payment-service
     datasource:
         # 当前数据源操作类型
         type: com.alibaba.druid.pool.DruidDataSource
         # mysql驱动包
         driver-class-name: org.gjt.mm.mysql.Driver
         url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
         username: root
         password: 123456
   
   
   mybatis:
     mapperLocations: classpath:mapper/*.xml
     # 所有 Entity 别名类所在包
     type-aliases-package: com.atguigu.springcloud.entity
   

4. 主启动

   /**
    * 8001 启动类
    */
   @SpringBootApplication
   public class PaymentMain8001 {
       public static void main(String[] args) {
           SpringApplication.run(PaymentMain8001.class,args);
       }
   }
   

5. 建数据表

   -- 创建数据库
   CREATE DATABASE db2019;
   
   -- 选择数据库
   USE db2019;
   
   -- 创建表
   CREATE TABLE payment (
    `id` BIGINT(20) PRIMARY KEY AUTO_INCREMENT,
    `serial` VARCHAR(200)
   );
   
   -- 新增数据
   INSERT INTO payment(id,SERIAL)
   VALUES(NULL,'laoyang');
   

6. 业务类

   Entity

   @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

   //@Mapper：把mapper这个DAO交給Spring管理
   @Mapper
   public interface PaymentDao {
       /**
        * 新增
        */
       public int create(Payment payment);
   
       /**
        * 根据id查询对应数据
        */
       public Payment getPaymentById(@Param("id") Long id);
   }
   

   Service

   /**
    * Service层的方法可以直接复制 Dao 层的方法
    */
   public interface PaymentService {
       /**
        * 新增
        */
       public int create(Payment payment);
   
       /**
        * 根据id查询对应数据
        */
       public Payment getPaymentById(Long id);
   
   }
   

   ServiceImpl

   @Service
   public class PaymentServiceImpl implements PaymentService {
       //调用dao层
       @Resource
       private PaymentDao paymentDao;
   
       /**
        * 新增
        */
       @Override
       public int create(Payment payment) {
           return paymentDao.create(payment);
       }
   
       /**
        * 查询
        */
       @Override
       public Payment getPaymentById(Long id) {
           return paymentDao.getPaymentById(id);
       }
   }
   

   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.atguigu.springcloud.dao.PaymentDao">
       <!--
           id对应的是DAO中的方法名
           parameterType表示参数类型
           useGeneratedKeys是否使用产生的返回值（插入成功后会返回1失败会返回0）
           keyProperty表示对应的主键
       -->
       <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
           insert into payment(serial) values(#{serial});
       </insert>
   
       <!-- 高级映射 -->
       <resultMap id="BaseResultMap" type="com.atguigu.springcloud.entity.Payment">
           <!--
               column表示数据库字段名
               property表示实体类属性名
               jdbcType表示数据库字段的数据类型
           -->
           <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>
   

7. 控制层Controller

   /**
    * @RestController: 作用等同于@Controller + @ResponseBody
    * @Slf4j: 使用前需要下载 Lombok 插件，日志
    */
   @RestController
   @Slf4j
   public class PaymentController {
       //调用service层
       @Resource
       private PaymentService paymentService;
   
       @PostMapping(value = "/payment/create")
       public CommonResult create(Payment payment) {
           int result = paymentService.create(payment);
           log.info("------插入结果：" + result);
           if (result > 0) {
               return new CommonResult(200, "插入成功", result);
           }
           return new CommonResult(444, "插入失败", null);
       }
   
       /**
        * @PathVariable():接收请求路径中占位符的值
        */
       @GetMapping(value = "/payment/get/{id}")
       public CommonResult getPaymentById(@PathVariable("id") Long id) {
           Payment payment = paymentService.getPaymentById(id);
           log.info("------查询结构为：" + payment);
           if (payment != null) {
               return new CommonResult(200, "查询成功", payment);
           }
           return new CommonResult(444, "没有对应数据，查询ID：" + id, null);
       }
   }
   

8. 测试
   
   启动成功后进入浏览器，输入地址：http://localhost:8001/payment/get/1 即可查看get方法
   还有一个create方法不再浏览器中预览是因为在浏览器中预览会直接报错，需要用到一个软件来进行测试
   软件名：Postman
   

以上操作都是基本操作，就不做过多的说明了。

后面的子项目步骤也是差不多的！

热部署

1. 导入对于依赖（前面的依赖中已经有了，这里了解一下即可）

   子工程
   <!-- 热部署 -->
   <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
   </dependency>
   
   父工程
   <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>
   

2. 在settings中将进行以下操作
   

3. 使用Ctrl+Shift+Alt+/快捷键选择Registry，在选择以下几个即可
   

热部署一般用于开发阶段，实际上线之后一定要关闭！

消费者

创建cloud-consumer-order80子工程作为消费者

改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>SpringCloud2020</artifactId>
        <groupId>com.lyang.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>

写yml

server:
  port: 80

科普：

       80端口是为HTTP即超文本传输协议开放的，此为上网冲浪使用次数最多的协议，主要用于WWW即万维网传输信息的协议。80是浏览网页服务默认的端口号，在我们使用80端口访问的时候可以不用加上端口号！

主启动

/**
 * 80启动类
 * 消费者
 */
@SpringBootApplication
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class,args);
    }
}
   

业务类

1. 直接把 8001 中的 entity 复制过来

2. 编写配置类

   /**
    * @Configuration: 表示这是一个配置类
    */
   @Configuration
   public class ApplicationContextConfig {
       /**
        * 使用 @Bean 注解将数据放进容器中
        */
       @Bean
       public RestTemplate getRestTemplate(){
           return new RestTemplate();
       }
   }

控制层

@RestController
@Slf4j
public class OrderController {
    //地址
    private static final String PAYMENT_URL = "http://localhost:8001";

    /**
     * RestTemplate提供了多种便捷访问远程Http服务的方法,
     * 是一种简单便捷的访问 restful 服务模板类
     * 是Spring提供的用于访问Rest服务的客户端模板工具集
     */
    @Resource
    private RestTemplate restTemplate;
    
    @GetMapping("/consumer/payment/create")
    public CommonResult<Payment> create(Payment payment){
        return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResult.class);
    }
    
    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
        return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
    }
}

修改8001中的PaymentController

  /**
   * @RestController: 作用等同于@Controller + @ResponseBody
   * @Slf4j: 使用前需要下载 Lombok 插件，日志
   */
   @RestController
   @Slf4j
   public class PaymentController {
   @Resource
   private PaymentService paymentService;

   /**

    *  @RequestBody
    *  主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的)
    *  如果不加上的话在插入的时候就无法正常传值进入数据库中
       */
       @PostMapping(value = "/payment/create")
       public CommonResult create(@RequestBody Payment payment) {
           int result = paymentService.create(payment);
           log.info("------插入结果：" + result);
           if (result > 0) {
               return new CommonResult(200, "插入成功", result);
           }
           return new CommonResult(444, "插入失败", null);
       }

   /**

    * @PathVariable():接收请求路径中占位符的值
      */
      @GetMapping(value = "/payment/get/{id}")
      public CommonResult getPaymentById(@PathVariable("id") Long id) {
      Payment payment = paymentService.getPaymentById(id);
      log.info("------查询结构为：" + payment);
      if (payment != null) {
          return new CommonResult(200, "查询成功", payment);
      }
      return new CommonResult(444, "没有对应数据，查询ID：" + id, null);
      }
}

添加一个@RequestBody注解将数据转换为json类型，然后在进行使用

测试

现在我们已经有了两个服务了，所以如果一个一个的启动就会比较麻烦，所以我们可以进行以下操作

如果没有提示的话就需要自己手动修改 idea 的 workspace.xml 的方式来快速打开 RunDashboard 窗口

打开workspace文件后找到RunDashboard然后在里面添加如下代码即可

<option name="configurationTypes">
      <set>
        <option value="SpringBootApplicationConfigurationType" />
      </set>
</option>

注意：

如果有提示那么只需要选择刚才指定的那个即可，只有在没有出现提示或者不小心把提示叉掉之后才需要自己手动加代码进行设置！！！
PS： 2020版的idea可以直接在 View 中设置

运行效果

工程重构

       大家完成上面的操作之后可以发现，似乎每一个工程里面都写了实体类，而且都进行了一定的使用，但是每一个工程都加上实体类的话就会出现代码冗余的情况，所以我们可以创建一个公用的工程来进行操作！

创建一个公用工程 cloud-api-commons，和之前一样的子工程即可

修改 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>SpringCloud2020</artifactId>
        <groupId>com.lyang.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>
            <scope>runtime</scope>
            <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>

将其他工程中的 entity 包复制进来

将其他工程的 entity 包删除，删除后会报错。需要在对于 pom 中调用这个公用的工程，调用后即可恢复正常！

<!-- 引入自己定义的api通用包，可以使用 Payment 支付 Entity -->
<dependency>
        <groupId>com.lyang.springcloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>1.0-SNAPSHOT</version>
        <scope>compile</scope>
</dependency>

测试，和之前的一样，运行程序后在浏览器中进行测试即可，这里就不多演示了