如何手写一个RPC？

news2025/1/10 12:06:04

在学习 RPC 框架之前，我们先来手写一个RPC。

我们在学习的过程中，一定要做到知其然，还要知其所以然。

架构演进

单体架构

要知道，在以前单体架构的时候，会将所有的应用功能都集中在一个服务当中。

nbsp

单体架构初始开发简单，所有的功能都在一个项目中，容易理解整个应用的业务，而且部署也比较简单，就一个服务。
还有就是方便测试和更容易实现跨多个业务功能的事务性操作。

但是单体服务也存在很多缺点：可维护性差、难以扩展、可用性低等等

拆分服务

既然单体服务有这么多缺点，那咋办嘛，将服务根据业务需求进行拆分呗。
拆分服务之后，那服务之间需要互相调用啊，采用什么方式交流呢（通信方式）？数据的一致性怎么保证呢？

nbsp

首先我们可能会想到，服务拆分了，但是数据库可以不用拆啊，多个服务共享统一份数据，
这样数据的一致性就很容易保证了。
或者对于数据一致性要求不高的服务采用消息中间件，保证数据的最终一致性就行；
再或者，服务之间通过RPC这种通讯机制通信也行啊。

RPC只是一种泛概念，在不同时期有不同的表现方式。

早期基于Web的RPC。如XML-RPC：使用XML格式编码其调用和HTTP作为传输机制。虽然它支持跨语言调用，但由于XML的冗余性，效率相对较低。
现代RPC系统，如JSON-RPC：一个无状态、轻量级的远程过程调用（RPC）协议，以JSON（JavaScript Object Notation）作为数据格式，可以使用各种传输协议。

在现代分布式系统开发中，RPC对任何开发者来说都是一项重要的技能，因此学习RPC就显得很重要了。

在正式学习RPC框架之前，我们手动实现一个PRC框架，方便于后面对其他RPC框架的学习。

手写RPC


nbsp

首先来看看上面这张图，做一个详细的介绍： 两个角色、三个项目

两个角色：一个服务提供者和一个服务消费者

三个项目：rpc-api、rpc-provider和rpc-consumer

API工程是整个服务的标准：
各类服务传输过程当中的传输对象的标准，包括接口的标准。

Provider工程：
将依赖于上面的标准，就是API工程，并且将会去实现IService，即实现标准当中定义的接口。还要基于网络对外提供服务，因此会包含Net Server这个模块来提供网络服务。主要用来接收和解析网络请求，并去调用 Service Dispatch 来完成整个服务的调用和分发。

Consumer工程：
Net Client 主要是完成网络的调用。
ProxyFactory，动态代理模式，主要在调用的过程当中屏蔽网络通讯相关的一些细节，使得我们开发人员在使用过程中不再关注网络细节。

工程搭建步骤

为了简单演示，rpc-api项目中只有一个接口，接口中有一个方法：addUser();
接口的具体实现在rpc-provider中；rpc-consumer中模拟调用addUser() 方法。

建立三个maven项目，首先创建API工程

搭建 rpc-api

如何新建maven工程这里就不做介绍了，下面只包含具体代码

1、pom文件

只包含一个lombok依赖，主要是为了方便不用手写getter和setter

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mntalk</groupId>
  <artifactId>rpc-api</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.30</version>
    </dependency>
  </dependencies>

</project>
2、UserDto

三个属性name、age、userId
因为需要在网络中传输，实现了Serializable，并添加了序列化id

package com.mntalk.dto;


import lombok.Data;
import java.io.Serializable;

@Data
public class UserDto implements Serializable {
    private static final long serialVersionUID = 4266781378102409837L;

    private String name;
    private int age;
    private String userId;
}
3、UserService

定义接口和方法

package com.mntalk.api;

import com.mntalk.dto.UserDto;

public interface UserService {
    // 添加用户
    public UserDto addUser(UserDto userDto);

}
4、RPACommonReqDto

定义统一的传输标准，这里先定义成这样，后面再详细解释，为什么会包含者几个属性

package com.mntalk.dto;

import lombok.Data;
import java.io.Serializable;
/**
 * 统一传输标准
 */
@Data
public class RPACommonReqDto implements Serializable {

    private static final long serialVersionUID = 6212822493972023391L;
    // 方法名
    private String methodName;

    // 类的全路径名
    private String classPath;

