SpringCloud学习笔记

最新推荐文章于 2024-06-11 16:59:08 发布
最新推荐文章于 2024-06-11 16:59:08 发布
阅读量134 收藏
点赞数
文章标签： spring cloud 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51369864/article/details/132662681
版权

文章目录

微服务之间如何沟通

-HttpClient

  1. Spring框架提供了一个httpclient对象RestTemplate，发起一个http的请求。
  2. 创建resttemplate对象,由spring管理

Eureka注册中心

搭建eureka注册中心

package com.zyl;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

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

配置文件

server:
  port: 10086
spring:
  application:
    name: eureka-server  #服务名
eureka:
  client:
    register-with-eureka: false  #是否禁用自己注册自己
    fetch-registry: false
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka  #地址

Ribbon

Ribbon是一个为客户端提供负载均衡功能的服务，它内部提供了一个叫做ILoadBalance的接口代表负载均衡器的操作，比如有添加服务器操作、选择服务器操作、获取所有的服务器列表、获取可用的服务器列表等等。

1.需要解决的问题：

① 如何在配置Eureka Client注册中心时不去硬编码Eureka Server的地址？
② 在微服务不同模块间进行通信时，如何不去硬编码服务提供者的地址？
③ 当部署多个相同微服务时，如何实现请求时的负载均衡？

2.Ribbon是什么？

Ribbon是Netflix发布的云中间层服务开源项目，其主要功能是提供客户端实现负载均衡算法。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，Ribbon是一个客户端负载均衡器，我们可以在配置文件中Load Balancer后面的所有机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器，我们也很容易使用Ribbon实现自定义的负载均衡算法。

3.配置

  1. 第一种配置方式(配置类申明)

    @Bean
public IRule iRule(){
    return new RandomRule();
}

  2. 第二种配置文件申明

    userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbanlance.randomrule

加载机制

饥饿加载 加速访问速度

默认加载 第一次访问速度慢

​

Nacos注册中心

父工程

    <dependencyManagement>
        <dependencies>
            <!-- springCloud -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring-cloud-alibaba-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.2.5.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

导入依赖

<!-- nacos客户端依赖包 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

配置文件

server:
  port: 8080
spring:
  application:
    name: orderservice
  cloud:
    nacos:
      server-addr: localhost:8848

nacos的启动

在bin目录里命令行输入

startup.cmd - m standalone

集群配置

spring:
  application:
    name: userservice
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: hangzhou

配置选择服务规则负载均衡

userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule

配置服务权重负载均衡

环境隔离-namespace

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/cloud_order?useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: orderservice
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: hangzhou
        namespace: 196f350f-64ed-44d1-940c-f12b44e72f6f #环境隔离id

分析

修改非临时实例

  1. 临时实例:自己主动向nacos发送请求表示自己还是正常的 挂了nacos就会自动剔除服务
  2. 非临时实例:nacos主动向服务请求 当服务挂了不会剔除而是等待服务恢复
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/cloud_order?useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: orderservice
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: hangzhou
        namespace: 196f350f-64ed-44d1-940c-f12b44e72f6f
        ephemeral: false  #设置非临时实例

Nacos配置管理

1.统一配置管理

2.添加实现

bootstrap.yml的读取顺序比application.yml先

3.热更新

  1. 使用@refreshscope注解实现热更新
  2. 使用@configrationproperties

多环境配置共享

image-20230526145457215

Nacos集群的搭建

Http客户端Feign

为什么更换restTemplate

  1. 代码可读性差,编程体验不统一
  2. 参数复杂url难以维护

导入坐标

<!--Feign客户端-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

加上注解开启功能

@EnableFeignClients

编写接口

@FeignClient("userservice")
public interface UserClient {
    @GetMapping("/user/{id}")
    User getByid(@PathVariable Long id);
}

怎么优化feign(默认的没有连接池)

统一网关Gateway

  1. 身份认证和权限校验
  2. 服务路由,负载均衡
  3. 请求限流

创建gateway模块

