今天完成的事情：（一定要写非常细致的内容，比如说学会了盒子模型，了解了Margin） 

一、学习Dubbo   http://www.cnblogs.com/soulaz/p/5577196.html

1.Dubbo是什么？   

Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。简单的说，dubbo就是个服务框架，如果没有分布式的需求，其实是不需要用的，只有在分布式的时候，才有dubbo这样的分布式服务框架的需求，并且本质上是个服务调用的东东，说白了就是个远程服务调用的分布式框架（告别Web Service模式中的WSdl，以服务者与消费者的方式在dubbo上注册）

因为之前学的RMI,tuscany都是只存在客户端和服务端，也就是服务端将端口暴露之后，客户端对照着服务端的端口去访问调用，而在dubbo之中，就是得服务端先去注册中心注册，客户端去注册中心查找，就相当于从路边摊模式转换成拍卖行模式。
其核心部分包含:
1)远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。
2) 集群容错: 提供基于接口方法的透明远程过程调用，包括多协议支持，以及软负载均衡，失败容错，地址路由，动态配置等集群支持。其相比RMI的需要自己来配置宕机切换，可以在注册中心就实现一个负载均衡，宕机切换。
3) 自动发现: 基于注册中心目录服务，使服务消费方能动态的查找服务提供方，使地址透明，使服务提供方可以平滑增加或减少机器。

2.Dubbo能做什么？

1）透明化的远程方法调用，就像调用本地方法一样调用远程方法，只需简单配置，没有任何API侵入。      
2）软负载均衡及容错机制，可在内网替代F5等硬件负载均衡器，降低成本，减少单点。
3） 服务自动注册与发现，不再需要写死服务提供方地址，注册中心基于接口名查询服务提供者的IP地址，并且能够平滑添加或删除服务提供者。

3.dubbo的架构

dubbo架构图如下所示：

节点角色说明：

       Provider: 暴露服务的服务提供方。相当于之前的server

       Consumer: 调用远程服务的服务消费方。相当于之前的client

       Registry: 服务注册与发现的注册中心。

       Monitor: 统计服务的调用次调和调用时间的监控中心。

       Container: 服务运行容器。

其中

init代表初始需要加载，即只需执行一次即可，

async代表异步，即可以多个请求同时处理

sync代表同步，单个服务单词只能供给单个消费方

调用关系说明：

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

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

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

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

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

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

二、使用Dubbo https://blog.csdn.net/qq_18860653/article/details/53186040

1.首先下载zookeeper注册中心，下载后解压然后进入conf文件夹将zzoo_simple.cfg复制一份改名为zoo.cfg

这个配置文件里需要注意的是注册中心的端口号2181

bin文件夹运行

就可以打开注册中心了，但是我遇到一个小问题，就是正常情况应该是启动后就会像redis一样一直开着，但是我这里却直接闪退，导致后面一直注册不进去。百度一下，首先在zkServer.cmd最后加上pause方便查看报错

然后运行

可以看到是因为端口被占用，因为之前启动了一个8080的tomcat，所以将那个tomcat换个端口，然后再重新启动

可以看到这个就是启动成功了！

2.然后是下载图形化界面，在https://github.com/apache/incubator-dubbo-ops

上将项目fork到本地，然后打开，将其中的dubbo-admin打包，获得一个war包，将其放入tomcat的webapps中，然后就可以在tomcat的bin中启动了，注意启动脚本是startup.bat而不是sh，启动过程和服务器上差不多

之后就可以登陆默认端口8080，输入项目名访问此项目

在这个界面是可以查看接入的provoider和consumer，并且何以设置负载均衡的方式，后面再研究。

3.创建多模块项目，总共三个模块，可以看到下面，添加相关依赖

<modules>
    <module>providerA</module>
    <module>consumer</module>
    <module>myService</module>
</modules>

<properties>
    <spring.version>4.3.3.RELEASE</spring.version>
    <slf4j.version>1.7.12</slf4j.version>
    <log4j.version>1.2.17</log4j.version>
</properties>