    // 形参列表
    private Object[] args;
}
5、将工程打成jar包，方便provider和consumer工程引入进行实现和调用

具体怎么打包就不做介绍了，可以使用命令打包，也可以接触idea打包

搭建 rpc-provider

提供接口实现，并使用Socket网络编程，模拟等待调用

1、pom文件

引入rpc-api工程

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mntalk</groupId>
  <artifactId>rpc-privider</artifactId>
  <version>1.0-SNAPSHOT</version>


  <dependencies>
    <dependency>
      <groupId>com.mntalk</groupId>
      <artifactId>rpc-api</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

</project>
2、实现UserService

实现具体的addUser方法，这里就模拟已经添加到数据库，并生成了userId，然后将生成的信息返回。
UserServiceImpl业务实现

package com.mntalk.impl;

import com.mntalk.api.UserService;
import com.mntalk.dto.UserDto;

import java.util.Random;

public class UserServiceImpl implements UserService {
    @Override
    public UserDto addUser(UserDto userDto) {
        // todo xxx

        // 模拟插入数据库并生成了userId
        System.out.println("接收：" + userDto);
        userDto.setUserId(new Random().nextInt(100000) + "");
        System.out.println("设置了用户id：" + userDto);

        return userDto  ;
    }
}
3、NetServer

根据上面实现手写RPC的思路图，现在需要Socket网络编程，模拟等待consumer来进行调用。

这里采用线程池来进行异步实现，为什么不不直接在主线程中等待呢？
因为ServerSocket的accept() 是典型的 Blocking IO，会阻塞工作线程。

package com.mntalk.net;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 对外提供服务
 */
public class NetServer {

    static final ExecutorService threadPool = Executors.newFixedThreadPool(50);

    public static void startUp(int port) throws IOException {

        ServerSocket serverSocket = new ServerSocket(port);


//        // 阻塞等待客户端连接
//        Socket socket = serverSocket.accept();
//
//        // 典型的 Blocking IO，会阻塞工作线程
//        socket.getOutputStream();
//        socket.getInputStream();

        // 多线程方式
        // 线程池
        while (true) {
            Socket socket = serverSocket.accept();
            threadPool.submit(new RPCProcessor(socket));
        }

    }

}
4、RPCProcessor

具体的socket处理，实现Runnable接口，方便放入多线程处理。
其中很重要的一点就是模拟服务的分发 ServiceDispatch.dispatch(reqObject);

package com.mntalk.net;

import com.mntalk.dispatch.ServiceDispatch;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Optional;

public class RPCProcessor implements Runnable {

    ObjectInputStream objectInputStream = null;
    ObjectOutputStream objectOutputStream = null;

    private final Socket socket;

    /**
     * 因为需要处理socket的流，所以需要注入socket
     */
    public RPCProcessor(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {


        try {
            // 将输入输出流包装成对象流
            objectInputStream = new ObjectInputStream(socket.getInputStream());

            // 读取客户端对象
            Object reqObject = objectInputStream.readObject();
            // 服务分发
            Object respObj = ServiceDispatch.dispatch(reqObject);


            // 将结果进行输出
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(respObj);
            objectOutputStream.flush();


        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (Optional.ofNullable(objectInputStream).isPresent()) {

                    objectInputStream.close();
                }
                if (Optional.ofNullable(objectOutputStream).isPresent()) {

                    objectOutputStream.close();
                }
            } catch (IOException e) {
                System.out.println("远程调用流关闭错误：" + e.getMessage());
            }
        }

    }
}
5、ServiceDispatch 服务分发

在这里详细解释一下，为什么之前要定义一个 RPACommonReqDto 标准传输对象，并且包含三个属性：
最主要的就是为了下面通过反射生成具体的instance，然后调用方法。

通过classPath可以生成字节码对象；通过方法参数列表，可以得到参数类型列表，然后再通过方法名，就可以得到具体的方法；
然后就可以进行方法调用了。

package com.mntalk.dispatch;


