【Spring Cloud实战】消费者直接调用提供者（案例）

最新推荐文章于 2023-06-27 22:11:55 发布
最新推荐文章于 2023-06-27 22:11:55 发布
阅读量442 收藏
点赞数
分类专栏： Spring Cloud实战 文章标签： spring cloud 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y_hanxiong/article/details/127840849
版权

环境版本定稿

  <!-- 统一管理jar包版本 -->
  <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.12</lombok.version>
    <mysql.version>8.0.21</mysql.version>
    <druid.version>1.2.4</druid.version>
    <mybatis.spring.boot.version>2.1.3</mybatis.spring.boot.version>
  </properties>

  <!-- 子模块继承之后，提供作用：锁定版本+子modlue不用写groupId和version  -->
  <dependencyManagement>
    <dependencies>
      <!--spring boot 2.2.2-->
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.3.3.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.SR4</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.2.1.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
      </dependency>
      <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
      </dependency>
      <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>${mybatis.spring.boot.version}</version>
      </dependency>
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
      </dependency>
      <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
      </dependency>
      <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok.version}</version>
        <optional>true</optional>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <fork>true</fork>
          <addResources>true</addResources>
        </configuration>
      </plugin>
    </plugins>
  </build>

1、maven工程复习

dependencyManagement

Maven 使用dependencyManagement 元素来提供了一种管理依赖版本号的方式。通常会在一个组织或者项目的最顶层的父POM 中看到dependencyManagement 元素。

使用pom.xml 中的dependencyManagement 元素能让所有在子项目中引用一个依赖而不用显式的列出版本号。
Maven 会沿着父子层次向上走，直到找到一个拥有dependencyManagement 元素的项目，然后它就会使用这个
dependencyManagement 元素中指定的版本号。

例如：

我们在父项目指定了版本，子项目就可以不用指定版本，直接用父项目的版本

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TziPwLHA-1668385920648)(SpringCloud学习笔记.assets/image-20210413121951227.png)]

这样做的好处就是：如果有多个子项目都引用同一样依赖，则可以避免在每个使用的子项目里都声明一个版本号，

这样当想升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要一个一个子项目的修改 ；另外如果

某个子项目需要另外的一个版本，只需要声明version就可。

  • dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。

  • 如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，
 才会从父项目中继承该项，并且version和scope都读取自父pom;

  • 如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

2、mysql驱动说明

com.mysql.jdbc.Driver和mysql-connector-java 5一起用。

com.mysql.cj.jdbc.Driver和mysql-connector-java 6 一起用。

com.mysql.cj.jdbc.Driver是mysql-connector-java 6 中的特性，相比mysql-connector-java 5 多了一个时区：

serverTimezone，把数据源配置的驱动改一下就好了

org.gjt.mm.mysql.Driver是当时最好的MySQL JDBC，但不是MySQL公司的，然后MySQL将MM的JDBC驱动 收为

官方的JDBC驱动，所以将驱动的package也改了，但还保留了org.gjt.mm.mysql.Driver这个路径的引用，也就

是你使用新版的JDBC驱动时还可以通过这个来引用，打开下载的新版JDBC驱动的jar文件可以看到，只有一个

文件的目录是org.gjt.mm.mysql，就是为了兼容而设计的。

消费者直接调用提供者（案例）

建立一个父工程，父工程新建module

步骤

  1. 建module
  2. 改pom.xml
  3. 写yaml
  4. 主启动
  5. 业务类
    • 建表
    • entities
    • dao
    • service
    • controller
  6. 测试

1、微服务提供者module

1、建module

名字为：xiaobear-provider-payment-8001-1

2、改pom.xml

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

3、写yaml

在rescourse目录下新建application.yml

server:
  port: 8001

spring:
  application:
    name: xiaobear-cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/spring-cloud-xiaobear?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
    username: 用户名
    password: mima

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.xiaobear.entity

4、主启动

在java目录下，新建一个主启动类

package com.xiaobear;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @Author xiaobear
 * @Date 2021/4/6 21:41
 * @Description 主启动类
 * @Version 1.0
 */
@SpringBootApplication
public class Payment8001Application {

    public static void main(String[] args) {
        SpringApplication.run(Payment8001Application.class,args);
    }
}

5、业务类

