Dubbo分布式框架

最新推荐文章于 2022-08-23 22:00:00 发布

王墨鱼

最新推荐文章于 2022-08-23 22:00:00 发布

阅读量147

点赞数

分类专栏：分布式文章标签： dubbo 分布式 java

本文链接：https://blog.csdn.net/m0_53737524/article/details/125856200

版权

分布式专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Dubbo分布式框架

分布式系统是若干独立系统的集合，但是用户用起来像是在使用一套系统

原因：规模的逐步扩大和业务的复杂，单台计算机扛不住像双十一一样的流量

应用架构的发展演变：

1）单一架构

当网站流量很小的时候，我们将所有的业务放在一台服务器上，打包运行公司管理系统/超市收银系统

优点：开发简单，部署简单

缺点：拓展不容易，维护不容易，性能提升难

2）垂直应用架构

将大型的应用拆分成小应用（一般按着业务进行拆分），根据不同的访问频率来决定各自业务的部署的服务器的数量

优点：扩展容易

缺点：页面一改，可能要造成整个项目的重新部署，业务和界面之间没有分离开，随着业务种类的增加，怎么去解决业务之间的相互调用的问题，订单服务器和用户服务器交互效率的问题

3）分布式架构（基于RPC远程过程调用）

将业务进行拆分之后，用某种方式来实现各个业务模块的远程复用和调用，这时候一个好的RPC框架就决定了分布式架构的性能，怎么调用何时去调用，服务器挂了怎么办，应对大流量的成功者莫过于中国的阿里巴巴公司，顶住了双十一淘宝的流量，反观学校的内部选课系统对于大流量只有宕机

为什么说Dubbo的性能高呢？

提升性能就要从两个最耗时的方面入手：网络通信和序列化

序列化：本地对象要在网络上进行传输就必须实现Serializable接口，也必须是序列化，我们序列化的方案有很多种：xml，json，二进制流其中效率最高的也就是二进制流

网络通信：不同于HTTP需要的七步走（三次握手和四次挥手）Dubbo采用了Socket通信机制，建立通信效率，可以去建立长连接，不用反复连接，直接进行数据的传输

2017年SpringCloud------------Dubbo持续更新

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

在这里插入图片描述

支持多种协议：dubbo，hessian,rmi,http,webservice,thrift,memcached,redis

dubbo官方推荐使用dubbo协议,dubbo的默认端口是20880

crtl + shift + Y来进行翻译

直连的方式：

监听器就是用来监听某个时机是否正在发生一些事

(70条消息) 小白新手web开发简单总结（九）-ContextLoaderListener_好人静的博客-CSDN博客_contextloaderlistener

1.ContextLoaderListener在web应用启动的时候，会创建Root WebApplicationContext；

2.一个WebApplicationContext就是一个Spring的IoC容器，用来管理JavaBean；

3.ContextLoaderListener会首先读取之前保存在ServletContext中的WebApplicationContext，如果没有的话，则重新创建；

4.ContextLoaderListener在新建一个WebApplicationContext的时候，会根据web.xml中是否配置"contextClass"来设置返回的WebApplicationContext；如果配置，则返回配置的类；如果没有配置，则读取默认的XmlWebApplicationContext；

5.ContextLoaderListener新建的WebApplicationContext都会转换成ConfigurableWebApplicationContext对象，所以如果要通过web.xml配置"contextClass"，则该类必须是ConfigurableWebApplicationContext的实现类；

6.一个ApplicationContext接口分为ConfigurableApplicationContext和WebApplicationContext，而WebApplicationContext为web应用专用的，并且为了可配置，特意又产生了一个ConfigurableWebApplicationContext的子接口，用来可配置的web应用的WebApplicationContext；

7.当产生WebApplicationContext对象的时候，再就是去配置里面的各个属性，即读取web.xml里面的“contextConfigLocation”配置的文件进行配置属性；

8.会WebApplicationContext保存到将ServletContext，所以就可以在ServletContext中使用WebApplicationContext对象；

9.ContextLoaderListener在web应用关闭的时候，会将保存在ServletContext里面的内容清空，并且释放本地Map里面的内容。

