SpringCloud（上）

最新推荐文章于 2024-06-11 08:09:19 发布
置顶 最新推荐文章于 2024-06-11 08:09:19 发布
阅读量172 收藏 1
点赞数 1
分类专栏： java 文章标签： java 分布式 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48320674/article/details/117488279
版权

概念

Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

新版架构图

dependencyManagement与dependencies区别

父工程用来管理版本，子工程不继承依赖，继承版本，子工程导入不需要写版本号 

<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.0</lombok.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.16</druid.version>
        <mybatis.spring.boot.version>1.3.2</mybatis.spring.boot.version>
    </properties>

    <!-- 子模块继承之后，提供作用：锁定版本+子模块不用写groupId和version  -->
    <dependencyManagement>
        <dependencies>
            <!--  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.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <optional>true</optional>
            </dependency>
        </dependencies>
    </dependencyManagement>

 RestTemplate

package com.wl.config;

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

@Configuration
public class ApplicationContextConfig {
    @Bean
    public RestTemplate getRRestTemplate(){
        return new RestTemplate() ;
    }
}

package com.wl.controller;

import com.wl.entities.CommonResult;
import com.wl.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

@RestController
@RequestMapping("/order")
@Slf4j
public class OrderController {
   public static final String PAYMENT_URL="http://localhost:8001";
   @Resource
   private RestTemplate restTemplate;
    @PostMapping(value = "/create")
    public CommonResult create(Payment payment){
         return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResult.class);
    }
    @GetMapping(value = "/get/{id}")
    public CommonResult get(@PathVariable("id") Long id){
        return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id, CommonResult.class);
     }
}

Eureka注册中心

  • 服务端
server:
  port: 7001

eureka:
  instance:
    hostname: localhost
  client:
    fetch-registry: false  #不注册自己
    register-with-eureka: false # 不检索自己
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

主启动类加：@EnableEurekaServer 

  • 客户端
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka

 对应

注册中心集群搭建

步骤：

  •  找到C:\Windows\System32\drivers\etc路径下的hosts文件

  • 修改注册中心yml

  • 修改服务的yml 

服务集群搭建

步骤：

  • 复制一个服务工程，只修改端口
  • 修改调用者的URL

  • 使用@LoadBalanced注解赋予RestTemplate负载均衡的能力

服务名称修改与显示端口

修改前

修改内容

修改后

服务发现Discovery（对于注册eureka里面的微服务,可以通过服务发现来获得该服务的信息）

启动类加：@EnableDiscoveryClient

效果：

eureka自我保护（属于CAP里面的AP分支）

出产默认自我保护机制是开启的

关闭：

CAP理论

Ribbon（负载均衡） 

Eureka已经集成了ribbon依赖

getForObject方法/getForEntity方法

Ribbon核心组件IRule

  • com.netflix.loadbalancer.RoundRobinRule（轮询，默认）
  • com.netflix.loadbalancer.RandomRule（随机）
  • com.netflix.loadbalancer.RetryRule（先按照RoundRobinRule的策略获取服务,如果获取服务失败则在指定时间内进行重试,获取可用的服务）
  • WeightedResponseTimeRule（对RoundRobinRule的扩展,响应速度越快的实例选择权重越多大,越容易被选择）
  • BestAvailableRule（会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务）
  • AvailabilityFilteringRule（先过滤掉故障实例,再选择并发较小的实例）
  • ZoneAvoidanceRule（默认规则,复合判断server所在区域的性能和server的可用性选择服务器）

替换负载均衡规则

  • 新建package（不能与主启动类同级）
  • 新建类
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RoundRobinRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MySelfRule {

    @Bean
    public IRule myRule() {
        // 定义为随机
        return new RoundRobinRule();
    }
}
  • 主启动类添加@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MySelfRule.class)

轮询的原理

OpenFeign（远程调用）

  • 加依赖
<!--openfeign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
  • 创建接口（注意注解）
package com.wl.service;