1、建表
CREATE TABLE `payment` (

  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',

  `serial` varchar(200) DEFAULT '',

  PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8
2、entities
/**
 * (Payment)实体类
 *
 * @author xiaobear
 * @since 2021-04-06 21:52:42
 */
public class Payment implements Serializable {
    private static final long serialVersionUID = -82310885557668418L;
    /**
     * ID
     */
    private Long id;

    private String serial;


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getSerial() {
        return serial;
    }

    public void setSerial(String serial) {
        this.serial = serial;
    }

}
3、dao
@Mapper
public interface PaymentDao {

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    Payment queryById(@Param("id")Long id);

    /**
     * 查询指定行数据
     *
     * @param offset 查询起始位置
     * @param limit  查询条数
     * @return 对象列表
     */
    List<Payment> queryAllByLimit(@Param("offset") int offset, @Param("limit") int limit);


    /**
     * 通过实体作为筛选条件查询
     *
     * @param payment 实例对象
     * @return 对象列表
     */
    List<Payment> queryAll(Payment payment);

    /**
     * 新增数据
     *
     * @param payment 实例对象
     * @return 影响行数
     */
    int insert(Payment payment);

    /**
     * 批量新增数据（MyBatis原生foreach方法）
     *
     * @param entities List<Payment> 实例对象列表
     * @return 影响行数
     */
    int insertBatch(@Param("entities") List<Payment> entities);

    /**
     * 批量新增或按主键更新数据（MyBatis原生foreach方法）
     *
     * @param entities List<Payment> 实例对象列表
     * @return 影响行数
     */
    int insertOrUpdateBatch(@Param("entities") List<Payment> entities);

    /**
     * 修改数据
     *
     * @param payment 实例对象
     * @return 影响行数
     */
    int update(Payment payment);

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 影响行数
     */
    int deleteById(Long id);

}
xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xiaobear.dao.PaymentDao">

    <resultMap type="com.xiaobear.entity.Payment" id="PaymentMap">
        <result property="id" column="id" jdbcType="INTEGER"/>
        <result property="serial" column="serial" jdbcType="VARCHAR"/>
    </resultMap>

    <!--查询单个-->
    <select id="queryById" resultMap="PaymentMap">
        select id,
               serial
        from payment
        where id = #{id}
    </select>

    <!--查询指定行数据-->
    <select id="queryAllByLimit" resultMap="PaymentMap">
        select id,
               serial
        from payment
        limit #{offset}
           , #{limit}
    </select>

    <!--通过实体作为筛选条件查询-->
    <select id="queryAll" resultMap="PaymentMap">
        select
        id, serial
        from payment
        <where>
            <if test="id != null">
                and id = #{id}
            </if>
            <if test="serial != null and serial != ''">
                and serial = #{serial}
            </if>
        </where>
    </select>

    <!--新增所有列-->
    <insert id="insert" keyProperty="id" useGeneratedKeys="true">
        insert into payment(serial)
        values (#{serial})
    </insert>

    <insert id="insertBatch" keyProperty="id" useGeneratedKeys="true">
        insert into payment(serial)
        values
        <foreach collection="entities" item="entity" separator=",">
            (#{entity.serial})
        </foreach>
    </insert>

    <insert id="insertOrUpdateBatch" keyProperty="id" useGeneratedKeys="true">
        insert into payment(serial)
        values
        <foreach collection="entities" item="entity" separator=",">
            (#{entity.serial})
        </foreach>
        on duplicate key update
        serial = values(serial)
    </insert>

    <!--通过主键修改数据-->
    <update id="update">
        update payment
        <set>
            <if test="serial != null and serial != ''">
                serial = #{serial},
            </if>
        </set>
        where id = #{id}
    </update>

    <!--通过主键删除-->
    <delete id="deleteById">
        delete
        from payment
        where id = #{id}
    </delete>

</mapper>
4、service
public interface PaymentService {

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    Payment queryById(Long id);

    /**
     * 查询多条数据
     *
     * @param offset 查询起始位置
     * @param limit  查询条数
     * @return 对象列表
     */
    List<Payment> queryAllByLimit(int offset, int limit);

    /**
     * 新增数据
     *
     * @param payment 实例对象
     * @return 实例对象
     */
    Payment insert(Payment payment);

    /**
     * 修改数据
     *
     * @param payment 实例对象
     * @return 实例对象
     */
    Payment update(Payment payment);

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
    boolean deleteById(Long id);

}
impl
@Service("paymentService")
public class PaymentServiceImpl implements PaymentService {
    @Resource
    private PaymentDao paymentDao;

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    @Override
    public Payment queryById(Long id) {
        return this.paymentDao.queryById(id);
    }

    /**
     * 查询多条数据
     *
     * @param offset 查询起始位置
     * @param limit  查询条数
     * @return 对象列表
     */
    @Override
    public List<Payment> queryAllByLimit(int offset, int limit) {
        return this.paymentDao.queryAllByLimit(offset, limit);
    }

    /**
     * 新增数据
     *
     * @param payment 实例对象
     * @return 实例对象
     */
    @Override
    public Payment insert(Payment payment) {
        this.paymentDao.insert(payment);
        return payment;
    }

    /**
     * 修改数据
     *
     * @param payment 实例对象
     * @return 实例对象
     */
    @Override
    public Payment update(Payment payment) {
        this.paymentDao.update(payment);
        return this.queryById(payment.getId());
    }

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
    @Override
    public boolean deleteById(Long id) {
        return this.paymentDao.deleteById(id) > 0;
    }
}
5、controller
@RestController
@RequestMapping("payment")
@Slf4j
public class PaymentController {
    /**
     * 服务对象
     */
    @Resource
    private PaymentService paymentService;

    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @GetMapping("/selectOne/{id}")
    public Payment selectOne(@PathVariable("id")Long id) {
        return this.paymentService.queryById(id);
    }


    @PostMapping("/insert")
    public CommonResult createPayment(@RequestBody Payment payment){
        Payment insert = paymentService.insert(payment);
        log.info("插入成功！");
        if (null != insert){
            return new CommonResult(200,"插入数据库成功！",insert);
        }else {
            return new CommonResult(500,"插入数据库失败！",null);
        }
    }
}

这里采用的是通用返回CommonResult

/**
 * @Author xiaobear
 * @Date 2021/4/10 20:39
 * @Description 通用返回类型
 * @Version 1.0
 */
public class CommonResult<T>{

    private Integer code;
    private String message;
    private T data;

    public CommonResult()
    {
    }

    public CommonResult(Integer code, String message, T data)
    {
        this.code = code;
        this.message = message;
        this.data = data;
    }
    public CommonResult( Integer code,String message) {
        this( code, message,null);
    }

    public CommonResult(T data) {
        this(200, "操作成功", data);
    }

    //setter--getter
    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

}

6、测试

2、微服务消费者module

1、建module

xiaobear-consumer-order80-2

2、改pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>SpringCloud-xiaobear</artifactId>
        <groupId>com.xiaobear</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>xiaobear-consumer-order80-2</artifactId>

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

  <!--      <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

3、写yaml

server:
  port: 80

4、主启动

@SpringBootApplication
public class Order80Application {

    public static void main(String[] args) {
        SpringApplication.run(Order80Application.class,args);
    }
}

5、业务类

把消费者的entities以及通用返回类型复制即可

在这里插入图片描述

1、RestTemplate

RestTemplate提供了多种便捷访问远程Http服务的方法，

是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集

https://docs.spring.io/spring-framework/docs/5.3.x/javadoc-api/org/springframework/web/client/RestTemplate.html

使用

使用restTemplate访问restful接口非常的简单粗暴无脑。

(url, requestMap, ResponseBean.class)这三个参数分别代表

REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。

2、config配置类
/**
 * @Author xiaobear
 * @Date 2021/4/11 16:23
 * @Description RestTemplate配置类
 * @Version 1.0
 */
@Configuration
public class ApplicationContextConfig {

    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}
3、controller
@RestController
@Slf4j
public class OrderController {

    private static final String PAYMENT_URL = "http://localhost:8001";

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("/consumer/payment/insert")
    public CommonResult<Payment> create(Payment payment){
        return restTemplate.postForObject(PAYMENT_URL+"/payment/insert",payment,CommonResult.class);
    }

    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable Long id){
        return restTemplate.getForObject(PAYMENT_URL + "/payment/selectOne/"+id,CommonResult.class, id);
    }
}

注意：两个服务需同时启动

3、问题

两个module都存在entities，而且两个实体类都是相同的，这时候我们可以工程重构

4、工程重构

新建一个module --名字为common-api

1、修改pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>SpringCloud-xiaobear</artifactId>
        <groupId>com.xiaobear</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>xiaobear-common-api-3</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.1.0</version>
        </dependency>
    </dependencies>

</project>
2、entities

放入实体类payment和CommonResult

3、对通用module进行clean install
4、分别对前面两个module进行改造
1、删除原来的entities目录
2、粘贴pom的内容
        <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
            <groupId>com.xiaobear</groupId>
            <artifactId>xiaobear-common-api-3</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
小熊学Java
关注
专栏目录
spring-cloud(一)生产者&消费者案例
weixin_44523741的博客
08-01 1034
spring-cloud工程间的调用底层采用http协议 依赖的引入这里就不贴了，cloud版本更新的很快，我使用的是2.0.7版本 生产者&消费者案例 一、基于rest实现 ​ 基于rest实现本质上是通过url来直接指向某个服务，并没有通过Eureka注册中心，所以无需Eureka的配置，这个案例还是加上了，以为要便于下个案例的演示。 生产者 生产者注册服务到 Eureka ①...
springCloud - 第4篇 - 消费者调用服务 ( Feign )
愿我如星君如月 ... 夜夜流光相皎洁 ...
07-23 772
一、新建 ribbon 工程： 1. file - new - module 2. spring Initializr - module SDK 选择自己的 JDK ，其余的可以不用填写，next。 3. 填写工程相关信息：包名、工程名等，next。 4. spring cloud discovery - 勾选 eureka discover client，next。 ...
SpringCloud中的服务调用组件
ljbnb的博客
07-06 596
SpringCloud中的服务调用
【仅是入门用】SpringCloud-ribbon 消费者调用生产者
小哇
03-09 573
Ribbon 就是在HttpClient 上做了一层包装，支持负载均衡，如果Producer(生产者)有多个，则消息者 (Consumer)ribbon 可以根据策略选择其中一个Producer(生产者) 其中核心的 @LoadBalanced负载均衡的原理步骤 1 首先从注册中心获取provider的列表 2 通过一定的策略选择其中一个节点 ...
springcloud-消费者调用服务者
林森木木的博客
04-27 825
在上篇博文中，我们已经通过阿里的脚手架创建了注册中心与服务者，本篇博文我们将介绍在消费者工程中请求服务者。 首先我们来创建一个消费者，消费者的创建方式与服务者一致，这里不再多做赘述。（小伙伴们可以参考上篇博文消费者的创建） 为了做到演示效果，我们首先在服务者工程中创建一个controller,代码如下： package com.example.server; import org.apac...
springcloud生产者与消费者项目实战案例
最新发布
09-18
在本实战案例中，我们将深入探讨SpringCloud框架的使用，特别是其核心组件在构建微服务架构中的作用。SpringCloud作为一款强大的微服务解决方案，它集成了众多子项目，包括服务发现、负载均衡、断路器、配置中心等，...
spring cloud 实战教程
01-31
接着，会介绍Spring Cloud的核心组件——Eureka，它是服务注册与发现的实现，让服务提供者和服务消费者能够自动发现彼此。通过实例，读者可以学习到如何创建和注册服务，以及如何实现服务调用。 Spring Cloud ...
spring cloud eureka微服务之——服务注册发现、服务消费者，服务提供者简单实例
11-29
在Spring Cloud项目中，pom.xml会包含Spring Cloud的父POM，以及Eureka Server、服务提供者和服务消费者所需的依赖，如`spring-cloud-starter-netflix-eureka-client`、`spring-cloud-starter-netflix-eureka-server...
SpringCloud消费者服务提供者
10-14
`springcloud-consumer-dept-80`可能是服务消费者模块，它负责调用服务提供者的接口。这个模块通常会包含使用Feign或Ribbon实现的客户端代码，通过服务名（如`dept`）查找服务提供者，并发起HTTP请求。其中的数字`80...
springcloud feign 服务消费者 类似 webservice
02-20
在Spring Cloud的环境中，Feign会自动发现服务提供者的位置（通过Eureka、Consul等服务注册与发现组件），并创建一个代理对象来执行这些方法，实现了透明化的远程调用。 除了基本的HTTP请求，Feign还支持更多的特性...
SpringCloud 消费者和提供者
qq_34429554的博客
10-15 973
SpringCloud 消费者和提供者 ​ sprincloud是基于微服务架构思想的框架，它提供了多种组件来解决微服务带来的的一些列问题，因此可以把它看做是一个生态，在微服务架构中，每一个微服务都是一个小的项目，服务之间必然存在接口调用，通常把接口提供方 称为为提供者，接口调用方称为消费者。 1.创建一个微服务提供者 对应代码如下 @RestController public class DeptController { @Autowired DeptService deptServi
SpringCloud之服务消费者使用RestTemplate调用服务接口即负载均衡
kxj19980524的博客
02-08 1592
 SpringCloud之搭建eureka注册中心https://blog.csdn.net/kxj19980524/article/details/86775500 SpringCloud之搭建服务提供者https://blog.csdn.net/kxj19980524/article/details/86775875 &lt;?xml version="1.0" encoding="UT...
SpringCloud学习(二)--消费者微服务对生产者微服务的调用
ShangHai0123的博客
08-19 2076
在已搭建好的微服务项目中创建一个provider微服务作为生产者和一个consumer微服务作为消费者. 创建生产者微服务 第一步, 在已搭建好的微服务Maven项目上,新建一个Springboot项目作为生产者微服务(provider) 步骤如下图: 1.在springcloud-demo上,右键选择"New"--"Module" 2.选择"Spring Initializr"选项,即创建Springboot项目 3.输出自己心仪的项目名称 4.在依赖选择内,选中...
spring cloud开发 消费者和服务提供者
bring_coco的博客
06-27 355
这里消费者是不需要service层，消费者通过url去请求，比如http://127.0.0.1:8001/dept/list这个url，但是这个url是在我们之前提供者模块的，那么我们怎么拿到这个url？可以看到跳到了，主项目的pom.xml，说明主项目的pom.xml是用了管理依赖的，再看看右侧maven，发现右边写进去的依赖并没有导入，真正使用还需要在子模块中pom.xml配置。可以看到我们配置了子模块，不用写版本号，因为父依赖中已经有了版本号，如果父依赖中没有，就需要单独写进去。
SpringCloud 远程消费（ Feign 远程调用&& DTO 层的构建）
m0_58525944的博客
02-14 1549
前言：继上一篇博客的基础上在进行的编码 SpringCloud 的基本使用 nacos SpringCloud 基本使用与 nacos_m0_58525944的博客-CSDN博客 一，Feign 远程调用消费者（consumer）生产者（provider） 1，定义远程调用接口 在生产者 建立pojo软件包，新建User实体类 package com.provider.nacos_provider.pojo; import lombok.AllArgsConstructor; ...
springcloud入门(一)之基本概念、服务提供者及消费者
指尖上的革新
12-16 1410
1 springcloud入门概述 1.1 什么是springcloud springcloud官网 springcloud,基于springboot提供了一套微服务解决方案，包括服务注册与发现，配置中心，全链路监控，服务网关，负载均衡，熔断器等组件； 除了基于Netflix的开源组件做高度抽象封装之外，还有一些选型中立的开源组件。 sprincloud利用springboot的开发便利性，巧妙地简化了分布式系统基础设施的开发，springcloud为开发人员提供了快速构建分布式的一些列工具， 包括配置
springcloud - 提供者-消费者
空中烟花
06-15 929
一、创建服务提供者 1、
SpringCloud——消费者订单模块及服务间调用
辰小白
08-16 576
模块名：cloud-consumer-order80 这里模拟用户端下订单，所以服务端口直接80 步骤和支付模块一样 建module 改pom 写yml 主启动 业务类 代码： 一、建module 这里忽略、参考前面支付模块的建立 二、改pom pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns
SpringCloud 三种服务调用方式，你学会了吗？
知识分享官
09-04 776
搭建服务测试环境测试中，服务发现层采用Netflix的Eureka搭建。主要步骤如下：1.引入Eureka所需依赖<!--eureka服务端-->&nbsp;&nbsp;<dependency>&nbsp;&nbsp;&nbsp;&nbsp;<groupId>org.springframework.cloud</groupId>&nbsp;&nbsp;&nbsp;&nbsp;&lt
SpringCloud服务提供者provider创建教程
"本文将详细介绍如何在SpringCloud中创建一个服务提供者(provider)。首先回顾一下之前关于Eureka注册中心的使用，然后我们将进入服务提供者的核心步骤。通过创建名为`provider-demo`的子模块，我们导入必要的Spring ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小熊学Java

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

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

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

打赏作者

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

抵扣说明：

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

余额充值