备案控制台
开发者社区 云原生 中间件 文章 正文

手写RPC框架第三章《RPC中间件》

2022-01-12 437
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
服务治理 MSE Sentinel/OpenSergo，Agent数量 不受限
简介： 1、注册中心，生产者在启动的时候需要将本地接口发布到注册中心，我们这里采用redis作为注册中心，随机取数模拟权重。2、客户端在启动的时候，连接到注册中心，也就是我们的redis。连接成功后将配置的生产者方法发布到注册中心{接口+别名}。3、服务端配置生产者的信息后，在加载xml时候由中间件生成动态代理类，当发生发放调用时实际则调用了我们代理类的方法，代理里会通过netty的futuer通信方式进行数据交互。

案例介绍

结合上面两章节，本章将实现rpc的基础功能；提供一个rpc中间件jar给生产端和服务端。

技术点；

1、注册中心，生产者在启动的时候需要将本地接口发布到注册中心，我们这里采用redis作为注册中心，随机取数模拟权重。

2、客户端在启动的时候，连接到注册中心，也就是我们的redis。连接成功后将配置的生产者方法发布到注册中心{接口+别名}。

3、服务端配置生产者的信息后，在加载xml时候由中间件生成动态代理类，当发生发放调用时实际则调用了我们代理类的方法，代理里会通过netty的futuer通信方式进行数据交互。

环境准备

1、jdk 1.8.0

2、IntelliJ IDEA Community Edition 2018.3.1 x64

3、windows redis

代码示例

| 源码获取，关注公众号：bugstack虫洞栈 | 回复RPC案例

1itstack-demo-rpc-03
 2└── src
 3    └── main
 4    │    ├── java
 5    │    │    └── org.itstack.demo.rpc
 6    │    │        ├── config
 7    │    │        ├── domain
 8    │    │        ├── network    
 9    │    │        │   ├── client
10    │    │        │   │   ├── ClientSocket.java
11    │    │        │   │   └── MyClientHandler.java  
12    │    │        │   ├── codec
13    │    │        │   │   ├── RpcDecoder.java
14    │    │        │   │   └── RpcEncoder.java  
15    │    │        │   ├── future
16    │    │        │   │   ├── SyncWrite.java     
17    │    │        │   │   ├── SyncWriteFuture.java    
18    │    │        │   │   ├── SyncWriteMap.java    
19    │    │        │   │   └── WriteFuture.java    
20    │    │        │   ├── msg
21    │    │        │   │   ├── Request.java
22    │    │        │   │   └── Response.java 
23    │    │        │   ├── server
24    │    │        │   │   ├── MyServerHandler.java
25    │    │        │   │   └── ServerSocket.java     
26    │    │        │   └── util
27    │    │        │       └── SerializationUtil.java    
28    │    │        ├── reflect
29    │    │        │   ├── JDKInvocationHandler.java    
30    │    │        │   └── JDKProxy.java
31    │    │        ├── registry
32    │    │        │   └── RedisRegistryCenter.java    
33    │    │        └── util    
34    │      └── resource
35    │        └── META-INF
36    │            ├── rpc.xsd
37    │            ├── spring.handlers
38    │            └── spring.schemas    
39
40    └── test
41         ├── java
42         │   └── org.itstack.demo.test
43         │       ├── service
44         │       │   ├── impl
45         │        │   │   └── HelloServiceImpl.java  
46         │        │   └── HelloService.java
47         │       └── ApiTest.java                 
48         └── resource  
49             ├── itstack-rpc-center.xml
50             ├── itstack-rpc-consumer.xml         
51             ├── itstack-rpc-provider.xml
52             └── log4j.xml

ConsumerBean.java

1package org.itstack.demo.rpc.config.spring.bean;
 2
 3import com.alibaba.fastjson.JSON;
 4import io.netty.channel.ChannelFuture;
 5import org.itstack.demo.rpc.config.ConsumerConfig;
 6import org.itstack.demo.rpc.domain.RpcProviderConfig;
 7import org.itstack.demo.rpc.network.client.ClientSocket;
 8import org.itstack.demo.rpc.network.msg.Request;
 9import org.itstack.demo.rpc.reflect.JDKProxy;
