手写一个简单的RPC

最新推荐文章于 2024-01-16 09:31:05 发布
最新推荐文章于 2024-01-16 09:31:05 发布
阅读量192 收藏
点赞数
分类专栏： RPC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45100361/article/details/113592043
版权

公共类

public class User implements Serializable {

    private static final long serialversionUID = 1L;

    private Integer id;
    private String name;

    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public static long getSerialversionUID() {
        return serialversionUID;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

public interface IUserService {
    public User findUserById(Integer id);
}


public class UserServiceImpl implements IUserService {
    @Override
    public User findUserById(Integer id) {
        return new User(id, "Alice");
    }
}

版本一

public class Client {

    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 8888);

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);

        dos.writeInt(123);


        socket.getOutputStream().write(baos.toByteArray());//把123变成二进制数组 在网络中传输的数据归根结底都是二进制数据

        socket.getOutputStream().flush();//清空缓冲区  将数据强行输出去


        DataInputStream dis = new DataInputStream(socket.getInputStream());
        int id = dis.readInt();
        String name = dis.readUTF();
        User user = new User(id, name);


        System.out.println(user);

        dos.close();

        socket.close();
    }
}

public class Server {

    private static boolean running = true;

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);

        while (running) {
            Socket s = serverSocket.accept();
            process(s);
            s.close();
        }

        serverSocket.close();
    }

    public static void process(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        int id = dis.readInt();
        IUserService service = new UserServiceImpl();
        User user = service.findUserById(id);
        dos.writeInt(user.getId());
        dos.writeUTF(user.getName());
        dos.flush();
    }
}

版本二

public class Client {
    public static void main(String[] args) throws IOException {
        Stub stub = new Stub();//这么写就给你屏蔽了许多细节
        System.out.println(stub.findUserById(223));
    }
}


//将网络进一步的封装
public class Stub {

    public User findUserById(Integer id) throws IOException {
        Socket socket = new Socket("127.0.0.1", 8888);

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        DataOutputStream dos = new DataOutputStream(baos);

        dos.writeInt(id);

        OutputStream out = socket.getOutputStream();

        out.write(baos.toByteArray());
        out.flush();

        DataInputStream dis = new DataInputStream(socket.getInputStream());

        int readId = dis.readInt();
        String readName = dis.readUTF();

        User user = new User(readId, readName);

        dis.close();
        dos.close();
        socket.close();
        return user;

    }
}

public class Server {

    private static boolean running = true;

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);

        while (running) {
            Socket s = serverSocket.accept();
            process(s);
            s.close();
        }

        serverSocket.close();
    }

    public static void process(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        int id = dis.readInt();
        IUserService service = new UserServiceImpl();
        User user = service.findUserById(id);
        dos.writeInt(user.getId());
        dos.writeUTF(user.getName());
        dos.flush();
    }
}

版本三

public class Client {

    public static void main(String[] args) {

        IUserService service = Stub.getStub();
        System.out.println(service.findUserById(123));//实际调的是invoke这个方法
    }
}

public class Server {

    private static boolean running = true;

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);

        while (running) {
            Socket s = serverSocket.accept();
            process(s);
            s.close();
        }

        serverSocket.close();
    }

    public static void process(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        int id = dis.readInt();
        IUserService service = new UserServiceImpl();
        User user = service.findUserById(id);
        dos.writeInt(user.getId());
        dos.writeUTF(user.getName());
        dos.flush();
    }
}

public class Stub {