<dependencies>
    <!--日志管理包-->
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <!--spring-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!--dubbo相关依赖-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>dubbo</artifactId>
        <version>2.5.3</version>
        <exclusions>
            <exclusion>
                <groupId>org.springframework</groupId>
                <artifactId>spring</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <!--dubbo注册中心-->
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.6</version>
    </dependency>
    <!--zookeeper客户端-->
    <dependency>
        <groupId>com.github.sgroschupf</groupId>
        <artifactId>zkclient</artifactId>
        <version>0.1</version>
    </dependency>
</dependencies>

4.编写myService,即功能接口模块，里面只有一个接口类，编写好之后安装到本地，然后在另外两个模块的依赖中添加此模块即可

public interface DemoService {
    String sayHello(String name);
    List getUsers();
}

<dependencies>
    <dependency>
        <groupId>com.task</groupId>
        <artifactId>myService</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

5.编写provider模块

接口实现

public class DemoServiceImpl implements DemoService {

    @Override
    public String sayHello(String name) {
        return "Hello"+name;
    }

    @Override
    public List getUsers() {
        List list = new ArrayList();
        User u1 = new User();
        u1.setName("jack");
        u1.setAge(20);
        u1.setSex("男");

        User u2 = new User();
        u2.setName("tom");
        u2.setAge(21);
        u2.setSex("女");

        User u3 = new User();
        u3.setName("rose");
        u3.setAge(19);
        u3.setSex("女");

        list.add(u1);
        list.add(u2);
        list.add(u3);
        return list;
    }
}

这里有个User类，其实也可以放在接口模块里面

package com.task.pojo;

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID =-4567894324645L;
    private String name;
    private int age;
    private String sex;

    public void setName(String name) {
        this.name = name;
    }

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

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

编写applicationContext.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://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        ">


    <!-- 提供方应用信息，用于计算依赖关系 -->
     <dubbo:application name="xixi_provider"/>

    <!--使用zookeeper注册中心暴露服务地址 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>

    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="20880" />

    <!-- 声明需要暴露的服务接口 -->
    <dubbo:service interface="com.task.service.DemoService" ref="demoService"/>

    <!--具体的实现bean-->
    <bean id="demoService" class="com.task.provider.DemoServiceImpl"/>

</beans>

最后是启动的main方法，主要是加载配置文件

public class StartProvider {
    public static void main(String[] args) throws Exception{
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        context.start();
        System.out.println("provider启动");
        System.in.read(); // 为保证服务一直开着，利用输入流的阻塞来模拟
    }
}

6.编写consumer类，也有一个User类，就不重复了，直接复制就行

然后是applicationContext-dubbo-demo.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        ">

    <!-- 消费方应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 -->
    <dubbo:application name="hehe_consumer" />

    <!-- 使用zookeeper注册中心暴露服务地址 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>

    <!-- 生成远程服务代理，可以像使用本地bean一样使用demoService -->
    <dubbo:reference id="demoService" interface="com.task.service.DemoService"/>
    
</beans>

相比上面的配置文件少了暴露服务的端口号和具体实现类的bean

最后是调用的main方法，也是加载配置文件

public class StartConsumer {
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext(
                "applicationContext-dubbo-demo.xml");
        context.start();

        DemoService demoService=(DemoService)context.getBean("demoService");
        System.out.println(demoService.sayHello("dubbo"));
        List list = demoService.getUsers();
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
        }
        System.in.read();
    }
}

7.启动startProvider

8.启动startConsumer

9.查看此时的观测台

可以看到启动成功了，provider和consumer都可以找到对应的名称。

三、总结Dubbo

1.要实现连接Dubbo,首先需要下载注册中心，注册中心的启动一定要是界面不关闭才算成功，否则就要看报错，然后解决。在启动前需要修改一下配置文件。

2.图形化界面的下载需要打包之后到tomcat中启动，注意输入的网址和端口号。

3.可以专门弄一个接口模块，其他模块依赖此接口模块，然后provider和consumer就不用再写对应的接口了。

4.配置文件没什么，和另外几种分布式差不多，只不过这里需要写的是注册中心的url而不是提供者的。

5.然后启动之后可以在注册中心来控制分配的权重等数据，很方便，不用像RMI那样再去想办法防宕机

明天计划的事情：（一定要写非常细致的内容） 

1.继续学习，将其加入到自己的项目中
遇到的问题：（遇到什么困难，怎么解决的） 

遇到的几个都解决了
收获：（通过今天的学习，学到了什么知识）

学习了dubbo的初始配置