        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-boot-starter</artifactId>
            <version>3.0.0</version>
        </dependency>

3.编写HelloController，测试确保运行成功！

@RestController
public class HelloController {
    @RequestMapping(value = "/hello")
    public String hello(){
        return "hello";
    }
}

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

@Configuration //配置类
@EnableOpenApi// 3.0替代了Swagger2
public class SwaggerConfig {  
}

5.在主启动类上添加@EnableWebMvc

@SpringBootApplication
@EnableWebMvc
public class SwaggerDemoApplication {

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

}

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

3.配置Swagger

1.Swagger实例Bean是Docket，所以通过配置Docket实例来配置Swaggger。

@Bean //配置docket以配置Swagger具体参数
public Docket docket() {
   return new Docket(DocumentationType.SWAGGER_2);
}

2.可以通过apiInfo()属性配置文档信息

//配置文档信息
    private ApiInfo apiInfo() {
        Contact contact = new Contact("联系人名字", "http://xxx.xxx.com/联系人访问链接", "联系人邮箱");
        return new ApiInfo(
                "Swagger学习", // 标题
                "学习演示如何配置Swagger", // 描述
                "v1.0", // 版本
                "https://www.baidu.com/", // 组织链接
                contact, // 联系人信息
                "Apach 2.0 许可", // 许可
                "许可链接", // 许可连接
                new ArrayList<>()// 扩展
        );
    }

3.Docket 实例关联上 apiInfo()

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

4.重启项目，访问测试 http://localhost:8080/swagger-ui/index.html 看下效果；

4.配置扫描接口

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

@Bean //配置docket以配置Swagger具体参数
    public Docket docket() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()// 通过.select()方法，去配置扫描接口,RequestHandlerSelectors配置如何扫描接口
                .apis(RequestHandlerSelectors.basePackage("com.jiang.controller"))
                .build();
    }

2.重启项目测试，由于我们配置根据包的路径扫描接口，所以我们只能看到一个类
3.除了通过包路径配置扫描接口外，还可以通过配置其他方式扫描接口，这里注释一下所有的配置方式：

    //any()：扫描所有，项目中的所有接口都会被扫描到
    //none()：不扫描接口
    //withMethodAnnotation(final Class<? extends Annotation> annotation)：通过方法上的注解扫描，如withMethodAnnotation(GetMapping.class)只扫描get请求
    //withClassAnnotation(final Class<? extends Annotation> annotation)：通过类上的注解扫描，如.withClassAnnotation(Controller.class)只扫描有controller注解的类中的接口
    //basePackage：指定要扫描的包

4.除此之外，我们还可以配置接口扫描过滤：

@Bean //配置docket以配置Swagger具体参数
    public Docket docket() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()// 通过.select()方法，去配置扫描接口,RequestHandlerSelectors配置如何扫描接口
                .apis(RequestHandlerSelectors.basePackage("com.jiang.controller"))
                .paths(PathSelectors.ant("/jiang/**"))
                .build();
    }

5.这里的可选值还有

//any():任何请求都扫描
//none():任何请求都不扫描
//regex(final String pathRegex):通过正则表达式控制
//ant(final String antPattern):通过ant()控制 ant(加上指定路径)

5.配置Swagger开关

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

    @Bean //配置docket以配置Swagger具体参数
    public Docket docket() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                //配置是否启用Swagger，如果是false，在浏览器将无法访问
                .enable(false)
                // 通过.select()方法，去配置扫描接口,RequestHandlerSelectors配置如何扫描接口
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.jiang.controller"))
                .paths(PathSelectors.ant("/jiang/**"))
                .build();
    }

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

新建两个配置文件application-dev.properties和application-test.properties,并分别赋予端口号，然后使用application.properties来指定环境

application-dev.properties

server.port=8081

application-test.properties

server.port=8082

application.properties

spring.profiles.active=dev

    @Bean //配置docket以配置Swagger具体参数
    public Docket docket(Environment environment) {
        // 设置要显示swagger的环境
        Profiles of = Profiles.of("dev","test");
        // 判断当前是否处于该环境
        // 通过environment.acceptsProfiles判断是否已经处在自己设置的环境当中 enable()接收此参数判断是否要显示
        boolean flag = environment.acceptsProfiles(of);

        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                //配置是否启用Swagger，如果是false，在浏览器将无法访问
                .enable(flag)
                // 通过.select()方法，去配置扫描接口,RequestHandlerSelectors配置如何扫描接口
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.jiang.controller"))
                .paths(PathSelectors.ant("/jiang/**"))
                .build();
    }