综上，准确的说ContextLoaderListener是在web应用启动的时候，读取contextConfigLocation中指定的xml文件，自动装配ApplicationContext的配置信息，并创建WebApplicationContext对象，即IoC容器，因为Servlet是在Servlet容器（Tomcat），而Spring实例化的JavaBean在IoC容器，为了使在Servlet容器中可以使用这些JavaBean，所以还将创建的WebApplicationContext对象和ServletContext做了绑定，那么就可以通过Servlet来访问到WebApplicationContext对象，并利用这个对象来访问到JavaBean。
在这里插入图片描述

第一个要注意的是model里面的类必须去implements串行化

001-link-provider

package com.wsy.dobbo.model;

import java.io.Serializable;

public class User implements Serializable {
    private int age;
    private String name;

    public User() {
    }

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

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

dubbo-userservice-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.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
<!--    服务的提供者声明名称：必须保证服务名称的唯一性，它的名称是dubbo内部使用的唯一标识-->
    <dubbo:application name="001-userservice-provider"></dubbo:application>
<!--    访问服务协议的名称和端口号，dubbo官方推荐使用的是dubbo协议，默认端口号是20880-->
<!--
        name就是指定协议的名称
        port指定协议的端口号

-->
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>
<!--
        interface表示的是暴露的接口 ref表示的是要注入的类接口中引用的实现类在Spring中的标识 register表示是否要注册 N/A表示使用直连的方式来进行注册
-->
    <dubbo:service interface="com.wsy.dobbo.service.UserService" ref="userService" registry="N/A"></dubbo:service>
    <bean id="userService" class="com.wsy.dobbo.service.impl.UserServiceImpl"></bean>

</beans>

002-link-customer

usercontroller的配置

package com.wsy.dubbo.web;

import com.wsy.dobbo.model.User;
import com.wsy.dobbo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UserController {
    @Autowired
    private UserService userService;
    @RequestMapping("/user")
    public String userDetail(Model model, Integer id){
        User user = userService.queryUserById(id);
        model.addAttribute("user", user);
        return "userDetail";
    }
}

002-link-dubbo-customer.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="002-link-consumer"></dubbo:application>
    <dubbo:reference id="userService" interface="com.wsy.dobbo.service.UserService" url="dubbo://localhost:20880" registry="N/A"></dubbo:reference>

</beans>

dubbo服务化最佳实践

分包：建议将服务接口服务模型放在公共包里面

粒度：服务接口应该尽可能大粒度，每个服务方法代表一个功能，额不是功能的一个步骤

服务接口建议以业务场景来划分，并对相近的业务去做抽象，防止接口数量爆炸

不建议使用过于抽象的通用接口，如Map query(map)，这样的接口没有明确的语义，会给后期的维护带来不便

版本：每个接口应该去定义版本号，区分接口的不同实现

ctrl+N来进行搜索类

一般maven的项目是自定义依赖，可以自己导入本地

只要是分布式开发，就必须进行序列化操作

bean id和 bean name的区别

简单的说：id用来标识bean，是唯一的，且只有一个；name定义的是bean的alias，可以有多个，并可能与其他的bean重名。

详细的说：

id是唯一标识bean.不能用特殊字符：×#@ ,不能用数字开头。在bean引用的时候只能用id指向你需要的bean；

name 可以用特殊字符，并且一个bean可以用多个名称：name=“bean1,bean2,bean3”,用逗号隔开。

通过id和name都可以取出该Bean.

BeanFactory factory=new XmlBeanFactory(new ClassPathResource(“config.xml”));

Dao dao=(Dao)factory.getBean(“thisbean”);

Dao dao1=(Dao)factory.getBean(“bean1”);

Dao dao2=(Dao)factory.getBean(“bean2”); …

// 验证是否指向同一个Bean
System.out.println((dao== dao1));
System.out.println((dao1== dao2));
// 输出bean的别名
String[] thisbean= factory.getAliases(“thisbean”);
for (String strbean: thisbean) {
System.out.println(strbean);
}

配置文件中不允许出现两个id相同的，否则在初始化时即会报错;但配置文件中允许出现两个name相同的，在用getBean()返回实例时，后面一个Bean被返回,应该是前面那个被后面同名的覆盖了。有鉴于此，为了避免不经意的同名覆盖的现象，尽量用id属性而不要用name属性。

如果id和name都没有指定，则用类全名作为name，如,则你可以通过
getBean(“com.stamen.BeanLifeCycleImpl”)返回该实例。

dubbo reference id service ref 需要一样么

不需要
dubbo 和spring一块使用，service是把已有的service服务发布成dubbo服务，即通过ref引用已存在的service服务（即已存在的spring bean对象）
dubbo 和spring一块使用，reference是通过引用外部提供的dubbo服务，生成可供使用的service服务的，id属性自定义spring bean标识供消费客户端服务使用的

dubbo服务端和客户端的这两个属性定义没有相关性通过接口interface属性和版本等信息关联

003-link-interface

在这里插入图片描述

同样model类要进行串行化

package com.wsy.dubbo.model;

import java.io.Serializable;

public class Users implements Serializable {
    private Integer id;
    private String username;