import com.mntalk.dto.RPACommonReqDto;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ServiceDispatch {

    /**
     * 服务分发
     */
    public static Object dispatch(Object reqObject) {
        // 大胆猜测一下，reqObject 中应该包含了分发的内容属性
        // type == 1    --> addUser
        // type == 2    --> deleteUser
        // 上面的这样太呆板了



        // 基于反射机制，就很灵活   instance方法的调用
        // classpath    全路径
        // 方法名 + 形参列表的类型列表
        // 实例对象   Class.newInstance
        // 方法在调用过程当中参数的值 ( getType 可以获得 形参列表的类型列表 )
        RPACommonReqDto reqDto = (RPACommonReqDto)reqObject;
        String classPath = reqDto.getClassPath();
        String methodName = reqDto.getMethodName();
        Object[] args = reqDto.getArgs();

        Class[] types = null;

        if (args != null && args.length > 0) {
            types = new Class[args.length];
            for (int i = 0; i < args.length; i++) {
                types[i] = args[i].getClass();
            }
        }

        Object respObject = null;

        // 方法获取及调用
        try {
            Class<?> clazz = Class.forName(classPath);
            Method method = clazz.getDeclaredMethod(methodName, types);
            Constructor<?> constructor = clazz.getDeclaredConstructor();
            respObject = method.invoke(constructor.newInstance(), args);

        } catch (Exception e) {
            e.printStackTrace();
        }


        return  respObject;
    }


}

搭建 rpc-consumer

模拟调用

1、pom文件

引入rpc-api工程

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mntalk</groupId>
  <artifactId>rpc-consumer</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>com.mntalk</groupId>
      <artifactId>rpc-api</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

</project>
2、TestRPC

模拟调用

package com.mntalk;

import com.mntalk.api.UserService;
import com.mntalk.dto.UserDto;
import com.mntalk.proxy.FactoryProxy;

public class TestRPC {
    public static void main(String[] args) {

        UserService userService = FactoryProxy.getInstanceByClassType(UserService.class);

        UserDto userDto = new UserDto();
        userDto.setName("feiz");
        userDto.setAge(18);

        System.out.println("invoke before: " + userDto);

        userDto = userService.addUser(userDto); // 实际上是跑到RPCInvocationHandler的invoke方法中去执行逻辑了

        System.out.println("invoke after: " + userDto);
    }
}
3、FactoryProxy 代理工厂

通过JDK的动态代理，底层会采用ASM字节码重组技术，会生成一个新的class字节码对象，
然后由ClassLoader将字节码对象加载到JVM进程当中，经由这个类的实例，
去创建出来了一个实例对象，这个class对象实现了interfaceClazz接口。

package com.mntalk.proxy;


import com.mntalk.api.UserService;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

/**
 * 代理工厂
 */
public class FactoryProxy {

//    写死的情况（并不是我们需要的）
//    public static UserService getUserServiceInstance() {
//        return (UserService) null;
//    }
    
    // 你传入什么样的一个接口，我希望得到的是你传入接口的实例对象
    public static <T> T getInstanceByClassType(Class<T> interfaceClazz) {

        /**
         * 需要用到JDK的动态代理
         *
         * ClassLoader loader,      类加载器Bootstrap、Application、Extension、户自定义类加载器   这里默认用Application
         * Class<?>[] interfaces,   实现的接口列表
         * InvocationHandler h      处理器
         */
        return (T) Proxy.newProxyInstance(FactoryProxy.class.getClassLoader(),
                new Class[]{interfaceClazz},
                new RPCInvocationHandler()
                );
    }
}
4、RPCInvocationHandler

RPCInvocationHandler

package com.mntalk.proxy;

import com.mntalk.dto.UserDto;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

// 创建实例对象时使用
public class RPCInvocationHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("11111");
        UserDto userDto = new UserDto();
        userDto.setAge(99);
        userDto.setName("feifei");
        return userDto;
    }
}

在TestRPC中点击运行
实际上userService.addUser(userDto);是跑到RPCInvocationHandler的invoke方法中去执行逻辑了

nbsp

在invoke方法中，实现了目标对象的保护和增强，
那么我们可以将网络实现的细节放到这里面来实现，让调用者无感知这件事情。

5、在invoke中组装网络请求

这里监听的是9999，因为provider中使用的是9999端口，自己根据自己的进行调整就行


package com.mntalk.proxy;

import com.mntalk.anno.ServiceMapped;
import com.mntalk.dto.RPACommonReqDto;
import com.mntalk.dto.UserDto;
import com.mntalk.net.NetClient;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

