1.微服务架构

1. 1 单体应用架构

将项目所有模块(功能)打成jar或者war，然后部署一个进程

优点:

1:部署简单:由于是完整的结构体，可以直接部署在一个服务器上即可。

2:技术单一:项目不需要复杂的技术栈，往往一套熟悉的技术栈就可以完成开发。

缺点:

1:系统启动慢，一个进程包含了所有的业务逻辑，涉及到的启动模块过多，导致系统的启动、重启时间周期过长;

2:系统错误隔离性差、可用性差，任何一个模块的错误均可能造成整个系统的宕机;

3:可伸缩性差:系统的扩容只能只对这个应用进行扩容，无法结合业务模块的特点进行伸缩。

4: 线上问题修复周期长:任何一个线上问题修复需要对整个应用系统进行全面升级。

5: 跨语言程度差

6: 不利于安全管理，所有开发人员都拥有全量代码。

小型项目适合单体应用架构. 比如:OA办公系统。管理类的项目 仓库管理系统。

1.2 微服务应用

微服务架构论文: https://martinfowler.com/articles/microservices.html

译文: https://blog.csdn.net/qq_42261668/article/details/102839758

简单来说，微服务架构风格[1]是一种将一个单一应用程序开发为一组小型服务的方法，每个服务运行在自己的进程中，服务间通信采用轻量级通信机制(通常用HTTP资源API)。这些服务围绕业务能力构建并且可通过全自动部署机制独立部署。这些服务共用一个最小型的集中式的管理，服务可用不同的语言开发，使用不同的数据存储技术。

解读微服务特点:


1:微服务是一种

项目架构思想

(风格)

2:微服务架构是一系列小服务的组合（组件化与多服务)

3:任何一个微服务，都是一个独立的进程(独立开发、独立维护、独立部署)

4:轻量级通信http协议(跨语言,跨平台)

5:服务粒度(围绕业务功能拆分—模块拆分【系统管理服务】【日志服务】【焦虑测试】【抑郁测试系统】)

6:去中心化管理(去中心化”地治理技术、去中心化地管理数据)

1.3 微服务架构的优势

1.易于开发和维护


一个微服务只关注一个特定的业务功能，所以它的业务清晰、代码量较少。开发和维护单个微服务相对比较简单，整个应用是由若干个微服务构建而成，所以整个应用也会维持在可控状态;

⒉.单个微服务启动较快


单个微服务代码量较少，所以启动会比较快;

3.局部修改容易部署


单体应用只要有修改，就要重新部署整个应用，微服务解决了这样的问题。一般来说，对某个微服务进行修改，只需要重新部署这个服务即可;

4.技术栈不受限


在微服务中，我们可以结合项目业务及团队的特点，合理地选择技术栈

5.按需伸缩

焦虑系统访问量大，只需要对焦虑系统进行扩展

1.4 微服务架构的缺点(挑战)

1、服务太多，导致服务间的依赖错综复杂，运维难度大

2、微服务放大了分布式架构的系列问题

• 分布式事务(seata)

• 分布式锁怎么处理(redisson) ,

• 服务注册与发现(nacos) .

• 依赖服务不稳定(sentinel)导致服务雪崩怎么办?

3、运维复杂度陡增，部署数量多、监控进程多导致整体运维复杂度提升。

springcloud来解决上面微服务面临的挑战

1.5 SpringCloud与微服务关系

• SpringBoot专注于快速方便的开发单个个体微服务。
• SpringCloud是关注全局的微服务协调、整理、治理的框架，它将SpringBoot开发的单体整合并管理起来。
• SpringBoot可以离开SpringCloud独立使用开发项目，但是SpringCloud离不开SpringBoot，属于依赖关系。

2. 创建微服务工程

2.1 创建一个父工程

src:可以删除

package:pom打包

