标签：Java nacos springframework Nacos 详解 org import cloud 分布式

1. 概念

微服务是一种软件架构模式，它将应用程序分解为一组小型、自治的服务单元。
个人理解上：微服务就是将服务拆分，让一种服务在一台或者多台电脑上运行，如下图微服务技术栈所示：

注册中心可以配置在一台或者多台电脑上，将功能拆分，n台电脑共同实现一个软件

单体架构：将业务的所有功能集中在一个项目中开发，打成一个包部署

优点：

架构简单
部署成本低

缺点：耦合度高

微服务：一种良好的分布式架构方案

优点：拆分粒度更小、服务更独立、耦合度更低

缺点：架构非常复杂，运维、监控、部署难度提高

微服务技术对比：

2. 服务的远程调用

第一步：向spring容器中注入RestTemplate对象

在启动类（Application）中加入如下代码：

package cn.itcast.order;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
    // 注入
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

第二步：利用RestTemplate中getForObject方法或者postForObject方法发送请求

在业务逻辑层（一般是Service）中调用

package cn.itcast.order.service;

import cn.itcast.order.mapper.OrderMapper;
import cn.itcast.order.pojo.Order;
import cn.itcast.order.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    // 注入
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        String url = "http://userservice/user/"+order.getUserId();
		// 4.调用，利用反序列化获取对象
        User user = restTemplate.getForObject(url, User.class);
        order.setUser(user);
        // 4.返回
        return order;
    }
}

3. 注册中心

Eureka

搭建Eureka服务器

1.创建Eureka服务器项目，引入spring-cloud-starter-netflix-eureka-server的依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

注：这里不用加版本号，因为在父工程的依赖中已经指定springboot、springcloud和springcloud依赖库（spring-cloud-dependencies）

2.编写启动类，添加@EnableEurekaServer注解

3.添加application.yml文件，编写下面的配置:

server:
	port:10086
spring:
	application:
		name: eurekaserver
eureka:
	client:
		service-url:
			defaultZone:http://127.0.0.1:10086/eureka/

Eureka自己也是服务，此处为注册自己

向Eureka服务器注册服务

在客户端项目中引入eureka-client依赖：

<!--eureka多户端放赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

在客户端项目的application.yml中配置eureka地址

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/cloud_order?useSSL=false
    username: root
    password: 123
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: orderservice
eureka:
	client:
		service-url:#eureka的地址信息
			defaultZone: http://127.0.0.1:10086/eureka

消费者拉取所有生产者实现负载均衡（服务发现）

1.修改业务逻辑层（Service）的代码，修改访问的url路径，用服务名代替ip、端口:

String url ="http://userservice/user/"+ order.getUserId();

2.在消费者项目的启动类Application中的RestTemplate添加负载均衡注解:

package cn.itcast.order;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {

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

    @Bean
    @LoadBalanced   //负载均衡注解
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

Ribbon负载均衡

原理：

策略：

默认为ZoneAvoidanceRule

通过定义IRule实现可以修改负载均衡规则，有两种方式：

1、代码方式:在order-service中的OrderApplication类中，定义一个新的IRule:

@Bean
public IRule randomRule(){
return new RandomRule();
}

2、配置文件方式:在消费者的application.yml文件中，添加新的配置也可以修改规则:

userservice:#生产者服务名
  ribbon:
    NFLoadBalancerRuleclassName: com.alibaba.cloud.nacos.ribbon.NacosRule #负载均衡规则

特点：懒加载

Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载:

ribbon :
	eager-load:
		enabled:true#开启饥饿加载
		clients:userservice#指定对userservice这个服务饥饿加载

Nacos

Nacos是阿里巴巴的产品，现在是Springcloud中的一个组件。相比Eureka功能更加丰富，在国内受欢迎程度较高。

安装

Windows安装：

开发阶段采用单机安装即可。

1.下载安装包
在Nacos的GitHub页面，提供有下载链接，可以下载编译好的Nacos服务端或者源代码：
GitHub主页：https://github.com/alibaba/nacos
GitHub的Release下载页：https://github.com/alibaba/nacos/releases

2.解压
将这个包解压到任意非中文目录下
目录说明：

bin：启动脚本
conf：配置文件

3.端口配置
Nacos的默认端口是8848，如果你电脑上的其它进程占用了8848端口，请先尝试关闭该进程。
如果无法关闭占用8848端口的进程，也可以进入nacos的conf目录，修改配置文件中的端口：

4.启动
启动非常简单，进入bin目录，结构如下：
然后执行命令即可：

windows命令：
```
startup.cmd -m standalone
```

5.访问

在浏览器输入地址：http://127.0.0.1:8848/nacos即可：
默认的账号和密码都是nacos，进入后：

Linux安装：
Linux或者Mac安装方式与Windows类似。

1.安装JDK
Nacos依赖于JDK运行，索引Linux上也需要安装JDK才行。
上传jdk安装包
上传到某个目录，例如：/usr/local/
然后解压缩：

tar -xvf jdk-8u144-linux-x64.tar.gz

然后重命名为java
配置环境变量：

export JAVA_HOME=/usr/local/java
export PATH=$PATH:$JAVA_HOME/bin

设置环境变量：

source /etc/profile

2.上传安装包

上传到Linux服务器的某个目录，例如/usr/local/src目录下：

3.解压
命令解压缩安装包：

tar -xvf nacos-server-1.4.1.tar.gz

然后删除安装包：

rm -rf nacos-server-1.4.1.tar.gz

4.端口配置
与windows中类似
5.启动
在nacos/bin目录中，输入命令启动Nacos：

sh startup.sh -m standalone

服务注册到nacos

1.在cloud-demo父工程中添加spring-cloud-alilbaba的管理依赖:
父工程：

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

如果存在Eureka依赖，注释掉原有的eureka依赖
2.添加nacos的客户端依赖:
客户端：

<!-- nacos客户端依赖包 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

Nacos服务分级存储模型

userservice功能——》区域集群（上海、杭州）——》每个区域下多个的实例（userservice代码）

配置文件中加入集群设置：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/cloud_user?useSSL=false
    username: root
    password: 123
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: userservice
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: SH

cluster-name为集群名

NacosRule负载均衡（消费者调用生产者会优先调用同集群的生产者）

1、设置集群名称:

spring:
	cloud:
		nacos:
			server-addr:localhost:8848#nacos服务端地址
			discovery:
				cluster-name:Hz#配置集群名称，也就是机房位置

2、然后在消费者的yml文件中中设置负载均衡的IRule为NacosRule，这个规则优先会寻找与自己同集群的服务

userservice:
  ribbon:
    NFLoadBalancerRuleclassName: com.alibaba.cloud.nacos.ribbon.NacosRule# 负载均衡规则

3、注意将user-service的权重都设置为1，权重0-1，越大被访问的概率越大，权重设置为0则完全不会被访问（可以用来升级更新服务）

Nacos环境隔离

命名空间->分组->服务

namespace用来做环境隔离
每个namespace都有唯-id
不同namespace下的服务不可见

实现：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/cloud_order?useSSL=false
    username: root
    password: 123
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: orderservice
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ
        namespace: b5cf9721-b0f7-437c-90b6-8dff03e16254 #命名空间id

Nacos与Eureka区别

1.Nacos与eureka的共同点

都支持服务注册和服务拉取

都支持服务提供者心跳方式做健康检测

2.Nacos与Eureka的区别

Nacos支持服务端主动检测提供者状态:临时实例采用心跳模式，非临时实例采用主动检测模式临时实例心跳不正常会被剔除，非临时实例则不会被剔除

Nacos支持服务列表变更的消息推送模式，服务列表更新更及时

Nacos集群默认采用AP方式，当集群中存在非临时实例时，采用CP模式;Eureka采用AP方式

Nacos配置管理

Nacos统一配置管理（先在Nacos中配置好配置文件）

微服务拉取上述Nacos配置

原理：

项目启动时会比读取application.yml更早读取bootstrap.yml文件，故而nacos配置文件的地址可以写在bootstrap.yml文件中

实现：

引入Nacos的配置管理客户端依赖:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

因为在子项目中不用写版本号，在父项目的pom文件的依赖库中已经定义

在需要配置服务的项目中的resource目录添加一个bootstrap.yml文件，这个文件是引导文件，优先级高于application.yml:

spring:
  application:
    name: userservice
  profiles:
    active: dev
  cloud:
    nacos:
      server-addr: localhost:8848
      config:
        server-addr: localhost:8848 #配置文件的地址不写会找不到，报空指针错误
        file-extension: yaml

校验代码（Controller中获取nacos中的配置文件）：

package cn.itcast.user.web;

import cn.itcast.user.pojo.User;
import cn.itcast.user.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @Value("${pattern.dateformat}")
    private String dateformat;

    @GetMapping("/now")
    public String now(){
        System.out.println("================================="+dateformat);
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
    }

    /**
     * 路径： /user/110
     *
     * @param id 用户id
     * @return 用户
     */
    @GetMapping("/{id}")
    public User queryById(@PathVariable("id") Long id) {
        return userService.queryById(id);
    }
}

效果：

输出nacos中配置的字符串，成功获取到

配置优先级：

Feign

远程调用

导包

<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-openfeign -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

启动类加注解@EnableFeignClients
写Client接口

import cn.itcast.order.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient("userservice")
public interface UserClient {
    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long id);
}

Service中自动注入，调用

标签：Java,nacos,springframework,Nacos,详解,org,import,cloud,分布式
From： https://www.cnblogs.com/beijie/p/18016622

微服务（Java分布式）详解