GVKun编程网logo

Spring Cloud配置版本控制（spring cloud 配置）

30

本文的目的是介绍SpringCloud配置版本控制的详细情况，特别关注springcloud配置的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解SpringCloud

本文的目的是介绍Spring Cloud配置版本控制的详细情况，特别关注spring cloud 配置的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解Spring Cloud配置版本控制的机会，同时也不会遗漏关于(七十) springcloud+springcloud+vue+uniapp分布式微服务电商 商城之Spring Cloud Eureka控制台快速查看Swagger文档、(七十七) springcloud+springcloud+vue+uniapp分布式微服务电商 商城之Spring Cloud集成Spring Data Redis、(二) 跟我学习SpringCloud-Spring Cloud是什么？Spring Cloud版本介绍?、F版本SpringCloud 2—什么是SpringCloud？SpringCloud版本选择的知识。

本文目录一览：

Spring Cloud配置版本控制（spring cloud 配置）

Spring Cloud配置版本控制（spring cloud 配置）

我在application.properties文件中具有所有常用属性。版本特定的属性位于github中的version1和version2文件夹中。

order-service(base folder)    application.properties    version1        app-dev.properties    version2        app-dev.properties

我如何在application.yml文件中设置配置以确保云配置服务器在击中version1
url时会返回版本1的道具以及常见的道具。下面是我现在要从基本文件夹中获取道具的配置，那怎么可能修改以实现上述目的。

spring:  cloud:    config:      server:        git:          uri: https://github.company.com/orders-properties          username: orders          password: orders          search-paths: order-service

答案1

小编典典

如果我理解正确，这就是您所需要的。

假设您有两个名为 app-dev-v1 和 app-dev-v2的应用程序 。

您需要在resources文件夹内添加bootstrap.yml文件，并在两个应用程序上都添加此属性。

对于app-dev-v1

spring:  application:    name: app-dev-v1

对于app-dev-v2

spring:  application:    name: app-dev-v2

在版本库和版本2文件夹中，您可以在存储库中拥有一个.yml或.properties文件。

app-dev-v1.yml 和 app-dev-v2.yml

同样对于配置服务器，您需要添加搜索路径：

spring:  cloud:    config:      server:        git:          uri: https://github.company.com/orders-properties          username: orders          password: orders          search-paths: order-service,version*

(七十) springcloud+springcloud+vue+uniapp分布式微服务电商 商城之Spring Cloud Eureka控制台快速查看Swagger文档

(七十) springcloud+springcloud+vue+uniapp分布式微服务电商 商城之Spring Cloud Eureka控制台快速查看Swagger文档

本节主要介绍如何在 Eureka 控制台快速查看 Swagger 文档和 Swagger 测试接口时需要完成的请求认证。

Eureka 控制台快速查看 Swagger 文档

在服务很多的情况下，我们想通过 Eureka 中注册的实例信息，能够直接跳转到 API 文档页面，这个时候可以定义 Eureka 的 Page 地址。在 application.properties 中增加如下配置即可：

eureka.instance.status-page-url=http://${spring.cloud.client.ip-address}: ${server.port}/swagger-ui.html

在 Eureka Web 控制台就可以直接点击注册的实例跳转到 Swagger 文档页面了，如图 1 所示。

请求认证

当我们的服务中有认证的逻辑，程序中会把认证的 Token 设置到请求头中，在用 Swagger 测试接口的时候也需要带上 Token 才能完成接口的测试。

点击 Authorize 按钮（如图 2 所示），填写认证信息（如图 3 所示）。

默认的请求头名称是 Token，这里改成了 Authorization，通过配置文件修改：

swagger.authorization.key-name=Authorization

推荐电子商务源码

(七十七) springcloud+springcloud+vue+uniapp分布式微服务电商 商城之Spring Cloud集成Spring Data Redis

(七十七) springcloud+springcloud+vue+uniapp分布式微服务电商 商城之Spring Cloud集成Spring Data Redis

