SpringCloud微服务总结

最新推荐文章于 2022-06-28 18:33:47 发布
最新推荐文章于 2022-06-28 18:33:47 发布
阅读量1.9k 收藏 68
点赞数 44
分类专栏： 面试 工作总结 文章标签： java spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40629687/article/details/120159974
版权

目录

一．微服务架构衍变

二．SpringCloud 概述

三．SpringCloud 实战

一．微服务架构衍变

  • 1.1 单体架构

    • 在应用初期，单体应用从成本、开发时间和运维等方面都有明显的优势，但是随着业务量和用户量的增加,导致代码的可读性和可维护性很差。同时面对海量的用户，数据库也会成为瓶颈。单体架构己经不能满足复杂的业务和海量的用户系统，改变单体架构势在必行。

  • 1.2 SOA 架构

    • Service Oriented Architecture 面向服务的架构

    • 也就是把工程拆分成服务层、表现层两个工程。服务层中包含业务逻辑，只需要对外提供服务即可。表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。

    • SOA架构下的系统编码更加灵活，提高了代码的重要性，且易于维护，同时提升了系统的伸缩性和高可用性，降低系统之间的耦合性

  • 1.3 微服务架构

    • “微服务”最初是由 软件工程师 Martin Fowler 2014 年写的《MicroServices》中提出来的 

    • 微服务架构是复杂的业务组件和，实际上也是一种面向服务的体现，他说SOA架构的一种实现，但是相比传统的SOA架构来讲它更为轻便】敏捷和简单。微服务架构的风格，就是将单一程序开发成一个微服务，每个微服务运行在自己的进程中，并使用轻量级机制通信，通常是HTTP RESTFUL API.这些服务围绕业务能力来划分构建的，并通过完全自动化部署机制来独立部署，这些服务可以使用不同的编程语言，以及不同数据存储技术，以保证最低限度的中式管理

    • 优点：

      • 1，由于每个服务都是独立并且微小的，由单独的团队负责，仍然可以采用敏捷开发模式，自由的选择合适的技术，甚至可以重写老服务，当然也要遵守统一的API约定

      • 2.每一个微服务都是独立部署的，可以进行快速迭代部署，根据各自服务需求选择合适的虚拟机和使用最匹配的服务资源要求的硬件

      • 3.降低系统之间的耦合性，因为采用HTTP方式交互，各个微服务可以使用不同的编程语言实现

    • 缺点：

      • 1.微服务应用作为分布式系统带来了复杂性。各个微服务进行分布式独立部署，当进行模块调用的时候，分布式变的更加麻烦

      • 2.微服务架构一般使用各个独立数据库，分布式事务的实现更具挑战性。

      • 3.测试微服务变的复杂，当一个服务依赖另一个服务时，测试时需要另一个服务的支持

      • 4.部署基于微服务的应用也很复杂，独立微服务的部署不但变得复杂，而且需要更高级别的自动化

二．SpringCloud 概述

  • 概述：

    • Spring Cloud的首要目标就是通过提供系列开发组件和框架，帮助开发者迅速搭建分布式的微服务系统。Spring Cloud是通过包装其它技术框架来实现的，例如包装开源的Netflix oss组件，实现了一套基于注解、java配置和基于模板开发的微服务框架。springCloud 框架来自于Spring Resources社区，由Pivotal和Netflix两大公司和其他开发者提供技术上的更新迭代

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

  • 2.1 SpringCloud 的特性

    • Spirng Cloud专注于提供良好的开箱即用经验的典型用例和可扩展性机制覆盖。

    • 分布式/版本配置

    • 服务注册和发现

    • 路由

    • service - to - service调用

    • 负载均衡

    • 断路器

    • 分布式消息传递

  • 2.2 SpringCloud 的组成

    • 1.服务注册和发现组件Eureka

      • 利用Eureka组件可以很轻松地实现服务的注册和发现的功能

    • 2.熔断组件Hystrix

      • 它提供了熔断功能，能够组织分布式系统中出现联动故障

    • 3.负载均衡组件Ribbon

      • Ribbon是将负载均衡逻辑封装在客户端中，并且运行在客户端的进程里

    • 4.声明式调用Feign

      • Feign使得服务调用变得更加简单优雅

    • 5.路由网关zuul

      • zuul作为微服务系统的网关组件，用于构建边界服务，致力于动态路由、过滤、监控、弹性伸缩和安全

    • 6.Spring Cloud Config

      • config server可以从本地仓库读取配置文件，也可以从远处git仓库读取，是SpirngCloud分布式开发下的配置中心组件

  • 2.3 SpringCloud 的版本

    • 注意：

      • Finchley 与 Spring Boot 2.0.x, 兼容，不支持 Spring Boot 1.5.x.

      • Dalston 和 Edgware 与 Spring Boot 1.5.x, 兼容，不支持 Spring Boot 2.0.x.

  • 2.4 SpringCloud 和 Dubbo 的比较

    • springcloud有很多的项目模块，包含了微服务系统的方方面面，dubbo是一个非常优秀的服务治理和服务调用框架，但缺少很多功能模块，例如网关、链路追踪等。在项目模块上，springcloud占据更大的优势，从开发速度上讲，springcloud基于springboot注解无配置的开发模式，具有更高的开发和部署速度。

    • springcloud的通信方式大多数是基于http restful风格的，服务与服务之间无关、无耦合。由于采用的是http rest，此服务无关乎语言和平台，只需要提供API接口就可以实现相互调用。dubbo的通信方式基于远程调用，对接口、平台和语言有较强依赖，如果需要实现跨平台代用服务，需要额外的中间件

    • 基于RPC协议的dubbo速率上要比基于http的springcloud效率高很多

