使用java.rmi实现一个简易的RPC框架

最新推荐文章于 2024-04-20 18:10:57 发布
最新推荐文章于 2024-04-20 18:10:57 发布
阅读量139 收藏
点赞数
文章标签： java python 前端 ViewUI
原文链接：https://my.oschina.net/yuyizyk/blog/1919726
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

闲来无事，记录下前端时间使用java.rmi实现项目RPC框架过程中遇上的坑。

首先记录Java-RMI的用法。很是简单： #####server 与 client 均实现java.rmi.Remote接口：

public interface ClusterService extends java.rmi.Remote {
	String reply() throws RemoteException;
}

server: #####实现ClusterService:

public class TestAction  extends UnicastRemoteObject implements ClusterService{
   private static transient final long serialVersionUID = 0L;
   public CacheAction() throws RemoteException    {super();}
   public String reply() throws RemoteException{
       return "test";
   }
}

注册服务： #####绑定RMI端口

java.rmi.registry.LocateRegistry.createRegistry(9999)
//注册服务
new javax.naming.InitialContext().rebind("rmi://127.0.0.1:9999/index", new TestAction());

客户端使用:

((ClusterService)(new InitialContext().lookup("rmi://127.0.0.1:9999/index"))).reply();
//reply :: test

客户端首先是将RMI服务绑定到端口9999上。然后客户端在根据serverIP:serverport/bindName 进行调用服务。

DEMO没问题，那么接下来就可以开始准备组网了。

##1. ClusterRegistrar 该类主要是完成服务器RMI功能的注册，并将实现了ClusterService接口及注解RegistredService的类注册到RMI注册表中。

改进:

  1. 动态获取服务器指定所在网关的局域网IP和绑定端口
  2. 动态获取当前项目内需要注册的服务.
/**
 * [@author](https://my.oschina.net/arthor) yuyi
 */
public class ClusterRegistrar {
    protected final static Logger log = LoggerFactory.getLogger(ClusterRegistrar.class);
    private static final Map<ClusterService, EventTag> map = new HashMap<>();
    public static String gateway = "0.0.0.0";
    public static Integer masklength = 0;
    private boolean registry(Context namingContext, String url, ClusterService serivce, String name) {
        try {
            log.info("registred action [{}]", url = url + name);
            namingContext.rebind(url, serivce);
        } catch (NamingException e) {
            log.error(e.getMessage(), e);
            return false;
        }
        return true;
    }
    public static void main(String[] args) {
        register();
    }
    private static int registry_count = 0;
    public void _registry() {
        Random r = new Random();
        r.setSeed(System.currentTimeMillis());
        int port = 0;
        do {
            port = r.nextInt(0xFFFF);
        } while (!NetUtils.isUsableLocalPort(port));
        String ip = NetUtils.getLocalhost(gateway, masklength);
        String url = "rmi://" + ip + ":" + port + "/";
        log.info("registring rpc[rmi] server :[{}] ", url);
        try {
            LocateRegistry.createRegistry(port);
            Context namingContext = new InitialContext();
            ClassLoaderUtil.scanning(ClusterRegistrar.class.getPackage().getName(), clz -> {
                if (ClusterService.class.isAssignableFrom(clz) && (clz.getModifiers() & Modifier.ABSTRACT) == 0) {
                    RegistredService registredService = clz.getAnnotation(RegistredService.class);
                    if (registredService == null || registredService.value() == null) {
                        return;
                    }
                    try {
                        if ((clz.getConstructor(new Class<?>[] {}).getModifiers() & Modifier.PUBLIC) != 0) {
                            // public 无参构造函数
                            ClusterService service = (ClusterService) clz.newInstance();
                            registry(namingContext, url, service, registredService.value().name());
                            map.put(service, registredService.value());
                        }
                    } catch (InstantiationException | IllegalAccessException | NoSuchMethodException
                            | SecurityException e) {
                        log.error(e.getMessage(), e);
                        return;
                    }
                }
            });
            RPCServer.server.init(url, map);
            log.info("Successfully register  remote object.");
        } catch (Exception e) {
            log.error(e.getMessage());
            if (registry_count++ > 3) {
                log.error(e.getMessage(), e);
                log.error("error register  remote object.");
                return;
            }
            _registry();
        }
    }
    public static void register() {
        ClusterRegistrar clusterRegistrar = new ClusterRegistrar();
        ThreadRuningtUtil.runTask(clusterRegistrar::_registry);
    }
}
public static String getLocalhost(String gateway, int mask) {
    InetAddress candidateAddress = null;
    NetworkInterface iface;
    InetAddress inetAddr;
    try {
        for (Enumeration<NetworkInterface> ifaces = NetworkInterface.getNetworkInterfaces(); ifaces
                .hasMoreElements();) {
            iface = ifaces.nextElement();
            for (Enumeration<InetAddress> inetAddrs = iface.getInetAddresses(); inetAddrs.hasMoreElements();) {
                inetAddr = inetAddrs.nextElement();
                if (false == inetAddr.isLoopbackAddress()) {
                    if (inetAddr.isSiteLocalAddress()) {
                        if (checkSameSegment(gateway, mask, inetAddr.getHostAddress()))
                            return inetAddr.getHostAddress();
                    } else if (null == candidateAddress) {
                        // 非site-local地址做为候选地址返回
                        candidateAddress = inetAddr;
                    }
                }
            }
        }
    } catch (SocketException e) {
        // ignore socket exception, and return null;
    }
    if (null == candidateAddress) {
        try {
            candidateAddress = InetAddress.getLocalHost();
        } catch (UnknownHostException e) {
            // ignore
        }
    }
    if ((candidateAddress instanceof Inet4Address)
            && checkSameSegment(gateway, mask, candidateAddress.getHostAddress()))
        return candidateAddress.getHostAddress();
    throw new IllegalArgumentException(" 没有对应网段的IP  ");
}
/**
 * 根据网关和子网掩码长度判断是否在同一网络
 * 
 * [@param](https://my.oschina.net/u/2303379) gateway
 *            网关地址
 * [@param](https://my.oschina.net/u/2303379) mask
 * [@param](https://my.oschina.net/u/2303379) ip
 * [@return](https://my.oschina.net/u/556800)
 */
