Dubbo知识点梳理

Dubbo知识点梳理,第1张

Dubbo知识点梳理

文章预览:

Apache Dubbo

1. 应用架构的演进过程

【目标】【路径】【讲解】1.1. 主流的互联网技术特点1.2. 架构演变的过程

1.2.1. 单一应用架构(all in one)1.2.2. 垂直应用架构1.2.3. 分布式服务架构1.2.4. 流动计算架构(SOA) 【小结】 2. RPC(远程过程调用

【目标】【路径】【讲解】2.1. RPC介绍2.2. RPC组件【重点】2.3. RPC调用【小结】 3. Apache Dubbo概述

【目标】【路径】【讲解】3.1. Dubbo简介3.2. Dubbo架构【重点】【小结】 4. Dubbo快速开发【练习重点】

【目标】【路径】【讲解】4.2. 创建父工程4.3. 创建公共子模块4.4. 创建接口子模块4.5. 服务提供者模块

4.5.1. 创建子模块dubbo_provider(或者叫做dubbo_service)4.5.2. service与dao4.5.3. 配置文件编写

① spring-dao.xml② jdbc.properties③ spring-service.xml④ spring-provider.xml⑤ log4j.properties 4.5.4 启动项目

① ClassPathXmlApplication② 监听器或DispatcherServlet 4.5.5 注册中心验证 4.6. 服务消费者模块

4.6.1. 创建子模块dubbo_consumer(或者叫做dubbo_controller)4.6.2. Controller4.6.3. 编写配置文件

① spring-dubbo.xml文件② spring-mvc.xml③ 导入log4j.properties④ 配置web.xml 4.6.5. 启动服务消费者并测试 4.7. Zookeeper中存放Dubbo服务结构(作为Dubbo运行的注册中心)【小结】 5. Dubbo管理控制台

【目标】【路径】【讲解】5.1. 安装5.2. 使用【小结】 6. Dubbo相关配置说明

【目标】【路径】【讲解】6.1. 包扫描【重点】

61.1. 服务提供者,使用注解实现6.1.2. 服务消费者,使用注解实现6.1.3. 重启服务测试使用 6.2. 服务接口访问协议【提供方修改】6.3. **启动时检查**6.4. 超时调用【小结】 7. 负载均衡-【重点】

【目标】【路径】【讲解】7.1. 介绍7.2. 测试负载均衡效果【小结】 8. 配置中心【了解】

【目标】【路径】【讲解】8.1. 环境介绍![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xieY8zbH-1643714230893)(1573639104883.png)]8.2. 实现配置中心](https://img-blog.csdnimg.cn/d151b26319594e7aa872edeba44d36b6.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5YGa5pyA5bm456aP55qE,size_20,color_FFFFFF,t_70,g_se,x_16)

8.2.1. 在zookeeper中添加数据源所需配置8.2.2.在dubbo_common中导入jar包8.2.3. 修改数据源,读取zookeeper中数据

8.2.3.1. 在dubbo_common中创建工具类:SettingCenterUtil,继承PropertyPlaceholderConfigurer8.2.3.2. 编写载入zookeeper中配置文件,传递到Properties属性中8.2.3.3. 重写processProperties方法8.2.3.4. 修改spring-dao.xml 8.2.4. watch机制

8.2.4.1. 在SettingCenterUtil中添加监听8.2.4.2. 获取容器对象,刷新spring容器 【小结】

Apache Dubbo

学习目标

了解应用架构演进过程了解RPC远程调用方式掌握Dubbo框架的架构【重点】掌握Zookeeper注册中心的基本使用掌握Dubbo生产者和消费者的开发【重点】了解Dubbo的管理控制台的使用了解Dubbo的相关配置了解Dubbo的负载均衡(4种)了解Dubbo的配置中心(难点 代码 Watch) 1. 应用架构的演进过程 【目标】

了解软件架构的演进过程

【路径】

1:主流的互联网技术特点

2:架构演变的过程

(1):单体架构

(2):垂直架构

(3):分布式服务架构

(4):SOA架构

(5):微服务架构

【讲解】 1.1. 主流的互联网技术特点

分布式 、高并发、集群、负载均衡、高可用(故障转移)。

分布式:一件事情拆开来做。

集群:一件事情大家一起做。

负载均衡:将请求平均分配到不同的服务器中,达到均衡的目的。


高并发:同一时刻,处理同一件事情的处理能力(解决方案:分布式、集群、负载均衡)

高可用:系统都是可用的。实现故障转移

1.2. 架构演变的过程 1.2.1. 单一应用架构(all in one)

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

架构优点:

架构简单,前期开发成本低、开发周期短,适合小型项目(OA、CRM、ERP 企业内部应用 jsp)。

架构缺点:

全部功能集成在一个工程中

(1)业务代码耦合度高,不易维护。

(2)维护成本高,不易拓展

(3)并发量大,不易解决

(4)技术栈受限,只能使用一种语言开发。

1.2.2. 垂直应用架构

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

架构优点:

(1)业务代码相对解耦

(2)维护成本相对易于拓展(修改一个功能,可以直接修改一个项目,单独部署)

(3)并发量大相对易于解决(搭建集群)

(4)技术栈可扩展(不同的系统可以用不同的编程语言编写)。

架构缺点:

功能集中在一个项目中,不利于开发、扩展、维护。

代码之间存在数据、方法的冗余

1.2.3. 分布式服务架构

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

架构优点:

(1)业务代码完全解耦,并可实现通用

(2)维护成本易于拓展(修改一个功能,可以直接修改一个项目,单独部署)

(3)并发量大易于解决(搭建集群)

(4)技术栈完全扩展(不同的系统可以用不同的编程语言编写)。

架构缺点:

缺少统一管理资源调度的框架

1.2.4. 流动计算架构(SOA)

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

​ 资源调度和治理中心的框架:dubbo、spring cloudy

架构优点:

(1)业务代码完全解耦,并可实现通用

(2)维护成本易于拓展(修改一个功能,可以直接修改一个项目,单独部署)

(3)并发量大易于解决(搭建集群)

(4)技术栈完全扩展(不同的系统可以用不同的编程语言编写)。

( 5 ) 框架实现了服务治理,不去担心集群的使用情况(失败会尝试其它服务…)

【小结】

1:单体架构

全部功能集中在一个项目内(All in one)。 打一个war, 一个tomcat

2:垂直架构

按照业务进行切割,形成小的单体项目。 每个业务模块就是一个war,一个tomcat

3 : 分布式:应用调用服务(ip写死),服务挂了就不能用了,缺少服务治理。把业务服务(service+dao)拆分成一个war包,一个tomcat里。

4:SOA架构(项目一)

服务的提供者(以服务为主 service调用dao->数据库),消费者。

服务提供者与消费都注册到中心,由中心统一管理分配,失败重试,负载均衡。。。有服务治理

可以使用dubbo作为调度的工具(RPC协议), Zookeeper作为注册中心

5:微服务架构(项目二 畅购 Springboot+Spring Cloud)

将系统服务层完全独立出来,抽取为一个一个的微服务。 以功能为主(controller->service-dao->数据库 独立)

特点一:抽取的粒度更细,遵循单一原则,数据可以在服务之间完成数据传输(一般使用restful请求调用资源)。

特点二: 采用轻量级框架协议传输。(可以使用spring cloud)(http协议 restful json)

特点三: 每个服务都使用不同的数据库,完全独立和解耦 (分库分表)。

2. RPC(远程过程调用) 【目标】

了解什么是RPC

【路径】

1:RPC介绍

2:RPC组件

3:RPC调用

【讲解】 2.1. RPC介绍

​ Remote Procedure Call 远程过程调用,是分布式架构的核心,按响应方式分如下两种:

​ 同步调用:客户端调用服务方方法,等待直到服务方返回结果或者超时,再继续自己的 *** 作。

​ 异步调用:客户端把消息发送给中间件,不再等待服务端返回,直接继续自己的 *** 作。

是一种进程间的通信方式

它允许应用程序调用网络上的另一个应用程序中的方法

对于服务的消费者而言,无需了解远程调用的底层细节,是透明的

需要注意的是RPC并不是一个具体的技术,而是指整个网络远程调用过程。

RPC是一个泛化的概念,严格来说一切远程过程调用手段都属于RPC范畴。各种开发语言都有自己的RPC框架。Java中的RPC框架比较多,广泛使用的有RMI、Hessian、Dubbo、spring Cloud(restapi http)等。

一台电脑调用另外一台脑上的方法

2.2. RPC组件【重点】

简单来说一个RPC架构里包含如下4个组件:

1、 客户端(Client):服务调用者

2、 客户端存根(Client Stub):存放服务端地址信息,将客户端的请求参数打包成网络消息,再通过网络发送给服务方

3、 服务端存根(Server Stub):接受客户端发送过来的消息并解包,再调用本地服务

4、 服务端(Server):服务提供者。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-usRult15-1643694526366)(1562656624997.png)]

