ZooKeeper与Dubbo整合

架构优点：

（1）业务代码相对解耦

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

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

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

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

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

1.2.3. 分布式服务架构

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

架构优点：

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

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

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

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

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

1.2.4. 流动计算架构（SOA）

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

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

架构优点：

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

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

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

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

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

【小结】

1：单体架构

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

2：垂直架构

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

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

4：SOA架构（项目一）

服务的提供者(provider)=>war（以服务为主 service调用dao->数据库），消费者(consumer controller)。=>war

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

可以使用dubbo作为调度的工具（RPC协议 remote process call）, Zookeeper作为注册中心,相比于http更底层;

springcloud (RPC Http),他更通用,更跨平台,跨语言. /user/findById

5：微服务架构（项目二畅购 Springboot+Spring Cloud）

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

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

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

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

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)：服务调用者 socket 序列化反序列化 socketServer

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

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

4、服务端(Server)：服务提供者。 RPC remote procedure call 远程过程(方法) 调用

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概述：

3.1. Dubbo简介：

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

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

Dubbo提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

3.2. Dubbo架构【重点】：

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

调用关系说明:

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

【小结】

1：dubbo 远程调用框架 RPC, alibaba>apache(2019 2020)

2：dubbo架构

成员注册中心，服务提供者，消费者，监控中心
工作流程: 启动时服务提供与消费者都注册到注册中心，消费监听注册中心中的服务，消费者获得提供者列表，提供者发生变化时会通知消费者更新列表，调用提供者。调用的过程信息每间隔一段时间就发送给监控中心记录下来

4. Dubbo快速开发（重点）：

1：环境准备

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

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

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

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

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

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

【目标】

使用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 service层接口抽取
 5. 创建服务提供者子模块，在父工程的基础上，打包方式为war，模块名：dubbo_provider（勾选maven-archetype-webapp）
 6. 创建服务消费者模子块，在父工程的基础上，打包方式为war，模块名：dubbo_consumer（勾选maven-archetype-webapp）

结构图如下：

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. 创建父工程（dubbo-parent）：

导包（pom.xml文件）如下：

<?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.guigu.dubbo</groupId>
    <artifactId>dubbo-parent</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>dubbo-common</module>
        <module>dubbo-consumer</module>
        <module>dubbo-interface</module>
        <module>dubbo-provider</module>
    </modules>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.webmvc.version>5.0.5.RELEASE</spring.webmvc.version>
        <dubbo.version>2.6.2</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>5.1.47</mysql.version>
        <mybatis-spring.version>1.3.2</mybatis-spring.version>
        <druid.version>1.1.9</druid.version>
        <log.version>1.2.17</log.version>
        <slf4j.version>1.7.25</slf4j.version>
        <jackson.version>2.5.4</jackson.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <!--springmvc的环境-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.webmvc.version}</version>
            </dependency>
            <!--dubbo的环境-->
            <dependency>
                <groupId>com.alibaba</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>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log.version}</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.18</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.73</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

4.3. 创建公共子模块（dubbo_common）：

1、pom.xml文件如下：

<?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">
    <parent>
        <artifactId>dubbo-parent</artifactId>
        <groupId>com.guigu.dubbo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo-common</artifactId>
    <packaging>jar</packaging>

    <dependencies>
    <!--springmvc的环境-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
    </dependency>
    <!--dubbo的环境-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>dubbo</artifactId>
    </dependency>
    <!--zookeeper的环境-->
    <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>
    <!--mybatis的环境-->
    <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>
    <!--spring的环境-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
    </dependency>
    <!--日志的环境-->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.20</version>
        <scope>provided</scope>
    </dependency>

    <!--报No converter found for return value of type: class com.cyq.pojo.User这个500错-->
    <!--controller传输数据至前端时，如果直接传对象（不是json格式），可以将对象转成json格式-->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.9.8</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.8</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.9.8</version>
    </dependency>
</dependencies>
</project>

2、在com.cyq.pojo包中创建User实体类

package com.cyq.pojo;

import lombok.Data;

import java.io.Serializable;

@Data
public class User implements Serializable {
    private Integer id;
    private String username;
    private String password;

}

4.4. 创建接口子模块（dubbo_interface）：

1、pom.xml文件：

<?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">
    <parent>
        <artifactId>dubbo-parent</artifactId>
        <groupId>com.guigu.dubbo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo-interface</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.guigu.dubbo</groupId>
            <artifactId>dubbo-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.guigu.dubbo</groupId>
            <artifactId>dubbo-common</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

</project>

2、在com.cyq.service包中创建UserService

package com.cyq.service;

import com.cyq.pojo.User;

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

4.5. 服务提供者模块（dubbo_provider）：

1、pom.xml文件：

<?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">
    <parent>
        <artifactId>dubbo-parent</artifactId>
        <groupId>com.guigu.dubbo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo-provider</artifactId>
    <packaging>war</packaging>

    <name>dubbo-provider Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.guigu.dubbo</groupId>
            <artifactId>dubbo-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>dubbo-provider</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <resources>
            <resource>
                <directory>${basedir}/src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>${basedir}/src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