import com.wl.entities.CommonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(value = "cloud-payment-service")
@Component
public interface PaymentService {
    @GetMapping(value = "/payment/get/{id}")
    public CommonResult get(@PathVariable("id") Long id) ;
}
  • 主启动类加注解：@EnableFeignClients
  • 调用
package com.wl.controller;

import com.wl.entities.CommonResult;
import com.wl.entities.Payment;
import com.wl.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

@RestController
@RequestMapping("/order")
@Slf4j
public class OrderController {
    public static final String PAYMENT_URL = "http://localhost:8001";
    @Resource
    private RestTemplate restTemplate;
    @Autowired
    private PaymentService paymentService;

    @PostMapping(value = "/create")
    public CommonResult create(Payment payment) {
        return restTemplate.postForObject(PAYMENT_URL + "/payment/create", payment, CommonResult.class);
    }


    @GetMapping(value = "/get/{id}")
    public CommonResult get(@PathVariable("id") Long id) {
        return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
    }
    @GetMapping(value = "/get1/{id}")
    public CommonResult get1(@PathVariable("id") Long id) {
        return paymentService.get(id);
    }
}

OpenFeign超时控制（OpenFeign默认等待1秒钟,超过后报错）

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
# 设置feign客户端超时时间(OpenFeign默认支持ribbon)
ribbon:
  # 指的是建立连接所用的时间,适用于网络状态正常的情况下,两端连接所用的时间
  ReadTimeout: 5000
  # 指的是建立连接后从服务器读取到可用资源所用的时间
  ConnectTimeout: 5000

OpenFeign日志打印功能

  • 配置日志bean及yml

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

@Configuration
public class FeignConfig {

    /**
     * feignClient配置日志级别
     *
     * @return
     */
    @Bean
    public Logger.Level feignLoggerLevel() {
        // 请求和响应的头信息,请求和响应的正文及元数据
        return Logger.Level.FULL;
    }
}
 
 

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
# 设置feign客户端超时时间(OpenFeign默认支持ribbon)
ribbon:
  # 指的是建立连接所用的时间,适用于网络状态正常的情况下,两端连接所用的时间
  ReadTimeout: 5000
  # 指的是建立连接后从服务器读取到可用资源所用的时间
  ConnectTimeout: 5000
logging:
  level:
    # feign日志以什么级别监控哪个接口
    com.wl.service.PaymentService: debug
  • 后台日志查看

Hystrix熔断器

<!--hystrix-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

服务降级（设置自身调用超时时间的峰值,峰值内可以正常运行,  超过了需要有兜底的方法处理,做服务降级fallback）

方法1:自己业务类（service）

