2. 程式人生 > 實用技巧 >手寫一個RPC框架

手寫一個RPC框架

阿新 • • 發佈：2020-08-22

一、前言

前段時間看到一篇不錯的文章《看了這篇你就會手寫RPC框架了》，於是便來了興趣對著實現了一遍，後面覺得還有很多優化的地方便對其進行了改進。

主要改動點如下：

  1. 除了Java序列化協議，增加了protobuf和kryo序列化協議，配置即用。
  2. 增加多種負載均衡演算法（隨機、輪詢、加權輪詢、平滑加權輪詢），配置即用。
  3. 客戶端增加本地服務列表快取，提高效能。
  4. 修復高併發情況下，netty導致的記憶體洩漏問題
  5. 由原來的每個請求建立一次連線，改為建立TCP長連線，並多次複用。
  6. 服務端增加執行緒池提高訊息處理能力

二、介紹

RPC，即 Remote Procedure Call（遠端過程呼叫），呼叫遠端計算機上的服務，就像呼叫本地服務一樣。RPC可以很好的解耦系統，如WebService就是一種基於Http協議的RPC。


呼叫示意圖

總的來說，就如下幾個步驟：

  1. 客戶端（ServerA）執行遠端方法時就呼叫client stub傳遞類名、方法名和引數等資訊。
  2. client stub會將引數等資訊序列化為二進位制流的形式，然後通過Sockect傳送給服務端（ServerB）
  3. 服務端收到資料包後，server stub 需要進行解析反序列化為類名、方法名和引數等資訊。
  4. server stub呼叫對應的本地方法，並把執行結果返回給客戶端

所以一個RPC框架有如下角色：

服務消費者

遠端方法的呼叫方，即客戶端。一個服務既可以是消費者也可以是提供者。

服務提供者

遠端服務的提供方，即服務端。一個服務既可以是消費者也可以是提供者。

註冊中心

儲存服務提供者的服務地址等資訊，一般由zookeeper、redis等實現。

監控運維（可選）

監控介面的響應時間、統計請求數量等，及時發現系統問題併發出告警通知。

三、實現

本RPC框架rpc-spring-boot-starter涉及技術棧如下：

  • 使用zookeeper作為註冊中心
  • 使用netty作為通訊框架
  • 訊息編解碼：protostuff、kryo、java
  • spring
  • 使用SPI來根據配置動態選擇負載均衡演算法等

由於程式碼過多，這裡只講幾處改動點。

3.1動態負載均衡演算法

1.編寫LoadBalance的實現類


負載均衡演算法實現類

2.自定義註解 @LoadBalanceAno

  1. /**
  2. * 負載均衡註解
  3. */
  4. @Target(ElementType.TYPE)
  5. @Retention(RetentionPolicy.RUNTIME)
  6. @Documented
  7. public @interface LoadBalanceAno {

  9. String value() default "";
  10. }

  12. /**
  13. * 輪詢演算法
  14. */
  15. @LoadBalanceAno(RpcConstant.BALANCE_ROUND)
  16. public class FullRoundBalance implements LoadBalance {

  18. private static Logger logger = LoggerFactory.getLogger(FullRoundBalance.class);

  20. private volatile int index;

  22. @Override
  23. public synchronized Service chooseOne(List<Service> services) {
  24. // 加鎖防止多執行緒情況下，index超出services.size()
  25. if (index == services.size()) {
  26. index = 0;
  27. }
  28. return services.get(index++);
  29. }
  30. }

3.新建在resource目錄下META-INF/servers資料夾並建立檔案


enter description here

4.RpcConfig增加配置項loadBalance

  1. /**
  2. * @author 2YSP
  3. * @date 2020/7/26 15:13
  4. */
  5. @ConfigurationProperties(prefix = "sp.rpc")
  6. public class RpcConfig {

  8. /**
  9. * 服務註冊中心地址
  10. */
  11. private String registerAddress = "127.0.0.1:2181";

  13. /**
  14. * 服務暴露埠
  15. */
  16. private Integer serverPort = 9999;
  17. /**
  18. * 服務協議
  19. */
  20. private String protocol = "java";
  21. /**
  22. * 負載均衡演算法
  23. */
  24. private String loadBalance = "random";
  25. /**
  26. * 權重，預設為1
  27. */
  28. private Integer weight = 1;

  30. // 省略getter setter
  31. }

