SpringCloud个人笔记

于 2022-06-03 14:01:53 发布
阅读量180 收藏
点赞数
文章标签： spring cloud eureka java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42076204/article/details/125111969
版权

HTTP调用服务。

通过Rest风格的链接去调用远程服务。SpringBoot内置的RestTemplate模板，可以通过该模板的方法实现简单的http调用。首先实现服务的提供者（不再赘述）。

然后实现服务的消费者。消费者需要注册RestTemplate的bean。然后通过该bean实现远程调用。

@Controller
public class DeptCustomerController {
    @Autowired
    private RestTemplate restTemplate;

    private static final String REST_URL_PREFIX="http://localhost:8001";
    @ResponseBody
    @GetMapping("/getOne/{id}")
    public Dept getOne(@PathVariable Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/getDeptById/"+id,Dept.class);
    }

    @ResponseBody
    @GetMapping("/getAll")
    public List<Dept> getAll(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/deptList",List.class);
    }
}

Eureka服务注册与发现

遵循ap原则，基于Rest服务

Eureka包含两个组件：Eureka Server 和Eureka Client

Eureka Server 提供服务注册，各个节点启动后，会在EurekaServer中进行注册，这样Eureka Server中的注册服务表中会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。

Eureka Client是一个Java客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的使用轮询负载算法的负载均衡器。在应用启动后，将会向EureServe发送心跳（默认周期是30秒）。如果Eureka Server在多个心跳周期内没有收到某个节点的心跳，EurekaServer将会从注册表中把这个服务节点移除。（默认周期为90秒，也就是三个心跳周期）

Eureka三大角色

服务中心（Eureka Server），提供者（Service Provider），消费者（Service Consumer）

Eureka配置注册中心

首先导入依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    <version>2.2.9.RELEASE</version>
</dependency>

然后在yaml配置文件中配置注册中心：

server:
  port: 7001
#Eureka 配置
eureka:
  instance:
    hostname: localhost #Eureka服务端的实例名称
  client:
    register-with-eureka: false #表示是否向注册中心注册自己
    fetch-registry: false #如果为false 则便是自己是注册中心
    service-url: #注册中心地址
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

然后在启动器上方开启Eureka服务注解

@SpringBootApplication
@EnableEurekaServer //表示开启Eureka服务
public class EurekaServer {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer.class,args);
    }
}

Eureka提供者注册服务，配置服务信息

首先还是在提供者模块中导入依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

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

然后在yaml配置文件中配置信息

eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/ #这里是注册中心的url
  instance:
    instance-id: springCloud-provider-dept-8001 #修改Eureka的描述信息
#info配置
info:
  app.name: liangbo-springCloud  //一些描述信息

在团队开发中，一般需要将服务的配置信息展示出去

@Autowired
DiscoveryClient discoveryClient;
   @GetMapping("/dept/discover")
    public Object discover(){
        return discoveryClient.getInstances("springCloud-provider-dept");
    }

使用DiscoveryClient来得到该服务的配置信息。最后在启动类上开启注解

@SpringBootApplication
@MapperScan("com.lv.core.mapper")
@EnableEurekaClient //在服务启动后，自动注册到Eureka注册中心
@EnableDiscoveryClient //开启配置信息
public class DeptProvider {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider.class,args);
    }
}

运行起来，此时我们打开注册中心页面，就会发现服务已经被注册了。

红色的字体出现的原因是，Eureka的自我保护机制。它的架构哲学是宁可保存全部的微服务，也不盲目的删除任何一个可能健康的微服务。在一个心跳周期内，如果Eureka没有收到某个节点的心跳信息，它不会直接删除掉该节点，而是等待。当三个周期过去后，才会删除该节点。但如果Eureka在短时间内失去多个节点的心跳，Eureka的自我保护机制就会触发，它会认为是网络故障导致健康的微服务无法通信，这时他不会删除任何节点。会等待节点重新连接。这样的机制保证了Eureka的安全性和稳定性。

Eureka与Zookeeper的对比

CAP原则

  • C：强一致性
  • A：可用性
  • P：分区容错性

CPA核心理论：

一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求

根据CAP原理，将NOSQL数据库分成了三大类：CA,CP,AP

作为分布式服务注册中心，Eureka和Zookeeper的区别