@HystrixCommand(fallbackMethod = "payment_TimeOutHandler", commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")//超时3秒异常

主启动类：@EnableCircuitBreaker

方法2:远程调用类（controller）

@GetMapping("/consumer/payment/hystrix/timeout/{id}")
@HystrixCommand(fallbackMethod = "paymentTimeOutFallbackMethod", commandProperties = {
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1500")
})
public String paymentInfo_TimeOut(@PathVariable("id") Integer id) {
    //int age = 10/0;
    return paymentHystrixService.paymentInfo_TimeOut(id);
}

public String paymentTimeOutFallbackMethod(@PathVariable("id") Integer id) {
    return "我是消费者80,对方支付系统繁忙请10秒种后再试或者自己运行出错请检查自己,o(╥﹏╥)o";
}

配置yml

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka
feign:
  hystrix:
    enabled: true

主启动类：@EnableHystrix      

 方法3:统一调用失败方法

import com.atguigu.springcloud.service.PaymentHystrixService;
import com.netflix.hystrix.contrib.javanica.annotation.DefaultProperties;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@Slf4j
@DefaultProperties(defaultFallback = "payment_Global_FallbackMethod")
public class OrderHystrixController {
    @Resource
    private PaymentHystrixService paymentHystrixService;


       @GetMapping("/consumer/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id) {
        return paymentHystrixService.paymentInfo_OK(id);
    }

       @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    /*@HystrixCommand(fallbackMethod = "paymentTimeOutFallbackMethod", commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1500")
    })*/
    @HystrixCommand
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id) {
        //int age = 10/0;
        return paymentHystrixService.paymentInfo_TimeOut(id);
    }

  方法4:实现远程调用接口

package com.atguigu.springcloud.service;

import com.atguigu.springcloud.service.fallback.PaymentFallbackHystrixService;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@Component
@FeignClient(value = "CLOUD-PROVIDER-PAYMENT",fallback = PaymentFallbackHystrixService.class)
public interface PaymentHystrixService {

    @GetMapping("payment/info/ok/{id}")
    String paymentInfo_OK(@PathVariable("id") Integer id);

    @GetMapping("payment/info/error/{id}")
    String paymentInfo_ERROR(@PathVariable("id") Integer id);
}

package com.atguigu.springcloud.service.fallback;

import com.atguigu.springcloud.service.PaymentHystrixService;
import org.springframework.stereotype.Component;

@Component   //将fallback接口添加到容器中
public class PaymentFallbackHystrixService implements PaymentHystrixService {
    @Override
    public String paymentInfo_OK(Integer id) {
        return "-------PaymentFallbackService fall back-paymentInfo_OK,o(╥﹏╥)o";
    }

    @Override
    public String paymentInfo_ERROR(Integer id) {
        return "-------PaymentFallbackService fall back-paymentInfo_TimeOut,o(╥﹏╥)o";
    }
}

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka
feign:
  hystrix:
    enabled: true

服务熔断

实现

服务限流

服务监控hystrixDashboard 

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

修改application.yml，暴露数据监控流

management:
  endpoints:
    web:
      exposure:
        include: hystrix.stream #访问/actuator/hystrix.stream能看到不断更新的监控流

可视化

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

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

    /**
     * 此配置是为了服务监控而配置，与服务容错本身无观，springCloud 升级之后的坑
     * ServletRegistrationBean因为springboot的默认路径不是/hystrix.stream
     * 只要在自己的项目中配置上下面的servlet即可
     * @return
     */
    @Bean
    public ServletRegistrationBean getServlet(){
        HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
        ServletRegistrationBean<HystrixMetricsStreamServlet> registrationBean = new ServletRegistrationBean<>(streamServlet);
        registrationBean.setLoadOnStartup(1);
        registrationBean.addUrlMappings("/hystrix.stream");
        registrationBean.setName("HystrixMetricsStreamServlet");
        return registrationBean;
    }
}

Gateway新一代网关

三大核心概念

  1. Route(路由)：路由是构建网关的基本模块,它由ID,目标URI,一系列的断言和过滤器组成,如断言为true则匹配该路由
  2.  Predicate(断言)：开发人员可以匹配HTTP请求中的所有内容(例如请求头或请求参数),如果请求与断言相匹配则进行路由
  3. Filter(过滤)：指的是Spring框架中GatewayFilter的实例,使用过滤器,可以在请求被路由前或者之后对请求进行修改.       

Gateway网关路由有两种配置方式:

方式1：

server:
  port: 9527
spring:
  application:
    name: cloud-gateway-service
  cloud:
    gateway:
      routes:
        - id: payment_routh
#          uri: http://localhost:8001
          uri: lb://cloud-payment-service
          predicates:
            - Path=/payment/get/**
        - id: payment_routh2
#          uri: http://localhost:8001
          uri: lb://cloud-payment-service
          predicates:
            - Path=/payment/lb/**
      discovery:
        locator:
          enabled: true  #开启从注册中心动态生成路由的功能，用微服务名进行路由

eureka:
  instance:
    hostname: cloud_gateway_service
  client:
    service-url:
      defaultZone: http://www.eureka7001.com:7001/eureka/
    register-with-eureka: true
    fetch-registry: true

方式2：

import org.springframework.cloud.gateway.route.Route;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class GateWayConfig {
//访问localhost：9527/guonei 就是访问https://www.baidu.com
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        RouteLocatorBuilder.Builder routes = builder.routes();
        routes.route("path_route",r->r.path("/guonei").uri("https://www.baidu.com")).build();
        return routes.build();
    }
}

通过服务名实现动态（需要注意的是uri的协议lb,表示启用Gateway的负载均衡功能.）

网关配置的步骤：

  • 引入依赖

  • 配置yml（参考上面配置方式）
  • 访问

常用的Route Predicate

  • After Route Predicate

  • Before Route Predicate
  • Between Route Predicate 
  • Cookie Route Predicate 

  • Header Route Predicate

  • Host Route Predicate

  • Method Route Predicate 

  • Path Route Predicate
  • Query Route Predicate

Filter的使用

      自定义全局GlobalFilter

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.Date;

/**
 * 全局自定义过滤器
 */