5.在自動配置類RpcAutoConfiguration根據配置選擇對應的演算法實現類

  1. /**
  2. * 使用spi匹配符合配置的負載均衡演算法
  3. *
  4. * @param name
  5. * @return
  6. */
  7. private LoadBalance getLoadBalance(String name) {
  8. ServiceLoader<LoadBalance> loader = ServiceLoader.load(LoadBalance.class);
  9. Iterator<LoadBalance> iterator = loader.iterator();
  10. while (iterator.hasNext()) {
  11. LoadBalance loadBalance = iterator.next();
  12. LoadBalanceAno ano = loadBalance.getClass().getAnnotation(LoadBalanceAno.class);
  13. Assert.notNull(ano, "load balance name can not be empty!");
  14. if (name.equals(ano.value())) {
  15. return loadBalance;
  16. }
  17. }
  18. throw new RpcException("invalid load balance config");
  19. }

  21. @Bean
  22. public ClientProxyFactory proxyFactory(@Autowired RpcConfig rpcConfig) {
  23. ClientProxyFactory clientProxyFactory = new ClientProxyFactory();
  24. // 設定服務發現著
  25. clientProxyFactory.setServerDiscovery(new ZookeeperServerDiscovery(rpcConfig.getRegisterAddress()));

  27. // 設定支援的協議
  28. Map<String, MessageProtocol> supportMessageProtocols = buildSupportMessageProtocols();
  29. clientProxyFactory.setSupportMessageProtocols(supportMessageProtocols);
  30. // 設定負載均衡演算法
  31. LoadBalance loadBalance = getLoadBalance(rpcConfig.getLoadBalance());
  32. clientProxyFactory.setLoadBalance(loadBalance);
  33. // 設定網路層實現
  34. clientProxyFactory.setNetClient(new NettyNetClient());

  36. return clientProxyFactory;
  37. }

3.2本地服務列表快取

使用Map來快取資料

  1. /**
  2. * 服務發現本地快取
  3. */
  4. public class ServerDiscoveryCache {
  5. /**
  6. * key: serviceName
  7. */
  8. private static final Map<String, List<Service>> SERVER_MAP = new ConcurrentHashMap<>();
  9. /**
  10. * 客戶端注入的遠端服務service class
  11. */
  12. public static final List<String> SERVICE_CLASS_NAMES = new ArrayList<>();

  14. public static void put(String serviceName, List<Service> serviceList) {
  15. SERVER_MAP.put(serviceName, serviceList);
  16. }

  18. /**
  19. * 去除指定的值
  20. * @param serviceName
  21. * @param service
  22. */
  23. public static void remove(String serviceName, Service service) {
  24. SERVER_MAP.computeIfPresent(serviceName, (key, value) ->
  25. value.stream().filter(o -> !o.toString().equals(service.toString())).collect(Collectors.toList())
  26. );
  27. }

  29. public static void removeAll(String serviceName) {
  30. SERVER_MAP.remove(serviceName);
  31. }


  34. public static boolean isEmpty(String serviceName) {
  35. return SERVER_MAP.get(serviceName) == null || SERVER_MAP.get(serviceName).size() == 0;
  36. }

  38. public static List<Service> get(String serviceName) {
  39. return SERVER_MAP.get(serviceName);
  40. }
  41. }

ClientProxyFactory，先查本地快取，快取沒有再查詢zookeeper。

  1. /**
  2. * 根據服務名獲取可用的服務地址列表
  3. * @param serviceName
  4. * @return
  5. */
  6. private List<Service> getServiceList(String serviceName) {
  7. List<Service> services;
  8. synchronized (serviceName){
  9. if (ServerDiscoveryCache.isEmpty(serviceName)) {
  10. services = serverDiscovery.findServiceList(serviceName);
  11. if (services == null || services.size() == 0) {
  12. throw new RpcException("No provider available!");
  13. }
  14. ServerDiscoveryCache.put(serviceName, services);
  15. } else {
  16. services = ServerDiscoveryCache.get(serviceName);
  17. }
  18. }
  19. return services;
  20. }

