微服务概述

目录

服务架构

单体架构

分布式架构 

微服务

 SpringClound微服务

​编辑 总结

服务拆分和远程调用 

服务拆分原则 

 服务拆分例子

准备两个数据库，给两个独立的模块（服务）准备一个数据库

准备一个父工程管理依赖，两个子工程

order-service的application.yml文件

user-service的application.yml文件

在order-service工程中使用restTemplate调用user-service工程的接口

提供者与消费者

 Eureka注册中心

Eureka的结构和作用 

搭建eureka 

搭建eureka-server 

1.首先大家注册中心服务端：eureka-server，这必须是一个独立的微服务 

2.导入eureka依赖

 3.编写配置类，并使用@EnableEurekaServer，开启eureka服务端

4.编写application.yml配置文件

5.启动访问

注册eureka客户端

 1.引入依赖

2.在application.yml文件中编写eureka服务端地址进行连接，并给这个服务起一个名字

 3.启动eureka服务端和两个子工程的服务

4.启动多个user-service实例，搭建集群 

在order-service工程下使用eureka根据微服务的名字来获取 user-service的ip地址和端口号

1.使用@LoadBalanced注解，让restTemplate开启微服务负载均衡

2.直接使用user-service服务的名字代替ip地址和端口号

3.在user-service子工程中添加端口号标识，来确定访问了哪个user-service(有两个端口号不同的服务)

4.测试

Ribbon负载均衡 

负载均衡原理 

 负载均衡策略

 自定义负载均衡策略

第一种：代码实现，重新维护一个IRule类型的bean,覆盖默认的IRule

饥饿加载

服务架构

单体架构

将业务的所有功能集中在一个项目中开发，打成一个包部署。

单体架构的优缺点如下：

优点：

• 架构简单
• 部署成本低

缺点：

• 耦合度高（维护困难、升级困难）

分布式架构 

根据业务功能对系统做拆分，每个业务功能模块作为独立项目开发，称为一个服务。 

分布式架构的优缺点：

优点：

• 降低服务耦合
• 有利于服务升级和拓展

缺点：

• 服务调用关系错综复杂

分布式架构虽然降低了服务耦合，但是服务拆分时也有很多问题需要思考：

• 服务拆分的粒度如何界定？
• 服务之间如何调用？
• 服务的调用关系如何管理？

人们需要制定一套行之有效的标准来约束分布式架构。

微服务

微服务是一种经过良好架构设计的分布式架构方案 。 

微服务的架构特征：

• 单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责
• 自治：团队独立、技术独立、数据独立，独立部署和交付
• 面向服务：服务提供统一标准的接口，与语言和技术无关
• 隔离性强：服务调用做好隔离、容错、降级，避免出现级联问题

 SpringClound微服务

SpringCloud是目前国内使用最广泛的微服务框架。官网地址：https://spring.io/projects/spring-cloud。

SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验。

注意：SpringCloud底层是依赖于SpringBoot的，并且有版本的兼容关系，如下： 

 总结

• 单体架构：简单方便，高度耦合，扩展性差，适合小型项目。例如：学生管理系统

• 分布式架构：松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目，例如：京东、淘宝

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

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

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

• SpringCloud是微服务架构的一站式解决方案，集成了各种优秀微服务功能组件

服务拆分和远程调用 

任何分布式架构都离不开服务的拆分，微服务也是一样。 

服务拆分原则 

• 不同微服务，不要重复开发相同业务
• 微服务数据独立，不要访问其它微服务的数据库
• 微服务可以将自己的业务暴露为接口，供其它微服务调用

 服务拆分例子

准备两个数据库，给两个独立的模块（服务）准备一个数据库

准备一个父工程管理依赖，两个子工程

cloud-demo：父工程，管理依赖

• order-service：订单微服务，负责订单相关业务
• user-service：用户微服务，负责用户相关业务

 父工程pom.xml文件，注意父工程使用pom方式打包，并导入springboot的父工程

