dubbo使用最佳实践

最新推荐文章于 2022-09-29 20:08:32 发布
最新推荐文章于 2022-09-29 20:08:32 发布
阅读量125 收藏
点赞数
文章标签： java 大数据 shell
原文链接：https://my.oschina.net/yaphis/blog/615316
版权

简介

关于dubbo的原理及api zookeeper的使用 可自行百度

dubbo官网 http://dubbo.io/

工程代码结构

222650_4wns_2285424.png

接口层（archetype-dubbo-api）

223050_T3Mm_2285424.png

package com.yaphis.archetype.dubbo.api;

import com.yaphis.archetype.dubbo.api.bean.Request;
import com.yaphis.archetype.dubbo.api.bean.Response;

/**
 * 需要暴露的接口定义
 * 
 * @author yaphis 2016年2月15日 下午10:32:37
 */
public interface DubboService {

    public Response execute(Request request);
}
package com.yaphis.archetype.dubbo.api.bean;

import java.io.Serializable;

/**
 * 接口请求实体(必须序列化)
 * 
 * @author yaphis 2016年2月15日 下午10:33:38
 */
public class Request implements Serializable {

    private static final long serialVersionUID = -6108135813653701709L;

    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Request [name=" + name + "]";
    }
}
package com.yaphis.archetype.dubbo.api.bean;

import java.io.Serializable;

/**
 * 接口响应实体(必须序列化)
 * 
 * @author yaphis 2016年2月15日 下午10:33:55
 */
public class Response implements Serializable {

    private static final long serialVersionUID = -758877214314064622L;

    private String resCode;
    private String resMsg;

    public Response(String resCode, String resMsg) {
        super();
        this.resCode = resCode;
        this.resMsg = resMsg;
    }

    public String getResCode() {
        return resCode;
    }

    public void setResCode(String resCode) {
        this.resCode = resCode;
    }

    public String getResMsg() {
        return resMsg;
    }

    public void setResMsg(String resMsg) {
        this.resMsg = resMsg;
    }

    @Override
    public String toString() {
        return "Response [resCode=" + resCode + ", resMsg=" + resMsg + "]";
    }
}
package com.yaphis.archetype.dubbo.api.mock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.yaphis.archetype.dubbo.api.DubboService;
import com.yaphis.archetype.dubbo.api.bean.Request;
import com.yaphis.archetype.dubbo.api.bean.Response;

/**
 * 接口本地Mock实现(在dubbo服务调用异常时会默认调用该实现，可用取代try-catch做服务降级)
 * 
 * @author yaphis 2016年2月15日 下午10:35:09
 */
public class DubboServiceMock implements DubboService {

    private static final Logger LOG = LoggerFactory.getLogger(DubboServiceMock.class);

    @Override
    public Response execute(Request request) {
        LOG.info("DubboServiceMock execute!");
        Response response = new Response("999999", "系统异常");
        return response;
    }
}

服务提供者（archetype-dubbo-service）

223852_k1Vr_2285424.png

package com.yaphis.archetype.dubbo.api.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import com.alibaba.dubbo.rpc.RpcContext;
import com.yaphis.archetype.dubbo.api.DubboService;
import com.yaphis.archetype.dubbo.api.bean.Request;
import com.yaphis.archetype.dubbo.api.bean.Response;

/**
 * 暴露的接口在服务提供者端的实现
 * 
 * @author yaphis 2016年2月15日 下午10:39:09
 */
@Service
public class DubboServiceImpl implements DubboService {

    private static final Logger LOG = LoggerFactory.getLogger(DubboServiceImpl.class);

    @Override
    public Response execute(Request request) {
        LOG.info("ThreadName:{}", RpcContext.getContext().getAttachment("ThreadName"));// 获取隐式参数 可用来做框架通用参数透传，例如跟踪日志等
        LOG.info("DubboServiceImpl execute!request:{}", request);
        Response response = new Response("000000", "成功");
        return response;
    }
}
package com.yaphis.archetype.dubbo.api.impl;

import com.alibaba.dubbo.container.Main;

/**
 * dubbo服务端启动类(通过shell脚本启动)
 * 
 * @author Yaphis 2016年2月2日 下午2:29:05
 */
public class Server {

    public static void main(String[] args) {
        // 把spring配置文件放在META-INF/spring目录下，dubbo启动容器会自动加载 这是推荐的做法
        Main.main(args);// 服务提供者启动只有这一行代码，因此其实也可以通过shell直接启动com.alibaba.dubbo.container.Main类
    }
}

