SpringCloud概述

---

title: SpringCloud概述
date: 2021-08-27 15:53:33

1.什么是微服务

什么是微服务？打个很简单的比方，微服务就好像活字印刷术中的一个个字体模板，也被称为模块，每一个模块都可以单独的起作用，可以独立的部署运行，相互解耦。即便当中的某一个模块出了问题，也不影响其它的模块正常运行。每个模块之间采用轻量级交互（通常是http协议）

微服务和传统的单体架构比起来有什么好处?

在了解springcloud之前，先来了解单体架构是什么？

• 传统单体架构典型代表就是一个应用、一个数据库、一个web容器，这种架构在规模比较小的工作情况还好，但是随着系统规模的扩大就会暴露很多问题：

  1. 复杂性逐渐变高

     比如有的项目有几十万行的代码，各个模块之间区别比较模糊，逻辑比较混乱，代码越多，复杂性越高，越难解决遇到的问题

  2. 技术债务逐渐上升

     随着公司人员流动，之前员工在代码上留下的坑越来越多，越来越难以被人察觉

  3. 部署逐渐变慢

     单体架构代码量很大，部署时间很长，有的老项目光启动都会花费几十分钟，极大的增加了对=开发的困难，降低了效率

  4. 阻碍技术创新

     单体架构各个模块耦合性极高，对于项目的升级迭代成本极高

  5. 无法按需伸缩

     在实现新的需求是单体架构必须要考虑到其他模块是否会受到影响，我们不能因为扩展功能而损害其他模块的性能

既然单体架构凸显了这些困难，那么微服务在这些问题上肯定是给出了解决方案，这也是微服务比起单体架构的优点：

1. 易于开发和维护：一个微服务只会关注一个特定的业务功能，所以业务清晰、代码量较少。开发和维护单个微服务相对简单。
2. 单个微服务启动较快
3. 局部修改容易部署：单体应用只要有修改，就得重新部署整个应用。微服务解决了这样的问题。一般来说，对某个微服务进行修改，只需要重新部署这个服务即可。
4. 技术栈不受限制：在微服务架构中，可以结合项目业务及团队的特点，合理的选择技术栈。
5. 按需伸缩：可根据需求，实现细粒度的扩展。

但是微服务也有它的缺点：

1. 运维要求高：更多的服务意味着要投入更多的运维
2. 分布式固有的复杂性：使用微服务构建的是分布式系统。对于一个分布式系统，系统容错、网络延迟、分布式事务等都会带来巨大的问题。
3. 接口调整成本高：微服务之间通过接口进行通信。如果修改某一个微服务的API，可能所有用到这个接口的微服务都需要进行调整。

2.什么是SpringCloud

springcloud是微服务系统中的一站式解决方案，是一系列框架的有序集合，是一个微服务框架的规范。他包含各个组件：

1. 服务的注册与发现
2. 负载均衡
3. 服务熔断和限流
4. 智能路由
5. 控制总线
6. 链路监控

注意：springcloud规范下各个框架的版本都有严格的要求，为了避免框架的版本冲突，请参考官方文档查看springcloud对应的springboot版本

springcloud官方文档查询

3.创建springcloud父工程

1. 首先在idea创建一个mavn项目，将.idea和src文件都删除，只保留一个pom.xml文件

2. 然后在父工程控制依赖版本，这样做的好处是们可以通过修改父工程的pom文件直接进行迭代升级，而不需要手动去管理各个微服务的版本。

  <packaging>pom</packaging>

  <name>Maven</name>
  <!-- FIXME change it to the project's website -->
  <url>http://maven.apache.org/</url>
  <inceptionYear>2001</inceptionYear>

<!--版本管理-->
  <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.18.20</lombok.version>
    <mysql.version>8.0.25</mysql.version>
    <jdbc.version>2.5.3</jdbc.version>
    <netflix.eureka.server.version>2.2.5.RELEASE</netflix.eureka.server.version>
    <netflix.eureka.client.version>2.2.5.RELEASE</netflix.eureka.client.version>
    <mybatis.spring.boot.version>1.3.2</mybatis.spring.boot.version>
    <spring.boot.devtools.version>2.3.6.RELEASE</spring.boot.devtools.version>
  </properties>

  <!-- 子模块继承之后，提供作用：锁定版本+子模块不用写groupId和version  -->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        <version>${netflix.eureka.client.version}</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <version>${spring.boot.devtools.version}</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        <version>${netflix.eureka.server.version}</version>
      </dependency>
      <!--  springboot 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>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
        <version>${jdbc.version}</version>
      </dependency>
      <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.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>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
      </dependency>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.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>
        <version>2.5.1</version>
        <configuration>
          <fork>true</fork>
          <addResources>true</addResources>
        </configuration>
      </plugin>
    </plugins>
  </build>

这里注意 和 的区别,通常用于父工程的pom文件中，在创建子模块时导入的对应依赖可以不用添加版本号，pom文件会向上追溯到父工程，引用父工程中的版本依赖。父工程这里只是版本管理，并没有真正的导入依赖，子模块还是需要在导入对应依赖，如果添加版本号，就采用子模块导入的版本，如果未添加版本号，就采用父工程的版本。

4.小结

好啦，springcloud的父工程已经创建成功了，接下来只需要在父工程下创建对应的模块就可以了。