Redis 是一个开源的使用 ANSI C 语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value 数据库，并提供多种语言的 API。

Redis 是一个高性能的 key-value 数据库，同时支持多种存储类型，包括 String（字符串）、List（链表）、Set（集合）、Zset（sorted set——有序集合）和 Hash（哈希类型）。

用 Redistemplate 操作 Redis

在 Java 中操作 Redis 我们可以用 Jedis，也可以用 Spring Data Redis。

本节我们基于 Spring Data Redis 操作 Redis，Spring Data Redis 也是基于 Jedis 来实现的，它在 Jedis 上面封装了一层，让我们操作 Redis 更加简单。

关于在 Spring Boot 中集成 Spring Data Redis 不做过多讲解，本节主要讲怎么用 Redistemplate 操作 Redis。

Redistemplate 是一个泛型类，可以指定 Key 和 Value 的类型，我们以字符串操作来讲解，可以直接用 StringRedisTemplate 来操作。

在使用的类中直接注入 StringRedisTemplate 即可，如下代码所示。

@Autowired
private StringRedisTemplate stringRedisTemplate;

StringRedisTemplate 中提供了很多方法来操作数据，主要有以下几种：

  • opsForValue：操作 Key Value 类型
  • opsForHash：操作 Hash 类型
  • opsForList：操作 List 类型
  • opsForSet：操作 Set 类型
  • opsForZSet：操作 opsForZSet 类型

下面我们以 Key Value 类型来讲解，设置一个缓存，缓存时间为 1 小时，如下代码所示。

stringRedisTemplate.opsForValue().set("key", "鸿鹄云商", 1, TimeUnit.HOURS);

获取缓存，如下代码所示。

String value = stringRedisTemplate.opsForValue().get("key");

删除缓存，如下代码所示。

stringRedisTemplate.delete("key");

判断一个 key 是否存在，如下代码所示。

boolean exists = stringRedisTemplate.hasKey("key");

如果你不喜欢用这些封装好的方法，想要用最底层的方法来操作也是可以的。通过 StringRedisTemplate 可以拿到 RedisConnection，如下代码所示。

RedisConnection connection = stringRedisTemplate.getConnectionFactory().getConnection();

用 Repository 操作 Redis

凡是 Spring Data 系列的框架，都是一种风格，我们都可以用 Repository 方式来操作数据。下面我们看下怎么使用 Repository。

定义一个数据存储的实体类，@Id 类似于数据库中的主键，能够自动生成，RedisHash 是 Hash 的名称，相当于数据库的表名，如下代码所示。

@Data
@RedisHash("persons")
public class Person {
    @Id
    String id;
    String firstname;
    String lastname;
}

定义 Repository 接口，代码如下所示。

public interface PersonRepository extends CrudRepository<Person, String> {
}

使用接口对数据进行增删改查操作，代码如下所示。

@Autowired
PersonRepository repo;
public void basicCrudOperations() {
    Person person = new Person("张三", "zhangsan");
    repo.save(person);
    repo.findOne(person.getId());
    repo.count();
    repo.delete(person);
}

数据保存到 Redis 中会变成两部分，一部分是一个 set，里面存储的是所有数据的 ID 值，另一部分是一个 Hash，存储的是具体每条数据。

Spring Cache缓存数据

一般的缓存逻辑都是下面代码这样的方式，首先判断缓存中是否有数据，有就获取数据返回，没有就从数据库中查数据，然后缓存进去，再返回。

public Person get(String id) {
    Person person = repo.findOne(id);
    if (person != null) {
        return person;
    }
    person = dao.findById(id);
    repo.save(person);
    return person;
}

首先这种方式在逻辑上是肯定没有问题的，大部分人也都是这么用的，不过当这种代码充满整个项目的时候，看起来就非常别扭了，感觉有点多余，不过通过 Spring Cache 就能解决这个问题。我们不需要关心缓存的逻辑，只需要关注从数据库中查询数据，将缓存的逻辑交给框架来实现。