問題： 如果服務端因為宕機或網路問題下線了，快取卻還在就會導致客戶端請求已經不可用的服務端，增加請求失敗率。
解決方案：由於服務端註冊的是臨時節點，所以如果服務端下線節點會被移除。只要監聽zookeeper的子節點，如果新增或刪除子節點就直接清空本地快取即可。
DefaultRpcProcessor

  1. /**
  2. * Rpc處理者，支援服務啟動暴露，自動注入Service
  3. * @author 2YSP
  4. * @date 2020/7/26 14:46
  5. */
  6. public class DefaultRpcProcessor implements ApplicationListener<ContextRefreshedEvent> {



  10. @Override
  11. public void onApplicationEvent(ContextRefreshedEvent event) {
  12. // Spring啟動完畢過後會收到一個事件通知
  13. if (Objects.isNull(event.getApplicationContext().getParent())){
  14. ApplicationContext context = event.getApplicationContext();
  15. // 開啟服務
  16. startServer(context);
  17. // 注入Service
  18. injectService(context);
  19. }
  20. }

  22. private void injectService(ApplicationContext context) {
  23. String[] names = context.getBeanDefinitionNames();
  24. for(String name : names){
  25. Class<?> clazz = context.getType(name);
  26. if (Objects.isNull(clazz)){
  27. continue;
  28. }

  30. Field[] declaredFields = clazz.getDeclaredFields();
  31. for(Field field : declaredFields){
  32. // 找出標記了InjectService註解的屬性
  33. InjectService injectService = field.getAnnotation(InjectService.class);
  34. if (injectService == null){
  35. continue;
  36. }

  38. Class<?> fieldClass = field.getType();
  39. Object object = context.getBean(name);
  40. field.setAccessible(true);
  41. try {
  42. field.set(object,clientProxyFactory.getProxy(fieldClass));
  43. } catch (IllegalAccessException e) {
  44. e.printStackTrace();
  45. }
  46. // 新增本地服務快取
  47. ServerDiscoveryCache.SERVICE_CLASS_NAMES.add(fieldClass.getName());
  48. }
  49. }
  50. // 註冊子節點監聽
  51. if (clientProxyFactory.getServerDiscovery() instanceof ZookeeperServerDiscovery){
  52. ZookeeperServerDiscovery serverDiscovery = (ZookeeperServerDiscovery) clientProxyFactory.getServerDiscovery();
  53. ZkClient zkClient = serverDiscovery.getZkClient();
  54. ServerDiscoveryCache.SERVICE_CLASS_NAMES.forEach(name ->{
  55. String servicePath = RpcConstant.ZK_SERVICE_PATH + RpcConstant.PATH_DELIMITER + name + "/service";
  56. zkClient.subscribeChildChanges(servicePath, new ZkChildListenerImpl());
  57. });
  58. logger.info("subscribe service zk node successfully");
  59. }

  61. }

  63. private void startServer(ApplicationContext context) {
  64. ...

  66. }
  67. }

ZkChildListenerImpl

  1. /**
  2. * 子節點事件監聽處理類
  3. */
  4. public class ZkChildListenerImpl implements IZkChildListener {

  6. private static Logger logger = LoggerFactory.getLogger(ZkChildListenerImpl.class);

  8. /**
  9. * 監聽子節點的刪除和新增事件
  10. * @param parentPath /rpc/serviceName/service
  11. * @param childList
  12. * @throws Exception
  13. */
  14. @Override
  15. public void handleChildChange(String parentPath, List<String> childList) throws Exception {
  16. logger.debug("Child change parentPath:[{}] -- childList:[{}]", parentPath, childList);
  17. // 只要子節點有改動就清空快取
  18. String[] arr = parentPath.split("/");
  19. ServerDiscoveryCache.removeAll(arr[2]);
  20. }
  21. }

3.3nettyClient支援TCP長連線

這部分的改動最多，先增加新的sendRequest介面。


新增介面

