狂神。SpringBoot学习（3）

最新推荐文章于 2024-09-15 15:47:09 发布
最新推荐文章于 2024-09-15 15:47:09 发布
阅读量544 收藏 2
点赞数
分类专栏： Java学习 文章标签： spring boot java 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56064238/article/details/126518588
版权

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 依赖：

<!--swagger2-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>

<!--swagger-ui-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>
  1. 要使用 Swagger ，我们需要编写一个配置类 SwaggerConfig 来配置 Swagger ：
@Configuration
@EnableSwagger2   //开启Swagger2
public class SwaggerConfig {
  
}
  1. 访问测试 ：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. 可以通过 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. Docket 实例关联上 apiInfo()：
@Bean
public Docket docket() {
   return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo());
}
  1. 重启项目，进行测试，访问 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();
}

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

在这里插入图片描述

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. 我们新建一个 application-dev.properties 和一个 application-pro.properties 文件，并在 application.properties 配置文件中指定使用 dev 环境：
spring.profiles.active=dev
  1. 重启项目，进行测试，可以看到页面；如果我们改成 pro 环境 ，再次测试，无法进入页面。测试成功！

15.6、配置API分组

在这里插入图片描述

  1. 如果没有配置分组，默认是 default。通过 groupName() 方法即可配置分组：
@Bean
public Docket docket(Environment environment){
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo())
            .groupName("kuangshen")
            //......
}
  1. 如何配置多个分组？配置多个分组只需要配置多个 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. 重启项目，查看分组：

在这里插入图片描述

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. 只要这个实体在请求接口的返回值上（即使是泛型），都能映射到实体项中。

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

@RestController
public class HelloController {
  
    //只要我们的接口中，返回值中存在实体类，他就会被扫描到swagger中。
    @PostMapping(value = "/user")
    public User user(){
        return new User();
    }
  
}
  1. 重启项目，进行测试，查看结果：

在这里插入图片描述

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

  • @ApiModel 为类添加注释。

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

15.8、配置接口注释

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

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

Swagger注解简单说明
@Api(tags = “xxx模块说明”)作用在模块类上
@ApiOperation(“xxx接口说明”)作用在接口方法上
@ApiModel(“xxxPOJO说明”)作用在模型类上：如VO、BO
@ApiModelProperty(value = “xxx属性说明”,hidden = true)作用在类方法和属性上，hidden设置为true可以隐藏该属性
@ApiParam(“xxx参数说明”)作用在参数、方法和字段上，类似@ApiModelProperty

我们也可以给请求的接口配置一些注释。在 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;
}

运行项目，查看结果：

在这里插入图片描述

我们还可以对每个接口进行测试，点击 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. 新建 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. 启动项目，进行测试，3秒后出现 "OK!"，这是同步等待的情况。

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

  1. 给 hello 方法添加 @Async 注解；
@Service
public class AsyncService {
    //告诉Spring这是一个异步的方法。
    @Async
    public void hello(){

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

        System.out.println("数据正在处理。。。");
    }
}
  1. 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. 重启项目进行测试，网页瞬间显示 "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. 然后，我们需要在主程序上增加 @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. 启动项目，测试一下。我们填写的那个表达式的意思是，每三秒钟运行一次，查看结果，测试成功！

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触发

16.3、邮件任务

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

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

测试：

  1. 引入邮件发送的 pom 依赖：
<!--邮件发送-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

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

<dependency>
  <groupId>com.sun.mail</groupId>
  <artifactId>jakarta.mail</artifactId>
  <version>1.6.4</version>
  <scope>compile</scope>
</dependency>
  1. 查看自动配置类：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. 我们编写配置文件 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

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

在这里插入图片描述

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

  1. 打开测试类，测试邮件发送：
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("<p style='color:red'>邮件发送的练习！plus</p>",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. 查看邮箱，邮件接收成功！

之后，我们只需要使用 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/

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

在这里插入图片描述

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

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

在这里插入图片描述

  1. 启动：

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

启动服务：./zkServer.sh start

在这里插入图片描述

启动客户端：./zkCli.sh

在这里插入图片描述

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

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

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

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

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

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

我们再来查看一下节点:

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

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

  1. 进入目录 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. 在项目目录下打包 dubbo-admin：
mvn clean package -Dmaven.test.skip=true

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

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

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

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

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

  1. 执行完毕，访问 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();
}

