首页 > 其他分享 >SpringCloud Alibaba 01 （微服务的概念理解，微服务的环境搭建，微服务的服务注册中心Nacos）

SpringCloud Alibaba 01 （微服务的概念理解，微服务的环境搭建，微服务的服务注册中心Nacos）

时间：2024-10-27 15:50:03浏览次数：3  
标签：shop product 01 服务 SpringCloud Nacos com order

在这里插入图片描述

在这里插入图片描述

目录

了解微服务常用的概念

了解项目架构演变

掌握微服务环境搭建

掌握微服务治理组件-Nacos Discovery

掌握微服务负载均衡调度组件-Ribbon

掌握微服务远程调度组件-Feign

掌握微服务流控容错组件-Sentinel

掌握微服务网关组件-Gateway

掌握微服务链路追踪组件-Sleuth&Zipkin

掌握微服务配置中心-Nacos Config

开口表述上面所有组件概念、定位、原理与运用(每个10分钟)

第一章 微服务概念

1.0 科普一些术语

科普一下项目开发过程中常出现的术语，方便后续课程内容的理解。

服务器：
分软件与硬件，软件：类型tomcat这种跑项目的程序， 硬件：用来部署项目的电脑(一般性能比个人电脑好)

服务： 操作系统上术语：一个程序，开发中术语：一个能对外提供功能的程序

微服务： 小的服务，一个完整项目可以拆n个子项目，这些子项目能独立运行，独立对为提供功能。

节点： 微观上：一个服务，宏观上：一台服务器

垂直扩展： 垂直扩展是指单机硬件性能

水平扩展： 通过增加更多的服务器或者程序实例来分散负载，从而提升存储能力和计算能力。

容错率： 允许服务器集群(一堆服务器)错误(异常/故障)出现的范围和概率，

高内聚低耦合： 内聚–>讲究程序功能独立 耦合—>讲究程序间交互，

​ 以java为例子：高内聚低耦合：讲究类设计时尽量简单(边界清晰/功能简单)，类与类间交互尽可能少(减少类间的相互调用)

流量： 有很多种说，开发中说的是访问量(请求次数)

服务间依赖： 项目与项目间的调用，程序与程序间的调用

资源调度： 各种资源进行合理有效的调节和测量及分析和使用，开发中资源：服务器，内存，CPU，IO等项目运行需要各种软硬件。

单点： 唯一，开发中的单点：唯一一个mysql数据库，唯一个服务器

单点故障： 如果项目/程序部署唯一一个服务器，它挂了，那就玩完了

宕机： 服务器挂了

1.1 单体、分布式、集群

我们学习微服务之前,需要先理解单体、集群、分布式这些概念，这样会帮助我们在学习后面课程会更加容易些.

单体

一个系统业务量很小的时候所有的代码都放在一个项目中就好了，然后这个项目部署在一台服务器上就好了。整个项目所有的服务都由这台服务器提供。这就是单机结构。

请添加图片描述
单体应用开发简单,部署测试简单.但是存在一些问题,比如:单点问题,单机处理能力有限,当你的业务增长到一定程度的时候，单机的硬件资源将无法满足你的业务需求。

分布式

由于整个系统运行需要使用到Tomcat和MySQL，单台服务器处理的能力有限,2G的内存需要分配给Tomcat和MySQL使用，，随着业务越来越复杂，请求越来越多. 内存越来越不够用了，所以这时候我们就需要进行分布式的部署.
请添加图片描述
我们行一个评论的请求，这个请求是需要依赖分布在两台不同的服务器的组件[Tomat和MySQL],才能完成的. 所以叫做分布式的系统.

集群

在上面的图解中其实是存在问题的，比如Tomcat存在单点故障问题，一旦Tomcat所在的服务器宕机不可用了，我们就无法提供服务了,所以针对单点故障问题，我们会使用集群来解决.那什么是集群模式呢?

单机处理到达瓶颈的时候，你就把单机复制几份，这样就构成了一个“集群”。集群中每台服务器就叫做这个集群的一个“节点”，所有节点构成了一个集群。每个节点都提供相同的服务，那么这样系统的处理能力就相当于提升了好几倍（有几个节点就相当于提升了这么多倍）。