    public Users() {
    }

    public Users(Integer id, String username) {
        this.id = id;
        this.username = username;
    }

    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;
    }

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

004-link-userservice-provider主要是来写接口的实现类

dubbo-userservice-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.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
<!--    声明服务提供者，保证唯一性-->
    <dubbo:application name="004-link-userservice-provider"></dubbo:application>
<!--    设置dubbo使用的协议和端口号 name是协议的名称 port是接口-->
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>
<!--    暴露接口-->
    <dubbo:service interface="com.wsy.dubbo.service.UserService" ref="userService" registry="N/A"></dubbo:service>
<!--    加载业务接口的实现类-->
    <bean id="userService" class="com.wsy.dubbo.service.impl.UserServiceImpl"></bean>

</beans>

005-link-consumer主要是通过controller来调用接口

dubbo-userservice-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="005-link-consumer"></dubbo:application>
    <dubbo:reference id="userService" interface="com.wsy.dubbo.service.UserService" url="dubbo://localhost:20880" registry="N/A"></dubbo:reference>

</beans>

注册中心概述

对于服务提供方，需要发布服务，而且由于系统的复杂性，服务的数量和类型也是在不断地膨胀；对于服务消费方，他最关心如何获取到它所需要的服务，面对复杂的应用系统，需要管理大量的服务调用。

dubbo官方推荐zookeeper注册中心，相当于一个小本本

zookeeper是Apache Hadoop的一个子项目，支持变更推送，适合作为Dubbo的服务注册中心，工业强度较高，可用于生产环境，并且推荐使用

在这里插入图片描述

ZooKeeper安装

才开始并没有安装上是因为java_home没有配置成功

Alt加下面的下划线就可以点击出来按钮，还是很方便的

ctrl+ I来实现接口的重写overide

@Autowired和@Resource 到底有什么区别那，带着疑问开启了抛坟模式。它们的区别到底在哪里。

    先说下@Resource注解，@Resource实际上并不是spring当中提供的注解。他和spring没有半毛钱关系，虽然他也实现了spring中bean注入功能。但是@Resource是javaEE的注解，它遵循的是JSR250规范。所以spring只有一个亲儿子那就是@Autowired。
    
   虽然亲儿子是Autowired，但是Resource并不比亲儿子差。他们都实现了bean注入的功能。
   而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的，分是name和type，Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。

@Resource装配顺序
　　1. 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常
　　2. 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常
　　3. 如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常
　　4. 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配；
那么接下来再说下spring的亲儿子@Autowired，Autowired同样实现了bean注入功能。只不过他是默认按照byType进行装配，如果匹配类型是多个直接抛出异常、当然这个问题是可以解决的那就是@Qualifier注解进行匹配。

mdol实体类：（还是必须去implement接口）

package com.bjpowernode.dubbo.model;

import java.io.Serializable;

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

    public User() {
    }

    public User(Integer id, String username) {
        this.id = id;
        this.username = username;
    }

    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;
    }

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

007-userservice-provider module

dubbo-zk-userservice.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="007-userservice-provider"></dubbo:application>
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>
<!--    指定zookeeper的注册中心-->
    <dubbo:registry address="zookeeper://localhost:2181"></dubbo:registry>
    <dubbo:service interface="com.bjpowernode.dubbo.service.UserService" ref="userService"></dubbo:service>
    <bean id="userService" class="com.bjpowernode.dubbo.service.impl.UserServiceImpl"></bean>

