nacos从安装部署到生产实现（基于SpringCloud）

已于 2022-10-16 17:58:34 修改
阅读量689 收藏 1
点赞数
文章标签： spring cloud java
于 2022-10-16 12:07:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61603262/article/details/127345851
版权

nacos:从安装部署到生产实现（基于SpringCloud）

文章目录

前言：为什么要学nacos

一句话概括：因为好用，因为旧的（Eureka+Config）将来可能没得用。

众所周知，由于网飞的奇妙自信，Eureka闭源、Hystrix等一系列工具停更，使得入手nacos、sentinel等更新更强大的工具有了更充分的理由。

nacos（Naming and Configuration Service）的功能相当丰富，分：服务发现和服务健康监测、动态配置服务、动态DNS服务、服务及其元数据管理四部分，这里我们先从前两（三）个功能开始。
nacos和Eureka不同，配置一开始就很少侵入性，注册中心是直接独立出来的——从开发阶段独立调试到后期独立部署，这一点对Eureka重度使用者可能是全新的体验。也因为这个原因，nacos需要独立下载而不是单纯引入依赖，独立下载的nacos也提供了一套网页GUI供使用。

一句话概括就是，突然舒适到不太适应。

与其说是从0开始，不如说是技术栈从网飞向阿里的迁移，从这边的0.1向那边的0迁移。

本文标题其实改了好多次，一直找不到恰当的概括，按照学术论文的命名方案又显得雷声大雨点小，想了想还是以半教程半学习笔记的方式贴出罢。项目源码托管在gitee，地址见文末。

常用本地dashboard地址：

nacos:http://169.254.67.104:8848/nacos/index.html

（端口可自定义，需要注意的是nacos的服务地址在127.0.0.1，而dashboard并不在localhost。用户名密码默认都是nacos）

swagger:http://localhost:{服务端口}/swagger-ui/index.html

Druid:http://localhost:{服务端口}/{项目名}/druid/login.html

0.环境搭建

如上文所说，nacos本身也是一个springcloud项目，想要使用是需要直接下载的。下面提供两种下载途径

  • nacos官方GitHub页面：https://github.com/alibaba/nacos

  • 大陆分流：

    SSH:git@gitee.com:mirrors/Nacos.git

    http:https://gitee.com/mirrors/Nacos.git

关于springboot、springcloud、springcloud alibaba三者版本对应关系，可参照下文，或查阅官方文档：

版本说明 · alibaba/spring-cloud-alibaba Wiki · GitHub

0.1Spring Cloud Alibaba组件版本对应关系

Spring Cloud Alibaba VersionSentinel VersionNacos VersionRocketMQ VersionDubbo VersionSeata Version
2.2.7.RELEASE*1.8.12.0.34.6.12.7.131.3.0
2.2.6.RELEASE1.8.11.4.24.4.02.7.81.3.0
2021.1 or 2.2.5.RELEASE or 2.1.4.RELEASE or 2.0.4.RELEASE1.8.01.4.14.4.02.7.81.3.0
2.2.3.RELEASE or 2.1.3.RELEASE or 2.0.3.RELEASE1.8.01.3.34.4.02.7.81.3.0
2.2.1.RELEASE or 2.1.2.RELEASE or 2.0.2.RELEASE1.7.11.2.14.4.02.7.61.2.0
2.2.0.RELEASE1.7.11.1.44.4.02.7.4.11.0.0
2.1.1.RELEASE or 2.0.1.RELEASE or 1.5.1.RELEASE1.7.01.1.44.4.02.7.30.9.0
2.1.0.RELEASE or 2.0.0.RELEASE or 1.5.0.RELEASE1.6.31.1.14.4.02.7.30.7.1

0.2毕业版本依赖关系(推荐使用)

下表为按时间顺序发布的 Spring Cloud Alibaba 以及对应的适配 Spring Cloud 和 Spring Boot 版本关系（由于 Spring Cloud 版本命名有调整，所以对应的 Spring Cloud Alibaba 版本号也做了对应变化）