10import org.itstack.demo.rpc.registry.RedisRegistryCenter;
11import org.itstack.demo.rpc.util.ClassLoaderUtils;
12import org.springframework.beans.factory.FactoryBean;
13import org.springframework.util.Assert;
14
15/**
16 * http://www.itstack.org
17 * create by fuzhengwei on 2019/5/6
18 */
19public class ConsumerBean<T> extends ConsumerConfig<T> implements FactoryBean {
20
21    private ChannelFuture channelFuture;
22
23    private RpcProviderConfig rpcProviderConfig;
24
25    @Override
26    public Object getObject() throws Exception {
27
28        //从redis获取链接
29        if (null == rpcProviderConfig) {
30            String infoStr = RedisRegistryCenter.obtainProvider(nozzle, alias);
31            rpcProviderConfig = JSON.parseObject(infoStr, RpcProviderConfig.class);
32        }
33        Assert.isTrue(null != rpcProviderConfig);
34
35        //获取通信channel
36        if (null == channelFuture) {
37            ClientSocket clientSocket = new ClientSocket(rpcProviderConfig.getHost(), rpcProviderConfig.getPort());
38            new Thread(clientSocket).start();
39            for (int i = 0; i < 100; i++) {
40                if (null != channelFuture) break;
41                Thread.sleep(500);
42                channelFuture = clientSocket.getFuture();
43            }
44        }
45        Assert.isTrue(null != channelFuture);
46
47        Request request = new Request();
48        request.setChannel(channelFuture.channel());
49        request.setNozzle(nozzle);
50        request.setRef(rpcProviderConfig.getRef());
51        request.setAlias(alias);
52        return (T) JDKProxy.getProxy(ClassLoaderUtils.forName(nozzle), request);
53    }
54
55    @Override
56    public Class<?> getObjectType() {
57        try {
58            return ClassLoaderUtils.forName(nozzle);
59        } catch (ClassNotFoundException e) {
60            return null;
61        }
62    }
63
64    @Override
65    public boolean isSingleton() {
66        return true;
67    }
68
69
70}

ProviderBean.java

1package org.itstack.demo.rpc.config.spring.bean;
 2
 3import com.alibaba.fastjson.JSON;
 4import org.itstack.demo.rpc.config.ProviderConfig;
 5import org.itstack.demo.rpc.domain.LocalServerInfo;
 6import org.itstack.demo.rpc.domain.RpcProviderConfig;
 7import org.itstack.demo.rpc.registry.RedisRegistryCenter;
 8import org.slf4j.Logger;
 9import org.slf4j.LoggerFactory;
10import org.springframework.beans.BeansException;
11import org.springframework.context.ApplicationContext;
12import org.springframework.context.ApplicationContextAware;
13
14/**
15 * http://www.itstack.org
16 * create by fuzhengwei on 2019/5/6
17 */
18public class ProviderBean extends ProviderConfig implements ApplicationContextAware {
19
20    private Logger logger = LoggerFactory.getLogger(ProviderBean.class);
21
22    @Override
23    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
24
25        RpcProviderConfig rpcProviderConfig = new RpcProviderConfig();
26        rpcProviderConfig.setNozzle(nozzle);
27        rpcProviderConfig.setRef(ref);
28        rpcProviderConfig.setAlias(alias);
29        rpcProviderConfig.setHost(LocalServerInfo.LOCAL_HOST);
30        rpcProviderConfig.setPort(LocalServerInfo.LOCAL_PORT);
31
32        //注册生产者
33        long count = RedisRegistryCenter.registryProvider(nozzle, alias, JSON.toJSONString(rpcProviderConfig));
34
35        logger.info("注册生产者：{} {} {}", nozzle, alias, count);
36    }
37
38}

ServerBean.java

1package org.itstack.demo.rpc.config.spring.bean;
 2
 3import org.itstack.demo.rpc.config.ServerConfig;
 4import org.itstack.demo.rpc.domain.LocalServerInfo;
 5import org.itstack.demo.rpc.network.server.ServerSocket;
 6import org.itstack.demo.rpc.registry.RedisRegistryCenter;
 7import org.slf4j.Logger;
 8import org.slf4j.LoggerFactory;
 9import org.springframework.beans.BeansException;