實現類NettyNetClient

  1. /**
  2. * @author 2YSP
  3. * @date 2020/7/25 20:12
  4. */
  5. public class NettyNetClient implements NetClient {

  7. private static Logger logger = LoggerFactory.getLogger(NettyNetClient.class);

  9. private static ExecutorService threadPool = new ThreadPoolExecutor(4, 10, 200,
  10. TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000), new ThreadFactoryBuilder()
  11. .setNameFormat("rpcClient-%d")
  12. .build());

  14. private EventLoopGroup loopGroup = new NioEventLoopGroup(4);

  16. /**
  17. * 已連線的服務快取
  18. * key: 服務地址，格式：ip:port
  19. */
  20. public static Map<String, SendHandlerV2> connectedServerNodes = new ConcurrentHashMap<>();

  22. @Override
  23. public byte[] sendRequest(byte[] data, Service service) throws InterruptedException {
  24. ....
  25. return respData;
  26. }

  28. @Override
  29. public RpcResponse sendRequest(RpcRequest rpcRequest, Service service, MessageProtocol messageProtocol) {

  31. String address = service.getAddress();
  32. synchronized (address) {
  33. if (connectedServerNodes.containsKey(address)) {
  34. SendHandlerV2 handler = connectedServerNodes.get(address);
  35. logger.info("使用現有的連線");
  36. return handler.sendRequest(rpcRequest);
  37. }

  39. String[] addrInfo = address.split(":");
  40. final String serverAddress = addrInfo[0];
  41. final String serverPort = addrInfo[1];
  42. final SendHandlerV2 handler = new SendHandlerV2(messageProtocol, address);
  43. threadPool.submit(() -> {
  44. // 配置客戶端
  45. Bootstrap b = new Bootstrap();
  46. b.group(loopGroup).channel(NioSocketChannel.class)
  47. .option(ChannelOption.TCP_NODELAY, true)
  48. .handler(new ChannelInitializer<SocketChannel>() {
  49. @Override
  50. protected void initChannel(SocketChannel socketChannel) throws Exception {
  51. ChannelPipeline pipeline = socketChannel.pipeline();
  52. pipeline
  53. .addLast(handler);
  54. }
  55. });
  56. // 啟用客戶端連線
  57. ChannelFuture channelFuture = b.connect(serverAddress, Integer.parseInt(serverPort));
  58. channelFuture.addListener(new ChannelFutureListener() {
  59. @Override
  60. public void operationComplete(ChannelFuture channelFuture) throws Exception {
  61. connectedServerNodes.put(address, handler);
  62. }
  63. });
  64. }
  65. );
  66. logger.info("使用新的連線。。。");
  67. return handler.sendRequest(rpcRequest);
  68. }
  69. }
  70. }

每次請求都會呼叫sendRequest()方法，用執行緒池非同步和服務端建立TCP長連線，連線成功後將SendHandlerV2快取到ConcurrentHashMap中方便複用，後續請求的請求地址（ip+port）如果在connectedServerNodes中存在則使用connectedServerNodes中的handler處理不再重新建立連線。

SendHandlerV2

  1. /**
  2. * @author 2YSP
  3. * @date 2020/8/19 20:06
  4. */
  5. public class SendHandlerV2 extends ChannelInboundHandlerAdapter {

  7. private static Logger logger = LoggerFactory.getLogger(SendHandlerV2.class);

  9. /**
  10. * 等待通道建立最大時間
  11. */
  12. static final int CHANNEL_WAIT_TIME = 4;
  13. /**
  14. * 等待響應最大時間
  15. */
  16. static final int RESPONSE_WAIT_TIME = 8;

  18. private volatile Channel channel;

  20. private String remoteAddress;

  22. private static Map<String, RpcFuture<RpcResponse>> requestMap = new ConcurrentHashMap<>();

  24. private MessageProtocol messageProtocol;

  26. private CountDownLatch latch = new CountDownLatch(1);

  28. public SendHandlerV2(MessageProtocol messageProtocol,String remoteAddress) {
  29. this.messageProtocol = messageProtocol;
  30. this.remoteAddress = remoteAddress;
  31. }

  33. @Override
  34. public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
  35. this.channel = ctx.channel();
  36. latch.countDown();
  37. }

  39. @Override
  40. public void channelActive(ChannelHandlerContext ctx) throws Exception {
  41. logger.debug("Connect to server successfully:{}", ctx);
  42. }

  44. @Override
  45. public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  46. logger.debug("Client reads message:{}", msg);
  47. ByteBuf byteBuf = (ByteBuf) msg;
  48. byte[] resp = new byte[byteBuf.readableBytes()];
  49. byteBuf.readBytes(resp);
  50. // 手動回收
  51. ReferenceCountUtil.release(byteBuf);
  52. RpcResponse response = messageProtocol.unmarshallingResponse(resp);
  53. RpcFuture<RpcResponse> future = requestMap.get(response.getRequestId());
  54. future.setResponse(response);
  55. }

  57. @Override
  58. public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  59. cause.printStackTrace();
  60. logger.error("Exception occurred:{}", cause.getMessage());
  61. ctx.close();
  62. }

  64. @Override
  65. public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
  66. ctx.flush();
  67. }

  69. @Override
  70. public void channelInactive(ChannelHandlerContext ctx) throws Exception {
  71. super.channelInactive(ctx);
  72. logger.error("channel inactive with remoteAddress:[{}]",remoteAddress);
  73. NettyNetClient.connectedServerNodes.remove(remoteAddress);

  75. }

  77. @Override
  78. public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
  79. super.userEventTriggered(ctx, evt);
  80. }

  82. public RpcResponse sendRequest(RpcRequest request) {
  83. RpcResponse response;
  84. RpcFuture<RpcResponse> future = new RpcFuture<>();
  85. requestMap.put(request.getRequestId(), future);
  86. try {
  87. byte[] data = messageProtocol.marshallingRequest(request);
  88. ByteBuf reqBuf = Unpooled.buffer(data.length);
  89. reqBuf.writeBytes(data);
  90. if (latch.await(CHANNEL_WAIT_TIME,TimeUnit.SECONDS)){
  91. channel.writeAndFlush(reqBuf);
  92. // 等待響應
  93. response = future.get(RESPONSE_WAIT_TIME, TimeUnit.SECONDS);
  94. }else {
  95. throw new RpcException("establish channel time out");
  96. }
  97. } catch (Exception e) {
  98. throw new RpcException(e.getMessage());
  99. } finally {
  100. requestMap.remove(request.getRequestId());
  101. }
  102. return response;
  103. }
  104. }