// 创建实例对象时使用
public class RPCInvocationHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 组装 RPACommonReqDto 对象，完成网络的调用。。。
        RPACommonReqDto commonReqDto = new RPACommonReqDto();
        commonReqDto.setArgs(args);
        commonReqDto.setMethodName(method.getName());
        String classPath = method.getDeclaringClass().getDeclaredAnnotation(ServiceMapped.class).value();
        commonReqDto.setClassPath(classPath);    // 使用注解的方式替代写死的方式


        // 完成网络的调用（host暂时写死）
        return NetClient.callRemoteService("localhost", 9999, commonReqDto);
    }
}
6、NetClient 拟调用
package com.mntalk.net;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Optional;

/**
 * 网络调用
 */
public class NetClient {

    public static Object callRemoteService(String host, int port, Object reqObject) {
        ObjectOutputStream objectOutputStream = null;
        ObjectInputStream objectInputStream = null;
        Object respObject = null;
        Socket socket = null;

        try {
            socket = new Socket(host, port);

            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(reqObject);
            objectOutputStream.flush();

            objectInputStream = new ObjectInputStream(socket.getInputStream());
            respObject = objectInputStream.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (Optional.ofNullable(objectInputStream).isPresent()) {
                    objectInputStream.close();
                }
                if (Optional.ofNullable(objectOutputStream).isPresent()) {
                    objectOutputStream.close();
                }
            } catch (IOException e) {
                System.out.println("远程调用流关闭错误：" + e.getMessage());
            }
        }

        return respObject;
    }

}

7、使用注解替代classPath写死的情况

在rpc-api中定义注解**@ServiceMapped**， 并且在 UserService 接口上添加注解 @ServiceMapped(“com.mntalk.impl.UserServiceImpl”)

package com.mntalk.anno;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface ServiceMapped {
    String value();
}

7、在TestRPC中运行

如下图，consumer调用provider成功，模拟插入数据，生成id并返回了。

nbsp

小结

上面我们手动实现了一个RPC， 能够发起远程调用了，但是与 Dubbo 这样的框架相比，还有什么需要优化的点？

我们现在仅仅只是完成了跨进程、跨网络的调用。
这个机制还是有很多可以优化和调整的地方，比如说

序列化方式

给予Java的网络编程，Java的序列化还是不够妥当，Java的序列化和反序列化在安全性方面考虑得非常多，
把一个Java序列化和反序列化，都会把整个类的层级结构进行序列化，包括序列化ID的检查，所以序列化出来的二进制占用的空间是非常大的。
这样在网络中传输就会占用更大的带宽，带来更大的数据传输效率的影响。

Dubbo中默认采用Hessian2序列化
Hessian2是一种紧凑的、对各种语言友好的二进制协议，它在性能和跨语言互操作性方面都表现不错。

网络编程中流的处理

我们现在采用的是基于线程池的异步处理方式。

可以使用更为友好的网络编程方式进行处理，比如 MINA、Netty等等，Dubbo底层的默认通讯框架就是Netty

Netty：
这是一个异步的、事件驱动的网络应用程序框架，可以快速开发可维护的高性能协议服务器与客户端。
Netty广泛用于开发网络游戏、大数据传输应用、实时通讯系统等。它提供了对多种传输类型的支持，例如TCP和UDP的socket服务。

最后说一句(求关注，求赞，别白嫖我)

最近无意间获得一份阿里大佬写的刷题笔记和面经，一下子打通了我的任督二脉，进大厂原来没那么难。

这是大佬写的， 7701页的阿里大佬写的刷题笔记，让我offer拿到手软

求一键三连：点赞、分享、收藏

点赞对我真的非常重要！在线求赞，加个关注我会非常感激！@小郑说编程

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1388543.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

学习Java API（三）：基础知识点一文通✅

学习Java API（三）：基础知识点一文通✅

推荐阅读 智能化校园&#xff1a;深入探讨云端管理系统设计与实现&#xff08;一&#xff09; 智能化校园&#xff1a;深入探讨云端管理系统设计与实现&#xff08;二&#xff09; 文章目录 推荐阅读Date 类SimpleDateFormatCalendar Date 类 java.util 包提供了 Date 类来封…
阅读更多...
UI自动化测试框架

UI自动化测试框架

文章目录 UI自动化基础什么是UI自动化测试框架UI自动化测试框架的模式数据驱动测试框架关键字驱动测试框架行为驱动测试框架 UI自动化测试框架的作用UI自动化测试框架的核心思想UI自动化测试框架的步骤UI自动化测试框架的构成UtilsLog.javaReadProperties.Java coreBaseTest.ja…
阅读更多...
屏幕录制软件有哪些？强烈推荐5款免费好用录屏软件

