Akka 学习（四）Remote Actor

已于 2022-12-12 16:13:52 修改
阅读量3.3k 收藏 3
点赞数 1
分类专栏： # Akka 文章标签： 学习 java scala 大数据 Akka
于 2022-12-07 13:57:14 首次发布
小林
本文链接：https://blog.csdn.net/weixin_44451022/article/details/128219098
版权

目录


参考文章

文章系列

Akka 基础篇就此结束了，Akka基础篇主要介绍Akka的基本概念与一些基本术语，使用方式
代码：https://github.com/Eason-shu/Akka

一 介绍

1.1 Remote Actor

虽然Akka在单机上可以运行上百万的Actor，但出于容错、负载均衡、灰度发布、提高并行度等等原因，我们仍然需要能在多个不同的服务器上运行Actor。所以Akka提供了akka-remoting的扩展包，屏蔽底层网络传输的细节，让上层以及其简单的方式使用远程的Actor调度。
Akka Remoting 是一个以点对点方式连接 actor 系统的通信模块，它是 Akka 集群的基础。远程处理的设计由两个（相关的）设计决策驱动：

  1. 相关系统之间的通信是对称的：如果系统 A 可以连接到系统 B，那么系统 B 也必须能够独立连接到系统 A。
  2. 通信系统的角色在连接模式方面是对称的：没有只接受连接的系统，也没有只发起连接的系统。

这些决定的结果是不可能安全地创建具有预定义角色的纯客户端-服务器设置（违反假设 2）。对于客户端-服务器设置，最好使用 HTTP 或 Akka I/O。
重要提示：使用涉及网络地址转换、负载平衡器或 Docker 容器的设置违反了假设 1，除非在网络配置中采取额外步骤以允许相关系统之间的对称通信。在这种情况下，Akka 可以配置为绑定到与用于在 Akka 节点之间建立连接的地址不同的网络地址。请参阅NAT 后面或 Docker 容器中的 Akka。

1.2 适用场景

  • remoting的存在其实是为akka cluster做底层支持的，通常并不会直接去使用remoting的包。但为了了解cluster的底层原理，还是有必要看下remoting。
  • 同时，remoting被设计为Peer-to-Peer而非Client-Server，所以不适用于基于后者的系统开发，比如我们无法在一个provider为local的Actor里去查找一个remote actor发送消息，必须两者均为remote actor，才满足对等。

1.3 踩坑点

  • Akka版本需要与Scala版本匹配

maven仓库地址：
image.png
注意版本匹配，不然会疯狂报错，运行不起来
我的版本：
scala：2.13.0
Akka版本：2.13

  • 依赖
<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.hc</groupId>
  <artifactId>ActorDemo03</artifactId>
  <version>0.0.1-SNAPSHOT</version>

  <name>ActorDemo03</name>
  <description>Demo project for Spring Boot</description>

  <properties>
    <java.version>1.8</java.version>
    <scala.version>2.11.7</scala.version>
  </properties>



  <dependencies>

    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>


    <!-- https://mvnrepository.com/artifact/com.typesafe.akka/akka-actor -->
    <dependency>
      <groupId>com.typesafe.akka</groupId>
      <artifactId>akka-actor_2.13</artifactId>
      <version>2.5.23</version>
    </dependency>


    <dependency>
      <groupId>com.typesafe.akka</groupId>
      <artifactId>akka-remote_2.13</artifactId>
      <version>2.5.23</version>
    </dependency>

    <dependency>
      <groupId>com.typesafe.akka</groupId>
      <artifactId>akka-testkit_2.13</artifactId>
      <version>2.5.23</version>
    </dependency>

    <dependency>
      <groupId>org.scala-lang.modules</groupId>
      <artifactId>scala-java8-compat_2.11</artifactId>
      <version>1.0.2</version>
    </dependency>







    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.testng</groupId>
      <artifactId>testng</artifactId>
      <version>RELEASE</version>
      <scope>compile</scope>
    </dependency>


  </dependencies>



  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>8</source>
          <target>8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>



</project>