（1）依赖

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <!--引入父依赖-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.12.RELEASE</version>
  </parent>

  <groupId>org.example</groupId>
  <artifactId>spring-cloudwork</artifactId>
  <!--父工程那么它的打包方式必须为pom打包-->
  <packaging>pom</packaging>
  <modules>
    <module>xak-common</module>
    <module>xak-product</module>
  </modules>
  <version>1.0-SNAPSHOT</version>
  <name>spring-cloudwork Maven Webapp</name>
  <url>http://maven.apache.org</url>

  <!--定义版本号-->
  <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>

    <!--管理了cloud版本-->
    <dependencies>

      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>${spring-cloud.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <!--alibaba的版本-->
      <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.2 公共模块

<dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
    </dependencies>

2）product实体类

@Data
@TableName(value = "shop_product")
public class Product {
    @TableId(value="pid",type = IdType.AUTO )
    private Integer pid;
    private String pname;
    //小数类型必须使用BigDecimal
    private BigDecimal pprice;
    private Integer stock;
}

order实体类

@Data
@TableName(value = "shop_order")
public class Order {
    @TableId(value="oid",type = IdType.AUTO )
    private Integer oid;
    private Integer uid;
    private String username;
    private Integer pid;
    private String pname;
    private BigDecimal pprice;
    private Integer number;
}

2.3 product商品微服务

 <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>xak-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
    </dependencies>

(2)配置文件

#端口号:8080~8089 []
server.port=8080
#数据源
spring.datasource.url=jdbc:mysql://localhost:3306/product?serverTimezone=Asia/Shanghai
spring.datasource.password=1234
spring.datasource.username=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

#打印sql日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

(3)主启动类

@SpringBootApplication
@MapperScan(basePackages = "com.xak.product.dao")
public class ProductApp {
    public static void main(String[] args) {
        SpringApplication.run(ProductApp.class,args);
    }
}

(4)dao层

public interface ProductDao extends BaseMapper<Product> {
}

（5）service层

public interface ProductService {
        //根据id查询商品信息
    Product selectById(Integer pid);
}

public class ProductServiceImpl implements ProductService {
   @Autowired
    ProductDao productDao;
    @Override
    public Product selectById(Integer pid) {
        Product product = productDao.selectById(pid);
        return product;
    }
}

（6）controller层

package com.xak.product.controller;

import com.xak.pojo.Product;
import com.xak.product.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

/**
 * @program: spring-cloudwork
 * @description:
 * @author: 
 * @create: 2023-05-13 09:53
 **/
@RestController
public class ProductController {
    @Autowired
    ProductService productService;
    @GetMapping("selectById/{pid}")
    public Product selectById(@PathVariable Integer pid){
        Product product = productService.selectById(pid);
        return product;
    }
}

2.4 order订单微服务

（1）依赖

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.example</groupId>
        <artifactId>spring-cloudwork</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>xak-order</artifactId>
    <packaging>war</packaging>
    <name>xak-order Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>xak-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
    </dependencies>
</project>

(2) 配置

server.port=8090

spring.datasource.url=jdbc:mysql://localhost:3306/order?serverTimezone=Asia/Shanghai
spring.datasource.password=1234
spring.datasource.username=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver


mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

(3)启动类

package com.xak.order;

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

/**
 * @program: spring-cloudwork
 * @description:
 * @author: 肖
 * @create: 2023-05-13 10:23
 **/
@SpringBootApplication
@MapperScan(basePackages = "com.xak.order.dao")
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class,args);
    }
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

(4)controller

package com.xak.order.controller;

import com.xak.order.service.OrderService;
import com.xak.pojo.Order;
import com.xak.pojo.Product;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @program: spring-cloudwork
 * @description:
 * @author: 肖
 * @create: 2023-05-13 10:32
 **/
@RestController
public class OrderController {
    @Autowired
    OrderService orderService;
    @Autowired
    RestTemplate restTemplate;
    @GetMapping("insert")
    public String insert( Integer pid, Integer num){
        Order order = new Order();
        //用户信息--登录中获取
        order.setUid(1);
        order.setUsername("张三");
        order.setNumber(num);
        //商品信息的设置: 远程调用商品微服务的接口。 基于Http协议进行远程调用。
        //两种基于http调用的方式: 第一种: 可以使用httclient工具jar 自己封装工具类
        //                    第二种方式: spring框架中提供了一个工具类。RestTemplate.
        Product product = restTemplate.getForObject("http://localhost:8080/selectById/"+pid, Product.class);
        if (product == null){
            return "下单失败";
        }
        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());