public static boolean checkSameSegment(String gateway, int mask, String ip) {
    assert isIp(gateway) && (mask <= 32 && mask >= 0) && isIp(ip);
    String gateway_val = ip2BinStr(gateway);
    String ip_val = ip2BinStr(ip);
    return ip_val.startsWith(gateway_val.substring(0, mask));
}
/**
 * 转化为二进制字符串
 * @param ip
 * @return
 */
public static String ip2BinStr(String ip) {
    String[] arr = ip.split("\\.");
    String rs = "";
    for (String str : arr) {
        String s = Integer.toBinaryString(Integer.parseInt(str));
        if (s.length() < 8) {
            int diff = 8 - s.length();
            for (int i = 0; i < diff; i++) {
                s = "0" + s;
            }
        }
        rs += s;
    }
    return rs;
}
    public static boolean isIp(String val) {
    Pattern p = Pattern.compile(
            "^(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)\\.(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)\\.(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)\\.(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)$");
    Matcher m = p.matcher(val);
    return m.matches();
}
/**
 * 检测本地端口可用性
 * 
 * @param port
 *            被检测的端口
 * @return 是否可用
 */
public static boolean isUsableLocalPort(int port) {
    if (false == isValidPort(port)) {
        // 给定的IP未在指定端口范围中
        return false;
    }
    try {
        new Socket(LOCAL_IP, port).close();
        // socket链接正常，说明这个端口正在使用
        return false;
    } catch (Exception e) {
        return true;
    }
}

##2. ClusterService

/**
 * 事件标签
 * @author yuyi
 */
public enum EventTag {
    /** cache 同步 */
    SynchronizeCache(CacheAction.class),
    /** 注册服务器 */
    RegisterServer(RemoteServerRegisteredAction.class),
    private Class<? extends ClusterService> clz;
    private EventTag(Class<? extends ClusterService> clz) {
        this.clz = clz;
    }
    public Class<? extends ClusterService> getClz() {
        return clz;
    }
    public static EventTag valueOf(Class<? extends ClusterService> clz) {
        for (EventTag e : EventTag.values()) {
            if (e.getClz().equals(clz))
                return e;
            }
        return null;
    }
    public void setClz(Class<? extends ClusterService> clz) {
        this.clz = clz;
    }
}
/**
 * 注册服务
 * @author yuyi
 */
