微服务架构及nacos集群的搭建

2301_77560707

已于 2023-05-16 18:55:00 修改

阅读量683

点赞数

文章标签：架构微服务 java

于 2023-05-13 18:23:48 首次发布

本文链接：https://blog.csdn.net/2301_77560707/article/details/130650166

版权

1.微服务架构

（1）单体应用架构

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

优点和缺点

优点:

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

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

缺点:

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

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

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

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

5: 跨语言程度差

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

（2）微服务应用

微服务架构论文: Microservices

译文: 微服务译文理解_微服务架构翻译_发了个版的博客-CSDN博客

In short, the microservice architectural style [1] is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services, which may be written in different programming languages and use different data storage technologies.

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

解读微服务特点:

（1）微服务是一种项目架构思想(风格)

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

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

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

（5）服务粒度(围绕业务功能拆分)

（6）去中心化管理(去中心化"地治理技术、去中心化地管理数据)

（3）微服务架构的优势

        1.易于开发和维护

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

        2.单个微服务启动比较快

单个微服务代码量比较小，所以启动速度比较快

        3.局部修改容易部署

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

4.技术栈不受限

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

5.按需伸缩

在单体应用架构中，想要扩展某个某个模块不得不考虑其他的模块会不会受影响，而对于微服务来说，完全不是问题，不必考虑其他功能模块的情况

（4）微服务架构的缺点（挑战）

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

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

：分布式事务（seata ）

分布式锁怎么处理（redisson）

服务注册与发现（nacos）

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

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

（5）springCloud与微服务的关系

1. Springcloud为微服务思想提供了完美的解决方案

2. Springcloud是一些列框架的集合体（服务的注册与发现【注册中心】、服务间远程调用、服务降级、服务熔断、服务限流、分布式事务等)

一般我们说springc1oud 其实指的是Springc1oud-netflix，Springcloud并不是造轮子，只是把Netflix公司的组件做二次开发

（6）SpringBoot和SpringCloud的关系

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

SpringCloud是关注全局的微服务协调、整理、治理的框架，它将SpringBoot开发的单体整合并管理起来。

SpringBoot可以离开SpringCloud独立使用开发项目，但是SpringCloud离不开SpringBoot，属于依赖关系

2.创建一个微服务工程

2.1 创建一个父工程

src ：可以删除； package：打包方式 ---- pom

（1）导入依赖

<?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>org.example</groupId>
  <artifactId>spring_cloud</artifactId>
  <version>2.3.12.RELEASE</version>
  <modules>
    <module>spring_common01</module>
    <module>spring_product</module>
      <module>spring_order</module>
  </modules>
  <!-- 父工程那么它的打包方式必须为pom打包 -->
  <packaging>pom</packaging>
  <name>spring_cloud Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.12.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>
    <!-- 管理了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 公共模块

（1）导入依赖

<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(type = IdType.AUTO)
    private Integer pid;
    private String pname ;
    private BigDecimal pprice;
    private Integer stock;
}

Order实体类：

@Data
@TableName(value = "shop_order")
public class Order {
    @TableId(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商品微服务

（1）依赖

<dependencies>
    <dependency>
        <groupId>org.example</groupId>
        <artifactId>spring_common01</artifactId>
        <version>2.3.12.RELEASE</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>
    <!--nacos依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
</dependencies>
<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
</properties>

（2）配置文件

#设置端口号：8080-8089
server.port=8080
#数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db3
spring.datasource.username=root
spring.datasource.password=wenqing.

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

(3)主启动类

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

（4）dao层

@Mapper
public interface ProductDao extends BaseMapper<Product> {
}

（5）service层

@Service
public class ProductServiceImpl implements ProductService {
    @Autowired
    private ProductDao productDao;

    @Override
    public Product findByID(Integer id) {
        Product product = productDao.selectById(id);
        return product;
    }
}

（6）controller层

@RestController
public class ProductController {
    @Autowired
    private ProductService productService;
    @GetMapping("findID/{id}")
    public Product findProduct(@PathVariable Integer id){
        Product product = productService.findByID(id);
        return product;
    }

}

2.4 order订单微服务

（1）依赖

<?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>spring_cloud</artifactId>
        <groupId>org.example</groupId>
        <version>2.3.12.RELEASE</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring_order</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>spring_common01</artifactId>
            <version>2.3.12.RELEASE</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>
        <!--nacos依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--①openfeign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

    </dependencies>


    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

（2）配置

#端口号：8090-8099
server.port=8090
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db3
spring.datasource.username=root
spring.datasource.password=wenqing.

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

（3）启动类

package com.aaa;

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.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@MapperScan(basePackages = "com.aaa.dao")
@EnableFeignClients  // 开启oppenFeign注解类
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class, args);
    }

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

}

（4）controller


package com.aaa.controller;

import com.aaa.dao.OrderDao;
import com.aaa.pojo.Order;
import com.aaa.pojo.Product;
import com.aaa.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.websocket.server.PathParam;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;


/**
 * @program: spring_cloud
 * @author: 乔文庆
 * @create: 2023-05-12 19:29
 **/

@RestController
public class OrderController {
    @Autowired
    private OrderService orderService;

    @Autowired
    private RestTemplate restTemplate;

    //springCloud提供了一个工具类-DiscoveryClient，该类可以从注册中心nacos中拉取服务清单
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("save")
    public String saveOrder(Integer pid, Integer num) {
        Order order = new Order();
        //用户信息
        order.setUid(1);
        order.setUsername("乔");
        order.setNumber(num);

        //设置商品信息：远程调用商品微服务的接口，基于http协议远程进行调用
        //基于http调用方式  第一种：可以使用httpclient工具jar，封装自己的工具类
        //第二种：spring框架中提供了一个工具类---RestTemplate
        Product product = restTemplate.getForObject("http://localhost:8080/findID/" + pid, Product.class);
        if (product == null) {
            return "商品有误";
        } else if (num > product.getStock()) {
            return "库存不足";
        }

        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        Integer integer = orderService.saveOrder(order);
        return "下单成功";

    }
}