1.导入依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

2.配置文件

server:
  port: 10010
spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    gateway:
      routes:
        - id: user-service  #路由标识唯一
          uri: lb://userservice #路由地址
          predicates:  #判断是否符合规则
            - Path=/user/**

  application:
    name: gateway

路由断言工厂

过滤器

  • 对服务的请求和返回的数据进行过滤

1.全局过滤器

2.默认过滤器

3.路由过滤器

全局过滤器代码实现

@Order(-1)  
@Component
public class AuthorizeFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //获取请求参数
        ServerHttpRequest request = exchange.getRequest();
        MultiValueMap<String, String> queryParams = request.getQueryParams();
        //获取参数
        String authorization = queryParams.getFirst("user");
        if ("admin".equals(authorization)) {
            //放行
            return chain.filter(exchange);
        }
        //拦截
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        return exchange.getResponse().setComplete();
    }
}

执行顺序

解决跨域问题

spring:
  application:
    name: gateway  #服务名称
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #nacos地址
    gateway:
      globalcors:
        add-to-simple-url-handler-mapping: true
        cors-configurations:
          '[/**]':  #拦截的请求
            allowedOrigins: #允许跨域的请求
              - "http://localhost:8080"
            allowedMethods: #运行跨域的请求方式
              - "GET"
              - "POST"
              - "DELETE"
              - "PUT"
              - "OPTIONS"
            allowedHeaders: "*" #允许请求中携带的头信息
            allowedCredentials: true #是否允许携带cookie
            maxAge: 36000 #跨域检测的有效期,单位s

Docker

  • 决各种服务之间依赖的冲突和版本控制

什么是镜像容器等

image-20230526184013889

Docker基本操作

1.容器的启动

systemctl docker start

2.帮助

docker --help

3.保存镜像

docker save -o redis.tar redis

4.加载镜像

docker load -i redis.tar

5.查看状态

docker ps

6.进入容器

docker exec -it 容器名 bash
image-20230526191147292

数据卷

  • 是一个虚拟目录,指向宿主机文件系统的一个真实的目录(方便配置的修改)

1.创建数据卷

docker volume create 卷名

2.查看所有数据卷

docker volume ls

3.查看数据卷详细信息

docker volume inspect 卷名

4.删除数据卷

docker volume rm 卷名

5.挂载容器到数据卷

docker run --name r -p 9999:80 -v html:/usr/share/nginx/html  -d nginx

自定义镜像结构

1.入口

镜像运行的入口,一般是程序启动的脚本和参数

2.层

在baseImage的基础上添加安装包,依赖,配置等,每次的操作都形成新的一层

3.基础镜像

应用依赖的系统函数库,环境,配置,文件等

docker-compose

docker-compose是docker提供的一个命令行工具，用来定义和运行由多个容器组成的应用。

Elasticsearch

elasticsearch是一个非常强大的关键字搜索引擎,还可以日志统计,可视化分析

索引库的操作

1.创建索引库

PUT /zyl
{
  "mappings": {
    "properties": {
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": false
      },
      "name":{
        "type": "object",
        "properties": {
          "firstname":{
            "type": "keyword"
          },
          "lastname":{
            "type": "keyword"
          }
        }
      }
    }
  }
}

2.删除索引库

delete /zyl

3.禁止修改索引库

PUT /zyl/_mapping
{
  "properties": {
    "age":{
      "type": "integer"
    }
  }
}

4.查询

get /zyl

文档操作

1.新增文档

POST /zyl/_doc/1
{
  "email": "2040@qq.com",
  "info": "朱岳磊喜欢白嫖",
  "name":{
    "firstname":"云",
    "lastname":"赵"
  }
}

2.查看文档

GET /zyl/_doc/1

3.删除

delete /zyl/_doc/1

4.修改文档

  • 全量修改,id存在会删除旧的,然后新增,如果id不存在就会直接新增
PUT /zyl/_doc/1
{
  "email": "2040@qq.com",
  "info": "朱岳磊喜欢白嫖",
  "name":{
    "firstname":"s",
    "lastname":"赵"
  }
}
  • 增量修改
POST /zyl/_update/1
{
  "doc": {
    "email":"9999@aa"
  }
}

java相关的api操作

	 private RestHighLevelClient client;

    @BeforeEach
    void setUp() {
        this.client = new RestHighLevelClient(
                RestClient.builder(HttpHost.create("8.130.94.244:9200")));
    }

    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }

    @Test
    void test1() throws IOException {
        //创建request对象
        CreateIndexRequest request = new CreateIndexRequest("hotel");
        //准备请求参数  dsl语句
        request.source(MAPPING_TEMPLATE, XContentType.JSON);
        //发送请求
        client.indices().create(request, RequestOptions.DEFAULT);
    }

    @Test
    void test2() throws IOException {
        //创建request对象
        DeleteIndexRequest request = new DeleteIndexRequest("hotel");
        //发送请求
        client.indices().delete(request, RequestOptions.DEFAULT);
    }

    @Test
    void test3() throws IOException {
        //创建request对象
        GetIndexRequest request = new GetIndexRequest("hotel");
        //发送请求
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

操作文档

    private RestHighLevelClient client;
    @Autowired
    private IHotelService iHotelService;
    @Test
    void test1() throws IOException {
        //查询数据库
        Hotel hotel = iHotelService.getById(61083L);
        //类型转换
        HotelDoc hotelDoc = new HotelDoc(hotel);
        //创建request对象
        IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
        //准备请求参数  dsl语句
        request.source(JSON.toJSONString(hotelDoc), XContentType.JSON);
        //发送请求
        client.index(request,RequestOptions.DEFAULT);
    }

    @Test
    void test2() throws IOException {
        //创建request对象
        GetRequest request = new GetRequest("hotel","61083");
        //发送请求
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        //解析
        String json = response.getSourceAsString();
        HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
        System.out.println(hotelDoc);
    }

    @Test
    void test3() throws IOException {
        //创建request对象
        UpdateRequest request = new UpdateRequest("hotel", "61083");
        //修改的参数
        request.doc(
                "price","1000",
                "starName","四钻"
        );
        //发送请求
        client.update(request, RequestOptions.DEFAULT);
    }
    @Test
    void test4() throws IOException {
        //创建request对象
        DeleteRequest request = new DeleteRequest("hotel", "61083");
        //发送请求
        client.delete(request, RequestOptions.DEFAULT);
    }
    @Test
    void test5() throws IOException {
        //查询数据
        List<Hotel> hotels = iHotelService.list();
        //创建request对象
        BulkRequest bulkRequest = new BulkRequest();
        //批量添加
        for (Hotel hotel : hotels) {
            HotelDoc hotelDoc = new HotelDoc(hotel);
            bulkRequest.add(new IndexRequest("hotel")
                    .id(hotelDoc.getId().toString())
                    .source(JSON.toJSONString(hotelDoc),XContentType.JSON));
        }
        //发送请求
        client.bulk(bulkRequest, RequestOptions.DEFAULT);
    }
    @BeforeEach
    void setUp() {
        this.client = new RestHighLevelClient(
                RestClient.builder(HttpHost.create("8.130.94.244:9200")));
    }

    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }

DSL查询语法

1.查询所有

GET /hotel/_search
{
  "query": {
    "match_all": {}
  }
}

2.全文检索查询

  • 使用了copy_to all
GET /hotel/_search
{
  "query": {
    "match": {
      "all": "上海如家"
    }
  }
}

3.精确查询

GET /hotel/_search
{
  "query": {
    "term": {
      "city": "上海1"
    }
  }
}

4.范围查询

GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 100,
        "lte": 200
      }
    }
  }
}

5.位置查询

GET /hotel/_search
{
  "query": {
    "geo_distance": {
      "distance":"5km",
    "location": "31.21,121.5"
    }
  }
}

6.相关性算分

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": {
          "all": "外滩"
        }
      },
      "functions": [
        {
          "filter": {
            "term": {
              "brand": "如家"
            }
          },
          "weight": 10
        }
      ],
      "boost_mode": "multiply"
    }
  }
}

7.复合查询

GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "如家"
          }
        }
      ],
      "must_not": [
        {
          "range": {
            "price": {
              "gt": 400
            }
          }
        }
      ],
      "filter": [
        {
          "geo_distance": {
            "distance": "10km",
            "location": {
              "lat": 31.21,
              "lon": 121.5
            }
          }
        }
      ]
    }
  }
}

8.排序

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "score": "desc"
    },
    {
      "price": "asc"
    }
  ]
}

9.分页查询

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "score": "desc"
    },
    {
      "price": "asc"
    }
  ],
  "from": "10",
  "size": 20
}

10.关键字高亮

GET /hotel/_search
{
  "query": {
    "match": {
      "all": "如家"
    }
  },
  "highlight": {
    "fields": {
      "all": {
        "require_field_match": "false"
      }
    }
  }
}

java的搜索 api

    private RestHighLevelClient client;

    @Test
    void test1() throws IOException {
        //创建request对象
        SearchRequest request = new SearchRequest("hotel");
        //准备请求参数  dsl语句
        request.source().query(QueryBuilders.matchAllQuery());
        //发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //解析数据
        SearchHits hits = response.getHits();
        //总数据数
        TotalHits total = hits.getTotalHits();
        System.out.println("总条数-----"+total);
        //具体数据
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            String json = hit.getSourceAsString();
            System.out.println(json);
        }
    }

    @Test
    void test2() throws IOException {
        //创建request对象
        SearchRequest request = new SearchRequest("hotel");
        //准备请求参数  dsl语句
        request.source().query(QueryBuilders.matchQuery("all","如家"));
        //发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //解析数据
        SearchHits hits = response.getHits();
        //总数据数
        TotalHits total = hits.getTotalHits();
        System.out.println("总条数-----"+total);
        //具体数据
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            String json = hit.getSourceAsString();
            System.out.println(json);
        }
    }

    @Test
    void test3() throws IOException {
        //创建request对象
        SearchRequest request = new SearchRequest("hotel");
        //准备请求参数  dsl语句
        BoolQueryBuilder booledQuery = QueryBuilders.boolQuery();
        //具体查询
        booledQuery.must(QueryBuilders.termQuery("city","上海"));
        //范围查询
        booledQuery.filter(QueryBuilders.rangeQuery("price").lte(200));
        request.source().query(booledQuery);
        //发送请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);
        //解析数据
        SearchHits hits = response.getHits();
        //总数据数
        TotalHits total = hits.getTotalHits();
        System.out.println("总条数-----"+total);
        //具体数据
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            String json = hit.getSourceAsString();
            System.out.println(json);
        }
    }
    @Test
    void test4() throws IOException {
        //创建request对象
        SearchRequest request = new SearchRequest("hotel");
        //准备请求参数  dsl语句
        request.source().query(QueryBuilders.matchAllQuery());
        //排序 sort
        request.source().sort("price", SortOrder.ASC);
        //分页
        request.source().from(0).size(7);
        //发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //解析数据
        SearchHits hits = response.getHits();
        //总数据数
        TotalHits total = hits.getTotalHits();
        System.out.println("总条数-----"+total);
        //具体数据
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            String json = hit.getSourceAsString();
            System.out.println(json);
        }
    }
    @Test
    void test5() throws IOException {
        //创建request对象
        SearchRequest request = new SearchRequest("hotel");
        //准备请求参数  dsl语句
        request.source().query(QueryBuilders.matchQuery("all","如家"));
        request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
        //发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //解析数据
        SearchHits hits = response.getHits();
        //总数据数
        TotalHits total = hits.getTotalHits();
        System.out.println("总条数-----"+total);
        //具体数据
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            String json = hit.getSourceAsString();
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if (!CollectionUtils.isEmpty(highlightFields)){
                HighlightField name = highlightFields.get("name");
                String string = name.getFragments()[0].toString();
                System.out.println(string);
                System.out.println(json);
            }
        }
    }
    @BeforeEach
    void setUp() {
        this.client = new RestHighLevelClient(
                RestClient.builder(HttpHost.create("8.130.94.244:9200")));
    }

    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }

SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    //解析数据
    SearchHits hits = response.getHits();
    //总数据数
    TotalHits total = hits.getTotalHits();
    System.out.println("总条数-----"+total);
    //具体数据
    SearchHit[] searchHits = hits.getHits();
    for (SearchHit hit : searchHits) {
        String json = hit.getSourceAsString();
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();
        if (!CollectionUtils.isEmpty(highlightFields)){
            HighlightField name = highlightFields.get("name");
            String string = name.getFragments()[0].toString();
            System.out.println(string);
            System.out.println(json);
        }
    }
}
@BeforeEach
void setUp() {
    this.client = new RestHighLevelClient(
            RestClient.builder(HttpHost.create("8.130.94.244:9200")));
}

@AfterEach
void tearDown() throws IOException {
    this.client.close();
}
zyl熬夜之路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
狂神说SpringCloud学习笔记
qq_43161404的博客
01-09 2193
前言：B站狂神说Java中SpringBoot笔记，传送门 UP很nice，课程生动形象，欢迎支持。 一、什么是微服务 整体部署：每一个模块的变更很难不影响到其他模块，使得变更周期变得漫长，扩展需要整体扩展，而不能进行部分扩展。 就目前而言，对于微服务，业界并没有一个统一的，标准的定义。 但通常而言，微服务架构是一种架构模式，或者说是一种架构风格，它体长将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值，服务之间采用轻量级的通信机制(HT
狂神springcloud学习笔记加代码
03-24
狂神springcloud学习笔记加代码 笔记可以看：https://www.kuangstudy.com/bbs/1374942542566551554#header4 视频链接：https://www.bilibili.com/video/BV1jJ411S7xr
SpringCloud 学习笔记
Java技术一点通
12-16 1585
单体架构垂直架构分布式架构SOA架构微服务架构Feign 是一个声明式的 REST 客户端，它用了基于接口的注解方式，很方便实现客户端像调用本地接口方法一样，进行远程调用。Feign 最初由 Netflix 公司提供，但不支持SpringMVC注解，后由 SpringCloud 对其封装，支持了SpringMVC注解，让使用者更易于接受。能让服务的调用方，够快的知道被调方挂了！不至于说让用户在等待。Hystix 是 Netflix 开源的一个延迟和容错库，用于隔离访问远程服务、第三方库，
Spring Cloud 学习笔记（1 / 3）
热门推荐
KISS
03-03 20万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
Spring Cloud 学习笔记（2 / 3）
KISS
03-03 8万+
Spring Cloud 学习笔记（1 / 3） Spring Cloud 学习笔记（3 / 3） - - - 56_Hystrix之全局服务降级DefaultProperties 57_Hystrix之通配服务降级FeignFallback 58_Hystrix之服务熔断理论 59_Hystrix之服务熔断案例(上) 60_Hystrix之服务熔断案例(下) 61_Hystrix之服务熔断总结 62_Hystrix工作流程最后总结 63_Hystrix图形化Dashboard搭建
Spring Cloud 学习笔记
山河已无恙
03-19 1947
26岁的时候，如果你过的不够好。请不要过于自责。很可能，你只是不够幸运罢了！---哈哈，知乎看到的，讲给自己 ...
SpringCloud学习笔记（一）
怕什么真理无穷，进一寸有一寸的欢喜。即使开了一辆老掉牙的破车，只要在前行就好，偶尔吹点小风，这就是幸
03-31 1129
什么是SpringCloud Spring Cloud 是一套完整的微服务解决方案，Spring Cloud 构建于 Spring Boot 之上，使得开发者很容易入手并快速应用于生产中。准确的说，它不是一个框架，而是一个大的容器，它将市面上较好的微服务框架集成进来，从而简化了开发者的代码量。 springCloud和spring boot有什么关系？ springboot可以快速开发单个微服务。springcloud是一个基于springboot实现的一系列框架的集合，用来提供全局的服务治理方案。.
SpringCloud学习笔记01
qq_43117059的博客
10-18 947
Spring Cloud封装了Netflix 公司开发的Eureka模块来实现服务治理。在传统的rpc远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务与服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。Erueka采用了CS的设计架构，Eureka Server 作为服务注册功能的服务器，它是服务注册中心。而系统中的其他微服务，使用Eureka的客户端连接到Eureka的客户端连接到Eureka Server并维持心跳连接。
springcloud学习笔记
一般社员的博客
01-10 270
** 2022/1/10-springboot-cloud-study ** spring cloud NetFlix 一站式解决方案 api网关，zuul组件 Feign–HttpClient–http通信方式，同步的，阻塞 服务注册：Eureka 熔断机制：Hystrix apache Dubbo zookeeper 半自动，需要整合其他的 API:使用三方组件 Dubbo zookeeper （这个方案并不完善） soring cloud Alibaba 新的一站式解决方案，简化 主要解
尚硅谷 周阳老师 SpringCloud 学习笔记
shuai_aaaaaaa的博客
01-15 3005
十二、服务配置 Spring Cloud Config 配置中心 1. 概述 1.1 分布式系统面临的配置问题 微服务意味着要将单体应用中的业务拆分成一个个子服务，每个服务的粒度相对较小，因此系统中会出现大量的服务。由于每个服务都需要必要的配置信息才能运行，所以一套集中式的、动态的配置管理设施是必不可少的。 我们每一个微服务自己带着一个application.yml，上百个配置文件的管理就非常痛苦，SpringCloud 提供了ConfigServer来解决这个问题。 1.2 是什么 SpringCloud
springcloud学习笔记.pdf
03-12
Spring Cloud 学习笔记 本笔记主要介绍了从单体架构到微服务架构的演变过程，以及 Spring Cloud 中的微服务架构搭建。下面是本笔记的详细知识点总结： 一、单体架构 单体架构是指整个系统只有一个工程，打包往往...
Spring Cloud 学习笔记.pdf
03-26
Spring Cloud 学习入门笔记，全方面实践，包含 spring cloud alibaba 模块
Springcloud学习笔记.md
07-02
Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Spring...
如何学习Golang语言!
FengyangCoder的博客
06-09 397
起源与设计哲学：Go语言由Robert Griesemer、Rob Pike和Ken Thompson三位Google工程师设计，旨在解决现代编程中的一些常见问题，如编译速度、运行效率和并发编程。主要特点：Go语言的语法简单、编译速度快、运行效率高，支持静态类型和内存安全，具有垃圾回收功能，并且原生支持并发编程。
扩展学习|风险管理的文献综述汇总（持续更新向）
weixin_63253486的博客
06-10 775
本片博客主要介绍风险管理领域本人所看到的一些有意思的文章，并就风险管理领域的相关内容进行一个分享。
[ue5]建模场景学习笔记（5）——必修内容可交互的地形，交互沙（3）
qq_40128113的博客
06-09 299
5.第一想法直接clear掉，但直接clear会把想要保留的痕迹一并去除，跑起来就没有痕迹！所以不行，要做一个转载，先把痕迹保留在一个载体上，清楚原来痕迹，用sandsave表示，再把这个载体的痕迹保存回原来rt，这样之前的痕迹被清空了，只留下了保存在载体上的部分，正好符合我们想要的部分。我们现在已经能够让这片地形出现在任意地方，只要角色走在这片地形上，就能够产生痕迹，但这片区域总是需要人工指定，又无法把这片区域无限扩大（显存爆炸），因此尝试使角色无论走到哪里都能产生痕迹。否则绘制不到画板上。
Qt---pro文件的学习
最新发布
weixin_51883798的博客
06-11 425
【代码】Qt---pro文件的学习。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值