SpringCloud Nacos

一、 为什么要学SpringCloud

互联网应用和传统应用的区别

传统应用用于企业内部管理，面向企业内部人员

典型传统应用：

• ERP 企业资源计划
• CRM 客户关系管理
• WMS 仓储管理系统
• OA 办公自动化
• 各种后台管理系统，物业、物流、银行、金融.....

特点：

1. 使用的是特定人群，数量不多
2. 对用户体验要求不高
3. 对数据的一致性要求高

互联网应用面向所有互联网用户

典型互联网应用：

• 电商
• 视频
• 社交媒体
• 新闻
• 游戏
• .....

特点：

1. 面对所有互联网用户，用户量大
2. 对用户体验要求高（界面、人性化、性能）
3. 数据一致性要求相对不高
4. 可用性要求高
5. 三高问题（并发量、可用性、性能）

微服务架构和单体应用架构的区别

传统应用大多数使用单体应用架构，互联网应用大多数采用微服务架构

单体应用架构

一个项目打成一个包部署到一台服务器

弊端：

1. 项目复杂性高
2. 技术更新迭代慢
3. 单体故障，可用性差
4. 并发量有限，只能垂直扩展，不能水平扩展
5. 性能比较差

微服务架构

N个项目打成N个包部署到N台服务器

将传统单体应用架构拆分为多微服务项目，每个微服务可以相互通信，部署到各自的服务器

优点：

1. 每个微服务项目复杂性降低
2. 技术更新迭代快
3. 可用性高
4. 并发量提高
5. 性能提高

弊端：

1. 整体项目复杂性大大提升
2. 运维、硬件等成本高
3. 项目之间通信、跟踪麻烦
4. ....

SpringCloud的作用

SpringCloud能够解决微服务架构带来的一系列挑战，提供一个工具包来开发分布式系统

功能包含：

• 分布式配置中心 Config、Nacos
• 服务注册和发现 Eureka、Nacos、Zookeeper、Consul
• 网关 Gateway、Zuul
• 服务之间的调用 Feign、Dubbo
• 负载均衡 Ribbon、LoadBalancer
• 熔断器 Hystrix、Sentinel
• 全局锁
• 集群状态管理
• 分布式消息 Bus

二、微服务入门案例

提供数据的服务叫服务提供者，使用数据的服务叫服务消费者

订单微服务能够查询订单信息，订单信息中包含商品数据，订单微服务要调用商品微服务完成查询

订单服务数据库为sys_order
-- 订单表
create table sys_order
(
	id int primary key auto_increment,
	product_id int not null,
	count int not null,
	user_id int not null,
	time datetime
);

insert into sys_order(product_id,count,user_id,time)
values(1,1,1,'2022-11-21 13:11:12'),
(2,2,1,'2022-12-21 13:11:12'),
(3,1,1,'2022-10-21 13:11:12');

select * from sys_order;

商品服务的商品数据库sys_product
-- 商品表
create table sys_product
(
	id int PRIMARY key auto_increment,
	name varchar(50) not null,
	price double not null,
	type varchar(10) not null
);

insert into sys_product(name,price,type)
values('华为笔记本',5000,'电器'),
('百事可乐',5,'饮料'),
('Nike篮球鞋',800,'鞋子');

select * from sys_product;

1. 编写商品服务，完成按商品id查询商品的功能
2. 编写订单服务，完成按查询订单的功能
3. 订单微服务调用商品微服务

@Configuration
public class RestTemplateConfig {

    /**
     * 创建RestTemplate交给容器
     * @return
     */
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

订单包含商品信息

@Data
@TableName("sys_order")
public class Order {

    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private Long productId;
    private Long count;
    private LocalDateTime time;

    @TableField(exist = false)
    private Product product;
}

订单service查询订单时远程调用商品服务

@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private OrderMapper orderMapper;

    @Override
    public Order getOrderById(Long id) {
        Order order = orderMapper.selectById(id);
        //调用商品微服务获得商品信息
        ResponseEntity<Product> entity = restTemplate.getForEntity("http://localhost:8002/product/" + order.getProductId(), Product.class);
        order.setProduct(entity.getBody());
        return order;
    }
}

三、 SpringCloud Alibaba的主要组件

SCA

SCN Netflix

这些是Spring Cloud Alibaba的几个主要组件

• Nacos 服务注册和发现组件，类似Eureka，除此还包含配置中心的功能，类似Config
• Sentinel 限流、熔断和降级组件，类似Hystrix
• Seata 分布式事务
• RocketMQ Alibaba的消息中间件，以高性能和高吞吐量为特点
• Dubbo Alibaba的RPC组件

四、使用步骤

这里我们需要服务提供者来提供商品数据，服务提供者主要注册到nacos中，服务消费者通过nacos来调用服务提供者。

1）服务提供者和服务消费者都需要注册到注册中心上，服务名 = IP + 端口

2）服务提供者需要每隔一段时间向注册中心发送心跳，如果IP和端口发生改变，注册中心会进行修改，如果超过阈值没有发送心跳，注册中心会剔除掉服务

3）服务消费者调用提供者之前，通过对方服务名到注册中心查询对方的ip和端口，实现服务调用

1.安装Nacos

1. 下载Nacos下载地址：Releases · alibaba/nacos · GitHub
2. 复制文件到Linux的/usr/local目录下cd /usr/localtar -vxf nacos-server-1.4.0.tar.gzcd nacos/binsh startup.sh -m standalone PS：启动文件位于nacos的bin目录下，这里以单机模式启动，除此还有集群模式
3. 打开浏览器，输入http://Linux主机IP:8848/nacos/index.html，就可以看到Nacos的登录界面