3.测试Profiles of = Profiles.of(); 中不加dev的测试

4.测试Profiles of = Profiles.of(); 中加dev的测试

6.配置API分组

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

    @Bean //配置docket以配置Swagger具体参数
    public Docket docket(Environment environment) {
        // 设置要显示swagger的环境
        Profiles of = Profiles.of("dev", "test");
        // 判断当前是否处于该环境
        // 通过environment.acceptsProfiles判断是否已经处在自己设置的环境当中 enable()接收此参数判断是否要显示
        boolean flag = environment.acceptsProfiles(of);

        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .groupName("雙馬")
                //配置是否启用Swagger，如果是false，在浏览器将无法访问
                .enable(flag)
                // 通过.select()方法，去配置扫描接口,RequestHandlerSelectors配置如何扫描接口
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.jiang.controller"))
                .paths(PathSelectors.ant("/jiang/**"))
                .build();
    }

2.重启项目查看分组

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

@Bean
public Docket docket1(){
   return new Docket(DocumentationType.SWAGGER_2).groupName("group1");
}
@Bean
public Docket docket2(){
   return new Docket(DocumentationType.SWAGGER_2).groupName("group2");
}
@Bean
public Docket docket3(){
   return new Docket(DocumentationType.SWAGGER_2).groupName("group3");
}

4.重启项目查看

7.实体配置

1.新建一个实体类

@ApiModel("用户实体")
public class User {
   @ApiModelProperty("用户名")
   private String username;
   @ApiModelProperty("密码")
   private String password;
//get、set、有参无参、toString
}

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

//只要我们的接口中，返回值中存在实体类，他就会被扫描到swagger中
    @PostMapping(value = "/user")
    public User user(){
        return new User();
    }

3.重启查看测试

4.如果去掉注释

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

@ApiModel为类添加注释

@ApiModelProperty为类属性添加注释

8.常用注解

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

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

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

我们也可以给请求的接口配置一些注释

    @ApiOperation("雙馬的接口")
    @GetMapping(value = "/shuangma")
    public String shuangma(@ApiParam("用户名")String username){
        return username;
    }

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

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

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

18.异步-邮件-定时任务

在我们的工作中，常常会用到异步处理任务，比如我们在网站上发送邮件，后台会去发送邮件，此时前台会造成响应不动，直到邮件发送完毕，响应才会成功，所以我们一般会采用多线程的方式去处理这些任务。还有一些定时任务，比如需要在每天凌晨的时候，分析一次前一天的日志信息。还有就是邮件的发送，微信的前身也是邮件服务呢？这些东西都是怎么实现的呢？其实SpringBoot都给我们提供了对应的支持，我们上手使用十分的简单，只需要开启一些注解支持，配置一些配置文件即可！那我们来看看吧~

1.异步任务

1.新建一个web依赖的springboot项目
2.创建一个service包，创建一个类AsyncService

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

编写方法，假装正在处理数据，使用线程设置一些延时，模拟同步等待的情况；

@Service
public class AsyncService {

   public void hello(){
       try {
           Thread.sleep(3000);
      } catch (InterruptedException e) {
           e.printStackTrace();
      }
       System.out.println("业务进行中....");
  }
}

3.编写controller包，编写AsyncController类

@RestController
public class AsyncController {

   @Autowired
   AsyncService asyncService;

   @GetMapping("/hello")
   public String hello(){
       asyncService.hello();
       return "success";
  }

}

4.访问http://localhost:8080/hello进行测试，3秒后出现success，这是同步等待的情况。

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

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

//告诉Spring这是一个异步方法
@Async
public void hello(){
   try {
       Thread.sleep(3000);
  } catch (InterruptedException e) {
       e.printStackTrace();
  }
   System.out.println("业务进行中....");
}

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

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

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

}

6.重启测试，网页瞬间响应，后台代码依旧执行！

2.邮件任务

邮件发送，在我们的日常开发中，也非常的多，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.7</version>
      <scope>compile</scope>
    </dependency>

2.查看自动配置类：MailSenderAutoConfiguration

这个类中存在bean，JavaMailSenderImpl

然后我们去看下propertis可以配的东西

@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;
}

3.配置文件：

spring.mail.username=24736743@qq.com
spring.mail.password=你的qq授权码
#什么邮箱中间的值就为其名字
spring.mail.host=smtp.qq.com
# qq需要配置ssl
spring.mail.properties.mail.smtp.ssl.enable=true

获取授权码：在QQ邮箱中的设置->账户->开启pop3和smtp服务

4.Spring单元测试