2.3. RPC调用

1、 服务调用方(client)调用以本地调用方式调用服务;

2、 client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体

​ 在Java里就是序列化的过程

3、 client stub找到服务地址,并将消息通过网络发送到服务端;

4、 server stub收到消息后进行解码,在Java里就是反序列化的过程;

5、 server stub根据解码结果调用本地的服务;

6、 本地服务执行处理逻辑;

7、 本地服务将结果返回给server stub;

8、 server stub将返回结果打包成消息,Java里的序列化;

9、 server stub将打包后的消息通过网络并发送至消费方;

10、 client stub接收到消息,并进行解码, Java里的反序列化;

11、 服务调用方(client)得到最终结果。

【小结】

1:RPC 远程过程调用 调用另一个应用的方法

2:RPC组件及调用过程

客户端->客户端存根->服务端存根->服务端->服务端存根->客户端存根->客户端

3:调用方式 接口调用

Web Service 接口 http+soap Dubbo 接口 3. Apache Dubbo概述 【目标】

什么是dubbo?

dubbo的架构是什么(图)?

【路径】

1:dubbo简介

2:dubbo架构

【讲解】 3.1. Dubbo简介

Apache Dubbo是一款高性能的Java RPC框架。其前身是阿里巴巴公司开源的一个高性能、轻量级的开源Java RPC框架,可以和Spring框架无缝集成。

