Dubbo:软件架构、RPC、dubbo概述、dubbo的使用 直连方式

已于 2022-07-14 09:44:56 修改
阅读量317 收藏
点赞数 1
分类专栏： # Dubbo总结 文章标签： java 服务器 servlet
于 2022-07-13 19:17:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dengfengling999/article/details/125755711
版权

目录：

第一章：

（1）软件架构

（2）RPC

（3）dubbo概述

（4）dubbo的使用 直连方式

1.1软件架构 

（ 1 ） 单一应用架构
当网站流量很小时，应用规模小时，只需一个应用，将所有功能都部署在一起，以减少
部署服务器数量和成本。此时，用于简化增删改查工作量的数据访问框架 (ORM) 是关键。数
据库的处理时间影响应用的性能
                    

这种结构的应用适合小型系统，小型网站，或者企业的内部系统，用户较少，请求量不 大，对请求的处理时间没有太高的要求。 将所有功能都部署到一个服务器，简单易用。开 发项目的难度低。

缺点： 1、性能扩展比较困难 2、不利于多人同时开发 3、不利于升级维护 4、整个系统的空间占用比较大 

（3） 分布式服务架构

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

           

 1.2分布式系统

1.2.1 什么是分布式系统

分布式系统是若干独立计算机（服务器）的集合，这些计算机对于用户来说就像单个相 关系统，分布式系统（distributed system）是建立在网络之上的服务器端一种结构。 分布式系统中的计算机可以使用不同的操作系统，可以运行不同应用程序提供服务，将 服务分散部署到多个计算机服务器上。

1.2.2 RPC ？

RPC 【Remote Procedure Call】是指远程过程调用，是一种进程间通信方式，是一种技 术思想，而不是规范。它允许程序调用另一个地址空间（网络的另一台机器上）的过程或函 数，而不用开发人员显式编码这个调用的细节。调用本地方法和调用远程方法一样。

RPC 的实现方式可以不同。例如 java 的 rmi, spring 远程调用等。

RPC 概念是在上世纪 80 年代由 Brue Jay Nelson(布鲁·杰伊·纳尔逊)提出。使用 PRC 可以 将本地的调用扩展到远程调用（分布式系统的其他服务器）。

RPC 的特点：

1. 简单：使用简单，建立分布式应用更容易。 2. 高效：调用过程看起来十分清晰，效率高。 3. 通用：进程间通讯的方式，有通用的规则。

     

 PRC 调用过程：

1.调用方 client 要使用右侧 server 的功能（方法），发起对方法的调用

2.client stub 是 PRC 中定义的存根，看做是 client 的助手。stub 把要调用的方法参数进行序 列化，方法名称和其他数据包装起来。

3.通过网络 socket(网络通信的技术)，把方法调用的细节内容发送给右侧的 server

4.server 端通过 socket 接收请求的方法名称，参数等数据，传给 stub。

5.server 端接到的数据由 serverstub(server 的助手)处理，调用 server 的真正方法，处理业务 6.server 方法处理完业务，把处理的结果对象（Object）交给了助手，助手把 Object 进行序 列化，对象转为二进制数据。

7. server 助手二进制数据交给网络处理程序

8. 通过网络将二进制数据，发送给 client。

9.client 接数据，交给 client 助手。

10.client 助手，接收数据通过反序列化为 java 对象（Object），作为远程方法调用结果。 

其他： rpc 通讯是基于 tcp 或 udp 议

序列化方式（xml/json/二进制） 

2.1 dubbo 概述

Apache Dubbo (incubating) |ˈdʌbəʊ| 是一款高性能、轻量级的开源 Java RPC 框架，它提 供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和 发现。 Dubbo 是一个分布式服务框架，致力于提供高性能和透明化的 RPC 远程服务调用方案、服 务治理方案。

官网：http://dubbo.apache.org/zh-cn/ 

 dubbo：发展历程：  