@Documented
@Retention(RUNTIME)
@Target(TYPE)
public @interface RegistredService {
    EventTag value();
}

##3. RegistredService

/**
 * 事件标签
 * [@author](https://my.oschina.net/arthor) yuyi
 */
public enum EventTag {
	/** cache 同步 */
	SynchronizeCache(CacheAction.class),
	/** 注册服务器 */
	RegisterServer(RemoteServerRegisteredAction.class),
	private Class<? extends ClusterService> clz;
	private EventTag(Class<? extends ClusterService> clz) {
		this.clz = clz;
	}
	public Class<? extends ClusterService> getClz() {
		return clz;
	}
	public static EventTag valueOf(Class<? extends ClusterService> clz) {
		for (EventTag e : EventTag.values()) {
			if (e.getClz().equals(clz))
				return e;
			}
		return null;
	}
	public void setClz(Class<? extends ClusterService> clz) {
		this.clz = clz;
	}
}
/**
 * 注册服务
 * [@author](https://my.oschina.net/arthor) yuyi
 */
@Documented
@Retention(RUNTIME)
@Target(TYPE)
public @interface RegistredService {
	EventTag value();
}

##4. RPCServer

public class RPCServer {
    public static final RPCServer server = new RPCServer();
    private Server current_server = new Server(NetUtils.getLocalMacAddress(), null);
    public Map<String, Boolean> localTasks = new SimpleCache<>();
    public void init(String host, Map<ClusterService, EventTag> map) {
        current_server.setHost(host);
        refresh();
        ThreadRuningtUtil.runTask(() -> RemoteServerRegisteredAction.register(current_server, map));
    }
    public String getCurrentMac() {
        return current_server.getMac();
    }
    public String getCurrentHost() {
        return current_server.getHost();
    }
    public static class Server {
        private String mac;
        private String host;
        public Server(String mac2, String host2) {
            setHost(host2);
            setMac(mac2);
        }
        public String getMac() {
            return mac;
        }
        public void setMac(String mac) {
            this.mac = mac;
        }
        public String getHost() {
            return host;
        }
        public void setHost(String host) {
            this.host = host;
        }
    }
}

##5. AbstractRPCService