Dubbo官网地址:http://dubbo.apache.org

Dubbo提供了三大核心能力:面向【接口】的远程方法调用,智能容错和负载均衡,以及服务自动注册(dubbo帮你注册在zookeeper创建节点数据)和发现(订阅 watch, dubbo帮我们做了)。

3.2. Dubbo架构【重点】

Dubbo架构图(Dubbo官方提供)如下:

节点角色说明:

节点角色名称Provider暴露服务的服务提供方 服务方Consumer调用远程服务的服务消费方 调用方Registry服务注册与发现的注册中心Monitor统计服务的调用次数和调用时间的监控中心Container服务运行容器

虚线都是异步访问,实线都是同步访问
蓝色虚线:在启动时完成的功能
红色虚线(实线)都是程序运行过程中执行的功能

调用关系说明:

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

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

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

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

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

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

【小结】

1:dubbo 远程调用框架 RPC, alibaba>apache(2019 2020),服务注册与发现(订阅),调用

2:dubbo架构

成员 注册中心, 服务提供者, 消费者, 监控中心工作流程: 启动时服务提供与消费者都注册到注册中心,消费监听注册中心中的服务,消费者获得提供者列表,提供者发生变化时会通知消费者更新列表,调用提供者。调用的过程信息每间隔一段时间就发送给监控中心记录下来 4. Dubbo快速开发【练习重点】 【目标】

使用dubbo,完成服务消费者,调用,服务提供者方法

【路径】

1:环境准备

2:创建父工程(dubbo_parent) 依赖管理

3:创建公共子模块(dubbo_common) 实体类

4:创建接口子模块(dubbo_interface) 通用接口

5:创建服务提供者模块(dubbo_provider) 对接口的实现 调用dao完成数据库的 *** 作

6:创建服务消费者模块(dubbo_consumer) 引用接口 接收参数调用服务,返回结果

7:Zookeeper中存放Dubbo服务结构(注册中心) 启动zookeeper

【讲解】

​ Dubbo作为一个RPC框架,其最核心的功能就是要实现跨网络的远程调用,服务提供者、服务消费者会使用共同的接口,故本小节先创建一个父工程,父工程下有4个子模块,一个是公共子模块,一个是接口模块,一个是服务提供者模块,一个是服务消费者模块。通过Dubbo来实现服务消费方远程调用服务提供方的方法。

​ 实现的业务为:根据id查询用户对象

​ 业务描述:页面发送请求:user/findById.do?id=1 根据id从数据库获取用户对象

实现步骤:

 1. 环境准备:创建数据库,创建t_user表
 2. 创建父工程,基于maven,打包方式为pom,工程名:dubbo_parent
 3. 创建公共子模块,创建user实体类,打包方式为jar,工程名:dubbo_common
 4. 创建接口子模块,在父工程的基础上,打包方式为jar,模块名:dubbo_interface
 5. 创建服务提供者子模块,在父工程的基础上,打包方式为war,模块名:dubbo_provider
 6. 创建服务消费者模子块,在父工程的基础上,打包方式为war,模块名:dubbo_consumer
 ### 4.1.  环境准备

