Java在线笔记

YangeIT大约 14 分钟

今日目标

学习什么叫微服务，能说出它和单体的区别
能搭建微服务架构，并实现手动从0到1的过程
能够实现远程调用

1.认识微服务

随着互联网行业的发展，对服务的要求也越来越高，服务架构也从单体架构逐渐演变为现在流行的微服务架构。这些架构之间有怎样的差别呢？

前言

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

单体架构的优缺点如下：

优点：

架构简单
部署成本低

缺点：

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

1.2.分布式架构

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

分布式架构的优缺点：

优点：

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

缺点：

服务调用关系错综复杂

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

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

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

1.3.微服务

微服务的架构特征：

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

微服务的上述特性其实是在给分布式架构制定一个标准，进一步降低服务之间的耦合度，提供服务的独立性和灵活性。做到高内聚，低耦合。

因此，可以认为微服务是一种经过良好架构设计的分布式架构方案 。👈

但方案该怎么落地？选用什么样的技术栈？

全球的互联网公司都在积极尝试自己的微服务落地方案。

其中在Java领域最引人注目的就是SpringCloud提供的方案了。

1.4.SpringCloud

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

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

其中常见的组件包括：

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

我们课堂学习的版本是 2022.0.0.0-RC2，因此对应的SpringBoot版本是3.0.2版本。

总结

单体架构 ：简单方便，高度耦合，扩展性差，适合小型项目。例如：学生管理系统
分布式架构 ：松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目，例如：京东、淘宝
微服务：一种良好的分布式架构方案 ①优点：拆分粒度更小、服务更独立、耦合度更低 ②缺点：架构非常复杂，运维、监控、部署难度提高
SpringCloud是微服务架构的一站式解决方案，集成了各种优秀微服务功能组件

2.服务拆分和远程调用

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

前言

2.1.服务拆分原则

这里我总结了微服务拆分时的几个原则：

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

2.2.服务拆分示例 ✏️ ✏️

以课前资料中的微服务cloud-demo为例，其结构如下：

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

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

这里用到了Maven的高级特性，聚合和继承，把相同的依赖提取到父工程中，各个子模块不需要各自定义，减少重复，聚合解决了项目构建和部署的问题，继承可以减少配置。

要求： 👇

订单微服务和用户微服务都必须有各自的数据库，相互独立
订单服务和用户服务都对外暴露Restful的接口
订单服务如果需要查询用户信息，只能调用用户服务的Restful接口，不能查询用户数据库

2.2.1.导入Sql语句

首先，将课前资料提供的cloud-order.sql和cloud-user.sql导入到mysql中：

cloud-user表中初始数据如下：

cloud-order表中初始数据如下：

cloud-order表中持有cloud-user表中的id字段。

2.2.2.导入demo工程

用IDEA导入课前资料提供的Demo：

项目结构如下：

导入后，会在IDEA右下角出现弹窗：

点击弹窗，然后按下图选择：

会出现这样的菜单：

配置下项目使用的JDK：

2.3.实现远程调用案例

在order-service服务中，有一个根据id查询订单的接口：

根据id查询订单，返回值是Order对象，如图：

localhost:8080/order/101

其中的user为null

在user-service中有一个根据id查询用户的接口：

查询的结果如图：

2.3.1.案例需求：🚀

修改order-service中的根据id查询订单业务，要求在查询订单的同时，根据订单中包含的userId查询出用户信息，一起返回。

因此，我们需要在order-service中向user-service发起一个http的请求，调用http://localhost:8081/user/{userId}这个接口。

大概的步骤是这样的：

注册一个RestTemplate的实例到Spring容器
修改order-service服务中的OrderService类中的queryOrderById方法，根据Order对象中的userId查询User
将查询的User填充到Order对象，一起返回

RestTemplate是Spring提供的一个用于访问Rest服务的客户端模板工具集，操作非常简单！说白了，就是发送Http请求用的！ 👈

2.3.2.注册RestTemplate

首先，我们在order-service服务中的OrderApplication启动类中，注册RestTemplate实例：

package cn.zx.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;