Spring Cloud Alibaba VersionSpring Cloud VersionSpring Boot Version
2.2.7.RELEASESpring Cloud Hoxton.SR122.3.12.RELEASE
2021.1 （项目源码fhadmin.cn）Spring Cloud 2020.0.12.4.2
2.2.6.RELEASESpring Cloud Hoxton.SR92.3.2.RELEASE
2.1.4.RELEASESpring Cloud Greenwich.SR62.1.13.RELEASE
2.2.1.RELEASESpring Cloud Hoxton.SR32.2.5.RELEASE
2.2.0.RELEASESpring Cloud Hoxton.RELEASE2.2.X.RELEASE
2.1.2.RELEASESpring Cloud Greenwich2.1.X.RELEASE
2.0.4.RELEASE(停止维护，建议升级)Spring Cloud Finchley2.0.X.RELEASE
1.5.1.RELEASE(停止维护，建议升级)Spring Cloud Edgware1.5.X.RELEASE

依赖管理

Spring Cloud Alibaba BOM 包含了它所使用的所有依赖的版本。

RELEASE 版本

Spring Cloud 2020

如果需要使用 Spring Cloud 2020 版本，请在 dependencyManagement 中添加如下内容

<dependency>

   <groupId>com.alibaba.cloud</groupId>

   <artifactId>spring-cloud-alibaba-dependencies</artifactId>

   <version>2021.1</version>

   <type>pom</type>

   <scope>import</scope>

</dependency>

Spring Cloud Hoxton

如果需要使用 Spring Cloud Hoxton 版本，请在 dependencyManagement 中添加如下内容

<dependency>

   <groupId>com.alibaba.cloud</groupId>

   <artifactId>spring-cloud-alibaba-dependencies</artifactId>

   <version>2.2.7.RELEASE</version>

   <type>pom</type>

   <scope>import</scope>

</dependency>

Spring Cloud Greenwich

如果需要使用 Spring Cloud Greenwich 版本，请在 dependencyManagement 中添加如下内容

<dependency>

   <groupId>com.alibaba.cloud</groupId>

   <artifactId>spring-cloud-alibaba-dependencies</artifactId>

   <version>2.1.4.RELEASE</version>

   <type>pom</type>

   <scope>import</scope>

</dependency>

Spring Cloud Finchley

如果需要使用 Spring Cloud Finchley 版本，请在 dependencyManagement 中添加如下内容

<dependency>

   <groupId>com.alibaba.cloud</groupId>

   <artifactId>spring-cloud-alibaba-dependencies</artifactId>

   <version>2.0.4.RELEASE</version>

   <type>pom</type>

   <scope>import</scope>

</dependency>

孵化器版本依赖关系(不推荐使用)

Spring Cloud VersionSpring Cloud Alibaba VersionSpring Boot Version
Spring Cloud Greenwich0.9.0.RELEASE2.1.X.RELEASE
Spring Cloud Finchley0.2.X.RELEASE2.0.X.RELEASE
Spring Cloud Edgware0.1.X.RELEASE1.5.X.RELEASE

1.nacos初步配置

下载上方提供的源码（个人推荐GitHub版，更新更及时），解压后丢到环境目录，启动前注意配置好java路径变量。

nacos本地默认访问路径：http://127.0.0.1:8848/nacos

用户名：nacos

密码：nacos

在bin目录下启动，命令为：

Linux/Unix/Mac

启动命令(standalone代表着单机模式运行，非集群模式):

sh startup.sh -m standalone

