Dubbo基础（一）

最新推荐文章于 2024-03-23 16:12:43 发布

chinusyan

最新推荐文章于 2024-03-23 16:12:43 发布

阅读量814

点赞数

分类专栏：分布式文章标签： Duboo

本文链接：https://blog.csdn.net/chinus_yan/article/details/120356525

版权

分布式专栏收录该内容

25 篇文章 2 订阅

订阅专栏

一、主流的互联网技术特点

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

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

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

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

高并发：同一时刻，处理同一件事情的处理能力（解决方案：分布式、集群、负载均衡）

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

二、架构演变的过程

在这里插入图片描述
当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。
（1）：单体架构（all in one）

架构优点：

架构简单，前期开发成本低、开发周期短，适合小型项目（OA、CRM、ERP 企业内部应用 jsp）。
架构缺点：

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

（1）业务代码耦合度高，不易维护。

（2）维护成本高，不易拓展

（3）并发量大，不易解决

（4）技术栈受限，只能使用一种语言开发。

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

架构优点：

（1）业务代码相对解耦

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

（3）并发量大相对易于解决（搭建集群）

（4）技术栈可扩展（不同的系统可以用不同的编程语言编写）。
架构缺点：

服务之间相互调用，如果某个服务的端口或者ip地址发生改变，调用的系统得手动改变

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

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

架构优点：

（1）业务代码完全解耦，并可实现通用

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

（3）并发量大易于解决（搭建集群）

（4）技术栈完全扩展（不同的系统可以用不同的编程语言编写）。
架构缺点：

缺少统一管理资源调度的框架
（4）流动计算架构（SOA）
当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。
SOA（Service-Oriented Architecture），中文意思是面向服务编程，是一种思想，一种方法论，一种分布式的服务架构。SOA解决多服务凌乱问题，SOA架构解决数据服务的复杂程度，同时SOA又有一个名字，叫做服务治理。

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

架构优点：

（1）业务代码完全解耦，并可实现通用

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

（3）并发量大易于解决（搭建集群）

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

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

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

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

特点二：采用轻量级框架协议传输。（可以使用spring cloud）（http协议 restful json）

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

对象关系映射（英语：Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。
对象数据库是一种以对象形式表示信息的数据库。对象数据库的数据库管理系统被称为ODBMS或OODBMS。
两个主要原因让用户使用对象数据库技术。首先，关系数据库在管理复杂数据时显得笨重。其次，被应用软件操作的数据一般是用面向对象的编程语言如C++,Java,Delphi和C#写成，而那些用来转化数据表示和关系数据库元组的代码很冗繁，执行时也有不少耗时。这种应用程序和数据库表示信息的模式之间的不匹配有时也被称为impedance mismatch。

单一架构，垂直架构，分布式服务，微服务的优缺点比较

三、RPC（远程过程调用）

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

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

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

是一种进程间的通信方式
它允许应用程序调用网络上的另一个应用程序中的方法
对于服务的消费者而言，无需了解远程调用的底层细节，是透明的

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

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

一台电脑调用另外一台脑上的方法
RPC组件
简单来说一个RPC架构里包含如下4个组件:

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

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

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

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

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）得到最终结果。

调用方式接口调用

Web Service 接口 http+soap
Dubbo 接口

四、 Dubbo简介

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

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

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

Dubbo架构
在这里插入图片描述

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

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

调用关系说明:

服务容器负责启动，加载，运行服务提供者。
服务提供者在启动时，向注册中心注册自己提供的服务。
服务消费者在启动时，向注册中心订阅自己所需的服务。
注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送通知消费者。
服务消费者，从注册中心摘取服务提供者列表，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

Dubbo
使用的是长连接
在这里插入图片描述工程实现：
1：环境准备

