spring-cloud+ nacos+feign 增删改查（多表）

最新推荐文章于 2024-07-28 16:45:11 发布
最新推荐文章于 2024-07-28 16:45:11 发布
阅读量2.9k 收藏 10
点赞数 1
文章标签： 大数据 spring cloud 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dwiwhwjd/article/details/121386482
版权

spring-cloud+ nacos+feign 增删改查（多表）

环境准备

  • 数据库
    学生自行创建数据库，根据提供的sql创建表和数据,每个表单独一个数据库
  • 后台
    学生自行搭建SpringCloud+Feign+Nacos+GateWay+MyBatis后台环境
  • 前台
    学生自行创建前台vue环境，实现测试要求

后端：以book和category为例

如图所示：book 是主，category是从

在这里插入图片描述

book.pom文件 和category.pom文件

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
         <!--这个是你自己的 feign-apl -->
        <dependency>
            <groupId>book-parent</groupId>
            <artifactId>feign-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--阿里 spring cloud-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--通用mapper-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>
        <!--spring boot 启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mysql 启动器-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!--nacos配置管理依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
    </dependencies>
    <build>
        <finalName>app</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

feign（远程调用）和getaway（网关）


红色的不用写 那是过滤器

feign 和getaway的pom文件

 <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.2.6.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!--引入feign的starter依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <version>2.2.6.RELEASE</version>
        </dependency>

        <!-- 时间所需的jar @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!-- 通用mysql-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>

    </dependencies>

getaway·：内容

   
    <dependencies>
    <!--网关-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
        <version>2.2.6.RELEASE</version>
    </dependency>
    <!--nacos服务发现依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        <version>2.2.6.RELEASE</version>
    </dependency>