2、com.cyq.dao包中：

UserDao：

package com.cyq.dao;

import com.cyq.pojo.User;

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

UserDao.xml：

<?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.cyq.dao.UserDao">
    <select id="findById" resultType="com.cyq.pojo.User" parameterType="integer">
        select * from t_user where id = #{id}
    </select>
</mapper>

3、com.cyq.service.impl包中：

UserServiceImpl:

package com.cyq.service.impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.cyq.dao.UserDao;
import com.cyq.pojo.User;
import com.cyq.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;

//@Service(loadbalance = "roundrobin")
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    @Override
    public User findById(Integer id) {
        return userDao.findById(id);
    }
}

4、resources文件下：

database.properties：

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

log4j.properties：

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

log4j.rootLogger=debug,console,file
### direct log messages to stdout ###
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.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=mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

spring-dao.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: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:database.properties"/>
    <!--<bean class="com.cyq.utils.SettingCenterUtil"/>-->
    <!--数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--sqlSession工厂-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.cyq.pojo"/>
    </bean>
    <!--dao扫描-->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.cyq.dao"/>
    </bean>
</beans>

spring-provider.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-4.3.xsd        http://dubbo.apache.org/schema/dubbo        http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

        <!-- 提供方应用信息，用于计算依赖关系 -->
        <!--发布服务的名称-->
        <dubbo:application name="dubbo-provider"/>

        <!-- 使用multicast广播注册中心暴露服务地址 -->
    <!--发布dubbo协议，默认端口20880-->
    <!--    <dubbo:protocol name="dubbo" port="20881"></dubbo:protocol>-->
    <!--注册中心-->
         <dubbo:registry address="zookeeper://192.168.211.129:2181"/>

        <!-- 用dubbo协议在20880端口暴露服务 -->
        <dubbo:protocol name="dubbo" port="20880" />
        <!-- 声明需要暴露的服务接口 -->
       <!-- <dubbo:service interface="org.apache.dubbo.demo.DemoService" ref="demoService" />-->
        <dubbo:service interface="com.cyq.service.UserService" ref="userService"/>
        <!-- 和本地bean一样实现服务 -->
       <!-- <bean id="demoService" class="org.apache.dubbo.demo.provider.DemoServiceImpl" />-->
    <!--服务真正的执行者-->
    <!--<dubbo:annotation package="com.cyq"/>-->
    <bean id="userService" class="com.cyq.service.impl.UserServiceImpl"/>
    <!--注入spring-service.xml-->
    <import resource="classpath:spring-service.xml"/>
</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" proxy-target-class="true"/>
    <!--注入dao-->
    <import resource="classpath:spring-dao.xml"/>
</beans>

5、webapp文件下的WEB-INF下的web.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
  <!--
  方式一:监听器启动spring容器
  -->
  <!--  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-provider.xml</param-value>
    </context-param>
    <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>-->
  <!--方式二-->
  <!--  <servlet>
      <servlet-name>dispatcherServlet</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-provider.xml</param-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
      <servlet-name>dispatcherServlet</servlet-name>
      <url-pattern>/</url-pattern>
    </servlet-mapping>-->
</web-app>

6、这里我们用方法三启动：

在com.cyq包中创建ProviderApplication文件：

ProviderApplication：

package com.cyq;

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");
        //让进程保持运行状态,阻塞main进程
        System.in.read();
    }
}

4.6. 服务消费者模块（dubbo_consumer）：

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

1、pom.xml文件：

<?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">
    <parent>
        <artifactId>dubbo-parent</artifactId>
        <groupId>com.guigu.dubbo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo-consumer</artifactId>
    <packaging>war</packaging>

    <name>dubbo-consumer Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.guigu.dubbo</groupId>
            <artifactId>dubbo-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>dubbo-consumer</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <!-- tomcat插件 -->
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                    <uriEncoding>UTF-8</uriEncoding>
                    <server>tomcat7</server>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2、com.cyq.controller包中创建UserController

UserController：

package com.cyq.controller;

import com.alibaba.dubbo.config.annotation.Reference;
import com.cyq.pojo.User;
import com.cyq.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 {
    //负载均衡：随机random、轮询roundrobin、最少活跃调用数leastactive），
    // 缺省【默认】为random随机调用。
    //可以放在控制层或者服务层：UserServiceIpml

    //使用@Autowired时报编译时异常没关系，不影响运行
    //@Autowired
    @Reference(loadbalance="roundrobin")
    private UserService userService;

    @RequestMapping("/findById")
    public User findById(Integer id){
        User user=userService.findById(id);
        System.out.println("user:"+user);
        return user;
    }
}

3、resources下：

log4j.properties：

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

log4j.rootLogger=debug,console,file
### direct log messages to stdout ###
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.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=mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