屏幕录制软件有哪些？强烈推荐5款免费好用录屏软件

录制全屏视频是制作视频教程、评论、游戏等内容的绝佳方式。它可以包括您计算机屏幕上的任何活动以及您的音频和网络摄像头。特别是&#xff0c;屏幕录像机对喜欢创建软件评论的视频博主很有帮助。如果您是其中之一&#xff0c;那么好消息是您可以在网络上找到很多屏幕录制应用…
阅读更多...
纯c++简易的迷宫小游戏

纯c++简易的迷宫小游戏

一个用c写的黑框框迷宫 适合新手入门学习 也适合大学生小作业 下面附上代码 总体思路 初始化游戏界面&#xff1a;设置迷宫的大小&#xff08;WIDTH和HEIGH&#xff09;&#xff0c;生成迷宫地图&#xff08;map&#xff09;&#xff0c;包括墙壁、空地、起点和终点。显示…
阅读更多...
怿星科技测试实验室获CNAS实验室认可，汽车以太网检测能力达国际标准

怿星科技测试实验室获CNAS实验室认可，汽车以太网检测能力达国际标准

2023年12月27日&#xff0c;上海怿星电子科技有限公司测试实验室&#xff08;下称&#xff1a;EPT LABS&#xff09;通过CNAS实验室认可批准&#xff0c;并于2024年1月5日正式取得CNAS实验室认可证书&#xff08;注册号CNAS L19826&#xff09;&#xff0c;标志着怿星科技的实验…
阅读更多...
SpringBoot3自动配置原理

SpringBoot3自动配置原理

​​​​​​自动配置 遵循约定大约配置的原则&#xff0c;在boot程序启动后&#xff0c;起步依赖中的一些bean对象会自动注入到ioc容器 看一下我们前面写的代码有没有达到自动配置的效果呢&#xff1f; 没有自动&#xff0c;我们写了配置类&#xff0c;写了Import注解&#…
阅读更多...
一台电脑如何通过另一台联网电脑访问网络

一台电脑如何通过另一台联网电脑访问网络

电脑A没有连接网络&#xff0c;电脑B已经连接wifi。 电脑A如何通过访问电脑B从而连接网络&#xff1f; 1. 将这2台电脑用网线直连 2. 电脑B打开【网络和Internet设置】 3. 右键点击WLAN&#xff0c;选择属性&#xff0c;进入共享tab页面&#xff0c;勾选【允许其他网络用户通过…
阅读更多...
超融合之道：亚信安慧AntDB 8.0版本引领数据库创新

超融合之道：亚信安慧AntDB 8.0版本引领数据库创新

在当今多变的数据应用场景中&#xff0c;AntDB作为行业领先的超融合流式实时数仓&#xff0c;秉承着“融合实时”的研发理念&#xff0c;全面应对企业日益复杂的数据处理需求。通过SQL接口访问多种执行引擎&#xff0c;AntDB在实现交易、分析等多重能力的“超融合”方面取得了显…
阅读更多...
nacos配置yml空格报错提示

nacos配置yml空格报错提示

错误格式 正确格式 spring:redis: # redis配置host: 192.168.30.113 # IPport: 6379 # 端口password: # 密码connect-timeout: 10s # 连接超时时间lettuce: # lettuce redis客户端配置pool: # 连接池配置max-active: 8 # 连接池最大连接数&#xff08;使用负值表示没有限…
阅读更多...
android studio设置gradle和gradle JDK版本

android studio设置gradle和gradle JDK版本

文章目录 1.gradle JDK版本2.gradle版本 1.gradle JDK版本 file -> project structure -> SDK Location -> Gradle Settings -> Gradle JDK -> Download JDK 2.gradle版本 file -> project structure -> Project
阅读更多...
打造创新的金融数据平台，加速数字化和智能化转型丨PingCAP 官网金融行业专区上线

打造创新的金融数据平台，加速数字化和智能化转型丨PingCAP 官网金融行业专区上线

自诞生以来&#xff0c;TiDB 的原生分布式架构在强一致性、高可用性和可扩展性等方面与金融级业务需求高度契合&#xff0c;早期版本即为包括北京银行在内的金融用户提供服务。 TiDB 的核心能力始终源自与中国金融用户的共同创造。作为金融级分布式数据库&#xff0c;TiDB 在国…
阅读更多...
东南亚潜力巨大，下一个变现增长点！Flat Ads助力休闲游戏出海

