前言：本文是基础应用Nacos的文章，全是基础内容，已熟悉的建议跳过。

零、本文纲要

一、基础的服务调用
二、Nacos服务注册&发现
三、Nacos整合Dubbo
四、Nacos整合OpenFeign

一、基础的服务调用

注意：Nacos是客户端的负载均衡调用，所以涉及到消费的请在consumer处理响应的逻辑。

1. 基础依赖

spring-boot-starter-web：web开发，暴露服务接口；

<!--web开发相关依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2. 编写服务提供方

① application.yml

server:
  port: 56010

② ProviderController

@RestController
@RequestMapping("/provider")
public class ProviderController {
    @GetMapping("/service")
    public String providerService() {
        return "Hello, consumer.";
    }
}

③ 启动类

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

3. 编写服务消费方

① application.yml

server:
  port: 56020

② ConsumerController

使用Spring web开发提供的RestTemplate客户端对象调用远程服务，如下：

@RestController
@RequestMapping("/consumer")
public class ConsumerController {
    /**
     * 使用基本的客户端方法调用远程服务
     *
     * @return 响应结果
     */
    @GetMapping("/hello")
    public String basicConsume() {
        //0. 获取客户端对象
        RestTemplate restTemplate = new RestTemplate();
        //1. 获取服务提供方地址
        final String URI = "http://127.0.0.1:56010";
        final String SERVICE_PATH = "/provider/service";
        //2. 使用客户端模拟访问
        String result = restTemplate.getForObject(URI + SERVICE_PATH, String.class);
        //3. 返回响应结果
        return "Consumer got message from provider, and message is: [" + result + "]";
    }
}

③ 启动类

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

4. 测试

基础调用测试.png

基础调用测试返回结果.png

二、Nacos服务注册&发现

注意：Nacos是客户端的负载均衡调用，所以涉及到消费的请在consumer处理响应的逻辑。

引入Nacos服务注册&发现中心

1. 基础依赖

增加Nacos服务注册&发现的依赖

<!--Nacos服务注册与发现的依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

2. 修改配置文件

添加Nacos相关配置，将服务注册至Nacos

① 服务提供方

spring:
  application:
    name: nacos-restful-provider
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

② 服务消费方

spring:
  application:
    name: nacos-restful-consumer
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

3. 修改服务消费方代码

使用LoadBalancerClient调用服务实例ServiceInstance，轮询获取实例对象；
然后通过ServiceInstance实例对象获取URI，此处URI即为http://192.168.253.128:56010；

private static final String SERVICE_ID = "nacos-restful-provider";

@Autowired
private LoadBalancerClient loadBalancerClient;

/**
 * 使用 Nacos 提供的方法调用远程服务
 *
 * @return 响应结果
 */
@GetMapping("/nacos")
public String useNacos() {
    //1. 获取客户端对象
    RestTemplate restTemplate = new RestTemplate();

    //2. 获取服务提供对象
    ServiceInstance serviceInstance = loadBalancerClient.choose(SERVICE_ID);

    //3. 通过服务实现对象获取其具体的URI
    URI serviceInstanceUri = serviceInstance.getUri();

    //4. 通过 URI+具体服务 进行远程调用
    final String SERVICE_PATH = "/provider/service";
    String result = restTemplate.getForObject(serviceInstanceUri + SERVICE_PATH, String.class);

    //5. 返回响应结果
    return "serviceInstanceUri is: [" + serviceInstanceUri + "] and result is: [" + result + "]";
}

4. 重启服务

Nacos服务注册&发现.png

nacos服务调用.png

nacos服务调用结果.png

补充：负载均衡策略配置

此处我们配置了nacos-restful-provider服务的负载均衡策略，如下：

# 在消费方配置某一具体服务的负载均衡策略
nacos-restful-provider:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

三、Nacos整合Dubbo

注意：Nacos是客户端的负载均衡调用，所以涉及到消费的请在consumer处理响应的逻辑。

1. 基础依赖

添加Dubbo服务相关依赖

<!--Dubbo服务-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-dubbo</artifactId>
</dependency>

2. 编写配置文件

编写bootstrap.yml配置文件，注意两个配置文件端口、应用名等区分开，如下：

server:
  port: 56040
spring:
  application:
    name: nacos-dubbo-service2
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
  main:
    allow-bean-definition-overriding: true
# dubbo 服务相关配置
dubbo:
  scan:
    # dubbo 服务扫描基准包
    base-packages: com.itheima.service.impl
  protocol:
    name: dubbo
    port: 20891
  registry:
    address: nacos://127.0.0.1:8848
  application:
    qos-enable: false # dubbo 运维服务是否开启
  consumer:
    check: false # 启动时就否检查依赖的服务，false的话启动顺序不会影响服务正常启动

3. 编写api接口、服务实现

DDD设计模块
nacos-dubbo-service1
|__service-api1
|__service-server1

nacos-dubbo-service2
|__service-api2
|__service-server2

① service1

/**
 * 服务接口
 */
public interface Service1Api {
    public String dubboService1();
}

/**
 * 服务实现类
 */
@Component
@Service(interfaceClass = Service1Api.class)
public class Service1ApiImpl implements Service1Api {
    @Reference
    private Service2Api service2Api;
    @Override
    public String dubboService1() {
        String service2Result = service2Api.dubboService2();
        return "Dubbo service1 | " + service2Result;
    }
}

/**
 * 启动类
 */
@SpringBootApplication
public class Service1Application {
    public static void main(String[] args) {
        SpringApplication.run(Service1Application.class, args);
    }
}

② service2

/**
 * 服务接口
 */
public interface Service2Api {
    public String dubboService2();
}

/**
 * 服务接口
 */
@Component
@Service(interfaceClass = Service2Api.class)
public class Service2ApiImpl implements Service2Api {
    @Override
    public String dubboService2() {
        return "Dubbo Service2.";
    }
}

/**
 * 服务接口
 */
@SpringBootApplication
public class Service2Application {
    public static void main(String[] args) {
        SpringApplication.run(Service2Application.class, args);
    }
}

4. 编写消费代码

注意：消费方需要添加dubbo服务的依赖，以及对应service-api接口的依赖；

@Reference
private Service1Api service1Api;

@Reference
private Service2Api service2Api;

@GetMapping("/dubbo")
public String useDubbo() {
    return service1Api.dubboService1() + " | " + service2Api.dubboService2();
}

5. 测试

Dubbo对比基本的Nacos服务.png

Nacos整合Dubbo.png

Nacos整合Dubbo测试响应.png

四、Nacos整合OpenFeign

注意：Nacos是客户端的负载均衡调用，所以涉及到消费的请在consumer处理响应的逻辑。

1. 添加依赖

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

2. 编写OpenFeign客户端

@FeignClient(name = "nacos-restful-provider", path = "/provider")
public interface ProviderClient {
    @GetMapping("/service")
    public String providerService();
}

3. 开启OpenFegin的支持

在启动类上添加@EnableFeignClients注解

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

4. 编写消费代码

@Autowired
private ProviderClient providerClient;

@GetMapping("/openfeign")
public String openFeign() {
    return "OpenFeign msg: " + providerClient.providerService();
}

5. 测试

Nacos整合OpenFeign.png

Nacos整合OpenFeign响应结果.png

补充：简单对比Feign和Dubbo

五、结尾

以上即为Nacos基础-服务注册&服务调用的基础内容，感谢阅读。