如果使用的是ubuntu系统，或者运行脚本报错提示[[符号找不到，可尝试如下运行：

bash startup.sh -m standalone

Windows

启动命令(standalone代表着单机模式运行，非集群模式):

startup.cmd -m standalone

登入，验证部署成功。后面也可以修改startup.cmd，把"cluster"改成"standalone"，即可满足不带参直接单机模式启动。

2.动态配置（Nacos Config）

2.0项目建立

父项目依赖如下

（加入了lombok、dev-tools、springdoc等辅助开发）

<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>com.zjy</groupId>
    <artifactId>sys</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <name>sys</name>
    <url>http://maven.apache.org</url>
    <modules>
        <module>DataProvider8000</module>
    </modules>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
        <spring-cloud-alibaba.version>2.2.2.RELEASE</spring-cloud-alibaba.version>

        <mybatis.version>2.1.4</mybatis.version>
        <springdoc.version>1.6.11</springdoc.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-sentinel-datasource</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springdoc/springdoc-openapi-ui -->
            <dependency>
                <groupId>org.springdoc</groupId>
                <artifactId>springdoc-openapi-ui</artifactId>
                <version>${springdoc.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>com.zjy.dataprovider8000.DataProvider8000Application</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

2.1依赖导入

由于spring-cloud-alibaba-dependencies内置的nacos最高只支持到0.8.0，实际建议自己导入官网推荐的版本，这里笔者实际选用了2.0.3.RELEASE。

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

2.2环境测试

那么，先写一个helloworld好了：

package com.zjy.dataprovider8000.controller;


import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;


@Tag(name = "测试用例")
@RestController
@RefreshScope
public class TestController {


    @Value(value="${my.name:goodBye}")
    private String value;
    @Operation(summary = "测试配置读取")
    @GetMapping("/test")
    public String test(){



        return value;
    }


}

bootstrap.yaml(这里要注意的是，必须引入SpringCloud的bootstrap依赖，否则不会识别)

spring:
  application:
    name: dataProvider8000
    #名字很重要，nacos要根据名字来找到对应的配置文件
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: properties
        #从源代码可以看到，这一项默认就是properties，现版本仅支持properties和yaml
        group: DEFAULT_GROUP
        #默认分组就是DEFAULT_GROUP
        username: nacos
        password: nacos
server:
  port: 8000

在nacos的dashboard添加如下配置，注意：Data ID需要带应用名后缀！

Data ID:
dataProvider8000.properties
 
Group:
DEFAULT_GROUP

配置内容：
my.name=helloworld

运行项目，直接访问或通过swagger后台测试，得到输出

helloworld

如果刻意将配置的key修改成my.name1，则访问时输出：

goodBye

此时未取到值，上面设置的缺省值发挥了作用

如果将配置的value修改成seeYou，无需重启项目，直接访问，得到输出：

seeYou

说明@RefreshScope的即时刷新功能发挥了作用

附：Data ID命名规范
${prefix}-${spring.profiles.active}.${file-extension}
  • prefix 默认为 spring.application.name 的值，也可以通过配置项 spring.cloud.nacos.config.prefix来配置。
  • spring.profiles.active 即为当前环境对应的 profile，详情可以参考 Spring Boot文档。 注意：当 spring.profiles.active 为空时，对应的连接符 - 也将不存在，dataId 的拼接格式变成 ${prefix}.${file-extension}
  • file-exetension 为配置内容的数据格式，可以通过配置项 spring.cloud.nacos.config.file-extension 来配置。目前只支持 properties 和 yaml 类型。

2.3生产环境测试

​ 这一点官方文档好像并没有提及，实际上在bootstrap.yaml里面可以用${}表达式直接拉取到nacos端的配置（类加载在nacos登录之前完成的不能拉取，如mybatis.mapper-locations,否则报错）。

搭建一个较真实的服务提供者

DATAPROVIDER8000
├─.mvn
│ └─wrapper
└─src
└─main
├─java
│ └─com
│ └─zjy
│ └─dataprovider8000
│ ├─config
│ ├─controller
│ ├─mapper
│ └─service
└─resources
├─mybatis
│ └─mapper
├─static
└─templates

其中三层架构：

Mapper
<?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.zjy.dataprovider8000.mapper.DepartmentMapper">

    <select id="getDepartmentList" resultType="com.zjy.pojo.Department" useCache="true">
        select * from `myemployees`.`departments`;
    </select>
    <select id="getDepartmentById" resultType="com.zjy.pojo.Department" >
        select * from myemployees.departments where `department_id`=#{departmentId};
    </select>
    <select id="getDepartmentByName" resultType="com.zjy.pojo.Department" >
        select * from myemployees.departments where `department_name`=#{departmentName};
    </select>
    <insert id="insert">
        insert into myemployees.departments
        values (#{departmentId},#{departmentName},#{managerId},#{locationId});
    </insert>
    <delete id="deleteDepartmentById">
        delete *from myemployees.departments where `department_id`=#{departmentId};
    </delete>
    <update id="update">
        update `departments`
        set `department_name`=#{departmentName},`manager_id`=#{managerId},`location_id`=#{locationId})
        WHERE `department_id`=#{departmentId};
    </update>
</mapper>

package com.zjy.dataprovider8000.mapper;


import com.zjy.pojo.Department;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
@Repository
public interface DepartmentMapper {
    List<Department> getDepartmentList();
    Department getDepartmentById(Integer departmentId);

    List<Department> getDepartmentByName(String departmentName);
    void insert(Department department);
    void deleteDepartmentById(Integer departmentId);
    void update(Department department);
}
Service
package com.zjy.dataprovider8000.service;



import com.zjy.dataprovider8000.mapper.DepartmentMapper;
import com.zjy.pojo.Department;
import org.springframework.stereotype.Service;

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

@Service
public class DepartmentService {
    @Resource
    private DepartmentMapper departmentMapper;

    public List<Department> getDepartmentList(){
        System.err.println("Service：getDepartmentList...");
        return departmentMapper.getDepartmentList();
    }
    public Department getDepartmentById(Integer departmentId){
        return departmentMapper.getDepartmentById(departmentId);
    }
    public List<Department> getDepartmentByName(String departmentName){
        return departmentMapper.getDepartmentByName(departmentName);
    }
    public void insert(Department department){
         departmentMapper.insert(department);
    }
    public void deleteDepartmentById(Integer departmentId){
        departmentMapper.deleteDepartmentById(departmentId);
    }
    public void update(Department department){
        departmentMapper.update(department);
    }
}
Controller
package com.zjy.dataprovider8000.controller;


import com.zjy.dataprovider8000.service.DepartmentService;
import com.zjy.pojo.Department;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;



@RestController
@Tag(name="部门")
@RequestMapping("/dept")
public class DepartmentController {
    @Resource
    DepartmentService departmentService;


    @Operation(summary = "获取部门列表")
    @GetMapping("/list")
    public List<Department> getAll(){
        return departmentService.getDepartmentList();
    }

    @Operation(summary = "通过id查找部门")
    @GetMapping("/query/id/{departmentId}")
    public Department queryById(@PathVariable Integer departmentId){
        return departmentService.getDepartmentById(departmentId);
    }
    @Operation(summary = "通过名称查找部门")
    @GetMapping("/query/name/{departmentName}")
    public List<Department> queryByName(@PathVariable String departmentName){
        return departmentService.getDepartmentByName(departmentName);
    }
}
数据库结构

myemployees.departments

Field Type Null Key Default Extra

department_id int NO PRI (NULL) auto_increment
department_name varchar(3) YES (NULL)
manager_id int YES (NULL)
location_id int YES MUL (NULL)

nacos端配置文件
mybatis:
  type-aliases-package: com.zjy.pojo
  configuration:
    map-underscore-to-camel-case: true
  mapper-locations: classpath:mappers/*.xml
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306?useUnicode=true&chractorEncoding=utf-8&serverTimezone=UTC
    username: root
    password: 123456
  application:
    name: actor-provider-application
bootstrap.yaml
spring:
  datasource:
    type: ${spring-config.datasource.type}
    driver-class-name: ${spring-config.datasource.driver-class-name}
    url: ${spring-config.datasource.url}
    username: ${spring-config.datasource.username}
    password: ${spring-config.datasource.password}
  application:
    name: dataProvider8000
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
        group: DEFAULT_GROUP
        username: nacos
        password: nacos
        enabled: true
server:
  port: 8000
mybatis:
  type-aliases-package: ${mybatis-config.type-aliases-package:}
  configuration:
    map-underscore-to-camel-case: true
  mapper-locations: classpath:mybatis/mapper/*.xml

验证同上。

3.服务发现（Nacos Discovery）

3.0项目建立

consumer建立

这里我们沿用上面的项目，再新建一个consumer，配置如下：

application.yaml

spring:
  application:
    name: consumer9000
  cloud:
    nacos:
      discovery:
        enabled: true
        server-addr: 127.0.0.1:8848
server:
  port: 9000

启动器加入注解@EnableDiscoveryClient

provider配置

yaml加入以下配置

spring:
  application:
    name: consumer8000
  cloud:
    nacos:
      discovery:
        enabled: true
        server-addr: 127.0.0.1:8848
server:
  port: 8000

启动器加入注解@EnableDiscoveryClient

环境验证

在进一步配置consumer访问provider的controller前，先启动两个服务，在nacos后台查看服务。

如显示两个服务都成功注册到了nacos，证明环境无误。

3.1Feign均衡负载（客户端）的consumer配置

（用于服务器均衡负载的Nginx等方案我们会在之后介绍）

consumer引入依赖，springdoc为可选，笔者为了方便调试引入

		<dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-ui</artifactId>
        </dependency>
        <!--openfeign服务调用-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
编写FeignService层
package com.zjy.consumer9000.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;
import java.util.Map;

@FeignClient("dataProvider8000")//和Eureka+Feign一样，根据服务名找到服务，简单优雅
@Component
public interface FeignService {

    @GetMapping("/dept/list")
    List<Map> getAll();

    @GetMapping("/dept/query/id/{departmentId}")
    Map queryById(@PathVariable("departmentId") Integer departmentId);

    @GetMapping("/dept/query/name/{departmentName}")
    List<Map> queryByName(@PathVariable("departmentName") String departmentName);

}
ConsumerController
package com.zjy.consumer9000.controller;


import com.zjy.consumer9000.service.FeignService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@Tag(name="consumer for dept")
@RequestMapping("/dept")
public class DeptConsumerController {
    @Resource
    private FeignService feignService;


    @Operation(summary="本地测试")
    public String test(){
        return "OK";
    }
    @Operation(summary = "获取部门列表")
    @GetMapping("/list")
    public List<Map> getAll(){
        System.err.println("listing all departments...");
        return feignService.getAll();
    }

    @Operation(summary = "通过id查找部门")
    @GetMapping("/query/id/{departmentId}")
    public Map queryById(@PathVariable Integer departmentId){
        return feignService.queryById(departmentId);
    }
    @Operation(summary = "通过名称查找部门")
    @GetMapping("/query/name/{departmentName}")
    public List<Map> queryByName(@PathVariable String departmentName){
        return feignService.queryByName(departmentName);
    }

}
启动类记得加上注解@EnableFeignClients

​ 假如启动consumer提示获取不到FeignService的Bean，那么大概率需要检查一下是否忘记加上@FeignClient和@EnableFeignClients注解！

3.2功能验证

同上，进入swagger后台，逐个测试有参无参接口。

4.项目源代码发布

SpringCloudAlibaba: SpringCloudAlibaba练习项目 (gitee.com)

复读机3827
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Nacos生产环境集群部署
liukejun的博客
08-28 1199
Nacos生产环境集群部署环境介绍集群架构开始部署安装mysql数据库安装java及mvn部署nacos配置nginx集群代理访问nacos 环境介绍 节点 ip 用途 操作系统 tcontrol 172.16.96.24 mysql–nginx centos7 tmaster1 172.16.96.25 nacos1 centos7 tmaster2 172.16.96.26 nacos2 centos7 tmaster3 172.16.96.27 nacos3 centos7
03.Spring Cloud Alibaba学习笔记--Nacos生产环境配置（Linux）
java阳旭的博客
08-07 1389
Nacos之Linux版本安装、Nacos集群配置
阿里注册中心Nacos生产部署方案
zlt2000的博客
08-20 6782
生产环境中部署`nacos`首先肯定是使用集群模式`cluster`保证高可用，本文主要详细介绍最佳的集群方案怎样搭建与`spring cloud`程序怎样集成
SpringCloud Nacos的配置与使用
最新发布
Mwt258的博客
07-24 1991
【SpringCloud】(超详细) - Nacos(Dynamic Naming and Configuration Service)是阿里Nacos开源的一个项目，由阿里Nacos内部三个产品合并统一开源，Nacos是的组件，遵循着Spring Cloud 中定义的服务注册、服务发现规范，因此使用Nacos和使用Eureka对于微服务来说并没有太大区别，但Nacos除了提供服务发现和服务注册外，还提供了配置中心和流量管理等功能！！
springCloud alibaba+nacos模块化项目搭建
ruo_yuan
12-28 1726
背景 今天本来很想写一个由数据读取网关配置，避免每次上新模块都会去修改配置文件导致频繁操作。本以为集成个sc+nacos应该是一件很easy的事情，纸上得来终觉浅，一躬行发现问题接憧而来。接下来就一步一步的实现springCloud alibaba+nacos模块化项目搭建。 nacos本地环境搭建 工欲善其事必先利其器，先把安装包安排上。网上普遍推荐是走gitlab官方去下载，慢的一撇。给大家来个传送门。 链接：https://pan.baidu.com/s/1aaICD4ytNB_pVdhB_OyDCg
nacos 2.1.2 (当前最新版) 生产环境安装部署
一粒小粟
12-14 3728
nacos 2.1.2 (当前最新版) 生产环境安装部署
seata 1.7 基于springcloud 和nacos搭建的客户端
11-17
在本项目中，我们将基于 Seata 1.7 版本，结合 Spring Cloud 和 Nacos 来搭建一个客户端，实现 AT 模式的分布式事务。 **Seata 的核心组件：** 1. **TC (Transaction Coordinator)**：事务协调器，负责全局事务的...
Springcloud-nacos实现配置和注册中心的方法
08-25
Springcloud-nacos是一种实现配置和注册中心的方法，它主要基于Nacos框架，提供了一种简洁易用的解决方案。Nacos是阿里开源的一款框架，致力于帮助开发者发现、配置和管理微服务。下面我们将详细介绍Springcloud-...
SpringCloud - Nacos详解
09-30
**SpringCloud - Nacos详解** 在微服务架构中，服务治理和配置管理是至关重要的环节。Spring Cloud作为一套完整的微服务解决方案，提供了多种组件来解决这些问题。其中，Nacos是Spring Cloud生态中的一个核心组件，...
SpringCloud入门案例 nacos dubbo
09-27
1. **Spring Cloud Nacos的安装与配置**：首先，你需要了解如何下载并部署Nacos服务器，配置服务器的基本参数，如端口号、数据存储路径等。 2. **创建Spring Boot项目**：接下来，创建基于Spring Boot的微服务项目...
spring cloud nacos 工具+demo+安装攻略
05-09
1. **创建Spring Boot项目**：基于Spring Initializr创建一个Spring Boot项目，添加Spring Cloud和Nacos的相关依赖。 2. **配置Nacos**：在`application.properties`或`application.yml`中配置Nacos服务器的地址、...
nacos生产者配置文件
weixin_45503738的博客
08-24 162
启动类 @SpringBootApplication @EnableDiscoveryClient public class PwcAbcNacosApplication { public static void main(String[] args) { SpringApplication.run(PwcAbcNacosApplication.class, args); } @LoadBalanced @Bean public RestTemplate restTemplate() {
springcloud生产环境一般怎么部署_生产环境高可用，Alibaba Nacos 集群部署
weixin_39776817的博客
11-28 611
前面学习了单机模式下的启动，生产环境中部署nacos肯定是使用集群模式cluster保证高可用。官方文档的集群部署推荐使用VIP+域名模式，把所有服务列表放到一个vip下面，然后挂到一个域名下面。三种部署方式官方推荐，nacos集群一般有3种方式，三种部署方式在访问形式的区别如下，http://ip1:port/openAPI 直连ip模式，机器挂则需要修改ip才可以使用http://VIP:po...
【微服务】Nacos生产环境配置技巧分享
我爱娃哈哈的专栏
04-15 1364
前面我们介绍了Nacos作为配置中心组件实现，是如何配置和接入的。对于Nacos来说，他是集注册中心及配置中心为一体的。基于它的强大能力，我们在这里来统一分享几个Nacos在生产环境的配置技巧。
springCloudAlibaba---nacos配置中心生产实战
池海
05-12 377
在使用之前如nacos环境搭建，mysql持久化配置等一系列问题就不再这里赘述了。下面直接上实战使用方法,演示使用的是单机环境此处我们以配置datasource来进行使用的案例演示。 引入相关依赖 <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId> &l
史上最全的Nacos 介绍和部署
qq_31532979的博客
01-16 3658
前言什么是微服务一、nacos 概述1.1 nacos 简介1.2 Nacos 核心特性1.2.1 服务发现1.2.2 服务健康监测1.2.3 动态配置服务1.2.4 动态DNS服务1.2.5 服务及其元数据管理1.3 组件介绍1.4 nacos 的架构图二、主流的配置中心三、Nacos与其他注册中心的区别3.1 Nacos和Eurek、apollo的区别3.2 注册中心的原理四、Nacos 搭建4.1 nacos的结构图4.2 nacos 单机部署。
nacos安装配置和单机部署教程
qq_36575363的博客
01-26 6933
首先说明：次教程是针对的nacos版本：1.3.2，不同的版本，可能略有不同。 Springcloudalibaba的版本与Springboot的版本与nacos版本需要对应 Nacos支持三种部署模式 单机模式 - 用于测试和单机试用。 集群模式 - 用于生产环境，确保高可用。 多集群模式 - 用于多数据中心场景。 单机部署： 1、首先去官网下载nacos Releases · alibaba/nacos · GitHub 默认是集群启动的，可以修改为单机启动模式： Window
生产环境下使用CentOS7+Nacos+Mysql搭建Nacos集群，并完成注册中心，配置中心及Sentinel及Seata的测试
Foeverlikeluo的博客
06-16 966
③MySQL配置文件保存在/etc/路径下，可修改配置，重启MySQL服务后配置生效重启MySQL服务：systemctl restart mysqld。rpm -qa | grep mariadb #检查是否存在 mariadb 数据库（内置的MySQL数据库），有则强制删除。PS：MySQL默认的密码复杂度为 MEDIUM，所以新密码至少为8位，并且必须包含大、小写字母、数字和特殊字符。rpm -e --nodeps mariadb-libs-5.5.68-1.el7.x86_64 #强制删除。
Nacos集群部署-详细篇
weixin_38568503的博客
10-03 9083
官网说明： 官网： https://nacos.io/zh-cn/docs/cluster-mode-quick-start.html 部署书册：https://nacos.io/zh-cn/docs/deployment.html 集群架构： 官网图说明：vip:虚拟映射ip 高可用 Nginx 集群 Nacos 集群(至少三个实例) 高可用数据库集群(取代 Nacos 内嵌数据库) 环境要求： 默认的Nacos使用嵌入式数据库实现数据的存储，所以启动多个默认配置下的Nacos节点，数据存储存在
Nacos深度解析：作为Spring Cloud Alibaba的注册与配置中心
Nacos作为Spring Cloud Alibaba的一部分，提供了强大的服务治理功能，使得微服务的管理和部署变得更加高效和便捷。无论是服务注册、配置管理还是健康检查，Nacos都为开发者提供了强大的工具，有助于构建健壮的微服务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值