archetype-dubbo-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:context="http://www.springframework.org/schema/context" xmlns:amq="http://activemq.apache.org/schema/core"
	xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd"
	default-lazy-init="false">
	<!-- 自动扫描 -->
	<context:component-scan base-package="com.yaphis.archetype.dubbo.api.impl" />
	<!-- 加载配置文件、利用spring的属性替换解决测试、生产环境的差异 -->
	<context:property-placeholder location="classpath:config.properties" />
	<!-- dubbo配置 -->
	<dubbo:application name="archetype-dubbo-service" logger="slf4j" />
	<!-- 注册中心支持zookeeper、redis、Muticast、Simple注册中心 -->
	<!-- 推荐使用zookeeper作为注册中心 多个address间用,分隔 -->
	<dubbo:registry protocol="zookeeper" address="${zookeeper.address}" client="zkclient" />
	<!-- 协议类型和暴露服务的端口 -->
	<dubbo:protocol name="dubbo" port="${server.port}" />
	<!-- 暴露的服务 -->
	<!-- delay=-1延迟到spring容器启动完成再暴露服务 强烈不建议使用applicationContext显式获取bean,应该像本例一样使用ioc依赖注入获取bean -->
	<dubbo:service interface="com.yaphis.archetype.dubbo.api.DubboService" ref="dubboServiceImpl" delay="-1" />
	<!-- 超时时间 服务提供方更加清楚每个服务的耗时 这边进行设置是更加合理的 -->
	<dubbo:provider timeout="5000" />
</beans>

config.properties

#这里的配置 可以用${zookeeper.address}占位符的形式，用maven的profile替换 来解决线上、测试环境配置的差异配置问题
zookeeper.address=127.0.0.1:2181
server.port=20880

#配置1
config1=${config1}

dubbo.properties

#dubbo的配置文件,启动时会自动读取类路径下的该配置文件 与xml配置效果相同
dubbo.container=spring,log4j
dubbo.service.loadbalance=random

logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
	<property name="LOG_PATH" value="/var/logs/archetype-dubbo-service/" />
	<property name="LOG_PATTEN" value="[%-5level] %d{HH:mm:ss.SSS} [%X{ThreadName}] [%logger{64}:%line] >>> %msg%n" />

	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
			<Pattern>${LOG_PATTEN}</Pattern>
		</encoder>
	</appender>

	<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
		<File>${LOG_PATH}/service.log</File>
		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<FileNamePattern>${LOG_PATH}/service_%d{yyyy-MM-dd}.log</FileNamePattern>
		</rollingPolicy>
		<encoder charset="UTF-8">
			<pattern>${LOG_PATTEN}</pattern>
		</encoder>
	</appender>

	<appender name="ERRORFILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
		<File>${LOG_PATH}/errorService.log</File>
		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<FileNamePattern>${LOG_PATH}/errorService_%d{yyyy-MM-dd}.log</FileNamePattern>
		</rollingPolicy>
		<encoder charset="UTF-8">
			<pattern>${LOG_PATTEN}</pattern>
		</encoder>
		<filter class="ch.qos.logback.classic.filter.LevelFilter">
			<level>ERROR</level>
			<OnMismatch>DENY</OnMismatch>
			<OnMatch>ACCEPT</OnMatch>
		</filter>
	</appender>

	<root>
		<level value="DEBUG" />
		<appender-ref ref="STDOUT" />
		<appender-ref ref="FILE" />
		<appender-ref ref="ERRORFILE" />
	</root>
</configuration>

pom.xml（仅贴出maven依赖部分代码，jar包版本号定义在父工程，可百度最新的jar版本）

<dependencies>
		<!-- project -->
		<dependency>
			<groupId>com.yaphis</groupId>
			<artifactId>archetype-dubbo-api</artifactId>
			<version>${project.version}</version>
		</dependency>
		<!-- spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>commons-logging</artifactId>
					<groupId>commons-logging</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- dubbo -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>dubbo</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>spring</artifactId>
					<groupId>org.springframework</groupId>
				</exclusion>
				<exclusion>
					<artifactId>netty</artifactId>
					<groupId>org.jboss.netty</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- zookeeper -->
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>slf4j-log4j12</artifactId>
					<groupId>org.slf4j</groupId>
				</exclusion>
				<exclusion>
					<artifactId>log4j</artifactId>
					<groupId>log4j</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>com.101tec</groupId>
			<artifactId>zkclient</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>slf4j-log4j12</artifactId>
					<groupId>org.slf4j</groupId>
				</exclusion>
				<exclusion>
					<artifactId>log4j</artifactId>
					<groupId>log4j</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>commons-logging</artifactId>
					<groupId>commons-logging</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- log4j zookeeper依赖 -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
		</dependency>
	</dependencies>