Spring Cache 利用注解方式来实现数据的缓存，还具备相当的灵活性，能够使用 SpEL（Spring Expression Language）来定义缓存的 key，还能定义多种条件判断。

Spring Cache 的注解定义在 spring-context 包中，如图 1 所示。

常用的注解有 @Cacheable、@CachePut、@CacheEvict。

  • @Cacheable：用于查询的时候缓存数据。
  • @CachePut：用于对数据修改的时候修改缓存中的数据。
  • @CacheEvict：用于对数据删除的时候清除缓存中的数据。

首先我们配置一下 Redistemplate，设置下序列化方式为 JSON，这样存在于 Redis 中的数据查看起来就比较方便了，如下代码所示。

@Configuration
@EnableCaching
public class RedisConfig {
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
        redisTemplate.setConnectionFactory(factory);
        redisTemplate.afterPropertiesSet();
        setSerializer(redisTemplate);
        return redisTemplate;
    }
    private void setSerializer(RedisTemplate<String, String> template) {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(jackson2JsonRedisSerializer);
    }
}

除了 Json 序列化，还有很多其他的序列化方式，读者可以根据自己的需求来设置，序列化的类在 Spring-Data-Redis 包中，如图 2 所示。

除了配置序列化方式，我们还可以配置 CacheManager 来设置缓存的过期时间，代码如下所示。

@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
    RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofDays(1)).disableCachingNullValues()
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                    .fromSerializer(new GenericJackson2JsonRedisSerializer()));
    return RedisCacheManager.builder(factory).cacheDefaults(cacheConfiguration).build();
}

还可以配置缓存 Key 的自动生成方式，这里是用类名+方法名+参数来生成缓存的 Key，只有这样才能让 Key 具有唯一性，当然你也可以使用默认的 org.springframework.cache.interceptor.SimpleKeyGenerator，代码如下所示。

@Bean
public KeyGenerator keyGenerator() {
    return new KeyGenerator() {
        @Override
        public Object generate(Object target, Method method, Object... params) {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(":" + method.getName());
            for (Object obj : params) {
                sb.append(":" + obj.toString());
            }
            return sb.toString();
        }
    };
}

接下来，我们改造一下上面定义的get方法，用注解的方式来使用缓存，具体代码如下所示。

@Cacheable(value="get", key="#id")
public Person get(String id) {
    return findById(id);
}

@Cacheable 中的 value 我们可以定义成与方法名称一样。标识这个方法的缓存 key，会在 Redis 中存储一个 Zset，Zset 的 key 就是我们定义的 value 的值，Zset 中会存储具体的每个缓存的 key，也就是当调用 get("1001") 的时候，Zset 中就会存储 1001，同时 Redis 中会有一个单独的 String 类型的数据，Key 是 1001。

#id 是 SpEL 的语法，通过参数名来定义缓存 key，上面的 key 如果直接用参数 id 来定义的话会出问题的，比如当另一个缓存方法的参数也是 1001 的时候，这个 key 就会冲突。所以我们最好还是定义一个唯一的前缀，然后再加上参数，这样就不会有冲突了，比如：key="''get''+#id"。

除了用 SpEL 来自定义key，我们刚刚其实配置了一个 keyGenerator，它就是用来生成 key 的，使用方法代码如下所示。

@Cacheable(value = "get", keyGenerator = "keyGenerator")
public Person get(String id) {
    return findById(id);
}

指定 keyGenerator 后，就可以不用配置 key，通过 keyGenerator 会自动生成缓存的 key，生成的规则就是我们配置中自己定义的，我们可以看到使用我们自定义的 keyGenerator 之后，存储在 Redis 中的数据的 key 是很长的一个字符串，规则也就是我们自定义的类名+方法名+参数。

@CachePut、@CacheEvict 的用法和 @Cacheable 一样，本节不做演示。

缓存异常处理

在用注解进行自动缓存的过程中，包括 Redis 的链接都是框架自动完成的，在缓存过程中如果 Redis 连接不上出现了异常，这时候整个请求都将失败。