spring-dubbo.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" xmlns:doubbo="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://192.168.211.129:2181"/>

    <!--这个得要-->
    <dubbo:annotation package="com.cyq"/>
    <!--
        retries:重置次数
        没用annotation改成用reference要将控制层的@Reference改成@Autowired
    -->
    <doubbo:reference interface="com.cyq.service.UserService" id="userService" retries="3"/>

    <dubbo:consumer check="false" timeout="50000" retries="3"/>
</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">
    <context:component-scan base-package="com.cyq.controller"/>
    <!--注解驱动-->
    <!--Jackson乱码解决(实体类对象转json乱码)-->
    <!--<mvc:annotation-driven/>-->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
    <mvc:default-servlet-handler/>
    <!--引入dubbo配置文件-->
    <import resource="classpath:spring-dubbo.xml"/>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".html"/>
    </bean>

</beans>

4、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>

5、配置tomcat：

6、测试：

1、在Xshell4软件中关闭防火墙、启动zookeeper服务，启动客户端：

我的电脑中操作如下：

①、先切换到zookeeper账户：

su zookeeper

②、切换到zookeeper的bin文件下：

cd /home/zookeeper/zookeeper-3.3.6/bin

③、有可能输入命令java显示：bash: java: 未找到命令，则：

. /etc/.bash_profile

④、启动zookeeper服务：

[zookeeper@localhost bin]$ ./zkServer.sh start
JMX enabled by default
Using config: /home/zookeeper/zookeeper-3.3.6/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED

如果zookeeper服务已启动，可以kill掉，命令：kill 端口号

⑤、启动zookeeper客户端：

./zkCli.sh

2、先运行ProviderApplication文件；

3、运行tomcat；

4、在浏览器输入http://localhost:9090/user/findById?id=1，查看浏览器输出结果

此时浏览器用json格式显示数据，json形式显示需一个小插件，可以参考博客：https://www.cnblogs.com/javacyq/p/14868963.html(最后面)，进行安装小插件。

7、Dubbo管理控制台：

我们在开发时，需要知道Zookeeper注册中心都注册了哪些服务，有哪些消费者来消费这些服务。我们可以通过部署一个管理中心来实现。其实管理中心就是一个web应用，部署到tomcat即可。

7.1. 安装

安装步骤：

（1）将资料中的dubbo-admin.war文件复制到tomcat 64位的webapps（C:\work\apache-tomcat-8.5.11\webapps）目录下 64位jdk1.8

（2）配置环境变量：

此电脑 > 属性 > 高级系统设置 > 环境变量：

①配置两个系统变量（这个路径是你tomcat的路径）：

CATALINA_BASE      C:\work\apache-tomcat-8.5.11
CATALINA_HOME      C:\work\apache-tomcat-8.5.11

②在系统变量Path里面添加：

%CATALINA_HOME%\bin
%CATALINA_HOME%\lib

（3）启动tomcat（win+r > 输入startup），此war文件会自动解压

（4）修改WEB-INF（C:\work\apache-tomcat-8.5.11\webapps\dubbo-admin\WEB-INF）下的dubbo.properties文件

# 注意dubbo.registry.address对应的值需要对应当前使用的Zookeeper的ip地址和端口号
# 可以将localhost改为虚拟机ip地址
# dubbo.registry.address=zookeeper://192.168.211.129:2181
dubbo.registry.address=zookeeper://localhost:2181
dubbo.admin.root.password=root
dubbo.admin.guest.password=guest

（5）再次win+r > 输入startup重启一遍。

（6）访问http://localhost:8080/dubbo-admin/，输入用户名(root)和密码(root)

进来之后：

服务治理 > 服务 >

dubbo管理控制台工具：

链接：https://pan.baidu.com/s/1FJwINmpl4aGIrVodr1DT-g 提取码：dbad

posted @ 2021-07-03 09:55 堇墨傾城阅读(214) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

ZooKeeper与Dubbo整合：

1.1. 主流的互联网技术特点

1.2. 架构演变的过程

1.2.1. 单一应用架构（all in one）

1.2.2. 垂直应用架构

1.2.3. 分布式服务架构

1.2.4. 流动计算架构（SOA）

【小结】

2.1. RPC介绍

2.2. RPC组件【重点】

2.3. RPC调用 时序图

按时间顺序来解读程序运行过程

【小结】

3. Apache Dubbo概述：

3.1. Dubbo简介 ：

3.2. Dubbo架构【重点】：

【小结】

4. Dubbo快速开发（重点）：

【目标】

4.1. 环境准备

4.2. 创建父工程（dubbo-parent）：

4.3. 创建公共子模块（dubbo_common）：

4.4. 创建接口子模块（dubbo_interface）：

4.5. 服务提供者模块（dubbo_provider）：

4.6. 服务消费者模块（dubbo_consumer）：

5、配置tomcat：

6、测试：

7、Dubbo管理控制台：

7.1. 安装

公告

2.3. RPC调用时序图

3.1. Dubbo简介：