编写实现类 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. 再创建一个 springboot 模块，实现服务消费者：consumer-server ， 选择web依赖即可。

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

编写服务 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. 将服务提供者注册到注册中心，我们需要整合 Dubbo 和 zookeeper ，需要导入相关的依赖：
<!--Dubbo-->
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.7.3</version>
</dependency>

<!--zkclient-->
<dependency>
    <groupId>com.github.sgroschupf</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.1</version>
</dependency>

<!--curator-->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>2.12.0</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>2.12.0</version>
</dependency>

<!-- 引入zookeeper -->
<!--解决日志冲突-->
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.14</version>
    <!--排除这个slf4j-log4j12-->
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>
  1. 在 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. 在 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 "测试分布式！";
    }

}

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

服务消费者

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

  2. 配置相关属性。

server.port=8002

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

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

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

  2. 完善消费者的服务类 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. 测试类编写；
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. 开启 zookeeper。

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

  3. 开启服务者。

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

在这里插入图片描述

  1. 查看监控中心 ：

在这里插入图片描述

测试成功 , 这就是 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

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

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

    不完善，Dubbo.

  2. SpringCloud Alibaba 一站式解决方案

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

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

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

狂神说——SpringBoot学习
weixin_44543307的博客
12-06 5149
Springboot 学习笔记Springboot简介什么是微服务？ThymeleafDuridSpringboot整合mybatisSpringSecurity安全Shiroswagger定时任务springboot 整合分布式 dubbo+ zookeeper+ springbootDubboRPC（两大核心：通讯，序列化）Zookeeper总结 学习源码 spring官网 springboot官网 spring-security版本下载 狂神官网学习 也可以搜索B站 （狂神说） Springboot简
狂神springboot静态资源.zip
10-07
标题“狂神springboot静态资源.zip”表明这是一个关于Spring Boot框架中处理静态资源的教程或示例集合。Spring Boot是Java开发中一个流行的微服务框架，它简化了配置，提供了快速构建可生产级应用的方式。在Spring ...
狂神SpringBoot学习笔记
qq_43608638的博客
04-20 547
springboot创建，原理,yaml赋值，多环境切换
狂神SpringBoot学习笔记系列学习
weixin_52613545的博客
08-03 263
狂神SpringBoot学习笔记系列学习！
狂神说SpringBoot学习笔记
记录学习的历程
04-04 3733
目录P1、SpringBoot：Hello,World！1.1、回顾什么是Spring1.2、Spring是如何简化Java开发的1.3、什么是SpringBoot1.4、准备工作1.5、创建基础项目说明1.6、pom.xml 分析1.7、编写一个http接口1.8、将项目打成jar包，点击 maven的 packageP2、SpringBoot：运行原理初探2.1、父依赖2.2、启动器 spring-boot-starter2.3、默认的主启动类2.4、@SpringBootApplication2.5、
狂神SpringBoot
qq_42938698的博客
11-29 331
学习
狂神SpringBoot学习笔记12天-Day 08 SpringBoot SpringSecurity(安全)
weixin_52613545的博客
08-02 1298
SpringBoot SpringSecurity（安全）
SpringBoot狂神说学习笔记
weixin_47955543的博客
09-14 950
SpringBoot学习笔记
狂神SpringBoot学习笔记12天-Day 06 基于SpringBoot的员工管理系统
weixin_52613545的博客
08-02 949
基于SpringBoot的员工管理系统！
SpringBoot学习笔记（上）-狂神说
qq_42760375的博客
07-17 563
一、二、三、
狂神-SpringBoot笔记目录
wang_luwei的博客
03-22 487
【笔记整理来源 B站狂神说https://www.bilibili.com/video/BV1PE411i7CV】 一、SpringBoot简介 二、微服务 三、第一个SpringBoot程序 四、SpringBoo原理初探【重点】 五、yaml语法学习 六、多环境切换 七、自动配置原理【重点】 八、SpringBoot Web 开发前准备 九、一个简单的员工管理系统 十、整合JDBC 十一、整合Druid 十二、整合MyBatis 十三、SpringSecurity（安全） 十四、项目集成Swagger
狂神SpringBoot源码--分享
04-30
《狂神SpringBoot源码深度解析与实践》 SpringBoot是由Pivotal团队开发的一款用于简化Spring应用初始搭建以及开发过程的框架。它基于Spring框架，致力于“开箱即用”和“零配置”，旨在让开发者能快速创建稳定、...
狂神springboot学习笔记.md
10-24
狂神springboot学习笔记.md
b站狂神SpringBoot员工管理系统源码
04-25
在这个"b站狂神SpringBoot员工管理系统"中，我们可以深入学习如何利用SpringBoot构建一个完整的业务系统。 首先，我们要理解SpringBoot的核心特性： 1. **自动配置**：SpringBoot通过`@EnableAutoConfiguration`...
狂神说springboot员工管理系统静态资源.zip
10-26
《狂神说springboot员工管理系统静态资源》是一个与Java开发相关的学习资料压缩包，主要针对Spring Boot框架在构建员工管理系统的应用。这个压缩包包含了该系统的一些关键静态资源，可以帮助学习者理解Spring Boot...
Spring Boot-版本兼容性问题
Flying_Fish_roe的博客
09-14 1335
Spring Boot 作为一个高度集成的框架，其版本兼容性涉及到多个方面，包括与 Spring Framework、JDK、第三方库、Spring Cloud 及开发工具之间的兼容性问题。在实际项目开发中，版本不兼容是常见问题，容易导致功能异常、编译错误甚至系统崩溃。尽量使用 Spring Boot 官方推荐的依赖版本，避免手动管理依赖版本。定期检查和升级项目中的依赖库，并在升级前充分测试。使用 Spring Boot 和 Spring Cloud 的 BOM 管理依赖，以确保版本兼容性。
Java项目实战II基于Spring Boot的民族婚纱预定系统
2401_86524610的博客
09-11 444
在全球化与多元文化交融的今天，民族特色婚纱正逐渐成为新人们追求个性与传承文化的热门选择。然而，传统的婚纱预定流程往往缺乏针对性与便捷性，难以满足新人们对民族婚纱独特性与定制化的需求。基于这一背景，我们设计并实现了一款基于Spring Boot的民族婚纱预定系统。本系统旨在通过现代化的信息技术手段，为新人们提供一个集浏览、选择、定制、预定及售后服务于一体的全方位平台。它不仅汇聚了丰富的民族婚纱款式与设计灵感，还通过智能化的推荐与定制功能，让新人们能够轻松找到心仪的婚纱，并享受个性化的定制体验。
Spring Boot母婴商城：育儿专家的推荐
最新发布
2401_85761762的博客
09-15 790
当前需要开发的程序软件是根据当下的用户需求进行设计开发的，但是随着时间的推移，社会大环境的改变，开发出的程序也是需要与时俱进的，需要根据用户不断变换的需求进行相应的功能内容的扩展，需要注意的就是，当对成型的程序进行功能模块新增时，仍然需要保证程序原有架构以及功能不能受到影响，新增的功能模块在系统中也能够运行正常，该指标达标也就可以保证此程序是可以在满足信息管理要求下，从容应对市场环境的变化。系统分析就是分析系统需要做什么的问题，主要目的就是确定系统的功能，这也为接下来的工作做了一个好的开端。
腾讯云Ubuntu系统安装宝塔，配置Java环境，运行spring boot项目
沧笙踏歌的博客
09-13 1015
进来以后，他会弹出一个窗口，“推荐安装套件”，我这里直接装的Java，忘记截图了系统操作显示当前服务器系统类型、服务器运行时间、面板版本、面板升级更新入口、并提供宝塔账号绑定、微信小程序绑定、服务器重启、面板重启、修复面板等快捷功能。服务器状态显示当前服务器CPU、内存、硬盘的使用率、内存清理，所有状态均取自服务器真实数据。内存的清理：点击内存图标中的小火箭图标，即可实现清理功能。站点信息显示当前面板管理的站点、FTP、数据库数量，仅提供数量显示，如需添加站点，请在网站选项中添加站点。
狂神springboot
08-29
- *1* *2* *3* [（全）SpringBoot学习笔记（狂神说java系列）](https://blog.csdn.net/qq_41978509/article/details/116104434)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值