东南亚潜力巨大，下一个变现增长点！Flat Ads助力休闲游戏出海

近年来,得益于庞大的消费市场和人口红利,东南亚经济飞速发展,尤其在移动互联网和数字经济领域表现亮眼。巨大的发展空间吸引了众多出海者布局,而东南亚有利的人口结构、不断增长的财富以及日益城市化的人口为数字经济的未来增长奠定了基础。那么,2024年游戏出海东南亚,是否仍有…
阅读更多...
Zabbix补充扩展

Zabbix补充扩展

目录 1.自定义监控内容 客户端配置 2.zabbix自动发现与自动注册 自动发现 在服务端和客户端上配置 hosts 解析 在Web页面配置自动发现 自动注册 3.部署zabbix代理服务器 下载zabbix-proxy以及数据库 启动zabbix-proxy及添加hosts解析 在Web页面配置agent代理 配置a…
阅读更多...
S1D13L02 VGA简单的液晶控制器

S1D13L02 VGA简单的液晶控制器

S1D13L02是一款简单、低成本、低功耗、多用途的液晶控制器&#xff0c;具有一个1024 KB的嵌入式SRAM显示缓冲区。 S1D13L02提供了一个灵活的&#xff0c;但易于开发的显示系统&#xff0c;适合于满足嵌入式市场的需求&#xff0c;如工厂自动化、医疗设备和 办公自动化应用。 S1…
阅读更多...
过滤器、拦截器、AOP、ControllerAdvcie执行顺序对比

过滤器、拦截器、AOP、ControllerAdvcie执行顺序对比

过滤器Filter 简介 来自J2EE中的Servlet技术实现原理&#xff1a;基于servlet的函数回调实现只可以获取到请求中的request和response&#xff0c;无法获取到响应方法的信息可以拦截所有请求支持使用xml配置和注解配置应用场景&#xff1a;权限认证、敏感词检测、访问日志记录…
阅读更多...
JVM对象创建与内存分配机制剖析

JVM对象创建与内存分配机制剖析

欢迎大家关注我的微信公众号&#xff1a; 传送门&#xff1a;JVM内存模型深度剖析与优化 目录 对象的创建 对象大小与指针压缩 对象内存分配 对象内存回收 对象的创建 对象创建的主要流程: 1.类加载检查 虚拟机遇到一条new指令时&#xff0c;首先将去检查这个指令的…
阅读更多...
GC6106 双通道5V低电压步进电机驱动芯片——低噪声、低振动

GC6106 双通道5V低电压步进电机驱动芯片——低噪声、低振动

GC6106是双通道5V低电压步进电机驱动器&#xff0c;具有低噪声、低振动的特点&#xff0c;特别适用于相机的变焦和对焦系统&#xff0c;万向节和其他精密&#xff0c;低噪声STM控制系统。该芯片为每个通道集成了256微步驱动器。我SPl接口&#xff0c;用户可以方便地调整驱动器的…
阅读更多...
设计模式入门

设计模式入门

0. 类图 1. 设计原则 1.单一职责原则&#xff1a;每个类只有一个功能 2.开放封闭原则&#xff1a;模块和函数应该对扩展开放(对提供方)&#xff0c;对修改关闭(对使用方) 3.里氏代换原则&#xff1a;子类拥有父类的所有方法和属性&#xff0c;从而可以减少创建类的工作量 4.依…
阅读更多...
【MySQL高级】——性能分析

【MySQL高级】——性能分析

数据库调优中&#xff0c;目标是 响应时间更快&#xff0c;吞吐量更大&#xff0c;利用宏观的监控工具和微观的日志分析帮助我们快速找到调优的思路和方式。 1. 数据库服务器优化步骤 整个流程划分成了 观察&#xff08;Show status&#xff09; 和 行动&#xff08;Action&am…
阅读更多...
业财融合：解密企业管理的黄金钥匙

业财融合：解密企业管理的黄金钥匙

本文提炼总结自专刊《上市公司如何打好合规与增长的双赢之战》。全书40页&#xff0c;出品方纷享销客市场部。如有需要&#xff0c;请阅读原版电子书&#xff1a;《上市公司如何打好合规与增长的双赢之战》 目 录 一、什么是业财融合&#xff1f; 二、财务部门面临的挑战…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023