public abstract class AbstractRPCService extends UnicastRemoteObject implements ClusterService {
    private static final long serialVersionUID = 1L;
    protected final static Logger log = LoggerFactory.getLogger(AbstractRPCService.class);
    private static final String neterror = "ClusterService_NET_ERROR";
    public AbstractRPCService() throws RemoteException {
        super();
    }
    protected String[] getApplyServices() {
        return getApplyServices(this.getClass());
    }
    protected static String[] getApplyServices(Class<? extends ClusterService> cls) {
        EventTag e = getAttentionEvent(cls);
        Assert.anyIllegalArgument(" class[" + cls + "]  not define attention event !", e == null);
        return JedisClient.task(j -> {
            // 获得所有远程服务器信息
            Map<String, Object> map = j.getMap(Server.class.getName());
            return j.getArr(e.name()).stream().filter(tj -> {
                if (map.containsKey(tj)) {
                    if (!map.get(tj).equals(RPCServer.server.getCurrentMac()))
                        return true;
                    return false;
                }
                JedisClient.run(a -> {
                    log.info("删除不存在Server中的异常请求[{}].", tj);
                    a.lrem(e.name(), (Serializable) tj);
                });
                return false;
            }).map(m -> map.get(m).toString() + e.name()).toArray(String[]::new);
        });
    }
    /**
     * 
     * @param ask
     */
    protected static void applyAction(Class<? extends ClusterService> cls, AskModel ask) {
        String[] urls = getApplyServices(cls);
        for (String url : urls) {
            remoteCall(url, ask);
        }
    }
    /**
     * 
     * @param ask
     */
    protected void applyAction(AskModel ask) {
        String[] urls = getApplyServices();
        for (String url : urls) {
            remoteCall(url, ask);
        }
    }
    /**
     * 远程调用
     * 
     * @param remoteUrl
     * @return
     */
    protected static Object remoteCall(String remoteUrl, AskModel ask) {
        return remoteCall(remoteUrl, a -> a.reply(ask), true);
    }
    /**
     * 远程调用
     * 
     * @param remoteUrl
     * @return
     */
    protected static <T> T remoteCall(String remoteUrl, Function<ClusterService, T> action, boolean isRecursive) {
        try {
            Context namingContext = new InitialContext();
            ClusterService r = (ClusterService) namingContext.lookup(remoteUrl);
            return action.apply(r);
        } catch (Exception e) {
            log.error("error url [{}]", remoteUrl);
            log.error(e.getMessage(), e);
            JedisClient.run(a -> {
                Integer i = a.hget(neterror, remoteUrl, Integer.class);
                if (i != null && 3 >= i) {
                    Map<String, Object> macs = a.getMap(Server.class.getName());
                    macs.forEach((k, v) -> {
                        if (remoteUrl.startsWith((String) v)) {
                            log.info("异常请求已超出3次，关闭该请求[{}].-删除key[{}]value[{}]", remoteUrl,
                                    remoteUrl.substring(remoteUrl.lastIndexOf("/") + 1), k);
                            a.lrem(remoteUrl.substring(remoteUrl.lastIndexOf("/") + 1), k);
                            a.hdel(neterror, remoteUrl);
                        }
                    });
                    return;
                } else
                    a.hset(neterror, remoteUrl, i == null ? 1 : i + 1);
            });
            try {
                return action.apply(new NetErrorImp());
            } catch (Exception e1) {
                log.error(e1.getMessage(), e1);
                throw new RuntimeException(e1);
            }
            // throw new RuntimeException(e);
        }
    }
    public static EventTag getAttentionEvent(Class<? extends ClusterService> clz) {
        return EventTag.valueOf(clz);
    }
    static interface Function<T, R> {
        public R apply(T t) throws Exception;
    }
}

示例:

/**
 * cache 操作器
 * @author yuyi
 */
@RegistredService(EventTag.SynchronizeCache)
public class CacheAction extends AbstractRPCService {
    protected final static Logger log = LoggerFactory.getLogger(CacheAction.class);
    private static transient final long serialVersionUID = -2929269581432562044L;
    private static final SessionEngine session = SessionEngine.getInstance();
    public CacheAction() throws RemoteException {
        super();
    }
    /**
     * 发起一个远程 删除请求
     * 
     * @param key
     */
    public static void deleteRemoteServerCahche(String key) {
        ThreadRuningtUtil.runTask(() -> {
            CacheAsk ask = new CacheAsk();
            ask.setAskId(UUID.randomUUID().toString());
        // 暂停广播
            // ask.setIps(RPCServer.server.getRemoteServers());
            ask.setCacheKey(key);
            RPCServer.server.localTasks.put(ask.getAskId(), true);
            applyAction(CacheAction.class, ask);
            JedisClient.task(jedisClient -> {
                if (jedisClient.exists(key)) {
                    return jedisClient.del(key);
                }
                return null;
            });
        });
    }
    @Override
    public Object reply(AskModel ask) throws RemoteException {
        synchronized (CacheAction.class) {
            if (!(ask instanceof CacheAsk)) {
                throw new RemoteException(" ask type not`s CacheAsk ");
            }
            if (RPCServer.server.localTasks.containsKey(ask.getAskId())) {
                return "OK,but is old news";
            }
            RPCServer.server.localTasks.put(ask.getAskId(), true);
            CacheAsk cacheAsk = (CacheAsk) ask;
            if (!delete(cacheAsk.getCacheKey())) {
                throw new RemoteException("删除过程中发生错误");
            }
            return "OK";
        }
    }
    /**
     * 删除cache
     * 
     * @param key
     * @return
     */
    private static boolean delete(String key) {
        session.remove(key, true);
        return true;
    }
    /**
     * Cache 请求实例
     * @author yuyi
     */
    public static class CacheAsk extends AskModel {
        private static final long serialVersionUID = 1L;
        private String cacheKey;
        public String getCacheKey() {
            return cacheKey;
        }
        public void setCacheKey(String cacheKey) {
            this.cacheKey = cacheKey;
        }
    }
}

