SpringBoot-Dubbo和Zookeeper-15

1.分布式理论

1. 分布式系统是什么?

是若干独立计算机的集合,这些计算机对于用户来说就像单个相关系统;

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

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

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

2. Dubbo文档

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

3. 单一的应用架构

当网站流量很小的时候,只需要一个引用来将所有的功能都部署在一起,减少部署的节点和成本,此时,简化CRUD工作量的数据访问框架(ORM)是关键--->适用于小型的网站,管理系统,将所有的功能都部署到一个功能里面,简单易用
缺点

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

4. 垂直的应用架构

当访问的量逐渐增大的时候,单一应用增加机器带来的加速度越来越小,将应用拆成互不相干的几个引用,以提升效率.此是,用于加速前端页面开发的Web框架(MVC)是关键
通过切分业务来实现各个模块的独立部署,降低了维护和部署的难度,团队各司其职更容易管理,性能扩展也更方便,更有针对性
缺点

1. 公用模块无法复用,开发性浪费

5. 分布式服务架构

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

6. 流动计算架构

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

2.分布式服务架构(RPC)

RPC是指远程过程调用,是一种进程间的通信方式,是一种技术思想,而不是规范.它允许程序调用一个地址空间(通常是网络的其他机器上)的过程或者函数,而不用程序显式编码这个远程调用的细节.即程序员无论是调用本地的还是远程的函数,本质上编写的调用代码基本相同.

eg 机器A和机器B,一个部署在A服务器上面,一个部署在B服务器上面,想要调用B服务器上应用提供的函数或方法,由于不在一个内存(一个机器上),不能直接调用,需要通过网络来表达调用的语义和传达调用的数据.

为什么需要rpc呢?就是无法在一个进程内,甚至一个计算机内通过本地调用的方式完成的需求,比如不同系统间的通讯,甚至不同的组织间的通信,由于计算能力需要横向扩展,需要在多台机器组成的集群上部署应用,rpc就是要像本地的函数一样去调远程函数.
基本原理

两个核心模块:通讯,序列化

3.SpringBoot + Dubbo + zookeeper

1. 框架的搭建:

   1. 启动zookeeper(下载zookeeper,解压之后去config中将zoo_sample.cfg复制一份改名为zoo.cfg之后去bin中运行zkService.cmd即可.可以在其中加入pause进行断点)
   2. 使用idea创建一个新的空项目
   3. 创建两个springboot模块,分别是provider-service 和 consumer-service 选择web依赖即可.provider为服务提供者,consumer为服务调用者
   4. 创建完毕之后,写一个服务,例如买票的

2. 编写接口,在服务提供者中

public interface TicketService {
    public String getTicket();
}

3. 编写上面接口的实现类

public class TicketServiceImpl implements TicketService{
    @Override
    public String getTicket() {
        return "xxx到zzz的票";
    }
}

4. 在consumer中写一个服务,如用户的服务;

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

需求,现在我们的用户想使用买票的服务,需要如何

提供者

1. 将服务的提供者注册到注册中心,需要整合Dubbo和zookeeper,需要导依赖以及排除冲突还有依赖的包

 <!--导入依赖Dubbo zookeeper-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.3</version>
        </dependency>
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
        <!--日志会冲突,需要排除slf4j-log4j-->
        <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>
        <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>

2. 在springboot的application.properties中配置dubbo的属性

server.port=8001
#注册中心地址
dubbo.application.name=provider-server
#服务应用名字
dubbo.registry.address=zookeeper://127.0.0.1:2181
#哪些服务可以被注册
dubbo.scan.base-packages=com.sli.service

3. 在提供者的实现类中配置服务注解

//服务注册与发现
@Service//为dubbo的service.可以被扫描到,在项目启动的时候就可以自动注册到注册中心
@Component//这里使用了dubbo之后尽量不要使用service注解.放在容器中
public class TicketServiceImpl implements TicketService{
    @Override
    public String getTicket() {
        return "xxx到zzz的票";
    }
}

应用启动之后,dubbo就会扫描指定的包下面带有@component(<beans>)注解的服务,将他们发布在指定的注解中心中

调用者

1. 导入依赖(和上面一样)

<!--导入依赖Dubbo zookeeper-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.3</version>
        </dependency>
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
        <!--日志会冲突,需要排除slf4j-log4j-->
        <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>
        <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>

2. 配置参数

server.port=8002
#调用者去哪里拿
dubbo.application.name=consumer-server
#注册中心的地址,也就是@component注解之下的类被托管到注册中心的地方
dubbo.registry.address=zookeeper://127.0.0.1:2181

3. 可以直接将提供者的接口拿来放到和提供者相同路径下的位置
4. 完善调用者服务类

@Service//放到容器中,此处是springframework包下面的service
public class UserService {

    //想的到provider提供的票,要去注册中心na

    @Reference//引用,类似于autowired
    TicketService ticketService;

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

5. 测试类的编写

@SpringBootTest
class ConsumerServerApplicationTests {
  @Autowired
    UserService userService;
    @Test
    void contextLoads() {
        userService.buyTicket();
    }
}

6. 启动测试,开启zookeeper,开启提供者,调用者调用测试结果为在注册中心拿到xxx到zzz的票

以上就是SpringBoot + Dubbo + zookeeper实现的分布式开发的引用,也就为服务器拆分的思想