# springcloud2021

**Repository Path**: BeheadingKill/springcloud2021

## Basic Information

- **Project Name**: springcloud2021
- **Description**: springCloud相关技术学习总结
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-12-26
- **Last Updated**: 2022-01-04

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Springboot版本和springcloud版本
## springboot版本
<b>spring-boot的git源码地址:https://github.com/spring-projects/spring-boot/releases/</b>  
## springcloud版本
<b>spring-cloud的git源码地址:https://github.com/spring-projects/spring-cloud</b>  
<b>springcloud官网：https://spring.io/projects/spring-cloud</b>
```
Spring Cloud 采用了英国伦敦地铁站的名称来命名，并由地铁站名称字母A-Z依次类推的形式来发布迭代版本
SpringCloud是一个由许多子项目组成的综合项目，各子项目有不同的发布节奏。

为了管理SpringCloud与各子项目的版本依赖关系，发布了一个清单，其中包括了某个SpringCloud版
本对应的子项目版本。为了避免SpringCloud版本号与子项目版本号混淆，SpringCloud版本采用了名
称而非版本号的命名，这些版本的名字采用了伦敦地铁站的名字，根据字母表的顺序来对应版本时间顺序。
例如Angel是第一个版本, Brixton是第二个版本。

当SpringCloud的发布内容积累到临界点或者一个重大BUG被解决后，会发布一个"service releases"版本，
简称SRX版本，比如Greenwich.SR2就是SpringCloud发布的Greenwich版本的第2个SRX版本

从 Spring Cloud 2020.0.0-M1 开始，Spring Cloud 废除了这种英国伦敦地铁站的命名方式，而使用了全新的 
"日历化" 版本命名方式,例如：
Spring Cloud 2020.0.0-M1 Released
```
![springcloud多版本](image/springcloud多版本.png)   

## springboot与springcloud的关系
<b>springBoot与springCloud的关系，如：https://spring.io/projects/spring-cloud#overview</b>  
![springboot与springcloud的关系](image/boot与cloud的关系.png)   

<b>更详细的对应结果：https://start.spring.io/actuator/info</b>

## 本项目springboot与springcloud版本及其相关版本
1. springcloud  Hoxton.SR1
2. springboot   2.2.2.RELEASE
3. spring cloud alibaba 2.1.0.RELEASE
4. java jdk1.8
5. Maven 3.6.1
6. Mysql 5.7以上

<b>2.x常用组件的pom</b>  
```
<!--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>
```  

# springcloud的各种组件的停更/升级/替换

<b>cloud的组件条目:</b>
![cloud的组件条目](image/cloud的更新.png)  
<b>springcloud官方网站Hoxton.SR1文档：https://cloud.spring.io/spring-cloud-static/Hoxton.SR1/reference/htmlsingle/</b>  
<b>springcloud中文文档：https://www.bookstack.cn/read/spring-cloud-docs/docs-index.md</b>

<b>springboot2.2.2文档：https://docs.spring.io/spring-boot/docs/2.2.2.RELEASE/reference/htmlsingle/</b>
 

<b></b>
# 微服务架构编码构建

## 约定 >配置  > 编码

## idea新建project工作空间
### 微服务cloud整体聚合父工程Project
1. New Project
![cloud的组件条目](image/newproject.png)  
2. 聚合总父工程名字
![cloud的组件条目](image/聚合父工程名字.png)  
3. Maven选版本
![cloud的组件条目](image/maven版本.png)  
4. 工程名字
![cloud的组件条目](image/工程名字.png)  
5. 字符编码
![cloud的组件条目](image/字符编码.png)  
6. 注解生效激活
![cloud的组件条目](image/注解生效.png)  
7. java编译版本选8
![cloud的组件条目](image/选择jdk.png)  
8. File Type过滤
![cloud的组件条目](image/Filetype过滤.png)  

### 父工程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>mscloud03</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>
```

### Maven工程落地
#### Maven中的DependencyManagement和Dependencies
<b>dependencyManagement</b>
 
<b>Maven 使用dependencyManagement 元素来提供了一种管理依赖版本号的方式。  
通常会在一个组织或者项目的最顶层的父POM 中看到dependencyManagement 元素。</b>
 
<b>使用pom.xml 中的dependencyManagement 元素能让所有在子项目中引用一个依赖而不用显式的列出版本号。
Maven 会沿着父子层次向上走，直到找到一个拥有dependencyManagement 元素的项目，然后它就会使用这个
dependencyManagement 元素中指定的版本号。</b>
 
 
<b>这样做的好处就是：如果有多个子项目都引用同一样依赖，则可以避免在每个使用的子项目里都声明一
个版本号，这样当想升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要一个一个子项目
的修改 ；另外如果某个子项目需要另外的一个版本，只需要声明version就可。</b>
 
<b>dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。</b>
 
<b>如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，
并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;</b>
 
<b>如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。</b>