SpringCloud Alibaba入门4之nacos注册中心和使用OpenFegin调用服务

我们继续在上一章的基础上进行开发。

https://blog.51cto.com/u_13312531/6541533

一、概念

什么是注册中心?

注册中心记录了服务和服务地址的映射关系。在分布式架构中，服务会注册到这里，当服务需要调用其它服务时，就到这里找到服务的地址，进行调用。注册中心的作用就是服务的注册和服务的发现。

二、引入Nacos作为注册中心

我们查看SpringBoot和SpringCloudAlibab的版本匹配，使用合适的版本开发。

版本说明

1.在父项目pom.xml中添加Nacos所需的依赖：

<!--cloud-->
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-dependencies</artifactId>
	<version>Hoxton.RELEASE</version>
	<type>pom</type>
<scope>import</scope>
</dependency>
<!--alibaba-->
<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-alibaba-dependencies</artifactId>
	<version>2.2.0.RELEASE</version>
	<type>pom</type>
	<scope>import</scope>
</dependency>

完整的pom文件如下所示:

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>mymall</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--设置为pom,管理依赖-->
    <packaging>pom</packaging>
    <modules>
        <module>mymall-common</module>
        <module>mymall-goods</module>
        <module>mymall-order</module>
        <module>mymall-pay</module>
        <module>mymall-stock</module>
        <module>mymall-user</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <!--统一管理项目依赖版本-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.6.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--cloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--alibaba-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.2.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

2.在子模块引入Nacos

我们先在user子模块中进行引入

<!--cloud相关依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>0.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.nacos</groupId>
            <artifactId>nacos-client</artifactId>
        </dependency>

user子模块完整的pom文件如下所示:

<?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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.example</groupId>
        <artifactId>mymall</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>mymall-user</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>mymall-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--cloud相关依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>0.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.nacos</groupId>
            <artifactId>nacos-client</artifactId>
        </dependency>
    </dependencies>
</project>

3.服务注册

在user子模块的启动类上添加@EnableDiscoveryClient注解开启服务注册发现功能 。

package com.example.mymall;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

/**
 * @author qx
 * @date 2023/06/25
 * @desc 用户模块启动类
 */
@SpringBootApplication
// 开启服务注册发现
@EnableDiscoveryClient
public class MyMallUserApplication {

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

4.修改配置文件

在配置文件application.yml中添加服务名称和Nacos Server地址

5.启动user子模块和nacos服务。

启动成功后，我们通过nacos的控制台查看，服务列表里面发现我们的服务已经注册到了Nacos Server中。

6.添加其他子模块到Nacos服务

我们按照上一个的操作方式把其他子模块的服务依次添加到Nacos的服务列表中。注意修改一下每个子模块的端口号，不要重复。

添加完成之后的截图如下:

三、OpenFeign的使用

1.概念

Feign是一种声明式、模板化的HTTP客户端。使用Feign，可以做到声明式调用。Feign是在RestTemplate和Ribbon的基础上进一步封装，使用RestTemplate实现Http调用，使用Ribbon实现负载均衡。

2.引入依赖

我们当前实现一个功能就是添加商品的时候，添加相应的库存数量到库存模块，因为这两个模块是独立的，所以需要在添加商品的时候使用Feign调用库存的服务接口来实现我们的功能。

在商品模块(goods)中添加OpenFeign的依赖:

  <!--OpenFeign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

商品模块完整的pom文件如下:

<?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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.example</groupId>
        <artifactId>mymall</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>mymall-goods</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>mymall-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--cloud相关依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>0.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.nacos</groupId>
            <artifactId>nacos-client</artifactId>
        </dependency>
        <!--OpenFeign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
    </dependencies>
</project>

3.在common模块创建实体类

在common模块通过JPA创建商品和库存的实体类。

示例代码如下:

Goods.java

package com.example.mymall.entity;

import lombok.Data;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;
import org.hibernate.annotations.UpdateTimestamp;

import javax.persistence.*;
import java.util.Date;

/**
 * @author qx
 * @date 2023/06/25
 * @desc 商品实体
 */
@Entity
@Table(name = "t_goods")
@DynamicUpdate
@DynamicInsert
@Data
public class Goods {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    /**
     * 商品名称
     */
    private String goodsName;