缓存是一种辅助的手段，就算不能用，也不能影响正常的业务逻辑，如果我们直接用 Redis 的连接或者 Redistemplate 来操作的话可以通过异常捕获来解决这个问题，在用注解进行自动缓存的时候我们需要定义异常处理类来对异常进行处理。

@Configuration
public class CacheAutoConfiguration extends CachingConfigurerSupport {
    private Logger logger = LoggerFactory.getLogger(CacheAutoConfiguration.class);
    /**
     * redis 数据操作异常处理, 这里的处理：在日志中打印出错误信息, 但是放行
     * 保证 redis 服务器出现连接等问题的时候不影响程序的正常运行, 使得能够出问题时不用缓存 , 继续执行业务逻辑去查询 DB
     *
     * @return
     */
    @Bean
    public CacheErrorHandler errorHandler() {
        CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
            @Override
            public void handleCacheGetError(RuntimeException e, Cache cache, Object key, Object value) {
                logger.error("redis 异常：key=[{}]", key, e);
            }
            @Override
            public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
                logger.error("redis 异常：key=[{}]", key, e);
            }
            @Override
            public void handleCacheClearError(RuntimeException e, Cache cache) {
                logger.error("redis 异常：", e);
            }
            @Override
            public void handleCacheClearError(RuntimeException e, Cache cache) {
                logger.error("redis 异常：", e);
            };
            return cacheErrorHandler;
        }
    }
}

通过上面的处理，即使 Redis 挂掉了，程序连接不上时也不会影响业务功能，而是会继续执行查询数据库的操作。

自定义缓存工具类

在上面代码中，我们首先判断缓存中是否有数据，如果没有就从数据库中查询，然后再缓存进行，这样操作比较麻烦，还得写判断。使用注解的方式相对来说就简单多了，如果你不想用注解的方式，还是想在代码层面自己做缓存控制，那么我们可以自己封装一个工具类来避免写大量的判断操作。笔者以字符串操作为例，不涉及反序列化为对象的封装，封装缓存的基本操作，读者可以自行扩展。

首先定义一个缓存操作的接口，提供获取缓存，删除缓存操作，具体代码如下所示。

public interface CacheService {
    /**
     * 设置缓存
     *
     * @param key      缓存 KEY
     * @param value    缓存值
     * @param timeout  缓存过期时间
     * @param timeUnit 缓存过期时间单位
     */
    public void setCache(String key, String value, long timeout, TimeUnit timeUnit);
    /**
     * 获取缓存
     *
     * @param key 缓存KEY
     * @return
     */
    public String getCache(String key);
    public <V, K> String getCache(K key, Closure<V, K> closure);
    public <V, K> String getCache(K key, Closure<V, K> closure, long timeout, TimeUnit timeUnit);
    /**
     * 删除缓存
     *
     * @param key缓存KEY
     */
    public void deleteCache(String key);
}

实现类代码如下所示。