由于分区容错性是分布式系统中必须要保证的，所以我们需要在一致性和可用性之间权衡

  • zookeeper保证的是cp，满足一致性，分区容错性的系统，通常性能不是特别高
  • eureka保证的是ap，满足可用性，分区容错性，通常可能对一致性的要求比较低

Eureka集群

通过多个注册中心互相关联来打造一个Eureka集群。

server:
  port: 7001
#Eureka 配置
eureka:
  instance:
    hostname: eureka7001.com
  client:
    register-with-eureka: false #表示是否向注册中心注册自己
    fetch-registry: false #如果为false 则便是自己是注册中心
    service-url: #注册中心地址
      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

如上互相引用，然后在服务提供方注册到所有的注册中心，这样就达成了集群。

eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: springCloud-provider-dept-8001 #修改Eureka的描述信息

Ribbon客户端负载均衡

主要功能是提供客户负载均衡的算法。

负载均衡简单来说就是将用户的请求平摊到多个服务商，从而达到系统的HA（高可用）

常见的负载均衡有Nginx Lvs

负载均衡简单分类：

  • 集中式LB
  • 进程式LB

集中式：在服务的提供方和消费方之间使用独立的设施，如Nginx（反向代理服务器），由该设施负责把访问请求通过某种策略转发之服务的提供方！

进程式：将LB的逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。Ribbon就属于进程式LB，它只是个类库，集成于消费方进程，消费方通过它老获取到服务提供方的地址。

集成Ribbon

首先向消费方导入依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
    <version>2.2.9.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

然后在yaml配置文件中配置Eureka

eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7002/eureka/,http://eureka7003.com:7003/eureka/

然后在RestTemplate模板中集成Ribbon

@Configuration
public class ConfigBean {
    @Bean
    @LoadBalanced //ribbon配置restTemplate负载均衡
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }


}

在原来的rest调用中，将提供方的地址改变为服务名

@Controller
public class DeptCustomerController {
    @Autowired
    private RestTemplate restTemplate;
//通过Ribbon实现负载均衡的时候，应该是一个变量，通过服务名来访问
//    private static final String REST_URL_PREFIX="http://localhost:8001";
      private static final String REST_URL_PREFIX="http://springCloud-provider-dept";
    @ResponseBody
    @GetMapping("/getOne/{id}")
    public Dept getOne(@PathVariable Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/getDeptById/"+id,Dept.class);
    }

    @ResponseBody
    @GetMapping("/getAll")
    public List<Dept> getAll(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/deptList",List.class);
    }

最后在启动类上方开启Eureka客户端服务

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

然后我们生成多个服务提供方，同一服务的提供方，他们的服务名必须是一致的，但是Eureka的instance-id不能一致。

这时把所有服务跑起来，访问消费者项目，通过刷新页面可以观察到，消费方访问的接口是不断交替改变的，这就是轮询。

Ribbon负载均衡算法

可以在Ribbon集成RestTemplate的配置中，切换算法。

@Configuration
public class ConfigBean {
    @LoadBalanced //ribbon配置restTemplate负载均衡
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

    @Bean
    public IRule diyRule(){
        return new RandomRule();
        /**
         * IRule
         * RoundRobinRule 默认的轮询算法
         * RandomRule 随机算法
         * AvailabilityFilteringRule：会先过滤掉访问故障的服务，在健康的服务中轮询
         * RetryRule：会先按照轮询的策略获取服务。如果服务获取失败，则会在指定的时间内进行重试
         */
    }
}

除了内置的规则，我们也可以自定义规则。

在myRule包下自定义一个配置类MyRule.java，注意：该包不要和主启动类所在的包同级。

然后在主启动类开启负载均衡并为复制指定自定义配置

//Ribbon 和 Eureka 整合以后，客户端可以直接调用，不用关心IP地址和端口号
@SpringBootApplication
@EnableEurekaClient
//在微服务启动的时候就能加载自定义的Ribbon类(自定义的规则会覆盖原有默认的规则)
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = MyRule.class)//开启负载均衡,并指定自定义的规则
public class DeptConsumer_80 {
public static void main(String[] args) {
SpringApplication.run(DeptConsumer_80.class, args);
}
}

Feign负载均衡

Feign是在Ribbon的基础上进行进一步的封装，转化为接口式的调用。

集成feign

首先在消费方导入Feign和Eureka的依赖。

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-openfeign -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
        <version>2.2.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok
        </groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>