消费者（archetype-dubbo-client）

225759_Kldz_2285424.png

package com.yaphis.archetype.dubbo.client;

import java.util.UUID;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.alibaba.dubbo.rpc.RpcContext;
import com.yaphis.archetype.dubbo.api.DubboService;
import com.yaphis.archetype.dubbo.api.bean.Request;
import com.yaphis.archetype.dubbo.api.bean.Response;

/**
 * 消费者调用方式，直接使用依赖注入
 * 
 * @author yaphis 2016年2月15日 下午11:04:16
 */
@Service
public class ClientService {

    private static final Logger LOG = LoggerFactory.getLogger(ClientService.class);

    @Autowired
    private DubboService dubboService;

    public void call() {
        RpcContext.getContext().setAttachment("ThreadName", UUID.randomUUID().toString());// 隐式传参
        Request request = new Request();
        request.setName("yaphis");
        Response response = dubboService.execute(request);
        LOG.info("response:{}", response);
    }
}
package com.yaphis.archetype.dubbo.client;

import java.util.Arrays;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 消费者启动类
 * 
 * @author yaphis 2016年2月15日 下午11:03:12
 */
public class Client {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:META-INF/spring/*.xml");
        System.out.println(Arrays.toString(context.getBeanDefinitionNames()));
        ClientService clientService = context.getBean(ClientService.class);
        clientService.call();
    }
}

archetype-dubbo-client.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:amq="http://activemq.apache.org/schema/core"
	xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd"
	default-lazy-init="false">

	<context:component-scan base-package="com.yaphis.archetype.dubbo.client" />
	<!-- dubbo配置 -->
	<dubbo:application name="archetype-dubbo-client" logger="slf4j" />
	<!-- 注册中心支持zookeeper、redis、Muticast、Simple注册中心 -->
	<!-- 多个address间用,分隔 -->
	<dubbo:registry protocol="zookeeper" address="127.0.0.1:2181" client="zkclient" />
	<!-- 暴露的服务 -->
	<dubbo:reference id="dubboService" interface="com.yaphis.archetype.dubbo.api.DubboService" check="false" />
	<!-- mock使用 -->
	<!-- mock属性 当发生RPC异常的时候调用，用于做服务降级,一般情况不需要，开启mock时建议打开dubbo的info日志否则看不到异常 -->
	<!-- <dubbo:reference id="dubboService" interface="com.yaphis.archetype.dubbo.api.DubboService" mock="com.yaphis.archetype.dubbo.api.mock.DubboServiceMock" check="false" /> -->
	<!-- 超时时间 -->
	<dubbo:consumer timeout="5000" />
	<!-- 启动检查 -->
	<!-- <dubbo:consumer check="false" /> -->
	<!-- 直连测试 仅适合用在测试环境 -->
	<!-- <dubbo:reference id="dubboService" interface="com.yaphis.archetype.dubbo.api.DubboService" url="dubbo://127.0.0.1:20880" /> -->

</beans>

pom.xml(仅贴出maven依赖，jar版本号定义在父工程，可直接百度最新的版本号)

<dependencies>
		<!-- project -->
		<dependency>
			<groupId>com.yaphis</groupId>
			<artifactId>archetype-dubbo-api</artifactId>
			<version>${project.version}</version>
		</dependency>
		<!-- spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>commons-logging</artifactId>
					<groupId>commons-logging</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- dubbo -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>dubbo</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>spring</artifactId>
					<groupId>org.springframework</groupId>
				</exclusion>
				<exclusion>
					<artifactId>netty</artifactId>
					<groupId>org.jboss.netty</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- zookeeper -->
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>slf4j-log4j12</artifactId>
					<groupId>org.slf4j</groupId>
				</exclusion>
				<exclusion>
					<artifactId>log4j</artifactId>
					<groupId>log4j</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>com.101tec</groupId>
			<artifactId>zkclient</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>slf4j-log4j12</artifactId>
					<groupId>org.slf4j</groupId>
				</exclusion>
				<exclusion>
					<artifactId>log4j</artifactId>
					<groupId>log4j</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<exclusions>
				<exclusion>
					<artifactId>commons-logging</artifactId>
					<groupId>commons-logging</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- log4j zookeeper依赖 -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
		</dependency>
	</dependencies>


转载于:https://my.oschina.net/yaphis/blog/615316

chizhu5318
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【微服务】Dubbo的最佳实践
陌北有棵树的博客
02-10 1703
以下是Dubbo的一些最佳实践整理，可以当做一张Dubbo的使用说明书，具体的原理分析后续再详写，这里就言简意赅的说明用法，且大部分来自官方文档： 【一】服务化最佳实践 分包 服务接口、服务模型、服务异常等均放在 API 包中，符合REP（重用发布原则），CRP（共同重用原则） 粒度 服务接口尽可能大粒度，避免分布式事务，因为Dubbo暂未提供分布式事务支持。 服务接口建议以业务场景为...
最佳实践 — Dubbo 服务化进程的一点思考
12-22
但在使用 dubbo 服务化就依赖版本这个概念。在项目中我们打包的方式和项目的版本的是相互绑定的。 这对于运维来说其实是一种负担。每次修改版本的时候都开发修改 build 脚本。而且运维也需要在CI/CD 的脚本也需要...
Dubbo：dubbo 服务化最佳实践
dengfengling999的博客
07-14 244
由于直连方式中存在的问题，改造 dubbo 项目：抽象分散在多个项目中的公共接口，实体类，异常，工具类到一个项目中，在其他项目 如服务提供者，消费者共用公共的资源。2.6.1 分包建议将服务接口、服务模型、服务异常等均放在公共包中。 就是接口工程2.6.2 粒度服务接口尽可能大粒度，每个服务方法应代表一个功能，而不是某功能的一个步骤， 否则将面临分布式事务问题，Dubbo 暂未提供分布式事务支持。服务接口建议以业务场景为单位划分，并对相近业务做抽象，防止接口数量爆炸。不建议使用过于抽象的通用接口，如：Map
Dubbo API 笔记——Dubbo协议&最佳实践
asdfadafd的博客
08-14 287
Dubbo缺省协议采用单一长连接和NIO异步通讯，适合于小数据量大并发的服务调用，以及服务消费者机器远大于服务提供者机器数的情况反之，Dubbo 缺省协议不适合传送大数据量的服务，比如传文件，传视频等，除非请求量很低缺省协议，使用基于 mina 1.1.7 和 hessian 3.2.1 的 tbremoting 交互数据通讯情况A->B类A多一种属性（或者说类B少一种属性）A->B枚举A多一种枚举（或者说B少一种枚举），A使用多出来的枚举进行传输A->B。...
3、dubbo 服务化最佳实践
a1037352798的博客
06-11 1113
将服务接口、服务模型、服务异常等均放在公共包中，不再让消费者和生产者直接沟通，而是通过中介，这也是直连的一种。 这是之前采用直连的样子 这是我们现在要用的最佳直连方式 要想实现这个方式来个简单模拟，首先新建一个服务提供者，消费者，接口者 先说接口工程 新建一个java工程，把实体类和服务接口类 然后新建服务提供类 1导入依赖 2然后写实现上面接口工程的接口的实现方法 3写配置文件dubbo.xml和web.xml <?xml version="1.0" encoding="UTF-8"?&gt
Dubbo最佳实践，我整理了以下9点
u010889990的专栏
10-16 1784
点击上方蓝色字关注我们~Dubbo服务化，在当前互联网后端开发中，大部分都使用了Dubbo。截止目前github dubbo上，star也将近3万，使用dubbo的公司数...
xbs-springboot-dubbo:SpringBoot整合Dubbo最佳实践
05-17
xbs-springboot-dubboSpringBoot整合Dubbo最佳实践(1)dubbo-spring-boot-api 是接口工程，dubbo服务的提供者和消费者都会依赖此工程；(2)dubbo-spring-boot-client 是 dubbo 服务的消费者，它会从 dubbo-spring-boot...
dubbo-spring-boot-best-practice:Dubbo Spring Boot 最佳实践整合 Demo
05-18
dubbo-spring-boot-best-praticedubbo-spring-boot-best-pratice 是 Dubbo Spring Boot 最佳实践整合 DemoRoadmap利用 Dubbo Spring Boot Starter 项目整合 Dubbo注册中心：ZooKeeper / ETCD 两种实现同一个 API ，...
dubbo技术介绍
04-26
用户指南 ...服务化最佳实践 分包 粒度 版本 兼容性 枚举值 序列化 异常 调用 推荐用法 容量规划 基准测试工具包 性能测试报告 测试说明 测试环境 测试目的 测试脚本 测试结果 测试分析 测试覆盖率报告
Apache Dubbo3 源码深入解析
04-07
务提供服务发现、流量治理、可观测、认证鉴权等能力、工具与最佳实践。 使用 Dubbo 开发的微服务原生具备相互之间的远程地址发现与通信能力，利用 Dubbo 提供的丰富服务治理特性，可以实现诸如服务发现、负载均衡...
dubbo服务化最佳实践
wh柒八九的博客
03-14 840
本文来说下dubbo服务化最佳实践 文章目录概述 概述 dubbo的服务化最佳实践包括分包, 粒度, 版本, 兼容性, 枚举, 序列化, 异常等内容，详细信息可以看官网提供的内容
十二：Dubbo高级特性（二）服务提供者异步
qq_36364521的博客
03-29 2076
Apache Dubbo服务提供者异步 Apache Dubbo在新版加入了服务提供者异步 服务提供者异步在提升性能和响应时长没有任何用处 服务提供者异步旨在尽量规避Dubbo任务处理的瓶颈 图示： 代码演示 provider端接口实现 public class ServiceDemoImpl implements ServiceDemo { private Executor executor = new ThreadPoolExecutor(2, 4, 1, Time
Dubbo---dubbo服务化最佳实践
hcz666的博客
03-21 268
目录一、dubbo服务化最佳实践1、分包2、改造dubbo项目实现项目：（1）创建公共接口资源项目（2）创建服务提供资源项目（3）创建服务消费资源项目（4）发布项目 一、dubbo服务化最佳实践 1、分包 建议将服务接口、服务模型、服务异常等均放在公共包中 2、改造dubbo项目 抽象分散在多个项目中的公共接口，实体类，异常，工具类到一个项目中 实现项目： 目录结构 （1）创建公共接口资源项目 （2）创建服务提供资源项目 （3）创建服务消费资源项目 （4）发布项目
APISIX+Dubbo+Nacos 最佳实践
阿里巴巴中间件
09-29 1912
01项目简介Aliware01ApacheAPISIXApache APISIX 是 Apache 软件基金会下的云原生 API 网关，它具有多平台支持、精细化路由、运维友好和插件支持的优点特点。1. 多平台支持：APISIX 提供了多平台解决方案，它不但支持裸机运行，也支持在 Kubernetes 中使用，还支持与 AWS Lambda、Azure Function、Lua 函数和 Apac...
最佳实践 -- Dubbo 服务化进程的一点思考
carl.zhao的专栏
03-19 642
最近主要负责公司的 dubbo 服务改造。在改造过程中，涉及到很多核心系统的编码。改造的系统涉及到核心系统，并且改造的系统一多，难免会产生一点胡思乱想。下面我就分享一下我在项目改造过程中的一点胡乱的想法。需要对大家有帮助： 1、统一的打包方式 对于之前项目中使用 restful 进行交互，项目的发布就没有版本这个概念。但在使用 dubbo 服务化就依赖版本这个概念。在项目中我们打包的方式和项目的版...
springboot 整合dubbo最佳实践 (使用redis作为注册中心)
xueyunzi1的博客
08-30 948
参考原文 一 概述       Apache Dubbo (incubating) |ˈdʌbəʊ| 是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。  面向接口代理的高性能RPC调用 提供高性能的基于代理的远程调用能力，服务以接口为粒度，为开发者屏蔽远程调用底层细节。 智能负载均衡 ...
对外提供dubbo服务的最佳实践
weixin_34309543的博客
06-21 498
为什么80%的码农都做不了架构师？>>> ...
阿里技术团队推荐：Dubbo 服务化最佳实践
编程者说的博客专栏
11-15 261
Dubbo是阿里巴巴SOA服务化治理方案的核心框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。下面我们来看下服务化的最佳实践。 分包 建议将服务接口、服务模型、服务异常等均放在 API 包中，因为服务模型和异常也是 API 的一部分，这样做也符合分包原则：重用发布等价原则(REP)，共同重用原则(CRP)。 如果需要，也可以考虑在 API 包中放置一...
网易考拉在服务化改造方面的实践
cpongo011702
03-02 588
网易考拉（以下简称考拉）是网易旗下以跨境业务为主的综合型电商，自2015年1月9日上线公测后，业务保持了高速增长，这背后离不开其技术团队的支撑。微服务化是电商IT架构演化的必然趋势，网易考拉的服务架构演进也经历了从单体应用走向微服务化的整个过程，以下整理自网易考拉陶杨在近期Apache Dubbo Meetup上的分享，通过该文，您将了解到：考拉架构的演进过程考拉在服务化改造方面的实践考拉在解决注...
dubbo使用EagerThreadPoolExecutor
最新发布
11-07
Dubbo使用EagerThreadPoolExecutor作为默认的线程池实现，它是基于JDK的ThreadPoolExecutor实现的，但是重写了execute和afterExecute方法，增加了任务计数和线程池的动态扩容机制。EagerThreadPoolExecutor会在任务...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值