Spring Cloud(一)-概述和环境搭建

一个爱浪费时间的人

已于 2022-03-19 17:38:24 修改

阅读量543

点赞数

分类专栏： spring Cloud 文章标签： spring cloud

于 2020-12-02 19:26:56 首次发布

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/qq_33248299/article/details/110494864

版权

spring Cloud 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一.微服务结构理论入门

1.概述

微服务是一种架构模式，提倡将单一应用程序划分成一组小的服务，服务之间互相协调，互相配合
每个服务运行在独立的进程中，服务与服务之间采用轻量级的通信机制互相协作(通常基于HTTP协议的RESTful API)
能独立部署到生产环境和类生产环境中，尽量避免统一、集中的服务管理机制
简单的来说就是Spring boot开发的一个个的服务集合
谈谈你对分布式架构的理解，如果面试问到这个问题，肯定要有以下几个方面

在这里插入图片描述

分布式微服务架构是一个整体，而不是单一的技术

2.Spring Cloud简介

分布式微服务架构一站式解决方案，是多种微服务架构落地技术的集合，俗称微服务全家桶
有这么多种技术
微服务之间的调度和共享：比如多个人，一个人做支付，一个人做账户，一个人做用户，之间互相调用，比如每个订单都要一个自增器，不需要三个人都做一套了，直接用基础通用配置

在这里插入图片描述

主要学主流的技术
Spring Cloud主要通过网关调用负载均衡，每个微服务，

3.版本选型

Spring Cloud和Spring Boot版本之间有限制，有依赖，严格按照官网
Spring Boot2.x版本，别用1版本了
更详细的版本查看地址

版本查看地址

不过最好由Cloud来决定Boot的版本，比如现在官网最新的Cloud是Hoxton.SR9，点进它的文档它推荐用2.3.5的Boot版本

4.Cloud组件停更说明

以前是这样的

A.服务注册中心

Eureka2.x版本停止更新了，但是1.x还在维护
Zookeeper
Consul
Nacos（千万级，强烈推荐，阿里的）

B.服务调用

Ribbon(进入了维护状态)
LoadBalancer(还未成熟)
Feign(差不多挂了)
OpenFeign（推荐）

C.服务降级

Hystrix（官网不推荐）
resilience4j(国外推荐)
sentienl(国内推荐，阿里的)

D.服务网关

Zuul(挂了)，Zuul2出不来了
gateway

E.服务配置

Config
Nacos(推荐)

F.服务总线

Bus
还有上海携程的阿波罗
Nacos(推荐)

在这里插入图片描述

二.搭建环境

1.建立父工程

建立一个父工程
配置编码，注释生效，和JDK版本，删掉src(忽略这些文件后缀)
pom.xml

    <packaging>pom</packaging>

    <!-- 统一管理jar包版本 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>12</maven.compiler.source>
        <maven.compiler.target>12</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <lombok.version>1.18.10</lombok.version>
        <log4j.version>1.2.17</log4j.version>
        <mysql.version>8.0.18</mysql.version>
        <druid.version>1.1.21</druid.version>
        <mybatis.spring.boot.version>2.1.1</mybatis.spring.boot.version>
    </properties>

    <!-- 子模块继承之后，提供作用：锁定版本 + 子module不用写groupId和version -->
    <dependencyManagement>
        <dependencies>
            <!--spring boot 2.2.2-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.5.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.SR9</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.2.1.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>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </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>

2.Maven中的DependencyManagement和Dependencies区别

通常会在一个组织或者项目的最顶层的父POM中看到DependencyManagement元素
使用pom.xml中的DependencyManagement元素能让所有在子项目中引用一个依赖而不用显式的列出版本号
Maven会沿着父子层次向上走，直到找到一个拥有DependencyManagement元素的项目，然后它就会使用这个DependencyManagement元素中指定的版本号
比如父项目中

子类工程就不需要写版本号了

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

DependencyManagement只是声明依赖，并不是实现引入，因此子项目需要显示的声明需要用的依赖
如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom
如果子项目中指定了版本号，会使用子项目中指定的版本

3.maven跳过单元测试

在这里插入图片描述

父工程创建完成执行mvn:install将父工程发布到仓库方便子工程继承，看到success就说明环境没问题了

4.支付模块的构建

在这里插入图片描述

怎样构建一个微服务模块？以下五个步骤
建立module
改pom

 <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>
        </dependency>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

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

写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                 # mysql驱动包
    url: jdbc:mysql://localhost:3306/cloud?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456


mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.playmaker.springcloud.entities  #所有Entity别名类所在包

主启动

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

业务类

A.建表

这里你也可以通过写类用jpa直接生成表

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

B.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 = code;
        this.message = message;
    }
}

C.dao

PaymentDao

@Mapper
public interface PaymentDao {

    public int create(Payment payment);

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

Payment.xml

<mapper namespace="com.playmaker.springcloud.dao.PaymentDao">
    <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
        insert into payment(serial) values(#{serial});
    </insert>

    <resultMap id="BaseResultMap" type="com.playmaker.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>

D.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;

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

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

E.controller

@RestController
@Slf4j
public class PaymentController {

    @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);
        }else{
            return new CommonResult(200,"插入数据库失败",null);
        }
    }

    @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);
        }else{
            return new CommonResult(444,"没有对应记录，查询ID:"+id,null);

        }
    }
}

测试,先插入一条数据…

访问上面两个接口没问题就OK了

5.热部署Devtools

代码改动，自动生效，不需要我们手动重启

A.添加devtools到pom文件中

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

B.添加maven-plugin到父总工程pom.xml中

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

C.开启自动编译选项

在这里插入图片描述

D.热注册开启

Ctrl+shift+Alt+/
Ctrl+shift+a 搜索registry

在这里插入图片描述

E.重启IDEA

开发阶段开热部署，生产部署一定要关闭

6.消费者订单模块

有微服务的提供者必然有服务的消费者
步骤和上面建立提供者模块一样

A.建立cloud-consumer-order80 Module

B.改pom

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

C.写yml配置文件

server:
  port: 80

D.主启动类

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

E.写业务类

消费者去调用提供者是否还需要controller-service-dao呢？
消费者只应该有一个controller就行了，干活的是提供者
这里可以直接把实体类单独弄成一个模块
两个服务之间怎么调用？最原始方法是HttpClient，现在可以用restTemplate，相当于对httpClient进行了一次封装，实现了微服务与微服务之间的横向调用
RestTemplate提供了多种便捷访问远程Http服务的方法，是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集
使用RestTemplate访问restful接口非常简单粗暴无脑(url,requestMap,ResponseBeanclass)三个参数分别代表REST请求地址、请求参数、HTTP响应转换被转换成的对象类型
写个配置类

@Configuration
public class ApplicationContextConfig {
    //高版本的spring boot已经引入了RestTemplate,可以直接注入,不用写这个配置类也行
    @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;

    @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> getPayment(@PathVariable("id") Long id){
        return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
    }
}

F.测试

启动两个服务
访问查询接口没有问题
访问创建接口也没有问题，但是…数据库里面也主键，但是serial字段为空。不要忘记RequestBody注解
在8001的创建接口上加上RequestBody注解就没问题了
IDEA2020之前统一用rundashboard来管理启动的微服务，而2020之后用services来代替了rundashboard，rundashboard开启方法网上找得到我这里就不多说了

7.工程重构

系统有重复部分,entites包下的实体写在两个微服务下有点多余，单独抽离出来
新建一个Module(cloud-api-commons)
改pom

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

建立entites包
maven命令clean install
改造另外的微服务模块
- 删掉各自的entites包
- 在各自的pom.xml中引入打包的模块

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