    /**
     * 价格
     */
    private Double price;


    /**
     * 商品介绍
     */
    private String description;

    /**
     * 创建时间
     */
    @CreationTimestamp
    private Date createTime;

    /**
     * 更新时间
     */
    @UpdateTimestamp
    private Date updateTime;


    /**
     * 状态 0：正常 1：禁用
     */
    @Column(columnDefinition = "tinyint(1) default 0 comment '状态'")
    private Integer status;


    /**
     * 临时存储库存数量 不保存到数据库
     */
    @Transient
    private Integer inventory;

}

Stock.java

package com.example.mymall.entity;

import lombok.Data;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;
import org.hibernate.annotations.UpdateTimestamp;

import javax.persistence.*;
import java.util.Date;

/**
 * @author qx
 * @date 2023/06/25
 * @desc 库存实体
 */
@Entity
@Table(name = "t_stock")
@DynamicInsert
@DynamicUpdate
@Data
public class Stock {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    /**
     * 商品ID
     */
    private Long goodsId;

    /**
     * 库存量
     */
    private Integer inventory;

    /**
     * 创建时间
     */
    @CreationTimestamp
    private Date createTime;

    /**
     * 更新时间
     */
    @UpdateTimestamp
    private Date updateTime;

}

4.库存模块开发

数据层:StockRepository.java

package com.example.mymall.repository;

import com.example.mymall.entity.Stock;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * 库存模块数据层
 */
public interface StockRepository extends JpaRepository<Stock, Long> {

    Stock findByGoodsId(Long goodsId);
}

服务层:StockService.java

package com.example.mymall.service;

import com.example.mymall.entity.Stock;
import com.example.mymall.repository.StockRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author qx
 * @date 2023/06/25
 * @desc 库存服务层
 */
@Service
public class StockService {

    @Autowired
    private StockRepository stockRepository;

    /**
     * 添加库存，返回主键
     *
     * @param stock 库存对象
     * @return 主键值
     */
    public Long addStock(Stock stock) {
        stockRepository.save(stock);
        return stock.getId();
    }

    /**
     * 根据商品ID获取商品库存数量
     *
     * @param goodsId 商品ID
     * @return 库存数量
     */
    public Integer getInventoryById(Long goodsId) {
        Stock stock = stockRepository.findByGoodsId(goodsId);
        return stock.getInventory();
    }

}

控制层:StockController.java

package com.example.mymall.controller;

import com.example.mymall.entity.Stock;
import com.example.mymall.service.StockService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author qx
 * @date 2023/06/25
 * @desc 库存控制层
 */
@RestController
@RequestMapping("/stock")
public class StockController {

    @Autowired
    private StockService stockService;

    /**
     * 添加库存
     *
     * @param stock 库存请求
     */
    @PostMapping("/add")
    public Long addStock(@RequestBody Stock stock) {
        return stockService.addStock(stock);
    }

    /**
     * 根据商品ID获取库存数量
     *
     * @param goodsId 商品ID
     * @return 库存数量
     */
    @GetMapping("/getinventory/{goodsId}")
    public Integer getInventoryByGoodsId(@PathVariable Long goodsId) {
        return stockService.getInventoryById(goodsId);
    }
}

5.商品模块开发

数据层:GoodsRepository.java

package com.example.mymall.repository;

import com.example.mymall.entity.Goods;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * 商品模块数据层
 */
public interface GoodsRepository extends JpaRepository<Goods, Long> {
}

商品服务远程调用库存服务的Feign客户端配置

StockClientFeign.java

package com.example.mymall.feign;

import com.example.mymall.entity.Stock;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

/**
 * @author qx
 * @date 2023/06/25
 * @desc 库存服务feign客户端
 */
@FeignClient(value = "stock-service")
public interface StockClientFeign {