@Service
public class CacheServiceImpl implements CacheService {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    private long timeout = 1L;
    private TimeUnit timeUnit = TimeUnit.HOURS;
    @Override
    public void setCache(String key, String value, long timeout, TimeUnit timeUnit) {
        stringRedisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }
    @Override
    public String getCache(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
    @Override
    public void deleteCache(String key) {
        stringRedisTemplate.delete(key);
    }
    @Override
    public <V, K> String getCache(K key, Closure<V, K> closure) {
        return doGetCache(key, closure, this.timeout, this.timeUnit);
    }
    @Override
    public <V, K> String getCache(K key, Closure<V, K> closure, long timeout, TimeUnit timeUnit) {
        return doGetCache(key, closure, timeout, timeUnit);
    }
    private <K, V> String doGetCache(K key, Closure<V, K> closure, long timeout, TimeUnit timeUnit) {
        String ret = getCache(key.toString());
        if (ret == null) {
            Object r = closure.execute(key);
            setCache(key.toString(), r.toString(), timeout, timeUnit);
            return r.toString();
        }
        return ret;
    }
}

定义一个方法回调的接口，用于执行回调的业务逻辑。代码如下所示。

public interface Closure<O, I> {
    public O execute(I input);
}

下面我们对这个缓存操作类的代码进行讲解。简单的 set 和 get 缓存不做过多讲解，因为和直接使用 RedisTemplate 没什么区别，本节主要讲的是基于方法的回调实现缓存。

我们的目的也很简单，就是先去判断缓存中是否存在，不存在的话则从数据库查询，然后将插入到缓存中的逻辑统一，不用每个方法中都去写这个判断的逻辑。

方法的回调实现是基于 Closure 接口来做的，使用方法代码如下所示。

@Autowired
private CacheService cacheService;
public String get() {
    String cacheKey = "1001";
    return cacheService.getCache(cacheKey, new Closure<String, String>() {
        @Override
        public String execute(String id) {
            // 执行你的业务逻辑
            return userService.getById(id);
        }
    });
}

通过这样的封装，我们就不用在每个缓存的地方都去判断了，当缓存中有值的时候，getCache 方法会根据缓存的 key 去缓存中获取，然后返回；如果没有值的话会执行 execute 中的逻辑获取数据，然后缓存起来再返回。

推荐电子商务源码

(二) 跟我学习SpringCloud-Spring Cloud是什么？Spring Cloud版本介绍?

(二) 跟我学习SpringCloud-Spring Cloud是什么？Spring Cloud版本介绍?

Spring Cloud 是一系列框架的有序集合。它利用 Spring Boot 的开发便利性，巧妙地简化了分布式系统基础设施的开发，如服务注册、服务发现、配置中心、消息总线、负载均衡、断路器、数据监控等，这些都可以用 Spring Boot 的开发风格做到一键启动和部署。

通俗地讲，Spring Cloud 就是用于构建微服务开发和治理的框架集合（并不是具体的一个框架），主要贡献来自 Netflix OSS。

Spring Cloud 模块介绍

Spring Cloud 模块的相关介绍如下：