</dependencies>

然后配置yaml文件

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7002/eureka/,http://eureka7003.com:7003/eureka/

注册service接口，并添加@FeignClient注解，注解的值为提供方服务名称。注意service接口的方法要和提供方一致：

@Service
@FeignClient("springCloud-provider-dept")
public interface FeignService {
    @GetMapping("/deptList")
    List<Dept> list();

    @GetMapping("/getDeptById/{id}")
    Dept getById(@PathVariable("id") Long id);
}

集成RestTemplate实现负载均衡

@Configuration
public class ConfigBean {
    @LoadBalanced //ribbon配置restTemplate负载均衡
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

    @Bean
    public IRule diyRule(){
        return new RandomRule();
        /**
         * IRule
         * RoundRobinRule 默认的轮询算法
         * RandomRule 随机算法
         * AvailabilityFilteringRule：会先过滤掉访问故障的服务，在健康的服务中轮询
         * RetryRule：会先按照轮询的策略获取服务。如果服务获取失败，则会在指定的时间内进行重试
         */
    }
}

最后要在主启动类上方开启Eureka和Feign

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {"com.lv.service"}) //开启Feign并指定要扫描的包
public class FeignCustomer {
    public static void main(String[] args) {
        SpringApplication.run(FeignCustomer.class,args);
    }
}

Hystrix断路器

服务熔断

熔断机制是对应雪崩效应的一致微服务链路保护机制。

当扇出链路的某个微服务不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回错误的响应信息。检测到该节点调用正常后恢复调用链路。

springCloud中通过Hystrix实现熔断。Hystrix会监控微服务间调用的状况，当失败的调用到一定阀值缺省是5秒内20次调用失败，就会启动熔断机制，。熔断的注解是@HystrixCommand。

熔断机制解决如下问题：

  • 当所依赖的对象不稳定是，能够快速失败。避免造成占用，导致雪崩。
  • 快速失败后，能够根据一定的算法动态试探所依赖的对象是够恢复。

配置Hystrix:

在提供方导入依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>2.2.9.RELEASE</version>
</dependency>

然后在需要熔断的方法上标识注解：@HystrixCommand 并提供备用的方法

@HystrixCommand(fallbackMethod = "htest")
@GetMapping("/getDeptById/{id}")
public Dept getDeptById(@PathVariable Long id){
    Dept dept = deptService.getById(id);
    if(dept==null){
        throw new RuntimeException("Fail");
    }
    return dept;
}
  public Dept htest(@PathVariable Long id){
        Dept dept = new Dept();
        dept.setDeptId(id);
        dept.setDeptName("不存在该id的名称");
return dept;
    }

最后在启动类开启Hystrix：@EnableCircuitBreaker

@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
@EnableDiscoveryClient
@MapperScan("com.lv.core.mapper")
public class DeotProviderHystrix {
    public static void main(String[] args) {
        SpringApplication.run(DeotProviderHystrix.class,args);
    }
}

服务降级

服务降级是当服务器压力剧增的时候，根据实际业务的情况以及流量，对一些服务和页面有策略性的不做处理，或换种简单的方式处理，从而释放服务器资源以保证核心业务的正常高效运转。就是尽可能的把系统资源让给核心业务。

自动降级分类：
  • 超时降级 ：主要配置好超时时间和超时重试次数和机制，并使用异步机制探测回复情况
  • 失败次数降级：主要是一些不稳定的api，当失败调用次数达到一定阀值自动降级，同样要使用异步机制探测回复情况
  • 故障降级：比如要调用的远程服务挂掉了（网络故障、DNS故障、http服务返回错误的状态码、rpc服务抛出异常），则可以直接降级。降级后的处理方案有：默认值（比如库存服务挂了，返回默认现货）、兜底数据（比如广告挂了，返回提前准备好的一些静态页面）、缓存（之前暂存的一些缓存数据）
  • 限流降级：秒杀或者抢购一些限购商品时，此时可能会因为访问量太大而导致系统崩溃，此时会使用限流来进行限制访问量，当达到限流阀值，后续请求会被降级；降级后的处理方案可以是：排队页面（将用户导流到排队页面等一会重试）、无货（直接告知用户没货了）、错误页（如活动太火爆了，稍后重试）。

案例：

首先我们在fergn客户端的service包内新建FallbackFactory接口的实现类，重写create（）方法，并将该类注册到spring中