    public static IUserService getStub() {


        InvocationHandler h = new InvocationHandler() {

            /**
             *
             * @param proxy   代理的对象是谁
             * @param method   调的是哪个方法  findUserById()
             * @param args    这个方法传了哪些参数  123
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("你好");
                Socket s = new Socket("127.0.0.1", 8888);
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                DataOutputStream dos = new DataOutputStream(baos);
                dos.writeInt(123);

                s.getOutputStream().write(baos.toByteArray());
                s.getOutputStream().flush();

                DataInputStream dis = new DataInputStream(s.getInputStream());

                int id = dis.readInt();
                String name = dis.readUTF();
                User user = new User(id, name);

                dos.close();
                s.close();
                return user;
            }
        };

        //第一个参数：被代理对象的类加载器
        //第二个参数：被代理对象的接口  IUserService本来就是个接口
        //第三个参数：
        Object o = Proxy.newProxyInstance(IUserService.class.getClassLoader(), new Class[] {IUserService.class}, h);

        return (IUserService) o;
    }
}

版本四

public class Client {

    public static void main(String[] args) {

        IUserService stub = Stub.getStub();
        System.out.println(stub.findUserById(123));//你调findUserById这个方法会给你调invoke这个方法
    }
}

public class Server {
    private static boolean running = true;

    public static void main(String[] args) throws Exception {
        ServerSocket ss = new ServerSocket(8888);

        while (running) {
            Socket s = ss.accept();
            process(s);
            s.close();
        }
    }

    private static void process(Socket s) throws Exception {
        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();
        ObjectInputStream ois = new ObjectInputStream(in);

        DataOutputStream dos = new DataOutputStream(out);

        String methodName = ois.readUTF();//把方法名读进来
        Class[] parameterTypes = (Class[])ois.readObject();//参数类型读进来
        Object[] args = (Object[])ois.readObject();//参数读进来

        IUserService service = new UserServiceImpl();
        Method method = service.getClass().getMethod(methodName, parameterTypes);//通过反射的方式找到类里面的方法
        User user = (User)method.invoke(service,args);//对方法进行调用

        dos.writeInt(user.getId());//返回数据
        dos.writeUTF(user.getName());

        dos.flush();

    }
}

public class Stub {



    public static IUserService getStub() {


        InvocationHandler h = new InvocationHandler() {

            /**
             *
             * @param proxy   代理的对象是谁
             * @param method   调的是哪个方法  findUserById()
             * @param args    这个方法传了哪些参数  123
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                Socket s = new Socket("127.0.0.1", 8888);

                ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());

                //把方法的信息通过网络传过去
                String methodName = method.getName();//现在调用方法的name
                //通过 方法名 和 参数列表 就可以知道你要调用哪个方法了
                Class<?>[] parameterTypes = method.getParameterTypes();//方法的参数类型  防止出现方法重载  来辨认哪个方法

                //将一个方法的基本信息都写出去
                oos.writeUTF(methodName);
                oos.writeObject(parameterTypes);
                oos.writeObject(args);
                oos.flush();

                DataInputStream dis = new DataInputStream(s.getInputStream());

                int id = dis.readInt();
                String name = dis.readUTF();

                User user = new User(id, name);

                dis.close();
                s.close();

                return user;

            }
        };

        //第一个参数：被代理对象的类加载器
        //第二个参数：被代理对象的接口  IUserService本来就是个接口
        //第三个参数：
        Object o = Proxy.newProxyInstance(IUserService.class.getClassLoader(), new Class[] {IUserService.class}, h);

        return (IUserService) o;
    }
}

版本五

public class Client {

    public static void main(String[] args) {

        IUserService stub = Stub.getStub();
        System.out.println(stub.findUserById(123));//你调findUserById这个方法会给你调invoke这个方法  这里给你返回的
    }
}

public class Server {
    private static boolean running = true;

    public static void main(String[] args) throws Exception {
        ServerSocket ss = new ServerSocket(8888);

        while (running) {
            Socket s = ss.accept();
            process(s);
            s.close();
        }
    }

    private static void process(Socket s) throws Exception {
        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();
        ObjectInputStream ois = new ObjectInputStream(in);

        DataOutputStream dos = new DataOutputStream(out);

        String methodName = ois.readUTF();//把方法名读进来
        Class[] parameterTypes = (Class[])ois.readObject();//参数类型读进来
        Object[] args = (Object[])ois.readObject();//参数读进来

        IUserService service = new UserServiceImpl();
        Method method = service.getClass().getMethod(methodName, parameterTypes);//通过反射的方式找到类里面的方法
        User user = (User)method.invoke(service,args);//对方法进行调用

        ObjectOutputStream oos = new ObjectOutputStream(out);//将输出的结果封装成Object

        //直接把结果user对象返回给客户端
        oos.writeObject(user);

        dos.flush();

    }
}

public class Stub {



    public static IUserService getStub() {


        InvocationHandler h = new InvocationHandler() {

            /**
             *
             * @param proxy   代理的对象是谁
             * @param method   调的是哪个方法  findUserById()
             * @param args    这个方法传了哪些参数  123
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                Socket s = new Socket("127.0.0.1", 8888);

                ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());

                //把方法的信息通过网络传过去
                String methodName = method.getName();//现在调用方法的name
                //通过 方法名 和 参数列表 就可以知道你要调用哪个方法了
                Class[] parameterTypes = method.getParameterTypes();//方法的参数类型  防止出现方法重载  来辨认哪个方法

                //将一个方法的基本信息都写出去
                oos.writeUTF(methodName);
                oos.writeObject(parameterTypes);
                oos.writeObject(args);//args就是参数
                oos.flush();

                DataInputStream dis = new DataInputStream(s.getInputStream());

                int id = dis.readInt();
                String name = dis.readUTF();

                User user = new User(id, name);

                dis.close();
                s.close();

                return user;

            }
        };

        //第一个参数：被代理对象的类加载器
        //第二个参数：被代理对象的接口  IUserService本来就是个接口
        //第三个参数：
        Object o = Proxy.newProxyInstance(IUserService.class.getClassLoader(), new Class[] {IUserService.class}, h);

        return (IUserService) o;
    }
}

版本六

public class Client {


    public static void main(String[] args) {

        //传入一个类  给你返回一个指定对象  这是一个代理类
        IUserService service = (IUserService) Stub.getStub(IUserService.class);

        System.out.println(service.findUserById(123));
    }
}

public class Server {
    private static boolean running = true;

    public static void main(String[] args) throws Exception {
        ServerSocket ss = new ServerSocket(8888);

        while (running) {
            Socket s = ss.accept();
            process(s);
            s.close();
        }
    }

    private static void process(Socket s) throws Exception {
        InputStream in = s.getInputStream();
        OutputStream out = s.getOutputStream();
        ObjectInputStream ois = new ObjectInputStream(in);

        //这几个获取的顺序和你客户端写出的顺序一样吧
        //String clazzName = ois.readUTF();
        String methodName =  ois.readUTF();
        Class[] parameterTypes =  (Class[])ois.readObject();
        Object[] args = (Object[])ois.readObject();

        Class clazz = null;

        //从服务注册表中找到具体的类   这个是具体的实现类
        clazz = UserServiceImpl.class;


        Method method = clazz.getMethod(methodName, parameterTypes);

        //这里才是调用的方法  客户端把你需要调用的方法信息给你
        //首先我要创建一个对象才能调用里面的方法  clazz.newInstance()  反射创建对象
        Object o = (Object) method.invoke(clazz.newInstance(), args);


        ObjectOutputStream oos = new ObjectOutputStream(out);
        oos.writeObject(o);
        oos.flush();

    }
}

public class Stub {

    //这样可以给你返回一个任意类型的对象
    public static Object getStub(Class clazz) {


        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {


                Socket s = new Socket("127.0.0.1", 8888);

                ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());


                String clazzName = clazz.getName();//获取类的名字
                String methodName = method.getName();
                Class<?>[] parameterTypes = method.getParameterTypes();

                //oos.writeObject(clazzName);
                oos.writeUTF(methodName);
                oos.writeObject(parameterTypes);
                oos.writeObject(args);
                oos.flush();

                ObjectInputStream ois = new ObjectInputStream(s.getInputStream());

                Object o = ois.readObject();

                oos.close();
                s.close();

                return o;
            }


        };

        Object o = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, h);
        return o;
    }
}
千鸟送天
关注
专栏目录
手写一个 RPC 远程调用(C++)
WilliamCode的博客
02-25 3901
手写一个 RPC 远程调用(C++)
c++socket多个客户端通过不同端口与一个服务端通信_手写RPC，深入底层理解整个RPC通信...
weixin_42347739的博客
12-18 608
一、前言RPC，远程过程调用，调用远程方法像调用本地方法一样。RPC交互分为客户端和服务端，客户端调用服务端方法，服务端接收数据并打印到控制台，并response响应给客户端。RPC和HTTP的联系与区别联系：都是远程通信的网络协议，任何网络协议都包括语法、语义、时序三个特征。区别：HTTP协议是应用层协议，更多地用于前后端通信或移动端、PC端与后端通信，其他的常用应用层协议还包括SSH协议、ft...
一文讲解 基于C++手写Rpc项目
hch977的博客
06-07 3096
一文讲解C++ rpc的实现, 基于muduo与protobuf
手写简易版rpc
sg7067576的专栏
06-08 1181
本文为手写版rpc通信框架，主要为了解决服务间的通信复杂度，仅实现通信过程，不添加注册中心路由等组件，非常适合小型项目的解耦合。 1.自定义需要的注解 EmokeRpcClient,EmokeMapping @Documented @Inherited @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
RPC（ Remote Procedure Call） C++ 基础
Ma_Hong_Kai的博客
10-26 816
1、基础 prc、分布式计算、 Nelson ： ------- 下文摘自RPC 的概念模型与实现解析---------- 模型 1. User 2. User-stub 3. RPCRuntime 4. Server-stub 5. Server 组件 RpcServer 负责导出（export）远程接口 RpcClient 负责导入（import）远程...
手写rpc rpc简单源码 rpc源码学习 rpc过程了解 rpc通信原理
09-20
下面将详细解释RPC的核心概念、工作原理以及手写RPC的基本流程。 一、RPC核心概念 1. **客户端（Client）**：发起RPC调用的一方，它通常需要知道服务接口和方法，但不需要关心服务是如何实现的。 2. **服务端...
手写一个RPC框架（造轮子）
q952194436的博客
12-16 3719
偶然间看到一个RPC的框架项目，感觉与其他的项目与众不同，所以准备跟着实现一下。由于教程比较少，因此写下这边记录，慢慢踩坑。既然是重复造轮子，自然是以学习框架与组件的运用为主。 1 涉及的知识点 RPC的概念及运作流程。 RPC协议及RPC框架的概念。 Netty的基本使用，修复高并发情况下，netty导致的内存泄漏问题。 Java序列化以及反序列化，protobuf和kryo序列化协议，配置即用。 Zookeeper作为注册中心的基本使用。 自定义注释实现特殊业务逻辑 Java动态代理 自定义Sprin
简单手写tcp-rpc.zip
03-22
# 手撕RPC实现基于TCP的仿Dubbo...>万万没想到我的第一次面试的第一个问题就是与此相关，希望认真准备每一次面试，及时查漏补缺，谨以此文，代表诚意~奥利给！ > >思路： >my-rpc通过client调用interface给server
Netty4.1实战-手写RPC框架.pdf
09-01
本专题主要通过三个章节实现一个rpc通信的基础功能，来学习RPC服务中间件是如何开发和使用。章节内以源码加说明实战方式来讲解，请尽可能下载源码学习。 - 手写RPC框架第一章《自定义配置xml》 - 手写RPC框架第二章...
手写rpc框架
juzhenxing的博客
06-27 200
服务端 public interface HelloService { String sayHello(String msg); } public class HelloServiceImpl implements HelloService { @Override public String sayHello(String msg) { return "hello, " + msg; } } import java.io.IOExceptio
RPC的实现
11-01
介绍RCP的实现原理 目录 1. 前言 2 2. 基本概念 3 2.1. IDL 3 2.2. 代理（Proxy） 3 2.3. 存根（Stub） 4 3. 三要素 4 3.1. 网络通讯 4 3.2. 消息编解码 5 3.3. IDL编译器 5 4. flex和bison 5 4.1. 准备概念 5 4.1.1. 正则表达式（regex/regexp） 6 4.1.2. 符号∈ 6 4.1.3. 终结符/非终结符/产生式 6 4.1.4. 记号（Token） 6 4.1.5. 形式文法 7 4.1.6. 上下文无关文法（CFG） 7 4.1.7. BNF 8 4.1.8. 推导 8 4.1.9. 语法树 8 4.1.10. LL(k) 9 4.1.11. LR(k) 9 4.1.12. LALR(k) 9 4.1.13. GLR 9 4.1.14. 移进/归约 9 4.2. flex和bison文件格式 9 4.2.1. 定义部分 10 4.2.2. 规则部分 10 4.2.3. 用户子例程部分 10 4.3. flex基础 10 4.3.1. flex文件格式 11 4.3.2. 选项 11 4.3.3. 名字定义 11 4.3.4. 词法规则 12 4.3.5. 匹配规则 12 4.3.6. %option 13 4.3.7. 全局变量yytext 13 4.3.8. 全局变量yyval 13 4.3.9. 全局变量yyleng 13 4.3.10. 全局函数yylex 13 4.3.11. 全局函数yywrap 13 4.4. bison基础 14 4.4.1. bison文件格式 14 4.4.2. %union 14 4.4.3. %token 15 4.4.4. 全局函数yyerror() 15 4.4.5. 全局函数yyparse() 15 4.5. 例1：单词计数 15 4.5.1. 目的 15 4.5.2. flex词法文件wc.l 16 4.5.3. Makefile 16 4.6. 例2：表达式 17 4.6.1. 目的 17 4.6.2. flex词法exp.l 17 4.6.3. bison语法exp.y 17 4.6.4. Makefile 19 4.6.5. 代码集成 19 4.7. 例3：函数 20 4.7.1. 目的 20 4.7.2. func.h 20 4.7.3. func.c 21 4.7.4. IDL代码func.idl 22 4.7.5. flex词法func.l 22 4.7.6. bison语法func.y 24 4.7.7. Makefile 27 5. 进阶 27 5.1. 客户端函数实现 27 5.2. 服务端函数实现 28 5.2.1. Stub部分实现 28 5.2.2. 用户部分实现 29 6. 参考资料 29
手写一个简单的rpc框架
qq_48336929的博客
10-05 216
手写一个简单的rpc框架 自己手写的一个小RPC框架，只是为了巩固自己所学的知识。 几个概念 RPC: Remote Procedure Call即远程过程调用，是分布式系统常用的一种通信方法，从跨进程到跨物理机已经有十几年的历史了。 Procedure: 一段可执行的代码，自我可理解为java中的方法而已。 跨进程的交互方式： RESTful、WebService、HTTP、基于DB做数据交换，基于MQ数据交换及RPC 几个模块 my-rpc my-rpc-common:公共模块（工具类） my-rpc
手写简单 rpc 框架
渐行渐远 的博客
09-03 1756
手写简单 rpc 框架 手写简单 rpc 框架 0 缘起 1 技术选型 2 框架思路 3 调用方式 3.1 定义服务 3.2 定义 bean 3.3 启动服务 3.4 服务调用 4 完整代码 5 参考 0 缘起 一直对 rpc 的实现原理很好奇， 看了下别人实现的 rpc 框架， 感觉实现太复杂了，本文参考了 黄勇实现的 轻量级 rpc 框架，专注 rpc 核心功...
手写RPC框架（文末附代码）
trigger的博客
02-14 2394
目录 RPC是什么？ 应用场景 RPC 优点 写RPC框架需要具备哪些知识？ RPC原理（摘自：什么情况下使用 RPC ？ - 知乎） Netty框架 具体代码 代码目录 api provider consumer proxy registry protocol 本地调用和远程调用 产生的对象有什么区别呢？ RPC的调用速度如何？ RPC是什么？ RPC是远程过程调用（Remote Procedure Call）的缩写形式。通俗的理解就是我调用了一个函数func(args
3. 手写RPC
hanzong110的博客
01-26 314
1 RPC功能简介 远程过程调用，可以让程序员像调用本地方法一样调用远程方法 本地只有接口Car、Fly，服务端有其实现类MyCar和MyFly，客户端通过动态代理生成该接口的代理类，这个代理类底层需要将相关信息通过IO传递到远程服务端，最终服务端调用MyCar和MyFly的方法，并将结果通过IO返回给客户端 2 协议作用 所谓使用哪种协议，就是指将数据以该协议要求的格式，发送出去，将要发送的内容包装成指定协议要求的格式，就叫网络封包 使用RPC协议传递数据，就好像小火车（协议Myheader）拉货（
手写RPC框架
hikktn的博客
03-23 242
RPC框架的实现过程 1.注册中心 a.本地注册，需要的参数是 接口名，ip和端口 b.开启ServerSocket 服务端，注册服务 c.开启线程，返回 服务注册信息 2.服务端 a.接口 实现类注册 b.开启服务端，等待客户端请求，返回结果 3.客户端 a.动态代理处理服务端请求 需要的参数是 接口名，方法名，方法参数列表，方法参数 b.结果返回 1.注册中心 a.本地注册，需要的参数是 接口名，ip和端口 ...
如何手写一个RPC？
最新发布
码农小郑有话说的博客
01-16 1468
在学习 RPC 框架之前，我们先来手写一个RPC。我们在学习的过程中，一定要做到知其然，还要知其所以然。
C++实现轻量级RPC分布式网络通信框架
m0_54850467的博客
07-30 1360
2022/4/14更新在我重新回顾这篇文章的时候，我觉得里面内容有点乱，主要还是因为RPC里面涉及到很多概念和知识点。本来代码内容就已经挺抽象了，还要结合各种概念，让人难以阅读，所以特地写了下面这一篇文章，梳理了RPC框架的基本原理和知识点，顺便拓展了一些RPC在实际应用中会遇到的问题。RPC框架基础篇链接地址本次项目用C++实现了一个简单的RPC分布式网络通信框架，因此写下本篇文章梳理一下该框架的实现逻辑和相关知识点。）。然后就能生成user.cc和user.h文件了。类给caller使用，...
简单手写一个rpc框架
03-10
手写一个RPC框架需要实现以下几个步骤： 1. 定义协议：定义客户端和服务端之间通信的协议，包括数据格式、编码方式、传输协议等。 2. 生成代码：根据协议生成客户端和服务端的代码，包括序列化和反序列化的代码、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值