scala用Akka实现一对一聊天功能

最新推荐文章于 2024-07-11 14:13:01 发布

狂拽酷炫棒棒棒

最新推荐文章于 2024-07-11 14:13:01 发布

阅读量362

点赞数 3

分类专栏： scala 文章标签： scala 并发编程

本文链接：https://blog.csdn.net/weixin_42382121/article/details/109381532

版权

scala 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

scala用Akka实现一对一聊天功能

- 1.基础知识
- 2.代码说明

1.基础知识

最近在学习scala，学习到Akka,这是一个scala用来编写并发程序的框架，可以轻松的写出并发程序而不用过多考虑线程，锁，资源竞争等细节。
在这里插入图片描述

Akka处理并发的方法基于Actor模型
actor与actor之间通信，是通过向对方的mailBox发送消息来实现的。消息的发送，转发，路由，接收处理是由框架给我们完成的，只需要简单的代码就可以实现功能

2.代码说明

本来是可以直接写一个简单的1对1聊天，只需要写2个客户端，相互持有对方实例的引用就可以相互往mailBox发消息；我这次是加入了一个服务端，实现：发送者->服务端转发->接s收者，这样的通讯过程。好处是发送者不需要知道接收者的具体位置，只管往服务端发消息，消息中带上接受者的名字，由服务端来解析，匹配接收者的ip地址。

定义一个消息样例

package com.zhoucx.akka.yellowChicken.common
//简单客户端消息
case class ClientMessage(mes: String)

case class ServerMessage(mes: String)

case class ClientToClientMessage(mes: String, senderName:String, receiverName:String)

case class ServerForwardClientMessage(mes: String, senderName:String, receiverName:String)

服务端代码：