@Component
@Slf4j
public class MyLogGatewayFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("come in global filter: {}", new Date());

        ServerHttpRequest request = exchange.getRequest();
        String uname = request.getQueryParams().getFirst("uname");
        if (uname == null) {
            log.info("用户名为null，非法用户");
            exchange.getResponse().setStatusCode(HttpStatus.NOT_ACCEPTABLE);
            return exchange.getResponse().setComplete();
        }
        // 放行
        return chain.filter(exchange);
    }

    /**
     * 过滤器加载的顺序 越小,优先级别越高
     *
     * @return
     */
    @Override
    public int getOrder() {
        return 0;
    }
}

SpringCloud config分布式配置中心

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

Config服务端配置与测试

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>
server:
  port: 3344

eureka:
  client:
    service-url:
      defaultZone: http://www.eureka7001.com:7001/eureka/
  instance:
    ip-address: 127.0.0.1
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 1
    lease-expiration-duration-in-seconds: 2
spring:
  application:
    name: cloud-config-center
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/cunjinFS/springcloud-config.git
          search-paths:
            - springcloud-config
          username: 
          password: 
      label: master


  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest

#rabbitmq相关配置，暴露bus刷新配置的端点
management:
  endpoints:  #暴露bus刷新配置的端点
    web:
      exposure:
        include: 'bus-refresh'

]

Config客户端配置与测试

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

server:
  port: 3355

spring:
  application:
    name: config-client
  cloud:
    config:
      label: master  #分支名称
      name: config  #配置文件名称
      profile: dev  #读取后缀名称   上述三个综合http://localhost:3344/master/config-dev.yml
      uri: http://localhost:3344  #配置中心的地址

eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka

Config客户端只动态刷新

修改YML,暴露监控接口

management:
  endpoints:
    web:
      exposure:
        include: "*"

@RefreshScope业务类Controller修改

SpringCloud Bus消息总线 

SpringCloud Bus配合Springcloud Config使用可以实现配置的动态刷新

服务端 

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
server:
  port: 3344

eureka:
  client:
    service-url:
      defaultZone: http://www.eureka7001.com:7001/eureka/
  instance:
    ip-address: 127.0.0.1
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 1
    lease-expiration-duration-in-seconds: 2
spring:
  application:
    name: cloud-config-center
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/cunjinFS/springcloud-config.git
          search-paths:
            - springcloud-config
          username: 
          password: 
      label: master


  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
management:
  endpoints:
    web:
      exposure:
        include: 'bus-refresh'

客户端

​​​ 

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
server:
  port: 3355

spring:
  application:
    name: config-client
  cloud:
    config:
      label: master  #分支名称
      name: config  #配置文件名称
      profile: dev  #读取后缀名称   上述三个综合http://localhost:3344/master/config-dev.yml
      uri: http://localhost:3344  #配置中心的地址
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    
eureka:
  client:
    service-url:
      defaultZone: http://www.eureka7001.com:7001/eureka/

management:
  endpoints:
    web:
      exposure:
        include: "*"

发送POST请求  curl  -X  POST "http://localhost:3344/actuator/bus-refresh"

部分通知  curl -X POST "http://localhost:3344actuator/bus-refresh/config-clent:3355"

 SpringCloud Stream消息驱动 

是什么

屏蔽底层消息中间件的差异，降低切换成本，统一消息的编程模型

编码API和常用注解