创建数据库表

create database dubbo;

CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(20) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

INSERT INTO t_user(username,age) VALUES("张三",22);
INSERT INTO t_user(username,age) VALUES("李四",20);
INSERT INTO t_user(username,age) VALUES("王五",25);
4.2. 创建父工程

​ 父工程,不实现任何代码,主要是添加工程需要的库的依赖管理(DependencyManagement),依赖管理就是解决项目中多个模块间公共依赖的版本号、scope的控制范围。本项目需要使用spring-webmvc,使用dubbo(务必2.6.2以上版本)、zookeeper及其客户端(curator-framework)、Spring、Mybatis依赖库。

GroupID:com.wjs

ArtifactId:dubbo_parent

    创建完工程:

    修改pom.xml,抽取版本、增加赖库依赖管理,全部内容如下:



    4.0.0

    com.wjs
    dubbo_parent
    pom
    1.0-SNAPSHOT
    
        dubbo_common
        dubbo_interface
        dubbo_provider
        dubbo_consumer
    

    
	        1.8
	        1.8
	        5.0.5.RELEASE
	        2.6.2
	        3.4.7
	        4.0.1
	        3.4.5
	        5.1.47
	        1.3.2
	        1.1.9
	        1.6.6
    
    
        
            
            
                org.springframework
                spring-webmvc
                ${spring.webmvc.version}
            
            
            
                com.alibaba
                dubbo
                ${dubbo.version}
            
            
            
                org.apache.zookeeper
                zookeeper
                ${zookeeper.version}
            
            
                org.apache.curator
                curator-framework
                ${curator.verion}
            
            
                org.apache.curator
                curator-recipes
                ${curator.verion}
            
            
            
                org.mybatis
                mybatis
                ${mybatis.version}
            
            
                org.mybatis
                mybatis-spring
                ${mybatis-spring.version}
            
            
                com.alibaba
                druid
                ${druid.version}
            
            
                mysql
                mysql-connector-java
                ${mysql.version}
            
            
            
                org.springframework
                spring-tx
                ${spring.webmvc.version}
            
            
                org.springframework
                spring-jdbc
                ${spring.webmvc.version}
            
            
            
                org.slf4j
                slf4j-log4j12
                ${slf4j.version}
            
        
    

    
        
            junit
            junit
            4.12
            test
        
    

4.3. 创建公共子模块

在当前父工程的基础上创建子模块GroupID:com.wjsArtifactId:dubbo_common

1:pom.xml

jar

        
            org.projectlombok
            lombok
            RELEASE
            compile
        
        
            org.springframework
            spring-beans
        
        
            com.alibaba
            dubbo
        
        
            org.apache.zookeeper
            zookeeper
        
        
            org.apache.curator
            curator-framework
        
        
            org.apache.curator
            curator-recipes
        
        
            org.springframework
            spring-beans
            5.0.5.RELEASE
            compile
        
    

2:在com.wjs.pojo包中创建User实体类

package com.wjs.pojo;

import java.io.Serializable;