但问题是用户的请求究竟由哪个节点来处理呢？最好能够让此时此刻负载较小的节点来处理，这样使得每个节点的压力都比较平均。要实现这个功能，就需要在所有节点之前增加一个“调度者”的角色，用户的所有请求都先交给它，然后它根据当前所有节点的负载情况，决定将这个请求交给哪个节点处理。这个“调度者”有个牛逼了名字——负载均衡服务器。

**在这里插入图片描述
我们在上面的图中仅展示了Tomcat的集群，如果MySQL压力比较大的情况下，我们也是可以对MySQL进行集群的.

1.2 系统架构演变

​ 随着互联网的发展，网站应用的规模也不断的扩大，进而导致系统架构也在不断的变化。

从互联网早起到现在，系统架构大体经历了下面几个过程:

​ 单体应用架构—>垂直应用架构—>分布式架构—>SOA架构—>微服务架构。

接下来我们就来了解一下每种系统架构是什么样子的， 以及各有什么优缺点。

1.2.1 单体应用架构

​ 互联网早期，一般的网站应用流量较小，只需一个应用，将所有功能代码都部署在一起就可以，这

样可以减少开发、部署和维护的成本。

​ 比如说一个电商系统，里面会包含很多用户管理，商品管理，订单管理，物流管理等等很多模块，

我们会把它们做成一个web项目，然后部署到一台tomcat服务器上。

在这里插入图片描述

优点：

  • 项目架构简单，小型项目的话， 开发成本低

  • 项目部署在一个节点上， 维护方便

缺点：

  • 全部功能集成在一个工程中，对于大型项目来讲不易开发和维护

  • 项目模块之间紧密耦合，单点容错率低

  • 无法针对不同模块进行针对性优化和水平扩展

1.2.2 垂直应用架构

​ 随着访问量的逐渐增大，单一应用只能依靠增加节点来应对，但是这时候会发现并不是所有的模块

都会有比较大的访问量.

​ 还是以上面的电商为例子， 用户访问量的增加可能影响的只是用户和订单模块， 但是对消息模块

的影响就比较小. 那么此时我们希望只多增加几个订单模块， 而不增加消息模块. 此时单体应用就做不

到了， 垂直应用就应运而生了.

​ 所谓的垂直应用架构，就是将原来的一个应用拆成互不相干的几个应用，以提升效率。比如我们可

以将上面电商的单体应用拆分成:

  • 电商系统(用户管理 商品管理 订单管理)

  • 后台系统(用户管理 订单管理 客户管理)

  • CMS系统(广告管理 营销管理)

这样拆分完毕之后，一旦用户访问量变大，只需要增加电商系统的节点就可以了，而无需增加后台

和CMS的节点。

在这里插入图片描述

优点：

  • 系统拆分实现了流量分担，解决了并发问题，而且可以针对不同模块进行优化和水平扩展

  • 一个系统的问题不会影响到其他系统，提高容错率

缺点：

  • 系统之间相互独立， 无法进行相互调用

  • 系统之间相互独立， 会有重复的开发任务

1.2.3 分布式架构

​ 当垂直应用越来越多，重复的业务代码就会越来越多。这时候，我们就思考可不可以将重复的代码

抽取出来，做成统一的业务层作为独立的服务，然后由前端控制层调用不同的业务层服务呢？

​ 这就产生了新的分布式系统架构。它将把工程拆分成表现层和服务层两个部分，服务层中包含业务

逻辑。表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。

在这里插入图片描述
优点：

  • 抽取公共的功能为服务层，提高代码复用性

缺点：

  • 系统间耦合度变高，调用关系错综复杂，难以维护

1.2.4 SOA架构

​ 在分布式架构下，当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加

一个调度中心对集群进行实时管理。此时，用于资源调度和治理中心(SOA Service Oriented

Architecture，面向服务的架构)是关键。

在这里插入图片描述

优点:

  • 使用注册中心解决了服务间调用关系的自动调节

缺点:

  • 服务间会有依赖关系，一旦某个环节出错会影响较大( 服务雪崩 )

  • 服务关系复杂，运维、测试部署困难

1.2.5 微服务架构

微服务架构在某种程度上是面向服务的架构SOA继续发展的下一步，它更加强调服务的"彻底拆分"。

在这里插入图片描述

优点：

  • 服务原子化拆分，独立打包、部署和升级，保证每个微服务清晰的任务划分，利于扩展

  • 微服务之间采用RESTful等轻量级Http协议相互调用