        orderService.insert(order);
        return "下单成功";
    }
}

3. 服务治理

服务治理介绍




先来思考一个问题



通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址

（ip，端口）等硬编码到了代码中，这种做法存在许多问题：

l 一旦服务提供者地址变化，就需要手工修改代码

l 一旦是多个服务提供者，无法实现负载均衡功能

l 一旦服务变得越来越多，人工维护

调用关系

困难

那么应该怎么解决呢， 这时候就需要通过注册中心动态的实现

服务治理

。

*什么是服务治理*

服务治理是微服务架构中最核心最基本的模块。用于实现各个微服务的

自动化注册与发现

。

服务注册

：在服务治理框架中，都会构建一个

注册中心

，每个服务单元向注册中心登记自己提供服务的详细信息。并在注册中心形成一张服务的****清单*


，服务注册中心需要以


*心跳30s

90s****的方式去监测清单中 的服务是否可用，如果不可用，需要在服务清单中剔除不可用的服务。

服务发现

：服务调用方向服务注册中心咨询服务，并获取****所有服务****的实例清单，实现对具体服务实例的访问。

3.1 常见的服务治理组件。

eureka: 它是netflix公司提供的一款组件，这款组件已经停止更新。

nacos: 它是阿里巴巴提供的一款服务治理组件。

zookeeper: 它是apache公司提供的服务治理组件。

consul: 服务治理的组件

3.2 安装nacos治理组件

https://github.com/alibaba/nacos/releases

解压到当前目录—不要带中文





双击

账号和密码: nacos/nacos

3.3 微服务注册到注册中心

（1） 引入nacos的依赖,这里添加到order的pom文件里

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

（2）配置文件指定注册中心的地址

 #注册中心的地址
spring.cloud.nacos.discovery.server-addr=localhost:8848

（3）为微服务起名

 #起名字 单词之间使用-划线
spring.application.name=qy-product

修改订单微服务的代码

 //在springcloud中提供了一个类DiscoveryClient 该类可以从注册中心nacos拉取指定的服务清单
    @Autowired
    DiscoveryClient discoveryClient;
    @GetMapping("insert")
    public String insert( Integer pid, Integer num){
        Order order = new Order();
        //用户信息--登录中获取
        order.setUid(1);
        order.setUsername("张三");
        order.setNumber(num);
        List<ServiceInstance> instances = discoveryClient.getInstances("qy-product");
        ServiceInstance serviceInstance = instances.get(0);
        String path = serviceInstance.getUri().toString();
        Product product = restTemplate.getForObject(path+"/findById/"+pid, Product.class);
        if (product == null){
            return "下单失败";
        }
        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());

        orderService.insert(order);
        return "下单成功";
    }

4. 实现负载均衡

4.1 什么是负载均衡

通俗的讲， 负载均衡就是将负载（工作任务，访问请求）进行分摊到多个操作单元（服务器,组件）上进行执行。


可以手动完成负载均衡。


修改Order调用方

 @GetMapping("insert")
    public String insert( Integer pid, Integer num){
        Order order = new Order();
        //用户信息--登录中获取
        order.setUid(1);
        order.setUsername("张三");
        order.setNumber(num);
        List<ServiceInstance> instances = discoveryClient.getInstances("qy-product");
        // 随机负载均衡
        int i = new Random().nextInt(instances.size());
        ServiceInstance serviceInstance = instances.get(i);
        String path = serviceInstance.getUri().toString();
        Product product = restTemplate.getForObject(path+"/findById/"+pid, Product.class);
        if (product == null){
            return "下单失败";
        }
        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());

        orderService.insert(order);
        return "下单成功";
    }

4.2 使用ribbon完成负载均衡

思考: 上面的负载均衡，是不是自己写的代码。缺点: 代码比较复杂。 如果想改变复杂均衡的策略，必须都是修改order的代码。

什么是ribbon

基于Ribbon实现服务调用， 是通过拉取到的所有服务列表组成（服务名-请求路径的）映射关系。借助 RestTemplate 最终进行调用

如何使用ribbon