10import org.springframework.beans.factory.InitializingBean;
11import org.springframework.context.ApplicationContext;
12import org.springframework.context.ApplicationContextAware;
13
14/**
15 * http://www.itstack.org
16 * create by fuzhengwei on 2019/5/6
17 */
18public class ServerBean extends ServerConfig implements ApplicationContextAware {
19
20    private Logger logger = LoggerFactory.getLogger(ServerBean.class);
21
22    @Override
23    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
24        //启动注册中心
25        logger.info("启动注册中心 ...");
26        RedisRegistryCenter.init(host, port);
27        logger.info("启动注册中心完成 {} {}", host, port);
28
29        //初始化服务端
30        logger.info("初始化生产端服务 ...");
31        ServerSocket serverSocket = new ServerSocket(applicationContext);
32        Thread thread = new Thread(serverSocket);
33        thread.start();
34        while (!serverSocket.isActiveSocketServer()) {
35            try {
36                Thread.sleep(500);
37            } catch (InterruptedException ignore) {
38            }
39        }
40
41        logger.info("初始化生产端服务完成 {} {}", LocalServerInfo.LOCAL_HOST, LocalServerInfo.LOCAL_PORT);
42    }
43
44
45}

MyClientHandler.java

1package org.itstack.demo.rpc.network.client;
 2
 3import io.netty.channel.ChannelHandlerContext;
 4import io.netty.channel.ChannelInboundHandlerAdapter;
 5import org.itstack.demo.rpc.network.future.SyncWriteFuture;
 6import org.itstack.demo.rpc.network.future.SyncWriteMap;
 7import org.itstack.demo.rpc.network.msg.Response;
 8
 9/**
10 * http://www.itstack.org
11 * create by fuzhengwei on 2019/5/6
12 */
13public class MyClientHandler extends ChannelInboundHandlerAdapter {
14
15    @Override
16    public void channelRead(ChannelHandlerContext ctx, Object obj) throws Exception {
17        Response msg = (Response) obj;
18        String requestId = msg.getRequestId();
19        SyncWriteFuture future = (SyncWriteFuture) SyncWriteMap.syncKey.get(requestId);
20        if (future != null) {
21            future.setResponse(msg);
22        }
23    }
24
25    @Override
26    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
27        cause.printStackTrace();
28        ctx.close();
29    }
30
31}

MyServerHandler.java

1package org.itstack.demo.rpc.network.server;
 2
 3import io.netty.channel.ChannelHandlerContext;
 4import io.netty.channel.ChannelInboundHandlerAdapter;
 5import io.netty.util.ReferenceCountUtil;
 6import org.itstack.demo.rpc.network.msg.Request;
 7import org.itstack.demo.rpc.network.msg.Response;
 8import org.itstack.demo.rpc.util.ClassLoaderUtils;
 9import org.springframework.context.ApplicationContext;
10
11import java.lang.reflect.Method;
12
13/**
14 * http://www.itstack.org
15 * create by fuzhengwei on 2019/5/6
16 */
17public class MyServerHandler extends ChannelInboundHandlerAdapter {
18
19    private ApplicationContext applicationContext;
20
21    MyServerHandler(ApplicationContext applicationContext) {
22        this.applicationContext = applicationContext;
23    }
24
25    @Override
26    public void channelRead(ChannelHandlerContext ctx, Object obj) {
27        try {
28            Request msg = (Request) obj;
29            //调用
30            Class<?> classType = ClassLoaderUtils.forName(msg.getNozzle());
31            Method addMethod = classType.getMethod(msg.getMethodName(), msg.getParamTypes());
32            Object objectBean = applicationContext.getBean(msg.getRef());
33            Object result = addMethod.invoke(objectBean, msg.getArgs());
34            //反馈
35            Response request = new Response();
36            request.setRequestId(msg.getRequestId());
37            request.setResult(result);
38            ctx.writeAndFlush(request);
39            //释放
40            ReferenceCountUtil.release(msg);
41        } catch (Exception e) {
42            e.printStackTrace();
43        }
44    }
45
46    @Override
47    public void channelReadComplete(ChannelHandlerContext ctx) {
48        ctx.flush();
49    }
50
51}