缺点：

  • 分布式系统开发的技术成本高（容错、分布式事务等）

1.3 微服务架构介绍

​ 微服务架构， 简单的说就是将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独立运行的项目。

微服务架构的常见问题

一旦采用微服务系统架构，就势必会遇到这样几个问题：

  • 这么多小服务，如何管理他们？

  • 这么多小服务，他们之间如何通讯？

  • 这么多小服务，客户端怎么访问他们？

  • 这么多小服务，一旦出现问题了，应该如何自处理？

  • 这么多小服务，一旦出现问题了，应该如何排错?

对于上面的问题，是任何一个微服务设计者都不能绕过去的，因此大部分的微服务产品都针对每一个问题提供了相应的组件来解决它们。

在这里插入图片描述

1.4 SpringCloud介绍

Spring Cloud是一系列框架的集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。

Spring Cloud并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

1.4.1 SpringBoot和SpringCloud有啥关系?

  • SpringBoot专注于快速方便的开发单个个体微服务。

  • SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务整合并管理起来，为各个微服务之间提供，配置管理、服务发现、断路器、路由、事件总线、分布式事务、等等集成服务。

总结: SpringBoot专注于快速、方便的开发单个微服务个体，SpringCloud关注全局的服务治理组件的集合。

1.4.2 SpringCloud版本名称?

因为Spring Cloud不同其他独立项目，它是拥有很多子项目的大项目。所以它是的版本是 版本名+版本号 （如Greenwich.SR6）。
版本名：是伦敦的地铁名
版本号：SR（Service Releases）是固定的 ,大概意思是稳定版本。后面会有一个递增的数字。
所以 Greenwich.SR6就是Greenwich的第6个Release版本。

1.4.3 为什么是SpringCloud Alibaba？

目前，业界比较成熟的服务框架有很多，比如：Hessian、CXF、Dubbo、Dubbox、Spring Cloud、gRPC、thrift等技术实现

在这里插入图片描述

这里我们为什么选择SpringCloud Alibaba呢，主要因为SpringCloud Netflix的组件：服务注册与发现的 Eureka、服务限流降级的 Hystrix、网关 Zuul都已经停止更新了，当然继续使用是没问题的，只是出现问题，官方不维护，需要自行解决.

第二章 微服务环境搭建

2.1 一些说明

为了方便讲解SpringCloud课程，我们以电商项目2个核心模块：商品模块、订单模块为例子，一一讲解SpringCloud组件的使用。

学习SpringCloud组件要诀：不求甚解

1>能解决啥问题

2>怎么解决(理解原理)

3>API调用(代码怎么写)–建议写3遍–【1遍抄全，2遍思考，3遍掌握】

4>总结，开口表述

5>类比以前代码结构

微服务-----完整项目按功能分类拆分成n个子项目/子模块，这些子模块能对外提供对应的功能。我们称这些服务为微服务

落地到代码：单看子项目，每个子项目就是一个完整项目(springmvc项目)----记住没啥高大上的

商品微服务

  • 对外提供查询商品列表接口
  • 对外提供查询某个商品信息接口

订单微服务

  • 对外提供创建订单接口

服务调用

在微服务架构中，最常见的场景就是微服务之间的相互调用。以下单为例子：客户向订单微服务发起一个下单的请求，在进行保存订单之前需要调用商品微服务查询商品的信息。

在这里插入图片描述

一般把调用方称为服务消费者，把被调用方称为服务提供者。

上例中，订单微服务就是服务消费者， 而商品微服务是服务提供者。

2.2 技术选型

持久层: MyBatis-Plus

数据库: MySQL5.7

其他: SpringCloud Alibaba 技术栈

2.3 模块设计

— shop-parent 父工程

​ — shop-product-api 商品微服务api 【存放商品实体】

​ — shop-product-server 商品微服务 【端口:808x】

​ — shop-order-api 订单微服务api 【存放订单实体】

​ — shop-order-server 订单微服务 【端口:809x】

*在这里插入图片描述

shop-product-server：子项目-商品微服务，对外提供查询商品信息的接口

shop-order-server：子项目-订单微服务，对外提供创建订单的接口

shop-product-api / shop-order-api : 各自微服务依赖的实体类，为啥要拆开？答案是：解耦

此处暂时先记住

2.4 版本说明

​ https://github.com/alibaba/spring-cloud-alibaba/wiki/版本说明