3.服务治理

思考：我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在很多问题：

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

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

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

解决办法：这时候就需要通过注册中心动态的实现服务治理。

什么是服务治理？

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

服务注册：在服务治理框架中，都会构建一个*注册中心*，每个服务单元向注册中心登记自己提供服务的详细信息。并在注册中心形成一张服务的*清单*，服务注册中心需要以*心跳30s 90s*的方式去监测清单中的服务是否可用，如果不可用，需要在服务清单中剔除不可用的服务。

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

3.1 常见的服务治理组件。

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

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

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

consul: 服务治理的组件

3.2 安装nacos治理组件

Releases · alibaba/nacos · GitHub

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

首次登录输入：账号：nacos 密码： nacos

3.3 微服务注册到注册中心

（1）引入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=qy163-product

---- 创建restTemplate 交给容器

------- 修改订单微服务的代码

@RestController
public class OrderController {
    @Autowired
    private OrderService orderService;

    @Autowired
    private RestTemplate restTemplate;

    //springCloud提供了一个工具类-DiscoveryClient，该类可以从注册中心nacos中拉取服务清单
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("save")
    public String saveOrder(Integer pid, Integer num) {
        Order order = new Order();
        //用户信息
        order.setUid(1);
        order.setUsername("乔文庆");
        order.setNumber(num);

        //返回类型事集合，后期可能事集群模式
        List<ServiceInstance> instances = discoveryClient.getInstances("qy163-product");
        ServiceInstance serviceInstance = instances.get(0);
        //geiUri()----拿到http协议+ip+端口号
        String path = serviceInstance.getUri().toString();

        //设置商品信息：远程调用商品微服务的接口，基于http协议远程进行调用
        //基于http调用方式  第一种：可以使用httpclient工具jar，封装自己的工具类
        //第二种：spring框架中提供了一个工具类---RestTemplate
        Product product = restTemplate.getForObject(path+"/findID/" + pid, Product.class);
        if (product == null) {
            return "商品有误";
        } else if (num > product.getStock()) {
            return "库存不足";
        }
        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        Integer integer = orderService.saveOrder(order);
        return "下单成功";
    }
}

4. 实现负载均衡

4.1 什么是负载均衡

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

（1）可以手动完成负载均衡。----修改Order调用方

4.2 使用ribbon完成负载均衡

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

什么是ribbon？

是 Netflix 发布的一个负载均衡器，有助于控制 HTTP 和 TCP 客户端行为。在 Springcloud中，nacos 一般配合 Ribbon 进行使用，Ribbon 提供了客户端负载均衡的功能，Ribbon 利用从 nacos 中读取到的服务信息，在调用服务节点提供的服务时，会合理(策略) 的进行负载。在Springcloud 中可以将注册中心和 Ribbon 配合使用，Ribbon 自动的从注册中心中获取服务提供者的列表信息，并基于内置的负载均衡算法，请求服务。

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

如何使用ribbon？

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

（2）修改controller层代码

ribbon内置的负载均衡策略

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

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

修改order的配置文件

5. 使用Openfeign完成远程调用

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

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

5.1什么是OpenFeign？

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

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

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

5.2 如何使用openfeign

(1) 依赖openfeign依赖

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

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

package com.aaa.fegin;

import com.aaa.pojo.Product;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

/**
 * @program: spring_cloud
 * @author: 乔文庆
 * @create: 2023-05-13 17:46
 **/
@FeignClient(value = "qy163-product") //value="服务提供者的名字"
public interface ProductFeign {
    //抽象方法必须和服务提供者的方法完全一样
    //url+@getMapping中的内容:  http://qy163-product/findID/
    @GetMapping("findID/{id}")
    public Product findProduct(@PathVariable Integer id);
}

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

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

@RestController
public class OrderController02 {
    @Autowired
    private OrderService orderService;
    @Autowired
    private RestTemplate restTemplate;
    @Autowired  // 注入productFeign 接口
    private ProductFeign productFeign;

    @GetMapping("save")
    public String saveOrder(Integer pid, Integer num) {
        Order order = new Order();
        //用户信息
        order.setUid(1);
        order.setUsername("乔文庆");
        order.setNumber(num);
       // Product product = restTemplate.getForObject("http://qy163-product/findID/" + pid, Product.class);
        //springcloud扫描到@FeignClient注解后，就会为该注解接口自动生成一个代理实现类，再吧代理实现类注册该相应的属性
        Product product = productFeign.findProduct(pid);

        if (product == null) {
            return "商品有误";
        } else if (num > product.getStock()) {
            return "库存不足";
        }
        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        Integer integer = orderService.saveOrder(order);
        return "下单成功";

    }
}

总结：

2301_77560707

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
微服务架构及nacos集群的搭建

将项目所有模块(功能)打成jar或者war，然后部署一个进程优点:1:部署简单:由于是完整的结构体，可以直接部署在一个服务器上即可。2:技术单一:项目不需要复杂的技术栈，往往一套熟悉的技术栈就可以完成开发。缺点:1:系统启动慢，一个进程包含了所有的业务逻辑，涉及到的启动模块过多，导致系统的启动、重启时间周期过长;2:系统错误隔离性差、可用性差，任何一个约块的错误均可能造成整个系统的宕机;3:可伸缩性差:系统的扩容只能只对这个应用进行扩容，无法结合业务模块的特点进行伸缩。
复制链接

扫一扫