面向接口代理：调用接口的方法，在 A 服务器调用 B 服务器的方法，由 dubbo 实现对 B 的 调用，无需关心实现的细节，就像 MyBatis 访问 Dao 的接口，可以操作数据库一样。不用关 心 Dao 接口方法的实现。这样开发是方便，舒服的。

2.2 基本架构

        

 服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注 册自己提供的服务。

服务消费者（Consumer）: 调用远程服务的服务消费方，服务消费者在启动时，向注册 中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一 台提供者进行调用，如果调用失败，再选另一台调用。

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

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

 调用关系说明:

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

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

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

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

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

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

2.5 直连方式 dubbo

点对点的直连项目:消费者直接访问服务提供者，没有注册中心。消费者必须指定服务 提供者的访问地址（url）。

消费者直接通过 url 地址访问固定的服务提供者。这个 url 地址是不变的。 

    

 

创建服务的提供者：

pom.xml:引入dubbo的依赖：

<?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.wkcto.dubbo</groupId>
  <artifactId>001-link-userservice-provider</artifactId>
  <version>1.0.0</version>
  <packaging>war</packaging>

  <name>001-link-userservice-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>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!--spring依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.16.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.16.RELEASE</version>
    </dependency>

    <!--dubbo依赖-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>dubbo</artifactId>
      <version>2.6.2</version>
    </dependency>
  </dependencies>

  <build>
    <!--编译级别：JDK1.8编译插件-->
     <plugins>
       <plugin>
         <artifactId>maven-compiler-plugin</artifactId>
         <version>3.1</version>
         <configuration>
           <source>1.8</source>
           <target>1.8</target>
         </configuration>
       </plugin>
     </plugins>
  </build>
</project>

 User类：

package com.wkcto.model;

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

UserService接口：

package com.wkcto.service;

import com.wkcto.model.User;

public interface UserService {

    //根据用户标识获取用户信息
    User queryUserById(Integer id);
}

UserServiceImpl：

package com.wkcto.service.impl;

import com.wkcto.model.User;
import com.wkcto.service.UserService;

public class UserServiceImpl implements UserService {
    @Override
    public User queryUserById(Integer id) {

        //调用持久层去查用户信息，这里只是模仿直接创建一个用户信息就行了
        User user=new User();
        user.setId(1001);
        user.setUsername("lisi");
        user.setAge(23);
        return user;
    }
}

服务创建好之后如何把这个服务暴露出去呢？这就用到dubbo的核心配置文件，跟spring的配置文件一样

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-link-userservice-provider"/>

    <!--访问服务协议的名称及端口号，dubbo官方推荐使用的是dubbo协议，端口号默认为20880
        name:指定协议的名称
        port：指定协议的端口号
    -->
    <dubbo:protocol name="dubbo" port="20880"/>
    
    <!--暴露服务的接口：
       interface：暴露服务接口的全限定名称
       ref：接口引用它的实现类在spring容器中标识
       registry：如果不使用注册中心，使用直连方式，则值为N/A
     -->
    <dubbo:service interface="com.wkcto.service.UserService" ref="userService" registry="N/A"/>

    <!--将接口的实现类加载到spring容器中-->
    <bean id="userService" class="com.wkcto.service.impl.UserServiceImpl"/>
</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-userservice-provider.xml</param-value>
    </context-param>

   <!--设置监听器-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

配置tomcat：

创建服务的消费者：

创建一个新的Model：

把001-link-userservice-provider打成一个架包，发到本地仓库：002Model会引用001

按两下Ctrl 

 引入依赖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.wkcto.dubbo</groupId>
  <artifactId>002-link-consumer</artifactId>
  <version>1.0.0</version>
  <packaging>war</packaging>

  <name>002-link-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>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!--spring依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.16.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.16.RELEASE</version>
    </dependency>

    <!--dubbo依赖-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>dubbo</artifactId>
      <version>2.6.2</version>
    </dependency>

    <!--依赖服务提供者-->
    <dependency>
      <groupId>com.wkcto.dubbo</groupId>
      <artifactId>001-link-userservice-provider</artifactId>
      <version>1.0.0</version>
    </dependency>

  </dependencies>

  <build>

  </build>