二 实战

2.1 需求

epub_22651331_22.jpg

  • 我们还将创建一个数据库客户端，用于展示如何请求服务器，以及如何从远程Actor中获取Future。
  • 服务器端的服务接收到客户端的请求后将返回Future。
  • 这样我们就已经编写了一个可以使用的键值存储数据库（和redis很类似）以及一个可以使用该数据库的远程客户端。

2.2 Java 版本

2.2.1 效果图

  • 服务端启动前

image.png

  • 客服端启动

image.png

  • 服务端收到请求后

image.png

2.2.2 实体类

  • SetRequest
package pojo;

import java.io.Serializable;

/**
 * @description: 设置消息
 * @author: shu
 * @createDate: 2022/11/28 11:51
 * @version: 1.0
 */
public class SetRequest implements Serializable {
    public final String key;
    public final Object value;
    public SetRequest(String key, Object value) {
        this.key = key;
        this.value = value;
    }

}
  • GetRequest
package pojo;

import java.io.Serializable;

/**
 * @description: 获取消息
 * @author: shu
 * @createDate: 2022/11/28 11:52
 * @version: 1.0
 */
public class GetRequest implements Serializable {
    public final String key;
    public GetRequest(String key) {
        this.key = key;
    }
}
  • 错误消息
package pojo;

import java.io.Serializable;

/**
 * @description:
 * @author: shu
 * @createDate: 2022/11/28 11:52
 * @version: 1.0
 */
public class KeyNotFoundException extends Exception implements
        Serializable {
    public final String key;
    public KeyNotFoundException(String key) {
        this.key = key;
    }
}

2.2.3 服务端Actor 处理


import akka.actor.*;
import akka.event.Logging;
import akka.event.LoggingAdapter;
import akka.japi.pf.ReceiveBuilder;
import pojo.GetRequest;
import pojo.KeyNotFoundException;
import pojo.SetRequest;

import java.util.HashMap;
import java.util.Map;

/**
 * @description:
 * @author: shu
 * @createDate: 2022/11/28 12:31
 * @version: 1.0
 */
public class RequestActor extends AbstractActor {

    LoggingAdapter log = Logging.getLogger(getContext().system(), this);


    protected final Map<String, Object> map = new HashMap<>();

    @Override
    public void preStart() throws Exception {
        log.info("ToFindRemoteActor is starting");
    }

    @Override
    public Receive createReceive() {
        return  ReceiveBuilder.create()
                // 设置消息
                .match(SetRequest.class, message -> {
                    // 打印消息
                    log.info("Received Set request: {}", message.key);
                    // 缓存消息
                    map.put(message.key, message.value);
                    // 回应消息
                    sender().tell(new Status.Success(message.key), self());
                })
                // 得到消息
                .match(GetRequest.class, message -> {
                    // 打印日志
                    log.info("Received Get request: {}", message.key);
                    // 获取消息
                    Object value = (Object) map.get(message.key);
                    Object response = (value!= null)
                            ? value
                            : new Status.Failure(new KeyNotFoundException(message.key));
                    // 响应消息
                    sender().tell(response, self());
                })
                // 未找到消息
                .matchAny(o ->
                        sender().tell(new Status.Failure(new ClassNotFoundException()), self())
                )
                .build();

    }


    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {

//        Config config = ConfigFactory.parseString(
//                        "akka.remote.netty.tcp.port=" + 2551)
//                .withFallback(ConfigFactory.load("application.conf"));

        // Create an Akka system
        ActorSystem system = ActorSystem.create("akkademy");

        // Create an actor
        ActorRef ref = system.actorOf(Props.create(RequestActor.class), "akkademy-db");

        System.out.println(ref);

    }



}

2.2.4 服务端配置文件

image.png

akka {
  stdout-loglevel = "DEBUG"
  loglevel = "DEBUG"
  actor {
  provider = "akka.remote.RemoteActorRefProvider"
}
remote {
  enabled-transports = ["akka.remote.netty.tcp"]
  netty.tcp {
  hostname = "127.0.0.1"
}
}
log-sent-messages = on
log-received-messages = on
}