三．SpringCloud 实战

  • 3.1 创建父工程

    • 创建父工程：micro-service-parent，通过父工程统一管理 SpringCloud 组件的版本号。我 使 用 jdk 为 1.8 版 本 ， springBoot 为 2.0.6.RELEASE 版 本 ， SpringCloud 为Finchley.RELEASE 版本。

    •  使用 IDEA 创建 spring 实例工程,如图：

    •  修改 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> 
    <parent> 
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>             
        <version>2.0.6.RELEASE</version> <relativePath/> <!-- lookup parent from repository -->
    </parent> 
    <groupId>com.spring.microservice</groupId> 
    <artifactId>micro-service-parent</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
    <name>micro-service-parent</name> 
    <description>Demo project for Spring Boot</description> 
    
    <modules> 
        <module>micro-service-registry</module> 
        <module>micro-service-publish</module> 
        <module>micro-service-consumer</module> 
        <module>micro-service-feign</module> 
        <module>micro-service-zull</module>
    </modules>

    <!--版本信息-->
    <properties> 
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>     
        <dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency> 

        <dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies> 
            <dependency>
                <groupId>org.springframework.cloud</groupId> 
                <artifactId>spring-cloud-dependencies</artifactId> 
                <version>${spring-cloud.version}</version>
                <type>pom</type> 
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build> 
        <plugins> 
            <plugin> 
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

  • 3.2 Eureka

    • 3.2.1 Eureka 概述

      • 和 Zookeeper 类似，Eureka 是一个用于服务注册和发现的组件。Eureka 分为 Eureka Server 和 Eureka Client，Eureka Server 为 Eureka 服务注册中心，Eureka Client 为 Eureka客户端。

      • 服务注册是指向服务注册中心注册一个服务实例，服务提供者将自己的服务信息（如服务名、IP地址等）告知服务注册中心。服务发现是指当服务消费者需要另一个服务时，服务注册中心能够告知服务消费者它所要消费服务的实例信息（如服务名、地址等）。通常情况下一个服务既是服务提供者，也是消费者。服务消费者一般使用http协议或者消息组件这种轻量级的通信机制来进行服务消费

    • 3.2.2 注册中心 Eureka Server

    • 创建 micro-service-parent 子工程 micro-service-registry，并依赖 eureka-server。

    • 修改工程依赖 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"
14
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> 
        <parent> 
        <groupId>com.spring.microservice</groupId> 
        <artifactId>micro-service-parent</artifactId> 
        <version>0.0.1-SNAPSHOT</version>
    </parent> 
    <groupId>com.spring.microservice</groupId> 
    <artifactId>micro-service-registry</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
    <name>micro-service-registry</name> 
    <packaging>jar</packaging> 
    <description>Demo project for Spring Boot</description> 
    <dependencies> 
        <dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency> 
            <groupId>org.springframework.cloud</groupId> 
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency> 
        <dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-test</artifactId> 
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>
      修改 application.properties, 添加 eureka 配置信息 : 
      #注册中心端口
server.port=8081
#设置当前实例的主机名称
eureka.instance.hostname=localhost
#默认是启动服务注册的 此处关闭服务注册 表示不向注册中心注册自己
eureka.client.registerWithEureka=false
#由于注册中心的职责是维护服务实例，不需要检索服务，所以设置为 false
eureka.client.fetch-registry=false
#注册中心服务 URL
eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${s
erver.port}/eureka/
#注册中心服务名
spring.application.name=eurka-server
      在启动类上添加注解 @EnableEurekaServer 开启注册中心功能： 
      @EnableEurekaServer