账号密码默认都是nacos，输入后进入主界面

windows 安装

在mysql创建nacos数据库，导入nacos-mysql.sql脚本

配置application.properties

### If use MySQL as datasource:
spring.datasource.platform=mysql

### Count of DB:
db.num=1

### Connect URL of DB:
db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user=root
db.password=123456

bin目录输入 ： startup.cmd -m standalone运行

2.创建父项目

先创建一个SpringBoot父项目，便于统一管理项目依赖，下面是pom文件内容：

springboot 2.3.4.RELEASE
	<properties>
        <java.version>1.8</java.version>
        <spring.cloud-version>Hoxton.SR8</spring.cloud-version>
        <spring-cloud-alibaba.version>2.2.5.RELEASE</spring-cloud-alibaba.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud-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>
        </dependencies>
    </dependencyManagement>

3. 服务提供者

在父项目中，新建Module作为服务提供者，继承父项目，同时引入nacos依赖：

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

启动类上需要添加注解：@EnableDiscoveryClient

@EnableDiscoveryClient
@SpringBootApplication
public class ProviderServiceApplication {

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

}

配置文件application.yml

server:
  port: 8002
spring:
  application:
    name: provider-service
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.7.188:8848  # nacos的地址，端口默认是8848

商品实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Goods {

    private Long id;
    private String name;
    private Double price;
}

Service类

@Service
public class GoodsService {

    public Goods findGoods(){
        return new Goods(1L,"MI笔记本5400",5555.0);
    }
}

Controller类

@RestController
@RequestMapping("provider")
public class GoodsController {

    @Autowired
    private GoodsService goodsService;

    @GetMapping("goods")
    public Goods findGoods(){
        return goodsService.findGoods();
    }
}

4. 服务消费者

在父项目中创建新的Module作为服务消费者，消费者也需要继承父项目，引入nacos依赖pom文件可以参考服务提供者修改就可以了

这里也需要添加Goods实体类，启动类上添加@EnableDiscoveryClient，这里就不写了

配置文件，修改下端口

server:
  port: 8001
spring:
  application:
    name: consumer-service
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.7.188:8848

下面我们需要使用RestTemplate来调用服务提供者的接口，需要添加配置类：

@Configuration
public class RestTemplateConfig {

    @LoadBalancaed
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

编写控制器调用服务提供者

@RestController
@RequestMapping("consumer")
public class GoodsController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("goods")
    public Goods findGoods(){
        //通过服务id调用服务提供者
        Goods goods = restTemplate.getForObject("http://provider-service/provider/goods", Goods.class);
        return goods;
    }
}

5.测试

打开浏览器，输入：http://localhost:8001/consumer/goods出现结果：

这里我们访问的是服务消费者的接口，服务消费者通过nacos查找服务提供者，然后成功调用服务提供者的接口获得商品数据。在nacos后台可以看到上面两个服务：

nacos配置中心介绍

nacos除了做服务注册中心外，还能起来配置中心的作用，类似Spring Cloud Config的作用。不过Config需要将配置文件保存到git仓库中，nacos可以直接保存配置文件了，使用起来更加方便。并且nacos还支持配置文件的热加载。

使用步骤

本章的案例是在前面案例基础上进行修改的，大概的过程是：1、在nacos中添加配置文件 2、由provider_service服务加载该配置文件3、在服务的接口中输出配置内容进行验证。

先登录nacos，在配置列表中添加配置：其中Data ID分为三个部分：1、前缀，一般是服务的id 2、profile 应用的环境，有dev、pro、test几种 3、后缀名，这里使用yaml

配置内容随意填写了一些，包含端口和jdbc属性

写完后点击发布，在配置列表中可以看到该配置，下一步就是在provider-service中加载该配置

在provider-service中添加依赖

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

在resources目录下添加bootstrap.yml文件，它比application.yml文件提前加载前面添加的Data ID 的格式就是 ${prefix}-${profiles.active}.${file-extension}

spring:
  cloud:
    nacos:
      config:
        server-addr: 192.168.7.188:8848 # 配置中心地址
        file-extension: yaml            # 配置文件的后缀
        prefix: provider-service        # 配置文件的前缀
  profiles:
    active: dev                         # 使用的profile

application.yml

spring:
  application:
    name: provider-service
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.7.188:8848  # nacos的地址，端口默认是8848

用于测试的Controller

@RestController
@RefreshScope
public class NacosConfigController {

    @Value("${server.port}")
    private String port;

    @Value("${spring.datasource.driver-class-name}")
    private String driver;

    @Value("${spring.datasource.url}")
    private String url;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    @RequestMapping("/config")
    public String config(){
        return "{port='" + port + '\'' +
                ", driver='" + driver + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

启动服务，直接在浏览器中测试在nacos后台修改密码，然后刷新浏览器，可以看到nacos应用了配置热加载的机制

Nacos集群

Nacos高可用 HA (High Avaiability)

三台nacos服务器搭建伪集群

192.168.1.104:8848

192.168.1.104:8847

192.168.1.104:8846

1、在mysql中创建nacos数据库，将nacos-mysql.sql导入进去

2、配置config下的application.properties

server.port=8848

## If use MySQL as datasource:
spring.datasource.platform=mysql

## Count of DB:
db.num=1

## Connect URL of DB:
db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user=root
db.password=123456

3、复制cluster.conf.example文件为cluster.conf

192.168.1.104:8846
192.168.1.104:8847
192.168.1.104:8848

4、将nacos目录复制两个作为新的服务器，修改application.properties中的端口8847、8846

5、分别双击三个nacos目录中的startup.cmd启动三台服务器