    /**
     * 调用添加库存的接口
     */
    @PostMapping("/stock/add")
    Long addStock(@RequestBody Stock stock);


    /**
     * 调用根据商品ID获取库存量接口
     *
     * @param goodsId 商品ID
     * @return 库存数量
     */
    @GetMapping("/stock/getinventory/{goodsId}")
    Integer getInventoryByGoodsId(@PathVariable("goodsId") Long goodsId);

}

在启动类上加上注解@EnableFeignClientgs扫描Feign客户端

package com.example.mymall;

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

/**
 * @author qx
 * @date 2023/06/25
 * @desc 商品模块启动类
 */
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients(basePackages = "com.example.mymall")
public class MyMallGoodsApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyMallGoodsApplication.class, args);
    }
}

商品服务层: GoodsService.java

package com.example.mymall.service;

import com.example.mymall.common.CommonResult;
import com.example.mymall.entity.Goods;
import com.example.mymall.entity.Stock;
import com.example.mymall.feign.StockClientFeign;
import com.example.mymall.repository.GoodsRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author qx
 * @date 2023/06/25
 * @desc 商品服务层
 */
@Service
public class GoodsService {

    @Autowired
    private StockClientFeign stockClientFeign;

    @Autowired
    private GoodsRepository goodsRepository;

    /**
     * 添加商品
     *
     * @param goods 商品对象
     */
    public CommonResult addGoods(Goods goods) {
        goodsRepository.save(goods);

        // 保存到商品库存表
        Stock stock = new Stock();
        stock.setGoodsId(goods.getId());
        stock.setInventory(goods.getInventory());
        stockClientFeign.addStock(stock);
        return CommonResult.success();
    }

    /**
     * 根据ID获取商品数据
     *
     * @param goodsId 商品ID
     * @return 商品数据包含库存数量
     */
    public CommonResult getGoodsById(Long goodsId) {
        Goods goods = goodsRepository.findById(goodsId).orElse(null);
        if (goods != null) {
            goods.setInventory(stockClientFeign.getInventoryByGoodsId(goodsId));
            return CommonResult.success(goods);
        }
        return CommonResult.fail("数据不存在");
    }
}

商品控制层: GoodsController.java

package com.example.mymall.controller;

import com.example.mymall.common.CommonResult;
import com.example.mymall.entity.Goods;
import com.example.mymall.service.GoodsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author qx
 * @date 2023/06/25
 * @desc 商品控制层
 */
@RestController
@RequestMapping("/goods")
public class GoodsController {

    @Autowired
    private GoodsService goodsService;


    /**
     * 添加商品
     *
     * @param goods 商品请求实体
     * @return
     */
    @PostMapping("/add")
    public CommonResult addGoods(@RequestBody Goods goods) {
        return goodsService.addGoods(goods);
    }


    /**
     * 根据ID获取商品
     *
     * @param id 商品ID
     * @return 商品
     */
    @GetMapping("/{id}")
    public CommonResult getGoodsById(@PathVariable Long id) {
        return goodsService.getGoodsById(id);
    }
}

最后的完成的项目结果如下所示:

四、OpenFeign测试

我们分别启动商品模块和库存模块，分别注册到nacos。

我们查看商品和库存的数据表，都没有数据

我们使用Postman进行接口的测试

我们测试新增商品的接口，同时调用了添加库存的方法，我们需要的结果是商品添加成功，并且库存也添加成功。

我们刷新数据表t_goods和t_stock

发现这两个数据表都添加成功了我们传入的数据。完成了通过Feign实现各自模块的服务之间的调用。

最后我们测试查询接口也是返回了我们需要的结果，把库存表的数据和商品信息一起返回了。

、