JDKInvocationHandler.java

1package org.itstack.demo.rpc.reflect;
 2
 3
 4import org.itstack.demo.rpc.network.future.SyncWrite;
 5import org.itstack.demo.rpc.network.msg.Request;
 6import org.itstack.demo.rpc.network.msg.Response;
 7
 8import java.lang.reflect.InvocationHandler;
 9import java.lang.reflect.Method;
10
11public class JDKInvocationHandler implements InvocationHandler {
12
13    private Request request;
14
15    public JDKInvocationHandler(Request request) {
16        this.request = request;
17    }
18
19    @Override
20    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
21        String methodName = method.getName();
22        Class[] paramTypes = method.getParameterTypes();
23        if ("toString".equals(methodName) && paramTypes.length == 0) {
24            return request.toString();
25        } else if ("hashCode".equals(methodName) && paramTypes.length == 0) {
26            return request.hashCode();
27        } else if ("equals".equals(methodName) && paramTypes.length == 1) {
28            return request.equals(args[0]);
29        }
30        //设置参数
31        request.setMethodName(methodName);
32        request.setParamTypes(paramTypes);
33        request.setArgs(args);
34        request.setRef(request.getRef());
35        Response response = new SyncWrite().writeAndSync(request.getChannel(), request, 5000);
36        //异步调用
37        return response.getResult();
38
39    }
40
41}

JDKProxy.java

1package org.itstack.demo.rpc.reflect;
 2
 3
 4import org.itstack.demo.rpc.network.msg.Request;
 5import org.itstack.demo.rpc.util.ClassLoaderUtils;
 6
 7import java.lang.reflect.InvocationHandler;
 8import java.lang.reflect.Proxy;
 9
10public class JDKProxy {
11
12    public static <T> T getProxy(Class<T> interfaceClass, Request request) throws Exception {
13        InvocationHandler handler = new JDKInvocationHandler(request);
14        ClassLoader classLoader = ClassLoaderUtils.getCurrentClassLoader();
15        T result = (T) Proxy.newProxyInstance(classLoader, new Class[]{interfaceClass}, handler);
16        return result;
17    }
18
19}

RedisRegistryCenter.java

1package org.itstack.demo.rpc.registry;
 2
 3import redis.clients.jedis.Jedis;
 4import redis.clients.jedis.JedisPool;
 5import redis.clients.jedis.JedisPoolConfig;
 6
 7/**
 8 * http://www.itstack.org
 9 * create by fuzhengwei on 2019/5/7
10 * redis 模拟RPC注册中心
11 */
12public class RedisRegistryCenter {
13
14    private static Jedis jedis;   //非切片额客户端连接
15
16    //初始化redis
17    public static void init(String host, int port) {
18        // 池基本配置
19        JedisPoolConfig config = new JedisPoolConfig();
20        config.setMaxIdle(5);
21        config.setTestOnBorrow(false);
22        JedisPool jedisPool = new JedisPool(config, host, port);
23        jedis = jedisPool.getResource();
24    }
25
26    /**
27     * 注册生产者
28     *
29     * @param nozzle 接口
30     * @param alias  别名
31     * @param info   信息
32     * @return 注册结果
33     */
34    public static Long registryProvider(String nozzle, String alias, String info) {
35        return jedis.sadd(nozzle + "_" + alias, info);
36    }
37
38    /**
39     * 获取生产者
40     * 模拟权重，随机获取
41     * @param nozzle 接口名称
42     */
43    public static String obtainProvider(String nozzle, String alias) {
44        return jedis.srandmember(nozzle + "_" + alias);
45    }
46
47    public static Jedis jedis() {
48        return jedis;
49    }
50
51}

ApiTest.java

1public class ApiTest {
2
3    public static void main(String[] args) {
4        String[] configs = {"itstack-rpc-center.xml", "itstack-rpc-provider.xml", "itstack-rpc-consumer.xml"};
5        new ClassPathXmlApplicationContext(configs);
6    }
7
8}