在这里插入图片描述

2.5 创建父工程

创建 shop-parent 一个maven工程，然后在pom.xml文件中添加下面内容

<?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>com.gec</groupId>
    <artifactId>shop-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <!--父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
    </parent>
    <!--依赖版本的锁定-->
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-cloud.version>Hoxton.SR8</spring-cloud.version>
        <spring-cloud-alibaba.version>2.2.3.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>
</project>

2.6 创建商品微服务

1.创建shop-product-api项目，然后在pom.xml文件中添加下面内容

<?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">
 <parent>
        <artifactId>shop-parent</artifactId>
        <groupId>com.gec</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shop-product-api</artifactId>
     <!--依赖-->
    <dependencies>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

2 创建实体类

//商品
@Getter
@Setter
@ToString
@TableName("t_product")
public class Product implements Serializable {
    @TableId(type= IdType.AUTO)
    private Long id;//主键
    private String name;//商品名称
    private Double price;//商品价格
    private Integer stock;//库存
}

3.创建shop-product-server项目，然后在pom.xml文件中添加下面内容

<?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">
   <parent>
        <artifactId>shop-parent</artifactId>
        <groupId>com.gec</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shop-product-server</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>
       <dependency>
            <groupId>com.gec</groupId>
            <artifactId>shop-product-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

4.编写配置文件application.yml

server:
  port: 8081
spring:
  application:
    name: shop-product-service
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///shop-product?serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=utf-8
    username: root
    password: 12345

5.在数据库中创建shop-product的数据库

CREATE TABLE `t_product` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(255) DEFAULT NULL COMMENT '商品名称',
  `price` double(10,2) DEFAULT NULL COMMENT '商品价格',
  `stock` int DEFAULT NULL COMMENT '库存',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;

INSERT INTO t_product VALUE(NULL,'小米','1000','5000'); 
INSERT INTO t_product VALUE(NULL,'华为','2000','5000'); 
INSERT INTO t_product VALUE(NULL,'苹果','3000','5000'); 
INSERT INTO t_product VALUE(NULL,'OPPO','4000','5000');

6.创建ProductMapper

package com.gec.shop.product.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.gec.shop.product.pojo.Product;

public interface ProductMapper extends BaseMapper<Product> {
}

7.创建ProductService接口和实现类

public interface ProductService extends IService<Product> {
}

@Service
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements ProductService {
}

8.创建Controller

@RestController
@Slf4j
public class ProductController {
    @Autowired
    private ProductService productService;
    //商品信息查询
    @RequestMapping("/products/{pid}")
    public Product findByPid(@PathVariable("pid") Long pid) {
        log.info("接下来要进行{}号商品信息的查询", pid);
        Product product = productService.getById(pid);
        log.info("商品信息查询成功,内容为{}", JSON.toJSONString(product));
        return product;
    }
}

9.编写启动类ProductServer.java

package com.gec.shop.product;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.gec.shop.mapper")
public class ProductServer {

    public static void main(String[] args) {

        SpringApplication.run(ProductServer.class,args);

    }
}

10.通过浏览器访问服务

在这里插入图片描述

2.7 创建订单微服务

1.创建shop-order-api项目，然后在pom.xml文件中添加下面内容

<?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">
  <parent>
        <artifactId>shop-parent</artifactId>
        <groupId>com.gec</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shop-order-api</artifactId>
 	<!--依赖-->
    <dependencies>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

2 创建实体类

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Getter;
import lombok.Setter;

import java.io.Serializable;

//订单
@Getter
@Setter
@ToString
@TableName("t_order")
public class Order implements Serializable {

    @TableId(type = IdType.AUTO)
    private Long id;//订单id
    //用户
    private Long uid;//用户id
    private String username;//用户名
    //商品
    private Long pid;//商品id
    private String productName;//商品名称
    private Double productPrice;//商品单价
    //数量
    private Integer number;//购买数量
}

3.创建shop-order-server项目，然后在pom.xml文件中添加下面内容

<?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">
 <parent>
        <artifactId>shop-parent</artifactId>
        <groupId>com.gec</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shop-order-server</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>
       <dependency>
            <groupId>com.gec</groupId>
            <artifactId>shop-order-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

4.编写配置文件application.yml

server:
  port: 8091
spring:
  application:
    name: shop-order-service
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///shop-order?serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=utf-8
    username: root
    password: 12345