存在的问题

  • 重复消费问题（分组解决，默认不同组；同一组会产生竞争关系，只会消费一次）
  • 消息持久化问题（分组）

SpringCloud Sleuth分布式链路跟踪

打工人上人
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCloud中文文档
03-10
在使用 Spring Cloud 时，需要注意到引导上下文和主应用程序上下文的区别，引导上下文使用与主应用程序上下文不同的外部配置约定。可以通过设置 spring.cloud.bootstrap.enabled=false 来完全禁用引导过程。 Spring...
Spring Cloud 从入门到精通
热门推荐
GitChat
07-03 79万+
Spring Cloud 是一套完整的微服务解决方案，基于 Spring Boot 框架，准确的说，它不是一个框架，而是一个大的容器，它将市面上较好的微服务框架集成进来，从而简化了开发者的代码量。 本课程由浅入深带领大家一步步攻克 Spring Cloud 各大模块，接着通过一个实例带领大家了解大型分布式微服务架构的搭建过程，最后深入源码加深对它的了解。 本课程共分为四个部分： 第一部分（第...
springcloud教程 -- 1.快速搭建入门级demo,看这一篇就够了
叶巨岩的博客
08-01 7万+
废话不多讲，跟紧我，开启你的SpringCloud初体验 首先回顾微服务的基本组成： [图片 here] 生产者：提供服务 消费者：消费服务 服务注册/发现中心：服务注册，发现，监控 所以，首先明白springcloud微服务的架构基础：生产者（client），消费者（client），服务注册/发现中心（server）
SpringCloud入门教程
最新发布
Admans的专栏
06-11 847
①Feign:声明式 REST 客户端–Feign 通过使用 JAX-RS（就是一种使用注解来实现 RESTful 的技术）或 SpringMVC 注解的装饰方式，生成接口的动态实现。旨在自动封装服务调用客户端，减少代码开发量微服务中调用接口常见方式：Ⅰ.通过http方式进行直接调用：即通过http+port的方式调用，可以使用okhttp、httpclient等进行接口的调用与解析，需要关注接口数据流、接口的数据转换等。
史上最简单的 SpringCloud 教程 | 第一篇： 服务的注册与发现Eureka(Finchley版本)
weixin_30525825的博客
07-14 8661
转载请标明出处： 原文首发于：https://www.fangzhipeng.com/springcloud/2018/08/30/sc-f1-eureka/ 本文出自方志朋的博客 一、spring cloud简介 鉴于《史上最简单的Spring Cloud教程》很受读者欢迎，再次我特意升级了一下版本，目前支持的版本为Spring Bo...
Spring Cloud详解
a2285786446的博客
08-29 1万+
微服务架构的提出者：马丁福勒简而言之，微服务架构样式[1]是一种将单个应用程序开发为一组小服务的方法，每个小服务都在自己的进程中运行并与轻量级机制（通常是HTTP资源API）进行通信。这些服务围绕业务功能构建，并且可以由全自动部署机制独立部署。这些服务的集中管理几乎没有，它可以用不同的编程语言编写并使用不同的数据存储技术。1、 微服务架构只是一个样式，一个风格。2、 将一个完成的项目，拆分成多个模块去分别开发。3、 每一个模块都是单独的运行在自己的容器中。4、 每一个模块都是需要相互通讯的。
SpringCloud-springcloud简介
weixin_51604685的博客
08-07 9362
这是springcloud的简介，里面比较了springcloud的优缺点语句服务生产者和服务消费者的搭建
全套spring cloud 项目
03-27
Spring Cloud包含了多个子项目（针对分布式系统中涉及的多个不同开源产品），比如：Spring Cloud Config、Spring Cloud Netflix、Spring Cloud CloudFoundry、Spring Cloud AWS、Spring Cloud Security、Spring ...
springcloud 完整练习项目
03-07
标题中的“springcloud 完整练习项目”意味着这是一个包含了多个 Spring Cloud 组件的实战项目，涵盖了从基础到进阶的多个层面。接下来我们将逐一解析其中的关键知识点： 1. **Eureka**：Eureka 是 Spring Cloud 中...
SpringCloud视频教程全套百度网盘
03-01
第1章 SpringCloud简介 第2章 SpringCache缓存详细讲解及应用 第3章 Redis高级缓存讲解及应用 第4章 SpringSecurity安全详细讲解及应用 第5章 RabbitMQ高级消息的讲解及应用 第6章 ElasticSearch详细讲解及应用 第7...
springcloud视频
01-20
《SpringCloud视频学习指南》 在当今的互联网行业中，微服务架构已经成为大型系统设计的主流趋势，而SpringCloud作为Java领域最热门的微服务框架，备受开发者青睐。本系列视频教程将带你深入理解SpringCloud的核心...
SpringCloud详解
0xc
05-02 1万+
网站架构演变集群：不同的机器，执行同一个计算问题。   一台机器累如狗，怎么办？来两台，负载均衡。    一台机器宕机,怎么办？来两台，灾备容错。    一台机器性能好，怎么办？让性能好的，加权轮询。分布式：把一个复杂的计算问题，拆分多个子计算，分布到不同机器上，使其并行执行。    一个计算问题计算过长，怎么办？拆分成子计算，在不同机器并行执行，缩短计算时长。    一个计算问题涉及另一个机器的...
SpringCloud 微服务架构详解
weixin_49137820的博客
12-07 1万+
如果你正在学习SpringCloud或者学过微服务有点遗忘，这篇文章是不错的选择，内有丰富的图文和案例帮助你理解。
springcloud简介
小七
12-12 3739
springcloud简介一、什么是springcloud二、关于springcloud的网站三、Spring Cloud 现状四、Spring Cloud 优缺点五、创建一个项目来介绍springcloud 今天要讲解的问题 1、springcloud解决了什么问题？ 2、最简单的分布式架构的项目 一个消费者一个生产者 3、引入eureka初步解决可能的服务宕机的问题 初步理解注册中心的作用 4、配置注册中心中的服务的联系负责人 一、什么是springcloud Spring Cloud是一系列框架的
全网最全微服务架构—Spring Cloud详解，没有比这更详细的了！
dongjia9的博客
03-15 4678
软件是有生命的，你做出来的架构决定了这个软件它这一生是坎坷还是幸福。 本文不是讲解如何使用Spring Cloud的教程，而是探讨Spring Cloud是什么，以及它诞生的背景和意义。 转载自简书作者 原文链接：： https://www.jianshu.com/p/3899d7f47303 一、背景 2008年以后，国内互联网行业飞速发展，我们对软件系统的需求已经不再是过去”能用就行”这种很low的档次了，像 抢红包、双十一这样的活动 不断逼迫我们去突破软件系统的性能上限，传统的IT企业”能用就行”的开
SpringCloud超详细教程
m0_73939789的博客
08-26 3611
单体架构：简单方便，高度耦合，扩展性差，适合小型项目。例如：学生管理系统分布式架构：松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目，例如：京东、淘宝微服务：一种良好的分布式架构方案①优点：拆分粒度更小、服务更独立、耦合度更低②缺点：架构非常复杂，运维、监控、部署难度提高SpringCloud是微服务架构的一站式解决方案，集成了各种优秀微服务功能组件SpringCloudRibbon的底层采用了一个拦截器，拦截了RestTemplate发出的请求，对地址做了修改。
Spring Cloud应用框架简介（值得收藏）
javalingyu的博客
04-12 7729
1. Spring Cloud简介 Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分
Spring Cloud 简介
蜕变
07-23 5597
1、微服务应该具备的功能 2、Spring Cloud介绍 3、Dubbo介绍 4、Kubernetes介绍 5、Spring Cloud与Dubbo比较 6、Spring Cloud 与 Kubernetes 比较
Spring Cloud Dalston 中文参考手册
"Spring Cloud Dalston中文文档是一个2018年的翻译版，包含了Spring Cloud在Dalston版本的各种特性和使用方法，包括云原生应用、Spring Cloud上下文、环境刷新、加密解密、端点、服务发现、配置管理、安全性等多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值