@MapperScan("cn.zx.order.mapper")
@SpringBootApplication
public class OrderApplication {

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

//放在启动类中，让spring管理，注入到容器中
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

2.3.3.实现远程调用

修改order-service服务中的cn.zx.order.service包下的OrderService类中的queryOrderById方法：


@Service
public class OrderService {

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


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

        // 2.从订单中获取用户id   并使用restTemplate调用用户服务查询用户信息
        String url = "http://localhost:8081/user/" + order.getUserId();
        ResponseEntity<User> forEntity = restTemplate.getForEntity(url, User.class);
        User user = forEntity.getBody();

        //3.将用户信息封装到Order中
        order.setUser(user);

        // 4.返回
        return order;
    }
}

访问：http://localhost:8080/order/101open in new window

2.4.提供者与消费者

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

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

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

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

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

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

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

2.5.问题思考 🍐 🍐

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

大家思考几个问题： 👈

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

启动多个实例

3.启动服务实例

为了测试一个服务多个实例的情况，我们再配置一个 user-service 的部署实例：

在add VM options中配置：-Dserver.port=8083

然后配置启动项，注意重命名并且配置新的端口，避免冲突：

重启 user-service 的两个实例：

访问 nacos 控制台，可以发现服务注册成功：

这时候order-service找哪个尼？

3. Nacos注册中心

3.1.认识和安装Nacos ✏️

国内公司一般都推崇阿里巴巴的技术，比如注册中心，SpringCloudAlibaba也推出了一个名为Nacos的注册中心。

认识和安装Nacos

Nacosopen in new window是阿里巴巴的产品，现在是SpringCloudopen in new window中的一个组件。相比Eurekaopen in new window功能更加丰富，在国内受欢迎程度较高。

安装教程码操作

1.1.下载安装包

在Nacos的GitHub页面，提供有下载链接，可以下载编译好的Nacos服务端或者源代码：

主页：https://nacos.io/open in new window

本课程采用nacos-server-2.5.1.zip版本的Nacos，课前资料已经准备了安装包：

windows版本使用nacos-server-2.5.1.zip包即可。

1.2.解压

将这个包解压到任意非中文目录下，如图：

启动非常简单:命令：startup.cmd -m standalone

1.3.端口配置

Nacos的默认端口是8848，如果你电脑上的其它进程占用了8848端口，请先尝试关闭该进程。

如果无法关闭占用8848端口的进程，也可以进入nacos的conf目录，修改配置文件中的端口：

修改其中的内容：

1.4.访问

在浏览器输入地址：http://127.0.0.1:8848/nacosopen in new window

如果需要登录，默认的账号和密码都是nacos，进入后：

3.2.服务注册到Nacos

前言

接下来，我们把 user-service和order-service注册到 Nacos，🎯 步骤如下：

引入依赖
配置 Nacos 地址
重启

3.2.1.引入依赖

在cloud-demo父工程的pom文件中的<dependencyManagement>中引入SpringCloudAlibaba的依赖：（已导入）

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2022.0.0.0-RC2</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

然后在user-service和order-service中的pom文件中引入nacos-discovery依赖：

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

3.2.2.配置nacos地址

在user-service和order-service的application.yml中添加nacos地址：

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

3.2.3.配置服务名称

user-service服务application.yml配置spring.application.name

完整配置如下

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/cloud_user?autoReconnect=true&useServerPreparedStmts=false&rewriteBatchedStatements=true&characterEncoding=UTF-8&useSSL=false&allowMultiQueries=true&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  cloud:
    nacos:
      server-addr: localhost:8848
  application:
    name: user-service
mybatis:
  type-aliases-package: cn.zx.user.pojo
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.zx: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS

order-service服务application.yml配置spring.application.name

完整配置如下

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/cloud_order?autoReconnect=true&useServerPreparedStmts=false&rewriteBatchedStatements=true&characterEncoding=UTF-8&useSSL=false&allowMultiQueries=true&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  cloud:
    nacos:
      server-addr: localhost:8848
  application:
    name: order-service
mybatis:
  type-aliases-package: cn.zx.order.pojo
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.zx: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS

3.2.4.重启

重启微服务后，登录nacos管理页面，可以看到微服务信息：

可以发现，有3个服务已经注册到nacos了。其中order-service 1个，user-service 2个

4. Feign远程调用

前言