5.在数据库中创建shop-order的数据库

CREATE TABLE `t_order` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
  `uid` bigint DEFAULT NULL COMMENT '用户id',
  `username` varchar(255) DEFAULT NULL COMMENT '用户名称',
  `pid` bigint DEFAULT NULL COMMENT '商品id',
  `product_name` varchar(255) DEFAULT NULL COMMENT '商品名称',
  `product_price` double(255,0) DEFAULT NULL COMMENT '商品单价',
  `number` int DEFAULT NULL COMMENT '购买数量',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;

6.创建OrderMapper


import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface OrderMapper extends BaseMapper<Order> {
}

7.创建OrderService接口和实现类




import com.baomidou.mybatisplus.extension.service.IService;

public interface OrderService  extends IService<Order> {
}

package com.gec.shop.order.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.gec.shop.order.mapper.OrderMapper;
import com.gec.shop.order.pojo.Order;
import com.gec.shop.order.service.OrderService;
import org.springframework.stereotype.Service;

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

8.创建Controller

package com.gec.shop.order.controller;

import com.gec.shop.order.pojo.Order;
import com.gec.shop.order.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("orders")
public class OrderController {
    @Autowired
    private OrderService orderService;
    @GetMapping("/save")  //测试方便使用Get方式
    public Order order(Long pid, Long uid){
        return orderService.createOrder(pid, uid);
    }
}

9.编写启动类OrderServer.java



import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.gec.shop.order.mapper")
public class OrderServer {
    public static void main(String[] args) {
        SpringApplication.run(OrderServer.class,args);
    }
}

2.8 服务间如何进行远程调用

现在存在一个问题，Order-server服务创建订单操作需要配置商品信息，此时怎么办？

@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {
    @Override
    public Order createOrder(Long pid, Long uid) {
        Order order = new Order();
        //商品？？
        Product product = null;
        order.setPid(pid);
        order.setProductName(product.getName());
        order.setProductPrice(product.getPrice());

        //用户
        order.setUid(1L);
        order.setUsername("dafei");
        order.setNumber(1);
       
        
        // 保存订单
        super.save(order);
        
        return order;
    }
}

思考，谁能提供商品信息查询逻辑呢？答案：product-server， 问题来了，怎么调用？这里引入一个新问题：服务与服务间如何调用(交互)？

在这里插入图片描述

问题来了，怎么用java代码调用发起http接口调用嗯？？

2.9.服务调用方式

2.9.1.RPC和HTTP

无论是微服务还是SOA，都面临着服务间的远程调用。那么服务间的远程调用方式有哪些呢？

常见的远程调用方式有以下2种：

  • RPC：Remote Produce Call远程过程调用，类似的还有RMI。自定义数据格式，基于原生TCP通信，速度快，效率高。早期的webservice，现在热门的dubbo，都是RPC的典型代表

  • Http：http其实是一种网络传输协议，基于TCP，规定了数据传输的格式。现在客户端浏览器与服务端通信基本都是采用Http协议，也可以用来进行远程服务调用。缺点是消息封装臃肿，优势是对服务的提供和调用方没有任何技术限定，自由灵活，更符合微服务理念。

    现在热门的Rest风格，就可以通过http协议来实现。

如果你们公司全部采用Java技术栈，那么使用Dubbo作为微服务架构是一个不错的选择。

相反，如果公司的技术栈多样化，而且你更青睐Spring家族，那么SpringCloud搭建微服务是不二之选。在我们的项目中，我们会选择SpringCloud套件，因此我们会使用Http方式来实现服务间调用。

2.9.2.Spring的RestTemplate

Spring提供了一个RestTemplate模板工具类，对基于Http的客户端进行了封装，并且实现了对象与json的序列化和反序列化，非常方便。

答案是：RestTemplate

RestTempate 是SpringMVC提供专门用于访问http请求的工具类

1.在shop-order-server项目启动类上添加RestTemplate的bean配置

@SpringBootApplication
@MapperScan("com.gec.shop.order.mapper")
public class OrderServer {
    public static void main(String[] args) {
        SpringApplication.run(OrderServer.class,args);
    }

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

2.在OrderServiceImpl中注入RestTemplate并实现远程调用

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

    @Autowired
    private RestTemplate restTemplate;