public class User implements Serializable {
    private Integer id;
    private String username;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + ''' +
                ", age=" + age +
                '}';
    }
}

4.4. 创建接口子模块

此模块,主要放业务接口的定义,它是服务消费者模块和服务提供者模块的公共依赖模块。

在当前父工程的基础上创建子模块GroupID:com.wjsArtifactId:dubbo_interface

    创建子模块:

    pom.xml,添加依赖

    jar
    
      	
        	com.wjs
        	dubbo_common
        	1.0-SNAPSHOT
      	
    
    

    在包com.wjs.service创建业务接口

package com.wjs.service;

import com.wjs.pojo.User;

public interface UserService {

    User findById(Integer id);
}

如图所示:

4.5. 服务提供者模块

此模块是服务提供者模块,需要在容器启动时,把服务注册到zookeeper,故需要引入spring-webmvc,zookeeper及客户端依赖。

【路径】

实现步骤:

    创建子模块dubbo_provider,使用war 需要依赖dubbo_interface

    代码目录

    resources资源目录

    创建spring-dubbo.xml 配置文件:

    配置dubbo的应用名称

    配置dubbo注册中心Zookeeper地址

    配置需要暴露的业务接口及实例

    创建spring-dao.xml

    配置数据源配置sqlSessionFactory对象扫描dao包,创建dao接口的动态代理对象

    创建spring-service.xml

    配置事务(事务管理器,注解事务)

    在web.xml文件中,只要加载spring的配置文件即可

    配置tomcat启动服务提供者 或使用ClassPathXmlApplicationContext加载spring容器

实现过程:

4.5.1. 创建子模块dubbo_provider(或者叫做dubbo_service)

在当前父工程的基础上创建子模块

打包方式为war

项目坐标如下

​ GroupID:com.wjs

​ ArtifactId:dubbo_provider

工程创建完成后,如图所示:

修改pom.xml文件,打包方式为war,增加依赖库,新增编译插件tomcat7,端口81

war

    
        com.wjs
        dubbo_interface
        1.0-SNAPSHOT
    
    
        org.springframework
        spring-webmvc
    
    
        com.alibaba
        dubbo
    
    
        org.apache.zookeeper
        zookeeper
    
    
        org.apache.curator
        curator-framework
    
    
        org.apache.curator
        curator-recipes
    
    
        org.mybatis
        mybatis
    
    
        org.mybatis
        mybatis-spring
    
    
        com.alibaba
        druid
    
    
        mysql
        mysql-connector-java
    
    
        org.springframework
        spring-tx
    
    
        org.springframework
        spring-jdbc
    
    
        org.slf4j
        slf4j-log4j12
    

4.5.2. service与dao

1:在main下,创建子目录java(刷新maven工程),增加com.wjs.service.impl包及创建UserServiceImpl实现类

package com.wjs.service.impl;

import com.wjs.pojo.User;
import com.wjs.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;

public class UserServiceImpl implements UserService {
    
    @Autowired
    UserDao userDao;

    @Override
    public User findById(Integer id) {
        return userDao.findById(id);
    }
}

2:增加com.wjs.dao包,创建UserDao接口

package com.wjs.dao;

import com.wjs.pojo.User;

public interface UserDao {
    User findById(Integer id);
}

3:在resource下创建com/wjs/dao目录,创建UserDao接口的映射文件,内容如下




    
        select * from t_user where id = #{id}
    

也可以使用注解方式

 @Select("select * from t_user where uid=#{id}")

4.5.3. 配置文件编写

在main下,创建子目录resources目录,在resources目录下

创建

spring-dao.xmljdbc.propertiesspring-service.xmlspring-provider.xmllog4j.properties启动项目 ① spring-dao.xml




    


    
        
        
        
        
    

    
        
        
    

    
        
    

② jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/dubbo
jdbc.user=
jdbc.password=
③ spring-service.xml




    
        
    

    

    

④ spring-provider.xml




    

    

    

    


    

⑤ log4j.properties

将资料的log4j.properties配置文件拷贝到resources目录下

效果如下

4.5.4 启动项目

只要能启动spring的容器(加载spring的配置文件)就可以启动项目,因此有3种方式

① ClassPathXmlApplication
package com.wjs;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;


public class ProviderApplication {
    public static void main(String[] args) throws IOException {
        new ClassPathXmlApplicationContext("classpath:spring-provider.xml");
        //阻塞进程
        System.in.read();
    }
}

② 监听器或DispatcherServlet

配置web.xml文件






    
        dispatcherServlet
        org.springframework.web.servlet.DispatcherServlet
        
            contextConfigLocation
            classpath:spring-provider.xml
        
        1
    
    
        dispatcherServlet
        *.do
    

配置tomcat启动项目

4.5.5 注册中心验证

检查是否注册到zookeeper

(1)启动zookeeper,作为dubbo的注册中心

(2)登录zookeeper客户端,直接查看ls /dubbo/com.wjs.service.UserService节点

如果 /dubbo下面没有这个节点,说明没有注册上,

如果有,内容是空,说明已经掉线

【正常注册并连接在线】,如图所示:

注意:

消费者与提供者应用名称不能相同

如果有多个服务提供者,名称不能相同,通信端口也不能相同

只有服务提供者才会配置服务发布的协议,默认是dubbo协议,端口号是20880

可以在spring-dubbo.xml中配置协议的端口


其实就spring与mybatis整合,多了一dubbo的配置文件(注册Zookeeper)。

4.6. 服务消费者模块

此模块是服务消费者模块,此模块基于是Web应用,需要引入spring-webmvc,需要在容器启动时,去zookeeper注册中心订阅服务,需要引入dubbo、zookeeper及客户端依赖。

实现步骤:

    创建子模块dubbo_consumer,打包方式为war包,dubbo_interface(用来调用接口方法)

    java源代码目录

    resources资源目录

    ​ 创建spring-dubbo.xml 配置文件:

    ​ 配置dubbo的应用名称

    ​ 配置dubbo注册中心Zookeeper地址

    ​ 配置需要订阅的业务接口及引用

    ​ 创建spring-mvc.xml

    ​ 开启注解扫描

    ​ 开启mvc注解驱动

    将资料的log4j.properties配置文件拷贝到resources目录下

    在web.xml文件中(拦截*.do),配置SpringMVC

    启动服务消费者,并测试访问

实现过程:

4.6.1. 创建子模块dubbo_consumer(或者叫做dubbo_controller)

在当前父工程的基础上创建子模块

坐标如下

​ GroupID:com.wjs

​ ArtifactId:dubbo_consumer

1:创建工程,如图所示:

 	war

    
        
            com.wjs
            dubbo_interface
            1.0-SNAPSHOT
        
        
            org.springframework
            spring-webmvc
        

        
            com.fasterxml.jackson.core
            jackson-core
            2.9.0
        
        
            com.fasterxml.jackson.core
            jackson-databind
            2.9.0
        
        
            com.fasterxml.jackson.core
            jackson-annotations
            2.9.0
        
        
            javax.servlet
            servlet-api
            2.5
            provided
        

        
            com.alibaba
            dubbo
        
        
            org.apache.zookeeper
            zookeeper
        
        
            org.apache.curator
            curator-framework
        
        
            org.apache.curator
            curator-recipes
        
        
            org.slf4j
            slf4j-log4j12
        
    
4.6.2. Controller

创建com.itheima.controller包及创建UserController控制类,该类调用远程业务UserService,实现调用findById方法。

package com.wjs.controller;

import com.wjs.pojo.User;
import com.wjs.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

// 
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("/findById")
    public User findById(int id){
        // 调用服务
        User user = userService.findById(id);
        // 要返回json给前端,必须有@ResponseBody,或类上有@RestController
        // 另外springmvc默认使用jaskson来解析java对象为json字符串,注意引入jaskson的依赖
        return user;// 返回json数据
    }
}

4.6.3. 编写配置文件

在main下,创建子目录resources目录,在resources目录下

1:spring-dubbo.xml

2:spring-mvc.xml配置文件

3:log4j.properties

① spring-dubbo.xml文件




    

    

    


    


② spring-mvc.xml




    


    


    


③ 导入log4j.properties

复制log4j.properteis到resources目录下

④ 配置web.xml

配置springmvc的核心控制器,用来加载spring-mvc.xml



	
    
        springMVC
        org.springframework.web.servlet.DispatcherServlet
        
            contextConfigLocation
            classpath:spring-mvc.xml
        
        1
    
    
        springMVC
        /
    
    
    
        CharacterEncodingFilter
        org.springframework.web.filter.CharacterEncodingFilter
        
            encoding
            UTF-8
        
    
    
        CharacterEncodingFilter
        
public class CreateJDBCPath {

    @Test
    public void createJDBCPath() throws Exception {
        //1. 重试策略
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,1);
        // 客户端
        Curatorframework client = CuratorframeworkFactory.newClient("127.0.0.1:2181",30000,3000,retryPolicy);
        // 启动
        client.start();

        //  *** 作
        client.create().creatingParentsIfNeeded().forPath("/config/jdbc.driver","com.mysql.jdbc.Driver".getBytes());
        client.create().creatingParentsIfNeeded().forPath("/config/jdbc.url","jdbc:mysql://localhost:3306/dubbo".getBytes());
        client.create().creatingParentsIfNeeded().forPath("/config/jdbc.user","root".getBytes());
        client.create().creatingParentsIfNeeded().forPath("/config/jdbc.password","root".getBytes());
        // 关闭
        client.close();
    }

}

8.2.3. 修改数据源,读取zookeeper中数据 8.2.3.1. 在dubbo_common中创建工具类:SettingCenterUtil,继承PropertyPlaceholderConfigurer

8.2.3.2. 编写载入zookeeper中配置文件,传递到Properties属性中
package com.wjs.utils;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.Curatorframework;
import org.apache.curator.framework.CuratorframeworkFactory;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
import org.springframework.util.StringValueResolver;

import java.util.Properties;

public class SettingCenterUtil extends PropertyPlaceholderConfigurer{

    
    private void loadZk(Properties props) {
        //connectString       连接字符串 host:port
        String connectString = "127.0.0.1:2181";
        //sessionTimeoutMs    session timeout  会话超时时间
        int sessionTimeoutMs = 1000;
        //connectionTimeoutMs connection timeout 连接超时时间
        int connectionTimeoutMs = 1000;
        //retryPolicy         retry policy to use  重试策略
        // baseSleepTimeMs  每次重试间隔时间
        // 1.创建重试策略
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,1);
        // 2. 创建客户端
        Curatorframework client = CuratorframeworkFactory.newClient(connectString, sessionTimeoutMs, connectionTimeoutMs, retryPolicy);
        // 3. 启动
        client.start();// 启动

        try {
            String driver = new String(client.getData().forPath("/config/jdbc.driver"));
            String url = new String(client.getData().forPath("/config/jdbc.url"));
            String user = new String(client.getData().forPath("/config/jdbc.user"));
            String password = new String(client.getData().forPath("/config/jdbc.password"));

            // 设置数据库的配置
            props.setProperty("jdbc.driver", driver);
            props.setProperty("jdbc.url", url);
            props.setProperty("jdbc.user", user);
            props.setProperty("jdbc.password", password);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

8.2.3.3. 重写processProperties方法
@Override
protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
        throws BeansException {
    // 设置数据库的配置
    // 读取zookeeper
    loadFormZk(props);
    super.processProperties(beanFactoryToProcess, props);
}

8.2.3.4. 修改spring-dao.xml

注释掉:


添加:


spring-dao.xml中配置

8.2.4. watch机制 8.2.4.1. 在SettingCenterUtil中添加监听
private void addWatch() {
    // 重试策略
    RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3, 3000);
    // 创建客户端
    Curatorframework client = CuratorframeworkFactory.newClient("127.0.0.1:2181", 3000, 3000, retryPolicy);
    // 启动
    client.start();

    TreeCache treeCache = new TreeCache(client, "/config");
    try {
        treeCache.start();
    } catch (Exception e) {
        e.printStackTrace();
    }

    treeCache.getListenable().addListener(new TreeCacheListener() {
        @Override
        public void childEvent(Curatorframework client, TreeCacheEvent event) throws Exception {
           if (event.getType() == TreeCacheEvent.Type.NODE_UPDATED) {
               String path = event.getData().getPath();
               System.out.println("==================================修改路径:" + path);
                if(path.startsWith("/config/jdbc")){
                    // 修改了数据库配置
                    // 刷新spring容器,触发重新加载数据库连接池
                    applicationContext.refresh();
                }
            }
        }
    });
}

注意:

1:不要关闭client,否则无法进行监控

2:修改完成后必须刷新spring容器的对象

8.2.4.2. 获取容器对象,刷新spring容器

1:修改SettingCenterUtil实现ApplicationContextAware接口,重写setApplicationContext方法,获取applicationContext对象。

2:AbstractApplicationContext容器对象父类,提供了refresh方法,可以刷新容器中的对象,故强制转换。

3:在processProperties的方法中,添加addWatch(props);

private static boolean flag = true;


@Override
protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
        throws BeansException {
    // 设置数据库的配置
    // 读取zookeeper
    loadFormZk(props);
    // 订阅数据库配置
    if(flag) {
        // 已经订阅过了,不需要再次订阅
        addWatch();
        flag=false;
    }
    super.processProperties(beanFactoryToProcess, props);
}

4:修改Zookeeper的配置

【小结】

1:配置中心环境介绍 回看zookeeper配置中心的图

2:实现配置中心

(1)在Zookeeper中添加数据源所需配置

(2)在dubbo-common中导入jar包

(3)修改数据源,读取Zookeeper中数据 继承ProperteisPlaceHolderConfigurer.processProperties, 读取zk中的数据库配置,设置进props参数

3:watch机制

(1)添加监听 TreeCache, event.type=node_update, 注意:判断path 不要关闭客户端,防止重复订阅

(2)获取容器对象(ApplicationContextAware)且刷新

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/zaji/5719952.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-12-17
下一篇 2022-12-18

发表评论

登录后才能评论

评论列表(0条)

保存