@SpringBootApplication
public class MicroServiceRegistryApplication {
    public static void main(String[] args) {
        SpringApplication.run(MicroServiceRegistryApplication.class, args);
    } 
}
      启动成功后访问 :http://localhost:8081/, 显示如图：

    • 3.1.3 服务发布 Eureka Clinet

    • 创建 micro-service-parent 子工程 micro-service-publish ，并依赖 eureka-client 。

    •  修改 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>
    <parent> 
        <groupId>com.spring.microservice</groupId> 
        <artifactId>micro-service-parent</artifactId> 
        <version>0.0.1-SNAPSHOT</version>
    </parent> 
    <groupId>com.spring.microservice</groupId> 
    <artifactId>micro-service-publish</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
    <name>micro-service-publish</name> 
    <description>Demo project for Spring Boot</description>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency> 
        <dependency>
            <groupId>org.springframework.cloud</groupId> 
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency> 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId> 
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>
      修改 application.properties 文件，添加相关配置 
    • #指定服务端口
server.port=8082
#指定服务名称
spring.application.name=service-hi
#指定服务注册中心地址
eureka.client.service-url.defaultZone=http://localhost:8081/eureka/
      启动类添加 @EnableEurekaClient ，表明这是一个服务提供方 
      @SpringBootApplication
@EnableEurekaClient
public class MicroServicePublishApplication {
    public static void main(String[] args) {
        SpringApplication.run(MicroServicePublishApplication.class, args);
    } 
}
      创建 Controller ，添加 hi 接口 
      @RestController
public class EurekaPublishController {
    @Value("${server.port}")
    private String port;
    @RequestMapping("/hi")
    public String publish(@RequestParam(value = "name") String name){
        return name+"------port:"+port; 
    } 
}
      访问注册中心可以看到服务列表中新增 SERVICE-HI 服务信息：

    • 3.1.4 Eureka Server 的高可用

    • 修改 tomcat 启动配置为非单实例方式。

    • 修改 application.properties 文件，启动一个实例 
    • #注册中心端口
server.port=8181
#设置当前实例的主机名称
eureka.instance.hostname=server
#默认是启动服务注册的 此处关闭服务注册 表示不向注册中心注册自己
eureka.client.registerWithEureka=false
#由于注册中心的职责是维护服务实例，不需要检索服务，所以设置为 false
eureka.client.fetch-registry=false
#注册中心服务 URL
eureka.client.service-url.defaultZone=http://localhost:8081/eureka/
#注册中心服务名
spring.application.name=eurka-server
      修改 application.properties 文件，启动第二个实例 
      #注册中心端口
server.port=8081
#设置当前实例的主机名称
eureka.instance.hostname=server2
#默认是启动服务注册的 此处关闭服务注册 表示不向注册中心注册自己
eureka.client.registerWithEureka=false
#由于注册中心的职责是维护服务实例，不需要检索服务，所以设置为 false
eureka.client.fetch-registry=false
#注册中心服务 URL 此处写其他注册中心服务 URL
eureka.client.service-url.defaultZone=http://localhost:8181/eureka/
#注册中心服务名
spring.application.name=eurka-server
      分别访问： http://localhost:8181 和 http://localhost:8081 , 可以看到：

      启动服务，继续访问我们可以看到虽然服务只注册了一个注册中心，但是两个注册中心都可 以查看到服务列表中已存在该服务。

    • 3.1.5 Eureka Client 的高可用

    • 修改 tomcat 启动配置为非单实例方式。

    •  修改 application.properties 文件，端口为 8089：

    • #指定服务端口
server.port=8089
#指定服务名称
spring.application.name=service-hi
#指定服务注册中心地址
eureka.client.service-url.defaultZone=http://localhost:8081/eureka/
      再次启动服务，查看服务注册中心，可以看到同一个服务有两个实例了。

  • 3.3 Ribbon

    • 3.2.1 Ribbo 概述

      • 负载均衡是指将负载分摊到多个执行单元上，常见的负载均衡有两种方式。一种是独立进程单元，通过负载均衡策略，将请求转发到不同的执行单元上，例如nginx。另一种是负载均衡逻辑以代码的形式封装到服务消费者的客户端上，服务消费者客户端维护了一份服务提供的信息列表，有了信息列表，通过负载均衡策略将请求分摊给多个服务提供者，从而达到负载均衡的目的

      •  

      • ribbon是Netflix公司开源的一个负载均衡的组件，它属于上述的第二种方式，是将负载均衡逻辑封装在客户端中，并且运行在客户端的进程里，ribbon作为服务消费者的负载均衡器，有两种使用方式，一种是何restTemplate相结合，另一种是feign相结合。feign已经默认继承了ribbon

    • 3.2.2 RestTemplate 消费案例

    • 创建 micro-service-parent 子工程 micro-service-consumer ，并依赖 eureka-client 和
      ribbon 。 
    • <?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>
    <parent>
        <groupId>com.spring.microservice</groupId>
        <artifactId>micro-service-parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.spring.microservice</groupId>
    <artifactId>micro-service-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>micro-service-consumer</name>
    <description>Demo project for Spring Boot</description>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

       修改 application,properties 配置文件，指定相关信息

    • #指定 ribbon 服务名称