@Component
public class ClientServiceFallBackFactory implements FallbackFactory {
    @Override
    public Object create(Throwable throwable) {
        return new FeignService() {
            @Override
            public List<Dept> list() {
                return null;
            }

            @Override
            public Dept getById(Long id) {
                Dept dept = new Dept();
                dept.setDeptId(id);
                dept.setDeptName("这个服务已经被暂时关闭！");
                return dept;
            }
        };
    }
}

然后在服务层指定fallbackFactory

@Service
@FeignClient(value = "springCloud-provider-dept",fallbackFactory = ClientServiceFallBackFactory.class)
public interface FeignService {
    @GetMapping("/deptList")
    List<Dept> list();

    @GetMapping("/getDeptById/{id}")
    Dept getById(@PathVariable("id") Long id);
}

最后在yaml配置文件中开启降级

feign:
  hystrix:
    enabled: true

当我们关闭服务提供者时，界面就会显示我们想要的信息，而不是无响应

熔断和降级的区别

  • 熔断：服务端，某个服务超时或者异常，引起熔断。
  • 降级：客户端，从负荷考虑，干预式暂时关闭某些微服务。
  • 触发原因不一样，服务熔断一般是因为服务的故障引起的自我触发的，而降级是具有代码入侵性的。
  • 管理目标的层次不一样，熔断是一个框架级别的处理，每个微服务都需要，没有层级之分。而降级一般需要对业务有层级之分。

熔断，降级，限流：

限流：限制并发的请求访问量，超过阈值则拒绝；

降级：服务分优先级，牺牲非核心服务（不可用），保证核心服务稳定；从整体负荷考虑；

熔断：依赖的下游服务故障触发熔断，避免引发本系统崩溃；系统自动执行和恢复

DashBoard流监控

可以监控Hystrix的服务流

首先创建监控项目

导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        <version>2.2.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
        <version>2.2.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-ribbon -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        <version>2.2.9.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>

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

然后在主启动类开启监控：@EnableHystrixDashboard

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

然后在被监控的提供方添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>2.2.9.RELEASE</version>
</dependency>

然后在被监控方主启动类添加一个Servlet

@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
@EnableDiscoveryClient
@MapperScan("com.lv.core.mapper")
public class DeotProviderHystrix {
    public static void main(String[] args) {
        SpringApplication.run(DeotProviderHystrix.class,args);
    }
    @Bean
    public ServletRegistrationBean hystrixMetricsStreamServlet (){
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
        servletRegistrationBean.addUrlMappings("/actuator/hystrix.stream");
        return servletRegistrationBean;
    }
}

然后启动节点后，进入监控见面：http：localhost：9001/hystrix

输入被监控的页面 就可以得到该流的监控仪表板