2.2.5 客服端Actor处理

package client;



import akka.actor.ActorRef;
import akka.actor.ActorSelection;
import akka.actor.ActorSystem;
import akka.pattern.AskableActorSelection;
import akka.util.Timeout;
import pojo.GetRequest;
import pojo.SetRequest;

import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;

import static scala.compat.java8.FutureConverters.toJava;


/**
* @description:
* @author: shu
* @createDate: 2022/11/28 16:10
* @version: 1.0
*/
public class JClient {
    private final ActorSystem system = ActorSystem.create("LocalSystem");
    private final ActorSelection remoteDb;

    public JClient(String remoteAddress) {
        remoteDb = system.actorSelection("akka.tcp://akkademy@" +
                                         remoteAddress + "/user/akkademy-db");
    }

    /**
* 缓存消息
* @param key
* @param value
* @return
*/
    public CompletionStage set(String key, Object value) {
        return toJava(new AskableActorSelection(remoteDb).ask(new SetRequest(key, value), Timeout.apply(5000, TimeUnit.SECONDS)));
    }

    /**
* 获取缓存消息
* @param key
* @return
*/
    public CompletionStage get(String key){
        return   toJava(new AskableActorSelection(remoteDb).ask(new GetRequest(key), Timeout.apply(5000, TimeUnit.SECONDS)));
    }

}

import akka.actor.ActorRef;
import akka.actor.ActorSelection;
import akka.actor.ActorSystem;
import client.JClient;
import org.junit.Test;
import pojo.SetRequest;

import java.util.concurrent.CompletableFuture;
public class AkkademyDbTest {

    /**
     * 测试注意需要放在不同的两个项目进行测试，不然会Caused by: java.net.BindException: Address already in use: bind
     * @throws Exception
     */
    @Test
    public void itShouldSetRecord() throws Exception {
            JClient client = new JClient("127.0.0.1:2552");
                client.set("123", 123);
                Integer result = (Integer) ((CompletableFuture) client.
                        get("123")).get();
                System.out.println("获取的结果："+result);
                assert(result == 123);

        }


}

2.2.6 客服端配置文件

akka {
  stdout-loglevel = "DEBUG"
  loglevel = "DEBUG"
  actor {
  provider = "akka.remote.RemoteActorRefProvider"
}
remote {
  enabled-transports = ["akka.remote.netty.tcp"]
  netty.tcp {
  hostname = "127.0.0.1"
  port = 0
}
log-sent-messages = on
log-received-messages = on
}
}

2.2.7 测试

注意：需要放在两个不一样的配置项目中

  1. 服务端项目启动，等待请求的到来，注意配置文件
  2. 客服端项目启动，发送AKKA请求给服务端
  3. 服务端收到客服端的请求，缓存请求数据，把缓存结果返回给客服端

2.3 Scala 版本

2.3.1 效果

  • 启动服务前

image.png

  • 客户端启动

image.png

  • 服务端收到请求

image.png

2.2.3 服务端Actor处理

import akka.actor.{Actor, Status}
import akka.event.{Logging, LoggingAdapter}

import scala.collection.convert.ImplicitConversions.`map AsJavaMap`
import scala.collection.mutable

/**
 * @description:
 * @author: shu
 * @createDate: 2022/11/28 12:41
 * @version: 1.0
 */
class ScalaRequest extends Actor {
  protected val log: LoggingAdapter = Logging.getLogger(context.system, this)
   val map: mutable.Map[String, Object] = new mutable.HashMap[String, Object]

  override def receive = {

    case SetRequest(key, value) =>
      log.info("received SetRequest - key: {} value: {}", key, value)
      map.put(key, value)
      sender() ! Status.Success

    case GetRequest(key) =>
      log.info("received GetRequest - key: {}", key)
      val response: Option[Object] = map.get(key)

      response match{
        case Some(x) => sender() ! x
        case None => sender() ! Status.Failure(new KeyNotFoundException(key))
      }

    case o => Status.Failure(new ClassNotFoundException)
  }

}