框架，测试结果

12019-....ClassPathXmlApplicationContext:prepareRefresh:510] - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@299a06ac: startup date [Tue May 07 20:19:47 CST 2019]; root of context hierarchy
 22019-...ml.XmlBeanDefinitionReader:loadBeanDefinitions:315] - Loading XML bean definitions from class path resource [spring/itstack-rpc-center.xml]
 32019-...ml.XmlBeanDefinitionReader:loadBeanDefinitions:315] - Loading XML bean definitions from class path resource [spring/itstack-rpc-provider.xml]
 42019-...ml.XmlBeanDefinitionReader:loadBeanDefinitions:315] - Loading XML bean definitions from class path resource [spring/itstack-rpc-consumer.xml]
 52019-...upport.DefaultListableBeanFactory:preInstantiateSingletons:577] - Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@7e0b0338: defining beans [consumer_itstack,provider_helloService,consumer_helloService]; root of factory hierarchy
 62019-...bean.ServerBean:setApplicationContext:25] - 启动注册中心 ...
 72019-...bean.ServerBean:setApplicationContext:27] - 启动注册中心完成 127.0.0.1 6379
 82019-...bean.ServerBean:setApplicationContext:30] - 初始化生产端服务 ...
 92019-...bean.ServerBean:setApplicationContext:41] - 初始化生产端服务完成 10.13.81.104 22201
102019-...bean.ProviderBean:setApplicationContext:35] - 注册生产者：org.itstack.demo.test.service.HelloService itStackRpc 0

框架应用

为了测试我们写两个测试工程；itstack-demo-rpc-provider、itstack-demo-rpc-consumer

itstack-demo-rpc-provider 提供生产者接口

1itstack-demo-rpc-provider
 2├── itstack-demo-rpc-provider-export
 3│   └── src
 4│        └── main
 5│            └── java
 6│                 └── org.itstack.demo.rpc.provider.export
 7│                     ├── domain 
 8│                     │   └── Hi.java
 9│                     └── HelloService.java
10│   
11└── itstack-demo-rpc-provider-web
12    └── src
13         └── main
14             ├── java
15             │    └── org.itstack.demo.rpc.provider.web
16             │        └── HelloServiceImpl.java
17             └── resources
18                  └── spring
19                      └── spring-itstack-rpc-provider.xml

HelloService.java

1public interface HelloService {
2
3    String hi();
4
5    String say(String str);
6
7    String sayHi(Hi hi);
8
9}

HelloServiceImpl.java

1@Controller("helloService")
 2public class HelloServiceImpl implements HelloService {
 3
 4    @Override
 5    public String hi() {
 6        return "hi itstack rpc";
 7    }
 8
 9    @Override
10    public String say(String str) {
11        return str;
12    }
13
14    @Override
15    public String sayHi(Hi hi) {
16        return hi.getUserName() + " say：" + hi.getSayMsg();
17    }
18
19}

spring-itstack-rpc-provider.xml

1<?xml version="1.0" encoding="UTF-8"?>
 2<beans xmlns="http://www.springframework.org/schema/beans"
 3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rpc="http://rpc.itstack.org/schema/rpc"
 4       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 5      http://rpc.itstack.org/schema/rpc http://rpc.itstack.org/schema/rpc/rpc.xsd">
 6
 7    <!-- 注册中心 -->
 8    <rpc:server id="rpcServer" host="127.0.0.1" port="6379"/>
 9
10    <rpc:provider id="helloServiceRpc" nozzle="org.itstack.demo.rpc.provider.export.HelloService"
11                  ref="helloService" alias="itstackRpc"/>
12
13</beans>

itstack-demo-rpc-consumer 提供消费者调用

1itstack-demo-rpc-consumer
 2└── src
 3     ├── main
 4     │   ├── java    
 5     │   └── resources
 6     │       └── spring
 7     │           └── spring-itstack-rpc-consumer.xml
 8     │   
 9     └── test
10         └── java
11             └── org.itstack.demo.test
12                 └── ConsumerTest.java