@SpringBootTest
class Springboot10TestApplicationTests {

    @Autowired
    JavaMailSenderImpl mailSender;

    @Test
    public void contextLoads() {
        //邮件设置1：一个简单的邮件
        SimpleMailMessage message = new SimpleMailMessage();
        message.setSubject("主题");
        message.setText("正文");

        message.setTo("24736743@qq.com");
        message.setFrom("24736743@qq.com");
        mailSender.send(message);
    }

    @Test
    public void contextLoads2() throws MessagingException {
        //邮件设置2：一个复杂的邮件
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);

        helper.setSubject("主题");
        helper.setText("<b style='color:red'>正文</b>",true);

        //发送附件
        helper.addAttachment("1.jpg",new File(""src/main/resources/static/1.jpg""));
        helper.addAttachment("2.jpg",new File(""src/main/resources/static/1.jpg""));

        helper.setTo("24736743@qq.com");
        helper.setFrom("24736743@qq.com");

        mailSender.send(mimeMessage);
    }

}

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

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

3.定时任务

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

TaskExecutor接口任务调度
TaskScheduler接口任务执行

两个注解：

@EnableScheduling
@Scheduled

cron表达式：

字段	允许值	允许的特殊字符
秒（Seconds）	0~59的整数	, - * / 四个字符
分（Minutes）	0~59的整数	, - * / 四个字符
小时（Hours）	0~23的整数	, - * / 四个字符
日期（DayofMonth）	1~31的整数（但是你需要考虑你月的天数）	,- * ? / L W C 八个字符
月份（Month）	1~12的整数或者 JAN-DEC	, - * / 四个字符
星期（DayofWeek）	0~7的整数或者 SUN-SAT 0,7 是 sun	, - * ? / L C # 八个字符
年(可选，留空)（Year）	1970~2099	, - * / 四个字符

特殊字符	代表含义
，	枚举
-	区间
*	任意
/	步长，5/20,5分钟触发一次，25和50触发
？	日/星期冲突匹配
L	最后
W	工作日
C	和calendar联系后计算过的值
#	星期，4#2，第二个星期三

测试步骤：

1.创建一个ScheduledService

我们里面存在一个hello方法，他需要定时执行，怎么处理呢？

@Service
public class ScheduledService {
   
   //秒   分   时     日   月   周几
   //0 * * * * MON-FRI
   //注意cron表达式的用法；
   @Scheduled(cron = "0 * * * * 0-7")
   public void hello(){
       System.out.println("hello.....");
  }
}

2.这里写完定时任务之后，我们需要在主程序上增加@EnableScheduling 开启定时任务功能

@EnableAsync //开启异步注解功能
@EnableScheduling //开启基于注解的定时任务
@SpringBootApplication
public class SpringbootTaskApplication {

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

}

3.我们来详细了解下cron表达式；

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

4.常用的表达式

（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）有些子表达式能包含一些范围或列表
　　例如：子表达式（天（星期））可以为 “MON-FRI”，“MON，WED，FRI”，“MON-WED,SAT”

“*”字符代表所有可能的值

　　因此，“”在子表达式（月）里表示每个月的含义，“”在子表达式（天（星期））表示星期的每一天

　　“/”字符用来指定数值的增量 　　例如：在子表达式（分钟）里的“0/15”表示从第0分钟开始，每15分钟 在子表达式（分钟）里的“3/20”表示从第3分钟开始，每20分钟（它和“3，23，43”）的含义一样

　　“？”字符仅被用于天（月）和天（星期）两个子表达式，表示不指定值 　　当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“？”

　　“L” 字符仅被用于天（月）和天（星期）两个子表达式，它是单词“last”的缩写 　　但是它在两个子表达式里的含义是不同的。 　　在天（月）子表达式中，“L”表示一个月的最后一天 　　在天（星期）自表达式中，“L”表示一个星期的最后一天，也就是SAT

　　如果在“L”前有具体的内容，它就具有其他的含义了

　　例如：“6L”表示这个月的倒数第６天，“FRIL”表示这个月的最一个星期五 　　注意：在使用“L”参数时，不要指定列表或范围，因为这会导致问题

19.Dubbo和Zookeeper集成

1.分布式理论

什么是分布式系统？

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

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

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

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

Dubbo文档

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

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

单一应用架构

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

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

缺点：

1.性能扩展比较难
2.协同开发问题
3.不利于升级维护

垂直应用架构

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

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

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

分布式服务架构

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

流动计算架构

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

2.什么是RPC

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

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

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

RPC基本原理

步骤解析：

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

3.测试环境搭建

Dubbo

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

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