case class SetRequest(key: String, value: Object)
case class GetRequest(key: String)
case class KeyNotFoundException(key: String) extends Exception

配置文件跟Java一样

2.3.4 客户端Actor处理

import akka.actor.ActorSystem
import akka.pattern.ask
import akka.util.Timeout

import scala.concurrent.duration.DurationInt
import scala.language.postfixOps

/**
 * @description:
 * @author: shu
 * @createDate: 2022/12/1 11:43
 * @version: 1.0
 */
class SClient(remoteAddress: String) {
  private implicit val timeout = Timeout(2 seconds)
  private implicit val system = ActorSystem("LocalSystem")
  private val remoteDb = system.actorSelection(
    s"akka.tcp://akkademy@$remoteAddress/user/akkademy-db")
  def set(key: String, value: Object) = {
    remoteDb ? SetRequest(key, value)
  }
  def get(key: String) = {
    remoteDb ? GetRequest(key)
  }
}



case class SetRequest(key: String, value: Object)
case class GetRequest(key: String)
case class KeyNotFoundException(key: String) extends Exception

import scala.concurrent.duration.DurationInt
import scala.concurrent.Await
import scala.language.postfixOps

/**
 * @description:
 * @author: shu
 * @createDate: 2022/12/1 11:44
 * @version: 1.0
 */

object Main extends App {
  val client = new SClient("127.0.0.1:2552")
  client.set("123", new Integer(123))
  val futureResult = client.get("123")
  val result = Await.result(futureResult, 10  seconds)

}

2.3.5 测试

注意：需要放在两个不一样的配置项目中

  1. 服务端项目启动，等待请求的到来，注意配置文件
  2. 客服端项目启动，发送AKKA请求给服务端
  3. 服务端收到客服端的请求，缓存请求数据，把缓存结果返回给客服端