  • Eureka：服务注册中心，用于服务管理。
  • Ribbon：基于客户端的负载均衡组件。
  • Hystrix：容错框架，能够防止服务的雪崩效应。
  • Feign：Web 服务客户端，能够简化 HTTP 接口的调用。
  • Zuul：API 网关，提供路由转发、请求过滤等功能。
  • Config：分布式配置管理。
  • Sleuth：服务跟踪。
  • Stream：构建消息驱动的微服务应用程序的框架。
  • Bus：消息代理的集群消息总线。

除了上述模块，还有 Cli、Task等。教程中只介绍一些常用的模块。
Spring Cloud 是一个非常好的框架集合，它包含的功能模块非常多，不可能一一讲解到，凡是在教程中出现的模块都是真实开发中用得到的。

Spring Cloud 版本介绍

相信大家跟笔者一样，在第一次访问 Spring Cloud 官网时一定会有一个疑惑那就是版本太多了，到底哪个是稳定版本？哪个才是自己需要的版本？接下来就给大家简单介绍一下版本的问题。
访问官网 https://spring.io/projects/spring-cloud 可以看到网页右侧的版本列表，如图 1 所示。


从图 1中可以看到 Spring Cloud 不是像别的项目那样，版本号采用 1.1、1.2、1.3 这种的格式。因为 Spring Cloud 是一个拥有诸多子项目的大型综合项目，可以说是对微服务架构解决方案的综合套件组件，其中包含的各个子项目都独立进行着内容的迭代与更新，各自维护着自己的发布版本号。

至于怎么选择适合自己的版本，笔者认为，大家可以在接触的时候直接选最新的稳定版本。新版本中的 Bug 肯定要少，并且更稳定。

本教程的案例都是基于 Finchley SR2 进行讲解的。不同的版本有不同的功能，对应的每个子模块的版本也不一样，那么如何知道每个大版本下面具体的子模块是什么版本呢？

答案就在官网的首页上面，在页面的最下方有一个表格（见表 1 ），通过这个表格我们可以清楚地知道 Finchley SR2 对应的 Spring Boot 版本是 2.0.6.RELEASE，Spring-Cloud-Bus 是 2.0.0.RELEASE。

推荐布式架构源码

表 1 Spring Cloud版本列表
Component Edgware.SR5 Finchley.SR2 Finchley.BUILD-SNAPSHOT
spring-cloud-aws 1.2.3RELEASE 2.0.1.RELEASE 2.0.1.BUILD-SNAPSHOT
spring-cloud-bus 1.3.3.RELEASE 2.0.0.RELEASE 2.0.1.BUILD-SNAPSHOT
spring-cloud-cli 1.4.1.RELEASE 2.0.0.RELEASE 2.0.1.BUILD-SNAPSHOT
spring-cloud-commons 1.3.5.RELEASE 2.0.2.RELEASE 2.0.2.BUILD-SNAPSHOT
spring-cloud-contract 1.2.6.RELEASE 2.0.2.RELEASE 2.0.2.BUILD-SNAPSHOT
spring-cloud-config 1.4.5.RELEASE 2.0.2.RELEASE 2.0.2.BUILD-SNAPSHOT
spring-cloud-netflix  1.4.6.RELEASE  2.0.2.RELEASE 2.0.2.BUILD-SNAPSHOT
spring-cloud-security 1.2.3.RELEASE 2.0.1.RELEASE 2.0.1.BUILD-SNAPSHOT
spring-cloud-cloudfoundry 1.1.2.RELEASE 2.0.1.RELEASE 2.0.1.BUILD-SNAPSHOT
spring-cloud-consul  1.3.5.RELEASE 2.0.1.RELEASE 2.0.2.BUILD-SNAPSHOT
spring-cloud-sleuth  1.3.5.RELEASE 2.0.2.RELEASE 2.0.2.BUILD-SNAPSHOT
spring-cloud-stream  Ditmars.SR4 Elmhurst.SRI Elmhurst. BUILD-SNAPSHOT
spring-cloud-zookeeper 1.2.2.RELEASE 2.0.0.RELEASE 2.0.1.BUILD-SNAPSHOT
spring-boot 1.5.16.RELEASE 2.0.6.RELEASE  2.0.7.BUILD-SNAPSHOT
spring-cloud-task 1.2.3.RELEASE 2.0.0.RELEASE 2.0.1.BUILD-SNAPSHOT
spring-cloud-vault 1.1.2.RELEASE  2.0.2.RELEASE 2.0.2.BUILD-SNAPSHOT                                                    
spring-cloud-gateway 1.0.2.RELEASE 2.0.2.RELEASE  2.0.2.BUILD-SNAPSHOT

F版本SpringCloud 2—什么是SpringCloud？SpringCloud版本选择

F版本SpringCloud 2—什么是SpringCloud？SpringCloud版本选择

引言：搭建微服务架构就像是买电脑，使用SpringCloud就是在买品牌机。

前言

昂，美好的天气里，不想直接说技术，给小伙伴萌看看傍晚的天空吧。

—— 能找到天上的北极星吗？

上一篇文章中，通过一个简单的小故事，轻松愉快的讲解了架构的演变，以及为啥会有微服务，什么是微服务。不过在最后留下了一个小疑问：将架构设计为微服务需要一整套技术，解决服务调用，服务治理，服务监控等问题。

那么这些技术怎么来呢？

答案就是：SpringCloud。

本文就会详细讲解