4.1 Feign引入

先来看我们以前利用RestTemplate发起远程调用的代码：

     // 2.从订单中获取用户id   并使用restTemplate调用用户服务查询用户信息
        String url = "http://localhost:8081/user/" + order.getUserId();
        ResponseEntity<User> forEntity = restTemplate.getForEntity(url, User.class);
        User user = forEntity.getBody();

但依然有下面的问题：

代码可读性差，编程体验不统一
参数复杂URL难以维护

Feign是一个声明式的http客户端，官方地址：https://github.com/OpenFeign/feignopen in new window

其作用就是帮助我们优雅的实现http请求的发送，解决上面提到的问题。

4.2 Feign替代RestTemplate

4.2.1.引入依赖

我们在order-service服务的pom文件中引入feign的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
    <version>4.0.4</version>
</dependency>
<!--负载均衡-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
    <version>4.0.4</version>
</dependency>

4.2.2.编写Feign的客户端

在order-service中新建一个接口，内容如下：

package cn.zx.order.feignclient;

import cn.zx.order.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient("user-service")//指定调用哪个服务
public interface UserClient {
    //指定调用哪个接口
    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long id);
}

//这里要注意：user-service的controller要提供一个和UserClient接口中方法签名一样的接口

这样，Feign就可以帮助我们发送http请求，无需自己使用RestTemplate来发送了。

4.2.3.添加注解

在order-service的启动类添加注解@EnableFeignClients开启Feign的功能：

package cn.zx.order;

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

@MapperScan("cn.zx.order.mapper")
@SpringBootApplication
@EnableFeignClients(basePackages = "cn.zx.order.feignclient")
public class OrderApplication {

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

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

4.2.4.测试

修改order-service中的OrderService类中的queryOrderById方法，使用Feign客户端代替RestTemplate：


@Service
public class OrderService {

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

    @Autowired
    private UserClient userClient;

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

        // 2.从订单中获取用户id   并使用restTemplate调用用户服务查询用户信息
//        String url = "http://localhost:8081/user/" + order.getUserId();
//        ResponseEntity<User> forEntity = restTemplate.getForEntity(url, User.class);
//        User user = forEntity.getBody();
        User user = userClient.findById(order.getUserId());
        //3.将用户信息封装到Order中
        order.setUser(user);

        // 4.返回
        return order;
    }
}

是不是看起来优雅多了。

然后启动2个user-service，1个order-service，调用order-service的接口，观察会不会报错??? 👈

4.2.5.优化

将Feign接口抽取到统一的模块中，这样可以降低服务之间的耦合性

4.2.6.小结

使用Feign的步骤：

引入依赖
添加@EnableFeignClients(basePackages = " ")注解
编写FeignClient接口
使用FeignClient中定义的方法代替RestTemplate

总结

今天的核心任务是认识微服务并能搭建微服务架构
难点是服务之间的调用，从restTemplate到Feign的演化，要明白其中的原因
今天所学SpringCloud组件有Nacos,Feign，一定要明确其作用

# 今日目标

# 1.认识微服务

# 1.2.分布式架构

# 1.3.微服务

# 1.4.SpringCloud

# 2.服务拆分和远程调用

# 2.1.服务拆分原则

# 2.2.服务拆分示例 ✏️ ✏️

# 2.2.1.导入Sql语句

# 2.2.2.导入demo工程

# 2.3.实现远程调用案例

# 2.3.1.案例需求：🚀

# 2.3.2.注册RestTemplate

# 2.3.3.实现远程调用

# 2.4.提供者与消费者

# 2.5.问题思考 🍐 🍐

# 3.启动服务实例

# 3. Nacos注册中心

# 3.1.认识和安装Nacos ✏️

# 3.2.服务注册到Nacos

# 3.2.1.引入依赖

# 3.2.2.配置nacos地址

# 3.2.3.配置服务名称

# 3.2.4.重启

# 4. Feign远程调用

# 4.1 Feign引入

# 4.2 Feign替代RestTemplate

# 4.2.1.引入依赖

# 4.2.2.编写Feign的客户端

# 4.2.3.添加注解

# 4.2.4.测试

# 4.2.5.优化

# 4.2.6.小结

# 总结