![监控](https://img-blog.csdnimg.cn/ce00ef69bf8a43b092a9617188d87fd8.png)

注意！！！只能监控Hystrix熔断的项目。如果界面无法获得监控，请先触发一次熔断。

Zuul网关

zuul包含了对请求的路由和过滤两个最主要的功能。

其中路由功能负责将外部请求转发到具体的微服务上，是实现外部访问统一入口的基础。而过滤器功能则是负责对请求的过程进行干预，实现请求校验，服务聚合等功能的基础。Zuul和Eureka进行真核，将zuul自身注册为Eureka服务治理下的应用，同时从Eureka中获得其他服务的消息，也即以后的访问微服务都是通过Zuul跳转后获得。

创建zuul项目

导入依赖：

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-zuul -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        <version>2.2.9.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>

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

</dependencies>

配置yaml

server:
  port: 9527
spring:
  application:
    name: springCloud-zuul
eureka:
  instance:
    instance-id: springCloud-zuul-9527
    prefer-ip-address: true
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7002/eureka/,http://eureka7003.com:7003/eureka/
zuul:
  ignored-services: "*" #忽略所有服务名
  routes:
    mydept.serviceId: customer 
    mydept.path: /mydept/**

在启动类上添加注解 开启网关代理 @EnableZuulProxy

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

SpringCloud Config 分布式配置

springCloud config 为分布式系统中的外部配置提供服务器和客户端的支持。

为微服务架构中的微服务提供集中化的外部支持，配置服务器为各个不同的微服务应用的所有环节提供了一个中心化的配置。

服务端

服务端也称为分布式配置中心，他是一个独立的微服务应用，用来连接配置服务器并为客户端提供获取配置信息，加密，解密信息等访问接口。

客户端

客户端则是通过指定的配置中心来管理应用资源，以及业务相关的配置内容，并在启动的时候从配置中心获取和加载配置信息。

入门案例

首先创建服务端：

创建模块并导入依赖：

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

    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-config-server -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
        <version>2.2.8.RELEASE</version>
    </dependency>

配置yaml

server:
  port: 3344
spring:
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/liangboa/spring-cloud-config.git  #配置仓库的地址
  application:
    name: configServer

然后在主启动类上开启服务：@EnableConfigServer

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

客户端

在需要配置的微服务项目中，导入依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
    <version>2.2.8.RELEASE</version>
</dependency>

然后清空原本的yaml配置，新建bootstrap.yaml配置文件
在bootstrap中配置：

spring:
  cloud:
    config:
      name: provider8001-config #配置文件的名称，不需要后缀
      label: master #拉取的配置所在的分支
      profile: test #配置的环境
      uri: http://localhost:3344 #configServer的地址

这样就完成了！

总结，以及日后学习

Eureka，Zuul，技术停止更新，用Nocos和getway代替。可以往这方面学习。

凉薄不凉薄啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
SpringCloud笔记Day01
04-23
内包含服务拆分及远程调用，Eureka，Nacos解释，黑马系列课笔记（个人）
springcloud微服务技术栈-个人笔记文档（基础篇）
08-05
【SpringCloud微服务技术栈详解】 SpringCloud 是一套完整的微服务解决方案，它为开发者提供了构建分布式系统所需的工具，包括服务发现、配置管理、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导...
SpringCloud学习（5）：Rest学习环境搭建：服务消费者
游王子的博客
01-21 289
一、搭建消费者服务 （1）创建服务消费者模块 （2）导入依赖 <?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/
springboot使用RestTemplate
阿偶灬的专栏
07-22 525
1、创建RestTemplate的Bean交给Spring管理 package com.asiainfo.layout.bboss.restTemplate; import org.apache.http.client.HttpClient; import org.apache.http.config.RegistryBuilder; import org.apache.http.conn.socket.ConnectionSocketFactory; import org.apache.http.c
Feign的使用方法以及与RestTemplate的区别
热门推荐
a602389093的博客
08-02 1万+
版权声明：本文为博主ExcelMann的原创文章，未经博主允许不得转载。 作者：ExcelMann，转载需注明。 Feign的使用方法 第一步：导入依赖 第二步：在消费者服务，开启Feign客户端 @SpringBootApplication @EnableFeignClients // 开启Feign客户端 public class MircoRouteApplication { public static void main(String[] args) { SpringApp
RestTemplate和Feign的区别
weixin_41539721的博客
12-13 6996
然后接口方法里面，就是消费者order-service调用提供者user-service的方法。属性name：指定FeignClient的名称，如果项目使用了Ribbon，name属性会作为微服务的名称，用于服务发现。本案例用于简单的远程调用，所有name没太大意义，只是为了不报错而已。2.拼接转发到user-service的路径，并通过restTemplate方法发起调用，并获得user-service执行结果。属性url：手动指定@FeignClient调用的地址。3.编写Feign的客户端。
RestTemplate与Feign使用对比
诚的博客
10-20 3920
RestTemplate： 添加相关注解参数即可，使用简单方便 熔断节点易控制，方便后续基于业务作出相应调整 异常捕获简单，同页面下添加对应方法即可 请求更贴近httpclient，使用更有熟悉感 Feign： 编写方式优雅，基于面向接口的风格，但是开发起来较为繁琐 yml需要添加配置启动hystrix组件 需要创建对应类来执行fallback方法 捕获异常信息和不捕获异常实现的接口不同 需要在feign注解上作出相应参数配置 feign中作出任何操作需要创建各种类来对应不同参数 ...
《springcloud&学习资料》--尚硅谷SpringCloud视频学习笔记.zip
最新发布
04-19
个人花大量时间整理出的实战资料，内容丰富，文档也很详细。无论做毕业设计还是用于学习技能，或工作中当做参考资料，都能发挥重要作用 亲们下载我任何一个付费资源后，即可私信联系我免费下载其他相关资源哦~ 个人...
尚硅谷SpringCloud第二季笔记
01-22
【尚硅谷SpringCloud第二季笔记】是一份详细记录了SpringCloud组件使用的学习笔记，涵盖了SpringCloud在云原生环境下的核心概念和实践应用。SpringCloud是基于Spring Boot实现的微服务框架，它提供了构建分布式系统...
尚硅谷SpringCloud第2季2020.3.2.mmap
05-07
尚硅谷周阳老师springcloud学习、代码、笔记记录 今天看到周阳老师出了[尚硅谷2020最新版SpringCloud(H版&Alibaba)](https://www.bilibili.com/video/BV18E411x7eT)，十分欣喜，很喜欢周阳老师的讲课风格，内容也...
《深入理解Spring Cloud与微服务构建》学习笔记(十一)~使用RestTemplate和Ribbo消费服务
03-09
《深入理解Spring Cloud与微服务构建》学习笔记(十一)~使用RestTemplate和Ribbo消费服务
Feign和RestTemplate 的使用比较
Gufang617的博客
09-01 3741
Feign和RestTemplate 的使用比较 一.RestTemplate 基于RestTemplate 进行远程服务调用,但是在调用之前基于loadBalancerClient对象去从nacos注册中心基于服务名查找服务实例(可能有多个),此时会在本地按照一定算法去选择服务实例,然后进行服务调用. 1.首先创建RestTemplate的实例,交给IOC容器管理 2.在Controller类中注入loadBalancerTemplate 3.通过@LoadBalancer,可以通过服务名sca-pr
SpringCloud服务消费者：restTemplate和feignClient
liu1390910的博客
07-19 671
1、概述 在springCloud微服务架构下，各个业务会被拆分为独立的微服务。那么我们如何解决服务间调用的问题，springCloud默认提供了两种方式：restTemplate和feignClient 2、两者的区别 restTemplate：使用起来较为麻烦，需要自己指定ribbon的负载均衡，但参数较灵活，请求的路径可以使用程序灵活控制。 feignClient：手机简单，默认集成...
FeignClient与RestTemplate的区别比较简单研究
weixin_34144848的博客
01-20 2361
题外：个人觉得可能还没达到那种境界，还体会不到真正的实质性区别，就好比用HttpClient可以实现的用FeignClient同样可以实现，反之也是。 JAVA 项目中接口调用怎么做 ？ Httpclient Okhttp Httpurlconnection RestTemplate 上面是最常见的几种用法，我们今天要介绍的用法比上面的更简单，方便，它就是Feign Feig...
FeignClient与RestTemplate的区别
诚的博客
10-20 4821
JAVA 项目中接口调用怎么做 ？ Httpclient Okhttp Httpurlconnection RestTemplate 上面是最常见的几种用法，我们今天要介绍的用法比上面的更简单，方便，它就是Feign Feign是一个声明式的REST客户端，它的目的就是让REST调用更加简单。 Feign提供了HTTP请求的模板，通过编写简单的接口和插入注解，就可以定义好HTTP请求的参数、格式、地址等信息。 而Feign则会完全代理HTTP请求，我们只需要像调用方法一样调用它就可以完成服务请
SpringCloud微服务之间的通讯，Feign和RestTemplate概念实例详解
alan_liuyue的博客
09-19 8803
前言： 在springcloud微服务的实际项目开发中，多个微服务之间不仅是相对独立的，而且也是相对关联的；也就是说，微服务之间需要相互访问，多个微服务之间的接口可能会被互相多次调用，我们称之为微服务之间的通信； 微服务之间的通信方式有很多，一般使用以下两种方法：一种是RestTemplate,另一种是Feign； 概念简介： RestTemplate，是spring中方便使用rest资源的...
RestTemplate+ribbon与feign的用法区别
wuniangzhanyan的博客
01-28 768
简单记录一下，maven依赖略过 RestTemplate+ribbon 启动类中 @SpringBootApplication @EnableDiscoveryClient @EnableFeignClients public class CloudOrderApplication { @Bean @LoadBalanced public RestTemplate restTemplate() { return new RestTemplate(); }
springcloud尚硅谷笔记
08-25
很抱歉，我无法回答关于"springcloud尚硅谷笔记"的问题，因为在提供的引用内容中没有提到关于"springcloud尚硅谷笔记"的信息。 但是，根据引用和引用，Spring Cloud Bus是与Spring Cloud Config一起使用的一个组件，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值