SpringBoot学习3

15、Swagger

15.1、Swagger简介

前后端分离：

• 前端 -> 前端控制层、视图层；
• 后端 -> 后端控制层、服务层、数据访问层；
• 前后端通过API进行交互；
• 前后端相对独立且松耦合。

产生的问题：

• 前后端集成，前端或者后端无法做到 “及时协商，尽早解决” ，最终导致问题集中爆发。

解决方案：

• 首先定义schema [ 计划的提纲 ]，并实时跟踪最新的API，降低集成风险。

Swagger：

• 号称世界上最流行的API框架；
• Restful Api 文档在线自动生成器 => API 文档 与 API 定义同步更新；
• 直接运行，在线测试API；
• 支持多种语言 （如：Java，PHP等）；
• 官网：https://swagger.io/。

15.2、SpringBoot集成Swagger

要求：jdk1.8+，否则 swagger2 无法运行。

SpringBoot 中使用 swagger 需要 springbox ，需要导入两个包：

• swaggwe2
• swagger-ui

使用步骤：

1. 新建一个 SpringBoot-web 项目：swagger-study.

2. 添加 Maven 依赖：

<dependency>
    <groupId>io.springfoxgroupId>
    <artifactId>springfox-swagger2artifactId>
    <version>2.9.2version>
dependency>


<dependency>
    <groupId>io.springfoxgroupId>
    <artifactId>springfox-swagger-uiartifactId>
    <version>2.9.2version>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13

3. 要使用 Swagger ，我们需要编写一个配置类 SwaggerConfig 来配置 Swagger ：

@Configuration
@EnableSwagger2   //开启Swagger2
public class SwaggerConfig {
  
}
1
2
3
4
5

4. 访问测试 ：http://localhost:8080/swagger-ui.html ，可以看到 swagger 的界面：

15.3、配置Swagger信息

1. Swagger实例Bean是Docket，所以通过配置Docket实例来配置Swaggger。在 SwaggerConfig 中添加代码：

//配置了Swagger的Docket的bean实例。
@Bean
public Docket docket(){
    return new Docket(DocumentationType.SWAGGER_2);
}
1
2
3
4
5

2. 可以通过 apiInfo() 属性配置文档信息。在 SwaggerConfig 中添加 apiInfo() 方法：

//配置Swagger信息=apiInfo
private ApiInfo apiInfo(){
    //作者信息 ("联系人名字", "联系人访问链接", "联系人邮箱")
    Contact contact = new Contact("kuang", "https://blog.csdn.net/m0_56064238?type=blog", "717560396@qq.com");
    return new ApiInfo(
            "Swagger学习文档！",   // 标题
            "即使再小的帆也能远航！",   // 描述
            "v：1.0",    // 版本
            "https://blog.csdn.net/m0_56064238?type=blog",   // 组织链接
             contact,   //作者信息
            "Apache 2.0",   // 许可
            "http://www.apache.org/licenses/LICENSE-2.0",    // 许可连接
            new ArrayList());   // 扩展
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. Docket 实例关联上 apiInfo()：

@Bean
public Docket docket() {
   return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo());
}
1
2
3
4

4. 重启项目，进行测试，访问 http://localhost:8080/swagger-ui.html ，发现信息变成了我们设置的信息！

15.4、配置扫描接口

构建 Docket 时通过 select() 方法配置怎么扫描接口。

我们这里通过 .apis() 配置根据包的路径扫描接口，除了通过包路径配置扫描接口外，还可以通过配置其他方式扫描接口。

我们还可以通过 .paths() 配置接口扫描过滤。