    @Override
    public Order createOrder(Long pid, Long uid) {
        Order order = new Order();
        //商品
        //方案1：通过restTemplate方式
        String url  = "http://localhost:8081/products/" + pid;
        Product product = restTemplate.getForObject(url, Product.class);

        order.setPid(pid);
        order.setProductName(product.getName());
        order.setProductPrice(product.getPrice());

        //用户
        order.setUid(1L);
        order.setUsername("dafei");
        order.setNumber(1);
        System.out.println(order);
        super.save(order);
        return order;
    }
}

上面操作确实完成的服务间调用问题，但是代码很不优雅，存在着一定小瑕疵，比如：ip，端口变了呢？

  • 一旦服务提供者(商品服务)地址变化，就需要手工修改代码

  • 一旦是多个服务(商品服务)提供者，无法实现负载均衡功能

  • 一旦服务变得越来越多，人工维护调用关系困难

那怎么办呢， 这时候得引入SpringCloud Alibaba第一个组件：

**组件：**注册中心–Nacos

功能：动态的实现服务治理。

第三章 服务治理 Nacos Discovery

3.1 什么是服务治理

服务治理是微服务架构中最核心最基本的模块。用于实现各个微服务的自动化注册与发现。

大白话：各种微服务ip/端口的统一管理(CRUD)

在这里插入图片描述

服务注册：在服务治理框架中，都会构建一个注册中心(管理ip/端口的地方)，每个服务单元向注册中心登记自己提供服

务的详细信息。并在注册中心形成一张服务的清单(建立服务名与ip/端口映射)，服务注册中心需要以心跳的方式去监测清单中

的服务是否可用，如果不可用，需要在服务清单中剔除不可用的服务。

在这里插入图片描述

**服务发现：**微服务去咨询注册中心，并获取所有服务清单，实现对具体服务的访问。

在这里插入图片描述

总结一下：在微服务架构里服务中心主要起到了协调者的作用。功能有：

  1. 服务发现：

    服务注册：保存服务提供者和服务调用者的信息

    服务订阅：服务调用者订阅服务提供者的信息，注册中心向订阅者推送提供者的信息（拉服务清单）

  2. 服务健康检测

    检测服务提供者的健康情况，如果发现异常，执行服务剔除

3.2 常见注册中心

  • Zookeeper

    Zookeeper是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式

应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用

配置项的管理等。

  • Eureka

    Eureka是Springcloud Netflflix中的重要组件，主要作用就是做服务注册和发现。但是现在已经闭

源

  • Consul

    Consul是基于GO语言开发的开源工具，主要面向分布式，服务化的系统提供服务注册、服务发现

和配置管理的功能。Consul的功能都很实用，其中包括：服务注册/发现、健康检查、Key/Value

存储、多数据中心和分布式一致性保证等特性。Consul本身只是一个二进制的可执行文件，所以

安装和部署都非常简单，只需要从官网下载后，在执行对应的启动脚本即可。

  • Nacos

    Nacos是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。它是 Spring

Cloud Alibaba 组件之一，负责服务注册发现和服务配置。

在这里插入图片描述

3.3 Nacos 简介

Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速

实现动态服务发现、服务配置、服务元数据及流量管理。

从上面的介绍就可以看出，Nacos的作用就是一个注册中心，用来管理注册上来的各个微服务。

核心功能点:

  • 服务注册: Nacos Client会通过发送REST请求想Nacos Server注册自己的服务，提供自身的元数据，比如IP地址，端口等信息。Nacos Server接收到注册请求后，就会把这些元数据存储到一个双层的内存Map中。

  • 服务心跳: 在服务注册后，Nacos Client会维护一个定时心跳来维持统治Nacos Server,说明服务一致处于可用状态，防止被剔除，默认5s发送一次心跳

  • 服务同步: Nacos Server集群之间会相互同步服务实例，用来保证服务信息的一致性。

  • 服务发现： 服务消费者(Nacos Client)在调用服务提供的服务时，会发送一个REST请求给Nacos Server,获取上面注册的服务清单，并且缓存在Nacos Client本地,同时会在Nacos Client本地开启一个定时任务拉取服务最新的注册表信息更新到本地缓存。

  • 服务健康检查: Nacos Server 会开启一个定时任务来检查注册服务实例的健康情况，对于超过15s没有收到客户端心跳的实例会将他的healthy属性设置为false(客户端服务发现时不会发现)，如果某个实例超过30s没有收到心跳，直接剔除该实例(被剔除的实例如果恢复发送心跳则会重新注册)