1.了解Dubbo的特性

2.查看官方文档

dubbo基本概念

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

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

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

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

调用关系说明

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

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

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

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

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

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

Dubbo环境搭建

点进dubbo官方文档，推荐我们使用Zookeeper 注册中心

什么是zookeeper呢？可以查看官方文档

Window下安装zookeeper

1.下载zookeeper ：地址，我们下载3.7.1，稳定版！解压zookeeper

这里使用360解压，因为压缩包的特殊性，有很多的解压软件并不支持

2.在根目录创建两个文件夹data和log

3.运行/bin/zkServer.cmd ，初次运行会报错，没有zoo.cfg配置文件；

可能遇到问题：闪退 !

解决方案：编辑zkServer.cmd文件末尾添加pause 。这样运行出错就不会退出，会提示错误信息，方便找到原因。

再次运行

4.修改zoo.cfg配置文件

将conf文件夹下面的zoo_sample.cfg复制一份改名为zoo.cfg即可。

注意几个重要位置：

修改dataDir

dataDir=/tmp/zookeeper 改为我们刚才创建的data文件夹路径这里的路径要双\\

添加dataLogDi

dataLogDir= 改为我们刚才创建的log文件夹路径这里的路径要双\\

clientPort=2181 zookeeper的端口号

修改完成后再次启动zookeeper,注意这里要注意8080端口号不能被占用

5.在启动使用zkServer.cmd的同时，启动zkCli.cmd测试

ls /：列出zookeeper根下保存的所有节点注意空格

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

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

我们再来查看一下节点

window下安装dubbo-admin

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

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

我们这里来安装一下：

1.下载dubbo-admin

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

修改 application.properties 指定zookeeper地址

如果你之前zookeeper的端口号没有改动，那这里也不用动

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

mvn clean package -Dmaven.test.skip=true

如果遇到'mvn' 不是内部或外部命令，也不是可运行的程序或批处理文件。可能是当初配置换maven环境变量的时候没有在path添加一项maven地址的bin目录位置，在这里我来指出maven的几个环境变量

都如上述配置完，之后，使用管理员模式在cmd打开 dubbo-admin-master-0.2.0目录里面重新打包，第一次打包的过程有点慢，需要耐心等待！直到成功！

4.执行 dubbo-admin\target 下的dubbo-admin-0.0.1-SNAPSHOT.jar

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

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

执行完毕，我们去访问一下 http://localhost:7001/ ，这时候我们需要输入登录账户和密码，我们都是默认的root-root；

登录成功后，查看界面

安装完成！

4.SpringBoot + Dubbo + zookeeper

1. 启动zookeeper ！
2. IDEA创建一个空的Maven项目；
3.创建一个springboot模块，实现服务提供者：provider-server ，选择web依赖即可
4.项目创建完毕，我们写一个服务，比如卖票的服务；

编写接口

public interface TicketService {
   public String getTicket();
}

编写实现类

public class TicketServiceImpl implements TicketService {
   @Override
   public String getTicket() {
       return "《狂神说Java》";
  }
}

5.创建一个模块，实现服务消费者：consumer-server ，选择web依赖即可
6.项目创建完毕，我们写一个服务，比如用户的服务；

编写service

public class UserService {
   //我们需要去拿去注册中心的服务
}

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

先更改一下两个项目的端口号

provider-server

server.port=8081

consumer-server

server.port=8082

服务提供者

1.将服务提供者注册到注册中心，我们需要整合Dubbo和zookeeper，所以需要导包

我们从dubbo官网进入github，看下方的帮助文档，找到dubbo-springboot，找到依赖包

<!--Dubbo+zookeeper-->
		<dependency>
			<groupId>org.apache.dubbo</groupId>
			<artifactId>dubbo-spring-boot-starter</artifactId>
			<version>3.1.1</version>
		</dependency>

zookeeper的包我们去maven仓库下载，zkclient；是gethub里的依赖

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

【新版的坑】zookeeper及其依赖包，解决日志冲突，还需要剔除日志依赖；

<!-- 引入zookeeper -->
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-framework</artifactId>
			<version>5.3.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-recipes</artifactId>
			<version>5.3.0</version>
		</dependency>
		<!--这里版本要和自己下载的版本一致-->
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<version>3.7.1</version>
		</dependency>
		<!--排除这个slf4j-log4j12-->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>2.0.3</version>
		</dependency>

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

#当前应用名字
dubbo.application.name=provider-server
#注册中心地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
#扫描指定包下服务
dubbo.scan.base-packages=com.jiang.service