@Bean
public Docket docket(Environment environment){
    return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                /*
                    RequestHandlerSelectors：配置要扫描接口的方式。
                    basePackage：指定要扫描的包
                    any：扫描全部
                    none：不扫描
                    withClassAnnotation：扫描类上的注解，参数是一个注解的反射对象
                    withMethodAnnotation：扫描方法上的注解
                 */
                .apis(RequestHandlerSelectors.basePackage("com.kuang.controller"))
                /*
                    path：不过滤什么路径
                    any()：任何请求都扫描
                    none()：任何请求都不扫描
                    regex(final String pathRegex)：通过正则表达式控制
                    ant(final String antPattern)：通过ant()控制
                 */
                //.paths(PathSelectors.ant("/kuang/**"))
                .build();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

重启项目进行测试，由于我们配置根据包的路径扫描接口，所以我们只能看到一个类！

15.5、配置Swagger开关

1. 通过 enable() 方法配置是否启用 swagger，如果是 false，swagger 将不能在浏览器中访问了!

2. 问题：如何动态配置当项目处于 test、dev 环境时显示 swagger，而处于 prod 时不显示？

   修改 docket() 方法的代码：

@Bean
public Docket docket(Environment environment){

    //设置要现实的swagger环境。
    Profiles profiles = Profiles.of("dev", "test");
    //获取项目的环境。
    boolean flag = environment.acceptsProfiles(profiles);

    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo())
            //enable是否启动swagger，如果为false，则swagger不能在浏览器中访问。
            .enable(flag)
            .select()
            .apis(RequestHandlerSelectors.basePackage("com.kuang.controller")) 
            .build();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3. 我们新建一个 application-dev.properties 和一个 application-pro.properties 文件，并在 application.properties 配置文件中指定使用 dev 环境：

spring.profiles.active=dev
1

4. 重启项目，进行测试，可以看到页面；如果我们改成 pro 环境 ，再次测试，无法进入页面。测试成功！

15.6、配置API分组

1. 如果没有配置分组，默认是 default。通过 groupName() 方法即可配置分组：

@Bean
public Docket docket(Environment environment){
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo())
            .groupName("kuangshen")
            //......
}
1
2
3
4
5
6
7

2. 如何配置多个分组？配置多个分组只需要配置多个 docket 即可：

@Bean
public Docket docket1(){
    return new Docket(DocumentationType.SWAGGER_2).groupName("A");
}

@Bean
public Docket docket2(){
    return new Docket(DocumentationType.SWAGGER_2).groupName("B");
}