spring.application.name=eureka-ribbon-client
#设定当前服务端口
server.port=8083
#指定服务注册中心地址
eureka.client.service-url.defaultZone=http://localhost:8081/eureka
      添加 @EnableEurekaClient 注解，标识为 Eureka ，用于服务调用。 
    • @SpringBootApplication
@EnableEurekaClient
public class MicroServiceConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(MicroServiceConsumerApplication.class, args);
    } 
}
      创建配置类，获取 RestTemplate 对象 Bean ,LoadBalanced 注解使 restTemplate 在 http
      请求时候具备了负载均衡的能力。 
      package com.spring.micro.service.consumer.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;


@Configuration
public class RibbonConfig {
    @Bean
    @LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
      创建 service 类，通过 RestTemplate 调用服务： 
      package com.spring.micro.service.consumer.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class RibbonService {
    @Autowired
    RestTemplate restTemplate;

    public String hi(String name) {
        return
                restTemplate.getForObject("http://service-hi/hi?name=" + name, String.class);
    }
}
      创建 Controller 接口，调用服务 
      package com.spring.micro.service.consumer.controller;

import com.spring.micro.service.consumer.service.RibbonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RibbonController {
    @Autowired
    RibbonService ribbonService;

    @RequestMapping("/hi")
    public String hi(@RequestParam(required = false, defaultValue = "") String
                             name) {
        return ribbonService.hi(name);
    }
}
      启动服务，访问 http://localhost:8083/hi

       查看注册中心，可以看到服务消费方也是服务注册方：

    • 3.2.3 负载均衡案例

      • 创建高可用 Eureka 的服务实例，并启动。目前 eureka 服务有两个集群构成，那么我们继续访问 http://localhost:8083/hi，会发现 port 在 8082 和 8089 之间不断的切换，那么也我们也发现 ribbon 的负载均衡策略默认是轮流访问的方式进行的

      •  

  • 3.4 Feign

    • 3.4.1 Feign 概述

      • Feign受Retrofit、JAXRS-2.0和websocket影响，采用了声明式的api接口风格，将javahttp客户端绑定到它的内部。Feign的首要目的是将Javahttp客户端调用过程变得简单

    • 3.4.2 Feign 案例

    • 创 建 micro-service-parent 子 工 程 micro-service-feign ， 并 依 赖 eureka-client 和
      openfeign 。

    •  修改 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>
    <parent>
        <groupId>com.spring.microservice</groupId>
        <artifactId>micro-service-parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.spring.microservice</groupId>
    <artifactId>micro-service-feign</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>micro-service-feign</name>
    <description>Demo project for Spring Boot</description>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
      修改 application.properties 文件： 
    • #指定服务名称
spring.application.name=eureka-feign-client
#指定服务端口
server.port=8084
#指定注册中心 url
eureka.client.service-url.defaultZone=http://localhost:8081/eureka/
      添加注解 @EnableEurekaClient 和 @EnableFeignClients 在启动类： 
      package com.spring.microservice.feign;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class MicroServiceFeignApplication {
    public static void main(String[] args) {
        SpringApplication.run(MicroServiceFeignApplication.class, args);
    }
}
      创建 Feign 声明式调用接口，使用 @FeignClient 声明调用的服务名称，使用 requestMapping 声明调用的具体服务。 
      package com.spring.microservice.feign.client;

import com.spring.microservice.feign.config.FeignConfig;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;


@FeignClient(value = "service-hi", configuration = FeignConfig.class)
public interface EurekaClientFeign {
    @RequestMapping(value = "hi", method = RequestMethod.GET)
    String sayHi(@RequestParam(value = "name") String name);
}
      创建 Controller 使用 Feign 接口调用服务。 
      package com.spring.microservice.feign.controller;

import com.spring.microservice.feign.client.EurekaClientFeign;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class FeignController {
    @Autowired
    EurekaClientFeign eurekaClientFeign;

    @GetMapping("/hi")
    public String sayHi(@RequestParam(defaultValue = "", required = false) String name) {
        return eurekaClientFeign.sayHi(name);
    }
}
      使用 @Configuration 可以指定 FeignClient 的重试次数，重试间隔为 100ms ，最大重试时间 为 1s, 重试次数为 5 次 
      package com.spring.microservice.feign.config;

import feign.Retryer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import static java.util.concurrent.TimeUnit.SECONDS;


@Configuration
public class FeignConfig {
    @Bean
    public Retryer feignRetryer() {
        return new Retryer.Default(100, SECONDS.toMillis(1), 3);
    }
}