3.在service的实现类中配置服务注解，发布服务！注意导包问题

//服务注册与发现
@DubboService// dubbo旧版本不的使用时不建议使用service，原因是spring和dubbo都有这个注解在使用上在日后查看代码可能混淆，在新版本上解决了这个问题，dubbo弃用了这个注解使用@DubboService
@Component //放在容器中,将服务发布出去
public class TicketServiceImpl implements TicketService {
   @Override
   public String getTicket() {
       return "《Java》";
  }
}

4.在主启动类开启dubbo注解

@EnableDubbo//Dubbo的注解
@SpringBootApplication
public class ProviderServerApplication {

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

}

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

这里可能遇到端口被占用，查看端口是否被占用：

netstat -aon|findstr "7001"

强制关闭

taskkill /f /pid 16212

关闭之后

启动springboot服务提供者(ProviderServerApplication)发现启动不起来了，在这需要导入一个服务器管理的依赖

<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-x-discovery</artifactId>
			<version>5.3.0</version>
		</dependency>

使用后在启动服务提供者(ProviderServerApplication)，发现这里弹出，服务器未启用，在这打开zookeeper和dubbo的监管者模式

这里注意，要使用管理员模式

启动后查看服务者，发现已经有端口了

服务消费者

1.导入依赖，和之前的依赖一样；

<!--Dubbo+zookeeper-->
		<dependency>
			<groupId>org.apache.dubbo</groupId>
			<artifactId>dubbo-spring-boot-starter</artifactId>
			<version>3.1.1</version>
		</dependency>
		<!--zkclient-->
		<dependency>
			<groupId>com.github.sgroschupf</groupId>
			<artifactId>zkclient</artifactId>
			<version>0.1</version>
		</dependency>
		<!-- 引入zookeeper -->
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-framework</artifactId>
			<version>5.3.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-recipes</artifactId>
			<version>5.3.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-x-discovery</artifactId>
			<version>5.3.0</version>
		</dependency>
		<!--这里版本要和自己下载的版本一致-->
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<version>3.7.1</version>
		</dependency>
		<!--排除这个slf4j-log4j12-->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>2.0.3</version>
		</dependency>

2.配置参数

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

3.启动服务消费者(ConsumerServerApplication)，查看监控者端口

消费者也连上了服务器，接下来就可以进行购买了

3. 本来正常步骤是需要将服务提供者的接口打包，然后用pom文件导入，我们这里使用简单的方式，直接将服务的接口拿过来，路径必须保证正确，即和服务提供者相同；代码和服务提供者的接口完全一样

public interface TicketService {
   public String getTicket();
}

4.完善消费者的服务类

@Service
public class UserService {
    //我们需要去拿去注册中心的服务
    @Reference //远程引用指定的服务，他会按照全类名进行匹配，看谁给注册中心注册了这个全类名
            TicketService ticketService;

    public void bugTicket() {
        String ticket = ticketService.getTicket();
        System.out.println("在注册中心买到" + ticket);
    }
}

5. 编写测试类，进行尝试购买

@SpringBootTest
class ConsumerServerApplicationTests {

    @Autowired
    UserService userService;

    @Test
    public void contextLoads() {

        userService.bugTicket();

    }

}

启动测试

1. 开启zookeeper
2. 打开dubbo-admin实现监控【可以不用做】
3. 开启服务者
4. 消费者消费测试，结果：

监控中心：

5.关闭
- 1.关闭服务消费者
- 2.关闭服务提供者
- 3.关闭监控中心
- 4.关闭zookeeper

ok , 这就是SpingBoot + dubbo + zookeeper实现分布式开发的应用，其实就是一个服务拆分的思想。

猜你喜欢

CSS 相对|绝对(relative/absolute)定位系列（一）
macOS SwiftUI 窗体和视图规范之 12 警告提示框 alert
WCF - Versus Web Service
pip 源替换国内源
机器视觉与计算机视觉
《深入解析sas：数据处理、分析优化与商业应用》一一2.3　通过IMPORT过程读取外部文件数据
437. Path Sum III
《领域驱动设计：软件核心复杂性应对之道（修订版）》—第1章 1.3节持续学习
acwing 第63场周赛【2022.08.06】
传统云网络面临的这些问题
《锋利的SQL（第2版）》——1.9 SQL书写规范
Flutter如何一键唤起

相关主题

springboot多配置环境
SpringBoot集成Swagger
SpringBoot之文件上传
SpringBoot dubbo

zl程序教程

当前栏目

springboot(四)

17.Swaggger

1.Swagger简介

2.SpringBoot集成Swagger