转载于:https://my.oschina.net/yuyizyk/blog/1919726

weixin_33686714
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现简单的RPC框架
01-27
RPC，全称为RemoteProcedureCall，即远程过程调用，它是一个计算机通信协议。它允许像调用本地服务一样调用远程服务。它可以有不同的实现方式。如RMI(远程方法调用)、Hessian、Http invoker等。另外，RPC是与语言...
经典Java RPC框架细讲Dubbo
weixin_62421895的博客
07-25 1395
即开发者无论是调用本地的还是远程的函数，本质上编写的调用代码基本上都是相同的。当服务越来越多，服务资源得不到合理的利用逐渐呈现出来（例如有的服务调用频率特别大，有的服务调用频率又特别小，此时应该协调出调用频率小的服务器资源给调用频率高的服务），此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。就是无法在一个进程内，甚至一个计算机内通过本地调用的方式完成的需求，比如不同的系统间的通讯，甚至不同的组织间的通讯，由于计算能力需要横向扩展，需要在多台机器组成的集群上部署应用。...
Java实现简单RPC框架，Springboot + javaSocket实现简易的RPC框架
秃了也弱了
06-01 1690
RPC框架通常有基于http方式的（OpenFeign），还有tcp方式的（dubbo），我们今天就尝试使用Java的Socket自己封装一个RPC框架。客户端与服务器端之间的信息传输，就是使用该类进行传输// 类名 private String methodName;// 方法名 private Object [ ] args;// 方法参数 private Class [ ] types;// 返回值类型 // ...get set }
浅谈java网络编程及RPC框架
tang_seven的博客
04-19 966
简单总结java网络编程相关知识点，包括基于TCP协议和基于UDP协议的网络编程，同时简单总结基于TCP协议下的RPC框架的相关知识点
使用Java实现简单RPC框架
weixin_42605397的博客
02-12 503
实现简单的RPC框架需要遵循以下步骤： 定义接口：首先需要定义一个接口，其中包含所有可远程调用的方法。 服务端实现：服务端需要实现定义的接口，并通过服务端的程序来向客户端提供远程访问的服务。 客户端实现：客户端需要消息代理，用于将请求发送到服务端并接收服务端的响应。 网络通信：需要在服务端和客户端之间进行网络通信，以传递请求和响应。 Java提供了很多用于网络通信的工具，例如Java ...
Java中几种常用的RPC框架介绍
程序员小乐
11-07 9065
点击上方 "程序员小乐"关注,星标或置顶一起成长后台回复“大礼包”有惊喜礼包！关注订阅号「程序员小乐」，收看更多精彩内容每日英文Crouch down, hold y...
技术选型分享：JAVA中几种常用的RPC框架介绍.docx
09-04
Java中的RPC框架比较多，各有特色，广泛使用的有RMI、Hessian、Dubbo等。RPC还有一个特点就是能够跨语言，本资源只以JAVA语言里的RPC为例。其他的框架结构也类似，区别在于对象的序列化方法，传输对象的通讯协议，...
werpc:一个简单的rpc框架
05-07
RPC框架就是指封装好了参数编组、消息解组、底层网络通信的RPC程序开发框架，可以在这个框架的基础上只需专注与业务代码的编写。 常见rpc实现: RMI,Remote method invocation,远程方法调用是oop领域中rpc的一种具体...
【白雪红叶】JAVA学习技术栈梳理思维导图.xmind
04-25
框架实现 log4j logback commong logging jdk logger 测试框架 测试框架 junit easymock testng mockito bug管理 禅道 jira 开发工具 编程工具 eclipse myeclipse idea vi VS webstorm ...
RMI原理及实现
03-20
NULL 博文链接：https://269181927.iteye.com/blog/815956
Java与分布式架构：微服务和RPC框架的应用和设计思路
baidu_38876334的博客
06-01 778
在分布式架构中，系统的不同组件分布在多台机器上，通过网络进行通信和协同工作。分布式架构能够提供高可用性、可扩展性和容错性等优势。Java语言作为一种广泛应用于企业级系统开发的编程语言，具备丰富的生态系统和强大的跨平台特性，成为构建分布式架构的首选语言。
核心项目：MyRPC——基于Java语言实现的RPC框架
燕双嘤
09-05 7936
RPC：Remote Procedure Call，即远程过程调用。远程过程调用是一种像调用本地过程一样调用远程机器上的过程，而不需要了解网络细节的远程过程访问支持机制。 由于基于套接字的开发方式，因此带来了开发繁琐和排错困难的问题。
Java：分布式RPC框架Apache Dubbo
Litt_White的博客
03-18 898
Apache Dubbo是一款高性能的Java RPC框架。什么是RPC？RPC全称为remote procedure call，即远程过程调用。比如两台服务器A和B，A服务器上部署一个应用，B服务器上部署一个应用，A服务器上的应用想调用B服务器上的应用提供的方法由于两个应用不在一个内存空间，不能直接调用，所以需要通过网络来表达调用的语义和传达调用的数据。Dubbo提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。
第01篇:手写JavaRPC框架之思路分析
西魏陶渊明的博客
07-21 1484
如果不是因为热爱，我不会这样；如果不是为了，涨点粉丝，我不会这样；如果不是为了几两散碎银子，我更不会这样。以前的文章开场太过严肃，太过专业。就像大学老师上课，只知道讲课。不知道互动。这样效果太差，写的没意思，读者更是没意思。大数据分析还以为你是抄的，还不给你推荐热门😭。不然就改变一下风格吧，从本系列文章开始，小编就要放飞✈️自我，随心❤️而动。希望在分享，总结自己掌握的知识点的同时，能给各位客官带来一点小小的收获。小编尽量全力输出干货，如果看完感觉还行的话，希望能多多关注。......
万字总结！技术水平真的很重要_万字总结rpc框架(1)，2024年最新字节跳动面试app
最新发布
2401_84166103的博客
04-20 860
生成 client stub和server stub需要用到 Java 动态代理技术 ，我们可以使用JDK原生的动态代理机制，可以使用一些开源字节码工具框架 如：CgLib、Javassist等。可以使用Java原生的序列化机制，但是效率非常低，推荐使用一些开源的、成熟的序列化技术，例如：protobuf、Thrift、hessian、Kryo、Msgpack。为了让大家能够在Redis上能够加深，所以这次给大家准备了一些Redis的学习资料，还有一些大厂的面试题，包括以下这些面试题。
JAVA中几种常用的RPC框架介绍
gc1329689056的博客
11-22 1255
1. RPC是什么 RPC（Remote Procedure Call Protocol）——远程过程调用协议。 2. 为什么要用RPC 当我们的系统访问量增大、业务增多时，我们会发现一台单机运行此系统已经无法承受。微服务和分布式系统架构应运而生。 3.Java中的RPC框架 1）Dubbo（淘宝开源的基于TCP的RPC,Netty框架） 2）RMI（远程方法调用） 在Java...
java框架_Java 中几种常用的 RPC 框架介绍
weixin_39552538的博客
11-14 104
1、RMI(远程方法调用)服务实现RMI客户端RMI服务端2、Hessian(基于HTTP的远程方法调用)3、Dubbo(淘宝开源的基于TCP的RPC框架)RPC是远程过程调用的简称，广泛应用在大规模分布式应用中，作用是有助于系统的垂直拆分，使系统更易拓展。Java中的RPC框架比较多，各有特色，广泛使用的有RMI、Hessian、Dubbo等。RPC还有一个特点就是能够跨语言，本文只以JAVA语...
【分布式技术专题】「分布式技术架构」实践见真知，手把手教你如何实现一个属于自己的RPC框架（架构技术引导篇）
BASK2312的博客
07-02 1229
RPC（Remote Procedure Call，远程过程调用）是一种计算机通信协议，它允许一个程序调用另一个程序所在的远程计算机上的子程序（或函数）而不需要自己的代码去处理远程调用的细节。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值