</dependencies>
父类（项目类）

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.9.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR10</spring-cloud.version>
        <mysql.version>8.0.27</mysql.version>
        <mybatis.version>2.1.1</mybatis.version>
        <mapper.starter.version>2.0.2</mapper.starter.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- springCloud  阿里 -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.2.6.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- mysql驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!--mybatis-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <!-- 通用Mapper启动器 -->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>${mapper.starter.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

创建数据库：一个表 一个数据库
在这里插入图片描述
好了环境准备，已经做完了下面就是写代码了

BookController.java

package com.czxy.controller;

import com.czxy.Vo.BookVo;
import com.czxy.domain.Book;
import com.czxy.service.BookService;
import com.github.pagehelper.PageInfo;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/book")
public class BookController {

    @Resource
    private BookService bookService;

    @GetMapping
    public List<Book> findSchoolAll(){
        List<Book> list = bookService.findSchoolAll();
        return list;
    }
    @GetMapping("/{id}")
    public Book findSchoolById(@PathVariable("id") Integer id){
        Book book = bookService.findSchoolById(id);
        return book;
    }

    @PutMapping
    Integer Up(@RequestBody Book book){
        Integer up = bookService.Up(book);
        return up;
    }
    @PostMapping("/{pageNum}/{pageSize}")
    PageInfo<Book> pageIn(
            @PathVariable Integer pageNum,
            @PathVariable Integer pageSize,
            @RequestBody BookVo bookVo
    ){
        PageInfo<Book> bookPageInfo = bookService.pageIn(pageNum, pageSize, bookVo);
        return bookPageInfo;
    }


    @PostMapping
    Integer insert(@RequestBody Book book){
        Integer insert = bookService.insert(book);
        return insert;
    }


    @DeleteMapping("/{id}")
    Integer daleTe(@PathVariable("id") Integer id){
        Integer daleTe = bookService.daleTe(id);
        return daleTe;
    }

    @DeleteMapping("/batchDelete/{ids}")
    void daleAll(@PathVariable("ids") String ids){
        bookService.daleAll(ids);
    }

}

BookMapper.java

package com.czxy.dao;

import com.czxy.domain.Book;
import com.czxy.domain.Category;
import tk.mybatis.mapper.common.Mapper;

@org.apache.ibatis.annotations.Mapper
public interface BookMapper extends Mapper<Book> {
}

bookservice.java

package com.czxy.service;

import com.czxy.Vo.BookVo;
import com.czxy.dao.BookMapper;
import com.czxy.domain.Book;
import com.czxy.domain.Category;
import com.czxy.feign.BookFeign;
import com.czxy.feign.CategoryClient;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.entity.Example;

import javax.annotation.Resource;
import java.util.List;

@Service
@Transactional
public class BookService implements BookFeign {

    @Resource
    private BookMapper bookMapper;

    @Resource
    private CategoryClient categoryClient;
    @Override
    public List<Book> findSchoolAll() {
        List<Book> list = bookMapper.selectAll();
        for (Book book : list) {
            Category category = categoryClient.queryByTid(book.getCid());
            book.setCategory(category);
        }
        return list;
    }

    @Override
    public Book findSchoolById(Integer id) {
        Book book = bookMapper.selectByPrimaryKey(id);
        Category category = categoryClient.queryByTid(book.getCid());
        book.setCategory(category);
        return book;
    }

    @Override
    public Integer Up(Book book) {
        int i = bookMapper.updateByPrimaryKey(book);
        return i;
    }

    @Override
    public Integer daleTe(Integer id) {
        int i = bookMapper.deleteByPrimaryKey(id);
        return i;
    }

    @Override
    public void daleAll(String ids) {
        String[] split = ids.split(",");
        for (String s : split) {
            bookMapper.deleteByPrimaryKey(s);
        }
    }

    @Override
    public PageInfo<Book> pageIn(Integer pageNum, Integer pageSize, BookVo bookVo) {

        Example example = new Example(Book.class);

        Example.Criteria criteria = example.createCriteria();

        if (bookVo.getCid()!=null && !"".equals(bookVo.getCid())){
            criteria.andEqualTo("cid",bookVo.getCid());
        }

        if (bookVo.getName()!=null&& !"".equals(bookVo.getName())){
            criteria.andLike("name","%"+bookVo.getName()+"%");
        }
        if (bookVo.getStaPrice()!= null && !"".equals(bookVo.getStaPrice())){
            criteria.andGreaterThanOrEqualTo("price",bookVo.getStaPrice());
        }
        if (bookVo.getEntPrice()!= null && !"".equals(bookVo.getEntPrice())){
            criteria.andLessThanOrEqualTo("price",bookVo.getEntPrice());
        }

        PageHelper.startPage(pageNum,pageSize);

        List<Book> list = bookMapper.selectByExample(example);
        for (Book book : list) {
            Category category = categoryClient.queryByTid(book.getCid());
            book.setCategory(category);
        }


        return new PageInfo<>(list);
    }

    @Override
    public Integer insert(Book book) {
        int insert = bookMapper.insert(book);
        return insert;
    }

}

启动类：BookApplication

package com.czxy;

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

@EnableFeignClients(basePackages = "com.czxy.feign")
@SpringBootApplication
public class BookApplication {
    public static void main(String[] args) {
        SpringApplication.run(BookApplication.class,args);
    }
}

B：application.yml

server:
  port: 8081
spring:
  application:
    name: bookservice
  datasource:
    url: jdbc:mysql://localhost:3306/cloud-book?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC&useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
      config:
        file-extension: yaml # 文件后缀名
mybatis:
  type-aliases-package: com.czxy.domain
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
feign:
  client:
    config:
      default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
        loggerLevel: FULL #  日志级别

CategoryController.java

package com.czxy.controller;

import com.czxy.dao.CategoryMapper;
import com.czxy.domain.Book;
import com.czxy.domain.Category;
import com.czxy.service.CategoryService;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/category")
public class CategoryController {

    @Resource
    private CategoryService categoryService;



    @GetMapping
    List<Category> All(){
        List<Category> all = categoryService.All();
        return all;
    }

    @PostMapping
    Integer insert(@RequestBody Category category){
        return categoryService.insert(category);
    }

    @GetMapping("/{cid}")
    Category queryByTid(@PathVariable Integer cid){
        Category category = categoryService.queryByTid(cid);
        return category;
    }
    @PutMapping
    Integer Up(@RequestBody Category category){
        return categoryService.Up(category);
    }

    @DeleteMapping("/{cid}")
    Integer Up(@PathVariable("cid")  Integer cid){
        return categoryService.date(cid);
    }
}

CategoryService.java

package com.czxy.service;

import com.czxy.dao.CategoryMapper;
import com.czxy.domain.Category;
import com.czxy.feign.CategoryClient;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

@Service
@Transactional
public class CategoryService implements CategoryClient {

    @Resource
    private CategoryMapper categoryMapper;


    @Override
    public Category queryByTid(Integer cid) {
        Category category = categoryMapper.selectByPrimaryKey(cid);
        return category;
    }

    @Override
    public List<Category> All() {
        List<Category> categories = categoryMapper.selectAll();
        return categories;
    }

    @Override
    public Integer insert(Category category) {
        return categoryMapper.insert(category);
    }
    @Override
    public Integer Up(Category category) {
        return categoryMapper.updateByPrimaryKey(category);
    }
    @Override
    public Integer date(Integer cid) {
        return categoryMapper.deleteByPrimaryKey(cid);
    }
}

CategoryMapper.java

package com.czxy.dao;

import com.czxy.domain.Category;
import tk.mybatis.mapper.common.Mapper;

@org.apache.ibatis.annotations.Mapper
public interface CategoryMapper extends Mapper<Category> {
}

CategoryApplication.java

package com.czxy;

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

@EnableFeignClients(basePackages = "com.czxy.feign")
@SpringBootApplication
public class CategoryApplication {
    public static void main(String[] args) {
        SpringApplication.run(CategoryApplication.class,args);
    }
}

C：application.yml

server:
  port: 8082
spring:
  application:
    name: categoryservice
  datasource:
    url: jdbc:mysql://localhost:3306/cloud-category?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC&useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
      config:
        file-extension: yaml # 文件后缀名
mybatis:
  type-aliases-package: com.czxy.domain
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
feign:
  client:
    config:
      default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
        loggerLevel: FULL #  日志级别

在feign中创建实体类：book
在这里插入图片描述
在feign中创建实体类：category
在这里插入图片描述
BookFeign.java

package com.czxy.feign;

import com.czxy.Vo.BookVo;
import com.czxy.domain.Book;
import com.github.pagehelper.PageInfo;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

import java.util.List;

//微服务的地址
@FeignClient(value="bookservice")
public interface BookFeign {
    //todo 查询所有
    @GetMapping("/book")
    public List<Book> findSchoolAll();

    //todo 分页查询+ 模糊查询
    @PostMapping("/book/{pageNum}/{pageSize}")
    PageInfo<Book>pageIn(
            @PathVariable Integer pageNum,
            @PathVariable Integer pageSize,
            @RequestBody  BookVo bookVo
            );

    //todo 添加
    @PostMapping("/book")
    Integer insert(@RequestBody Book book);

    //todo 根据id 查询
    @GetMapping("/book/{id}")
    public Book findSchoolById(@PathVariable("id") Integer id);

    //todo 修改
    @PutMapping("/book")
    Integer Up(@RequestBody Book book);

    //todo 删除
    @DeleteMapping("/book/{id}")
    Integer daleTe(@PathVariable("id") Integer id);

    //todo 批量删除
    @DeleteMapping("/book/batchDelete/{ids}")
    void daleAll(@PathVariable("ids") String ids);

}

CategoryClient.java

package com.czxy.feign;

import com.czxy.domain.Category;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

import java.util.List;

//微服务的地址
@FeignClient(value = "categoryservice")
public interface CategoryClient {

    //todo 根据id 查询
    @GetMapping("/category/{cid}")
    Category queryByTid(@PathVariable Integer cid);

    //todo 查询所有
    @GetMapping("/category")
    List<Category> All();

    //todo 添加
    @PostMapping("/category")
    Integer insert(@RequestBody Category category);

    //todo 修改
    @PutMapping("/category")
    Integer Up(@RequestBody Category category);

    //todo 删除
    @DeleteMapping("/category/{cid}")
    Integer date(@PathVariable Integer cid);
}

分页所需要的Vo类
在这里插入图片描述
getaway的启动类
在这里插入图片描述
G：application.yml

server:
  port: 10010 # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
    gateway:
      routes: # 网关路由配置
        - id: book-service # 路由id，自定义，只要唯一即可
            # uri: http://127.0.0.1:8082 # 路由的目标地址 http就是固定地址
          uri: lb://bookservice/ # 路由的目标地址 lb就是负载均衡，后面跟服务名称
          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
            - Path=/book/** # 这个是按照路径匹配，只要以/user/开头就符合要求
        - id: category-service # 路由id，自定义，只要唯一即可
                  # uri: http://127.0.0.1:8082 # 路由的目标地址 http就是固定地址
          uri: lb://categoryservice/ # 路由的目标地址 lb就是负载均衡，后面跟服务名称
          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
          - Path=/category/** # 这个是按照路径匹配，只要以/user/开头就符合要求
      # 网关解决跨域
      globalcors: # 全局的跨域处理
        add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
        corsConfigurations:
          '[/**]':
            allowedOrigins: # 允许哪些网站的跨域请求
              - "http://localhost:8080"
            allowedMethods: # 允许的跨域ajax的请求方式
              - "GET"
              - "POST"
              - "DELETE"
              - "PUT"
              - "OPTIONS"
            allowedHeaders: "*" # 允许在请求中携带的头信息
            allowCredentials: true # 是否允许携带cookie
            maxAge: 360000 # 这次跨域检测的有效期
魔界小皮蛋
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
SpringBoot+SpringCloud+nacos+gateway+mybatis搭建微服务
11-09
在构建分布式系统时，Spring Boot、Spring Cloud、Nacos、Gateway和MyBatis这五大组件是常见的技术选型。下面将详细阐述它们的功能、如何整合以及在微服务架构中的作用。 1. Spring Boot：作为核心启动框架，Spring...
srping-cloud-alibaba-nacos-feign.zip
03-14
《Spring Cloud Alibaba Nacos与Feign的整合应用详解》 在微服务架构中，服务间的通信是关键一环。Spring Cloud Alibaba提供了丰富的组件，其中包括Nacos作为服务注册与配置中心，以及Feign作为声明式服务调用工具...
SpringCloud项目实战（3）——增删改查
qq_64037280的博客
12-17 399
在SpringCloud中，增删改查是基本操作，前端在响应用户操作后，将会把该响应通过API发送给后端，并调用后端对应功能对后端数据库进行增删改查的操作。而我们需要做的就是根据项目的业务逻辑和后端数据库表结构设计合理的查询事务，并能高效完成相应操作，本章节将会通过实际的案例来演示实现过程，但在了解实际操作过程前，我们需要了解MyBatis-Plus。总体来说，数据的增删改查是SpringBoot中的基本操作，但也是项目中最重要的过程。目前博主也在持续学习，博客持续更新中...
微服务设计指导-实践springcloud+springboot+nacos+feign+hytrix
lifetragedy的专栏
12-15 1445
什么样的请求需要做成微服务 模块A→模块B。 而，模块B→请求模块C。 如果A和B本身又有其它的请求如： 模块D->模块A，模块E→模块B； 此时，对于： 模块C，需要做成基于单根api的微服务provider； 对于访问模块C的，需要做成微服务consumer/client； 忌讳的做法 服务泛滥，例：把单表的增删改查都做成了微服务，到处调用； 循环无止镜去调用微服务； 什么都做成微服务； 需要记住的微服务开发规范 单体的provider在1,000并发的情况下，必须在毫秒级（
spring cloud + nacos + feign调用
xyzroundo的专栏
12-02 570
//by yan 20211119 需求： 简单建个项目，用来测试调用注册在nacos的服务接口。 步骤： idea -> new project-> Spring Initializr 踩坑： 1、开始是maven包引入报错。修改各种配置 pom repositories 、 maven 配置等，有时还要删除项目.idea重启idea。总结大多是maven的版本问题。最后都是使用idea 自带版本 “Bundled (Maven 3)” 就ok。 2、spring boot 和spring c
SpringCloud+Nacos+Gateway+Feign+Seata
不积跬步无以至千里，不积小流无以成江河
03-08 3498
SpringCloud+Nacos+Gateway+Feign+Seata
Spring Cloud+Nacos+feign
大胖东的博客
04-12 1258
Spring Cloud+Nacos+Feign 使用feign调用其他服务，提前是先要把其他服务（服务端和消费端）注册到Nacos上 使用Nacos作为服务注册中心
SpringBoot整合SpringCloud+nacos+feign
JJ_code的博客
05-06 371
最近因为项目需求，要将一个SpringBoot项目A整合进一个分布式项目B中，项目B的技术栈为SpringCloud Alibaba+nacos+openfeign。
SpringCloud-Nacos+Sentinel+Feign
dhylanyu1的博客
07-25 342
SpringCloud-Nacos+Sentinel+Feign高并发问题解决方案面向失败编程-容错方案Sentinel核心概念配置流量控制两种规则流量控制效果熔断策略熔断状态Alibaba Cloud升级异常种类Feign+Sentinel 高并发 问题 多个服务之间相互依赖，可能会导致系统负载过高，突发流量或网络异常等情况，导致服务不可用。 解决方案 面向失败编程： 不被外界影响 不被请求拖垮 2.1 上游服务 2.2 下游服务 面向失败编程-容错方案 限流 漏斗，不管流量多大，均匀的流入容器，令
springcloud+nacos+feign+gateway构建微服务
彼岸笙箫的博客
09-23 336
springcloud+nacos+feign+gateway构建微服务
SpringCloud+Nacos+Gateway
AG.『Feng』的博客
02-14 3903
SpringCloud+Nacos+Gateway
微服务 ： SpringCloud + Nacos + Feign
08-10
在这个主题中，我们重点关注的是SpringCloud、Nacos以及Feign这三个关键组件在构建微服务中的角色。 首先，SpringCloud是基于Spring Boot的一个框架集合，它提供了在分布式系统（如配置管理、服务发现、断路器、...
spring-cloud-alibaba+dubbo+nacos内部服务调用
03-08
4. **负载均衡**：Spring Cloud Alibaba中的Ribbon或Feign组件可以与Nacos集成，实现请求在多个服务实例间的智能负载均衡，提高系统性能和可用性。 5. **熔断与降级**：Hystrix或Sentinel（Spring Cloud Alibaba的...
SpringCloud + SpringBoot + Nacos + feign +config整合测试.zip
05-14
本项目“SpringCloud + SpringBoot + Nacos + feign + config整合测试”是一个典型的微服务实践案例，涉及到多个关键组件的集成与协同工作。下面我们将详细探讨这些组件以及它们在项目中的作用。 1. **SpringBoot**...
分布式系统常见软件架构模式
Ben的专栏
07-25 995
简而言之，有效管理数据和通信流对于构建健壮且可扩展的分布式系统至关重要。对等、API 网关、发布-订阅、请求-响应、事件溯源、ETL、批处理、流处理和编排等架构模式提供了有价值的解决方案，以应对系统设计和实现中的各种挑战。通过理解这些软件架构和分布式系统模式及其各自的优势和权衡，架构师和开发人员可以做出明智的决策，设计出满足其应用程序和用户不断变化的需求的系统。
消息队列-rabbitmq（生产者.消费者. 消息.可靠性）
最新发布
2202_75352238的博客
07-28 554
在我们 生产者发送消息到交换机的时候，假如 我们发送到交换机 ，但是 队列没有收到消息，会返回ack，发送到交换机，然后发送到队列，消费者没有接收到消息返回ack，但是发送到交换机失败，会返回nack。死信交换机 ，都是假如一个定时消息过期了，或者发送延迟消息我们直接把该消息传递到我们绑定的死信交换机中，跟上文 消息发送失败了返回rejct之后，消息发送到err交换机是两种不同的策略。当一条消息发送失败的时候，消费者重新尝试消费消息，达到我们重试的次数之后，消费者返回reject，mq直接删除消息。
Kafka知识总结（选举机制+控制器+幂等性）
月伴飞鱼
07-27 941
其他Broker启动时也会在Zookeeper中创建临时节点，但是发现节点已经存在，所以它们会收到一个异常，意识到控制器已经存在，那么就会在Zookeeper中创建Watch对象，便于它们收到控制器变更的通知。他只能保证单分区上的幂等性，即一个幂等性Producer只能够保证某个topic的一个分区上不出现重复消息，无法实现多分区的幂等。控制器上保存了最全的集群元数据信息，其他所有 Broker 会定期接收控制器发来的元数据更新请求，从而更新其内存中的缓存数据。目前，当有新 Broker 启动后，它会在。
Spark RPC框架详解
小昌昌的博客
07-22 1123
SparkContext构造过程的重要一步，就是Driver、ApplicationMaster以及Executor之间的协调和通信过程，这是基于RPC进行的。这里的Spark RPC是基于Netty的通信过程，而Netty的通信其实是基于Reactor架构进行的，Reactor架构其实是基于Java NIO模型进行的。本文详细讲解了基于Netty 的 SparkRPC 框架的实现细节。
springcloud+nacos+feign
09-16
springcloud nacos feign是一种结合了Spring Cloud和Nacos的服务调用方式。Nacos是一个动态服务发现、配置中心和服务管理平台，而Feign是Spring Cloud中的一个声明式的Web服务客户端。通过使用Nacos作为服务注册中心，Feign可以方便地调用其他服务。在使用springcloud nacos feign时，你需要在消费端的pom.xml中添加依赖，新建一个DemoFeign接口，并使用@FeignClient注解指定要调用的服务名。然后，就可以通过调用DemoFeign接口的方法来调用其他服务提供的接口。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

魔界小皮蛋

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

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

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

打赏作者

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

抵扣说明：

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

余额充值