spring-itstack-rpc-consumer.xml

1<?xml version="1.0" encoding="UTF-8"?>
 2<beans xmlns="http://www.springframework.org/schema/beans"
 3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rpc="http://rpc.itstack.org/schema/rpc"
 4       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 5      http://rpc.itstack.org/schema/rpc http://rpc.itstack.org/schema/rpc/rpc.xsd">
 6
 7    <!-- 注册中心 -->
 8    <rpc:server id="consumer_itstack" host="127.0.0.1" port="6379"/>
 9
10    <rpc:consumer id="helloService" nozzle="org.itstack.demo.rpc.provider.export.HelloService" alias="itstackRpc"/>
11
12</beans>

ConsumerTest.java

1@RunWith(SpringJUnit4ClassRunner.class)
 2@ContextConfiguration("/spring-config.xml")
 3public class ConsumerTest {
 4
 5    @Resource(name = "helloService")
 6    private HelloService helloService;
 7
 8    @Test
 9    public void test() {
10
11        String hi = helloService.hi();
12        System.out.println("测试结果：" + hi);
13
14        String say = helloService.say("hello world");
15        System.out.println("测试结果：" + say);
16
17        Hi hiReq = new Hi();
18        hiReq.setUserName("付栈");
19        hiReq.setSayMsg("付可敌国，栈无不胜");
20        String hiRes = helloService.sayHi(hiReq);
21
22        System.out.println("测试结果：" + hiRes);
23    }
24
25}

应用，测试结果

测试时启动redis

启动ProviderTest Redis中的注册数据

1redis 127.0.0.1:6379> srandmember org.itstack.demo.rpc.provider.export.HelloService_itstackRpc
2"{\"alias\":\"itstackRpc\",\"host\":\"10.13.81.104\",\"nozzle\":\"org.itstack.demo.rpc.provider.export.HelloService\",\"port\":22201,\"ref\":\"helloService\"}"
3redis 127.0.0.1:6379>

执行ConsumerTest中的单元测试方法

1log4j:WARN No appenders could be found for logger (org.springframework.test.context.junit4.SpringJUnit4ClassRunner).
2log4j:WARN Please initialize the log4j system properly.
3log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
4测试结果：hi itstack rpc
5测试结果：hello world
6测试结果：付栈 say：付可敌国，栈无不胜
7
8Process finished with exit code 0
9


