模仿分布计算

学习spark的时候
先学的做了一个小实例
用来模仿分布计算
项目结构
就是5个文件

创建一个数据结构

package bigdata.sparkCore.sparkTest01

/**
 * 数据结构
 */
class dataStructure extends Serializable {
  //数据
  val datas=List(1,2,3,4)
  //计算逻辑
  val logic:(Int) =>Int=_*2
}

创建一个任务

package bigdata.sparkCore.sparkTest01

/**
 * 任务
 */
class task extends Serializable {
  var datas:List[Int]=_
  var logic:(Int) =>Int=_

  def compute() : List[Int]={
      datas.map(logic)
  }
}

创建服务器1

package bigdata.sparkCore.sparkTest01

import java.io.ObjectInputStream
import java.net.ServerSocket

/**
 * 相当于服务器1
 */
object Executor1 {
  def main(args: Array[String]): Unit = {
    //启动一个端口是9999的服务
    val server =new ServerSocket(9999)
    println("服务器启动，等待接收数据")
    //等待客户端连接
    val client = server.accept()
    //对象输入流
    val in = client.getInputStream
    val objIn = new ObjectInputStream(in)
    val task = objIn.readObject().asInstanceOf[task]
    val ints = task.compute()
    println("9999计算节点计算的结果是："+ints)
    objIn.close()
    client.close()
    server.close()
  }
}

创建服务器2

package bigdata.sparkCore.sparkTest01

import java.io.ObjectInputStream
import java.net.ServerSocket
/**
 * 相当于服务器2
 */
object Executor2 {
  def main(args: Array[String]): Unit = {
    //启动一个端口是8888的服务
    val server =new ServerSocket(8888)
    println("服务器启动，等待接收数据")
    //等待客户端连接
    val client = server.accept()
    //对象输入流
    val in = client.getInputStream
    val objIn = new ObjectInputStream(in)
    val task = objIn.readObject().asInstanceOf[task]
    val ints = task.compute()
    println("8888计算节点计算的结果是："+ints)
    objIn.close()
    client.close()
    server.close()
  }
}

创建客户端

package bigdata.sparkCore.sparkTest01

import java.io.ObjectOutputStream
import java.net.Socket

/**
 * 相当于客户端
 */
object Driver {
  def main(args: Array[String]): Unit = {
    //连接我们的服务器9999和8888
    val client1=new Socket("localhost",9999)
    val client2=new Socket("localhost",8888)

    val dataStructures =new dataStructure()

    //给服务器发送对象输出流
    val out1 = client1.getOutputStream
    val objOut1=new ObjectOutputStream(out1)

    val task1 =new task();
    task1.logic=dataStructures.logic
    task1.datas=dataStructures.datas.take(2)

    objOut1.writeObject(task1)
    objOut1.flush()
    objOut1.close()
    client1.close()



    val out2 = client2.getOutputStream
    val objOut2=new ObjectOutputStream(out2)

    val task2 =new task();
    task2.logic=dataStructures.logic
    task2.datas=dataStructures.datas.takeRight(2)

    objOut2.writeObject(task2)
    objOut2.flush()
    objOut2.close()
    objOut2.close()


    println("客户端数据发送完毕")


  }
}

先启动服务器1，服务器2,
然后启动客户端
执行结果
客户端：

服务器1：

服务器2：