RpcFuture

  1. package cn.sp.rpc.client.net;

  3. import java.util.concurrent.*;

  5. /**
  6. * @author 2YSP
  7. * @date 2020/8/19 22:31
  8. */
  9. public class RpcFuture<T> implements Future<T> {

  11. private T response;
  12. /**
  13. * 因為請求和響應是一一對應的，所以這裡是1
  14. */
  15. private CountDownLatch countDownLatch = new CountDownLatch(1);
  16. /**
  17. * Future的請求時間，用於計算Future是否超時
  18. */
  19. private long beginTime = System.currentTimeMillis();

  21. @Override
  22. public boolean cancel(boolean mayInterruptIfRunning) {
  23. return false;
  24. }

  26. @Override
  27. public boolean isCancelled() {
  28. return false;
  29. }

  31. @Override
  32. public boolean isDone() {
  33. if (response != null) {
  34. return true;
  35. }
  36. return false;
  37. }

  39. /**
  40. * 獲取響應，直到有結果才返回
  41. * @return
  42. * @throws InterruptedException
  43. * @throws ExecutionException
  44. */
  45. @Override
  46. public T get() throws InterruptedException, ExecutionException {
  47. countDownLatch.await();
  48. return response;
  49. }

  51. @Override
  52. public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
  53. if (countDownLatch.await(timeout,unit)){
  54. return response;
  55. }
  56. return null;
  57. }

  59. public void setResponse(T response) {
  60. this.response = response;
  61. countDownLatch.countDown();
  62. }

  64. public long getBeginTime() {
  65. return beginTime;
  66. }
  67. }

此處邏輯，第一次執行 SendHandlerV2#sendRequest() 時channel需要等待通道建立好之後才能傳送請求，所以用CountDownLatch來控制，等待通道建立。
自定義Future+requestMap快取來實現netty的請求和阻塞等待響應，RpcRequest物件在建立時會生成一個請求的唯一標識requestId，傳送請求前先將RpcFuture快取到requestMap中，key為requestId，讀取到服務端的響應資訊後(channelRead方法)，將響應結果放入對應的RpcFuture中。
SendHandlerV2#channelInactive() 方法中，如果連線的服務端異常斷開連線了，則及時清理快取中對應的serverNode。

四、壓力測試

測試環境：
(英特爾)Intel(R) Core(TM) i5-6300HQ CPU @ 2.30GHz
4核
windows10家庭版（64位）
16G記憶體

1.本地啟動zookeeper
2.本地啟動一個消費者，兩個服務端，輪詢演算法
3.使用ab進行壓力測試，4個執行緒傳送10000個請求

ab -c 4 -n 10000 http://localhost:8080/test/user?id=1

測試結果：


測試結果

從圖片可以看出，10000個請求只用了11s，比之前的130+秒耗時減少了10倍以上。

程式碼地址：
https://github.com/2YSP/rpc-spring-boot-starter
https://github.com/2YSP/rpc-example

參考：
《看了這篇你就會手寫RPC框架了》

相關推薦

手寫一個RPC框架

一、前言 前段時間看到一篇不錯的文章《看了這篇你就會手寫RPC框架了》，於是便來了興趣對著實現了一遍，後面覺得還有很多優化的地方便對其進行了改進。