    • 3.3.3 负载均衡案例

      • 创建高可用 Eureka 的服务实例，并启动。目前 eureka 服务有两个集群构成，那么我们继续访问 http://localhost:8084/hi，会发现 port 在 8082 和 8089 之间不断的切换，那么也我们也发现 ribbon 的负载均衡策略默认是轮流访问的方式进行的。

      •  

  • 3.5 Hystrix

    • 3.5.1 Hystrix 概述

      • 在分布式系统中，服务与服务之间的依赖错综复杂，一种不可避免的情况就是某些服务出现故障，导致依赖于他们的其它服务出现远程调度的线程阻塞Hystrix是Netflix公司开源的一个项目，它提供了熔断器功能，能够阻止分布式系统中出现联动故障。Hystrix是通过隔离服务的访问点阻止联动故障的，并提供了故障的解决方案，从而提高了整个分布式系统的弹性

    • 3.5.2 Hystrix 案例

    • 修改 micro-service-feign 工程的 application.properties 文件：开启 hystrix 
    • feign.hystrix.enabled=true
      修改启动类，添加注解： EnableDiscoveryClient 
      @SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
@EnableDiscoveryClient
public class MicroServiceFeignApplication {
    public static void main(String[] args) {
        SpringApplication.run(MicroServiceFeignApplication.class, args);
    }
}
  • 创建 EurekaClientFeign 的实现类： EurekaClientHystric 
  • @Component
public class EurekaClientHystric implements EurekaClientFeign {
    @Override
    public String sayHi(String name) {
        return "sorry:" + name;
    }
}
    在 @FeignClient 注解中添加 fallback= EurekaClientHystric.class, 指定当所调用服务
    故障时候，调用 Hystric 。 
    @FeignClient(value = "service-hi", configuration = FeignConfig.class, fallback = EurekaClientHystric.class)
public interface EurekaClientFeign {
    @RequestMapping(value = "hi", method = RequestMethod.GET)
    String sayHi(@RequestParam(value = "name") String name);
}
    此时请求 http://localhost:8084/hi?Name=Hystric, 可以看到服务被调用

    关闭 eureka 服务，此时再次请求 http://localhost:8084/hi?Name=Hystric ，可以看
    到返回熔断器接口实现：

  • 3.6 Zuul

    • 3.6.1 Zuul 概述

      • zuul作为微服务系统的网关组件，用于构建边界服务（dgService），致力于动态路由、过滤、监控、弹性伸缩和安全。

    • 3.6.2 Zuul 案例