</project>

消费者的核心配置文件：

dubbo-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="002-link-consumer"/>

    <!--
        引用远程服务接口
        id：远程服务接口对象的名称
        interface：调用远程接口的全限定类名
        url：访问服务接口的地址
        registry：不使用注册中心，值为N/A
    -->
    <dubbo:reference id="userService" interface="com.wkcto.service.UserService" url="dubbo://localhost:20880" registry="N/A"/>

</beans>

spring配置文件application.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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"

       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 http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--扫描控制层 组件-->
    <context:component-scan base-package="com.wkcto.dubbo.web"/>

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

    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </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">

    <!--中央调度器-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>com.alibaba.dubbo.remoting.http.servlet.DispatcherServlet</servlet-class>
        <!--初始化参数-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:application.xml,classpath:dubbo-consumer.xml</param-value>
        </init-param>

    </servlet>
    
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <!--拦截所有请求-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

   <!--设置监听器-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

控制器：UserController：

package com.wkcto.dubbo.web;

import com.wkcto.model.User;
import com.wkcto.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(value = "/user")
    public String userDetil(Model model,Integer id){
        User user=userService.queryUserById(id);
        model.addAttribute("user",user);
        return "userDetail";
    }
}

创建jsp页面userDetail.jsp:

<%--
  Created by IntelliJ IDEA.
  User: DELL
  Date: 2022/7/13
  Time: 17:30
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
%>
<html>
<head>
    <title>用户详情</title>
    <base href="<%=basePath%>">
</head>
<body>
  <h1>用户详情</h1>
  <div>用户标识：${user.id}</div>
  <div>用户名称：&{user.username}</div>
</body>
</html>

配置tomcat：

先运行项目一服务提供者的tomcat，在运行项目二消费者的tomcat

在地址栏输入：地址

消费者依赖了提供者，就不在需要使用这个userService接口了， 在控制类中可以直接new出来接口的实现类，调用里面的方法，这样就跟dubbo没有关系了

dubbo是面向的这个接口，以接口为粒度，这里可以new出接口的实现类，就不需要dubbo，基于这种情况，dubbo要求这个工程里面需要一个接口工程 

中间是接口工程，左边是消费者，右边是服务提供者

服务提供者：把你暴露的接口放到这个接口工程里面

服务消费者：从接口工程里面获得暴露的接口

这样就不能new出来这个实现类了，只能通过RPC远程方法协议调用