趁熱打鐵，我們今天來手寫一個RPC框架……

前言 昨天大概理了下思路，覺得目前最合適的事，就是手寫一個rpc框架，因為只有創造、創作，才讓我覺得生活更有激情，而且做具體的事，也會讓生活更充實、更真實，會讓你不那麼迷茫。

從 0 開始手寫一個 Spring MVC 框架，向高手進階！

作者：我叫劉半仙 https://my.oschina.net/liughDevelop/blog/1622646 Spring框架對於Java後端程式設計師來說再熟悉不過了，以前只知道它用的反射實現的，但瞭解之後才知道有很多巧妙的設計在裡面。如果不看Spring

手寫一個類SpringBoot的HTTP框架：幾十行程式碼基於Netty搭建一個 HTTP Server

本文已經收錄進 :https://github.com/Snailclimb/netty-practical-tutorial(Netty 從入門到實戰：手寫 HTTP Server+RPC 框架)。

手寫一個簡單的響應式柵格

前言 前段時間一衝動搞了個騰訊雲主機，最簡單的配置那種。買完之後一陣折騰，想著不如整個部落格，於是各種部落格搭建方案，看著好多漂亮的部落格，毅然決定搭建一個自己的部落格，正好自己是一個前端新手，寫一個這

帶你一步一步手寫一個簡單的 Mybatis

在前兩篇文章中我向你介紹了 Mybatis 的構建和執行流程，這篇文章中我會帶領你一步一步手寫一個簡單的 Mybatis 框架。

【實戰演練】用手寫一個騷氣的請求合併，演繹底層的真實

冬來冬往，越來越喜歡軟綿綿的被窩了。a 厭倦了夏天的酷熱，秋天的浮躁，來一首冬天的安靜。

從零開始手寫 spring ioc 框架，深入學習 spring 原始碼

IoC Ioc 是一款 spring ioc 核心功能簡化實現版本，便於學習和理解原理。 創作目的

帶你一步一步手寫一個簡單的Spring MVC

如果對 servlet 和 Spring MVC 的基本原理還不是很理解的同學可以先看我的另一篇文章帶你一步一步手撕Spring MVC原始碼加手繪流程圖。再回過來看這篇文章你就會豁然開朗。

如何手寫一個簡單的 parser

前一陣子，收到燁兄的私聊，他突然要解決這樣一個任務： 做如下格式的表示式轉換：

手寫一個python迭代器過程詳解

分析 我們都知道一個可迭代物件可以通過iter()可以返回一個迭代器。 如果想要一個物件稱為可迭代物件，即可以使用for，那麼必須實現__iter __()方法。

JS手寫一個自定義Promise操作示例

本文例項講述了JS手寫一個自定義Promise操作。分享給大家供大家參考，具體如下：

手寫一個Redux，深入理解其原理

Redux可是一個大名鼎鼎的庫，很多地方都在用，我也用了幾年了，今天這篇文章就是自己來實現一個Redux，以便於深入理解他的原理。我們還是老套路，從基本的用法入手，然後自己實現一個Redux來替代原始碼的NPM包，但是

手寫一個React-Redux，玩轉React的Context API

上一篇文章我們手寫了一個Redux，但是單純的Redux只是一個狀態機，是沒有UI呈現的，所以一般我們使用的時候都會配合一個UI庫，比如在React中使用Redux就會用到React-Redux這個庫。這個庫的作用是將Redux的狀態機和Re

手寫一個vue雙向繫結的過程

通過Object.defineProperty()來進行資料劫持demo.html <body> <div id=\"app\"> {{message}}

Spring Security 實戰乾貨：從零手寫一個驗證碼登入

1. 前言 前面關於Spring Security寫了兩篇文章，一篇是介紹UsernamePasswordAuthenticationFilter，另一篇是介紹 AuthenticationManager。很多同學表示無法理解這兩個東西有什麼用，能解決哪些實際問題？所以今天就

84.手寫一個類的繼承

繼承在前端邏輯操作中是比較常見的，今天我們就從零開始寫一個js的繼承方式

手寫一個訊息佇列以及延遲訊息佇列

一、什麼是訊息佇列？ 訊息佇列（Message Queue），是分散式系統中重要的元件，其通用的使用場景可以簡單地描述為：

手寫一個簡單版的SpringMVC

一 寫在前面 這是自己實現一個簡單的具有SpringMVC功能的小Demo，主要實現效果是;

手寫一個簡單的工廠模式（一）

專案結構 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------