3.4 Nacos实战入门

接下来，我们就在现有的环境中加入nacos，并将我们的两个微服务注册上去。

3.4.1 搭建Nacos环境

  1. 安装Nacos

    下载地址: https://github.com/alibaba/nacos/releases 
下载zip格式的安装包，然后进行解压缩操作,上课使用的Nacos Server版本是1.3.2

  2. 启动Nacos

    #切换目录 
cd nacos/bin 
#命令启动 
startup.cmd -m standalone

  3. 访问Nacos

    打开浏览器输入http://localhost:8848/nacos，即可访问服务， 默认密码是nacos/nacos

在这里插入图片描述

3.4.2 将商品服务注册到Nacos

接下来开始修改 shop-product-server 模块的代码， 将其注册到nacos服务上

  1. 在pom.xml中添加Nacos的依赖
<!--nacos客户端-->
<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

  1. 在主类上添加@EnableDiscoveryClient注解

    @SpringBootApplication
@MapperScan("com.gec.shop.product.mapper")
@EnableDiscoveryClient
public class ProductServer {
    public static void main(String[] args) {
        SpringApplication.run(ProductServer.class,args);
    }
}

  2. 在application.yml中添加Nacos服务的地址

    spring:
  cloud: 
    nacos: 
      discovery: 
        server-addr: localhost:8848

  3. 启动服务， 观察Nacos的控制面板中是否有注册上来的商品微服务

**在这里插入图片描述
**

3.4.3 将订单服务注册到Nacos

接下来开始修改 shop-order-server 模块的代码， 将其注册到nacos服务上

  1. 在pom.xml中添加Nacos的依赖
<!--nacos客户端-->
<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

  1. 在主类上添加@EnableDiscoveryClient注解

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

  2. 在application.yml中添加Nacos服务的地址

spring:
  cloud: 
    nacos: 
      discovery: 
        server-addr: localhost:8848
  1. 启动服务， 观察Nacos的控制面板中是否有注册上来的订单微服务

在这里插入图片描述

  1. 修改OrderServiceImpl， 实现微服务调用
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;

    @Override
    public Order createOrder(Long pid, Long uid) {
        Order order = new Order();
        //商品
        //方案1：通过restTemplate方式
        //String url  = "http://localhost:8081/products/" + pid;
        //Product product = restTemplate.getForObject(url, Product.class);

        //方案2：使用注册中心api方式-discoveryClient
        List<ServiceInstance> instances = discoveryClient.getInstances("product-service");
        ServiceInstance instance = instances.get(0);  //当前只有一个
        String host = instance.getHost();
        int port = instance.getPort();
        String url = "http://" + host + ":" + port + "/products/" + pid;
        Product product = restTemplate.getForObject(url, Product.class);

        order.setPid(pid);
        order.setProductName(product.getName());
        order.setProductPrice(product.getPrice());

        //用户
        order.setUid(1L);
        order.setUsername("dafei");
        order.setNumber(1);
        System.out.println(order);
        super.save(order);
        return order;
    }
}

l<OrderMapper, Order> implements IOrderService {

@Autowired
private RestTemplate restTemplate;

@Autowired
private DiscoveryClient discoveryClient;

@Override
public Order createOrder(Long pid, Long uid) {
    Order order = new Order();
    //商品
    //方案1：通过restTemplate方式
    //String url  = "http://localhost:8081/products/" + pid;
    //Product product = restTemplate.getForObject(url, Product.class);

    //方案2：使用注册中心api方式-discoveryClient
    List<ServiceInstance> instances = discoveryClient.getInstances("product-service");
    ServiceInstance instance = instances.get(0);  //当前只有一个
    String host = instance.getHost();
    int port = instance.getPort();
    String url = "http://" + host + ":" + port + "/products/" + pid;
    Product product = restTemplate.getForObject(url, Product.class);

    order.setPid(pid);
    order.setProductName(product.getName());
    order.setProductPrice(product.getPrice());

    //用户
    order.setUid(1L);
    order.setUsername("dafei");
    order.setNumber(1);
    System.out.println(order);
    super.save(order);
    return order;
}

}

标签：shop,product,01,服务,SpringCloud,Nacos,com,order
From： https://blog.csdn.net/Fuck1269185654/article/details/143237608