喵俺第一专栏
关注
专栏目录
Dubbo架构设计详解
ZCC的专栏
06-10 4596
转载出处 参考 Dubbo开源 直到2011年10月27日，阿里巴巴开源了自己的SOA服务化治理方案的核心框架Dubbo，服务治理和SOA的设计理念开始逐渐在国内软件行业中落地，并被广泛应用。 Dubbo作为阿里巴巴内部的SOA服务化治理方案的核心框架，在2012年时已经每天为2000+个服务提供3,000,000,000+次访问量支持，并被广泛应用于阿里巴巴集团的各成员站点。Dubbo自...
Dubbo的简单使用
liming0025的专栏
07-08 6886
一、架构演进 单体架构 垂直应用架构：根据业务边界拆分，每个功能称为一个服务 公共的业务service，导致很多部分的冗余 分布式应用架构：把公共服务器的service提取成一个服务 网络通讯的问题，使用RPC框架 服务集群的负载均衡处理 服务如何被发现 服务如何被治理 服务之间如何高效的通信 微服务架构，主要解决以下几个问题 服务的注册和发现 服务的搞笑通信 服务的治理：服务权重、负载均衡、服务熔断、限流等等 二、注册中心 1、概述 主流的注册中心：
Springboot整合dubbo（一）：搭建一个springboot + dubbo的微服务
m0_67393039的博客
04-08 1539
现在越来越多的公司开发项目中使用了springboot作为搭建服务的框架，因为springboot集成了一套完整项目所需要的基本的开发工具的jar包，无需再像之前开发一个spring项目中需要引入各种配置，只需要引入简单的几个配置就能达到项目的启动，大大减少了开发周期，使开发越来越便捷，而dubbo是一款国内使用较多的SOA架构开发的中间件，其主要由三个部分组成：生产者，消费者，注册中心。注册中心一般使用的是zookeeper。于是我们从头来捋一捋如何搭建一个springboot+dubbo项目。 首先，使
Dubbo——初识RPC、Dubbo框架、使用直连方式实现Dubbo
★★光亭★★
05-27 7868
Dubbo——初识RPC、Dubbo框架、使用直连方式实现Dubbo
RPC框架：dubbo的基本使用
weixin_45565886的博客
10-20 1460
RPC框架：dubbo的基本使用
分布式RPC框架Dubbo详解
qq_43649937的博客
05-31 5798
分布式，微服务，dubbo, java
微服务学习 | Springboot整合Dubbo+Nacos实现RPC调用
热门推荐
qq_35716689的博客
02-18 2万+
Dubbo是一个基于Java的高性能RPC (远程过程调用)框架。作者：牵着猫散步的鼠鼠
org.apache.dubbo.rpc.RpcException: Fail to start server(url: dubbo://192.168.82.190:20882/service
四季轮换叶，一路招摇胜
04-19 1323
org.apache.dubbo.rpc.RpcException: Fail to start server(url: dubbo://192.168.0.9:20882/service.UserI
Dubbo：RPC原理
qq_43842093的博客
02-24 1333
1、RPC原理 一次完整的RPC调用流程如下： 1）服务消费方（client）调用以本地调用方式调用服务； 2）client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体； 3）client stub找到服务地址，并将消息发送到服务端； 4）server stub收到消息后进行解码； 5）server stub根据解码结果调用本地的服务； 6）本地服务执行并将结果返回给server stub； 7）server stub将返回结果打包成消息并发送至消费方； 8）client st
Dubbo 直连方式
h259077的博客
12-16 1184
Dubbo是一个分布式服务框架，致力于提高性能和透明化的RPC远程服务调用方案， 服务治理方案。
Apache Dubbo：Dubbo与微服务架构：集成与实践
07-12
Apache Dubbo作为一款优秀的RPC框架，不仅能够有效地支持微服务架构下的服务通信，还能提供一系列高级特性来增强系统的稳定性和可扩展性。通过深入理解微服务架构的核心概念及其优势与挑战，结合Apache Dubbo的实际...
easyway-dubbo:阿里巴巴 rpc dubbo 框架
07-02
Dubbo is a distributed service framework enpowers applications with service import/export capability with high performance RPC. It's composed of three kernel parts: Remoting: a network communication ...
Apache Dubbo：Dubbo监控与运维：服务性能分析
07-12
### Apache Dubbo：Dubbo监控与运维：服务性能分析 #### 一、Dubbo监控概述 ##### 1.1 Dubbo监控的重要性 在现代微服务架构中，由于服务之间存在着复杂的调用关系，任何单一服务的性能问题都有可能对整体系统稳定...
Apache Dubbo：Dubbo配置与参数详解
07-12
同样地，这也可以在XML配置文件中使用`<dubbo:reference>`标签或在代码中使用`@Reference`注解来完成。 - **使用`@Reference`注解**: ```java @Reference(version = "1.0.0") private DemoService demoService;...
Spring Boot 学习和使用
cesske的博客
09-24 1048
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
工厂模式的介绍及实现
户伟伟的博客
09-25 108
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 332
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 235
BI商业智能：数据可视化、报表可视化系统。
揭秘Dubbo：高性能RPC服务框架与透明调用实践
Dubbo是中国阿里巴巴集团B2B平台技术部门开发的一款分布式服务框架，主要用于实现高性能和透明化的远程过程调用（RPC）服务。Dubbo最初在2011年12月发布，其设计目标是简化服务间通信，并提供一套全面的服务治理解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

喵俺第一专栏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值