文章标签：
云数据库 Redis 版
Java
测试技术
NoSQL
Windows
Redis
中间件
数据格式
XML
关键词：
中间件框架
RPC框架
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
小傅哥
目录
相关文章
喜欢猪猪
|
3月前
|
负载均衡 Dubbo Java
Dubbo 3.x：探索阿里巴巴的开源RPC框架新技术
随着微服务架构的兴起，远程过程调用（RPC）框架成为了关键组件。Dubbo，作为阿里巴巴的开源RPC框架，已经演进到了3.x版本，带来了许多新特性和技术改进。本文将探讨Dubbo 3.x中的一些最新技术，包括服务注册与发现、负载均衡、服务治理等，并通过代码示例展示其使用方式。
喜欢猪猪
85 9
旺仔好吃糖er
|
8月前
|
JSON JavaScript 中间件
node.js中Express框架路由，中间件
node.js中Express框架路由，中间件
旺仔好吃糖er
47 0
赵广陆
|
8月前
|
消息中间件 负载均衡 Dubbo
如何自己设计一个类似Dubbo的RPC框架？
如何自己设计一个类似Dubbo的RPC框架？
赵广陆
64 0
岁岁种桃花儿
|
5月前
|
Dubbo Java 应用服务中间件
Rpc编程系列文章第三篇：Hessian RPC一个老的RPC框架
Rpc编程系列文章第三篇：Hessian RPC一个老的RPC框架
岁岁种桃花儿
59 0
1941623231718325
|
13天前
|
开发框架 JavaScript 中间件
深入探索Node.js的Express框架：使用与中间件详解
【4月更文挑战第30天】本文深入探讨了Node.js的Express框架，介绍了其作为Web开发的强大工具，主要聚焦于基本使用和中间件。Express是基于Node.js的Web应用框架，用于构建高效的应用和API。文章详细讲解了如何安装Express，创建简单应用，以及中间件的工作原理和应用，包括中间件的顺序、错误处理和挂载位置。此外，还提到了使用第三方中间件扩展功能。理解Express基础和中间件对于开发高质量Web应用至关重要。
1941623231718325
13 0
景天科技苑
|
13天前
|
缓存 前端开发 安全
Python web框架fastapi中间件的使用，CORS跨域详解
Python web框架fastapi中间件的使用，CORS跨域详解
景天科技苑
37 1
桃李春风一杯酒
|
13天前
|
缓存 中间件 PHP
【PHP开发专栏】PHP框架中的路由与中间件
【4月更文挑战第29天】本文探讨了PHP框架中的路由和中间件概念。路由负责将HTTP请求映射到控制器方法，提供灵活的请求处理和URL管理。中间件则是在请求处理前后插入的代码，用于实现如身份验证、日志等功能，与业务逻辑解耦。通过Laravel框架的示例展示了如何定义路由和创建中间件，以实现代码的模块化和可维护性。
桃李春风一杯酒
20 0
海风极客
|
3月前
|
XML JSON Java
RPC框架之Thrift—实现Go和Java远程过程调用
RPC框架之Thrift—实现Go和Java远程过程调用
海风极客
50 1
sumith
|
4月前
|
数据采集 中间件 Python
Scrapy框架 -- 中间件介绍
Scrapy框架 -- 中间件介绍
sumith
20 0
小小工匠
|
4月前
|
消息中间件 Dubbo Java
Simple RPC - 01 框架原理及总体架构初探
Simple RPC - 01 框架原理及总体架构初探
小小工匠
52 0
云原生

中间件

热门文章

最新文章

  • 1
    Apache RocketMQ ACL 2.0 全新升级
  • 2
    3分钟，了解阿里云热门开发者工具 Cloud Toolkit
  • 3
    SLS 查询新范式：使用 SPL 对日志进行交互式探索
  • 4
    得物 ZooKeeper SLA 也可以 99.99%丨最佳实践
  • 5
    Java编码技巧之高效代码50例
  • 6
    用户洞察的秘密武器：ARMS前端监控功能正式上线！
  • 7
    Kafka、RabbitMQ、RocketMQ消息中间件的对比—— 消息发送性能
  • 8
    HiSDP —— 高效的C++软件开发平台
  • 9
    业界主流MQ对比
  • 10
    分布式服务架构下的混沌工程实践
  • 1
    低成本、高稳定性 ｜满帮集团 Eureka 和 ZooKeeper 的上云实践
    43
  • 2
    低成本、高稳定性 | 满帮集团 Eureka 和 ZooKeeper 的上云实践
    27
  • 3
    阿里云微服务引擎及 API 网关 2024 年 4 月产品动态
    25
  • 4
    分布式搜索引擎ElasticSearch
    20
  • 5
    iLogtail 社区开源之夏活动来了！
    26
  • 6
    MQTT 5.0 报文解析 02：PUBLISH 与 PUBACK
    22
  • 7
    如何设计与构建 FinOps 流程、团队、体系与目标
    44
  • 8
    阿里云可观测 2024 年 4 月产品动态
    26
  • 9
    Spring AI 抢先体验，5 分钟玩转 Java AI 应用开发
    389
  • 10
    无需重新学习，使用 Kibana 查询/可视化 SLS 数据
    408

    • 相关课程

    更多
  • Dubbo分布式服务治理实战
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • 微服务实战-RocketMQ Binder
  • Python语言基础 - 函数、面向对象、异常处理
  • PHP进阶教程 - 由浅入深掌握面向对象开发 - 第二阶段
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 金融分布式中间件分享
  • 无需部署的前端中间件技术——企业移动化新思路
  • 《云原生中间件精品案例集》

    • 相关实验场景

    更多
  • 使用Java面向对象编写网络通信程序应用
  • 快速上手使用Dubbo进行远程调用
  • 基于函数计算快速搭建Zblog等传统应用框架
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）