最终效果
package cn.zxl.akka.server
import akka.actor._
import cn.zxl.akka.common.{ClientMessage, ServerMessage}
import com.typesafe.config.ConfigFactory
/**
* @description:
* @author: zhangxueliang
* @create: 2021-05-29 16:07
* @version: 1.0
* */
class YellowChickenServer extends Actor{
override def receive: Receive = {
case "start" => println("start 小黄鸡客服开始工作了....")
//如果接收到 ClientMessage
case ClientMessage(mes) => {
//使用 match --case 匹配(模糊)
mes match {
case "大数据学费" => sender() ! ServerMessage("35000RMB")
case "学校地址" => sender() ! ServerMessage("北京昌平 xx 路 xx 大楼")
case "学习什么技术" => sender() ! ServerMessage("大数据 前端 python")
case _ => sender() ! ServerMessage("你说的啥子~")
}
}
}
}
object YellowChickenServer extends App {
val host = "127.0.0.1" //服务端 ip 地址
val port = 9999
//创建 config 对象,指定协议类型，监听的 ip 和端口
val config = ConfigFactory.parseString(
s"""
|akka.actor.provider="akka.remote.RemoteActorRefProvider"
|akka.remote.netty.tcp.hostname=$host
|akka.remote.netty.tcp.port=$port
""".stripMargin)
//创建 ActorSystem
//url (统一资源定位)
val serverActorSystem =ActorSystem("Server",config)
//创建 YellowChickenServer 的 actor 和返回 actorRef
val yellowChickenServerRef: ActorRef =
serverActorSystem.actorOf(Props[YellowChickenServer],"YellowChickenServer")
//启动
yellowChickenServerRef ! "start"
}
package cn.zxl.akka.client
import akka.actor.{Actor, ActorRef, ActorSelection, ActorSystem, Props}
import cn.zxl.akka.common.{ClientMessage, ServerMessage}
import com.typesafe.config.ConfigFactory
import scala.io.StdIn
/**
* @description:
* @author: zhangxueliang
* @create: 2021-05-29 16:10
* @version: 1.0
* */
class CustomerActor(serverHost: String, serverPort: Int) extends Actor {
//定义一个 YellowChickenServerRef
var serverActorRef: ActorSelection = _
//在 Actor 中有一个方法 PreStart 方法，他会在 actor 运行前执行
//在 akka 的开发中，通常将初始化的工作，放在 preStart 方法
override def preStart(): Unit = {
println("preStart() 执行")
serverActorRef =
context.actorSelection(s"akka.tcp://Server@${serverHost}:${serverPort}/user/YellowChickenServer")
println("serverActorRef=" + serverActorRef)
}
override def receive: Receive = {
case "start" => println("start,客户端运行，可以咨询问题")
case mes: String => {
//发给小黄鸡客服
serverActorRef ! ClientMessage(mes) //使用 ClientMessage case class apply
}
//如果接收到服务器的回复
case ServerMessage(mes) => {
println(s"收到小黄鸡客服(Server): $mes")
}
}
}
//主程序-入口
object CustomerActor extends App {
val (clientHost, clientPort, serverHost, serverPort) = ("127.0.0.1", 9990, "127.0.0.1", 9999)
val config = ConfigFactory.parseString(
s"""
|akka.actor.provider="akka.remote.RemoteActorRefProvider"
|akka.remote.netty.tcp.hostname=$clientHost
|akka.remote.netty.tcp.port=$clientPort
""".stripMargin)
//创建 ActorSystem
val clientActorSystem = ActorSystem("client", config)
//创建 CustomerActor 的实例和引用
val customerActorRef: ActorRef = clientActorSystem.actorOf(Props(new CustomerActor(serverHost,
serverPort)), "CustomerActor")
//启动 customerRef/也可以理解启动 Actor
customerActorRef ! "start"
//客户端可以发送消息给服务器
while (true) {
println("请输入要咨询的问题")
val mes = StdIn.readLine()
customerActorRef ! mes
}
}
package cn.zxl.akka.common
/**
* @description:
* @author: zhangxueliang
* @create: 2021-05-29 16:14
* @version: 1.0
* */
//使用样例类来构建协议
//客户端发给服务器协议(序列化的对象)
case class ClientMessage(mes: String)
//服务端发给客户端的协议(样例类对象)
case class ServerMessage(mes: String)
<project xmlns="http:///POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http:///POM/4.0.0 http:///xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.zxl</groupId>
<artifactId>scala-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>scala-demo</name>
<url>http://</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<encoding>UTF-8</encoding>
<scala.version>2.11.12</scala.version>
<scala.compat.version>2.11</scala.compat.version>
<akka.version>2.5.12</akka.version>
<scala.actors.version>2.10.0-M6</scala.actors.version>
</properties>
<dependencies>
<!--scala 2.11起过时 无法使用-->
<!--<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-actors</artifactId>
<version>${scala.actors.version}</version>
</dependency>-->
<!--akka actor依赖-->
<dependency>
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-actor_${scala.compat.version}</artifactId>
<version>${akka.version}</version>
</dependency>
<!--多进程之间的Actor通信-->
<dependency>
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-remote_${scala.compat.version}</artifactId>
<version>${akka.version}</version>
</dependency>
</dependencies>
<build>
<!--指定源码包和测试包的位置-->
<sourceDirectory>src/main/scala</sourceDirectory>
<testSourceDirectory>src/test/scala</testSourceDirectory>
<plugins>
<!-- 该插件用于将 Scala 代码编译成 class 文件 -->
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<version>3.2.2</version>
<executions>
<execution>
<!-- 声明绑定到 maven 的 compile 阶段 -->
<goals>
<goal>compile</goal>
<goal>testCompile</goal>
</goals>
<configuration>
<args>
<arg>-dependencyfile</arg>
<arg>${project.build.directory}/.scala_depencencies</arg>
</args>
</configuration>
</execution>
</executions>
</plugin>
<!--maven打包的插件-->
<!-- maven-assembly-plugin 和 maven-shade-plugin都是打包插件。遇到同名文件assembly是覆盖，shade是追加。所以此处选择shade插件-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.1</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<filters>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
<transformers>
<transformer
implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
<resource>reference.conf</resource>
</transformer>
<!--指定main方法-->
<transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>xxx</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