<?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>cn.itcast.demo</groupId>
    <artifactId>cloud-demo</artifactId>
    <version>1.0</version>
    <modules>
        <module>user-service</module>
        <module>order-service</module>
    </modules>

    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.9.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR10</spring-cloud.version>
        <mysql.version>5.1.47</mysql.version>
        <mybatis.version>2.1.1</mybatis.version>
        <mybatisplus.version>3.4.2</mybatisplus.version>
    </properties>

    <dependencyManagement>
        <dependencies>
             <!-- springCloud的父工程，管理依赖 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- mysql驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!--mybatis-->
           <!-- <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.version}</version>
            </dependency>-->
            <!--mybatisplus起步依赖-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatisplus.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

子工程pom.xml文件，在<parent>中导入父工程的依赖管理

<?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>cloud-demo</artifactId>
        <groupId>cn.itcast.demo</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>order-service</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>
        <!--&lt;!&ndash;mybatis&ndash;&gt;
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>-->
        <!--mybatisplus起步依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

order-service的application.yml文件

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://192.168.230.100:3306/cloud_order?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
    username: root
    password: 1234
    driver-class-name: com.mysql.jdbc.Driver
#mybatis:
#  type-aliases-package: cn.itcast.user.pojo
#  configuration:
#    map-underscore-to-camel-case: true
# 设置mp运行时行为
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: cn.itcast.user.pojo
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS

user-service的application.yml文件

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://192.168.230.100:3306/cloud_user??useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
    username: root
    password: 1234
    driver-class-name: com.mysql.jdbc.Driver
mybatis:
  type-aliases-package: cn.itcast.user.pojo
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS

在order-service工程中使用restTemplate调用user-service工程的接口

order-service就是服务消费者，user-service就是服务提供者

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);

        //2.使用restTemplate向user-service服务发送请求获取用户数据
        String url="http://localhost:8081/user/"+order.getUserId();
        User user = restTemplate.getForObject(url, User.class);
        order.setUser(user);
        // 4.返回
        return order;
    }
}

提供者与消费者

在服务调用关系中，会有两个不同的角色：

服务提供者：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）

服务消费者：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）

但是，服务提供者与服务消费者的角色并不是绝对的，而是相对于业务而言。

如果服务A调用了服务B，而服务B又调用了服务C，服务B的角色是什么？

• 对于A调用B的业务而言：A是服务消费者，B是服务提供者
• 对于B调用C的业务而言：B是服务消费者，C是服务提供者

因此，服务B既可以是服务提供者，也可以是服务消费者。

 Eureka注册中心

假如我们的服务提供者user-service部署了多个实例，如图： 

有以下几个问题：

• order-service在发起远程调用的时候，该如何得知user-service实例的ip地址和端口？
• 有多个user-service实例地址，order-service调用时该如何选择？
• order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

Eureka的结构和作用 

解决之前的问题。

问题1：order-service如何得知user-service实例地址？

获取地址信息的流程如下：

• user-service服务实例启动后，将自己的信息注册到eureka-server（Eureka服务端）。这个叫服务注册
• eureka-server保存服务名称到服务实例地址列表的映射关系
• order-service根据服务名称，拉取实例地址列表。这个叫服务发现或服务拉取

问题2：order-service如何从多个user-service实例中选择具体的实例？

• order-service从实例列表中利用负载均衡算法选中一个实例地址
• 向该实例地址发起远程调用

问题3：order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

• user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己状态，称为心跳
• 当超过一定时间没有发送心跳时，eureka-server会认为微服务实例故障，将该实例从服务列表中剔除
• order-service拉取服务时，就能将故障实例排除了

注意：一个微服务，既可以是服务提供者，又可以是服务消费者，因此eureka将服务注册、服务发现等功能统一封装到了eureka-client端

注意：只有将当前服务注册到eureka服务端，才可以来去其他服务的实例地址

搭建eureka 

搭建eureka-server 

1.首先大家注册中心服务端：eureka-server，这必须是一个独立的微服务 

2.导入eureka依赖

<?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>
    <parent>
        <groupId>cn.itcast.demo</groupId>
        <artifactId>cloud-demo</artifactId>
        <version>1.0</version>
    </parent>

    <groupId>org.example</groupId>
    <artifactId>eureka-server</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
<!--        导入eureka依赖，因为cloud-demo父工程管理的spring-cloud各种组件的依赖，所以不用指定版本号-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