长安不及十里
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Akka Actor模型开发库-其他
06-12
Akka是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用。 Actor模型并非什么新鲜事物，它由Carl Hewitt于上世纪70年代早期提出，目的是为了解决分布式编程中一系列的编程问题。其特点如下： 1、系统中的所有事物都可以扮演一个Actor； 2、Actor之间完全独立； 3、在收到消息时Actor所采取的所有动作都是并行的，在一个方法中的动作没有明确的顺序； 4、Actor由标识和当前行为描述； 5、Actor可能被分成原始（primitive）和非原始（non primitive）类别； 6、非原始Actor有： 由一个邮件地址表示的标； 当前行为由一组知识（acquaintances）（实例变量或本地状态）和定义Actor在收到消息时将采取的动作组成； 7、消息传递是非阻塞和异步的，其机制是邮件队列（mail-queue）； 8、所有消息发送都是并行的。
akka-actor_2.12 jar包
11-22
akka-actor_2.12 jar包
Scala第二十章节(Akka并发编程框架、Akka入门案例、Akka定时任务代码实现、两个进程间通信的案例以及简易版spark通信框架案例)
最新发布
m0_56525833的博客
04-04 1436
1. 理解Akka并发编程框架简介 2. 掌握Akka入门案例 3. 掌握Akka定时任务代码实现 4. 掌握两个进程间通信的案例 5. 掌握简易版spark通信框架案例
akka-actor_2.11 jar包
11-22
akka-actor_2.11 jar包
akka-actor-2.11-2.5.19-API文档-中文版.zip
06-20
赠送jar包：akka-actor_2.11-2.5.19.jar； 赠送原API文档：akka-actor_2.11-2.5.19-javadoc.jar； 赠送源代码：akka-actor_2.11-2.5.19-sources.jar； 赠送Maven依赖信息文件：akka-actor_2.11-2.5.19.pom； 包含翻译后的API文档：akka-actor_2.11-2.5.19-javadoc-API文档-中文(简体)版.zip； Maven坐标：com.typesafe.akka:akka-actor_2.11:2.5.19； 标签：typesafe、akka、actor、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
akka-actor_2.11-2.5.23.jar
05-26
spark，akka，actor工具类，版本2.11；akka.actor override def receive: Receive = { case mess: Message => { if (mess.message.equals("")) { println(mess.message) } } }
Akka系列（九）：Akka分布式之Akka Remote
weixin_33980459的博客
08-19 250
Akka作为一个天生用于构建分布式应用的工具，当然提供了用于分布式组件即Akka Remote，那么我们就来看看如何用Akka Remote以及Akka Serialization来构建分布式应用。 背景 很多同学在程序的开发中都会遇到一个问题，当业务需求变得越来越复杂，单机服务器已经不足以承载相应的请求的时候，我们都会考虑将服务部署到不...
akka介绍之-akka-remote介绍
码农的世界你不懂
02-20 4073
akka-remote介绍   既然akka是构建分布式高并发的计算和运行框架，当然要离不开远程通信，akka的remote模块就是专门支持分布式的远程调用。 说到分布式应用，大家肯定想到以下几个耳熟能详的技术实现 RPC（Remote Procedure Call Protocol） Web Service RMI （Remote Method Invocation） JMS（Ja...
在Java8中使用Akka
wcuu的博客
04-20 757
提示：首先，让我们了解一些概念。在Akka中，actor是最基本的执行单位，它是一种轻量级的进程，具有独立的状态和行为。每个actor都有一个地址，可以通过该地址与其他actor进行通信。消息是与actor之间传递的唯一方式，每个actor都有一个邮箱，用于接收消息。每个actor都有自己的线程，可以并发地执行代码。最后，让我们总结一下。在本文中，我们介绍了如何在Java8中使用Akka，并提供了示例代码帮助您更好地理解。通过Akka，我们可以轻松地构建分布式、高可用、高可伸缩性的应用程序。
IDEA + Maven + Akka开发环境配置
sinat_18897273的博客
03-28 3904
IDEA + Maven + Akka开发环境配置说明Step1：新建一个Scala的项目；Step2：填写项目名称，并选择scala的版本；Step3：在项目名称下新建模块： "右键->New->Module->Scala"，填写模块名称和Scala版本；Step4：添加模块支持，模块“右键->Add Framework Support->选择Maven”,此时在模...
Scala(20) -- Scala的Akka（并发编程框架）
erainm
09-22 771
1. Akka并发编程框架简介 1.1 Akka概述 Akka是一个用于构建高并发、分布式和可扩展的基于事件驱动的应用工具包。Akka是使用scala开发的库，同时可 以使用scala和Java语言来开发基于Akka的应用程序。 1.2 Akka特性 提供基于异步非阻塞、高性能的事件驱动编程模型 内置容错机制，允许 Actor在出错时进行恢复或者重置操作 超级轻量级的事件处理（每 GB堆内存几百万Actor） 使用 Akka可以在单机上构建高并发程序，也可以在网络中构建分布式程序。 1.3 Akka通信
01_akka入门(java版)
zhuchuangang的专栏
08-04 7404
文档版本:2.4.9 RC1 1.环境akka需要java8以上版本.2.入门指导和模板项目学习akka最好的途径是下载 Lightbend Activator 并实验一个akka模板项目.3.模块akka非常的模块化,是由包含不同特性的jar文件组成. akka-actor – Classic Actors, Typed Actors, IO Actor etc. akka-agent – Age
Akka源码分析-Remote-发消息
weixin_30652491的博客
07-27 349
　　上一篇博客我们介绍了remote模式下Actor的创建，其实与local的创建并没有太大区别，一般情况下还是使用LocalActorRef创建了Actor。那么发消息是否意味着也是相同的呢？ 　　既然actorOf还是委托给了LocalActorRef，那么在本地创建的Actor发消息还是跟以前一样的，那么如果如何给远程的Actor发消息呢？我们一般是通过actorSelection或者给远...
使用Akka创建集群
zsj777的专栏
04-19 403
1、一直有一个想法，想做一个IM集群，最近有个思路 通过nacos注册中心实现IM集群节点的服务注册和服务发现，然后用Akka做集群之间的各节点通讯，通过服务注册和服务发现，实现Akka集群种子节点的加入。 2、Akka集群概念 节点（node）：集群中的逻辑成员。允许一台物理机上有多个节点。由元组hostname:port:uid唯一确定。 集群（cluster）：由成员关系服务构建的一组节点。 领导（leader）：集群中唯一扮演领导角色的节点。 种子节点（seed node）：作为其他节点加入
akka 2.5.16远程访问Actor
jialijuan521_zhang的博客
09-16 576
           今天搞了一下远程访问actor,顺便写个笔记记录一下过程。 废话少说，直接干代码：      建立服务端       第一步：构建项目结构。使用maven管理jar包（说实话，maven实在是太好使了，爱不释手），简单粗暴一点直接从akka官网自动生成一个基于java的maven项目，里面有完整的项目结构。其中build.sbt，sbt,sbt.bat, build....