2：创建父工程（dubbo_parent) 依赖管理

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

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

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

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

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

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

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.it</groupId>
    <artifactId>dubbo_parent</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>dubbo_common</module>
        <module>dubbo_interface</module>
        <module>dubbo_provider</module>
        <module>dubbo_consumer</module>
    </modules>

     <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.webmvc.version>5.2.16.RELEASE</spring.webmvc.version>
        <dubbo.version>2.7.0</dubbo.version>
        <zookeeper.version>3.4.7</zookeeper.version>
        <curator.verion>4.0.1</curator.verion>
        <mybatis.version>3.4.5</mybatis.version>
        <mysql.version>8.0.26</mysql.version>
        <mybatis-spring.version>1.3.2</mybatis-spring.version>
        <druid.version>1.1.9</druid.version>
        <slf4j.version>1.6.6</slf4j.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <!--springmvc的环境-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.webmvc.version}</version>
            </dependency>
            <!--dubbo的环境-->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo</artifactId>
                <version>${dubbo.version}</version>
            </dependency>

            <!--zookeeper的环境-->
            <dependency>
                <groupId>org.apache.zookeeper</groupId>
                <artifactId>zookeeper</artifactId>
                <version>${zookeeper.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.curator</groupId>
                <artifactId>curator-framework</artifactId>
                <version>${curator.verion}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.curator</groupId>
                <artifactId>curator-recipes</artifactId>
                <version>${curator.verion}</version>
            </dependency>
            <!--mybatis的环境-->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>${mybatis-spring.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!--spring的环境-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${spring.webmvc.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.webmvc.version}</version>
            </dependency>
            <!--日志的环境-->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

子模块：dubbo_common

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

子模块：dubbo_interface

<packaging>jar</packaging>
<dependencies>
  	<dependency>
    	<groupId>com.it</groupId>
    	<artifactId>dubbo_common</artifactId>
    	<version>1.0-SNAPSHOT</version>
  	</dependency>
</dependencies>

public interface UserService {

    User findById(Integer id);
}

服务提供者模块

需要依赖dubbo_interface

要查询数据库dao 接口与映射文件 , mybatis整合spring
实现接口的方法UserServiceImpl 事务控制
注册到dubbo上 application name="", registry zookeeper://ip:端口, dubbo:service 接口名 ref=实现的bean对象 bean 实现类
启动：3种方式：ClasspathXmlApplicationContext, ContextLoaderListener, DispatcherServlet

<properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.it</groupId>
            <artifactId>dubbo_interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

resources资源目录下

创建spring-dao.xml
- 配置数据源
- 配置sqlSessionFactory对象
- 扫描dao包，创建dao接口的动态代理对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--  数据源  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--  工厂  -->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.dp.pojo"/>
    </bean>
    <!--  dao扫描  -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.dp.dao"/>
    </bean>

</beans>

创建spring-service.xml
- 配置事务(事务管理器，注解事务)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--  事务管理器  -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--  事务注解  -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <!--  注入dao  -->
    <import resource="classpath:spring-dao.xml"/>

</beans>

创建spring-provider.xml 配置文件：
- 配置dubbo的应用名称
- 配置dubbo注册中心Zookeeper地址
- 配置需要暴露的业务接口及实例

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <!--  发布服务的名称  -->
    <dubbo:application name="dubbo_provider"/>
    <!--  注册中心
    zookeeper:
-->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    <!-- service:  注册上去服务
    interface： 发布服务的接口
    ref: spring容器的bean对象
    将来通过这个interface调用服务时，就来调用spring容器中的对象的方法
-->
    <dubbo:service interface="com.it.service.UserService" ref="userService"/>
    <!--  服务真正的执行者  -->
    <bean id="userService" class="com.it.imp.UserServiceImpl"></bean>
    <!--  注入spring-service.xml  -->
    <import resource="classpath:spring-service.xml"/>
</beans>

UserService 实现类

//实现类的包名必须和接口的包名一致
public class UserServiceImpl implements UserService {
    
    @Autowired
    UserDao userDao;

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

创建UserDao接口
public interface UserDao {
User findById(Integer id);
}
在resource下创建com/it/dao目录，创建UserDao接口的映射文件，内容如下

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.it.dao.UserDao">
    <select id="findById" resultType="com.it.pojo.User" parameterType="int">
        select * from t_user where id = #{id}
    </select>
</mapper>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/itcastdubbo
jdbc.user=root
jdbc.password=root

log4j.properties

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c:\\mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=debug, stdout

只要能启动spring的容器（加载spring的配置文件）就可以启动项目，因此有3种方式
ClassPathXmlApplication
监听器或DispatcherServlet

注册中心验证
登录zookeeper客户端，直接查看ls /dubbo/com.it.service.UserService节点

如果 /dubbo下面没有内容，说明没有注册上，
如果有，内容是空，说明已经掉线
正常注册并连接在线，如下图
注意：
消费者与提供者应用名称不能相同
如果有多个服务提供者，名称不能相同，通信端口也不能相同
只有服务提供者才会配置服务发布的协议，默认是dubbo协议，端口号是20880

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

<!--发布dubbo协议，默认端口20880-->
<dubbo:protocol name="dubbo" port="20881"></dubbo:protocol>

服务消费者模块

接收请求响应结果controller, springmvc
springmvc
- 扫controller，注解驱动
- 导入dubbo的配置
dubbo的配置
- 注册到dubbo上 application name="", registry zookeeper://ip:端口, dubbo:reference 接口名 id=controller中注入的service属性名
web.xml
- 乱码过滤器
- 核心控制器
  此模块基于是Web应用，需要引入spring-webmvc，需要在容器启动时，去zookeeper注册中心订阅服务,需要引入dubbo、zookeeper及客户端依赖。

<packaging>war</packaging>  
  <dependencies> 
    <dependency> 
      <groupId>org.it</groupId>  
      <artifactId>dubbo_interface</artifactId>  
      <version>1.0-SNAPSHOT</version> 
    </dependency>  
    <dependency> 
      <groupId>org.springframework</groupId>  
      <artifactId>spring-webmvc</artifactId> 
    </dependency>  
    <dependency> 
      <groupId>com.fasterxml.jackson.core</groupId>  
      <artifactId>jackson-core</artifactId>  
      <version>2.9.0</version> 
    </dependency>  
    <dependency> 
      <groupId>com.fasterxml.jackson.core</groupId>  
      <artifactId>jackson-databind</artifactId>  
      <version>2.9.0</version> 
    </dependency>  
    <dependency> 
      <groupId>com.fasterxml.jackson.core</groupId>  
      <artifactId>jackson-annotations</artifactId>  
      <version>2.9.0</version> 
    </dependency>  
    <dependency> 
      <groupId>javax.servlet</groupId>  
      <artifactId>servlet-api</artifactId>  
      <version>2.5</version>  
      <scope>provided</scope> 
    </dependency>  
    <dependency> 
      <groupId>org.apache.dubbo</groupId>  
      <artifactId>dubbo</artifactId> 
    </dependency>  
    <dependency> 
      <groupId>org.apache.zookeeper</groupId>  
      <artifactId>zookeeper</artifactId> 
    </dependency>  
    <dependency> 
      <groupId>org.apache.curator</groupId>  
      <artifactId>curator-framework</artifactId> 
    </dependency>  
    <dependency> 
      <groupId>org.apache.curator</groupId>  
      <artifactId>curator-recipes</artifactId> 
    </dependency>  
    <dependency> 
      <groupId>org.slf4j</groupId>  
      <artifactId>slf4j-log4j12</artifactId> 
    </dependency> 
  </dependencies>

controller

// 
@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数据
    }
}

spring-consumer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

<!--  发布的名称  -->
    <dubbo:application name="dubbo_consumer"/>
<!--  注册中心  -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
<!--  服务订阅扫包
      在controller的服务注入使用@Reference(dubbo)

    <dubbo:annotation package="com.it"/>  id 必须有值-->
    <dubbo:reference interface="com.it.service.UserService" id="userService"/>

<!--  启动时是否检查服务提供者是否存在，true: 则会检查【上线时】，没有则报错。false不检查
 retries: 失败后的重试次数
 -->
    <dubbo:consumer check="false" timeout="2000" retries="2"/>

</beans>

spring-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

<!--  扫controller-->
    <context:component-scan base-package="com.it.controller"/>

<!--  注解驱动  -->
    <mvc:annotation-driven/>

<!--  引入dubbo配置文件-->
    <import resource="classpath:spring-dubbo.xml"/>

</beans>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="WebApp_ID" version="3.0">
	<!--springmvc的核心控制器-->
    <servlet>	
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!--解决post请求的乱码过滤器-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

Zookeeper中存放Dubbo服务结构
在这里插入图片描述
流程说明：

1：服务提供者(Provider)启动时: 向 /dubbo/com.foo.BarService/providers 目录下写入自己的 URL 地址

2：服务消费者(Consumer)启动时: 订阅 /dubbo/com.foo.BarService/providers 目录下的提供者 URL 地址。并向 /dubbo/com.foo.BarService/consumers 目录下写入自己的 URL 地址

3：监控中心(Monitor)启动时: 订阅 /dubbo/com.foo.BarService 目录下的所有提供者和消费者 URL 地址

chinusyan

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Dubbo基础（一）

主流的互联网技术特点分布式、高并发、集群、负载均衡、高可用(故障转移)。分布式：一件事情拆开来做。集群：一件事情大家一起做。负载均衡：将请求平均分配到不同的服务器中，达到均衡的目的。高并发：同一时刻，处理同一件事情的处理能力（解决方案：分布式、集群、负载均衡）高可用：系统都是可用的。实现故障转移...
复制链接

扫一扫

专栏目录