</beans>

web.xml的配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:dubbo-zk-userservice.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

008-zk-consumer moduled:

008-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="008-zk-consumer"></dubbo:application>
    <dubbo:registry address="zookeeper://localhost:2181"/>
    <dubbo:reference id="userService" interface="com.bjpowernode.dubbo.service.UserService"></dubbo:reference>

</beans>

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: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 https://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.bjpowernode.dubbo.web"></context:component-scan>
    <mvc:annotation-driven></mvc:annotation-driven>
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

</beans>

version的应用

不管一个接口是否有多个实现类，只要服务提供者提供服务的时候指定了版本号，那作为消费者进行远程调用的时候必须指定version

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LLqfA74r-1658136480458)(C:\Users\王率宇\AppData\Roaming\Typora\typora-user-images\image-20220715200708014.png)]$

009-muti-userservice-provider

dubbo-userservice-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.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <dubbo:application name="009-muti-userservice-provider"></dubbo:application>
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>
    <dubbo:registry address="zookeeper://localhost:2181"></dubbo:registry>
    <dubbo:service interface="com.bjpowernode.dubbo.service.UserService" ref="userService" version="1.0.0"></dubbo:service>
    <dubbo:service interface="com.bjpowernode.dubbo.service.UserService" ref="userService2" version="2.0.0"></dubbo:service>
    <bean id="userService" class="com.bjpowernode.dubbo.service.impl.UserServiceImpl"></bean>
    <bean id="userService2" class="com.bjpowernode.dubbo.service.impl.UserServiceImpl2"></bean>

</beans>

010-muti-consumer

userController的java类

package com.bjpowernode.dubbo.web;

import com.bjpowernode.dubbo.model.User;
import com.bjpowernode.dubbo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

//<bean id="userService" class="com.bjpowernode.dubbo.service.impl.UserServiceImpl"></bean>
//<bean id="userService2" class="com.bjpowernode.dubbo.service.impl.UserServiceImpl2"></bean>

@Controller
public class UserController {
    @Autowired
    UserService userService;
    @Autowired
    UserService userService2;
    @RequestMapping("/user")
    public String userdetail(Model model,Integer id){
        User user = userService.queryByIdName(11);
        User user1 = userService2.queryByIdName(11);
        model.addAttribute("u1", user);
        model.addAttribute("u2", user1);
        return "userdetail";
    }

}
package com.bjpowernode.dubbo.web;

import com.bjpowernode.dubbo.model.User;
import com.bjpowernode.dubbo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

//<bean id="userService" class="com.bjpowernode.dubbo.service.impl.UserServiceImpl"></bean>
//<bean id="userService2" class="com.bjpowernode.dubbo.service.impl.UserServiceImpl2"></bean>

@Controller
public class UserController {
    @Autowired
    UserService userService;
    @Autowired
    UserService userService2;
    @RequestMapping("/user")
    public String userdetail(Model model,Integer id){
        User user = userService.queryByIdName(11);
        User user1 = userService2.queryByIdName(11);
        model.addAttribute("u1", user);
        model.addAttribute("u2", user1);
        return "userdetail";
    }

}

dubbo-multi-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="010-muti-consumer"></dubbo:application>
    <dubbo:registry address="zookeeper://localhost:2181"></dubbo:registry>
    <dubbo:reference id="userService" interface="com.bjpowernode.dubbo.service.UserService" version="1.0.0"></dubbo:reference>
    <dubbo:reference id="userService2" interface="com.bjpowernode.dubbo.service.UserService" version="2.0.0"></dubbo:reference>

</beans>

王墨鱼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Dubbo分布式框架

对于服务提供方，需要发布服务，而且由于系统的复杂性，服务的数量和类型也是在不断地膨胀；对于服务消费方，他最关心如何获取到它所需要的服务，面对复杂的应用系统，需要管理大量的服务调用。dubbo官方推荐zookeeper注册中心，相当于一个小本本zookeeper是ApacheHadoop的一个子项目，支持变更推送，适合作为Dubbo的服务注册中心，工业强度较高，可用于生产环境，并且推荐使用ZooKeeper安装才开始并没有安装上是因为java_home没有配置成功mdol实体类。...
复制链接

扫一扫