    • 创 建 micro-service-parent 子 工 程 micro-service-zuul ， 并 依 赖 eureka-client 和 openfeign。
    • 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>
    <parent>
        <groupId>com.spring.microservice</groupId>
        <artifactId>micro-service-parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.spring.microservice</groupId>
    <artifactId>micro-service-zull</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>micro-service-zull</name>
    <description>Demo project for Spring Boot</description>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>
      修改 application.properties 文件 
      #指定服务端口
server.port=8085
#指定服务名称
spring.application.name=service-zuul
#指定注册中心地址
eureka.client.service-url.defaultZone=http://localhost:8081/eureka/
#指定 api-a 请求调用的服务
zuul.routes.api-a.path=/api-a/**
zuul.routes.api-a.service-id=eureka-ribbon-client
#指定 api-b 请求调用的服务
zuul.routes.api-b.path=/api-b/**
zuul.routes.api-b.service-id=eureka-feign-client
      修改启动类添加相关注解： EnableZuulProxy 、 EnableEurekaClien 和 EnableDiscoveryClient 
      @SpringBootApplication
@EnableZuulProxy
@EnableEurekaClient
@EnableDiscoveryClient
public class MicroServiceZullApplication {
    public static void main(String[] args) {
        SpringApplication.run(MicroServiceZullApplication.class, args);
    }
}
      分别请求 /api-a/hi?name=apia 和 /api-b/hi?name=apib, 可以看到被 zuul 分发到不同
      的服务

       

  • 3.7 Config

    • 3.7.1 Config 概述

      • Springc config是springcloud组建中的分布式配置中心。该组件分为服务端和客户端，服务端可以读取管理远程仓库中的配置文件，客户端可以获取到服务端的配置信息。

    • 3.6.2 Config 案例

    • 创建一个 micro-service-config 父工程项目，指定依赖的版本， springBoot 为 2.0.6 ，
      41 spring cloud 为 Finchley.RELEASE 版本。
    • 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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.microservice</groupId>
    <artifactId>micro-service-config</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>micro-service-config</name>
    <description>Demo project for Spring Boot</description>
    <packaging>pom</packaging>
    <modules>
        <module>config-server</module>
        <module>config-client</module>
    </modules>
    <properties>
        <java.version>1.8</java.version>

        <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>

        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

    • 3.7.2 Config-Server 案例

    • 创 建 config-server 子 工 程 ， 负 责 加 载 远 程 仓 库 的 配 置 文 件 信 息 。 需 要 依 赖
      spring-cloud-config-server 。 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>
    <parent>
        <groupId>com.microservice</groupId>
        <artifactId>micro-service-config</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.microservice</groupId>

    <artifactId>config-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>config-server</name>
    <description>Demo project for Spring Boot</description>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
      修改 application.properties 文件 , 指定远程仓库信息： 
      spring.application.name=config-server
server.port=8086
#git 仓库地址
spring.cloud.config.server.git.uri=https://github.com/soulstare89/Springclou
dConfig
#仓库路径
spring.cloud.config.server.git.searchPaths=resp
#配置仓库的分支
spring.cloud.config.label=master
#访问 git 仓库的用户名
spring.cloud.config.server.git.username= #访问 git 仓库的密码
spring.cloud.config.server.git.password= #指定服务注册地址
eureka.client.serviceUrl.defaultZone=http://localhost:8081/eureka/
#开发环境 dev
spring.profiles.active=dev
      修改启动类 , 添加注解 @EnableConfigServer ： 
      package com.micro.service.config;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}
      在 gitHub 上创建自己的配置文件仓库中心，如图：

    • 3.7.3 Config-Client 案例

    • 创建 config-client 项目，依赖 spring-cloud-starter-config 。该项目负责获取配置
      中心服务端配置信息。也可以再其他项目中添加依赖来获取配置信息进行调用。 
    • <?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>
    <parent>
        <groupId>com.microservice</groupId>
        <artifactId>micro-service-config</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.microservice</groupId>
    <artifactId>config-client</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>config-client</name>
    <description>Demo project for Spring Boot</description>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
      修改 bootstrap.properties 配置文件： 
      #指明配置文件
spring.application.name=config-client
#指明远程仓库的分支
spring.cloud.config.label=master
#开发环境配置文件
spring.cloud.config.profile=dev
#指明配置服务中心的网址。
spring.cloud.config.uri= http://localhost:8086/
server.port=8087
#eureka.client.serviceUrl.defaultZone=http://localhost:8081/eureka/
#是从配置中心读取文件。
#spring.cloud.config.discovery.enabled=true
#配置中心的 servieId，即服务名。
#spring.cloud.config.discovery.serviceId=config-server
      修改启动类，添加注解： @EnableDiscoveryClient ， @RefreshScope 
      @SpringBootApplication
@EnableDiscoveryClient
@RefreshScope
public class ConfigClientApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigClientApplication.class, args);
    }
}
      编写控制层代码测试： 
      @RestController
public class ConfigClientController {
    @Value("${foo}")
    String foo;

    @RequestMapping(value = "/foo")
    public String hi() {
        return foo;
    }
}
      访问： http://localhost:8087/foo ，可以看到获取到远程仓库中的配置信息

    • 3.7.4 Config 高可用案例

      • 将配置中心config server做成一个微服务，并且将其集群化，从而达到高可用。配置中心 config server高可用的架构图如图。configserver和configclient想eureka server注册，并且将config server 多实例集群部署

      • 修改 config-server 的 pom 依赖信息，添加 eureka-client 依赖： 

             <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
        修改 application.properties 文件： 
      • #指定服务注册地址
eureka.client.serviceUrl.defaultZone=http://localhost:8081/eureka/
        修改启动类注解，添加注解 @EnableEurekaClient 
        @EnableEurekaClient
@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication
        分别启动注册中心以及两个 config-server 实例：

         修改 config-client 的依赖信息，添加 eureka-client:

            <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
        修改 bootstrap.properties 文件，指定从注册中心获取配置信息： 
        #指明配置文件
spring.application.name=config-client
#指明远程仓库的分支
spring.cloud.config.label=master
#开发环境配置文件
spring.cloud.config.profile=dev
#指明配置服务中心的网址。
#spring.cloud.config.uri= http://localhost:8088/
server.port=8087
#指定注册中心地址
eureka.client.serviceUrl.defaultZone=http://localhost:8081/eureka/
#是从配置中心读取文件。
spring.cloud.config.discovery.enabled=true
#配置中心的 servieId，即服务名。
spring.cloud.config.discovery.serviceId=CONFIG-SERVER
        启动 config-client ，就实现了配置中心的高可用
xinyi_java
关注
专栏目录
Spring Cloud 微服务开发 技术总结
06-18
比较片面的总结，刚刚接触，大佬勿喷
spring cloud 微服务总结
FutureCome的博客
03-03 2198
微服务：将传统的一站式应用，根据业务拆分成一个一个的服务，能够自行单独启动或销毁，拥有独立的数据库 微服务框架解决方案： 1）springcloud--》基于SpringBoot提供了一套微服务解决方案，包括服务注册与发现，负载均衡，熔断器，服务网关，配置中心等组件。 2）Dubbo--》Dubbo采用RPC通信，SpringCloud采用基于HTTP的REST方式通信，REST避免了原生RPC带来的问题（代码级别的强依赖），但牺牲了服务调用的性能，而且spring cloud背靠spring社区保证功
Spring Cloud微服务再谈微服务架构（七）
DT辰白
05-13 382
一、什么是微服务？ 1、微服务的由来 微服务最早由Martin Fowler与James Lewis于2014年共同提出，微服务架构风格是一种使用一套小服务来开发单个应用的方式途径，每个服务运行在自己的进程中（有多个服务，把一个项目拆分成多个独立的服务，多个服务是独立运行的，每个服务占用独立的进程），并使用轻量级机制通信，通常是HTTP API，这些服务基于业务能力构建，并能够通过自动化部署机制来独立部署，这些服务使用不同的编程语言实现，以及不同数据存储技术，并保持最低限度的集中式管理。 2、为什么需要微服
SpringCloud微服务架构使用心得
qq_35944953的博客
05-09 582
不积跬步，无以至千里；不积小流，无以成江海 前言 最近通过使用SpringCloud微服务架构，记录一些心得。 由于spring cloud是基于spring boot构建的，所以在引入springcloud依赖时需要考虑与spring boot的版本兼容性问题。例如，spring boot使用的是2.2.x或2.3.x，则springcloud版本号需要选择Hoxton。 创建注册中心Eureka服务，需要注意的是注册中心默认注销微服务实例的时间为90秒，当网络故障时，虽然无法进行正常通信.
介绍Spring-Cloud的版本是如何定义的
王浩的技术博客
03-20 6808
Spring Cloud是一个由众多独立子项目组成的大型综合项目，每个子项目有不同的发行节奏，都维护着自己的发布版本号。Spring Cloud通过一个资源清单BOM（Bill of Materials）来管理每个版本的子项目清单。为避免与子项目的发布号混淆，所以没有采用版本号的方式，而是通过命名的方式。 这些版本名称的命名方式采用了伦敦地铁站的名称，同时根据字母表的顺序来对应版本时间顺序，比如...
(完整版)基于SpringCloud微服务系统设计方案.pdf
06-07
SpringCloud微服务系统设计方案是构建大规模、高可用应用程序的一种现代架构。它基于Spring Boot和Spring Framework，旨在简化微服务的开发、部署和管理。本文将深入探讨微服务的本质、面临的挑战、架构设计以及核心...
详解Spring Cloud微服务架构下的WebSocket解决方案
08-26
Spring Cloud 微服务架构下的 WebSocket 解决方案 在现代浏览器中，WebSocket 的应用已经变得非常普遍，特别是在某些业务场景下，要求服务器端推送消息至客户端。在微服务架构集群模式下，选择合适的解决方案尤为...
springcloud微服务技术栈-个人笔记文档（基础篇）
08-05
【SpringCloud微服务技术栈详解】 SpringCloud 是一套完整的微服务解决方案，它为开发者提供了构建分布式系统所需的工具，包括服务发现、配置管理、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导...
SpringCloud微服务、链路跟踪、分布式配置、分布式网关
09-18
总结起来，这个压缩包提供了SpringCloud微服务架构的典型应用场景，涵盖了服务治理、监控、容错和安全等多个方面，对于学习和实践SpringCloud的开发者来说是非常有价值的资源。通过深入理解和实践这些组件，开发者...
SpringCloud微服务架构笔记（一）
03-18
本文总结了 Spring Cloud 微服务架构笔记（一），涵盖了微服务基础知识、系统架构演变、单体应用架构、垂直应用架构、分布式 SOA 架构、微服务架构、分布式核心知识等方面的知识点。 微服务基础知识： 1. 微服务...
Spring Cloud版本说明
陈续缘的专栏
04-11 1万+
Spring Cloud是一个由众多独立子项目组成的大型综合项目，每个子项目有不同的发行节奏，都维护着自己的发布版本号。Spring Cloud通过一个资源清单BOM（Bill of Materials）来管理每个版本的子项目清单。为避免与子项目的发布号混淆，所以没有采用版本号的方式，而是通过命名的方式。 这些版本名称的命名方式采用了伦敦地铁站的名称，同时根据字母表的顺序来对应版本时间顺序，比如...
springcloud微服务框架（学习梳理总结）
weixin_40794948的博客
06-28 200
最近在极客时间上学习了springcloud微服务框架，简单总结了一下各个服务的作用和功能。希望对大家有用~~~~~~~~~~
spring cloud 版本选择
水月青花
03-10 4990
出现问题。 之前用ribbon做负载 均衡，切换ribbon的负载均衡算法，切换成 随机负载均衡算法，始终切换不了， 通过debug，发现在调用choose方法后，总是调到BlockingLoadBalancerClient实现类中，而不是调到RibbonLoadBalancerClient实现类。所以切换算法无效果。而且没有RibbonLoadBalancerClient实现类，和IRule类，即使添加了依赖包也不行。 解决办法： 是由于Spring cloud 版本的问题。用的boot版本是2.
SpringCloud Version
难得糊涂
01-18 3762
SpringCloud是个技术整合熔炉.为我们提供了行业中的各种问题的解决方案.总的来说SpringCloud是做协议的,其它人按照他的协议出具体的解决方案.我们就可以按照统一的标准选择不同的实现方案来解决某一个问题cuiyaonan2000@163.com比如:SpringCloud Alibaba 和 SpringCloud Netflix 都是按照SpringCloud的标准,推出了某些问题的解决实现.通过官网也可以看到SpringCloud的追随者众多。...
微服务体系精简总结
huxiutao的博客
10-26 1092
一、 什么是微服务架构 1、 一组小的服务 2、 独立的进程 3、 轻量级通信 4、 基于业务能力 5、 独立部署 6、 无集中式管理 二、 利与弊 利： 1、 强模块化边界 2、 可独立部署 3、 技术多样性 弊： 1、 分布式复杂性 2、 最终一致性 3、 运维复杂性 4、 测试复杂性 三、康威法则和微服务——微服务的理论基础就是康威法则 康威法则：设计系统的组织以及产生的架构等价于组织的组织...
微服务总结
weixin_59096287的博客
11-17 373
核心组件分析 Spring Cloud Alibaba 默认提供了如下核心功能（先了解）： 服务限流降级： 默认支持 WebServlet、OpenFeign、RestTemplate、Spring Cloud Gateway, RocketMQ 限流降级功能的接入，可以在运行时通过控制台实时修改限流降级规则，还支持查看限流降级 Metrics 监控。 服务注册与发现： 基于Spring Cloud 服务注册与发现标准，借助Nacos进行实现，默认还集成了 Ribbon 的支持。 分布式配置管理
微服务架构（14）：SpringCloud微服务项目技术总结
rnang0的博客
02-26 567
微服务架构（14）：SpringCloud微服务项目总结一、项目架构二、项目技术具体解读1、前端2、后端三、项目部署 一、项目架构 微服务项目一般的架构图如图所示： 整个的项目现在都是采用前后端分离的开发模式。 前端主要是一些Vue结合Node.js来实现页面服务端渲染方式 （重点）后端主要是基于SpringCloud的微服务架构，对外统一Rest风格的API，采用nginx反向代理到Zuul...
Springcloud的版本依赖问题（最全，包含springCloud所有的版本)
热门推荐
诗和远方，任重道远
10-29 2万+
Springcloud的版本依赖问题version写在前面一、Greenwich 系列（按照从最新系列介绍）1.1、Greenwich.SR11.2、Greenwich.SR21.3、Greenwich.SR31.4、Greenwich.RELEASE二、Finchley 系列2.1、Finchley.SR12.2、Finchley.SR22.3、Finchley.SR32.4、Finchley....
评论 36
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xinyi_java

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值