相关文章

  • [2019红帽杯]easyRE WP
    [2019红帽杯]easyRE查壳无壳，64位elf文件分析首先没找到什么有用的函数，用shift+12搜索字符串定位这个字符串x追踪到函数首先关注这里第一个for循环，按tab到汇编界面查看这是个简单的异或，写一下脚本a=[73,111,100,108,62,81,110,98,40,111,99,121,127,121,46,......
  • 什么是云服务器ECS
    云服务器ECS（ElasticComputeService）是阿里云（AlibabaCloud）提供的一种云计算服务，它是一种基于虚拟化技术的弹性计算资源服务。ECS允许用户在阿里云平台上租用虚拟服务器来运行应用程序、托管网站、存储数据等。一、云服务器ECS的概念云服务器ECS（ElasticComputeService）是......
  • 04. 微服务 - 示例搭建 - LoadBalancer（一）
    前言基于Eureka示例搭建时的代码hosts增加域名dingsu-300两种设备服务提供者（软交换-sip、300）各两个节点，用于测试负载路由情况负载均衡概念依据各项指标（可使用硬件资源、节点数、请求速率、业务场景等）进行权重考量，将负载（访问请求、工作任务等）分摊到多个服务节点上，从而......
  • 微信小程序开发——注册登录（需要云服务器支撑噢）
    话不多说，先上图：（这是我实现的注册登陆界面，而且登陆实现后可以长时间保留） 前景工作：1、在云环境下构建：login云函数2、一张图片：3、pages下面构建pages/mine/index路径。 1、app.js代码//app.jsApp({onLaunch(){wx.cloud.init({env:......
  • 我有三台ubuntu服务器，手把手教我从0搭建HBase，然后往里存一些数据。
    好的，我们可以一步步来搭建一个基本的HBase集群，并在里面存储一些数据。这里的步骤包括在三台Ubuntu服务器上配置HBase所需的依赖、安装HBase、配置和启动集群、测试存储和查询数据。假设这三台服务器的IP地址分别为192.168.1.101、192.168.1.102和192.168.1.103，其中第......
  • 为什么要用云服务器
    使用云服务器的原因有：一、灵活性和可扩展性；二、降低成本；三、高可用性和容错性；四、快速部署和弹性资源；五、备份和恢复；六、全球范围的访问等。灵活性和可扩展性是指，云服务器允许用户根据实际需求灵活地调整计算、存储和网络资源，从而满足不同业务场景的需求。一、灵活性和可扩展......
  • 2024年最新互联网大厂精选 Java 面试真题集锦（JVM、多线程、MQ、MyBatis、MySQL、Redis
    前言春招，秋招，社招，我们Java程序员的面试之路，是挺难的，过了HR，还得被技术面，在去各个厂面试的时候，经常是通宵睡不着觉，头发都脱了一大把，还好最终侥幸能够入职一个独角兽公司，安稳从事喜欢的工作至今...近期也算是抽取出大部分休息的时间，为大家准备了一份通往大厂面试的小捷径，准备......
  • 虚拟线程实现Web服务器（处理HTTP请求）
    使用Java虚拟线程开发一个Web服务器可以显著提升并发能力，同时保持代码简洁。在这个示例中，我们将使用Java21的虚拟线程实现一个简单的HTTPWeb服务器，逐步解释每个部分的代码。实现目标通过虚拟线程处理HTTP请求。创建一个简单的Web服务器来响应客户端请求。适配IO......
  • Spring Cloud微服务：构建现代应用的新基石
    SpringCloud微服务：构建现代应用的新基石在当今的数字化时代，微服务架构已成为构建大型、复杂应用系统的主流方式。而在微服务领域，SpringCloud凭借其强大的功能和灵活的架构，成为了一颗璀璨的明星。本文将深入探讨SpringCloud微服务的相关知识，包括微服务架构的演变、Spring......
  • 《阿贝云：免费云端服务，成就无限可能》
    当科技的浪潮席卷而来，阿贝云以其免费的虚拟主机和云服务器，站在了时代的前沿。https://www.abeiyun.com 想象一下，无需花费一分钱，你就能拥有一个性能稳定、操作简便的云服务器。阿贝云做到了！它为你提供了一个实现梦想的舞台，无论是创建个人博客、搭建电商平台，还是开发创新的应用程......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99