(1)在RestTemplate类上加个注解@LoadBalance

 	@Bean
    @LoadBalanced//lspringcloud在扫描时会帮你完成从注册中心拉取服务清单的功能
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

(2)修改controller层代码

演示: ribbon默认采用的是轮询策略。 是否可以修改负载均衡策略。

ribbon内置的负载均衡策略


Ribbon内置了多种负载均衡策略,内部负载均衡的顶级接口为 com.netflix.loadbalancer.IRule , 具体的负载策略如下图所示:



如何改变ribbon的负载均衡策略

修改order的配置文件

#修改ribbon负载均衡策略
qy-product.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule
#qy-product表示对访问那个微服务设置负载均衡策略
#com.netflix.loadbalancer.RandomRule负载均衡策略

5. 使用Openfeign完成远程调用

上面服务之间的调用 使用的是RestTemplate. 使用Resttemplate远程调用，它不符合我们的编程习惯。Controller—Service—Dao 再Controller注入一个service对象，然后调用service中的方法，根据方法传递相应的参数以及接受方法的返回的结果。

我们可以使用Openfeign组件来完成。


什么是OpenFeign

OpenFeign是Spring Cloud提供的一个声明式的伪Http客户端， 它使得调用远程服务就像调用本地服务一样简单, 只需要创建一个接口并添加一个注解即可。

Nacos很好的兼容了OpenFeign， OpenFeign负载均衡默认集成了 Ribbon， 所以在Nacos下使用OpenFegin默认就实现了负载均衡的效果。

总结: openfeign就是为了完成服务的远程调用，它就像调用本地方法一样。

5.2 如何使用openfeign

(1) 依赖openfeign依赖

<!--openfeign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

(2)定义接口并添加@FeignClient（value=“服务提供者的名”）注解

@FeignClient(value = "qy-product")
public interface ProductFeign {
    //抽象方法一定要和服务提供者中的接口方法一致
    @GetMapping("/findById/{pid}")//url+@Getmapping中的内容
    public Product findById(@PathVariable Integer pid);
}

(3)在主启动类开启openfeign注解驱动

@SpringBootApplication
@MapperScan(basePackages =" com.aaa.order.dao")
@EnableFeignClients//开启openfeign注解驱动
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class,args);
    }
    @Bean
    @LoadBalanced//lspringcloud在扫描时会帮你完成从注册中心拉取服务清单的功能
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

(4)再使用的类中注入Openfeign注解

@RestController
public class OrderController03 {
    @Autowired
    private OrderService orderService;
    @Autowired
    ProductFeign productFeign;
    @GetMapping("insert")
    public String insert( Integer pid, Integer num){
        //springcloud 扫描到@FeignClient注解后，
        // 就会为改注解接口生成一个代理实现类，再把代理实现类注册改相应的属性

        Order order = new Order();
        //用户信息--登录中获取
        order.setUid(1);
        order.setUsername("张三");
        order.setNumber(num);

        Product product = productFeign.findById(pid);
        if (product == null){
            return "下单失败";
        }
        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());

        orderService.insert(order);
        return "下单成功";
    }
}

总结:

6. eureka作为注册中心[了解]

它的官网没有提供下载包。只能自己创建eureka的服务端。

（1）搭建eureka服务



（2）引入相关依赖

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
    </dependencies>

(2)配置文件

server.port=7001

eureka.instance.hostname=localhost
#是否把该服务注册到eureka服务上
eureka.client.register-with-eureka=false
#是否该服务从注册中心eureka上拉取服务
eureka.client.fetch-registry=false

#微服务访问eureka访问的地址
eureka.client.service-url.defaultZone=http://localhost:7001/eureka/

security.basic.enabled=false

(3)主启动

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

其他微服务可以注册到eureka

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

修改配置文件

eureka.client.service-url.defaultZone=http://localhost:7001/eureka/

7.nacos注册中心集群的搭建

要想搭建nacos集群模式，这些集群中的每台nacos服务，都必须连接同一个数据库。因为我们的nacos都放在同一台主机上，所以我们必须为每台nacos起不同的端口。

（1）修改端口号 8849 8850 8851

/conf/application.properties