Remote Actor
u013571243的专栏
06-19 590
 Akka的设计目标就是为分布式准备的，因此所有Actor之间的交互都是通过消息，且所有动作都是异步的。这种做法就是为了确保Akka的所有功能无论是在单独的JVM，还是包含了成百上千机器的Cluster，都是可用的。 然而，本地与分布式总是存在区别，主要牵涉到两点： 消息需要支持序列号；消息传递的可靠性问题； 为了保证本地处理与分布式处理的透明化，Akka几乎没有特别为Re
Akka源码分析-Remote-位置透明
weixin_30617695的博客
07-31 529
　　上一篇博客中，我们研究了remote模式下如何发消息给远程actor，其实无论如何，最终都是通过RemoteActorRef来发送消息的。另外官网也明确说明了，ActorRef是可以忽略网络位置的，这其实有两点含义：1.ActorRef可以序列化后跨网络传输；2.ActorRef反序列化后在本地可以正常识别是本地还是远程。那么实现位置透明就有两个关键点：1.ActorRef的序列化过程；2.A...
使用Akka的远程调用
热门推荐
beliefer的博客
01-06 1万+
概述 正如其它RPC或者RMI框架那样，Akka也提供了远程调用的能力。服务端在监听的端口上接收客户端的调用。本文将在《Spring与Akka的集成》一文的基础上介绍Akka的remote调用，本文很多代码和例子来源于Akka官网的代码示例，也包含了一些适用于Spring集成的改造，本文旨在介绍Akka的远程调用的开发过程。 服务端开发 配置 Akka的默认配置文件为application...
E:\developTool\maven\maven\mavenA\com\typesafe\akka\akka-remote_2.12\2.7.0\akka-remote_2.12-2.7.0.pom.part.lock (系统找不到指定的路径。)
09-02
看起来你遇到了一个找不到路径的问题。根据你提供的信息，这是一个关于maven依赖项的错误。该错误信息表明系统无法找到指定路径中的文件。可能有几个原因导致这个问题，我将提供一些可能的解决方案： 1. 确保你的路径是正确的：检查你的路径是否正确拼写并且存在于你的文件系统中。你可以使用文件资源管理器手动导航到该路径，以确认文件是否存在。 2. 检查你的maven配置：请确保您的maven配置文件（例如`settings.xml`）中没有错误，并且已正确配置Maven存储库。可以尝试清除maven本地存储库（通常位于用户主目录下的`.m2`文件夹），并重新运行maven命令。 3. 检查你的网络连接：如果你使用远程存储库来下载依赖项，那么可能是网络连接或代理设置的问题。请确保你的网络连接正常，并且没有任何防火墙或代理服务器阻止了maven访问远程存储库。 4. 检查你的依赖项配置：如果你在项目的`pom.xml`文件中定义了该依赖项，并且路径是正确的，那么可能是由于其他依赖项的问题导致的。尝试排除其他依赖项，逐个进行测试，以确定是否与其他依赖项有冲突。 希望这些解决方案能够帮助你解决问题！如果你需要更多的帮助，请提供更多详细信息，以便我能够更准确地理解你的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

长安不及十里

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值