</project>

 3.编写配置类，并使用@EnableEurekaServer，开启eureka服务端

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

4.编写application.yml配置文件

server:
  port: 10086
spring:
  application:
    name: eureka-server #配置这个服务的名字
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka #默认的注册地址

5.启动访问

注册eureka客户端

 1.引入依赖

在user-service的pom文件中，引入下面的eureka-client依赖：

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

2.在application.yml文件中编写eureka服务端地址进行连接，并给这个服务起一个名字

在user-service中，修改application.yml文件，添加服务名称、eureka地址：

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://192.168.230.130:3306/cloud_user??useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
    username: root
    password: 1234
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: user-service
#mybatis:
#  type-aliases-package: cn.itcast.user.pojo
#  configuration:
#    map-underscore-to-camel-case: true
# 设置mp运行时行为
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: cn.itcast.user.pojo
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
eureka:
  client:
    service-url: #eureka的服务端地址
      defaultZone: http://127.0.0.1:10086/eureka

 3.启动eureka服务端和两个子工程的服务

4.启动多个user-service实例，搭建集群 

设置端口号

启动之后user-service服务变成2个

在order-service工程下使用eureka根据微服务的名字来获取 user-service的ip地址和端口号

1.使用@LoadBalanced注解，让restTemplate开启微服务负载均衡

    //配置restTemplate bean
    @Bean
    @LoadBalanced//让restTemplate开启微服务负载均衡
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

2.直接使用user-service服务的名字代替ip地址和端口号

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);

        //2.使用restTemplate向user-service服务发送请求获取用户数据
//        String url="http://localhost:8081/user/"+order.getUserId();
        String url="http://user-service/user/"+order.getUserId();
        User user = restTemplate.getForObject(url, User.class);
        order.setUser(user);
        // 4.返回
        return order;
    }
}

3.在user-service子工程中添加端口号标识，来确定访问了哪个user-service(有两个端口号不同的服务)

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;
    @Value("${server.port}")
    private Integer port;

    public User queryById(Long id) {
        User user= userMapper.findById(id);
        user.setUsername(user.getUsername()+port);
        return user;
    }
}

4.测试

可以发现eureka默认的负载均衡默认策略是轮询模式 

Ribbon负载均衡 

我们添加了@LoadBalanced注解，即可实现负载均衡功能，这是什么原理呢？ 

负载均衡原理 

SpringCloud底层其实是利用了一个名为Ribbon的组件，来实现负载均衡功能的。 

 SpringCloudRibbon的底层采用了一个拦截器LoadBalancerIntercepor，拦截了RestTemplate发出的请求，对地址做了修改。用一幅图来总结一下：

基本流程如下：

• 拦截我们的RestTemplate请求http://userservice/user/1
• RibbonLoadBalancerClient会从请求url中获取服务名称，也就是user-service
• DynamicServerListLoadBalancer根据user-service到eureka拉取服务列表
• eureka返回列表，localhost:8081、localhost:8082
• IRule利用内置负载均衡规则，从列表中选择一个，例如localhost:8081
• RibbonLoadBalancerClient修改请求地址，用localhost:8081替代userservice，得到http://localhost:8081/user/1，发起真实请求

 负载均衡策略

负载均衡的规则都定义在IRule接口中，而IRule有很多不同的实现类： 

不同规则的含义如下：

默认的实现就是ZoneAvoidanceRule，是一种轮询方案

 自定义负载均衡策略

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

第一种：代码实现，重新维护一个IRule类型的bean,覆盖默认的IRule

   //自定义一个负载均衡Rule bean覆盖默认的负载均衡Rule
    @Bean
    public IRule randomRule(){
        return new RandomRule();
    }

 第二种：配置文件方式：在order-service的application.yml文件中，直接修改IRule的配置

user-service: # 给某个微服务配置负载均衡规则，这里是user-service服务
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则 

饥饿加载

Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，采取eureka下拉取指定服务的ip端口，第一次请求时间会很长。

而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，但是启动项目的时间会比较长,通过下面配置开启饥饿加载：

ribbon:
  eager-load:
    enabled: true
    clients: user-service # 指定对哪个微服务进行饥饿加载