import akka.actor.{Actor, ActorRef, ActorSelection, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import com.zhoucx.akka.yellowChicken.common.{ClientMessage, ClientToClientMessage, ServerForwardClientMessage, ServerMessage}
//继承actor，重写receive方法，剩下的消息发送和接收大多数都是框架完成
class Server extends Actor {

  var clientARef: ActorSelection = _
  var clientBRef: ActorSelection = _

  override def preStart(): Unit = {
  	//初始化拥有的客户端，找到客户端地址，拿到引用。 Demo这里是写死的，线上环境会动态处理吧
    println("preStart ...")
    //注意：akka.tcp://client@127.0.0.1:8888/user/ACustomerActor这个路径中的client和ACustomerActor，
    //一定要写在定义A客户端时取的名字
    clientARef = context.actorSelection(s"akka.tcp://client@127.0.0.1:8888/user/ACustomerActor")
    println("clientARef = " + clientARef)

    clientBRef = context.actorSelection(s"akka.tcp://client@127.0.0.1:7777/user/BCustomerActor")
    println("clientBRef = " + clientBRef)
  }

  override def receive: Receive = {
    case "start" => println("中转站启动了!")
    case ClientToClientMessage(mes, senderName, receiverName) => {
      printf("将消息'%s'转到%s \n",mes,receiverName)
      receiverName match {
        case "A" => clientARef ! ServerForwardClientMessage(mes, senderName, receiverName)
        case "B" => clientBRef ! ServerForwardClientMessage(mes, senderName, receiverName)
        case _ => println("不知道发谁？？")
      }
    }
  }
}
//启动类
object Server extends App {

  val host = "127.0.0.1"
  val port = "9999" //服务端口
  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
  val serverSystem = ActorSystem("serverSystem", config)
  val serverRef: ActorRef = serverSystem.actorOf(Props[Server], "server")
  //启动
  serverRef ! "start"
}

A客户端


import akka.actor.{Actor, ActorRef, ActorSelection, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import com.zhoucx.akka.yellowChicken.common.{ClientMessage, ClientToClientMessage, ServerForwardClientMessage, ServerMessage}

import scala.io.StdIn

class ACustomerActor(serverHost: String, serverPort: Int) extends Actor {

  var serverActorRef: ActorSelection = _

  //在actor中有个preStart,初始化方法
  override def preStart(): Unit = {
    println("preStart ...")
    //注意：akka.tcp://serverSystem@${serverHost}:${serverPort}/user/serve，中serverSystem和serve
    //就是服务端代码中定义ActorSystem和ActorRef时写的的name：
    //val serverSystem = ActorSystem("serverSystem", config)
    //val serverRef: ActorRef = serverSystem.actorOf(Props[Server], "server")
    serverActorRef = context.actorSelection(s"akka.tcp://serverSystem@${serverHost}:${serverPort}/user/server")
    println("serverActorRef = " + serverActorRef)
  }

//重写receive，case匹配处理不同消息
  override def receive: Receive = {
    case "start" => println("客户上线了")
    case mes:String => {
      serverActorRef ! ClientMessage(mes)
    }
    case ClientToClientMessage(mes,senderName,receiverName)=> {
      serverActorRef ! ClientToClientMessage(mes,senderName,receiverName)
    }
    case ServerForwardClientMessage(mes: String, senderName:String, receiverName:String) => {
      printf("收到用户%s消息：%s \n",senderName,mes)

    }
  }
}

object ACustomerActor extends App {
  val (host, port, serverHost, serverPort) = ("127.0.0.1", 8888, "127.0.0.1", 9999)
  val config = ConfigFactory.parseString(
    s"""
       |akka.actor.provider="akka.remote.RemoteActorRefProvider"
       |akka.remote.netty.tcp.hostname=$host
       |akka.remote.netty.tcp.port=$port
       |""".stripMargin)

  val clientActorSystem = ActorSystem("client", config)
  val customerActorRef: ActorRef = clientActorSystem.actorOf(Props(new ACustomerActor(serverHost, serverPort)), "ACustomerActor")

  //启动customerActorRef
  customerActorRef ! "start"


  while (true){
    customerActorRef ! ClientToClientMessage(StdIn.readLine(),"A","B")
  }
}

B客户端代码：与A客户端代码类似，注意更换了端口


import akka.actor.{Actor, ActorRef, ActorSelection, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import com.zhoucx.akka.yellowChicken.common.{ClientMessage, ClientToClientMessage, ServerForwardClientMessage, ServerMessage}

import scala.io.StdIn

class BCustomerActor(serverHost: String, serverPort: Int) extends Actor {

  var serverActorRef: ActorSelection = _

  //在actor中有个preStart,初始化方法


  override def preStart(): Unit = {
    println("preStart ...")
    serverActorRef = context.actorSelection(s"akka.tcp://serverSystem@${serverHost}:${serverPort}/user/server")
    println("serverActorRef = " + serverActorRef)
  }

  override def receive: Receive = {
    case "start" => println("客户上线了")
    case mes:String => {
      serverActorRef ! ClientMessage(mes)
    }
    case ClientToClientMessage(mes,senderName,receiverName) => {
      serverActorRef ! ClientToClientMessage(mes,senderName,receiverName)
    }
    case ServerForwardClientMessage(mes: String, senderName:String, receiverName:String) => {
      printf("收到用户%s消息：%s \n",senderName,mes)
    }
  }
}

object BCustomerActor extends App {
  val (host, port, serverHost, serverPort) = ("127.0.0.1", 7777, "127.0.0.1", 9999)
  val config = ConfigFactory.parseString(
    s"""
       |akka.actor.provider="akka.remote.RemoteActorRefProvider"
       |akka.remote.netty.tcp.hostname=$host
       |akka.remote.netty.tcp.port=$port
       |""".stripMargin)

  val clientActorSystem = ActorSystem("client", config)
  val customerActorRef: ActorRef = clientActorSystem.actorOf(Props(new BCustomerActor(serverHost, serverPort)), "BCustomerActor")

  //启动
  customerActorRef ! "start"


  while (true){
    customerActorRef ! ClientToClientMessage(StdIn.readLine(),"B","A")
  }
}

maven：

 <!-- 定义一下常量 -->
    <properties>
        <encoding>UTF-8</encoding>
        <scala.version>2.11.8</scala.version>
        <scala.compat.version>2.11</scala.compat.version>
        <akka.version>2.4.17</akka.version>
    </properties>

    <dependencies>
        <!-- 添加scala的依赖 -->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.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的插件 -->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                        <configuration>
                            <args>
                                <arg>-dependencyfile</arg>
                                <arg>${project.build.directory}/.scala_dependencies</arg>
                            </args>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- maven打包的插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.4.3</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>

展示结果：先启动服务端，再启动两个客户端。
A给B发,B收到后，回复A。效果:
在这里插入图片描述
这是服务端的转发效果：

以上。
觉得还不错，麻烦给个赞

狂拽酷炫棒棒棒

关注

3
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
scala用Akka实现一对一聊天功能

scala用Akka实现一对一聊天功能1.基础知识2.代码说明1.基础知识最近在学习scala，学习到Akka,这是一个scala用来编写并发程序的框架，可以轻松的写出并发程序而不用过多考虑线程，锁，资源竞争等细节。Akka处理并发的方法基于Actor模型actor与actor之间通信，是通过向对方的mailBox发送消息来实现的。消息的发送，转发，路由，接收处理是由框架给我们完成的，只需要简单的代码就可以实现功能2.代码说明本来是可以直接写一个简单的1对1聊天，只需要写2个客户端，相互持
复制链接

扫一扫