@Bean
public Docket docket3(){
    return new Docket(DocumentationType.SWAGGER_2).groupName("C");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. 重启项目，查看分组：

15.7、配置实体

1. 新建一个 User 实体类：

package com.kuang.pojo;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

//@Api("注释")
@ApiModel("用户实体类")
public class User {

    @ApiModelProperty("用户名")
    public String username;
    @ApiModelProperty("密码")
    public String password;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2. 只要这个实体在请求接口的返回值上（即使是泛型），都能映射到实体项中。

   新建一个 HelloController ，编写对应的 controller ：

@RestController
public class HelloController {
  
    //只要我们的接口中，返回值中存在实体类，他就会被扫描到swagger中。
    @PostMapping(value = "/user")
    public User user(){
        return new User();
    }
  
}
1
2
3
4
5
6
7
8
9
10

3. 重启项目，进行测试，查看结果：

**注意：**并不是因为 @ApiModel 这个注解让实体显示在这里了，而是只要出现在接口方法的返回值上的实体都会显示在这里，而 @ApiModel 和 @ApiModelProperty 这两个注解只是为实体添加注释的。

• @ApiModel 为类添加注释。

• @ApiModelProperty 为类属性添加注释。

15.8、配置接口注释

Swagger 的所有注解定义在 io.swagger.annotations 包下。

下面列一些经常用到的，未列举出来的可以另行查阅说明：

我们也可以给请求的接口配置一些注释。在 HelloController 中添加代码：

//Operation接口，不是放在类上的，是方法上。
@ApiOperation("Hello控制方法")
@GetMapping(value = "/hello2")
public String hello2(@ApiParam("用户名") String username){
    return "hello,swagger!"+username;
}

@ApiOperation("Post测试方法")
@PostMapping(value = "/postt")
public User postt(@ApiParam("用户名") User user){
    //制造500错误:
    //int a = 3/0;
    return user;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行项目，查看结果：

我们还可以对每个接口进行测试，点击 Try it out ，输入测试的参数，点击 Execute ，可以查看测试结果！

这样的话，可以给一些比较难理解的属性或者接口，增加一些配置信息，让人更容易阅读！

相较于传统的 Postman 或 Curl 方式测试接口，使用 swagger 简直就是傻瓜式操作，不需要额外说明文档(写得好本身就是文档)而且更不容易出错，只需要录入数据然后点击 Execute ，如果再配合自动化框架，可以说基本就不需要人为操作了。

Swagger是个优秀的工具，现在国内已经有很多的中小型互联网公司都在使用它，相较于传统的要先出Word接口文档再测试的方式，显然这样也更符合现在的快速迭代开发行情。当然了，提醒下大家在正式环境要记得关闭Swagger，一来出于安全考虑二来也可以节省运行时内存。

---

总结：

1. 我们可以通过 Swagger 给一些难理解的属性和接口添加注释信息。
2. 接口文档实时更新。
3. 可以在线测试。

16、异步、定时、邮件任务

16.1、异步任务

异步处理还是非常常用的，比如我们在网站上发送邮件，后台会去发送邮件，此时前台会造成响应不动，直到邮件发送完毕，响应才会成功，所以我们一般会采用多线程的方式去处理这些任务。

1. 新建一个项目：springboot-09-test。

2. 创建一个 service 包，在这个包下创建一个类 AsyncService ，编写一个 hello() 方法，假装正在处理数据，使用线程设置一些延时，模拟同步等待的情况：

package com.kuang.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

    public void hello(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("数据正在处理。。。");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3. 新建 controller 包，在这个包下编写 AsyncController 类，编写一个 controller 测试一下：

package com.kuang.controller;

import com.kuang.service.AsyncService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AsyncController {

    @Autowired
    AsyncService asyncService;

    @RequestMapping("/hello")
    public String hello(){
        //停止3秒,转圈～
        asyncService.hello();
        return "OK!";
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4. 启动项目，进行测试，3秒后出现 "OK!"，这是同步等待的情况。

问题：我们如果想让用户直接得到消息，就在后台使用多线程的方式进行处理即可，但是每次都需要自己手动去编写多线程的实现的话，太麻烦了，我们只需要用一个简单的办法，在我们的方法上加一个简单的注解即可，如下：

5. 给 hello 方法添加 @Async 注解；

@Service
public class AsyncService {
    //告诉Spring这是一个异步的方法。
    @Async
    public void hello(){

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("数据正在处理。。。");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6. SpringBoot 就会自己开一个线程池，进行调用！但是要让这个注解生效，我们还需要在主程序上添加一个注解 @EnableAsync ，开启异步注解功能：

package com.kuang;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableAsync  //开启异步注解功能。
@SpringBootApplication
public class Springboot09TestApplication {

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7. 重启项目进行测试，网页瞬间显示 "OK!"，后台3秒后出现 "数据正在处理。。。" ，测试成功！

16.2、定时任务

项目开发中经常需要执行一些定时任务，比如需要在每天凌晨的时候，分析一次前一天的日志信息，Spring为我们提供了异步执行任务调度的方式，提供了两个接口:

• TaskExecutor 接口
• TaskScheduler 接口

两个注解：

• @EnableScheduling
• @Scheduled

测试步骤：

1. 在 service 包下创建一个 ScheduledService，编写一个 hello 方法，我们想让他定时处理。

2. 首先，我们需要给 hello 方法加上一个 @Scheduled(cron = "") 注解，里面填的是cron表达式：

package com.kuang.service;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class ScheduledService {

    //在一个特定的时间执行这个方法～ Timer
    //cron表达式：秒 分 时 日 月 星期几
    /*
    30 15 10 * * ?: 每天10点15分30秒执行一次。
    30 0/5 10，18 * * ?: 每天10点和18点，每隔五分钟，的第30秒执行一次。
    0 15 10 ？ * 1-6: 每个月的周一到周六10点15分执行一次。
     */
    @Scheduled(cron = "0/3 * * * * ?")
    public void hello(){
        System.out.println("hello,你被执行了～");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3. 然后，我们需要在主程序上增加 @EnableScheduling 开启定时任务功能：

package com.kuang;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableAsync  //开启异步注解功能。
@EnableScheduling  //开启定时功能的注解
@SpringBootApplication
public class Springboot09TestApplication {

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4. 启动项目，测试一下。我们填写的那个表达式的意思是，每三秒钟运行一次，查看结果，测试成功！

---

cron表达式：

接下来，我们来详细了解下 cron 表达式：

http://www.bejson.com/othertools/cron/

常用的表达式：

（1）0/2 * * * * ?   表示每2秒 执行任务
（1）0 0/2 * * * ?   表示每2分钟 执行任务
（1）0 0 2 1 * ?   表示在每月的1日的凌晨2点调整任务
（2）0 15 10 ? * MON-FRI   表示周一到周五每天上午10:15执行作业
（3）0 15 10 ? 6L 2002-2006   表示2002-2006年的每个月的最后一个星期五上午10:15执行作
（4）0 0 10,14,16 * * ?   每天上午10点，下午2点，4点
（5）0 0/30 9-17 * * ?   朝九晚五工作时间内每半小时
（6）0 0 12 ? * WED   表示每个星期三中午12点
（7）0 0 12 * * ?   每天中午12点触发
（8）0 15 10 ? * *   每天上午10:15触发
（9）0 15 10 * * ?     每天上午10:15触发
（10）0 15 10 * * ?   每天上午10:15触发
（11）0 15 10 * * ? 2005   2005年的每天上午10:15触发
（12）0 * 14 * * ?     在每天下午2点到下午2:59期间的每1分钟触发
（13）0 0/5 14 * * ?   在每天下午2点到下午2:55期间的每5分钟触发
（14）0 0/5 14,18 * * ?     在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
（15）0 0-5 14 * * ?   在每天下午2点到下午2:05期间的每1分钟触发
（16）0 10,44 14 ? 3 WED   每年三月的星期三的下午2:10和2:44触发
（17）0 15 10 ? * MON-FRI   周一至周五的上午10:15触发
（18）0 15 10 15 * ?   每月15日上午10:15触发
（19）0 15 10 L * ?   每月最后一日的上午10:15触发
（20）0 15 10 ? * 6L   每月的最后一个星期五上午10:15触发
（21）0 15 10 ? * 6L 2002-2005   2002年至2005年的每月的最后一个星期五上午10:15触发
（22）0 15 10 ? * 6#3   每月的第三个星期五上午10:15触发
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

16.3、邮件任务

邮件发送，在我们的日常开发中，也非常的多，Springboot也帮我们做了支持：

• 邮件发送需要引入 spring-boot-start-mail 依赖。
• SpringBoot 自动配置 MailSenderAutoConfiguration 。
• 定义 MailProperties 内容，配置在 application.yml 中。
• 自动装配 JavaMailSender 。
• 测试邮件发送。

测试：

1. 引入邮件发送的 pom 依赖：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-mailartifactId>
dependency>
1
2
3
4
5

点进去，看它引入的依赖，可以看到 jakarta.mail：

<dependency>
  <groupId>com.sun.mailgroupId>
  <artifactId>jakarta.mailartifactId>
  <version>1.6.4version>
  <scope>compilescope>
dependency>
1
2
3
4
5
6

2. 查看自动配置类：MailSenderAutoConfiguration

这个类中存在bean，JavaMailSenderImpl

然后我们去看下配置文件

@ConfigurationProperties(
   prefix = "spring.mail"
)
public class MailProperties {
   private static final Charset DEFAULT_CHARSET;
   private String host;
   private Integer port;
   private String username;
   private String password;
   private String protocol = "smtp";
   private Charset defaultEncoding;
   private Map<String, String> properties;
   private String jndiName;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. 我们编写配置文件 application.properties ：

spring.mail.username=717560396@qq.com
spring.mail.password=yayjlkfpbtgkbfdj
spring.mail.host=smtp.qq.com
# 开启加密验证
spring.mail.properties.mail.smtl.ssl.enable=true
1
2
3
4
5

**注意：**这里需要获取授权码：在QQ邮箱中的设置->账户->开启pop3和smtp服务：

这里我们会得到一个授权码，这个授权码就是刚才配置文件 application.properties 中的密码。

4. 打开测试类，测试邮件发送：

package com.kuang;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import java.io.File;

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)//不加这个东西运行不了。
public class Springboot09TestApplicationTests{

    @Autowired
    JavaMailSenderImpl mailSender;

    @Test
    public void contextLoads() {
        //一个简单的邮件。
        SimpleMailMessage mailMessage = new SimpleMailMessage();

        mailMessage.setSubject("邮件发送！");
        mailMessage.setText("邮件发送的练习！");
        mailMessage.setFrom("717560396@qq.com");
        mailMessage.setTo("717560396@qq.com");

        mailSender.send(mailMessage);
    }

    @Test
    public void contextLoads2() throws MessagingException {
        //一个复杂的邮件。
        MimeMessage mimeMessage = mailSender.createMimeMessage();

        //组装
        MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);//支持多文本
        helper.setSubject("邮件发送！plus");
        helper.setText("
邮件发送的练习！plus
",true);//支持html
        //附件
        helper.addAttachment("1.jpg",new File("/Users/wangcheng/IdeaProjects/springboot-09-test/src/main/resources/static/img/jide.jpg"));
        helper.addAttachment("2.jpg",new File("/Users/wangcheng/IdeaProjects/springboot-09-test/src/main/resources/static/img/jide.jpg"));
        helper.setTo("717560396@qq.com");
        helper.setFrom("717560396@qq.com");

        mailSender.send(mimeMessage);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

5. 查看邮箱，邮件接收成功！

之后，我们只需要使用 Thymeleaf 进行前后端结合即可开发自己网站邮件收发功能了！

**注意：**我一开始用的 springboot 2.7.2 版本运行不了，不知道为啥。后来换了 2.2.1 版本，在类和方法前面加上 public ，并在测试类上加上：@RunWith(SpringJUnit4ClassRunner.class)。然后就运行成功了！

17、Dubbo和Zookeeper集成

17.1、分布式理论

什么是分布式系统？

在《分布式系统原理与范型》一书中有如下定义：“分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统”。

分布式系统是由一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统。分布式系统的出现是为了用廉价的、普通的机器完成单个计算机无法完成的计算、存储任务。其目的是利用更多的机器，处理更多的数据。

分布式系统（distributed system）是建立在网络之上的软件系统。

首先需要明确的是，只有当单个节点的处理能力无法满足日益增长的计算、存储任务的时候，且硬件的提升（加内存、加磁盘、使用更好的CPU）高昂到得不偿失的时候，应用程序也不能进一步优化的时候，我们才需要考虑分布式系统。因为，分布式系统要解决的问题本身就是和单机系统一样的，而由于分布式系统多节点、通过网络通信的拓扑结构，会引入很多单机系统没有的问题，为了解决这些问题又会引入更多的机制、协议，带来更多的问题。

Dubbo文档

随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，急需一个治理系统确保架构有条不紊的演进。

在 Dubbo 的官网文档有这样一张图：

单一应用架构

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。

适用于小型网站，小型管理系统，将所有功能都部署到一个功能里，简单易用。

缺点：

1. 性能扩展比较难

2. 协同开发问题

3. 不利于升级维护

垂直应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的 Web 框架(MVC)是关键。

通过切分业务来实现各个模块独立部署，降低了维护和部署的难度，团队各司其职更易管理，性能扩展也更方便，更有针对性。

**缺点：**公用模块无法重复利用，开发性的浪费。

分布式服务架构

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的**分布式服务框架(RPC)**是关键。

流动计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心 (SOA) [ Service Oriented Architecture] 是关键。

17.2、什么是RPC

RPC【Remote Procedure Call】是指远程过程调用，是一种进程间通信方式，他是一种技术的思想，而不是规范。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。即程序员无论是调用本地的还是远程的函数，本质上编写的调用代码基本相同。

也就是说两台服务器 A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数/方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。为什么要用RPC呢？就是无法在一个进程内，甚至一个计算机内通过本地调用的方式完成的需求，比如不同的系统间的通讯，甚至不同的组织间的通讯，由于计算能力需要横向扩展，需要在多台机器组成的集群上部署应用。RPC就是要像调用本地的函数一样去调远程函数。

推荐阅读文章：https://www.jianshu.com/p/2accc2840a1b

RPC基本原理：

步骤解析：

RPC两个核心模块：通讯，序列化。

17.3、Dubbo

Apache Dubbo 是一款高性能、轻量级的开源 Java RPC 框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

dubbo官网： https://dubbo.apache.org/zh/index.html

1. 了解Dubbo的特性

2. 查看官方文档

dubbo基本概念：

服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。

服务消费者（Consumer）：调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

注册中心（Registry）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

监控中心（Monitor）：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

调用关系说明：

• 服务容器负责启动，加载，运行服务提供者。

• 服务提供者在启动时，向注册中心注册自己提供的服务。

• 服务消费者在启动时，向注册中心订阅自己所需的服务。

• 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

• 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

• 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

17.4、Dubbo及zookeeper安装

我用的 mac 系统安装的。

Dubbo 官方文档，推荐我们使用 Zookeeper 。

Zookeeper：注册中心。

ZooKeeper 是一个分布式的，开放源码的分布式应用程序协调服务，是 Google 的 Chubby 一个开源的实现，是 Hadoop 和 Hbase 的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。

Zookeeper 的安装：

1. 下载 zookeeper 的安装包并且解压，这里我们下载 3.4.14 版本。

下载地址：https://archive.apache.org/dist/zookeeper/

2. 下载完进入 conf 文件夹中，复制一份 zoo_sample.cfg 文件命名为 zoo.cfg 。(因为 zookeeper 启动是会自动去目录下寻找这个文件)

3. 创建一个 data 文件夹用于存储数据。

4. 打开刚才复制的 zoo.cfg ，配置 dataDir=临时数据存储的目录（这里写我们刚刚创建的 data 文件夹的路径）。

5. 启动：

进入bin文件夹： cd /Users/wangcheng/zookeeper-3.4.14/bin

启动服务：./zkServer.sh start

启动客户端：./zkCli.sh

6. 这时我们已经安装成功，测试一下：

ls / ：列出 zookeeper 根下保存的所有节点：

[zk: localhost:2181(CONNECTED) 0] ls /
[zookeeper]
1
2

create /kuangshen 123：创建一个 kuangshen 节点，值为123：

[zk: localhost:2181(CONNECTED) 3] create /kuangshen 123
Created /kuangshen
1
2

get /kuangshen：获取 /kuangshen 节点的值：

[zk: localhost:2181(CONNECTED) 4] get /kuangshen
123
cZxid = 0x36
ctime = Wed Aug 24 16:29:00 CST 2022
mZxid = 0x36
mtime = Wed Aug 24 16:29:00 CST 2022
pZxid = 0x36
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 3
numChildren = 0
1
2
3
4
5
6
7
8
9
10
11
12
13

我们再来查看一下节点:

[zk: localhost:2181(CONNECTED) 5] ls /
[kuangshen, dubbo, zookeeper]
1
2

17.5、dubbo-admin安装

我用的 mac 系统安装的。

dubbo 本身并不是一个服务软件。它其实就是一个 jar 包，能够帮你的 java 程序连接到 zookeeper ，并利用zookeeper 消费、提供服务。

但是为了让用户更好的管理监控众多的 dubbo 服务，官方提供了一个可视化的监控程序 dubbo-admin ，不过这个监控即使不装也不影响使用。

dubbo-admin 的安装：

1. 我们下载 dubbo-admin 的安装包并解压：

下载地址 ：https://github.com/apache/dubbo-admin/tree/master

2. 进入目录 dubbo-admin\src\main\resources \application.properties， 查看指定 zookeeper 的地址是否正确。

server.port=7001
spring.velocity.cache=false
spring.velocity.charset=UTF-8
spring.velocity.layout-url=/templates/default.vm
spring.messages.fallback-to-system-locale=false
spring.messages.basename=i18n/message
spring.root.password=root
spring.guest.password=guest

dubbo.registry.address=zookeeper://127.0.0.1:2181
1
2
3
4
5
6
7
8
9
10

3. 在项目目录下打包 dubbo-admin：

mvn clean package -Dmaven.test.skip=true
1

第一次打包的过程有点慢，需要耐心等待！直到成功！

打包成功后，执行 dubbo-admin\target 下的 dubbo-admin-0.0.1-SNAPSHOT.jar：

java -jar dubbo-admin-0.0.1-SNAPSHOT.jar
1

注意：zookeeper 的服务一定要打开！

（我这一步没有打包成功，直接用 IDEA 打开运行也可以访问。）

4. 执行完毕，访问 http://localhost:7001/ ，我们需要输入登录账户和密码，默认是 root - root 。

登录成功，查看界面：

17.6、SpringBoot+Dubbo+zookeeper实现

框架搭建

1. 启动 zookeeper ！

2. IDEA 创建一个空项目。

3. 创建一个 springboot 模块，实现服务提供者：provider-server ，选择 web 依赖即可。

4. 项目创建完毕，我们写一个服务，比如卖票的服务。

编写接口 TicketService ：

package com.kuang.service;

public interface TicketService {
    public String getTicket();
}
1
2
3
4
5

编写实现类 TicketServiceImpl ：

package com.kuang.service;

import org.apache.dubbo.config.annotation.Service;
import org.springframework.stereotype.Component;

public class TicketServiceImpl implements TicketService{
  
    @Override
    public String getTicket() {
        return "测试分布式！";
    }
  
}
1
2
3
4
5
6
7
8
9
10
11
12
13

5. 再创建一个 springboot 模块，实现服务消费者：consumer-server ， 选择web依赖即可。

6. 项目创建完毕，我们写一个服务，比如用户的服务。

编写服务 TicketService ：

package com.kuang.service;

import org.apache.dubbo.config.annotation.Reference;
import org.springframework.stereotype.Service;

public class UserService {

    public void buyTicket(){
        //想拿到provider-server提供的票，要去注册中心拿到服务。
    }

}
1
2
3
4
5
6
7
8
9
10
11
12

需求：现在我们的用户想使用买票的服务，这要怎么弄呢 ？

服务提供者

1. 将服务提供者注册到注册中心，我们需要整合 Dubbo 和 zookeeper ，需要导入相关的依赖：

<dependency>
    <groupId>org.apache.dubbogroupId>
    <artifactId>dubbo-spring-boot-starterartifactId>
    <version>2.7.3version>
dependency>


<dependency>
    <groupId>com.github.sgroschupfgroupId>
    <artifactId>zkclientartifactId>
    <version>0.1version>
dependency>


<dependency>
    <groupId>org.apache.curatorgroupId>
    <artifactId>curator-frameworkartifactId>
    <version>2.12.0version>
dependency>
<dependency>
    <groupId>org.apache.curatorgroupId>
    <artifactId>curator-recipesartifactId>
    <version>2.12.0version>
dependency>



<dependency>
    <groupId>org.apache.zookeepergroupId>
    <artifactId>zookeeperartifactId>
    <version>3.4.14version>
    
    <exclusions>
        <exclusion>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
        exclusion>
    exclusions>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

2. 在 springboot 配置文件中配置 dubbo 相关属性：

server.port=8001

# 服务应用名字
dubbo.application.name=provider-server
# 注册中心地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
# 哪些服务要被注册
dubbo.scan.base-packages=com.kuang.service
1
2
3
4
5
6
7
8

3. 在 TicketServiceImpl 中配置服务注解，发布服务。注意导包问题！

package com.kuang.service;

import org.apache.dubbo.config.annotation.Service;
import org.springframework.stereotype.Component;

//zookeeper：服务注册与发现

@Service   //可以被扫描，在项目已启动就自动注册到注册中心。（注意这里导dubbo的包）
@Component   //使用了Dubbo后尽量不要用Service注解。
public class TicketServiceImpl implements TicketService{

    @Override
    public String getTicket() {
        return "测试分布式！";
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

逻辑理解 ：应用启动起来，dubbo就会扫描指定的包下带有@component注解的服务，将它发布在指定的注册中心中！

服务消费者

1. 导入相关依赖，和上面的依赖一样。

2. 配置相关属性。

server.port=8002

# 消费者去哪里拿服务器需要暴露自己的名字。
dubbo.application.name=consumer-server
# 注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
1
2
3
4
5
6

3. 本来正常步骤是需要将服务提供者的接口打包，然后用pom文件导入。

   我们这里使用简单的方式，直接将服务的接口 TicketService 复制过来，路径必须和服务提供者相同。

4. 完善消费者的服务类 UserService：

package com.kuang.service;

import org.apache.dubbo.config.annotation.Reference;
import org.springframework.stereotype.Service;

@Service //放到容器中。（注意这里到spring的包）
public class UserService {

    //想拿到provider-server提供的票，要去注册中心拿到服务。
    @Reference   //引用，Pom坐标，可以定义路径相同的接口名。
    TicketService ticketService;

    public void buyTicket(){
        String ticket = ticketService.getTicket();
        System.out.println("拿到了票："+ticket);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5. 测试类编写；

package com.kuang;

import com.kuang.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class ConsumerServerApplicationTests {

    @Autowired
    UserService userService;

    @Test
    void contextLoads() {
        userService.buyTicket();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

启动测试

1. 开启 zookeeper。

2. 启动 dubbo-admin 实现监控。

3. 开启服务者。

4. 消费者消费测试，查看输出结果：

5. 查看监控中心 ：

测试成功 , 这就是 SpingBoot + dubbo + zookeeper 实现分布式开发的应用，其实就是一个服务拆分的思想！

聊一聊现在和未来

一、Spring
IOC AOP
IOC ：控制反转
约泡：
泡温泉，泡茶·。。。泡友
附近的人，打招呼。加微信，聊天，天天聊 —> 约泡
浴场(容器) :温泉，茶庄，泡友
直接进温泉，就有人和你——起了!

​ 原来我们都是自己一步步操作，现在交给容器了!我们需要什么就去拿就可以了！

​ AOP ：切面 (本质,动态代理)
​ 为了解决什么? 不影响业务本来的情况下，实现动态增加功能，大量应用在日志，事务…等等方面。

​ Spring是一个轻量级的Java开源框架， 容器。

​ 目的：解决企业开发的复杂性问题。

​ Spring是春天，觉得他是春天，也十分复杂，配置文件！

二、SpringBoot
SpringBoot 并不是新东西，就是Spring的升级版!
新一代 JavaEE 的开发标准，开箱即用! --> 拿过来就可以用!
它自动帮我们配置了非常多的东西，我们拿来即用!
特性:约定大于配置

​ 随着公司体系越来越大，用户越来越多!
​ 微服务架构 —> 新架构

​ 模块化，功能化!
​ 用户，支付，签到，娱乐，… ;
​ 人多余多: 一台服务器解决不了；再增加服务器!

​ 横向
假设A服务器占用98%资源，B服务器只占用了10% 。——负载均衡
​ 将原来的整体项目，分成模块化，用户就是一个单独的项目，签到也是一个单独的项目，项目和项目之前需 要通信，如何通信?
​ 用户非常多，而签到十分少！给用户多点服务器 ，给签到少点服务器! 这就是引入了分布式！

三、微服务架构问题?
分布式架构会遇到的四个核心问题?
1.这么多服务，客户端该如何去访问?入口在哪里？
2.这么多服务，服务之间如何进行通信?
3.这么多服务，如何治理呢?
4.服务挂了，怎么办?

四、解决方案:
SpringCloud，是一套生态，就是来解决以上分布式架构的4个问题。
想使用SpringCloud，必须要掌握SpringBoot，因为SpringCloud是基于SpringBoot。

   1. Spring Cloud NetFlix，出来了一套解决方案！一站式解决方案。我们都可以直接去这里拿?
      Api网关，zuu1组件
      Feign --> HttpClient ---> HTTP的通信方式，同步并阻塞
      服务注册与发现，Eureka
      熔断机制，Hystrix
1
2
3
4
5

​ 2018年年底，NetFlix宣布无限期停止维护。生态不再维护，就会脱节。

2. Apache Dubbo zookeeper, 第二套解决系统。
   API :没有！要么找第三方组件，要么自己实现。
   Dubbo是一个高性能的基于Java实现的RPC通信框架!
   服务注册与发现，zookeeper：动物园管理者(Hadoop , Hive)
   没有:借助了Hystrix

   不完善，Dubbo.

3. SpringCloud Alibaba 一站式解决方案

五、万变不离其宗，一通百通!
1.API网关，服务路由。
2.HTTP, RPC框架，异步调用。
3.服务注册与发现，高可用!
4.熔断机制，服务降级。

六、本质问题：网络是不可靠的

七、目前，又提出了一种方案：服务网格:下一代微服务标准，Server Mesh，代表解决方案: istio (你们未来可能需要掌握! )