Principio experimental
El núcleo de Spark es RDD. Todas las operaciones en RDD se ejecutarán en el clúster. El programa Driver inicia muchos trabajadores. Los trabajadores leen datos en el sistema de archivos (distribuido) y los convierten en RDD (conjunto de datos distribuidos elásticos), y luego en RDD. se almacenan en caché y se calculan en la memoria.
RDD tiene dos tipos de operaciones, a saber, Acción (devolver valores) y Transformaciones (devolver un nuevo RDD).
1. Visualización de datos y preparación previa
Un sitio web de comercio electrónico registra una gran cantidad de datos de colección de productos de los usuarios y almacena los datos en un archivo llamado comprador_favorito 1. El formato de los datos y el contenido de los datos son los siguientes. Antes de realizar operaciones posteriores, habilite los servicios Hadoop y Spark
. Puede usar el comando jps para verificar si el proceso está completamente habilitado.
2. Crea un proyecto Scala
1. Entorno de desarrollo: eclipse
Abra Eclipse con el complemento Scala instalado y cree un nuevo proyecto Scala llamado spark4.
Cree un nuevo nombre de paquete en el proyecto spark4 y asígnele el nombre my.scala. Nombre el objeto scala ScalaWordCount.
2. Importe el paquete jar necesario para la ejecución.
Haga clic derecho en el proyecto y cree una carpeta llamada lib.
Importe el paquete jar, haga clic con el botón derecho en el paquete jar y haga clic en Build Path=>Add to Build Path. (Puede ir a mis recursos para descargar spark1.x hadoop2.x)
3. Escriba una declaración de Scala y cuente la cantidad de elementos que cada usuario recopila en los datos de recopilación de usuarios.
package my.scala
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
object ScalaWordCount {
def main(args: Array[String]) {
//创建Spark的配置对象sparkConf，设置Spark程序运行时的配置信息；
val conf = new SparkConf()
conf.setMaster("local") .setAppName("scalawordcount")
//创建SparkContext对象，SparkContext是Spark程序所有功能的唯一入口，无论采用Scala、Java还是Python都必须有一个SparkContext；
val sc = new SparkContext(conf)
val rdd = sc.textFile("hdfs://localhost:9000/myspark/buyer_favorite1") //根据具体的数据来源，通过SparkContext来创建RDD；
//对初始的RDD进行Transformation级别的处理。（首先将每一行的字符串拆分成单个的单词，然后在单词拆分的基础上对每个单词实例计数为1；
//最后，在每个单词实例计数为1的基础上统计每个单词在文件出现的总次数）。
rdd.map(line => (line.split("\t")(0), 1))
.reduceByKey(_ + _)
.collect()
.foreach(println)
sc.stop()
}
}
Los resultados de salida se ven en la consola de la interfaz de control.
3. Crea un proyecto Java
Vuelva a hacer clic con el botón derecho en el nombre del proyecto, cree un nuevo paquete y asígnele el nombre my.java.
Haga clic derecho en el paquete my.java, cree una nueva clase y asígnele el nombre JavaWordCount.
1. Escriba código Java para contar la cantidad de elementos recopilados por cada usuario en los datos de recopilación de usuarios.
package my.java;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import scala.Tuple2;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
public final class JavaWordCount {
private static final Pattern SPACE = Pattern.compile("\t");
public static void main(String[] args) throws Exception {
SparkConf sparkConf = new SparkConf().setMaster("local").setAppName("JavaWordCount");
JavaSparkContext ctx = new JavaSparkContext(sparkConf);
JavaRDD<String> lines = ctx.textFile("hdfs://localhost:9000/myspark/buyer_favorite1");
JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
@Override
public Iterable<String> call(String s) {
String word[]=s.split("\t",2);
return Arrays.asList(word[0]);
}
});
JavaPairRDD<String, Integer> ones = words.mapToPair(new PairFunction<String, String, Integer>() {
@Override
public Tuple2<String, Integer> call(String s) {
return new Tuple2<String, Integer>(s, 1);
}
});
JavaPairRDD<String, Integer> counts = ones.reduceByKey(new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer i1, Integer i2) {
return i1 + i2;
}
});
List<Tuple2<String, Integer>> output = counts.collect();
System.out.println(counts.collect());
counts.saveAsTextFile("hdfs://localhost:9000/myspark/out");
ctx.stop();
}
}
2. Ver los resultados de salida en la terminal de Linux
Ejecute el siguiente comando para ver los resultados, siempre que se haya iniciado el clúster
hadoop fs -cat /myspark/out/part-00000
escribir al final
Se puede ver a partir de esto que la superioridad del lenguaje Scala al escribir programas Spark es breve y concisa.