  • 什么是SpringCloud
  • SpringCloud和SpringBoot的关系
  • SpringCloud版本选择

什么是SpringCloud

引言：搭建微服务架构就像是买电脑，使用SpringCloud就是在买品牌机。

SpringCloud，基于SpringBoot提供了一套微服务解决方案，包括服务注册与发现，配置中心，全链路监控，服务网关，负载均衡，熔断器等组件，除了基于NetFlix的开源组件做高度抽象封装之外，还有一些选型中立的开源组件。

NetFlix 是美国的一个在线视频网站,微服务业的翘楚,他是公认的大规模生产级微服务的杰出实践者,NetFlix的开源组件已经在他大规模分布式微服务环境中经过多年的生产实战验证,因此spring cloud中很多组件都是基于NetFlix组件的封装

在上篇文章中我们讲到微服务是一套技术的合集，这些技术里面有服务调用技术，负载均衡技术，网关技术等等大大小小十几个技术。

那么问题来了？在开发中，我们怎么才能找到这样一整套技术呢？

第一种方案：就是自己需要什么找什么技术，但是这样会有一个问题，技术和技术之间往往都会有一些兼容性的问题，要解决这些问题，需要很强的技术示例，中小型企业一般没有这样的实力。

第二种方案：一些有实力的公司会自己寻找一整套技术，并且做一些封装和整合，然后开源让大家使用。SpringCloud就是这样的技术，SpringCloud是官方封装好的一整套分布式微服务的技术解决方案，我们也称之为微服务全家桶。

举个通俗的例子：开发微服务相当于买一台电脑

  1. 自己找微服务的技术相当于自己组装电脑，需要自己选配零部件，并且做组装整合，一般人搞不定。
  2. 使用SpringCloud相当于直接买了一个联想的电脑，买品牌机，厂家会把CPU 显卡等等都帮你配置好了，买来就能用。

SpringCloud包含的技术：

.....等一二十个技术，网址：https://www.springcloud.cc/

SpringCloud 和 SpringBoot的关系

用过SpringBoot的小伙伴都知道，SpringBoot开发之所以方便快捷，就是因为SpringBoot自动配置可以让我们在开发的时候不写基本的配置，通过完美的封装让应用可以做到一键启动和部署，而SpringCloud多个技术整合，最复杂的过程往往是配置。

所以SpringCloud选择SpringBoot作为技术底层，对目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，进行二次封装，屏蔽掉了复杂的配置和实现原理。让我们使用SpringCloud像使用SpringBoot一样的简单。

SpringCloud和SpringBoot的版本选择

关于SpringCloud和SpringBoot的版本选择问题，可以见官网：https://spring.io/projects/sp...

我们选择的是 Finchley 版本的SpringCloud，SpringBoot的版本就要选择 2.0.X。

解释一下 SpringCloud 版本号：SpringCloud 版本的命名规范实际上是 英文单词 SRX 的形式命名

  • SpringCloud的版本号没有采用 数字 命名，而是英文的单词，？Angel、Brixton、Camden等都是伦敦地铁站的名称，它们按照字母顺序发行。这个是主版本号，我们一般会称之为 F版本，D版本。
  • 后面的SR表示“Service Release”，一般表示Bug修复；在SR版本发布之前，会先发布一个Release版本，例如Camden RELEASE。

总结

恭喜你完成了本章的学习，为你鼓掌！如果本文对你有帮助，请帮忙点赞，评论，转发，这对作者很重要，谢谢。

要掌握SpringCloud更多的用法，请持续关注本系列教程。

欢迎关注本人公众号：鹿老师的Java笔记，将在长期更新Java技术图文教程和视频教程，Java学习经验，Java面试经验以及Java实战开发经验。

今天关于Spring Cloud配置版本控制和spring cloud 配置的讲解已经结束，谢谢您的阅读，如果想了解更多关于(七十) springcloud+springcloud+vue+uniapp分布式微服务电商 商城之Spring Cloud Eureka控制台快速查看Swagger文档、(七十七) springcloud+springcloud+vue+uniapp分布式微服务电商 商城之Spring Cloud集成Spring Data Redis、(二) 跟我学习SpringCloud-Spring Cloud是什么？Spring Cloud版本介绍?、F版本SpringCloud 2—什么是SpringCloud？SpringCloud版本选择的相关知识，请在本站搜索。

本文标签：

上一篇使用jackson和spring-boot将base64编码的JSON解码为POJO

下一篇“ Java DateFormat不是线程安全的”这将导致什么？（java date线程安全吗）

相关文章